| gt_python_bindings_generator_pyopencv_generated_types_content_h |  | python_bindings_generator_pyopencv_generated_types_content_h
--- | --- | --- | ---
f | 1 | //================================================================================ | f | 1 | //================================================================================
| 2 | // AKAZE (Generic) |  | 2 | // AKAZE (Generic)
| 3 | //================================================================================ |  | 3 | //================================================================================
| 4 |  |  | 4 |
| 5 | // GetSet (AKAZE) |  | 5 | // GetSet (AKAZE)
| 6 |  |  | 6 |
| 7 |  |  | 7 |
| 8 |  |  | 8 |
| 9 | // Methods (AKAZE) |  | 9 | // Methods (AKAZE)
| 10 |  |  | 10 |
| 11 | static PyObject* pyopencv_cv_AKAZE_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11 | static PyObject* pyopencv_cv_AKAZE_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 12 | { |  | 12 | {
| 13 | using namespace cv; |  | 13 | using namespace cv;
| 14 |  |  | 14 |
| 15 | PyObject* pyobj_descriptor_type = NULL; |  | 15 | PyObject* pyobj_descriptor_type = NULL;
| 16 | AKAZE_DescriptorType descriptor_type=AKAZE::DESCRIPTOR_MLDB; |  | 16 | AKAZE_DescriptorType descriptor_type=AKAZE::DESCRIPTOR_MLDB;
| 17 | PyObject* pyobj_descriptor_size = NULL; |  | 17 | PyObject* pyobj_descriptor_size = NULL;
| 18 | int descriptor_size=0; |  | 18 | int descriptor_size=0;
| 19 | PyObject* pyobj_descriptor_channels = NULL; |  | 19 | PyObject* pyobj_descriptor_channels = NULL;
| 20 | int descriptor_channels=3; |  | 20 | int descriptor_channels=3;
| 21 | PyObject* pyobj_threshold = NULL; |  | 21 | PyObject* pyobj_threshold = NULL;
| 22 | float threshold=0.001f; |  | 22 | float threshold=0.001f;
| 23 | PyObject* pyobj_nOctaves = NULL; |  | 23 | PyObject* pyobj_nOctaves = NULL;
| 24 | int nOctaves=4; |  | 24 | int nOctaves=4;
| 25 | PyObject* pyobj_nOctaveLayers = NULL; |  | 25 | PyObject* pyobj_nOctaveLayers = NULL;
| 26 | int nOctaveLayers=4; |  | 26 | int nOctaveLayers=4;
| 27 | PyObject* pyobj_diffusivity = NULL; |  | 27 | PyObject* pyobj_diffusivity = NULL;
| 28 | KAZE_DiffusivityType diffusivity=KAZE::DIFF_PM_G2; |  | 28 | KAZE_DiffusivityType diffusivity=KAZE::DIFF_PM_G2;
| 29 | PyObject* pyobj_max_points = NULL; |  | 29 | PyObject* pyobj_max_points = NULL;
| 30 | int max_points=-1; |  | 30 | int max_points=-1;
| 31 | Ptr<AKAZE> retval; |  | 31 | Ptr<AKAZE> retval;
| 32 |  |  | 32 |
| 33 | const char* keywords[] = { "descriptor_type", "descriptor_size", "descriptor_channels", "threshold", "nOctaves", "nOctaveLayers", "diffusivity", "max_points", NULL }; |  | 33 | const char* keywords[] = { "descriptor_type", "descriptor_size", "descriptor_channels", "threshold", "nOctaves", "nOctaveLayers", "diffusivity", "max_points", NULL };
| 34 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:AKAZE.create", (char**)keywords, &pyobj_descriptor_type, &pyobj_descriptor_size, &pyobj_descriptor_channels, &pyobj_threshold, &pyobj_nOctaves, &pyobj_nOctaveLayers, &pyobj_diffusivity, &pyobj_max_points) && |  | 34 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:AKAZE.create", (char**)keywords, &pyobj_descriptor_type, &pyobj_descriptor_size, &pyobj_descriptor_channels, &pyobj_threshold, &pyobj_nOctaves, &pyobj_nOctaveLayers, &pyobj_diffusivity, &pyobj_max_points) &&
| 35 | pyopencv_to_safe(pyobj_descriptor_type, descriptor_type, ArgInfo("descriptor_type", 0)) && |  | 35 | pyopencv_to_safe(pyobj_descriptor_type, descriptor_type, ArgInfo("descriptor_type", 0)) &&
| 36 | pyopencv_to_safe(pyobj_descriptor_size, descriptor_size, ArgInfo("descriptor_size", 0)) && |  | 36 | pyopencv_to_safe(pyobj_descriptor_size, descriptor_size, ArgInfo("descriptor_size", 0)) &&
| 37 | pyopencv_to_safe(pyobj_descriptor_channels, descriptor_channels, ArgInfo("descriptor_channels", 0)) && |  | 37 | pyopencv_to_safe(pyobj_descriptor_channels, descriptor_channels, ArgInfo("descriptor_channels", 0)) &&
| 38 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) && |  | 38 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) &&
| 39 | pyopencv_to_safe(pyobj_nOctaves, nOctaves, ArgInfo("nOctaves", 0)) && |  | 39 | pyopencv_to_safe(pyobj_nOctaves, nOctaves, ArgInfo("nOctaves", 0)) &&
| 40 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) && |  | 40 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) &&
| 41 | pyopencv_to_safe(pyobj_diffusivity, diffusivity, ArgInfo("diffusivity", 0)) && |  | 41 | pyopencv_to_safe(pyobj_diffusivity, diffusivity, ArgInfo("diffusivity", 0)) &&
| 42 | pyopencv_to_safe(pyobj_max_points, max_points, ArgInfo("max_points", 0)) ) |  | 42 | pyopencv_to_safe(pyobj_max_points, max_points, ArgInfo("max_points", 0)) )
| 43 | { |  | 43 | {
| 44 | ERRWRAP2(retval = cv::AKAZE::create(descriptor_type, descriptor_size, descriptor_channels, threshold, nOctaves, nOctaveLayers, diffusivity, max_points)); |  | 44 | ERRWRAP2(retval = cv::AKAZE::create(descriptor_type, descriptor_size, descriptor_channels, threshold, nOctaves, nOctaveLayers, diffusivity, max_points));
| 45 | return pyopencv_from(retval); |  | 45 | return pyopencv_from(retval);
| 46 | } |  | 46 | }
| 47 |  |  | 47 |
| 48 | return NULL; |  | 48 | return NULL;
| 49 | } |  | 49 | }
| 50 |  |  | 50 |
| 51 | static PyObject* pyopencv_cv_AKAZE_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51 | static PyObject* pyopencv_cv_AKAZE_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 52 | { |  | 52 | {
| 53 | using namespace cv; |  | 53 | using namespace cv;
| 54 |  |  | 54 |
| 55 |  |  | 55 |
| 56 | Ptr<cv::AKAZE> * self1 = 0; |  | 56 | Ptr<cv::AKAZE> * self1 = 0;
| 57 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 57 | if (!pyopencv_AKAZE_getp(self, self1))
| 58 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 58 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 59 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 59 | Ptr<cv::AKAZE> _self_ = *(self1);
| 60 | String retval; |  | 60 | String retval;
| 61 |  |  | 61 |
| 62 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 63 | { |  | 63 | {
| 64 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 64 | ERRWRAP2(retval = _self_->getDefaultName());
| 65 | return pyopencv_from(retval); |  | 65 | return pyopencv_from(retval);
| 66 | } |  | 66 | }
| 67 |  |  | 67 |
| 68 | return NULL; |  | 68 | return NULL;
| 69 | } |  | 69 | }
| 70 |  |  | 70 |
| 71 | static PyObject* pyopencv_cv_AKAZE_getDescriptorChannels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71 | static PyObject* pyopencv_cv_AKAZE_getDescriptorChannels(PyObject* self, PyObject* py_args, PyObject* kw)
| 72 | { |  | 72 | {
| 73 | using namespace cv; |  | 73 | using namespace cv;
| 74 |  |  | 74 |
| 75 |  |  | 75 |
| 76 | Ptr<cv::AKAZE> * self1 = 0; |  | 76 | Ptr<cv::AKAZE> * self1 = 0;
| 77 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 77 | if (!pyopencv_AKAZE_getp(self, self1))
| 78 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 78 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 79 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 79 | Ptr<cv::AKAZE> _self_ = *(self1);
| 80 | int retval; |  | 80 | int retval;
| 81 |  |  | 81 |
| 82 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 83 | { |  | 83 | {
| 84 | ERRWRAP2(retval = _self_->getDescriptorChannels()); |  | 84 | ERRWRAP2(retval = _self_->getDescriptorChannels());
| 85 | return pyopencv_from(retval); |  | 85 | return pyopencv_from(retval);
| 86 | } |  | 86 | }
| 87 |  |  | 87 |
| 88 | return NULL; |  | 88 | return NULL;
| 89 | } |  | 89 | }
| 90 |  |  | 90 |
| 91 | static PyObject* pyopencv_cv_AKAZE_getDescriptorSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91 | static PyObject* pyopencv_cv_AKAZE_getDescriptorSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 92 | { |  | 92 | {
| 93 | using namespace cv; |  | 93 | using namespace cv;
| 94 |  |  | 94 |
| 95 |  |  | 95 |
| 96 | Ptr<cv::AKAZE> * self1 = 0; |  | 96 | Ptr<cv::AKAZE> * self1 = 0;
| 97 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 97 | if (!pyopencv_AKAZE_getp(self, self1))
| 98 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 98 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 99 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 99 | Ptr<cv::AKAZE> _self_ = *(self1);
| 100 | int retval; |  | 100 | int retval;
| 101 |  |  | 101 |
| 102 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 102 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 103 | { |  | 103 | {
| 104 | ERRWRAP2(retval = _self_->getDescriptorSize()); |  | 104 | ERRWRAP2(retval = _self_->getDescriptorSize());
| 105 | return pyopencv_from(retval); |  | 105 | return pyopencv_from(retval);
| 106 | } |  | 106 | }
| 107 |  |  | 107 |
| 108 | return NULL; |  | 108 | return NULL;
| 109 | } |  | 109 | }
| 110 |  |  | 110 |
| 111 | static PyObject* pyopencv_cv_AKAZE_getDescriptorType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 111 | static PyObject* pyopencv_cv_AKAZE_getDescriptorType(PyObject* self, PyObject* py_args, PyObject* kw)
| 112 | { |  | 112 | {
| 113 | using namespace cv; |  | 113 | using namespace cv;
| 114 |  |  | 114 |
| 115 |  |  | 115 |
| 116 | Ptr<cv::AKAZE> * self1 = 0; |  | 116 | Ptr<cv::AKAZE> * self1 = 0;
| 117 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 117 | if (!pyopencv_AKAZE_getp(self, self1))
| 118 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 118 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 119 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 119 | Ptr<cv::AKAZE> _self_ = *(self1);
| 120 | AKAZE::DescriptorType retval; |  | 120 | AKAZE::DescriptorType retval;
| 121 |  |  | 121 |
| 122 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 122 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 123 | { |  | 123 | {
| 124 | ERRWRAP2(retval = _self_->getDescriptorType()); |  | 124 | ERRWRAP2(retval = _self_->getDescriptorType());
| 125 | return pyopencv_from(retval); |  | 125 | return pyopencv_from(retval);
| 126 | } |  | 126 | }
| 127 |  |  | 127 |
| 128 | return NULL; |  | 128 | return NULL;
| 129 | } |  | 129 | }
| 130 |  |  | 130 |
| 131 | static PyObject* pyopencv_cv_AKAZE_getDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 131 | static PyObject* pyopencv_cv_AKAZE_getDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw)
| 132 | { |  | 132 | {
| 133 | using namespace cv; |  | 133 | using namespace cv;
| 134 |  |  | 134 |
| 135 |  |  | 135 |
| 136 | Ptr<cv::AKAZE> * self1 = 0; |  | 136 | Ptr<cv::AKAZE> * self1 = 0;
| 137 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 137 | if (!pyopencv_AKAZE_getp(self, self1))
| 138 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 138 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 139 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 139 | Ptr<cv::AKAZE> _self_ = *(self1);
| 140 | KAZE::DiffusivityType retval; |  | 140 | KAZE::DiffusivityType retval;
| 141 |  |  | 141 |
| 142 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 142 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 143 | { |  | 143 | {
| 144 | ERRWRAP2(retval = _self_->getDiffusivity()); |  | 144 | ERRWRAP2(retval = _self_->getDiffusivity());
| 145 | return pyopencv_from(retval); |  | 145 | return pyopencv_from(retval);
| 146 | } |  | 146 | }
| 147 |  |  | 147 |
| 148 | return NULL; |  | 148 | return NULL;
| 149 | } |  | 149 | }
| 150 |  |  | 150 |
| 151 | static PyObject* pyopencv_cv_AKAZE_getMaxPoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 151 | static PyObject* pyopencv_cv_AKAZE_getMaxPoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 152 | { |  | 152 | {
| 153 | using namespace cv; |  | 153 | using namespace cv;
| 154 |  |  | 154 |
| 155 |  |  | 155 |
| 156 | Ptr<cv::AKAZE> * self1 = 0; |  | 156 | Ptr<cv::AKAZE> * self1 = 0;
| 157 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 157 | if (!pyopencv_AKAZE_getp(self, self1))
| 158 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 158 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 159 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 159 | Ptr<cv::AKAZE> _self_ = *(self1);
| 160 | int retval; |  | 160 | int retval;
| 161 |  |  | 161 |
| 162 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 162 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 163 | { |  | 163 | {
| 164 | ERRWRAP2(retval = _self_->getMaxPoints()); |  | 164 | ERRWRAP2(retval = _self_->getMaxPoints());
| 165 | return pyopencv_from(retval); |  | 165 | return pyopencv_from(retval);
| 166 | } |  | 166 | }
| 167 |  |  | 167 |
| 168 | return NULL; |  | 168 | return NULL;
| 169 | } |  | 169 | }
| 170 |  |  | 170 |
| 171 | static PyObject* pyopencv_cv_AKAZE_getNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 171 | static PyObject* pyopencv_cv_AKAZE_getNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw)
| 172 | { |  | 172 | {
| 173 | using namespace cv; |  | 173 | using namespace cv;
| 174 |  |  | 174 |
| 175 |  |  | 175 |
| 176 | Ptr<cv::AKAZE> * self1 = 0; |  | 176 | Ptr<cv::AKAZE> * self1 = 0;
| 177 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 177 | if (!pyopencv_AKAZE_getp(self, self1))
| 178 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 178 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 179 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 179 | Ptr<cv::AKAZE> _self_ = *(self1);
| 180 | int retval; |  | 180 | int retval;
| 181 |  |  | 181 |
| 182 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 182 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 183 | { |  | 183 | {
| 184 | ERRWRAP2(retval = _self_->getNOctaveLayers()); |  | 184 | ERRWRAP2(retval = _self_->getNOctaveLayers());
| 185 | return pyopencv_from(retval); |  | 185 | return pyopencv_from(retval);
| 186 | } |  | 186 | }
| 187 |  |  | 187 |
| 188 | return NULL; |  | 188 | return NULL;
| 189 | } |  | 189 | }
| 190 |  |  | 190 |
| 191 | static PyObject* pyopencv_cv_AKAZE_getNOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 191 | static PyObject* pyopencv_cv_AKAZE_getNOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 192 | { |  | 192 | {
| 193 | using namespace cv; |  | 193 | using namespace cv;
| 194 |  |  | 194 |
| 195 |  |  | 195 |
| 196 | Ptr<cv::AKAZE> * self1 = 0; |  | 196 | Ptr<cv::AKAZE> * self1 = 0;
| 197 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 197 | if (!pyopencv_AKAZE_getp(self, self1))
| 198 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 198 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 199 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 199 | Ptr<cv::AKAZE> _self_ = *(self1);
| 200 | int retval; |  | 200 | int retval;
| 201 |  |  | 201 |
| 202 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 202 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 203 | { |  | 203 | {
| 204 | ERRWRAP2(retval = _self_->getNOctaves()); |  | 204 | ERRWRAP2(retval = _self_->getNOctaves());
| 205 | return pyopencv_from(retval); |  | 205 | return pyopencv_from(retval);
| 206 | } |  | 206 | }
| 207 |  |  | 207 |
| 208 | return NULL; |  | 208 | return NULL;
| 209 | } |  | 209 | }
| 210 |  |  | 210 |
| 211 | static PyObject* pyopencv_cv_AKAZE_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 211 | static PyObject* pyopencv_cv_AKAZE_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 212 | { |  | 212 | {
| 213 | using namespace cv; |  | 213 | using namespace cv;
| 214 |  |  | 214 |
| 215 |  |  | 215 |
| 216 | Ptr<cv::AKAZE> * self1 = 0; |  | 216 | Ptr<cv::AKAZE> * self1 = 0;
| 217 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 217 | if (!pyopencv_AKAZE_getp(self, self1))
| 218 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 218 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 219 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 219 | Ptr<cv::AKAZE> _self_ = *(self1);
| 220 | double retval; |  | 220 | double retval;
| 221 |  |  | 221 |
| 222 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 222 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 223 | { |  | 223 | {
| 224 | ERRWRAP2(retval = _self_->getThreshold()); |  | 224 | ERRWRAP2(retval = _self_->getThreshold());
| 225 | return pyopencv_from(retval); |  | 225 | return pyopencv_from(retval);
| 226 | } |  | 226 | }
| 227 |  |  | 227 |
| 228 | return NULL; |  | 228 | return NULL;
| 229 | } |  | 229 | }
| 230 |  |  | 230 |
| 231 | static PyObject* pyopencv_cv_AKAZE_setDescriptorChannels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 231 | static PyObject* pyopencv_cv_AKAZE_setDescriptorChannels(PyObject* self, PyObject* py_args, PyObject* kw)
| 232 | { |  | 232 | {
| 233 | using namespace cv; |  | 233 | using namespace cv;
| 234 |  |  | 234 |
| 235 |  |  | 235 |
| 236 | Ptr<cv::AKAZE> * self1 = 0; |  | 236 | Ptr<cv::AKAZE> * self1 = 0;
| 237 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 237 | if (!pyopencv_AKAZE_getp(self, self1))
| 238 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 238 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 239 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 239 | Ptr<cv::AKAZE> _self_ = *(self1);
| 240 | PyObject* pyobj_dch = NULL; |  | 240 | PyObject* pyobj_dch = NULL;
| 241 | int dch=0; |  | 241 | int dch=0;
| 242 |  |  | 242 |
| 243 | const char* keywords[] = { "dch", NULL }; |  | 243 | const char* keywords[] = { "dch", NULL };
| 244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDescriptorChannels", (char**)keywords, &pyobj_dch) && |  | 244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDescriptorChannels", (char**)keywords, &pyobj_dch) &&
| 245 | pyopencv_to_safe(pyobj_dch, dch, ArgInfo("dch", 0)) ) |  | 245 | pyopencv_to_safe(pyobj_dch, dch, ArgInfo("dch", 0)) )
| 246 | { |  | 246 | {
| 247 | ERRWRAP2(_self_->setDescriptorChannels(dch)); |  | 247 | ERRWRAP2(_self_->setDescriptorChannels(dch));
| 248 | Py_RETURN_NONE; |  | 248 | Py_RETURN_NONE;
| 249 | } |  | 249 | }
| 250 |  |  | 250 |
| 251 | return NULL; |  | 251 | return NULL;
| 252 | } |  | 252 | }
| 253 |  |  | 253 |
| 254 | static PyObject* pyopencv_cv_AKAZE_setDescriptorSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 254 | static PyObject* pyopencv_cv_AKAZE_setDescriptorSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 255 | { |  | 255 | {
| 256 | using namespace cv; |  | 256 | using namespace cv;
| 257 |  |  | 257 |
| 258 |  |  | 258 |
| 259 | Ptr<cv::AKAZE> * self1 = 0; |  | 259 | Ptr<cv::AKAZE> * self1 = 0;
| 260 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 260 | if (!pyopencv_AKAZE_getp(self, self1))
| 261 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 261 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 262 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 262 | Ptr<cv::AKAZE> _self_ = *(self1);
| 263 | PyObject* pyobj_dsize = NULL; |  | 263 | PyObject* pyobj_dsize = NULL;
| 264 | int dsize=0; |  | 264 | int dsize=0;
| 265 |  |  | 265 |
| 266 | const char* keywords[] = { "dsize", NULL }; |  | 266 | const char* keywords[] = { "dsize", NULL };
| 267 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDescriptorSize", (char**)keywords, &pyobj_dsize) && |  | 267 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDescriptorSize", (char**)keywords, &pyobj_dsize) &&
| 268 | pyopencv_to_safe(pyobj_dsize, dsize, ArgInfo("dsize", 0)) ) |  | 268 | pyopencv_to_safe(pyobj_dsize, dsize, ArgInfo("dsize", 0)) )
| 269 | { |  | 269 | {
| 270 | ERRWRAP2(_self_->setDescriptorSize(dsize)); |  | 270 | ERRWRAP2(_self_->setDescriptorSize(dsize));
| 271 | Py_RETURN_NONE; |  | 271 | Py_RETURN_NONE;
| 272 | } |  | 272 | }
| 273 |  |  | 273 |
| 274 | return NULL; |  | 274 | return NULL;
| 275 | } |  | 275 | }
| 276 |  |  | 276 |
| 277 | static PyObject* pyopencv_cv_AKAZE_setDescriptorType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 277 | static PyObject* pyopencv_cv_AKAZE_setDescriptorType(PyObject* self, PyObject* py_args, PyObject* kw)
| 278 | { |  | 278 | {
| 279 | using namespace cv; |  | 279 | using namespace cv;
| 280 |  |  | 280 |
| 281 |  |  | 281 |
| 282 | Ptr<cv::AKAZE> * self1 = 0; |  | 282 | Ptr<cv::AKAZE> * self1 = 0;
| 283 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 283 | if (!pyopencv_AKAZE_getp(self, self1))
| 284 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 284 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 285 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 285 | Ptr<cv::AKAZE> _self_ = *(self1);
| 286 | PyObject* pyobj_dtype = NULL; |  | 286 | PyObject* pyobj_dtype = NULL;
| 287 | AKAZE_DescriptorType dtype=static_cast<AKAZE_DescriptorType>(0); |  | 287 | AKAZE_DescriptorType dtype=static_cast<AKAZE_DescriptorType>(0);
| 288 |  |  | 288 |
| 289 | const char* keywords[] = { "dtype", NULL }; |  | 289 | const char* keywords[] = { "dtype", NULL };
| 290 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDescriptorType", (char**)keywords, &pyobj_dtype) && |  | 290 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDescriptorType", (char**)keywords, &pyobj_dtype) &&
| 291 | pyopencv_to_safe(pyobj_dtype, dtype, ArgInfo("dtype", 0)) ) |  | 291 | pyopencv_to_safe(pyobj_dtype, dtype, ArgInfo("dtype", 0)) )
| 292 | { |  | 292 | {
| 293 | ERRWRAP2(_self_->setDescriptorType(dtype)); |  | 293 | ERRWRAP2(_self_->setDescriptorType(dtype));
| 294 | Py_RETURN_NONE; |  | 294 | Py_RETURN_NONE;
| 295 | } |  | 295 | }
| 296 |  |  | 296 |
| 297 | return NULL; |  | 297 | return NULL;
| 298 | } |  | 298 | }
| 299 |  |  | 299 |
| 300 | static PyObject* pyopencv_cv_AKAZE_setDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 300 | static PyObject* pyopencv_cv_AKAZE_setDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw)
| 301 | { |  | 301 | {
| 302 | using namespace cv; |  | 302 | using namespace cv;
| 303 |  |  | 303 |
| 304 |  |  | 304 |
| 305 | Ptr<cv::AKAZE> * self1 = 0; |  | 305 | Ptr<cv::AKAZE> * self1 = 0;
| 306 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 306 | if (!pyopencv_AKAZE_getp(self, self1))
| 307 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 307 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 308 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 308 | Ptr<cv::AKAZE> _self_ = *(self1);
| 309 | PyObject* pyobj_diff = NULL; |  | 309 | PyObject* pyobj_diff = NULL;
| 310 | KAZE_DiffusivityType diff=static_cast<KAZE_DiffusivityType>(0); |  | 310 | KAZE_DiffusivityType diff=static_cast<KAZE_DiffusivityType>(0);
| 311 |  |  | 311 |
| 312 | const char* keywords[] = { "diff", NULL }; |  | 312 | const char* keywords[] = { "diff", NULL };
| 313 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDiffusivity", (char**)keywords, &pyobj_diff) && |  | 313 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setDiffusivity", (char**)keywords, &pyobj_diff) &&
| 314 | pyopencv_to_safe(pyobj_diff, diff, ArgInfo("diff", 0)) ) |  | 314 | pyopencv_to_safe(pyobj_diff, diff, ArgInfo("diff", 0)) )
| 315 | { |  | 315 | {
| 316 | ERRWRAP2(_self_->setDiffusivity(diff)); |  | 316 | ERRWRAP2(_self_->setDiffusivity(diff));
| 317 | Py_RETURN_NONE; |  | 317 | Py_RETURN_NONE;
| 318 | } |  | 318 | }
| 319 |  |  | 319 |
| 320 | return NULL; |  | 320 | return NULL;
| 321 | } |  | 321 | }
| 322 |  |  | 322 |
| 323 | static PyObject* pyopencv_cv_AKAZE_setMaxPoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 323 | static PyObject* pyopencv_cv_AKAZE_setMaxPoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 324 | { |  | 324 | {
| 325 | using namespace cv; |  | 325 | using namespace cv;
| 326 |  |  | 326 |
| 327 |  |  | 327 |
| 328 | Ptr<cv::AKAZE> * self1 = 0; |  | 328 | Ptr<cv::AKAZE> * self1 = 0;
| 329 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 329 | if (!pyopencv_AKAZE_getp(self, self1))
| 330 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 330 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 331 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 331 | Ptr<cv::AKAZE> _self_ = *(self1);
| 332 | PyObject* pyobj_max_points = NULL; |  | 332 | PyObject* pyobj_max_points = NULL;
| 333 | int max_points=0; |  | 333 | int max_points=0;
| 334 |  |  | 334 |
| 335 | const char* keywords[] = { "max_points", NULL }; |  | 335 | const char* keywords[] = { "max_points", NULL };
| 336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setMaxPoints", (char**)keywords, &pyobj_max_points) && |  | 336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setMaxPoints", (char**)keywords, &pyobj_max_points) &&
| 337 | pyopencv_to_safe(pyobj_max_points, max_points, ArgInfo("max_points", 0)) ) |  | 337 | pyopencv_to_safe(pyobj_max_points, max_points, ArgInfo("max_points", 0)) )
| 338 | { |  | 338 | {
| 339 | ERRWRAP2(_self_->setMaxPoints(max_points)); |  | 339 | ERRWRAP2(_self_->setMaxPoints(max_points));
| 340 | Py_RETURN_NONE; |  | 340 | Py_RETURN_NONE;
| 341 | } |  | 341 | }
| 342 |  |  | 342 |
| 343 | return NULL; |  | 343 | return NULL;
| 344 | } |  | 344 | }
| 345 |  |  | 345 |
| 346 | static PyObject* pyopencv_cv_AKAZE_setNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 346 | static PyObject* pyopencv_cv_AKAZE_setNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw)
| 347 | { |  | 347 | {
| 348 | using namespace cv; |  | 348 | using namespace cv;
| 349 |  |  | 349 |
| 350 |  |  | 350 |
| 351 | Ptr<cv::AKAZE> * self1 = 0; |  | 351 | Ptr<cv::AKAZE> * self1 = 0;
| 352 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 352 | if (!pyopencv_AKAZE_getp(self, self1))
| 353 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 353 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 354 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 354 | Ptr<cv::AKAZE> _self_ = *(self1);
| 355 | PyObject* pyobj_octaveLayers = NULL; |  | 355 | PyObject* pyobj_octaveLayers = NULL;
| 356 | int octaveLayers=0; |  | 356 | int octaveLayers=0;
| 357 |  |  | 357 |
| 358 | const char* keywords[] = { "octaveLayers", NULL }; |  | 358 | const char* keywords[] = { "octaveLayers", NULL };
| 359 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setNOctaveLayers", (char**)keywords, &pyobj_octaveLayers) && |  | 359 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setNOctaveLayers", (char**)keywords, &pyobj_octaveLayers) &&
| 360 | pyopencv_to_safe(pyobj_octaveLayers, octaveLayers, ArgInfo("octaveLayers", 0)) ) |  | 360 | pyopencv_to_safe(pyobj_octaveLayers, octaveLayers, ArgInfo("octaveLayers", 0)) )
| 361 | { |  | 361 | {
| 362 | ERRWRAP2(_self_->setNOctaveLayers(octaveLayers)); |  | 362 | ERRWRAP2(_self_->setNOctaveLayers(octaveLayers));
| 363 | Py_RETURN_NONE; |  | 363 | Py_RETURN_NONE;
| 364 | } |  | 364 | }
| 365 |  |  | 365 |
| 366 | return NULL; |  | 366 | return NULL;
| 367 | } |  | 367 | }
| 368 |  |  | 368 |
| 369 | static PyObject* pyopencv_cv_AKAZE_setNOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 369 | static PyObject* pyopencv_cv_AKAZE_setNOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 370 | { |  | 370 | {
| 371 | using namespace cv; |  | 371 | using namespace cv;
| 372 |  |  | 372 |
| 373 |  |  | 373 |
| 374 | Ptr<cv::AKAZE> * self1 = 0; |  | 374 | Ptr<cv::AKAZE> * self1 = 0;
| 375 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 375 | if (!pyopencv_AKAZE_getp(self, self1))
| 376 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 376 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 377 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 377 | Ptr<cv::AKAZE> _self_ = *(self1);
| 378 | PyObject* pyobj_octaves = NULL; |  | 378 | PyObject* pyobj_octaves = NULL;
| 379 | int octaves=0; |  | 379 | int octaves=0;
| 380 |  |  | 380 |
| 381 | const char* keywords[] = { "octaves", NULL }; |  | 381 | const char* keywords[] = { "octaves", NULL };
| 382 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setNOctaves", (char**)keywords, &pyobj_octaves) && |  | 382 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setNOctaves", (char**)keywords, &pyobj_octaves) &&
| 383 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) ) |  | 383 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) )
| 384 | { |  | 384 | {
| 385 | ERRWRAP2(_self_->setNOctaves(octaves)); |  | 385 | ERRWRAP2(_self_->setNOctaves(octaves));
| 386 | Py_RETURN_NONE; |  | 386 | Py_RETURN_NONE;
| 387 | } |  | 387 | }
| 388 |  |  | 388 |
| 389 | return NULL; |  | 389 | return NULL;
| 390 | } |  | 390 | }
| 391 |  |  | 391 |
| 392 | static PyObject* pyopencv_cv_AKAZE_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 392 | static PyObject* pyopencv_cv_AKAZE_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 393 | { |  | 393 | {
| 394 | using namespace cv; |  | 394 | using namespace cv;
| 395 |  |  | 395 |
| 396 |  |  | 396 |
| 397 | Ptr<cv::AKAZE> * self1 = 0; |  | 397 | Ptr<cv::AKAZE> * self1 = 0;
| 398 | if (!pyopencv_AKAZE_getp(self, self1)) |  | 398 | if (!pyopencv_AKAZE_getp(self, self1))
| 399 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)"); |  | 399 | return failmsgp("Incorrect type of self (must be 'AKAZE' or its derivative)");
| 400 | Ptr<cv::AKAZE> _self_ = *(self1); |  | 400 | Ptr<cv::AKAZE> _self_ = *(self1);
| 401 | PyObject* pyobj_threshold = NULL; |  | 401 | PyObject* pyobj_threshold = NULL;
| 402 | double threshold=0; |  | 402 | double threshold=0;
| 403 |  |  | 403 |
| 404 | const char* keywords[] = { "threshold", NULL }; |  | 404 | const char* keywords[] = { "threshold", NULL };
| 405 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setThreshold", (char**)keywords, &pyobj_threshold) && |  | 405 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AKAZE.setThreshold", (char**)keywords, &pyobj_threshold) &&
| 406 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 406 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 407 | { |  | 407 | {
| 408 | ERRWRAP2(_self_->setThreshold(threshold)); |  | 408 | ERRWRAP2(_self_->setThreshold(threshold));
| 409 | Py_RETURN_NONE; |  | 409 | Py_RETURN_NONE;
| 410 | } |  | 410 | }
| 411 |  |  | 411 |
| 412 | return NULL; |  | 412 | return NULL;
| 413 | } |  | 413 | }
| 414 |  |  | 414 |
| 415 |  |  | 415 |
| 416 |  |  | 416 |
| 417 | // Tables (AKAZE) |  | 417 | // Tables (AKAZE)
| 418 |  |  | 418 |
| 419 | static PyGetSetDef pyopencv_AKAZE_getseters[] = |  | 419 | static PyGetSetDef pyopencv_AKAZE_getseters[] =
| 420 | { |  | 420 | {
| 421 | {NULL} /* Sentinel */ |  | 421 | {NULL} /* Sentinel */
| 422 | }; |  | 422 | };
| 423 |  |  | 423 |
| 424 | static PyMethodDef pyopencv_AKAZE_methods[] = |  | 424 | static PyMethodDef pyopencv_AKAZE_methods[] =
| 425 | { |  | 425 | {
| 426 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_create_static, METH_STATIC), "create([, descriptor_type[, descriptor_size[, descriptor_channels[, threshold[, nOctaves[, nOctaveLayers[, diffusivity[, max_points]]]]]]]]) -> retval\n. @brief The AKAZE constructor\n. \n. @param descriptor_type Type of the extracted descriptor: DESCRIPTOR_KAZE,\n. DESCRIPTOR_KAZE_UPRIGHT, DESCRIPTOR_MLDB or DESCRIPTOR_MLDB_UPRIGHT.\n. @param descriptor_size Size of the descriptor in bits. 0 -\\> Full size\n. @param descriptor_channels Number of channels in the descriptor (1, 2, 3)\n. @param threshold Detector response threshold to accept point\n. @param nOctaves Maximum octave evolution of the image\n. @param nOctaveLayers Default number of sublevels per scale level\n. @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or\n. DIFF_CHARBONNIER\n. @param max_points Maximum amount of returned points. In case if image contains\n. more features, then the features with highest response are returned.\n. Negative value means no limitation."}, |  | 426 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_create_static, METH_STATIC), "create([, descriptor_type[, descriptor_size[, descriptor_channels[, threshold[, nOctaves[, nOctaveLayers[, diffusivity[, max_points]]]]]]]]) -> retval\n. @brief The AKAZE constructor\n. \n. @param descriptor_type Type of the extracted descriptor: DESCRIPTOR_KAZE,\n. DESCRIPTOR_KAZE_UPRIGHT, DESCRIPTOR_MLDB or DESCRIPTOR_MLDB_UPRIGHT.\n. @param descriptor_size Size of the descriptor in bits. 0 -\\> Full size\n. @param descriptor_channels Number of channels in the descriptor (1, 2, 3)\n. @param threshold Detector response threshold to accept point\n. @param nOctaves Maximum octave evolution of the image\n. @param nOctaveLayers Default number of sublevels per scale level\n. @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or\n. DIFF_CHARBONNIER\n. @param max_points Maximum amount of returned points. In case if image contains\n. more features, then the features with highest response are returned.\n. Negative value means no limitation."},
| 427 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 427 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 428 | {"getDescriptorChannels", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDescriptorChannels, 0), "getDescriptorChannels() -> retval\n."}, |  | 428 | {"getDescriptorChannels", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDescriptorChannels, 0), "getDescriptorChannels() -> retval\n."},
| 429 | {"getDescriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDescriptorSize, 0), "getDescriptorSize() -> retval\n."}, |  | 429 | {"getDescriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDescriptorSize, 0), "getDescriptorSize() -> retval\n."},
| 430 | {"getDescriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDescriptorType, 0), "getDescriptorType() -> retval\n."}, |  | 430 | {"getDescriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDescriptorType, 0), "getDescriptorType() -> retval\n."},
| 431 | {"getDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDiffusivity, 0), "getDiffusivity() -> retval\n."}, |  | 431 | {"getDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getDiffusivity, 0), "getDiffusivity() -> retval\n."},
| 432 | {"getMaxPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getMaxPoints, 0), "getMaxPoints() -> retval\n."}, |  | 432 | {"getMaxPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getMaxPoints, 0), "getMaxPoints() -> retval\n."},
| 433 | {"getNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getNOctaveLayers, 0), "getNOctaveLayers() -> retval\n."}, |  | 433 | {"getNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getNOctaveLayers, 0), "getNOctaveLayers() -> retval\n."},
| 434 | {"getNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getNOctaves, 0), "getNOctaves() -> retval\n."}, |  | 434 | {"getNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getNOctaves, 0), "getNOctaves() -> retval\n."},
| 435 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getThreshold, 0), "getThreshold() -> retval\n."}, |  | 435 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_getThreshold, 0), "getThreshold() -> retval\n."},
| 436 | {"setDescriptorChannels", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDescriptorChannels, 0), "setDescriptorChannels(dch) -> None\n."}, |  | 436 | {"setDescriptorChannels", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDescriptorChannels, 0), "setDescriptorChannels(dch) -> None\n."},
| 437 | {"setDescriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDescriptorSize, 0), "setDescriptorSize(dsize) -> None\n."}, |  | 437 | {"setDescriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDescriptorSize, 0), "setDescriptorSize(dsize) -> None\n."},
| 438 | {"setDescriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDescriptorType, 0), "setDescriptorType(dtype) -> None\n."}, |  | 438 | {"setDescriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDescriptorType, 0), "setDescriptorType(dtype) -> None\n."},
| 439 | {"setDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDiffusivity, 0), "setDiffusivity(diff) -> None\n."}, |  | 439 | {"setDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setDiffusivity, 0), "setDiffusivity(diff) -> None\n."},
| 440 | {"setMaxPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setMaxPoints, 0), "setMaxPoints(max_points) -> None\n."}, |  | 440 | {"setMaxPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setMaxPoints, 0), "setMaxPoints(max_points) -> None\n."},
| 441 | {"setNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setNOctaveLayers, 0), "setNOctaveLayers(octaveLayers) -> None\n."}, |  | 441 | {"setNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setNOctaveLayers, 0), "setNOctaveLayers(octaveLayers) -> None\n."},
| 442 | {"setNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setNOctaves, 0), "setNOctaves(octaves) -> None\n."}, |  | 442 | {"setNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setNOctaves, 0), "setNOctaves(octaves) -> None\n."},
| 443 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setThreshold, 0), "setThreshold(threshold) -> None\n."}, |  | 443 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AKAZE_setThreshold, 0), "setThreshold(threshold) -> None\n."},
| 444 |  |  | 444 |
| 445 | {NULL, NULL} |  | 445 | {NULL, NULL}
| 446 | }; |  | 446 | };
| 447 |  |  | 447 |
| 448 | // Converter (AKAZE) |  | 448 | // Converter (AKAZE)
| 449 |  |  | 449 |
| 450 | template<> |  | 450 | template<>
| 451 | struct PyOpenCV_Converter< Ptr<cv::AKAZE> > |  | 451 | struct PyOpenCV_Converter< Ptr<cv::AKAZE> >
| 452 | { |  | 452 | {
| 453 | static PyObject* from(const Ptr<cv::AKAZE>& r) |  | 453 | static PyObject* from(const Ptr<cv::AKAZE>& r)
| 454 | { |  | 454 | {
| 455 | return pyopencv_AKAZE_Instance(r); |  | 455 | return pyopencv_AKAZE_Instance(r);
| 456 | } |  | 456 | }
| 457 | static bool to(PyObject* src, Ptr<cv::AKAZE>& dst, const ArgInfo& info) |  | 457 | static bool to(PyObject* src, Ptr<cv::AKAZE>& dst, const ArgInfo& info)
| 458 | { |  | 458 | {
| 459 | if(!src || src == Py_None) |  | 459 | if(!src || src == Py_None)
| 460 | return true; |  | 460 | return true;
| 461 | Ptr<cv::AKAZE> * dst_; |  | 461 | Ptr<cv::AKAZE> * dst_;
| 462 | if (pyopencv_AKAZE_getp(src, dst_)) |  | 462 | if (pyopencv_AKAZE_getp(src, dst_))
| 463 | { |  | 463 | {
| 464 | dst = *dst_; |  | 464 | dst = *dst_;
| 465 | return true; |  | 465 | return true;
| 466 | } |  | 466 | }
| 467 |  |  | 467 |
| 468 | failmsg("Expected Ptr<cv::AKAZE> for argument '%s'", info.name); |  | 468 | failmsg("Expected Ptr<cv::AKAZE> for argument '%s'", info.name);
| 469 | return false; |  | 469 | return false;
| 470 | } |  | 470 | }
| 471 | }; |  | 471 | };
| 472 |  |  | 472 |
| 473 | //================================================================================ |  | 473 | //================================================================================
| 474 | // AffineFeature (Generic) |  | 474 | // AffineFeature (Generic)
| 475 | //================================================================================ |  | 475 | //================================================================================
| 476 |  |  | 476 |
| 477 | // GetSet (AffineFeature) |  | 477 | // GetSet (AffineFeature)
| 478 |  |  | 478 |
| 479 |  |  | 479 |
| 480 |  |  | 480 |
| 481 | // Methods (AffineFeature) |  | 481 | // Methods (AffineFeature)
| 482 |  |  | 482 |
| 483 | static PyObject* pyopencv_cv_AffineFeature_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 483 | static PyObject* pyopencv_cv_AffineFeature_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 484 | { |  | 484 | {
| 485 | using namespace cv; |  | 485 | using namespace cv;
| 486 |  |  | 486 |
| 487 | PyObject* pyobj_backend = NULL; |  | 487 | PyObject* pyobj_backend = NULL;
| 488 | Ptr<Feature2D> backend; |  | 488 | Ptr<Feature2D> backend;
| 489 | PyObject* pyobj_maxTilt = NULL; |  | 489 | PyObject* pyobj_maxTilt = NULL;
| 490 | int maxTilt=5; |  | 490 | int maxTilt=5;
| 491 | PyObject* pyobj_minTilt = NULL; |  | 491 | PyObject* pyobj_minTilt = NULL;
| 492 | int minTilt=0; |  | 492 | int minTilt=0;
| 493 | PyObject* pyobj_tiltStep = NULL; |  | 493 | PyObject* pyobj_tiltStep = NULL;
| 494 | float tiltStep=1.4142135623730951f; |  | 494 | float tiltStep=1.4142135623730951f;
| 495 | PyObject* pyobj_rotateStepBase = NULL; |  | 495 | PyObject* pyobj_rotateStepBase = NULL;
| 496 | float rotateStepBase=72; |  | 496 | float rotateStepBase=72;
| 497 | Ptr<AffineFeature> retval; |  | 497 | Ptr<AffineFeature> retval;
| 498 |  |  | 498 |
| 499 | const char* keywords[] = { "backend", "maxTilt", "minTilt", "tiltStep", "rotateStepBase", NULL }; |  | 499 | const char* keywords[] = { "backend", "maxTilt", "minTilt", "tiltStep", "rotateStepBase", NULL };
| 500 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:AffineFeature.create", (char**)keywords, &pyobj_backend, &pyobj_maxTilt, &pyobj_minTilt, &pyobj_tiltStep, &pyobj_rotateStepBase) && |  | 500 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:AffineFeature.create", (char**)keywords, &pyobj_backend, &pyobj_maxTilt, &pyobj_minTilt, &pyobj_tiltStep, &pyobj_rotateStepBase) &&
| 501 | pyopencv_to_safe(pyobj_backend, backend, ArgInfo("backend", 0)) && |  | 501 | pyopencv_to_safe(pyobj_backend, backend, ArgInfo("backend", 0)) &&
| 502 | pyopencv_to_safe(pyobj_maxTilt, maxTilt, ArgInfo("maxTilt", 0)) && |  | 502 | pyopencv_to_safe(pyobj_maxTilt, maxTilt, ArgInfo("maxTilt", 0)) &&
| 503 | pyopencv_to_safe(pyobj_minTilt, minTilt, ArgInfo("minTilt", 0)) && |  | 503 | pyopencv_to_safe(pyobj_minTilt, minTilt, ArgInfo("minTilt", 0)) &&
| 504 | pyopencv_to_safe(pyobj_tiltStep, tiltStep, ArgInfo("tiltStep", 0)) && |  | 504 | pyopencv_to_safe(pyobj_tiltStep, tiltStep, ArgInfo("tiltStep", 0)) &&
| 505 | pyopencv_to_safe(pyobj_rotateStepBase, rotateStepBase, ArgInfo("rotateStepBase", 0)) ) |  | 505 | pyopencv_to_safe(pyobj_rotateStepBase, rotateStepBase, ArgInfo("rotateStepBase", 0)) )
| 506 | { |  | 506 | {
| 507 | ERRWRAP2(retval = cv::AffineFeature::create(backend, maxTilt, minTilt, tiltStep, rotateStepBase)); |  | 507 | ERRWRAP2(retval = cv::AffineFeature::create(backend, maxTilt, minTilt, tiltStep, rotateStepBase));
| 508 | return pyopencv_from(retval); |  | 508 | return pyopencv_from(retval);
| 509 | } |  | 509 | }
| 510 |  |  | 510 |
| 511 | return NULL; |  | 511 | return NULL;
| 512 | } |  | 512 | }
| 513 |  |  | 513 |
| 514 | static PyObject* pyopencv_cv_AffineFeature_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 514 | static PyObject* pyopencv_cv_AffineFeature_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 515 | { |  | 515 | {
| 516 | using namespace cv; |  | 516 | using namespace cv;
| 517 |  |  | 517 |
| 518 |  |  | 518 |
| 519 | Ptr<cv::AffineFeature> * self1 = 0; |  | 519 | Ptr<cv::AffineFeature> * self1 = 0;
| 520 | if (!pyopencv_AffineFeature_getp(self, self1)) |  | 520 | if (!pyopencv_AffineFeature_getp(self, self1))
| 521 | return failmsgp("Incorrect type of self (must be 'AffineFeature' or its derivative)"); |  | 521 | return failmsgp("Incorrect type of self (must be 'AffineFeature' or its derivative)");
| 522 | Ptr<cv::AffineFeature> _self_ = *(self1); |  | 522 | Ptr<cv::AffineFeature> _self_ = *(self1);
| 523 | String retval; |  | 523 | String retval;
| 524 |  |  | 524 |
| 525 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 525 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 526 | { |  | 526 | {
| 527 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 527 | ERRWRAP2(retval = _self_->getDefaultName());
| 528 | return pyopencv_from(retval); |  | 528 | return pyopencv_from(retval);
| 529 | } |  | 529 | }
| 530 |  |  | 530 |
| 531 | return NULL; |  | 531 | return NULL;
| 532 | } |  | 532 | }
| 533 |  |  | 533 |
| 534 | static PyObject* pyopencv_cv_AffineFeature_getViewParams(PyObject* self, PyObject* py_args, PyObject* kw) |  | 534 | static PyObject* pyopencv_cv_AffineFeature_getViewParams(PyObject* self, PyObject* py_args, PyObject* kw)
| 535 | { |  | 535 | {
| 536 | using namespace cv; |  | 536 | using namespace cv;
| 537 |  |  | 537 |
| 538 |  |  | 538 |
| 539 | Ptr<cv::AffineFeature> * self1 = 0; |  | 539 | Ptr<cv::AffineFeature> * self1 = 0;
| 540 | if (!pyopencv_AffineFeature_getp(self, self1)) |  | 540 | if (!pyopencv_AffineFeature_getp(self, self1))
| 541 | return failmsgp("Incorrect type of self (must be 'AffineFeature' or its derivative)"); |  | 541 | return failmsgp("Incorrect type of self (must be 'AffineFeature' or its derivative)");
| 542 | Ptr<cv::AffineFeature> _self_ = *(self1); |  | 542 | Ptr<cv::AffineFeature> _self_ = *(self1);
| 543 | PyObject* pyobj_tilts = NULL; |  | 543 | PyObject* pyobj_tilts = NULL;
| 544 | vector_float tilts; |  | 544 | vector_float tilts;
| 545 | PyObject* pyobj_rolls = NULL; |  | 545 | PyObject* pyobj_rolls = NULL;
| 546 | vector_float rolls; |  | 546 | vector_float rolls;
| 547 |  |  | 547 |
| 548 | const char* keywords[] = { "tilts", "rolls", NULL }; |  | 548 | const char* keywords[] = { "tilts", "rolls", NULL };
| 549 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AffineFeature.getViewParams", (char**)keywords, &pyobj_tilts, &pyobj_rolls) && |  | 549 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AffineFeature.getViewParams", (char**)keywords, &pyobj_tilts, &pyobj_rolls) &&
| 550 | pyopencv_to_safe(pyobj_tilts, tilts, ArgInfo("tilts", 0)) && |  | 550 | pyopencv_to_safe(pyobj_tilts, tilts, ArgInfo("tilts", 0)) &&
| 551 | pyopencv_to_safe(pyobj_rolls, rolls, ArgInfo("rolls", 0)) ) |  | 551 | pyopencv_to_safe(pyobj_rolls, rolls, ArgInfo("rolls", 0)) )
| 552 | { |  | 552 | {
| 553 | ERRWRAP2(_self_->getViewParams(tilts, rolls)); |  | 553 | ERRWRAP2(_self_->getViewParams(tilts, rolls));
| 554 | Py_RETURN_NONE; |  | 554 | Py_RETURN_NONE;
| 555 | } |  | 555 | }
| 556 |  |  | 556 |
| 557 | return NULL; |  | 557 | return NULL;
| 558 | } |  | 558 | }
| 559 |  |  | 559 |
| 560 | static PyObject* pyopencv_cv_AffineFeature_setViewParams(PyObject* self, PyObject* py_args, PyObject* kw) |  | 560 | static PyObject* pyopencv_cv_AffineFeature_setViewParams(PyObject* self, PyObject* py_args, PyObject* kw)
| 561 | { |  | 561 | {
| 562 | using namespace cv; |  | 562 | using namespace cv;
| 563 |  |  | 563 |
| 564 |  |  | 564 |
| 565 | Ptr<cv::AffineFeature> * self1 = 0; |  | 565 | Ptr<cv::AffineFeature> * self1 = 0;
| 566 | if (!pyopencv_AffineFeature_getp(self, self1)) |  | 566 | if (!pyopencv_AffineFeature_getp(self, self1))
| 567 | return failmsgp("Incorrect type of self (must be 'AffineFeature' or its derivative)"); |  | 567 | return failmsgp("Incorrect type of self (must be 'AffineFeature' or its derivative)");
| 568 | Ptr<cv::AffineFeature> _self_ = *(self1); |  | 568 | Ptr<cv::AffineFeature> _self_ = *(self1);
| 569 | PyObject* pyobj_tilts = NULL; |  | 569 | PyObject* pyobj_tilts = NULL;
| 570 | vector_float tilts; |  | 570 | vector_float tilts;
| 571 | PyObject* pyobj_rolls = NULL; |  | 571 | PyObject* pyobj_rolls = NULL;
| 572 | vector_float rolls; |  | 572 | vector_float rolls;
| 573 |  |  | 573 |
| 574 | const char* keywords[] = { "tilts", "rolls", NULL }; |  | 574 | const char* keywords[] = { "tilts", "rolls", NULL };
| 575 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AffineFeature.setViewParams", (char**)keywords, &pyobj_tilts, &pyobj_rolls) && |  | 575 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AffineFeature.setViewParams", (char**)keywords, &pyobj_tilts, &pyobj_rolls) &&
| 576 | pyopencv_to_safe(pyobj_tilts, tilts, ArgInfo("tilts", 0)) && |  | 576 | pyopencv_to_safe(pyobj_tilts, tilts, ArgInfo("tilts", 0)) &&
| 577 | pyopencv_to_safe(pyobj_rolls, rolls, ArgInfo("rolls", 0)) ) |  | 577 | pyopencv_to_safe(pyobj_rolls, rolls, ArgInfo("rolls", 0)) )
| 578 | { |  | 578 | {
| 579 | ERRWRAP2(_self_->setViewParams(tilts, rolls)); |  | 579 | ERRWRAP2(_self_->setViewParams(tilts, rolls));
| 580 | Py_RETURN_NONE; |  | 580 | Py_RETURN_NONE;
| 581 | } |  | 581 | }
| 582 |  |  | 582 |
| 583 | return NULL; |  | 583 | return NULL;
| 584 | } |  | 584 | }
| 585 |  |  | 585 |
| 586 |  |  | 586 |
| 587 |  |  | 587 |
| 588 | // Tables (AffineFeature) |  | 588 | // Tables (AffineFeature)
| 589 |  |  | 589 |
| 590 | static PyGetSetDef pyopencv_AffineFeature_getseters[] = |  | 590 | static PyGetSetDef pyopencv_AffineFeature_getseters[] =
| 591 | { |  | 591 | {
| 592 | {NULL} /* Sentinel */ |  | 592 | {NULL} /* Sentinel */
| 593 | }; |  | 593 | };
| 594 |  |  | 594 |
| 595 | static PyMethodDef pyopencv_AffineFeature_methods[] = |  | 595 | static PyMethodDef pyopencv_AffineFeature_methods[] =
| 596 | { |  | 596 | {
| 597 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_create_static, METH_STATIC), "create(backend[, maxTilt[, minTilt[, tiltStep[, rotateStepBase]]]]) -> retval\n. @param backend The detector/extractor you want to use as backend.\n. @param maxTilt The highest power index of tilt factor. 5 is used in the paper as tilt sampling range n.\n. @param minTilt The lowest power index of tilt factor. 0 is used in the paper.\n. @param tiltStep Tilt sampling step \\f$\\delta_t\\f$ in Algorithm 1 in the paper.\n. @param rotateStepBase Rotation sampling step factor b in Algorithm 1 in the paper."}, |  | 597 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_create_static, METH_STATIC), "create(backend[, maxTilt[, minTilt[, tiltStep[, rotateStepBase]]]]) -> retval\n. @param backend The detector/extractor you want to use as backend.\n. @param maxTilt The highest power index of tilt factor. 5 is used in the paper as tilt sampling range n.\n. @param minTilt The lowest power index of tilt factor. 0 is used in the paper.\n. @param tiltStep Tilt sampling step \\f$\\delta_t\\f$ in Algorithm 1 in the paper.\n. @param rotateStepBase Rotation sampling step factor b in Algorithm 1 in the paper."},
| 598 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 598 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 599 | {"getViewParams", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_getViewParams, 0), "getViewParams(tilts, rolls) -> None\n."}, |  | 599 | {"getViewParams", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_getViewParams, 0), "getViewParams(tilts, rolls) -> None\n."},
| 600 | {"setViewParams", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_setViewParams, 0), "setViewParams(tilts, rolls) -> None\n."}, |  | 600 | {"setViewParams", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineFeature_setViewParams, 0), "setViewParams(tilts, rolls) -> None\n."},
| 601 |  |  | 601 |
| 602 | {NULL, NULL} |  | 602 | {NULL, NULL}
| 603 | }; |  | 603 | };
| 604 |  |  | 604 |
| 605 | // Converter (AffineFeature) |  | 605 | // Converter (AffineFeature)
| 606 |  |  | 606 |
| 607 | template<> |  | 607 | template<>
| 608 | struct PyOpenCV_Converter< Ptr<cv::AffineFeature> > |  | 608 | struct PyOpenCV_Converter< Ptr<cv::AffineFeature> >
| 609 | { |  | 609 | {
| 610 | static PyObject* from(const Ptr<cv::AffineFeature>& r) |  | 610 | static PyObject* from(const Ptr<cv::AffineFeature>& r)
| 611 | { |  | 611 | {
| 612 | return pyopencv_AffineFeature_Instance(r); |  | 612 | return pyopencv_AffineFeature_Instance(r);
| 613 | } |  | 613 | }
| 614 | static bool to(PyObject* src, Ptr<cv::AffineFeature>& dst, const ArgInfo& info) |  | 614 | static bool to(PyObject* src, Ptr<cv::AffineFeature>& dst, const ArgInfo& info)
| 615 | { |  | 615 | {
| 616 | if(!src || src == Py_None) |  | 616 | if(!src || src == Py_None)
| 617 | return true; |  | 617 | return true;
| 618 | Ptr<cv::AffineFeature> * dst_; |  | 618 | Ptr<cv::AffineFeature> * dst_;
| 619 | if (pyopencv_AffineFeature_getp(src, dst_)) |  | 619 | if (pyopencv_AffineFeature_getp(src, dst_))
| 620 | { |  | 620 | {
| 621 | dst = *dst_; |  | 621 | dst = *dst_;
| 622 | return true; |  | 622 | return true;
| 623 | } |  | 623 | }
| 624 |  |  | 624 |
| 625 | failmsg("Expected Ptr<cv::AffineFeature> for argument '%s'", info.name); |  | 625 | failmsg("Expected Ptr<cv::AffineFeature> for argument '%s'", info.name);
| 626 | return false; |  | 626 | return false;
| 627 | } |  | 627 | }
| 628 | }; |  | 628 | };
| 629 |  |  | 629 |
| 630 | //================================================================================ |  | 630 | //================================================================================
| 631 | // AffineTransformer (Generic) |  | 631 | // AffineTransformer (Generic)
| 632 | //================================================================================ |  | 632 | //================================================================================
| 633 |  |  | 633 |
| 634 | // GetSet (AffineTransformer) |  | 634 | // GetSet (AffineTransformer)
| 635 |  |  | 635 |
| 636 |  |  | 636 |
| 637 |  |  | 637 |
| 638 | // Methods (AffineTransformer) |  | 638 | // Methods (AffineTransformer)
| 639 |  |  | 639 |
| 640 | static PyObject* pyopencv_cv_AffineTransformer_getFullAffine(PyObject* self, PyObject* py_args, PyObject* kw) |  | 640 | static PyObject* pyopencv_cv_AffineTransformer_getFullAffine(PyObject* self, PyObject* py_args, PyObject* kw)
| 641 | { |  | 641 | {
| 642 | using namespace cv; |  | 642 | using namespace cv;
| 643 |  |  | 643 |
| 644 |  |  | 644 |
| 645 | Ptr<cv::AffineTransformer> * self1 = 0; |  | 645 | Ptr<cv::AffineTransformer> * self1 = 0;
| 646 | if (!pyopencv_AffineTransformer_getp(self, self1)) |  | 646 | if (!pyopencv_AffineTransformer_getp(self, self1))
| 647 | return failmsgp("Incorrect type of self (must be 'AffineTransformer' or its derivative)"); |  | 647 | return failmsgp("Incorrect type of self (must be 'AffineTransformer' or its derivative)");
| 648 | Ptr<cv::AffineTransformer> _self_ = *(self1); |  | 648 | Ptr<cv::AffineTransformer> _self_ = *(self1);
| 649 | bool retval; |  | 649 | bool retval;
| 650 |  |  | 650 |
| 651 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 651 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 652 | { |  | 652 | {
| 653 | ERRWRAP2(retval = _self_->getFullAffine()); |  | 653 | ERRWRAP2(retval = _self_->getFullAffine());
| 654 | return pyopencv_from(retval); |  | 654 | return pyopencv_from(retval);
| 655 | } |  | 655 | }
| 656 |  |  | 656 |
| 657 | return NULL; |  | 657 | return NULL;
| 658 | } |  | 658 | }
| 659 |  |  | 659 |
| 660 | static PyObject* pyopencv_cv_AffineTransformer_setFullAffine(PyObject* self, PyObject* py_args, PyObject* kw) |  | 660 | static PyObject* pyopencv_cv_AffineTransformer_setFullAffine(PyObject* self, PyObject* py_args, PyObject* kw)
| 661 | { |  | 661 | {
| 662 | using namespace cv; |  | 662 | using namespace cv;
| 663 |  |  | 663 |
| 664 |  |  | 664 |
| 665 | Ptr<cv::AffineTransformer> * self1 = 0; |  | 665 | Ptr<cv::AffineTransformer> * self1 = 0;
| 666 | if (!pyopencv_AffineTransformer_getp(self, self1)) |  | 666 | if (!pyopencv_AffineTransformer_getp(self, self1))
| 667 | return failmsgp("Incorrect type of self (must be 'AffineTransformer' or its derivative)"); |  | 667 | return failmsgp("Incorrect type of self (must be 'AffineTransformer' or its derivative)");
| 668 | Ptr<cv::AffineTransformer> _self_ = *(self1); |  | 668 | Ptr<cv::AffineTransformer> _self_ = *(self1);
| 669 | PyObject* pyobj_fullAffine = NULL; |  | 669 | PyObject* pyobj_fullAffine = NULL;
| 670 | bool fullAffine=0; |  | 670 | bool fullAffine=0;
| 671 |  |  | 671 |
| 672 | const char* keywords[] = { "fullAffine", NULL }; |  | 672 | const char* keywords[] = { "fullAffine", NULL };
| 673 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AffineTransformer.setFullAffine", (char**)keywords, &pyobj_fullAffine) && |  | 673 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AffineTransformer.setFullAffine", (char**)keywords, &pyobj_fullAffine) &&
| 674 | pyopencv_to_safe(pyobj_fullAffine, fullAffine, ArgInfo("fullAffine", 0)) ) |  | 674 | pyopencv_to_safe(pyobj_fullAffine, fullAffine, ArgInfo("fullAffine", 0)) )
| 675 | { |  | 675 | {
| 676 | ERRWRAP2(_self_->setFullAffine(fullAffine)); |  | 676 | ERRWRAP2(_self_->setFullAffine(fullAffine));
| 677 | Py_RETURN_NONE; |  | 677 | Py_RETURN_NONE;
| 678 | } |  | 678 | }
| 679 |  |  | 679 |
| 680 | return NULL; |  | 680 | return NULL;
| 681 | } |  | 681 | }
| 682 |  |  | 682 |
| 683 |  |  | 683 |
| 684 |  |  | 684 |
| 685 | // Tables (AffineTransformer) |  | 685 | // Tables (AffineTransformer)
| 686 |  |  | 686 |
| 687 | static PyGetSetDef pyopencv_AffineTransformer_getseters[] = |  | 687 | static PyGetSetDef pyopencv_AffineTransformer_getseters[] =
| 688 | { |  | 688 | {
| 689 | {NULL} /* Sentinel */ |  | 689 | {NULL} /* Sentinel */
| 690 | }; |  | 690 | };
| 691 |  |  | 691 |
| 692 | static PyMethodDef pyopencv_AffineTransformer_methods[] = |  | 692 | static PyMethodDef pyopencv_AffineTransformer_methods[] =
| 693 | { |  | 693 | {
| 694 | {"getFullAffine", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineTransformer_getFullAffine, 0), "getFullAffine() -> retval\n."}, |  | 694 | {"getFullAffine", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineTransformer_getFullAffine, 0), "getFullAffine() -> retval\n."},
| 695 | {"setFullAffine", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineTransformer_setFullAffine, 0), "setFullAffine(fullAffine) -> None\n."}, |  | 695 | {"setFullAffine", CV_PY_FN_WITH_KW_(pyopencv_cv_AffineTransformer_setFullAffine, 0), "setFullAffine(fullAffine) -> None\n."},
| 696 |  |  | 696 |
| 697 | {NULL, NULL} |  | 697 | {NULL, NULL}
| 698 | }; |  | 698 | };
| 699 |  |  | 699 |
| 700 | // Converter (AffineTransformer) |  | 700 | // Converter (AffineTransformer)
| 701 |  |  | 701 |
| 702 | template<> |  | 702 | template<>
| 703 | struct PyOpenCV_Converter< Ptr<cv::AffineTransformer> > |  | 703 | struct PyOpenCV_Converter< Ptr<cv::AffineTransformer> >
| 704 | { |  | 704 | {
| 705 | static PyObject* from(const Ptr<cv::AffineTransformer>& r) |  | 705 | static PyObject* from(const Ptr<cv::AffineTransformer>& r)
| 706 | { |  | 706 | {
| 707 | return pyopencv_AffineTransformer_Instance(r); |  | 707 | return pyopencv_AffineTransformer_Instance(r);
| 708 | } |  | 708 | }
| 709 | static bool to(PyObject* src, Ptr<cv::AffineTransformer>& dst, const ArgInfo& info) |  | 709 | static bool to(PyObject* src, Ptr<cv::AffineTransformer>& dst, const ArgInfo& info)
| 710 | { |  | 710 | {
| 711 | if(!src || src == Py_None) |  | 711 | if(!src || src == Py_None)
| 712 | return true; |  | 712 | return true;
| 713 | Ptr<cv::AffineTransformer> * dst_; |  | 713 | Ptr<cv::AffineTransformer> * dst_;
| 714 | if (pyopencv_AffineTransformer_getp(src, dst_)) |  | 714 | if (pyopencv_AffineTransformer_getp(src, dst_))
| 715 | { |  | 715 | {
| 716 | dst = *dst_; |  | 716 | dst = *dst_;
| 717 | return true; |  | 717 | return true;
| 718 | } |  | 718 | }
| 719 |  |  | 719 |
| 720 | failmsg("Expected Ptr<cv::AffineTransformer> for argument '%s'", info.name); |  | 720 | failmsg("Expected Ptr<cv::AffineTransformer> for argument '%s'", info.name);
| 721 | return false; |  | 721 | return false;
| 722 | } |  | 722 | }
| 723 | }; |  | 723 | };
| 724 |  |  | 724 |
| 725 | //================================================================================ |  | 725 | //================================================================================
| 726 | // AgastFeatureDetector (Generic) |  | 726 | // AgastFeatureDetector (Generic)
| 727 | //================================================================================ |  | 727 | //================================================================================
| 728 |  |  | 728 |
| 729 | // GetSet (AgastFeatureDetector) |  | 729 | // GetSet (AgastFeatureDetector)
| 730 |  |  | 730 |
| 731 |  |  | 731 |
| 732 |  |  | 732 |
| 733 | // Methods (AgastFeatureDetector) |  | 733 | // Methods (AgastFeatureDetector)
| 734 |  |  | 734 |
| 735 | static PyObject* pyopencv_cv_AgastFeatureDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 735 | static PyObject* pyopencv_cv_AgastFeatureDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 736 | { |  | 736 | {
| 737 | using namespace cv; |  | 737 | using namespace cv;
| 738 |  |  | 738 |
| 739 | PyObject* pyobj_threshold = NULL; |  | 739 | PyObject* pyobj_threshold = NULL;
| 740 | int threshold=10; |  | 740 | int threshold=10;
| 741 | PyObject* pyobj_nonmaxSuppression = NULL; |  | 741 | PyObject* pyobj_nonmaxSuppression = NULL;
| 742 | bool nonmaxSuppression=true; |  | 742 | bool nonmaxSuppression=true;
| 743 | PyObject* pyobj_type = NULL; |  | 743 | PyObject* pyobj_type = NULL;
| 744 | AgastFeatureDetector_DetectorType type=AgastFeatureDetector::OAST_9_16; |  | 744 | AgastFeatureDetector_DetectorType type=AgastFeatureDetector::OAST_9_16;
| 745 | Ptr<AgastFeatureDetector> retval; |  | 745 | Ptr<AgastFeatureDetector> retval;
| 746 |  |  | 746 |
| 747 | const char* keywords[] = { "threshold", "nonmaxSuppression", "type", NULL }; |  | 747 | const char* keywords[] = { "threshold", "nonmaxSuppression", "type", NULL };
| 748 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:AgastFeatureDetector.create", (char**)keywords, &pyobj_threshold, &pyobj_nonmaxSuppression, &pyobj_type) && |  | 748 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:AgastFeatureDetector.create", (char**)keywords, &pyobj_threshold, &pyobj_nonmaxSuppression, &pyobj_type) &&
| 749 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) && |  | 749 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) &&
| 750 | pyopencv_to_safe(pyobj_nonmaxSuppression, nonmaxSuppression, ArgInfo("nonmaxSuppression", 0)) && |  | 750 | pyopencv_to_safe(pyobj_nonmaxSuppression, nonmaxSuppression, ArgInfo("nonmaxSuppression", 0)) &&
| 751 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 751 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 752 | { |  | 752 | {
| 753 | ERRWRAP2(retval = cv::AgastFeatureDetector::create(threshold, nonmaxSuppression, type)); |  | 753 | ERRWRAP2(retval = cv::AgastFeatureDetector::create(threshold, nonmaxSuppression, type));
| 754 | return pyopencv_from(retval); |  | 754 | return pyopencv_from(retval);
| 755 | } |  | 755 | }
| 756 |  |  | 756 |
| 757 | return NULL; |  | 757 | return NULL;
| 758 | } |  | 758 | }
| 759 |  |  | 759 |
| 760 | static PyObject* pyopencv_cv_AgastFeatureDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 760 | static PyObject* pyopencv_cv_AgastFeatureDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 761 | { |  | 761 | {
| 762 | using namespace cv; |  | 762 | using namespace cv;
| 763 |  |  | 763 |
| 764 |  |  | 764 |
| 765 | Ptr<cv::AgastFeatureDetector> * self1 = 0; |  | 765 | Ptr<cv::AgastFeatureDetector> * self1 = 0;
| 766 | if (!pyopencv_AgastFeatureDetector_getp(self, self1)) |  | 766 | if (!pyopencv_AgastFeatureDetector_getp(self, self1))
| 767 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)"); |  | 767 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)");
| 768 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1); |  | 768 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1);
| 769 | String retval; |  | 769 | String retval;
| 770 |  |  | 770 |
| 771 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 771 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 772 | { |  | 772 | {
| 773 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 773 | ERRWRAP2(retval = _self_->getDefaultName());
| 774 | return pyopencv_from(retval); |  | 774 | return pyopencv_from(retval);
| 775 | } |  | 775 | }
| 776 |  |  | 776 |
| 777 | return NULL; |  | 777 | return NULL;
| 778 | } |  | 778 | }
| 779 |  |  | 779 |
| 780 | static PyObject* pyopencv_cv_AgastFeatureDetector_getNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw) |  | 780 | static PyObject* pyopencv_cv_AgastFeatureDetector_getNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw)
| 781 | { |  | 781 | {
| 782 | using namespace cv; |  | 782 | using namespace cv;
| 783 |  |  | 783 |
| 784 |  |  | 784 |
| 785 | Ptr<cv::AgastFeatureDetector> * self1 = 0; |  | 785 | Ptr<cv::AgastFeatureDetector> * self1 = 0;
| 786 | if (!pyopencv_AgastFeatureDetector_getp(self, self1)) |  | 786 | if (!pyopencv_AgastFeatureDetector_getp(self, self1))
| 787 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)"); |  | 787 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)");
| 788 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1); |  | 788 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1);
| 789 | bool retval; |  | 789 | bool retval;
| 790 |  |  | 790 |
| 791 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 791 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 792 | { |  | 792 | {
| 793 | ERRWRAP2(retval = _self_->getNonmaxSuppression()); |  | 793 | ERRWRAP2(retval = _self_->getNonmaxSuppression());
| 794 | return pyopencv_from(retval); |  | 794 | return pyopencv_from(retval);
| 795 | } |  | 795 | }
| 796 |  |  | 796 |
| 797 | return NULL; |  | 797 | return NULL;
| 798 | } |  | 798 | }
| 799 |  |  | 799 |
| 800 | static PyObject* pyopencv_cv_AgastFeatureDetector_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 800 | static PyObject* pyopencv_cv_AgastFeatureDetector_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 801 | { |  | 801 | {
| 802 | using namespace cv; |  | 802 | using namespace cv;
| 803 |  |  | 803 |
| 804 |  |  | 804 |
| 805 | Ptr<cv::AgastFeatureDetector> * self1 = 0; |  | 805 | Ptr<cv::AgastFeatureDetector> * self1 = 0;
| 806 | if (!pyopencv_AgastFeatureDetector_getp(self, self1)) |  | 806 | if (!pyopencv_AgastFeatureDetector_getp(self, self1))
| 807 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)"); |  | 807 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)");
| 808 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1); |  | 808 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1);
| 809 | int retval; |  | 809 | int retval;
| 810 |  |  | 810 |
| 811 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 811 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 812 | { |  | 812 | {
| 813 | ERRWRAP2(retval = _self_->getThreshold()); |  | 813 | ERRWRAP2(retval = _self_->getThreshold());
| 814 | return pyopencv_from(retval); |  | 814 | return pyopencv_from(retval);
| 815 | } |  | 815 | }
| 816 |  |  | 816 |
| 817 | return NULL; |  | 817 | return NULL;
| 818 | } |  | 818 | }
| 819 |  |  | 819 |
| 820 | static PyObject* pyopencv_cv_AgastFeatureDetector_getType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 820 | static PyObject* pyopencv_cv_AgastFeatureDetector_getType(PyObject* self, PyObject* py_args, PyObject* kw)
| 821 | { |  | 821 | {
| 822 | using namespace cv; |  | 822 | using namespace cv;
| 823 |  |  | 823 |
| 824 |  |  | 824 |
| 825 | Ptr<cv::AgastFeatureDetector> * self1 = 0; |  | 825 | Ptr<cv::AgastFeatureDetector> * self1 = 0;
| 826 | if (!pyopencv_AgastFeatureDetector_getp(self, self1)) |  | 826 | if (!pyopencv_AgastFeatureDetector_getp(self, self1))
| 827 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)"); |  | 827 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)");
| 828 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1); |  | 828 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1);
| 829 | AgastFeatureDetector::DetectorType retval; |  | 829 | AgastFeatureDetector::DetectorType retval;
| 830 |  |  | 830 |
| 831 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 831 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 832 | { |  | 832 | {
| 833 | ERRWRAP2(retval = _self_->getType()); |  | 833 | ERRWRAP2(retval = _self_->getType());
| 834 | return pyopencv_from(retval); |  | 834 | return pyopencv_from(retval);
| 835 | } |  | 835 | }
| 836 |  |  | 836 |
| 837 | return NULL; |  | 837 | return NULL;
| 838 | } |  | 838 | }
| 839 |  |  | 839 |
| 840 | static PyObject* pyopencv_cv_AgastFeatureDetector_setNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw) |  | 840 | static PyObject* pyopencv_cv_AgastFeatureDetector_setNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw)
| 841 | { |  | 841 | {
| 842 | using namespace cv; |  | 842 | using namespace cv;
| 843 |  |  | 843 |
| 844 |  |  | 844 |
| 845 | Ptr<cv::AgastFeatureDetector> * self1 = 0; |  | 845 | Ptr<cv::AgastFeatureDetector> * self1 = 0;
| 846 | if (!pyopencv_AgastFeatureDetector_getp(self, self1)) |  | 846 | if (!pyopencv_AgastFeatureDetector_getp(self, self1))
| 847 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)"); |  | 847 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)");
| 848 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1); |  | 848 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1);
| 849 | PyObject* pyobj_f = NULL; |  | 849 | PyObject* pyobj_f = NULL;
| 850 | bool f=0; |  | 850 | bool f=0;
| 851 |  |  | 851 |
| 852 | const char* keywords[] = { "f", NULL }; |  | 852 | const char* keywords[] = { "f", NULL };
| 853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AgastFeatureDetector.setNonmaxSuppression", (char**)keywords, &pyobj_f) && |  | 853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AgastFeatureDetector.setNonmaxSuppression", (char**)keywords, &pyobj_f) &&
| 854 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) ) |  | 854 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) )
| 855 | { |  | 855 | {
| 856 | ERRWRAP2(_self_->setNonmaxSuppression(f)); |  | 856 | ERRWRAP2(_self_->setNonmaxSuppression(f));
| 857 | Py_RETURN_NONE; |  | 857 | Py_RETURN_NONE;
| 858 | } |  | 858 | }
| 859 |  |  | 859 |
| 860 | return NULL; |  | 860 | return NULL;
| 861 | } |  | 861 | }
| 862 |  |  | 862 |
| 863 | static PyObject* pyopencv_cv_AgastFeatureDetector_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 863 | static PyObject* pyopencv_cv_AgastFeatureDetector_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 864 | { |  | 864 | {
| 865 | using namespace cv; |  | 865 | using namespace cv;
| 866 |  |  | 866 |
| 867 |  |  | 867 |
| 868 | Ptr<cv::AgastFeatureDetector> * self1 = 0; |  | 868 | Ptr<cv::AgastFeatureDetector> * self1 = 0;
| 869 | if (!pyopencv_AgastFeatureDetector_getp(self, self1)) |  | 869 | if (!pyopencv_AgastFeatureDetector_getp(self, self1))
| 870 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)"); |  | 870 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)");
| 871 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1); |  | 871 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1);
| 872 | PyObject* pyobj_threshold = NULL; |  | 872 | PyObject* pyobj_threshold = NULL;
| 873 | int threshold=0; |  | 873 | int threshold=0;
| 874 |  |  | 874 |
| 875 | const char* keywords[] = { "threshold", NULL }; |  | 875 | const char* keywords[] = { "threshold", NULL };
| 876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AgastFeatureDetector.setThreshold", (char**)keywords, &pyobj_threshold) && |  | 876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AgastFeatureDetector.setThreshold", (char**)keywords, &pyobj_threshold) &&
| 877 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 877 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 878 | { |  | 878 | {
| 879 | ERRWRAP2(_self_->setThreshold(threshold)); |  | 879 | ERRWRAP2(_self_->setThreshold(threshold));
| 880 | Py_RETURN_NONE; |  | 880 | Py_RETURN_NONE;
| 881 | } |  | 881 | }
| 882 |  |  | 882 |
| 883 | return NULL; |  | 883 | return NULL;
| 884 | } |  | 884 | }
| 885 |  |  | 885 |
| 886 | static PyObject* pyopencv_cv_AgastFeatureDetector_setType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 886 | static PyObject* pyopencv_cv_AgastFeatureDetector_setType(PyObject* self, PyObject* py_args, PyObject* kw)
| 887 | { |  | 887 | {
| 888 | using namespace cv; |  | 888 | using namespace cv;
| 889 |  |  | 889 |
| 890 |  |  | 890 |
| 891 | Ptr<cv::AgastFeatureDetector> * self1 = 0; |  | 891 | Ptr<cv::AgastFeatureDetector> * self1 = 0;
| 892 | if (!pyopencv_AgastFeatureDetector_getp(self, self1)) |  | 892 | if (!pyopencv_AgastFeatureDetector_getp(self, self1))
| 893 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)"); |  | 893 | return failmsgp("Incorrect type of self (must be 'AgastFeatureDetector' or its derivative)");
| 894 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1); |  | 894 | Ptr<cv::AgastFeatureDetector> _self_ = *(self1);
| 895 | PyObject* pyobj_type = NULL; |  | 895 | PyObject* pyobj_type = NULL;
| 896 | AgastFeatureDetector_DetectorType type=static_cast<AgastFeatureDetector_DetectorType>(0); |  | 896 | AgastFeatureDetector_DetectorType type=static_cast<AgastFeatureDetector_DetectorType>(0);
| 897 |  |  | 897 |
| 898 | const char* keywords[] = { "type", NULL }; |  | 898 | const char* keywords[] = { "type", NULL };
| 899 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AgastFeatureDetector.setType", (char**)keywords, &pyobj_type) && |  | 899 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AgastFeatureDetector.setType", (char**)keywords, &pyobj_type) &&
| 900 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 900 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 901 | { |  | 901 | {
| 902 | ERRWRAP2(_self_->setType(type)); |  | 902 | ERRWRAP2(_self_->setType(type));
| 903 | Py_RETURN_NONE; |  | 903 | Py_RETURN_NONE;
| 904 | } |  | 904 | }
| 905 |  |  | 905 |
| 906 | return NULL; |  | 906 | return NULL;
| 907 | } |  | 907 | }
| 908 |  |  | 908 |
| 909 |  |  | 909 |
| 910 |  |  | 910 |
| 911 | // Tables (AgastFeatureDetector) |  | 911 | // Tables (AgastFeatureDetector)
| 912 |  |  | 912 |
| 913 | static PyGetSetDef pyopencv_AgastFeatureDetector_getseters[] = |  | 913 | static PyGetSetDef pyopencv_AgastFeatureDetector_getseters[] =
| 914 | { |  | 914 | {
| 915 | {NULL} /* Sentinel */ |  | 915 | {NULL} /* Sentinel */
| 916 | }; |  | 916 | };
| 917 |  |  | 917 |
| 918 | static PyMethodDef pyopencv_AgastFeatureDetector_methods[] = |  | 918 | static PyMethodDef pyopencv_AgastFeatureDetector_methods[] =
| 919 | { |  | 919 | {
| 920 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_create_static, METH_STATIC), "create([, threshold[, nonmaxSuppression[, type]]]) -> retval\n."}, |  | 920 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_create_static, METH_STATIC), "create([, threshold[, nonmaxSuppression[, type]]]) -> retval\n."},
| 921 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 921 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 922 | {"getNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getNonmaxSuppression, 0), "getNonmaxSuppression() -> retval\n."}, |  | 922 | {"getNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getNonmaxSuppression, 0), "getNonmaxSuppression() -> retval\n."},
| 923 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getThreshold, 0), "getThreshold() -> retval\n."}, |  | 923 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getThreshold, 0), "getThreshold() -> retval\n."},
| 924 | {"getType", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getType, 0), "getType() -> retval\n."}, |  | 924 | {"getType", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_getType, 0), "getType() -> retval\n."},
| 925 | {"setNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_setNonmaxSuppression, 0), "setNonmaxSuppression(f) -> None\n."}, |  | 925 | {"setNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_setNonmaxSuppression, 0), "setNonmaxSuppression(f) -> None\n."},
| 926 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_setThreshold, 0), "setThreshold(threshold) -> None\n."}, |  | 926 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_setThreshold, 0), "setThreshold(threshold) -> None\n."},
| 927 | {"setType", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_setType, 0), "setType(type) -> None\n."}, |  | 927 | {"setType", CV_PY_FN_WITH_KW_(pyopencv_cv_AgastFeatureDetector_setType, 0), "setType(type) -> None\n."},
| 928 |  |  | 928 |
| 929 | {NULL, NULL} |  | 929 | {NULL, NULL}
| 930 | }; |  | 930 | };
| 931 |  |  | 931 |
| 932 | // Converter (AgastFeatureDetector) |  | 932 | // Converter (AgastFeatureDetector)
| 933 |  |  | 933 |
| 934 | template<> |  | 934 | template<>
| 935 | struct PyOpenCV_Converter< Ptr<cv::AgastFeatureDetector> > |  | 935 | struct PyOpenCV_Converter< Ptr<cv::AgastFeatureDetector> >
| 936 | { |  | 936 | {
| 937 | static PyObject* from(const Ptr<cv::AgastFeatureDetector>& r) |  | 937 | static PyObject* from(const Ptr<cv::AgastFeatureDetector>& r)
| 938 | { |  | 938 | {
| 939 | return pyopencv_AgastFeatureDetector_Instance(r); |  | 939 | return pyopencv_AgastFeatureDetector_Instance(r);
| 940 | } |  | 940 | }
| 941 | static bool to(PyObject* src, Ptr<cv::AgastFeatureDetector>& dst, const ArgInfo& info) |  | 941 | static bool to(PyObject* src, Ptr<cv::AgastFeatureDetector>& dst, const ArgInfo& info)
| 942 | { |  | 942 | {
| 943 | if(!src || src == Py_None) |  | 943 | if(!src || src == Py_None)
| 944 | return true; |  | 944 | return true;
| 945 | Ptr<cv::AgastFeatureDetector> * dst_; |  | 945 | Ptr<cv::AgastFeatureDetector> * dst_;
| 946 | if (pyopencv_AgastFeatureDetector_getp(src, dst_)) |  | 946 | if (pyopencv_AgastFeatureDetector_getp(src, dst_))
| 947 | { |  | 947 | {
| 948 | dst = *dst_; |  | 948 | dst = *dst_;
| 949 | return true; |  | 949 | return true;
| 950 | } |  | 950 | }
| 951 |  |  | 951 |
| 952 | failmsg("Expected Ptr<cv::AgastFeatureDetector> for argument '%s'", info.name); |  | 952 | failmsg("Expected Ptr<cv::AgastFeatureDetector> for argument '%s'", info.name);
| 953 | return false; |  | 953 | return false;
| 954 | } |  | 954 | }
| 955 | }; |  | 955 | };
| 956 |  |  | 956 |
| 957 | //================================================================================ |  | 957 | //================================================================================
| 958 | // Algorithm (Generic) |  | 958 | // Algorithm (Generic)
| 959 | //================================================================================ |  | 959 | //================================================================================
| 960 |  |  | 960 |
| 961 | // GetSet (Algorithm) |  | 961 | // GetSet (Algorithm)
| 962 |  |  | 962 |
| 963 |  |  | 963 |
| 964 |  |  | 964 |
| 965 | // Methods (Algorithm) |  | 965 | // Methods (Algorithm)
| 966 |  |  | 966 |
| 967 | static PyObject* pyopencv_cv_Algorithm_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 967 | static PyObject* pyopencv_cv_Algorithm_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 968 | { |  | 968 | {
| 969 | using namespace cv; |  | 969 | using namespace cv;
| 970 |  |  | 970 |
| 971 |  |  | 971 |
| 972 | Ptr<cv::Algorithm> * self1 = 0; |  | 972 | Ptr<cv::Algorithm> * self1 = 0;
| 973 | if (!pyopencv_Algorithm_getp(self, self1)) |  | 973 | if (!pyopencv_Algorithm_getp(self, self1))
| 974 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)"); |  | 974 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)");
| 975 | Ptr<cv::Algorithm> _self_ = *(self1); |  | 975 | Ptr<cv::Algorithm> _self_ = *(self1);
| 976 |  |  | 976 |
| 977 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 977 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 978 | { |  | 978 | {
| 979 | ERRWRAP2(_self_->clear()); |  | 979 | ERRWRAP2(_self_->clear());
| 980 | Py_RETURN_NONE; |  | 980 | Py_RETURN_NONE;
| 981 | } |  | 981 | }
| 982 |  |  | 982 |
| 983 | return NULL; |  | 983 | return NULL;
| 984 | } |  | 984 | }
| 985 |  |  | 985 |
| 986 | static PyObject* pyopencv_cv_Algorithm_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 986 | static PyObject* pyopencv_cv_Algorithm_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 987 | { |  | 987 | {
| 988 | using namespace cv; |  | 988 | using namespace cv;
| 989 |  |  | 989 |
| 990 |  |  | 990 |
| 991 | Ptr<cv::Algorithm> * self1 = 0; |  | 991 | Ptr<cv::Algorithm> * self1 = 0;
| 992 | if (!pyopencv_Algorithm_getp(self, self1)) |  | 992 | if (!pyopencv_Algorithm_getp(self, self1))
| 993 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)"); |  | 993 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)");
| 994 | Ptr<cv::Algorithm> _self_ = *(self1); |  | 994 | Ptr<cv::Algorithm> _self_ = *(self1);
| 995 | bool retval; |  | 995 | bool retval;
| 996 |  |  | 996 |
| 997 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 997 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 998 | { |  | 998 | {
| 999 | ERRWRAP2(retval = _self_->empty()); |  | 999 | ERRWRAP2(retval = _self_->empty());
| 1000 | return pyopencv_from(retval); |  | 1000 | return pyopencv_from(retval);
| 1001 | } |  | 1001 | }
| 1002 |  |  | 1002 |
| 1003 | return NULL; |  | 1003 | return NULL;
| 1004 | } |  | 1004 | }
| 1005 |  |  | 1005 |
| 1006 | static PyObject* pyopencv_cv_Algorithm_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1006 | static PyObject* pyopencv_cv_Algorithm_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 1007 | { |  | 1007 | {
| 1008 | using namespace cv; |  | 1008 | using namespace cv;
| 1009 |  |  | 1009 |
| 1010 |  |  | 1010 |
| 1011 | Ptr<cv::Algorithm> * self1 = 0; |  | 1011 | Ptr<cv::Algorithm> * self1 = 0;
| 1012 | if (!pyopencv_Algorithm_getp(self, self1)) |  | 1012 | if (!pyopencv_Algorithm_getp(self, self1))
| 1013 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)"); |  | 1013 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)");
| 1014 | Ptr<cv::Algorithm> _self_ = *(self1); |  | 1014 | Ptr<cv::Algorithm> _self_ = *(self1);
| 1015 | String retval; |  | 1015 | String retval;
| 1016 |  |  | 1016 |
| 1017 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 1017 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 1018 | { |  | 1018 | {
| 1019 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 1019 | ERRWRAP2(retval = _self_->getDefaultName());
| 1020 | return pyopencv_from(retval); |  | 1020 | return pyopencv_from(retval);
| 1021 | } |  | 1021 | }
| 1022 |  |  | 1022 |
| 1023 | return NULL; |  | 1023 | return NULL;
| 1024 | } |  | 1024 | }
| 1025 |  |  | 1025 |
| 1026 | static PyObject* pyopencv_cv_Algorithm_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1026 | static PyObject* pyopencv_cv_Algorithm_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 1027 | { |  | 1027 | {
| 1028 | using namespace cv; |  | 1028 | using namespace cv;
| 1029 |  |  | 1029 |
| 1030 |  |  | 1030 |
| 1031 | Ptr<cv::Algorithm> * self1 = 0; |  | 1031 | Ptr<cv::Algorithm> * self1 = 0;
| 1032 | if (!pyopencv_Algorithm_getp(self, self1)) |  | 1032 | if (!pyopencv_Algorithm_getp(self, self1))
| 1033 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)"); |  | 1033 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)");
| 1034 | Ptr<cv::Algorithm> _self_ = *(self1); |  | 1034 | Ptr<cv::Algorithm> _self_ = *(self1);
| 1035 | PyObject* pyobj_fn = NULL; |  | 1035 | PyObject* pyobj_fn = NULL;
| 1036 | cv::FileNode fn; |  | 1036 | cv::FileNode fn;
| 1037 |  |  | 1037 |
| 1038 | const char* keywords[] = { "fn", NULL }; |  | 1038 | const char* keywords[] = { "fn", NULL };
| 1039 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Algorithm.read", (char**)keywords, &pyobj_fn) && |  | 1039 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Algorithm.read", (char**)keywords, &pyobj_fn) &&
| 1040 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 1040 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 1041 | { |  | 1041 | {
| 1042 | ERRWRAP2(_self_->read(fn)); |  | 1042 | ERRWRAP2(_self_->read(fn));
| 1043 | Py_RETURN_NONE; |  | 1043 | Py_RETURN_NONE;
| 1044 | } |  | 1044 | }
| 1045 |  |  | 1045 |
| 1046 | return NULL; |  | 1046 | return NULL;
| 1047 | } |  | 1047 | }
| 1048 |  |  | 1048 |
| 1049 | static PyObject* pyopencv_cv_Algorithm_save(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1049 | static PyObject* pyopencv_cv_Algorithm_save(PyObject* self, PyObject* py_args, PyObject* kw)
| 1050 | { |  | 1050 | {
| 1051 | using namespace cv; |  | 1051 | using namespace cv;
| 1052 |  |  | 1052 |
| 1053 |  |  | 1053 |
| 1054 | Ptr<cv::Algorithm> * self1 = 0; |  | 1054 | Ptr<cv::Algorithm> * self1 = 0;
| 1055 | if (!pyopencv_Algorithm_getp(self, self1)) |  | 1055 | if (!pyopencv_Algorithm_getp(self, self1))
| 1056 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)"); |  | 1056 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)");
| 1057 | Ptr<cv::Algorithm> _self_ = *(self1); |  | 1057 | Ptr<cv::Algorithm> _self_ = *(self1);
| 1058 | PyObject* pyobj_filename = NULL; |  | 1058 | PyObject* pyobj_filename = NULL;
| 1059 | String filename; |  | 1059 | String filename;
| 1060 |  |  | 1060 |
| 1061 | const char* keywords[] = { "filename", NULL }; |  | 1061 | const char* keywords[] = { "filename", NULL };
| 1062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Algorithm.save", (char**)keywords, &pyobj_filename) && |  | 1062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Algorithm.save", (char**)keywords, &pyobj_filename) &&
| 1063 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 1063 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 1064 | { |  | 1064 | {
| 1065 | ERRWRAP2(_self_->save(filename)); |  | 1065 | ERRWRAP2(_self_->save(filename));
| 1066 | Py_RETURN_NONE; |  | 1066 | Py_RETURN_NONE;
| 1067 | } |  | 1067 | }
| 1068 |  |  | 1068 |
| 1069 | return NULL; |  | 1069 | return NULL;
| 1070 | } |  | 1070 | }
| 1071 |  |  | 1071 |
| 1072 | static PyObject* pyopencv_cv_Algorithm_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1072 | static PyObject* pyopencv_cv_Algorithm_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 1073 | { |  | 1073 | {
| 1074 | using namespace cv; |  | 1074 | using namespace cv;
| 1075 |  |  | 1075 |
| 1076 |  |  | 1076 |
| 1077 | Ptr<cv::Algorithm> * self1 = 0; |  | 1077 | Ptr<cv::Algorithm> * self1 = 0;
| 1078 | if (!pyopencv_Algorithm_getp(self, self1)) |  | 1078 | if (!pyopencv_Algorithm_getp(self, self1))
| 1079 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)"); |  | 1079 | return failmsgp("Incorrect type of self (must be 'Algorithm' or its derivative)");
| 1080 | Ptr<cv::Algorithm> _self_ = *(self1); |  | 1080 | Ptr<cv::Algorithm> _self_ = *(self1);
| 1081 | pyPrepareArgumentConversionErrorsStorage(2); |  | 1081 | pyPrepareArgumentConversionErrorsStorage(2);
| 1082 |  |  | 1082 |
| 1083 | { |  | 1083 | {
| 1084 | PyObject* pyobj_fs = NULL; |  | 1084 | PyObject* pyobj_fs = NULL;
| 1085 | Ptr<cv::FileStorage> fs; |  | 1085 | Ptr<cv::FileStorage> fs;
| 1086 |  |  | 1086 |
| 1087 | const char* keywords[] = { "fs", NULL }; |  | 1087 | const char* keywords[] = { "fs", NULL };
| 1088 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Algorithm.write", (char**)keywords, &pyobj_fs) && |  | 1088 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Algorithm.write", (char**)keywords, &pyobj_fs) &&
| 1089 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) ) |  | 1089 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) )
| 1090 | { |  | 1090 | {
| 1091 | ERRWRAP2(_self_->write(*fs)); |  | 1091 | ERRWRAP2(_self_->write(*fs));
| 1092 | Py_RETURN_NONE; |  | 1092 | Py_RETURN_NONE;
| 1093 | } |  | 1093 | }
| 1094 |  |  | 1094 |
| 1095 |  |  | 1095 |
| 1096 | pyPopulateArgumentConversionErrors(); |  | 1096 | pyPopulateArgumentConversionErrors();
| 1097 | } |  | 1097 | }
| 1098 |  |  | 1098 |
| 1099 |  |  | 1099 |
| 1100 | { |  | 1100 | {
| 1101 | PyObject* pyobj_fs = NULL; |  | 1101 | PyObject* pyobj_fs = NULL;
| 1102 | Ptr<cv::FileStorage> fs; |  | 1102 | Ptr<cv::FileStorage> fs;
| 1103 | PyObject* pyobj_name = NULL; |  | 1103 | PyObject* pyobj_name = NULL;
| 1104 | String name; |  | 1104 | String name;
| 1105 |  |  | 1105 |
| 1106 | const char* keywords[] = { "fs", "name", NULL }; |  | 1106 | const char* keywords[] = { "fs", "name", NULL };
| 1107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Algorithm.write", (char**)keywords, &pyobj_fs, &pyobj_name) && |  | 1107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Algorithm.write", (char**)keywords, &pyobj_fs, &pyobj_name) &&
| 1108 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) && |  | 1108 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) &&
| 1109 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 1109 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 1110 | { |  | 1110 | {
| 1111 | ERRWRAP2(_self_->write(*fs, name)); |  | 1111 | ERRWRAP2(_self_->write(*fs, name));
| 1112 | Py_RETURN_NONE; |  | 1112 | Py_RETURN_NONE;
| 1113 | } |  | 1113 | }
| 1114 |  |  | 1114 |
| 1115 |  |  | 1115 |
| 1116 | pyPopulateArgumentConversionErrors(); |  | 1116 | pyPopulateArgumentConversionErrors();
| 1117 | } |  | 1117 | }
| 1118 | pyRaiseCVOverloadException("write"); |  | 1118 | pyRaiseCVOverloadException("write");
| 1119 |  |  | 1119 |
| 1120 | return NULL; |  | 1120 | return NULL;
| 1121 | } |  | 1121 | }
| 1122 |  |  | 1122 |
| 1123 |  |  | 1123 |
| 1124 |  |  | 1124 |
| 1125 | // Tables (Algorithm) |  | 1125 | // Tables (Algorithm)
| 1126 |  |  | 1126 |
| 1127 | static PyGetSetDef pyopencv_Algorithm_getseters[] = |  | 1127 | static PyGetSetDef pyopencv_Algorithm_getseters[] =
| 1128 | { |  | 1128 | {
| 1129 | {NULL} /* Sentinel */ |  | 1129 | {NULL} /* Sentinel */
| 1130 | }; |  | 1130 | };
| 1131 |  |  | 1131 |
| 1132 | static PyMethodDef pyopencv_Algorithm_methods[] = |  | 1132 | static PyMethodDef pyopencv_Algorithm_methods[] =
| 1133 | { |  | 1133 | {
| 1134 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_clear, 0), "clear() -> None\n. @brief Clears the algorithm state"}, |  | 1134 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_clear, 0), "clear() -> None\n. @brief Clears the algorithm state"},
| 1135 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_empty, 0), "empty() -> retval\n. @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read"}, |  | 1135 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_empty, 0), "empty() -> retval\n. @brief Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read"},
| 1136 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_getDefaultName, 0), "getDefaultName() -> retval\n. Returns the algorithm string identifier.\n. This string is used as top level xml/yml node tag when the object is saved to a file or string."}, |  | 1136 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_getDefaultName, 0), "getDefaultName() -> retval\n. Returns the algorithm string identifier.\n. This string is used as top level xml/yml node tag when the object is saved to a file or string."},
| 1137 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_read, 0), "read(fn) -> None\n. @brief Reads algorithm parameters from a file storage"}, |  | 1137 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_read, 0), "read(fn) -> None\n. @brief Reads algorithm parameters from a file storage"},
| 1138 | {"save", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_save, 0), "save(filename) -> None\n. Saves the algorithm to a file.\n. In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs)."}, |  | 1138 | {"save", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_save, 0), "save(filename) -> None\n. Saves the algorithm to a file.\n. In order to make this method work, the derived class must implement Algorithm::write(FileStorage& fs)."},
| 1139 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_write, 0), "write(fs) -> None\n. @brief Stores algorithm parameters in a file storage\n\n\n\nwrite(fs, name) -> None\n. * @overload"}, |  | 1139 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_Algorithm_write, 0), "write(fs) -> None\n. @brief Stores algorithm parameters in a file storage\n\n\n\nwrite(fs, name) -> None\n. * @overload"},
| 1140 |  |  | 1140 |
| 1141 | {NULL, NULL} |  | 1141 | {NULL, NULL}
| 1142 | }; |  | 1142 | };
| 1143 |  |  | 1143 |
| 1144 | // Converter (Algorithm) |  | 1144 | // Converter (Algorithm)
| 1145 |  |  | 1145 |
| 1146 | template<> |  | 1146 | template<>
| 1147 | struct PyOpenCV_Converter< Ptr<cv::Algorithm> > |  | 1147 | struct PyOpenCV_Converter< Ptr<cv::Algorithm> >
| 1148 | { |  | 1148 | {
| 1149 | static PyObject* from(const Ptr<cv::Algorithm>& r) |  | 1149 | static PyObject* from(const Ptr<cv::Algorithm>& r)
| 1150 | { |  | 1150 | {
| 1151 | return pyopencv_Algorithm_Instance(r); |  | 1151 | return pyopencv_Algorithm_Instance(r);
| 1152 | } |  | 1152 | }
| 1153 | static bool to(PyObject* src, Ptr<cv::Algorithm>& dst, const ArgInfo& info) |  | 1153 | static bool to(PyObject* src, Ptr<cv::Algorithm>& dst, const ArgInfo& info)
| 1154 | { |  | 1154 | {
| 1155 | if(!src || src == Py_None) |  | 1155 | if(!src || src == Py_None)
| 1156 | return true; |  | 1156 | return true;
| 1157 | Ptr<cv::Algorithm> * dst_; |  | 1157 | Ptr<cv::Algorithm> * dst_;
| 1158 | if (pyopencv_Algorithm_getp(src, dst_)) |  | 1158 | if (pyopencv_Algorithm_getp(src, dst_))
| 1159 | { |  | 1159 | {
| 1160 | dst = *dst_; |  | 1160 | dst = *dst_;
| 1161 | return true; |  | 1161 | return true;
| 1162 | } |  | 1162 | }
| 1163 |  |  | 1163 |
| 1164 | failmsg("Expected Ptr<cv::Algorithm> for argument '%s'", info.name); |  | 1164 | failmsg("Expected Ptr<cv::Algorithm> for argument '%s'", info.name);
| 1165 | return false; |  | 1165 | return false;
| 1166 | } |  | 1166 | }
| 1167 | }; |  | 1167 | };
| 1168 |  |  | 1168 |
| 1169 | //================================================================================ |  | 1169 | //================================================================================
| 1170 | // AlignExposures (Generic) |  | 1170 | // AlignExposures (Generic)
| 1171 | //================================================================================ |  | 1171 | //================================================================================
| 1172 |  |  | 1172 |
| 1173 | // GetSet (AlignExposures) |  | 1173 | // GetSet (AlignExposures)
| 1174 |  |  | 1174 |
| 1175 |  |  | 1175 |
| 1176 |  |  | 1176 |
| 1177 | // Methods (AlignExposures) |  | 1177 | // Methods (AlignExposures)
| 1178 |  |  | 1178 |
| 1179 | static PyObject* pyopencv_cv_AlignExposures_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1179 | static PyObject* pyopencv_cv_AlignExposures_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 1180 | { |  | 1180 | {
| 1181 | using namespace cv; |  | 1181 | using namespace cv;
| 1182 |  |  | 1182 |
| 1183 |  |  | 1183 |
| 1184 | Ptr<cv::AlignExposures> * self1 = 0; |  | 1184 | Ptr<cv::AlignExposures> * self1 = 0;
| 1185 | if (!pyopencv_AlignExposures_getp(self, self1)) |  | 1185 | if (!pyopencv_AlignExposures_getp(self, self1))
| 1186 | return failmsgp("Incorrect type of self (must be 'AlignExposures' or its derivative)"); |  | 1186 | return failmsgp("Incorrect type of self (must be 'AlignExposures' or its derivative)");
| 1187 | Ptr<cv::AlignExposures> _self_ = *(self1); |  | 1187 | Ptr<cv::AlignExposures> _self_ = *(self1);
| 1188 | pyPrepareArgumentConversionErrorsStorage(2); |  | 1188 | pyPrepareArgumentConversionErrorsStorage(2);
| 1189 |  |  | 1189 |
| 1190 | { |  | 1190 | {
| 1191 | PyObject* pyobj_src = NULL; |  | 1191 | PyObject* pyobj_src = NULL;
| 1192 | vector_Mat src; |  | 1192 | vector_Mat src;
| 1193 | PyObject* pyobj_dst = NULL; |  | 1193 | PyObject* pyobj_dst = NULL;
| 1194 | vector_Mat dst; |  | 1194 | vector_Mat dst;
| 1195 | PyObject* pyobj_times = NULL; |  | 1195 | PyObject* pyobj_times = NULL;
| 1196 | Mat times; |  | 1196 | Mat times;
| 1197 | PyObject* pyobj_response = NULL; |  | 1197 | PyObject* pyobj_response = NULL;
| 1198 | Mat response; |  | 1198 | Mat response;
| 1199 |  |  | 1199 |
| 1200 | const char* keywords[] = { "src", "dst", "times", "response", NULL }; |  | 1200 | const char* keywords[] = { "src", "dst", "times", "response", NULL };
| 1201 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignExposures.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) && |  | 1201 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignExposures.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) &&
| 1202 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1202 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1203 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) && |  | 1203 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) &&
| 1204 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 1204 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 1205 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 1205 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 1206 | { |  | 1206 | {
| 1207 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 1207 | ERRWRAP2(_self_->process(src, dst, times, response));
| 1208 | Py_RETURN_NONE; |  | 1208 | Py_RETURN_NONE;
| 1209 | } |  | 1209 | }
| 1210 |  |  | 1210 |
| 1211 |  |  | 1211 |
| 1212 | pyPopulateArgumentConversionErrors(); |  | 1212 | pyPopulateArgumentConversionErrors();
| 1213 | } |  | 1213 | }
| 1214 |  |  | 1214 |
| 1215 |  |  | 1215 |
| 1216 | { |  | 1216 | {
| 1217 | PyObject* pyobj_src = NULL; |  | 1217 | PyObject* pyobj_src = NULL;
| 1218 | vector_UMat src; |  | 1218 | vector_UMat src;
| 1219 | PyObject* pyobj_dst = NULL; |  | 1219 | PyObject* pyobj_dst = NULL;
| 1220 | vector_Mat dst; |  | 1220 | vector_Mat dst;
| 1221 | PyObject* pyobj_times = NULL; |  | 1221 | PyObject* pyobj_times = NULL;
| 1222 | UMat times; |  | 1222 | UMat times;
| 1223 | PyObject* pyobj_response = NULL; |  | 1223 | PyObject* pyobj_response = NULL;
| 1224 | UMat response; |  | 1224 | UMat response;
| 1225 |  |  | 1225 |
| 1226 | const char* keywords[] = { "src", "dst", "times", "response", NULL }; |  | 1226 | const char* keywords[] = { "src", "dst", "times", "response", NULL };
| 1227 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignExposures.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) && |  | 1227 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignExposures.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) &&
| 1228 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1228 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1229 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) && |  | 1229 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) &&
| 1230 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 1230 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 1231 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 1231 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 1232 | { |  | 1232 | {
| 1233 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 1233 | ERRWRAP2(_self_->process(src, dst, times, response));
| 1234 | Py_RETURN_NONE; |  | 1234 | Py_RETURN_NONE;
| 1235 | } |  | 1235 | }
| 1236 |  |  | 1236 |
| 1237 |  |  | 1237 |
| 1238 | pyPopulateArgumentConversionErrors(); |  | 1238 | pyPopulateArgumentConversionErrors();
| 1239 | } |  | 1239 | }
| 1240 | pyRaiseCVOverloadException("process"); |  | 1240 | pyRaiseCVOverloadException("process");
| 1241 |  |  | 1241 |
| 1242 | return NULL; |  | 1242 | return NULL;
| 1243 | } |  | 1243 | }
| 1244 |  |  | 1244 |
| 1245 |  |  | 1245 |
| 1246 |  |  | 1246 |
| 1247 | // Tables (AlignExposures) |  | 1247 | // Tables (AlignExposures)
| 1248 |  |  | 1248 |
| 1249 | static PyGetSetDef pyopencv_AlignExposures_getseters[] = |  | 1249 | static PyGetSetDef pyopencv_AlignExposures_getseters[] =
| 1250 | { |  | 1250 | {
| 1251 | {NULL} /* Sentinel */ |  | 1251 | {NULL} /* Sentinel */
| 1252 | }; |  | 1252 | };
| 1253 |  |  | 1253 |
| 1254 | static PyMethodDef pyopencv_AlignExposures_methods[] = |  | 1254 | static PyMethodDef pyopencv_AlignExposures_methods[] =
| 1255 | { |  | 1255 | {
| 1256 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignExposures_process, 0), "process(src, dst, times, response) -> None\n. @brief Aligns images\n. \n. @param src vector of input images\n. @param dst vector of aligned images\n. @param times vector of exposure time values for each image\n. @param response 256x1 matrix with inverse camera response function for each pixel value, it should\n. have the same number of channels as images."}, |  | 1256 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignExposures_process, 0), "process(src, dst, times, response) -> None\n. @brief Aligns images\n. \n. @param src vector of input images\n. @param dst vector of aligned images\n. @param times vector of exposure time values for each image\n. @param response 256x1 matrix with inverse camera response function for each pixel value, it should\n. have the same number of channels as images."},
| 1257 |  |  | 1257 |
| 1258 | {NULL, NULL} |  | 1258 | {NULL, NULL}
| 1259 | }; |  | 1259 | };
| 1260 |  |  | 1260 |
| 1261 | // Converter (AlignExposures) |  | 1261 | // Converter (AlignExposures)
| 1262 |  |  | 1262 |
| 1263 | template<> |  | 1263 | template<>
| 1264 | struct PyOpenCV_Converter< Ptr<cv::AlignExposures> > |  | 1264 | struct PyOpenCV_Converter< Ptr<cv::AlignExposures> >
| 1265 | { |  | 1265 | {
| 1266 | static PyObject* from(const Ptr<cv::AlignExposures>& r) |  | 1266 | static PyObject* from(const Ptr<cv::AlignExposures>& r)
| 1267 | { |  | 1267 | {
| 1268 | return pyopencv_AlignExposures_Instance(r); |  | 1268 | return pyopencv_AlignExposures_Instance(r);
| 1269 | } |  | 1269 | }
| 1270 | static bool to(PyObject* src, Ptr<cv::AlignExposures>& dst, const ArgInfo& info) |  | 1270 | static bool to(PyObject* src, Ptr<cv::AlignExposures>& dst, const ArgInfo& info)
| 1271 | { |  | 1271 | {
| 1272 | if(!src || src == Py_None) |  | 1272 | if(!src || src == Py_None)
| 1273 | return true; |  | 1273 | return true;
| 1274 | Ptr<cv::AlignExposures> * dst_; |  | 1274 | Ptr<cv::AlignExposures> * dst_;
| 1275 | if (pyopencv_AlignExposures_getp(src, dst_)) |  | 1275 | if (pyopencv_AlignExposures_getp(src, dst_))
| 1276 | { |  | 1276 | {
| 1277 | dst = *dst_; |  | 1277 | dst = *dst_;
| 1278 | return true; |  | 1278 | return true;
| 1279 | } |  | 1279 | }
| 1280 |  |  | 1280 |
| 1281 | failmsg("Expected Ptr<cv::AlignExposures> for argument '%s'", info.name); |  | 1281 | failmsg("Expected Ptr<cv::AlignExposures> for argument '%s'", info.name);
| 1282 | return false; |  | 1282 | return false;
| 1283 | } |  | 1283 | }
| 1284 | }; |  | 1284 | };
| 1285 |  |  | 1285 |
| 1286 | //================================================================================ |  | 1286 | //================================================================================
| 1287 | // AlignMTB (Generic) |  | 1287 | // AlignMTB (Generic)
| 1288 | //================================================================================ |  | 1288 | //================================================================================
| 1289 |  |  | 1289 |
| 1290 | // GetSet (AlignMTB) |  | 1290 | // GetSet (AlignMTB)
| 1291 |  |  | 1291 |
| 1292 |  |  | 1292 |
| 1293 |  |  | 1293 |
| 1294 | // Methods (AlignMTB) |  | 1294 | // Methods (AlignMTB)
| 1295 |  |  | 1295 |
| 1296 | static PyObject* pyopencv_cv_AlignMTB_calculateShift(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1296 | static PyObject* pyopencv_cv_AlignMTB_calculateShift(PyObject* self, PyObject* py_args, PyObject* kw)
| 1297 | { |  | 1297 | {
| 1298 | using namespace cv; |  | 1298 | using namespace cv;
| 1299 |  |  | 1299 |
| 1300 |  |  | 1300 |
| 1301 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1301 | Ptr<cv::AlignMTB> * self1 = 0;
| 1302 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1302 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1303 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1303 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1304 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1304 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1305 | pyPrepareArgumentConversionErrorsStorage(2); |  | 1305 | pyPrepareArgumentConversionErrorsStorage(2);
| 1306 |  |  | 1306 |
| 1307 | { |  | 1307 | {
| 1308 | PyObject* pyobj_img0 = NULL; |  | 1308 | PyObject* pyobj_img0 = NULL;
| 1309 | Mat img0; |  | 1309 | Mat img0;
| 1310 | PyObject* pyobj_img1 = NULL; |  | 1310 | PyObject* pyobj_img1 = NULL;
| 1311 | Mat img1; |  | 1311 | Mat img1;
| 1312 | Point retval; |  | 1312 | Point retval;
| 1313 |  |  | 1313 |
| 1314 | const char* keywords[] = { "img0", "img1", NULL }; |  | 1314 | const char* keywords[] = { "img0", "img1", NULL };
| 1315 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.calculateShift", (char**)keywords, &pyobj_img0, &pyobj_img1) && |  | 1315 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.calculateShift", (char**)keywords, &pyobj_img0, &pyobj_img1) &&
| 1316 | pyopencv_to_safe(pyobj_img0, img0, ArgInfo("img0", 0)) && |  | 1316 | pyopencv_to_safe(pyobj_img0, img0, ArgInfo("img0", 0)) &&
| 1317 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) ) |  | 1317 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) )
| 1318 | { |  | 1318 | {
| 1319 | ERRWRAP2(retval = _self_->calculateShift(img0, img1)); |  | 1319 | ERRWRAP2(retval = _self_->calculateShift(img0, img1));
| 1320 | return pyopencv_from(retval); |  | 1320 | return pyopencv_from(retval);
| 1321 | } |  | 1321 | }
| 1322 |  |  | 1322 |
| 1323 |  |  | 1323 |
| 1324 | pyPopulateArgumentConversionErrors(); |  | 1324 | pyPopulateArgumentConversionErrors();
| 1325 | } |  | 1325 | }
| 1326 |  |  | 1326 |
| 1327 |  |  | 1327 |
| 1328 | { |  | 1328 | {
| 1329 | PyObject* pyobj_img0 = NULL; |  | 1329 | PyObject* pyobj_img0 = NULL;
| 1330 | UMat img0; |  | 1330 | UMat img0;
| 1331 | PyObject* pyobj_img1 = NULL; |  | 1331 | PyObject* pyobj_img1 = NULL;
| 1332 | UMat img1; |  | 1332 | UMat img1;
| 1333 | Point retval; |  | 1333 | Point retval;
| 1334 |  |  | 1334 |
| 1335 | const char* keywords[] = { "img0", "img1", NULL }; |  | 1335 | const char* keywords[] = { "img0", "img1", NULL };
| 1336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.calculateShift", (char**)keywords, &pyobj_img0, &pyobj_img1) && |  | 1336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.calculateShift", (char**)keywords, &pyobj_img0, &pyobj_img1) &&
| 1337 | pyopencv_to_safe(pyobj_img0, img0, ArgInfo("img0", 0)) && |  | 1337 | pyopencv_to_safe(pyobj_img0, img0, ArgInfo("img0", 0)) &&
| 1338 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) ) |  | 1338 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) )
| 1339 | { |  | 1339 | {
| 1340 | ERRWRAP2(retval = _self_->calculateShift(img0, img1)); |  | 1340 | ERRWRAP2(retval = _self_->calculateShift(img0, img1));
| 1341 | return pyopencv_from(retval); |  | 1341 | return pyopencv_from(retval);
| 1342 | } |  | 1342 | }
| 1343 |  |  | 1343 |
| 1344 |  |  | 1344 |
| 1345 | pyPopulateArgumentConversionErrors(); |  | 1345 | pyPopulateArgumentConversionErrors();
| 1346 | } |  | 1346 | }
| 1347 | pyRaiseCVOverloadException("calculateShift"); |  | 1347 | pyRaiseCVOverloadException("calculateShift");
| 1348 |  |  | 1348 |
| 1349 | return NULL; |  | 1349 | return NULL;
| 1350 | } |  | 1350 | }
| 1351 |  |  | 1351 |
| 1352 | static PyObject* pyopencv_cv_AlignMTB_computeBitmaps(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1352 | static PyObject* pyopencv_cv_AlignMTB_computeBitmaps(PyObject* self, PyObject* py_args, PyObject* kw)
| 1353 | { |  | 1353 | {
| 1354 | using namespace cv; |  | 1354 | using namespace cv;
| 1355 |  |  | 1355 |
| 1356 |  |  | 1356 |
| 1357 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1357 | Ptr<cv::AlignMTB> * self1 = 0;
| 1358 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1358 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1359 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1359 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1360 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1360 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1361 | pyPrepareArgumentConversionErrorsStorage(2); |  | 1361 | pyPrepareArgumentConversionErrorsStorage(2);
| 1362 |  |  | 1362 |
| 1363 | { |  | 1363 | {
| 1364 | PyObject* pyobj_img = NULL; |  | 1364 | PyObject* pyobj_img = NULL;
| 1365 | Mat img; |  | 1365 | Mat img;
| 1366 | PyObject* pyobj_tb = NULL; |  | 1366 | PyObject* pyobj_tb = NULL;
| 1367 | Mat tb; |  | 1367 | Mat tb;
| 1368 | PyObject* pyobj_eb = NULL; |  | 1368 | PyObject* pyobj_eb = NULL;
| 1369 | Mat eb; |  | 1369 | Mat eb;
| 1370 |  |  | 1370 |
| 1371 | const char* keywords[] = { "img", "tb", "eb", NULL }; |  | 1371 | const char* keywords[] = { "img", "tb", "eb", NULL };
| 1372 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:AlignMTB.computeBitmaps", (char**)keywords, &pyobj_img, &pyobj_tb, &pyobj_eb) && |  | 1372 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:AlignMTB.computeBitmaps", (char**)keywords, &pyobj_img, &pyobj_tb, &pyobj_eb) &&
| 1373 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 1373 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 1374 | pyopencv_to_safe(pyobj_tb, tb, ArgInfo("tb", 1)) && |  | 1374 | pyopencv_to_safe(pyobj_tb, tb, ArgInfo("tb", 1)) &&
| 1375 | pyopencv_to_safe(pyobj_eb, eb, ArgInfo("eb", 1)) ) |  | 1375 | pyopencv_to_safe(pyobj_eb, eb, ArgInfo("eb", 1)) )
| 1376 | { |  | 1376 | {
| 1377 | ERRWRAP2(_self_->computeBitmaps(img, tb, eb)); |  | 1377 | ERRWRAP2(_self_->computeBitmaps(img, tb, eb));
| 1378 | return Py_BuildValue("(NN)", pyopencv_from(tb), pyopencv_from(eb)); |  | 1378 | return Py_BuildValue("(NN)", pyopencv_from(tb), pyopencv_from(eb));
| 1379 | } |  | 1379 | }
| 1380 |  |  | 1380 |
| 1381 |  |  | 1381 |
| 1382 | pyPopulateArgumentConversionErrors(); |  | 1382 | pyPopulateArgumentConversionErrors();
| 1383 | } |  | 1383 | }
| 1384 |  |  | 1384 |
| 1385 |  |  | 1385 |
| 1386 | { |  | 1386 | {
| 1387 | PyObject* pyobj_img = NULL; |  | 1387 | PyObject* pyobj_img = NULL;
| 1388 | UMat img; |  | 1388 | UMat img;
| 1389 | PyObject* pyobj_tb = NULL; |  | 1389 | PyObject* pyobj_tb = NULL;
| 1390 | UMat tb; |  | 1390 | UMat tb;
| 1391 | PyObject* pyobj_eb = NULL; |  | 1391 | PyObject* pyobj_eb = NULL;
| 1392 | UMat eb; |  | 1392 | UMat eb;
| 1393 |  |  | 1393 |
| 1394 | const char* keywords[] = { "img", "tb", "eb", NULL }; |  | 1394 | const char* keywords[] = { "img", "tb", "eb", NULL };
| 1395 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:AlignMTB.computeBitmaps", (char**)keywords, &pyobj_img, &pyobj_tb, &pyobj_eb) && |  | 1395 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:AlignMTB.computeBitmaps", (char**)keywords, &pyobj_img, &pyobj_tb, &pyobj_eb) &&
| 1396 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 1396 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 1397 | pyopencv_to_safe(pyobj_tb, tb, ArgInfo("tb", 1)) && |  | 1397 | pyopencv_to_safe(pyobj_tb, tb, ArgInfo("tb", 1)) &&
| 1398 | pyopencv_to_safe(pyobj_eb, eb, ArgInfo("eb", 1)) ) |  | 1398 | pyopencv_to_safe(pyobj_eb, eb, ArgInfo("eb", 1)) )
| 1399 | { |  | 1399 | {
| 1400 | ERRWRAP2(_self_->computeBitmaps(img, tb, eb)); |  | 1400 | ERRWRAP2(_self_->computeBitmaps(img, tb, eb));
| 1401 | return Py_BuildValue("(NN)", pyopencv_from(tb), pyopencv_from(eb)); |  | 1401 | return Py_BuildValue("(NN)", pyopencv_from(tb), pyopencv_from(eb));
| 1402 | } |  | 1402 | }
| 1403 |  |  | 1403 |
| 1404 |  |  | 1404 |
| 1405 | pyPopulateArgumentConversionErrors(); |  | 1405 | pyPopulateArgumentConversionErrors();
| 1406 | } |  | 1406 | }
| 1407 | pyRaiseCVOverloadException("computeBitmaps"); |  | 1407 | pyRaiseCVOverloadException("computeBitmaps");
| 1408 |  |  | 1408 |
| 1409 | return NULL; |  | 1409 | return NULL;
| 1410 | } |  | 1410 | }
| 1411 |  |  | 1411 |
| 1412 | static PyObject* pyopencv_cv_AlignMTB_getCut(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1412 | static PyObject* pyopencv_cv_AlignMTB_getCut(PyObject* self, PyObject* py_args, PyObject* kw)
| 1413 | { |  | 1413 | {
| 1414 | using namespace cv; |  | 1414 | using namespace cv;
| 1415 |  |  | 1415 |
| 1416 |  |  | 1416 |
| 1417 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1417 | Ptr<cv::AlignMTB> * self1 = 0;
| 1418 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1418 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1419 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1419 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1420 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1420 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1421 | bool retval; |  | 1421 | bool retval;
| 1422 |  |  | 1422 |
| 1423 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 1423 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 1424 | { |  | 1424 | {
| 1425 | ERRWRAP2(retval = _self_->getCut()); |  | 1425 | ERRWRAP2(retval = _self_->getCut());
| 1426 | return pyopencv_from(retval); |  | 1426 | return pyopencv_from(retval);
| 1427 | } |  | 1427 | }
| 1428 |  |  | 1428 |
| 1429 | return NULL; |  | 1429 | return NULL;
| 1430 | } |  | 1430 | }
| 1431 |  |  | 1431 |
| 1432 | static PyObject* pyopencv_cv_AlignMTB_getExcludeRange(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1432 | static PyObject* pyopencv_cv_AlignMTB_getExcludeRange(PyObject* self, PyObject* py_args, PyObject* kw)
| 1433 | { |  | 1433 | {
| 1434 | using namespace cv; |  | 1434 | using namespace cv;
| 1435 |  |  | 1435 |
| 1436 |  |  | 1436 |
| 1437 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1437 | Ptr<cv::AlignMTB> * self1 = 0;
| 1438 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1438 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1439 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1439 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1440 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1440 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1441 | int retval; |  | 1441 | int retval;
| 1442 |  |  | 1442 |
| 1443 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 1443 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 1444 | { |  | 1444 | {
| 1445 | ERRWRAP2(retval = _self_->getExcludeRange()); |  | 1445 | ERRWRAP2(retval = _self_->getExcludeRange());
| 1446 | return pyopencv_from(retval); |  | 1446 | return pyopencv_from(retval);
| 1447 | } |  | 1447 | }
| 1448 |  |  | 1448 |
| 1449 | return NULL; |  | 1449 | return NULL;
| 1450 | } |  | 1450 | }
| 1451 |  |  | 1451 |
| 1452 | static PyObject* pyopencv_cv_AlignMTB_getMaxBits(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1452 | static PyObject* pyopencv_cv_AlignMTB_getMaxBits(PyObject* self, PyObject* py_args, PyObject* kw)
| 1453 | { |  | 1453 | {
| 1454 | using namespace cv; |  | 1454 | using namespace cv;
| 1455 |  |  | 1455 |
| 1456 |  |  | 1456 |
| 1457 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1457 | Ptr<cv::AlignMTB> * self1 = 0;
| 1458 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1458 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1459 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1459 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1460 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1460 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1461 | int retval; |  | 1461 | int retval;
| 1462 |  |  | 1462 |
| 1463 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 1463 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 1464 | { |  | 1464 | {
| 1465 | ERRWRAP2(retval = _self_->getMaxBits()); |  | 1465 | ERRWRAP2(retval = _self_->getMaxBits());
| 1466 | return pyopencv_from(retval); |  | 1466 | return pyopencv_from(retval);
| 1467 | } |  | 1467 | }
| 1468 |  |  | 1468 |
| 1469 | return NULL; |  | 1469 | return NULL;
| 1470 | } |  | 1470 | }
| 1471 |  |  | 1471 |
| 1472 | static PyObject* pyopencv_cv_AlignMTB_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1472 | static PyObject* pyopencv_cv_AlignMTB_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 1473 | { |  | 1473 | {
| 1474 | using namespace cv; |  | 1474 | using namespace cv;
| 1475 |  |  | 1475 |
| 1476 |  |  | 1476 |
| 1477 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1477 | Ptr<cv::AlignMTB> * self1 = 0;
| 1478 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1478 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1479 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1479 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1480 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1480 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1481 | pyPrepareArgumentConversionErrorsStorage(4); |  | 1481 | pyPrepareArgumentConversionErrorsStorage(4);
| 1482 |  |  | 1482 |
| 1483 | { |  | 1483 | {
| 1484 | PyObject* pyobj_src = NULL; |  | 1484 | PyObject* pyobj_src = NULL;
| 1485 | vector_Mat src; |  | 1485 | vector_Mat src;
| 1486 | PyObject* pyobj_dst = NULL; |  | 1486 | PyObject* pyobj_dst = NULL;
| 1487 | vector_Mat dst; |  | 1487 | vector_Mat dst;
| 1488 | PyObject* pyobj_times = NULL; |  | 1488 | PyObject* pyobj_times = NULL;
| 1489 | Mat times; |  | 1489 | Mat times;
| 1490 | PyObject* pyobj_response = NULL; |  | 1490 | PyObject* pyobj_response = NULL;
| 1491 | Mat response; |  | 1491 | Mat response;
| 1492 |  |  | 1492 |
| 1493 | const char* keywords[] = { "src", "dst", "times", "response", NULL }; |  | 1493 | const char* keywords[] = { "src", "dst", "times", "response", NULL };
| 1494 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) && |  | 1494 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) &&
| 1495 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1495 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1496 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) && |  | 1496 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) &&
| 1497 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 1497 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 1498 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 1498 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 1499 | { |  | 1499 | {
| 1500 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 1500 | ERRWRAP2(_self_->process(src, dst, times, response));
| 1501 | Py_RETURN_NONE; |  | 1501 | Py_RETURN_NONE;
| 1502 | } |  | 1502 | }
| 1503 |  |  | 1503 |
| 1504 |  |  | 1504 |
| 1505 | pyPopulateArgumentConversionErrors(); |  | 1505 | pyPopulateArgumentConversionErrors();
| 1506 | } |  | 1506 | }
| 1507 |  |  | 1507 |
| 1508 |  |  | 1508 |
| 1509 | { |  | 1509 | {
| 1510 | PyObject* pyobj_src = NULL; |  | 1510 | PyObject* pyobj_src = NULL;
| 1511 | vector_Mat src; |  | 1511 | vector_Mat src;
| 1512 | PyObject* pyobj_dst = NULL; |  | 1512 | PyObject* pyobj_dst = NULL;
| 1513 | vector_Mat dst; |  | 1513 | vector_Mat dst;
| 1514 |  |  | 1514 |
| 1515 | const char* keywords[] = { "src", "dst", NULL }; |  | 1515 | const char* keywords[] = { "src", "dst", NULL };
| 1516 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 1516 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 1517 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1517 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1518 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) ) |  | 1518 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) )
| 1519 | { |  | 1519 | {
| 1520 | ERRWRAP2(_self_->process(src, dst)); |  | 1520 | ERRWRAP2(_self_->process(src, dst));
| 1521 | Py_RETURN_NONE; |  | 1521 | Py_RETURN_NONE;
| 1522 | } |  | 1522 | }
| 1523 |  |  | 1523 |
| 1524 |  |  | 1524 |
| 1525 | pyPopulateArgumentConversionErrors(); |  | 1525 | pyPopulateArgumentConversionErrors();
| 1526 | } |  | 1526 | }
| 1527 |  |  | 1527 |
| 1528 |  |  | 1528 |
| 1529 | { |  | 1529 | {
| 1530 | PyObject* pyobj_src = NULL; |  | 1530 | PyObject* pyobj_src = NULL;
| 1531 | vector_UMat src; |  | 1531 | vector_UMat src;
| 1532 | PyObject* pyobj_dst = NULL; |  | 1532 | PyObject* pyobj_dst = NULL;
| 1533 | vector_Mat dst; |  | 1533 | vector_Mat dst;
| 1534 | PyObject* pyobj_times = NULL; |  | 1534 | PyObject* pyobj_times = NULL;
| 1535 | UMat times; |  | 1535 | UMat times;
| 1536 | PyObject* pyobj_response = NULL; |  | 1536 | PyObject* pyobj_response = NULL;
| 1537 | UMat response; |  | 1537 | UMat response;
| 1538 |  |  | 1538 |
| 1539 | const char* keywords[] = { "src", "dst", "times", "response", NULL }; |  | 1539 | const char* keywords[] = { "src", "dst", "times", "response", NULL };
| 1540 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) && |  | 1540 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst, &pyobj_times, &pyobj_response) &&
| 1541 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1541 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1542 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) && |  | 1542 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) &&
| 1543 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 1543 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 1544 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 1544 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 1545 | { |  | 1545 | {
| 1546 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 1546 | ERRWRAP2(_self_->process(src, dst, times, response));
| 1547 | Py_RETURN_NONE; |  | 1547 | Py_RETURN_NONE;
| 1548 | } |  | 1548 | }
| 1549 |  |  | 1549 |
| 1550 |  |  | 1550 |
| 1551 | pyPopulateArgumentConversionErrors(); |  | 1551 | pyPopulateArgumentConversionErrors();
| 1552 | } |  | 1552 | }
| 1553 |  |  | 1553 |
| 1554 |  |  | 1554 |
| 1555 | { |  | 1555 | {
| 1556 | PyObject* pyobj_src = NULL; |  | 1556 | PyObject* pyobj_src = NULL;
| 1557 | vector_UMat src; |  | 1557 | vector_UMat src;
| 1558 | PyObject* pyobj_dst = NULL; |  | 1558 | PyObject* pyobj_dst = NULL;
| 1559 | vector_Mat dst; |  | 1559 | vector_Mat dst;
| 1560 |  |  | 1560 |
| 1561 | const char* keywords[] = { "src", "dst", NULL }; |  | 1561 | const char* keywords[] = { "src", "dst", NULL };
| 1562 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 1562 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:AlignMTB.process", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 1563 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1563 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1564 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) ) |  | 1564 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 0)) )
| 1565 | { |  | 1565 | {
| 1566 | ERRWRAP2(_self_->process(src, dst)); |  | 1566 | ERRWRAP2(_self_->process(src, dst));
| 1567 | Py_RETURN_NONE; |  | 1567 | Py_RETURN_NONE;
| 1568 | } |  | 1568 | }
| 1569 |  |  | 1569 |
| 1570 |  |  | 1570 |
| 1571 | pyPopulateArgumentConversionErrors(); |  | 1571 | pyPopulateArgumentConversionErrors();
| 1572 | } |  | 1572 | }
| 1573 | pyRaiseCVOverloadException("process"); |  | 1573 | pyRaiseCVOverloadException("process");
| 1574 |  |  | 1574 |
| 1575 | return NULL; |  | 1575 | return NULL;
| 1576 | } |  | 1576 | }
| 1577 |  |  | 1577 |
| 1578 | static PyObject* pyopencv_cv_AlignMTB_setCut(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1578 | static PyObject* pyopencv_cv_AlignMTB_setCut(PyObject* self, PyObject* py_args, PyObject* kw)
| 1579 | { |  | 1579 | {
| 1580 | using namespace cv; |  | 1580 | using namespace cv;
| 1581 |  |  | 1581 |
| 1582 |  |  | 1582 |
| 1583 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1583 | Ptr<cv::AlignMTB> * self1 = 0;
| 1584 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1584 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1585 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1585 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1586 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1586 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1587 | PyObject* pyobj_value = NULL; |  | 1587 | PyObject* pyobj_value = NULL;
| 1588 | bool value=0; |  | 1588 | bool value=0;
| 1589 |  |  | 1589 |
| 1590 | const char* keywords[] = { "value", NULL }; |  | 1590 | const char* keywords[] = { "value", NULL };
| 1591 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AlignMTB.setCut", (char**)keywords, &pyobj_value) && |  | 1591 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AlignMTB.setCut", (char**)keywords, &pyobj_value) &&
| 1592 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 1592 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 1593 | { |  | 1593 | {
| 1594 | ERRWRAP2(_self_->setCut(value)); |  | 1594 | ERRWRAP2(_self_->setCut(value));
| 1595 | Py_RETURN_NONE; |  | 1595 | Py_RETURN_NONE;
| 1596 | } |  | 1596 | }
| 1597 |  |  | 1597 |
| 1598 | return NULL; |  | 1598 | return NULL;
| 1599 | } |  | 1599 | }
| 1600 |  |  | 1600 |
| 1601 | static PyObject* pyopencv_cv_AlignMTB_setExcludeRange(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1601 | static PyObject* pyopencv_cv_AlignMTB_setExcludeRange(PyObject* self, PyObject* py_args, PyObject* kw)
| 1602 | { |  | 1602 | {
| 1603 | using namespace cv; |  | 1603 | using namespace cv;
| 1604 |  |  | 1604 |
| 1605 |  |  | 1605 |
| 1606 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1606 | Ptr<cv::AlignMTB> * self1 = 0;
| 1607 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1607 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1608 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1608 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1609 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1609 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1610 | PyObject* pyobj_exclude_range = NULL; |  | 1610 | PyObject* pyobj_exclude_range = NULL;
| 1611 | int exclude_range=0; |  | 1611 | int exclude_range=0;
| 1612 |  |  | 1612 |
| 1613 | const char* keywords[] = { "exclude_range", NULL }; |  | 1613 | const char* keywords[] = { "exclude_range", NULL };
| 1614 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AlignMTB.setExcludeRange", (char**)keywords, &pyobj_exclude_range) && |  | 1614 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AlignMTB.setExcludeRange", (char**)keywords, &pyobj_exclude_range) &&
| 1615 | pyopencv_to_safe(pyobj_exclude_range, exclude_range, ArgInfo("exclude_range", 0)) ) |  | 1615 | pyopencv_to_safe(pyobj_exclude_range, exclude_range, ArgInfo("exclude_range", 0)) )
| 1616 | { |  | 1616 | {
| 1617 | ERRWRAP2(_self_->setExcludeRange(exclude_range)); |  | 1617 | ERRWRAP2(_self_->setExcludeRange(exclude_range));
| 1618 | Py_RETURN_NONE; |  | 1618 | Py_RETURN_NONE;
| 1619 | } |  | 1619 | }
| 1620 |  |  | 1620 |
| 1621 | return NULL; |  | 1621 | return NULL;
| 1622 | } |  | 1622 | }
| 1623 |  |  | 1623 |
| 1624 | static PyObject* pyopencv_cv_AlignMTB_setMaxBits(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1624 | static PyObject* pyopencv_cv_AlignMTB_setMaxBits(PyObject* self, PyObject* py_args, PyObject* kw)
| 1625 | { |  | 1625 | {
| 1626 | using namespace cv; |  | 1626 | using namespace cv;
| 1627 |  |  | 1627 |
| 1628 |  |  | 1628 |
| 1629 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1629 | Ptr<cv::AlignMTB> * self1 = 0;
| 1630 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1630 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1631 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1631 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1632 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1632 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1633 | PyObject* pyobj_max_bits = NULL; |  | 1633 | PyObject* pyobj_max_bits = NULL;
| 1634 | int max_bits=0; |  | 1634 | int max_bits=0;
| 1635 |  |  | 1635 |
| 1636 | const char* keywords[] = { "max_bits", NULL }; |  | 1636 | const char* keywords[] = { "max_bits", NULL };
| 1637 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AlignMTB.setMaxBits", (char**)keywords, &pyobj_max_bits) && |  | 1637 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AlignMTB.setMaxBits", (char**)keywords, &pyobj_max_bits) &&
| 1638 | pyopencv_to_safe(pyobj_max_bits, max_bits, ArgInfo("max_bits", 0)) ) |  | 1638 | pyopencv_to_safe(pyobj_max_bits, max_bits, ArgInfo("max_bits", 0)) )
| 1639 | { |  | 1639 | {
| 1640 | ERRWRAP2(_self_->setMaxBits(max_bits)); |  | 1640 | ERRWRAP2(_self_->setMaxBits(max_bits));
| 1641 | Py_RETURN_NONE; |  | 1641 | Py_RETURN_NONE;
| 1642 | } |  | 1642 | }
| 1643 |  |  | 1643 |
| 1644 | return NULL; |  | 1644 | return NULL;
| 1645 | } |  | 1645 | }
| 1646 |  |  | 1646 |
| 1647 | static PyObject* pyopencv_cv_AlignMTB_shiftMat(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1647 | static PyObject* pyopencv_cv_AlignMTB_shiftMat(PyObject* self, PyObject* py_args, PyObject* kw)
| 1648 | { |  | 1648 | {
| 1649 | using namespace cv; |  | 1649 | using namespace cv;
| 1650 |  |  | 1650 |
| 1651 |  |  | 1651 |
| 1652 | Ptr<cv::AlignMTB> * self1 = 0; |  | 1652 | Ptr<cv::AlignMTB> * self1 = 0;
| 1653 | if (!pyopencv_AlignMTB_getp(self, self1)) |  | 1653 | if (!pyopencv_AlignMTB_getp(self, self1))
| 1654 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)"); |  | 1654 | return failmsgp("Incorrect type of self (must be 'AlignMTB' or its derivative)");
| 1655 | Ptr<cv::AlignMTB> _self_ = *(self1); |  | 1655 | Ptr<cv::AlignMTB> _self_ = *(self1);
| 1656 | pyPrepareArgumentConversionErrorsStorage(2); |  | 1656 | pyPrepareArgumentConversionErrorsStorage(2);
| 1657 |  |  | 1657 |
| 1658 | { |  | 1658 | {
| 1659 | PyObject* pyobj_src = NULL; |  | 1659 | PyObject* pyobj_src = NULL;
| 1660 | Mat src; |  | 1660 | Mat src;
| 1661 | PyObject* pyobj_dst = NULL; |  | 1661 | PyObject* pyobj_dst = NULL;
| 1662 | Mat dst; |  | 1662 | Mat dst;
| 1663 | PyObject* pyobj_shift = NULL; |  | 1663 | PyObject* pyobj_shift = NULL;
| 1664 | Point shift; |  | 1664 | Point shift;
| 1665 |  |  | 1665 |
| 1666 | const char* keywords[] = { "src", "shift", "dst", NULL }; |  | 1666 | const char* keywords[] = { "src", "shift", "dst", NULL };
| 1667 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:AlignMTB.shiftMat", (char**)keywords, &pyobj_src, &pyobj_shift, &pyobj_dst) && |  | 1667 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:AlignMTB.shiftMat", (char**)keywords, &pyobj_src, &pyobj_shift, &pyobj_dst) &&
| 1668 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1668 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1669 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 1669 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 1670 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) ) |  | 1670 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) )
| 1671 | { |  | 1671 | {
| 1672 | ERRWRAP2(_self_->shiftMat(src, dst, shift)); |  | 1672 | ERRWRAP2(_self_->shiftMat(src, dst, shift));
| 1673 | return pyopencv_from(dst); |  | 1673 | return pyopencv_from(dst);
| 1674 | } |  | 1674 | }
| 1675 |  |  | 1675 |
| 1676 |  |  | 1676 |
| 1677 | pyPopulateArgumentConversionErrors(); |  | 1677 | pyPopulateArgumentConversionErrors();
| 1678 | } |  | 1678 | }
| 1679 |  |  | 1679 |
| 1680 |  |  | 1680 |
| 1681 | { |  | 1681 | {
| 1682 | PyObject* pyobj_src = NULL; |  | 1682 | PyObject* pyobj_src = NULL;
| 1683 | UMat src; |  | 1683 | UMat src;
| 1684 | PyObject* pyobj_dst = NULL; |  | 1684 | PyObject* pyobj_dst = NULL;
| 1685 | UMat dst; |  | 1685 | UMat dst;
| 1686 | PyObject* pyobj_shift = NULL; |  | 1686 | PyObject* pyobj_shift = NULL;
| 1687 | Point shift; |  | 1687 | Point shift;
| 1688 |  |  | 1688 |
| 1689 | const char* keywords[] = { "src", "shift", "dst", NULL }; |  | 1689 | const char* keywords[] = { "src", "shift", "dst", NULL };
| 1690 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:AlignMTB.shiftMat", (char**)keywords, &pyobj_src, &pyobj_shift, &pyobj_dst) && |  | 1690 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:AlignMTB.shiftMat", (char**)keywords, &pyobj_src, &pyobj_shift, &pyobj_dst) &&
| 1691 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 1691 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 1692 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 1692 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 1693 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) ) |  | 1693 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) )
| 1694 | { |  | 1694 | {
| 1695 | ERRWRAP2(_self_->shiftMat(src, dst, shift)); |  | 1695 | ERRWRAP2(_self_->shiftMat(src, dst, shift));
| 1696 | return pyopencv_from(dst); |  | 1696 | return pyopencv_from(dst);
| 1697 | } |  | 1697 | }
| 1698 |  |  | 1698 |
| 1699 |  |  | 1699 |
| 1700 | pyPopulateArgumentConversionErrors(); |  | 1700 | pyPopulateArgumentConversionErrors();
| 1701 | } |  | 1701 | }
| 1702 | pyRaiseCVOverloadException("shiftMat"); |  | 1702 | pyRaiseCVOverloadException("shiftMat");
| 1703 |  |  | 1703 |
| 1704 | return NULL; |  | 1704 | return NULL;
| 1705 | } |  | 1705 | }
| 1706 |  |  | 1706 |
| 1707 |  |  | 1707 |
| 1708 |  |  | 1708 |
| 1709 | // Tables (AlignMTB) |  | 1709 | // Tables (AlignMTB)
| 1710 |  |  | 1710 |
| 1711 | static PyGetSetDef pyopencv_AlignMTB_getseters[] = |  | 1711 | static PyGetSetDef pyopencv_AlignMTB_getseters[] =
| 1712 | { |  | 1712 | {
| 1713 | {NULL} /* Sentinel */ |  | 1713 | {NULL} /* Sentinel */
| 1714 | }; |  | 1714 | };
| 1715 |  |  | 1715 |
| 1716 | static PyMethodDef pyopencv_AlignMTB_methods[] = |  | 1716 | static PyMethodDef pyopencv_AlignMTB_methods[] =
| 1717 | { |  | 1717 | {
| 1718 | {"calculateShift", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_calculateShift, 0), "calculateShift(img0, img1) -> retval\n. @brief Calculates shift between two images, i. e. how to shift the second image to correspond it with the\n. first.\n. \n. @param img0 first image\n. @param img1 second image"}, |  | 1718 | {"calculateShift", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_calculateShift, 0), "calculateShift(img0, img1) -> retval\n. @brief Calculates shift between two images, i. e. how to shift the second image to correspond it with the\n. first.\n. \n. @param img0 first image\n. @param img1 second image"},
| 1719 | {"computeBitmaps", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_computeBitmaps, 0), "computeBitmaps(img[, tb[, eb]]) -> tb, eb\n. @brief Computes median threshold and exclude bitmaps of given image.\n. \n. @param img input image\n. @param tb median threshold bitmap\n. @param eb exclude bitmap"}, |  | 1719 | {"computeBitmaps", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_computeBitmaps, 0), "computeBitmaps(img[, tb[, eb]]) -> tb, eb\n. @brief Computes median threshold and exclude bitmaps of given image.\n. \n. @param img input image\n. @param tb median threshold bitmap\n. @param eb exclude bitmap"},
| 1720 | {"getCut", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_getCut, 0), "getCut() -> retval\n."}, |  | 1720 | {"getCut", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_getCut, 0), "getCut() -> retval\n."},
| 1721 | {"getExcludeRange", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_getExcludeRange, 0), "getExcludeRange() -> retval\n."}, |  | 1721 | {"getExcludeRange", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_getExcludeRange, 0), "getExcludeRange() -> retval\n."},
| 1722 | {"getMaxBits", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_getMaxBits, 0), "getMaxBits() -> retval\n."}, |  | 1722 | {"getMaxBits", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_getMaxBits, 0), "getMaxBits() -> retval\n."},
| 1723 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_process, 0), "process(src, dst, times, response) -> None\n. \n\n\n\nprocess(src, dst) -> None\n. @brief Short version of process, that doesn't take extra arguments.\n. \n. @param src vector of input images\n. @param dst vector of aligned images"}, |  | 1723 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_process, 0), "process(src, dst, times, response) -> None\n. \n\n\n\nprocess(src, dst) -> None\n. @brief Short version of process, that doesn't take extra arguments.\n. \n. @param src vector of input images\n. @param dst vector of aligned images"},
| 1724 | {"setCut", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_setCut, 0), "setCut(value) -> None\n."}, |  | 1724 | {"setCut", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_setCut, 0), "setCut(value) -> None\n."},
| 1725 | {"setExcludeRange", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_setExcludeRange, 0), "setExcludeRange(exclude_range) -> None\n."}, |  | 1725 | {"setExcludeRange", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_setExcludeRange, 0), "setExcludeRange(exclude_range) -> None\n."},
| 1726 | {"setMaxBits", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_setMaxBits, 0), "setMaxBits(max_bits) -> None\n."}, |  | 1726 | {"setMaxBits", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_setMaxBits, 0), "setMaxBits(max_bits) -> None\n."},
| 1727 | {"shiftMat", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_shiftMat, 0), "shiftMat(src, shift[, dst]) -> dst\n. @brief Helper function, that shift Mat filling new regions with zeros.\n. \n. @param src input image\n. @param dst result image\n. @param shift shift value"}, |  | 1727 | {"shiftMat", CV_PY_FN_WITH_KW_(pyopencv_cv_AlignMTB_shiftMat, 0), "shiftMat(src, shift[, dst]) -> dst\n. @brief Helper function, that shift Mat filling new regions with zeros.\n. \n. @param src input image\n. @param dst result image\n. @param shift shift value"},
| 1728 |  |  | 1728 |
| 1729 | {NULL, NULL} |  | 1729 | {NULL, NULL}
| 1730 | }; |  | 1730 | };
| 1731 |  |  | 1731 |
| 1732 | // Converter (AlignMTB) |  | 1732 | // Converter (AlignMTB)
| 1733 |  |  | 1733 |
| 1734 | template<> |  | 1734 | template<>
| 1735 | struct PyOpenCV_Converter< Ptr<cv::AlignMTB> > |  | 1735 | struct PyOpenCV_Converter< Ptr<cv::AlignMTB> >
| 1736 | { |  | 1736 | {
| 1737 | static PyObject* from(const Ptr<cv::AlignMTB>& r) |  | 1737 | static PyObject* from(const Ptr<cv::AlignMTB>& r)
| 1738 | { |  | 1738 | {
| 1739 | return pyopencv_AlignMTB_Instance(r); |  | 1739 | return pyopencv_AlignMTB_Instance(r);
| 1740 | } |  | 1740 | }
| 1741 | static bool to(PyObject* src, Ptr<cv::AlignMTB>& dst, const ArgInfo& info) |  | 1741 | static bool to(PyObject* src, Ptr<cv::AlignMTB>& dst, const ArgInfo& info)
| 1742 | { |  | 1742 | {
| 1743 | if(!src || src == Py_None) |  | 1743 | if(!src || src == Py_None)
| 1744 | return true; |  | 1744 | return true;
| 1745 | Ptr<cv::AlignMTB> * dst_; |  | 1745 | Ptr<cv::AlignMTB> * dst_;
| 1746 | if (pyopencv_AlignMTB_getp(src, dst_)) |  | 1746 | if (pyopencv_AlignMTB_getp(src, dst_))
| 1747 | { |  | 1747 | {
| 1748 | dst = *dst_; |  | 1748 | dst = *dst_;
| 1749 | return true; |  | 1749 | return true;
| 1750 | } |  | 1750 | }
| 1751 |  |  | 1751 |
| 1752 | failmsg("Expected Ptr<cv::AlignMTB> for argument '%s'", info.name); |  | 1752 | failmsg("Expected Ptr<cv::AlignMTB> for argument '%s'", info.name);
| 1753 | return false; |  | 1753 | return false;
| 1754 | } |  | 1754 | }
| 1755 | }; |  | 1755 | };
| 1756 |  |  | 1756 |
| 1757 | //================================================================================ |  | 1757 | //================================================================================
| 1758 | // Animation (Generic) |  | 1758 | // Animation (Generic)
| 1759 | //================================================================================ |  | 1759 | //================================================================================
| 1760 |  |  | 1760 |
| 1761 | // GetSet (Animation) |  | 1761 | // GetSet (Animation)
| 1762 |  |  | 1762 |
| 1763 |  |  | 1763 |
| 1764 | static PyObject* pyopencv_Animation_get_bgcolor(pyopencv_Animation_t* p, void *closure) |  | 1764 | static PyObject* pyopencv_Animation_get_bgcolor(pyopencv_Animation_t* p, void *closure)
| 1765 | { |  | 1765 | {
| 1766 | return pyopencv_from(p->v.bgcolor); |  | 1766 | return pyopencv_from(p->v.bgcolor);
| 1767 | } |  | 1767 | }
| 1768 |  |  | 1768 |
| 1769 | static int pyopencv_Animation_set_bgcolor(pyopencv_Animation_t* p, PyObject *value, void *closure) |  | 1769 | static int pyopencv_Animation_set_bgcolor(pyopencv_Animation_t* p, PyObject *value, void *closure)
| 1770 | { |  | 1770 | {
| 1771 | if (!value) |  | 1771 | if (!value)
| 1772 | { |  | 1772 | {
| 1773 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bgcolor attribute"); |  | 1773 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bgcolor attribute");
| 1774 | return -1; |  | 1774 | return -1;
| 1775 | } |  | 1775 | }
| 1776 | return pyopencv_to_safe(value, p->v.bgcolor, ArgInfo("value", 0)) ? 0 : -1; |  | 1776 | return pyopencv_to_safe(value, p->v.bgcolor, ArgInfo("value", 0)) ? 0 : -1;
| 1777 | } |  | 1777 | }
| 1778 |  |  | 1778 |
| 1779 | static PyObject* pyopencv_Animation_get_durations(pyopencv_Animation_t* p, void *closure) |  | 1779 | static PyObject* pyopencv_Animation_get_durations(pyopencv_Animation_t* p, void *closure)
| 1780 | { |  | 1780 | {
| 1781 | return pyopencv_from(p->v.durations); |  | 1781 | return pyopencv_from(p->v.durations);
| 1782 | } |  | 1782 | }
| 1783 |  |  | 1783 |
| 1784 | static int pyopencv_Animation_set_durations(pyopencv_Animation_t* p, PyObject *value, void *closure) |  | 1784 | static int pyopencv_Animation_set_durations(pyopencv_Animation_t* p, PyObject *value, void *closure)
| 1785 | { |  | 1785 | {
| 1786 | if (!value) |  | 1786 | if (!value)
| 1787 | { |  | 1787 | {
| 1788 | PyErr_SetString(PyExc_TypeError, "Cannot delete the durations attribute"); |  | 1788 | PyErr_SetString(PyExc_TypeError, "Cannot delete the durations attribute");
| 1789 | return -1; |  | 1789 | return -1;
| 1790 | } |  | 1790 | }
| 1791 | return pyopencv_to_safe(value, p->v.durations, ArgInfo("value", 0)) ? 0 : -1; |  | 1791 | return pyopencv_to_safe(value, p->v.durations, ArgInfo("value", 0)) ? 0 : -1;
| 1792 | } |  | 1792 | }
| 1793 |  |  | 1793 |
| 1794 | static PyObject* pyopencv_Animation_get_frames(pyopencv_Animation_t* p, void *closure) |  | 1794 | static PyObject* pyopencv_Animation_get_frames(pyopencv_Animation_t* p, void *closure)
| 1795 | { |  | 1795 | {
| 1796 | return pyopencv_from(p->v.frames); |  | 1796 | return pyopencv_from(p->v.frames);
| 1797 | } |  | 1797 | }
| 1798 |  |  | 1798 |
| 1799 | static int pyopencv_Animation_set_frames(pyopencv_Animation_t* p, PyObject *value, void *closure) |  | 1799 | static int pyopencv_Animation_set_frames(pyopencv_Animation_t* p, PyObject *value, void *closure)
| 1800 | { |  | 1800 | {
| 1801 | if (!value) |  | 1801 | if (!value)
| 1802 | { |  | 1802 | {
| 1803 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frames attribute"); |  | 1803 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frames attribute");
| 1804 | return -1; |  | 1804 | return -1;
| 1805 | } |  | 1805 | }
| 1806 | return pyopencv_to_safe(value, p->v.frames, ArgInfo("value", 0)) ? 0 : -1; |  | 1806 | return pyopencv_to_safe(value, p->v.frames, ArgInfo("value", 0)) ? 0 : -1;
| 1807 | } |  | 1807 | }
| 1808 |  |  | 1808 |
| 1809 | static PyObject* pyopencv_Animation_get_loop_count(pyopencv_Animation_t* p, void *closure) |  | 1809 | static PyObject* pyopencv_Animation_get_loop_count(pyopencv_Animation_t* p, void *closure)
| 1810 | { |  | 1810 | {
| 1811 | return pyopencv_from(p->v.loop_count); |  | 1811 | return pyopencv_from(p->v.loop_count);
| 1812 | } |  | 1812 | }
| 1813 |  |  | 1813 |
| 1814 | static int pyopencv_Animation_set_loop_count(pyopencv_Animation_t* p, PyObject *value, void *closure) |  | 1814 | static int pyopencv_Animation_set_loop_count(pyopencv_Animation_t* p, PyObject *value, void *closure)
| 1815 | { |  | 1815 | {
| 1816 | if (!value) |  | 1816 | if (!value)
| 1817 | { |  | 1817 | {
| 1818 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loop_count attribute"); |  | 1818 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loop_count attribute");
| 1819 | return -1; |  | 1819 | return -1;
| 1820 | } |  | 1820 | }
| 1821 | return pyopencv_to_safe(value, p->v.loop_count, ArgInfo("value", 0)) ? 0 : -1; |  | 1821 | return pyopencv_to_safe(value, p->v.loop_count, ArgInfo("value", 0)) ? 0 : -1;
| 1822 | } |  | 1822 | }
| 1823 |  |  | 1823 |
| 1824 |  |  | 1824 |
| 1825 | // Methods (Animation) |  | 1825 | // Methods (Animation)
| 1826 |  |  | 1826 |
| 1827 | static int pyopencv_cv_Animation_Animation(pyopencv_Animation_t* self, PyObject* py_args, PyObject* kw) |  | 1827 | static int pyopencv_cv_Animation_Animation(pyopencv_Animation_t* self, PyObject* py_args, PyObject* kw)
| 1828 | { |  | 1828 | {
| 1829 | using namespace cv; |  | 1829 | using namespace cv;
| 1830 |  |  | 1830 |
| 1831 | PyObject* pyobj_loopCount = NULL; |  | 1831 | PyObject* pyobj_loopCount = NULL;
| 1832 | int loopCount=0; |  | 1832 | int loopCount=0;
| 1833 | PyObject* pyobj_bgColor = NULL; |  | 1833 | PyObject* pyobj_bgColor = NULL;
| 1834 | Scalar bgColor; |  | 1834 | Scalar bgColor;
| 1835 |  |  | 1835 |
| 1836 | const char* keywords[] = { "loopCount", "bgColor", NULL }; |  | 1836 | const char* keywords[] = { "loopCount", "bgColor", NULL };
| 1837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:Animation", (char**)keywords, &pyobj_loopCount, &pyobj_bgColor) && |  | 1837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:Animation", (char**)keywords, &pyobj_loopCount, &pyobj_bgColor) &&
| 1838 | pyopencv_to_safe(pyobj_loopCount, loopCount, ArgInfo("loopCount", 0)) && |  | 1838 | pyopencv_to_safe(pyobj_loopCount, loopCount, ArgInfo("loopCount", 0)) &&
| 1839 | pyopencv_to_safe(pyobj_bgColor, bgColor, ArgInfo("bgColor", 0)) ) |  | 1839 | pyopencv_to_safe(pyobj_bgColor, bgColor, ArgInfo("bgColor", 0)) )
| 1840 | { |  | 1840 | {
| 1841 | if(self) ERRWRAP2(new (&(self->v)) cv::Animation(loopCount, bgColor)); |  | 1841 | if(self) ERRWRAP2(new (&(self->v)) cv::Animation(loopCount, bgColor));
| 1842 | return 0; |  | 1842 | return 0;
| 1843 | } |  | 1843 | }
| 1844 |  |  | 1844 |
| 1845 | return -1; |  | 1845 | return -1;
| 1846 | } |  | 1846 | }
| 1847 |  |  | 1847 |
| 1848 |  |  | 1848 |
| 1849 |  |  | 1849 |
| 1850 | // Tables (Animation) |  | 1850 | // Tables (Animation)
| 1851 |  |  | 1851 |
| 1852 | static PyGetSetDef pyopencv_Animation_getseters[] = |  | 1852 | static PyGetSetDef pyopencv_Animation_getseters[] =
| 1853 | { |  | 1853 | {
| 1854 | {(char*)"bgcolor", (getter)pyopencv_Animation_get_bgcolor, (setter)pyopencv_Animation_set_bgcolor, (char*)"bgcolor", NULL}, |  | 1854 | {(char*)"bgcolor", (getter)pyopencv_Animation_get_bgcolor, (setter)pyopencv_Animation_set_bgcolor, (char*)"bgcolor", NULL},
| 1855 | {(char*)"durations", (getter)pyopencv_Animation_get_durations, (setter)pyopencv_Animation_set_durations, (char*)"durations", NULL}, |  | 1855 | {(char*)"durations", (getter)pyopencv_Animation_get_durations, (setter)pyopencv_Animation_set_durations, (char*)"durations", NULL},
| 1856 | {(char*)"frames", (getter)pyopencv_Animation_get_frames, (setter)pyopencv_Animation_set_frames, (char*)"frames", NULL}, |  | 1856 | {(char*)"frames", (getter)pyopencv_Animation_get_frames, (setter)pyopencv_Animation_set_frames, (char*)"frames", NULL},
| 1857 | {(char*)"loop_count", (getter)pyopencv_Animation_get_loop_count, (setter)pyopencv_Animation_set_loop_count, (char*)"loop_count", NULL}, |  | 1857 | {(char*)"loop_count", (getter)pyopencv_Animation_get_loop_count, (setter)pyopencv_Animation_set_loop_count, (char*)"loop_count", NULL},
| 1858 | {NULL} /* Sentinel */ |  | 1858 | {NULL} /* Sentinel */
| 1859 | }; |  | 1859 | };
| 1860 |  |  | 1860 |
| 1861 | static PyMethodDef pyopencv_Animation_methods[] = |  | 1861 | static PyMethodDef pyopencv_Animation_methods[] =
| 1862 | { |  | 1862 | {
| 1863 |  |  | 1863 |
| 1864 | {NULL, NULL} |  | 1864 | {NULL, NULL}
| 1865 | }; |  | 1865 | };
| 1866 |  |  | 1866 |
| 1867 | // Converter (Animation) |  | 1867 | // Converter (Animation)
| 1868 |  |  | 1868 |
| 1869 | template<> |  | 1869 | template<>
| 1870 | struct PyOpenCV_Converter< cv::Animation > |  | 1870 | struct PyOpenCV_Converter< cv::Animation >
| 1871 | { |  | 1871 | {
| 1872 | static PyObject* from(const cv::Animation& r) |  | 1872 | static PyObject* from(const cv::Animation& r)
| 1873 | { |  | 1873 | {
| 1874 | return pyopencv_Animation_Instance(r); |  | 1874 | return pyopencv_Animation_Instance(r);
| 1875 | } |  | 1875 | }
| 1876 | static bool to(PyObject* src, cv::Animation& dst, const ArgInfo& info) |  | 1876 | static bool to(PyObject* src, cv::Animation& dst, const ArgInfo& info)
| 1877 | { |  | 1877 | {
| 1878 | if(!src || src == Py_None) |  | 1878 | if(!src || src == Py_None)
| 1879 | return true; |  | 1879 | return true;
| 1880 | cv::Animation * dst_; |  | 1880 | cv::Animation * dst_;
| 1881 | if (pyopencv_Animation_getp(src, dst_)) |  | 1881 | if (pyopencv_Animation_getp(src, dst_))
| 1882 | { |  | 1882 | {
| 1883 | dst = *dst_; |  | 1883 | dst = *dst_;
| 1884 | return true; |  | 1884 | return true;
| 1885 | } |  | 1885 | }
| 1886 |  |  | 1886 |
| 1887 | failmsg("Expected cv::Animation for argument '%s'", info.name); |  | 1887 | failmsg("Expected cv::Animation for argument '%s'", info.name);
| 1888 | return false; |  | 1888 | return false;
| 1889 | } |  | 1889 | }
| 1890 | }; |  | 1890 | };
| 1891 |  |  | 1891 |
| 1892 | //================================================================================ |  | 1892 | //================================================================================
| 1893 | // AsyncArray (Generic) |  | 1893 | // AsyncArray (Generic)
| 1894 | //================================================================================ |  | 1894 | //================================================================================
| 1895 |  |  | 1895 |
| 1896 | // GetSet (AsyncArray) |  | 1896 | // GetSet (AsyncArray)
| 1897 |  |  | 1897 |
| 1898 |  |  | 1898 |
| 1899 |  |  | 1899 |
| 1900 | // Methods (AsyncArray) |  | 1900 | // Methods (AsyncArray)
| 1901 |  |  | 1901 |
| 1902 | static int pyopencv_cv_AsyncArray_AsyncArray(pyopencv_AsyncArray_t* self, PyObject* py_args, PyObject* kw) |  | 1902 | static int pyopencv_cv_AsyncArray_AsyncArray(pyopencv_AsyncArray_t* self, PyObject* py_args, PyObject* kw)
| 1903 | { |  | 1903 | {
| 1904 | using namespace cv; |  | 1904 | using namespace cv;
| 1905 |  |  | 1905 |
| 1906 |  |  | 1906 |
| 1907 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 1907 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 1908 | { |  | 1908 | {
| 1909 | new (&(self->v)) Ptr<cv::AsyncArray>(); // init Ptr with placement new |  | 1909 | new (&(self->v)) Ptr<cv::AsyncArray>(); // init Ptr with placement new
| 1910 | if(self) ERRWRAP2(self->v.reset(new cv::AsyncArray())); |  | 1910 | if(self) ERRWRAP2(self->v.reset(new cv::AsyncArray()));
| 1911 | return 0; |  | 1911 | return 0;
| 1912 | } |  | 1912 | }
| 1913 |  |  | 1913 |
| 1914 | return -1; |  | 1914 | return -1;
| 1915 | } |  | 1915 | }
| 1916 |  |  | 1916 |
| 1917 | static PyObject* pyopencv_cv_AsyncArray_get(PyObject* self, PyObject* py_args, PyObject* kw) |  | 1917 | static PyObject* pyopencv_cv_AsyncArray_get(PyObject* self, PyObject* py_args, PyObject* kw)
| 1918 | { |  | 1918 | {
| 1919 | using namespace cv; |  | 1919 | using namespace cv;
| 1920 |  |  | 1920 |
| 1921 |  |  | 1921 |
| 1922 | Ptr<cv::AsyncArray> * self1 = 0; |  | 1922 | Ptr<cv::AsyncArray> * self1 = 0;
| 1923 | if (!pyopencv_AsyncArray_getp(self, self1)) |  | 1923 | if (!pyopencv_AsyncArray_getp(self, self1))
| 1924 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)"); |  | 1924 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)");
| 1925 | Ptr<cv::AsyncArray> _self_ = *(self1); |  | 1925 | Ptr<cv::AsyncArray> _self_ = *(self1);
| 1926 | pyPrepareArgumentConversionErrorsStorage(4); |  | 1926 | pyPrepareArgumentConversionErrorsStorage(4);
| 1927 |  |  | 1927 |
| 1928 | { |  | 1928 | {
| 1929 | PyObject* pyobj_dst = NULL; |  | 1929 | PyObject* pyobj_dst = NULL;
| 1930 | Mat dst; |  | 1930 | Mat dst;
| 1931 |  |  | 1931 |
| 1932 | const char* keywords[] = { "dst", NULL }; |  | 1932 | const char* keywords[] = { "dst", NULL };
| 1933 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:AsyncArray.get", (char**)keywords, &pyobj_dst) && |  | 1933 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:AsyncArray.get", (char**)keywords, &pyobj_dst) &&
| 1934 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 1934 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 1935 | { |  | 1935 | {
| 1936 | ERRWRAP2(_self_->get(dst)); |  | 1936 | ERRWRAP2(_self_->get(dst));
| 1937 | return pyopencv_from(dst); |  | 1937 | return pyopencv_from(dst);
| 1938 | } |  | 1938 | }
| 1939 |  |  | 1939 |
| 1940 |  |  | 1940 |
| 1941 | pyPopulateArgumentConversionErrors(); |  | 1941 | pyPopulateArgumentConversionErrors();
| 1942 | } |  | 1942 | }
| 1943 |  |  | 1943 |
| 1944 |  |  | 1944 |
| 1945 | { |  | 1945 | {
| 1946 | PyObject* pyobj_dst = NULL; |  | 1946 | PyObject* pyobj_dst = NULL;
| 1947 | Mat dst; |  | 1947 | Mat dst;
| 1948 | PyObject* pyobj_timeoutNs = NULL; |  | 1948 | PyObject* pyobj_timeoutNs = NULL;
| 1949 | double timeoutNs=0; |  | 1949 | double timeoutNs=0;
| 1950 | bool retval; |  | 1950 | bool retval;
| 1951 |  |  | 1951 |
| 1952 | const char* keywords[] = { "timeoutNs", "dst", NULL }; |  | 1952 | const char* keywords[] = { "timeoutNs", "dst", NULL };
| 1953 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:AsyncArray.get", (char**)keywords, &pyobj_timeoutNs, &pyobj_dst) && |  | 1953 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:AsyncArray.get", (char**)keywords, &pyobj_timeoutNs, &pyobj_dst) &&
| 1954 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 1954 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 1955 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) ) |  | 1955 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) )
| 1956 | { |  | 1956 | {
| 1957 | ERRWRAP2(retval = _self_->get(dst, timeoutNs)); |  | 1957 | ERRWRAP2(retval = _self_->get(dst, timeoutNs));
| 1958 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst)); |  | 1958 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst));
| 1959 | } |  | 1959 | }
| 1960 |  |  | 1960 |
| 1961 |  |  | 1961 |
| 1962 | pyPopulateArgumentConversionErrors(); |  | 1962 | pyPopulateArgumentConversionErrors();
| 1963 | } |  | 1963 | }
| 1964 |  |  | 1964 |
| 1965 |  |  | 1965 |
| 1966 | { |  | 1966 | {
| 1967 | PyObject* pyobj_dst = NULL; |  | 1967 | PyObject* pyobj_dst = NULL;
| 1968 | UMat dst; |  | 1968 | UMat dst;
| 1969 |  |  | 1969 |
| 1970 | const char* keywords[] = { "dst", NULL }; |  | 1970 | const char* keywords[] = { "dst", NULL };
| 1971 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:AsyncArray.get", (char**)keywords, &pyobj_dst) && |  | 1971 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:AsyncArray.get", (char**)keywords, &pyobj_dst) &&
| 1972 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 1972 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 1973 | { |  | 1973 | {
| 1974 | ERRWRAP2(_self_->get(dst)); |  | 1974 | ERRWRAP2(_self_->get(dst));
| 1975 | return pyopencv_from(dst); |  | 1975 | return pyopencv_from(dst);
| 1976 | } |  | 1976 | }
| 1977 |  |  | 1977 |
| 1978 |  |  | 1978 |
| 1979 | pyPopulateArgumentConversionErrors(); |  | 1979 | pyPopulateArgumentConversionErrors();
| 1980 | } |  | 1980 | }
| 1981 |  |  | 1981 |
| 1982 |  |  | 1982 |
| 1983 | { |  | 1983 | {
| 1984 | PyObject* pyobj_dst = NULL; |  | 1984 | PyObject* pyobj_dst = NULL;
| 1985 | UMat dst; |  | 1985 | UMat dst;
| 1986 | PyObject* pyobj_timeoutNs = NULL; |  | 1986 | PyObject* pyobj_timeoutNs = NULL;
| 1987 | double timeoutNs=0; |  | 1987 | double timeoutNs=0;
| 1988 | bool retval; |  | 1988 | bool retval;
| 1989 |  |  | 1989 |
| 1990 | const char* keywords[] = { "timeoutNs", "dst", NULL }; |  | 1990 | const char* keywords[] = { "timeoutNs", "dst", NULL };
| 1991 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:AsyncArray.get", (char**)keywords, &pyobj_timeoutNs, &pyobj_dst) && |  | 1991 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:AsyncArray.get", (char**)keywords, &pyobj_timeoutNs, &pyobj_dst) &&
| 1992 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 1992 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 1993 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) ) |  | 1993 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) )
| 1994 | { |  | 1994 | {
| 1995 | ERRWRAP2(retval = _self_->get(dst, timeoutNs)); |  | 1995 | ERRWRAP2(retval = _self_->get(dst, timeoutNs));
| 1996 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst)); |  | 1996 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst));
| 1997 | } |  | 1997 | }
| 1998 |  |  | 1998 |
| 1999 |  |  | 1999 |
| 2000 | pyPopulateArgumentConversionErrors(); |  | 2000 | pyPopulateArgumentConversionErrors();
| 2001 | } |  | 2001 | }
| 2002 | pyRaiseCVOverloadException("get"); |  | 2002 | pyRaiseCVOverloadException("get");
| 2003 |  |  | 2003 |
| 2004 | return NULL; |  | 2004 | return NULL;
| 2005 | } |  | 2005 | }
| 2006 |  |  | 2006 |
| 2007 | static PyObject* pyopencv_cv_AsyncArray_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2007 | static PyObject* pyopencv_cv_AsyncArray_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 2008 | { |  | 2008 | {
| 2009 | using namespace cv; |  | 2009 | using namespace cv;
| 2010 |  |  | 2010 |
| 2011 |  |  | 2011 |
| 2012 | Ptr<cv::AsyncArray> * self1 = 0; |  | 2012 | Ptr<cv::AsyncArray> * self1 = 0;
| 2013 | if (!pyopencv_AsyncArray_getp(self, self1)) |  | 2013 | if (!pyopencv_AsyncArray_getp(self, self1))
| 2014 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)"); |  | 2014 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)");
| 2015 | Ptr<cv::AsyncArray> _self_ = *(self1); |  | 2015 | Ptr<cv::AsyncArray> _self_ = *(self1);
| 2016 |  |  | 2016 |
| 2017 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2017 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2018 | { |  | 2018 | {
| 2019 | ERRWRAP2(_self_->release()); |  | 2019 | ERRWRAP2(_self_->release());
| 2020 | Py_RETURN_NONE; |  | 2020 | Py_RETURN_NONE;
| 2021 | } |  | 2021 | }
| 2022 |  |  | 2022 |
| 2023 | return NULL; |  | 2023 | return NULL;
| 2024 | } |  | 2024 | }
| 2025 |  |  | 2025 |
| 2026 | static PyObject* pyopencv_cv_AsyncArray_valid(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2026 | static PyObject* pyopencv_cv_AsyncArray_valid(PyObject* self, PyObject* py_args, PyObject* kw)
| 2027 | { |  | 2027 | {
| 2028 | using namespace cv; |  | 2028 | using namespace cv;
| 2029 |  |  | 2029 |
| 2030 |  |  | 2030 |
| 2031 | Ptr<cv::AsyncArray> * self1 = 0; |  | 2031 | Ptr<cv::AsyncArray> * self1 = 0;
| 2032 | if (!pyopencv_AsyncArray_getp(self, self1)) |  | 2032 | if (!pyopencv_AsyncArray_getp(self, self1))
| 2033 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)"); |  | 2033 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)");
| 2034 | Ptr<cv::AsyncArray> _self_ = *(self1); |  | 2034 | Ptr<cv::AsyncArray> _self_ = *(self1);
| 2035 | bool retval; |  | 2035 | bool retval;
| 2036 |  |  | 2036 |
| 2037 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2037 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2038 | { |  | 2038 | {
| 2039 | ERRWRAP2(retval = _self_->valid()); |  | 2039 | ERRWRAP2(retval = _self_->valid());
| 2040 | return pyopencv_from(retval); |  | 2040 | return pyopencv_from(retval);
| 2041 | } |  | 2041 | }
| 2042 |  |  | 2042 |
| 2043 | return NULL; |  | 2043 | return NULL;
| 2044 | } |  | 2044 | }
| 2045 |  |  | 2045 |
| 2046 | static PyObject* pyopencv_cv_AsyncArray_wait_for(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2046 | static PyObject* pyopencv_cv_AsyncArray_wait_for(PyObject* self, PyObject* py_args, PyObject* kw)
| 2047 | { |  | 2047 | {
| 2048 | using namespace cv; |  | 2048 | using namespace cv;
| 2049 |  |  | 2049 |
| 2050 |  |  | 2050 |
| 2051 | Ptr<cv::AsyncArray> * self1 = 0; |  | 2051 | Ptr<cv::AsyncArray> * self1 = 0;
| 2052 | if (!pyopencv_AsyncArray_getp(self, self1)) |  | 2052 | if (!pyopencv_AsyncArray_getp(self, self1))
| 2053 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)"); |  | 2053 | return failmsgp("Incorrect type of self (must be 'AsyncArray' or its derivative)");
| 2054 | Ptr<cv::AsyncArray> _self_ = *(self1); |  | 2054 | Ptr<cv::AsyncArray> _self_ = *(self1);
| 2055 | PyObject* pyobj_timeoutNs = NULL; |  | 2055 | PyObject* pyobj_timeoutNs = NULL;
| 2056 | double timeoutNs=0; |  | 2056 | double timeoutNs=0;
| 2057 | bool retval; |  | 2057 | bool retval;
| 2058 |  |  | 2058 |
| 2059 | const char* keywords[] = { "timeoutNs", NULL }; |  | 2059 | const char* keywords[] = { "timeoutNs", NULL };
| 2060 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AsyncArray.wait_for", (char**)keywords, &pyobj_timeoutNs) && |  | 2060 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:AsyncArray.wait_for", (char**)keywords, &pyobj_timeoutNs) &&
| 2061 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) ) |  | 2061 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) )
| 2062 | { |  | 2062 | {
| 2063 | ERRWRAP2(retval = _self_->wait_for(timeoutNs)); |  | 2063 | ERRWRAP2(retval = _self_->wait_for(timeoutNs));
| 2064 | return pyopencv_from(retval); |  | 2064 | return pyopencv_from(retval);
| 2065 | } |  | 2065 | }
| 2066 |  |  | 2066 |
| 2067 | return NULL; |  | 2067 | return NULL;
| 2068 | } |  | 2068 | }
| 2069 |  |  | 2069 |
| 2070 |  |  | 2070 |
| 2071 |  |  | 2071 |
| 2072 | // Tables (AsyncArray) |  | 2072 | // Tables (AsyncArray)
| 2073 |  |  | 2073 |
| 2074 | static PyGetSetDef pyopencv_AsyncArray_getseters[] = |  | 2074 | static PyGetSetDef pyopencv_AsyncArray_getseters[] =
| 2075 | { |  | 2075 | {
| 2076 | {NULL} /* Sentinel */ |  | 2076 | {NULL} /* Sentinel */
| 2077 | }; |  | 2077 | };
| 2078 |  |  | 2078 |
| 2079 | static PyMethodDef pyopencv_AsyncArray_methods[] = |  | 2079 | static PyMethodDef pyopencv_AsyncArray_methods[] =
| 2080 | { |  | 2080 | {
| 2081 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_get, 0), "get([, dst]) -> dst\n. Fetch the result.\n. @param[out] dst destination array\n. \n. Waits for result until container has valid result.\n. Throws exception if exception was stored as a result.\n. \n. Throws exception on invalid container state.\n. \n. @note Result or stored exception can be fetched only once.\n\n\n\nget(timeoutNs[, dst]) -> retval, dst\n. Retrieving the result with timeout\n. @param[out] dst destination array\n. @param[in] timeoutNs timeout in nanoseconds, -1 for infinite wait\n. \n. @returns true if result is ready, false if the timeout has expired\n. \n. @note Result or stored exception can be fetched only once."}, |  | 2081 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_get, 0), "get([, dst]) -> dst\n. Fetch the result.\n. @param[out] dst destination array\n. \n. Waits for result until container has valid result.\n. Throws exception if exception was stored as a result.\n. \n. Throws exception on invalid container state.\n. \n. @note Result or stored exception can be fetched only once.\n\n\n\nget(timeoutNs[, dst]) -> retval, dst\n. Retrieving the result with timeout\n. @param[out] dst destination array\n. @param[in] timeoutNs timeout in nanoseconds, -1 for infinite wait\n. \n. @returns true if result is ready, false if the timeout has expired\n. \n. @note Result or stored exception can be fetched only once."},
| 2082 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_release, 0), "release() -> None\n."}, |  | 2082 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_release, 0), "release() -> None\n."},
| 2083 | {"valid", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_valid, 0), "valid() -> retval\n."}, |  | 2083 | {"valid", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_valid, 0), "valid() -> retval\n."},
| 2084 | {"wait_for", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_wait_for, 0), "wait_for(timeoutNs) -> retval\n."}, |  | 2084 | {"wait_for", CV_PY_FN_WITH_KW_(pyopencv_cv_AsyncArray_wait_for, 0), "wait_for(timeoutNs) -> retval\n."},
| 2085 |  |  | 2085 |
| 2086 | {NULL, NULL} |  | 2086 | {NULL, NULL}
| 2087 | }; |  | 2087 | };
| 2088 |  |  | 2088 |
| 2089 | // Converter (AsyncArray) |  | 2089 | // Converter (AsyncArray)
| 2090 |  |  | 2090 |
| 2091 | template<> |  | 2091 | template<>
| 2092 | struct PyOpenCV_Converter< Ptr<cv::AsyncArray> > |  | 2092 | struct PyOpenCV_Converter< Ptr<cv::AsyncArray> >
| 2093 | { |  | 2093 | {
| 2094 | static PyObject* from(const Ptr<cv::AsyncArray>& r) |  | 2094 | static PyObject* from(const Ptr<cv::AsyncArray>& r)
| 2095 | { |  | 2095 | {
| 2096 | return pyopencv_AsyncArray_Instance(r); |  | 2096 | return pyopencv_AsyncArray_Instance(r);
| 2097 | } |  | 2097 | }
| 2098 | static bool to(PyObject* src, Ptr<cv::AsyncArray>& dst, const ArgInfo& info) |  | 2098 | static bool to(PyObject* src, Ptr<cv::AsyncArray>& dst, const ArgInfo& info)
| 2099 | { |  | 2099 | {
| 2100 | if(!src || src == Py_None) |  | 2100 | if(!src || src == Py_None)
| 2101 | return true; |  | 2101 | return true;
| 2102 | Ptr<cv::AsyncArray> * dst_; |  | 2102 | Ptr<cv::AsyncArray> * dst_;
| 2103 | if (pyopencv_AsyncArray_getp(src, dst_)) |  | 2103 | if (pyopencv_AsyncArray_getp(src, dst_))
| 2104 | { |  | 2104 | {
| 2105 | dst = *dst_; |  | 2105 | dst = *dst_;
| 2106 | return true; |  | 2106 | return true;
| 2107 | } |  | 2107 | }
| 2108 |  |  | 2108 |
| 2109 | failmsg("Expected Ptr<cv::AsyncArray> for argument '%s'", info.name); |  | 2109 | failmsg("Expected Ptr<cv::AsyncArray> for argument '%s'", info.name);
| 2110 | return false; |  | 2110 | return false;
| 2111 | } |  | 2111 | }
| 2112 | }; |  | 2112 | };
| 2113 |  |  | 2113 |
| 2114 | //================================================================================ |  | 2114 | //================================================================================
| 2115 | // BFMatcher (Generic) |  | 2115 | // BFMatcher (Generic)
| 2116 | //================================================================================ |  | 2116 | //================================================================================
| 2117 |  |  | 2117 |
| 2118 | // GetSet (BFMatcher) |  | 2118 | // GetSet (BFMatcher)
| 2119 |  |  | 2119 |
| 2120 |  |  | 2120 |
| 2121 |  |  | 2121 |
| 2122 | // Methods (BFMatcher) |  | 2122 | // Methods (BFMatcher)
| 2123 |  |  | 2123 |
| 2124 | static int pyopencv_cv_BFMatcher_BFMatcher(pyopencv_BFMatcher_t* self, PyObject* py_args, PyObject* kw) |  | 2124 | static int pyopencv_cv_BFMatcher_BFMatcher(pyopencv_BFMatcher_t* self, PyObject* py_args, PyObject* kw)
| 2125 | { |  | 2125 | {
| 2126 | using namespace cv; |  | 2126 | using namespace cv;
| 2127 |  |  | 2127 |
| 2128 | PyObject* pyobj_normType = NULL; |  | 2128 | PyObject* pyobj_normType = NULL;
| 2129 | int normType=NORM_L2; |  | 2129 | int normType=NORM_L2;
| 2130 | PyObject* pyobj_crossCheck = NULL; |  | 2130 | PyObject* pyobj_crossCheck = NULL;
| 2131 | bool crossCheck=false; |  | 2131 | bool crossCheck=false;
| 2132 |  |  | 2132 |
| 2133 | const char* keywords[] = { "normType", "crossCheck", NULL }; |  | 2133 | const char* keywords[] = { "normType", "crossCheck", NULL };
| 2134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:BFMatcher", (char**)keywords, &pyobj_normType, &pyobj_crossCheck) && |  | 2134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:BFMatcher", (char**)keywords, &pyobj_normType, &pyobj_crossCheck) &&
| 2135 | pyopencv_to_safe(pyobj_normType, normType, ArgInfo("normType", 0)) && |  | 2135 | pyopencv_to_safe(pyobj_normType, normType, ArgInfo("normType", 0)) &&
| 2136 | pyopencv_to_safe(pyobj_crossCheck, crossCheck, ArgInfo("crossCheck", 0)) ) |  | 2136 | pyopencv_to_safe(pyobj_crossCheck, crossCheck, ArgInfo("crossCheck", 0)) )
| 2137 | { |  | 2137 | {
| 2138 | new (&(self->v)) Ptr<cv::BFMatcher>(); // init Ptr with placement new |  | 2138 | new (&(self->v)) Ptr<cv::BFMatcher>(); // init Ptr with placement new
| 2139 | if(self) ERRWRAP2(self->v.reset(new cv::BFMatcher(normType, crossCheck))); |  | 2139 | if(self) ERRWRAP2(self->v.reset(new cv::BFMatcher(normType, crossCheck)));
| 2140 | return 0; |  | 2140 | return 0;
| 2141 | } |  | 2141 | }
| 2142 |  |  | 2142 |
| 2143 | return -1; |  | 2143 | return -1;
| 2144 | } |  | 2144 | }
| 2145 |  |  | 2145 |
| 2146 | static PyObject* pyopencv_cv_BFMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2146 | static PyObject* pyopencv_cv_BFMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 2147 | { |  | 2147 | {
| 2148 | using namespace cv; |  | 2148 | using namespace cv;
| 2149 |  |  | 2149 |
| 2150 | PyObject* pyobj_normType = NULL; |  | 2150 | PyObject* pyobj_normType = NULL;
| 2151 | int normType=NORM_L2; |  | 2151 | int normType=NORM_L2;
| 2152 | PyObject* pyobj_crossCheck = NULL; |  | 2152 | PyObject* pyobj_crossCheck = NULL;
| 2153 | bool crossCheck=false; |  | 2153 | bool crossCheck=false;
| 2154 | Ptr<BFMatcher> retval; |  | 2154 | Ptr<BFMatcher> retval;
| 2155 |  |  | 2155 |
| 2156 | const char* keywords[] = { "normType", "crossCheck", NULL }; |  | 2156 | const char* keywords[] = { "normType", "crossCheck", NULL };
| 2157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:BFMatcher.create", (char**)keywords, &pyobj_normType, &pyobj_crossCheck) && |  | 2157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:BFMatcher.create", (char**)keywords, &pyobj_normType, &pyobj_crossCheck) &&
| 2158 | pyopencv_to_safe(pyobj_normType, normType, ArgInfo("normType", 0)) && |  | 2158 | pyopencv_to_safe(pyobj_normType, normType, ArgInfo("normType", 0)) &&
| 2159 | pyopencv_to_safe(pyobj_crossCheck, crossCheck, ArgInfo("crossCheck", 0)) ) |  | 2159 | pyopencv_to_safe(pyobj_crossCheck, crossCheck, ArgInfo("crossCheck", 0)) )
| 2160 | { |  | 2160 | {
| 2161 | ERRWRAP2(retval = cv::BFMatcher::create(normType, crossCheck)); |  | 2161 | ERRWRAP2(retval = cv::BFMatcher::create(normType, crossCheck));
| 2162 | return pyopencv_from(retval); |  | 2162 | return pyopencv_from(retval);
| 2163 | } |  | 2163 | }
| 2164 |  |  | 2164 |
| 2165 | return NULL; |  | 2165 | return NULL;
| 2166 | } |  | 2166 | }
| 2167 |  |  | 2167 |
| 2168 |  |  | 2168 |
| 2169 |  |  | 2169 |
| 2170 | // Tables (BFMatcher) |  | 2170 | // Tables (BFMatcher)
| 2171 |  |  | 2171 |
| 2172 | static PyGetSetDef pyopencv_BFMatcher_getseters[] = |  | 2172 | static PyGetSetDef pyopencv_BFMatcher_getseters[] =
| 2173 | { |  | 2173 | {
| 2174 | {NULL} /* Sentinel */ |  | 2174 | {NULL} /* Sentinel */
| 2175 | }; |  | 2175 | };
| 2176 |  |  | 2176 |
| 2177 | static PyMethodDef pyopencv_BFMatcher_methods[] = |  | 2177 | static PyMethodDef pyopencv_BFMatcher_methods[] =
| 2178 | { |  | 2178 | {
| 2179 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_BFMatcher_create_static, METH_STATIC), "create([, normType[, crossCheck]]) -> retval\n. @brief Brute-force matcher create method.\n. @param normType One of NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2. L1 and L2 norms are\n. preferable choices for SIFT and SURF descriptors, NORM_HAMMING should be used with ORB, BRISK and\n. BRIEF, NORM_HAMMING2 should be used with ORB when WTA_K==3 or 4 (see ORB::ORB constructor\n. description).\n. @param crossCheck If it is false, this is will be default BFMatcher behaviour when it finds the k\n. nearest neighbors for each query descriptor. If crossCheck==true, then the knnMatch() method with\n. k=1 will only return pairs (i,j) such that for i-th query descriptor the j-th descriptor in the\n. matcher's collection is the nearest and vice versa, i.e. the BFMatcher will only return consistent\n. pairs. Such technique usually produces best results with minimal number of outliers when there are\n. enough matches. This is alternative to the ratio test, used by D. Lowe in SIFT paper."}, |  | 2179 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_BFMatcher_create_static, METH_STATIC), "create([, normType[, crossCheck]]) -> retval\n. @brief Brute-force matcher create method.\n. @param normType One of NORM_L1, NORM_L2, NORM_HAMMING, NORM_HAMMING2. L1 and L2 norms are\n. preferable choices for SIFT and SURF descriptors, NORM_HAMMING should be used with ORB, BRISK and\n. BRIEF, NORM_HAMMING2 should be used with ORB when WTA_K==3 or 4 (see ORB::ORB constructor\n. description).\n. @param crossCheck If it is false, this is will be default BFMatcher behaviour when it finds the k\n. nearest neighbors for each query descriptor. If crossCheck==true, then the knnMatch() method with\n. k=1 will only return pairs (i,j) such that for i-th query descriptor the j-th descriptor in the\n. matcher's collection is the nearest and vice versa, i.e. the BFMatcher will only return consistent\n. pairs. Such technique usually produces best results with minimal number of outliers when there are\n. enough matches. This is alternative to the ratio test, used by D. Lowe in SIFT paper."},
| 2180 |  |  | 2180 |
| 2181 | {NULL, NULL} |  | 2181 | {NULL, NULL}
| 2182 | }; |  | 2182 | };
| 2183 |  |  | 2183 |
| 2184 | // Converter (BFMatcher) |  | 2184 | // Converter (BFMatcher)
| 2185 |  |  | 2185 |
| 2186 | template<> |  | 2186 | template<>
| 2187 | struct PyOpenCV_Converter< Ptr<cv::BFMatcher> > |  | 2187 | struct PyOpenCV_Converter< Ptr<cv::BFMatcher> >
| 2188 | { |  | 2188 | {
| 2189 | static PyObject* from(const Ptr<cv::BFMatcher>& r) |  | 2189 | static PyObject* from(const Ptr<cv::BFMatcher>& r)
| 2190 | { |  | 2190 | {
| 2191 | return pyopencv_BFMatcher_Instance(r); |  | 2191 | return pyopencv_BFMatcher_Instance(r);
| 2192 | } |  | 2192 | }
| 2193 | static bool to(PyObject* src, Ptr<cv::BFMatcher>& dst, const ArgInfo& info) |  | 2193 | static bool to(PyObject* src, Ptr<cv::BFMatcher>& dst, const ArgInfo& info)
| 2194 | { |  | 2194 | {
| 2195 | if(!src || src == Py_None) |  | 2195 | if(!src || src == Py_None)
| 2196 | return true; |  | 2196 | return true;
| 2197 | Ptr<cv::BFMatcher> * dst_; |  | 2197 | Ptr<cv::BFMatcher> * dst_;
| 2198 | if (pyopencv_BFMatcher_getp(src, dst_)) |  | 2198 | if (pyopencv_BFMatcher_getp(src, dst_))
| 2199 | { |  | 2199 | {
| 2200 | dst = *dst_; |  | 2200 | dst = *dst_;
| 2201 | return true; |  | 2201 | return true;
| 2202 | } |  | 2202 | }
| 2203 |  |  | 2203 |
| 2204 | failmsg("Expected Ptr<cv::BFMatcher> for argument '%s'", info.name); |  | 2204 | failmsg("Expected Ptr<cv::BFMatcher> for argument '%s'", info.name);
| 2205 | return false; |  | 2205 | return false;
| 2206 | } |  | 2206 | }
| 2207 | }; |  | 2207 | };
| 2208 |  |  | 2208 |
| 2209 | //================================================================================ |  | 2209 | //================================================================================
| 2210 | // BOWImgDescriptorExtractor (Generic) |  | 2210 | // BOWImgDescriptorExtractor (Generic)
| 2211 | //================================================================================ |  | 2211 | //================================================================================
| 2212 |  |  | 2212 |
| 2213 | // GetSet (BOWImgDescriptorExtractor) |  | 2213 | // GetSet (BOWImgDescriptorExtractor)
| 2214 |  |  | 2214 |
| 2215 |  |  | 2215 |
| 2216 |  |  | 2216 |
| 2217 | // Methods (BOWImgDescriptorExtractor) |  | 2217 | // Methods (BOWImgDescriptorExtractor)
| 2218 |  |  | 2218 |
| 2219 | static int pyopencv_cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor(pyopencv_BOWImgDescriptorExtractor_t* self, PyObject* py_args, PyObject* kw) |  | 2219 | static int pyopencv_cv_BOWImgDescriptorExtractor_BOWImgDescriptorExtractor(pyopencv_BOWImgDescriptorExtractor_t* self, PyObject* py_args, PyObject* kw)
| 2220 | { |  | 2220 | {
| 2221 | using namespace cv; |  | 2221 | using namespace cv;
| 2222 |  |  | 2222 |
| 2223 | PyObject* pyobj_dextractor = NULL; |  | 2223 | PyObject* pyobj_dextractor = NULL;
| 2224 | Ptr<Feature2D> dextractor; |  | 2224 | Ptr<Feature2D> dextractor;
| 2225 | PyObject* pyobj_dmatcher = NULL; |  | 2225 | PyObject* pyobj_dmatcher = NULL;
| 2226 | Ptr<DescriptorMatcher> dmatcher; |  | 2226 | Ptr<DescriptorMatcher> dmatcher;
| 2227 |  |  | 2227 |
| 2228 | const char* keywords[] = { "dextractor", "dmatcher", NULL }; |  | 2228 | const char* keywords[] = { "dextractor", "dmatcher", NULL };
| 2229 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:BOWImgDescriptorExtractor", (char**)keywords, &pyobj_dextractor, &pyobj_dmatcher) && |  | 2229 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:BOWImgDescriptorExtractor", (char**)keywords, &pyobj_dextractor, &pyobj_dmatcher) &&
| 2230 | pyopencv_to_safe(pyobj_dextractor, dextractor, ArgInfo("dextractor", 0)) && |  | 2230 | pyopencv_to_safe(pyobj_dextractor, dextractor, ArgInfo("dextractor", 0)) &&
| 2231 | pyopencv_to_safe(pyobj_dmatcher, dmatcher, ArgInfo("dmatcher", 0)) ) |  | 2231 | pyopencv_to_safe(pyobj_dmatcher, dmatcher, ArgInfo("dmatcher", 0)) )
| 2232 | { |  | 2232 | {
| 2233 | new (&(self->v)) Ptr<cv::BOWImgDescriptorExtractor>(); // init Ptr with placement new |  | 2233 | new (&(self->v)) Ptr<cv::BOWImgDescriptorExtractor>(); // init Ptr with placement new
| 2234 | if(self) ERRWRAP2(self->v.reset(new cv::BOWImgDescriptorExtractor(dextractor, dmatcher))); |  | 2234 | if(self) ERRWRAP2(self->v.reset(new cv::BOWImgDescriptorExtractor(dextractor, dmatcher)));
| 2235 | return 0; |  | 2235 | return 0;
| 2236 | } |  | 2236 | }
| 2237 |  |  | 2237 |
| 2238 | return -1; |  | 2238 | return -1;
| 2239 | } |  | 2239 | }
| 2240 |  |  | 2240 |
| 2241 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2241 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 2242 | { |  | 2242 | {
| 2243 | using namespace cv; |  | 2243 | using namespace cv;
| 2244 |  |  | 2244 |
| 2245 |  |  | 2245 |
| 2246 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0; |  | 2246 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0;
| 2247 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1)) |  | 2247 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1))
| 2248 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)"); |  | 2248 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)");
| 2249 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1); |  | 2249 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1);
| 2250 | PyObject* pyobj_image = NULL; |  | 2250 | PyObject* pyobj_image = NULL;
| 2251 | Mat image; |  | 2251 | Mat image;
| 2252 | PyObject* pyobj_keypoints = NULL; |  | 2252 | PyObject* pyobj_keypoints = NULL;
| 2253 | vector_KeyPoint keypoints; |  | 2253 | vector_KeyPoint keypoints;
| 2254 | PyObject* pyobj_imgDescriptor = NULL; |  | 2254 | PyObject* pyobj_imgDescriptor = NULL;
| 2255 | Mat imgDescriptor; |  | 2255 | Mat imgDescriptor;
| 2256 |  |  | 2256 |
| 2257 | const char* keywords[] = { "image", "keypoints", "imgDescriptor", NULL }; |  | 2257 | const char* keywords[] = { "image", "keypoints", "imgDescriptor", NULL };
| 2258 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:BOWImgDescriptorExtractor.compute", (char**)keywords, &pyobj_image, &pyobj_keypoints, &pyobj_imgDescriptor) && |  | 2258 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:BOWImgDescriptorExtractor.compute", (char**)keywords, &pyobj_image, &pyobj_keypoints, &pyobj_imgDescriptor) &&
| 2259 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 2259 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 2260 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 0)) && |  | 2260 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 0)) &&
| 2261 | pyopencv_to_safe(pyobj_imgDescriptor, imgDescriptor, ArgInfo("imgDescriptor", 1)) ) |  | 2261 | pyopencv_to_safe(pyobj_imgDescriptor, imgDescriptor, ArgInfo("imgDescriptor", 1)) )
| 2262 | { |  | 2262 | {
| 2263 | ERRWRAP2(_self_->compute2(image, keypoints, imgDescriptor)); |  | 2263 | ERRWRAP2(_self_->compute2(image, keypoints, imgDescriptor));
| 2264 | return pyopencv_from(imgDescriptor); |  | 2264 | return pyopencv_from(imgDescriptor);
| 2265 | } |  | 2265 | }
| 2266 |  |  | 2266 |
| 2267 | return NULL; |  | 2267 | return NULL;
| 2268 | } |  | 2268 | }
| 2269 |  |  | 2269 |
| 2270 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_descriptorSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2270 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_descriptorSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 2271 | { |  | 2271 | {
| 2272 | using namespace cv; |  | 2272 | using namespace cv;
| 2273 |  |  | 2273 |
| 2274 |  |  | 2274 |
| 2275 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0; |  | 2275 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0;
| 2276 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1)) |  | 2276 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1))
| 2277 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)"); |  | 2277 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)");
| 2278 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1); |  | 2278 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1);
| 2279 | int retval; |  | 2279 | int retval;
| 2280 |  |  | 2280 |
| 2281 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2281 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2282 | { |  | 2282 | {
| 2283 | ERRWRAP2(retval = _self_->descriptorSize()); |  | 2283 | ERRWRAP2(retval = _self_->descriptorSize());
| 2284 | return pyopencv_from(retval); |  | 2284 | return pyopencv_from(retval);
| 2285 | } |  | 2285 | }
| 2286 |  |  | 2286 |
| 2287 | return NULL; |  | 2287 | return NULL;
| 2288 | } |  | 2288 | }
| 2289 |  |  | 2289 |
| 2290 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_descriptorType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2290 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_descriptorType(PyObject* self, PyObject* py_args, PyObject* kw)
| 2291 | { |  | 2291 | {
| 2292 | using namespace cv; |  | 2292 | using namespace cv;
| 2293 |  |  | 2293 |
| 2294 |  |  | 2294 |
| 2295 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0; |  | 2295 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0;
| 2296 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1)) |  | 2296 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1))
| 2297 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)"); |  | 2297 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)");
| 2298 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1); |  | 2298 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1);
| 2299 | int retval; |  | 2299 | int retval;
| 2300 |  |  | 2300 |
| 2301 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2301 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2302 | { |  | 2302 | {
| 2303 | ERRWRAP2(retval = _self_->descriptorType()); |  | 2303 | ERRWRAP2(retval = _self_->descriptorType());
| 2304 | return pyopencv_from(retval); |  | 2304 | return pyopencv_from(retval);
| 2305 | } |  | 2305 | }
| 2306 |  |  | 2306 |
| 2307 | return NULL; |  | 2307 | return NULL;
| 2308 | } |  | 2308 | }
| 2309 |  |  | 2309 |
| 2310 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_getVocabulary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2310 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_getVocabulary(PyObject* self, PyObject* py_args, PyObject* kw)
| 2311 | { |  | 2311 | {
| 2312 | using namespace cv; |  | 2312 | using namespace cv;
| 2313 |  |  | 2313 |
| 2314 |  |  | 2314 |
| 2315 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0; |  | 2315 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0;
| 2316 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1)) |  | 2316 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1))
| 2317 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)"); |  | 2317 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)");
| 2318 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1); |  | 2318 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1);
| 2319 | Mat retval; |  | 2319 | Mat retval;
| 2320 |  |  | 2320 |
| 2321 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2321 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2322 | { |  | 2322 | {
| 2323 | ERRWRAP2(retval = _self_->getVocabulary()); |  | 2323 | ERRWRAP2(retval = _self_->getVocabulary());
| 2324 | return pyopencv_from(retval); |  | 2324 | return pyopencv_from(retval);
| 2325 | } |  | 2325 | }
| 2326 |  |  | 2326 |
| 2327 | return NULL; |  | 2327 | return NULL;
| 2328 | } |  | 2328 | }
| 2329 |  |  | 2329 |
| 2330 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_setVocabulary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2330 | static PyObject* pyopencv_cv_BOWImgDescriptorExtractor_setVocabulary(PyObject* self, PyObject* py_args, PyObject* kw)
| 2331 | { |  | 2331 | {
| 2332 | using namespace cv; |  | 2332 | using namespace cv;
| 2333 |  |  | 2333 |
| 2334 |  |  | 2334 |
| 2335 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0; |  | 2335 | Ptr<cv::BOWImgDescriptorExtractor> * self1 = 0;
| 2336 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1)) |  | 2336 | if (!pyopencv_BOWImgDescriptorExtractor_getp(self, self1))
| 2337 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)"); |  | 2337 | return failmsgp("Incorrect type of self (must be 'BOWImgDescriptorExtractor' or its derivative)");
| 2338 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1); |  | 2338 | Ptr<cv::BOWImgDescriptorExtractor> _self_ = *(self1);
| 2339 | PyObject* pyobj_vocabulary = NULL; |  | 2339 | PyObject* pyobj_vocabulary = NULL;
| 2340 | Mat vocabulary; |  | 2340 | Mat vocabulary;
| 2341 |  |  | 2341 |
| 2342 | const char* keywords[] = { "vocabulary", NULL }; |  | 2342 | const char* keywords[] = { "vocabulary", NULL };
| 2343 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWImgDescriptorExtractor.setVocabulary", (char**)keywords, &pyobj_vocabulary) && |  | 2343 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWImgDescriptorExtractor.setVocabulary", (char**)keywords, &pyobj_vocabulary) &&
| 2344 | pyopencv_to_safe(pyobj_vocabulary, vocabulary, ArgInfo("vocabulary", 0)) ) |  | 2344 | pyopencv_to_safe(pyobj_vocabulary, vocabulary, ArgInfo("vocabulary", 0)) )
| 2345 | { |  | 2345 | {
| 2346 | ERRWRAP2(_self_->setVocabulary(vocabulary)); |  | 2346 | ERRWRAP2(_self_->setVocabulary(vocabulary));
| 2347 | Py_RETURN_NONE; |  | 2347 | Py_RETURN_NONE;
| 2348 | } |  | 2348 | }
| 2349 |  |  | 2349 |
| 2350 | return NULL; |  | 2350 | return NULL;
| 2351 | } |  | 2351 | }
| 2352 |  |  | 2352 |
| 2353 |  |  | 2353 |
| 2354 |  |  | 2354 |
| 2355 | // Tables (BOWImgDescriptorExtractor) |  | 2355 | // Tables (BOWImgDescriptorExtractor)
| 2356 |  |  | 2356 |
| 2357 | static PyGetSetDef pyopencv_BOWImgDescriptorExtractor_getseters[] = |  | 2357 | static PyGetSetDef pyopencv_BOWImgDescriptorExtractor_getseters[] =
| 2358 | { |  | 2358 | {
| 2359 | {NULL} /* Sentinel */ |  | 2359 | {NULL} /* Sentinel */
| 2360 | }; |  | 2360 | };
| 2361 |  |  | 2361 |
| 2362 | static PyMethodDef pyopencv_BOWImgDescriptorExtractor_methods[] = |  | 2362 | static PyMethodDef pyopencv_BOWImgDescriptorExtractor_methods[] =
| 2363 | { |  | 2363 | {
| 2364 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_compute, 0), "compute(image, keypoints[, imgDescriptor]) -> imgDescriptor\n. @overload\n. @param keypointDescriptors Computed descriptors to match with vocabulary.\n. @param imgDescriptor Computed output image descriptor.\n. @param pointIdxsOfClusters Indices of keypoints that belong to the cluster. This means that\n. pointIdxsOfClusters[i] are keypoint indices that belong to the i -th cluster (word of vocabulary)\n. returned if it is non-zero."}, |  | 2364 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_compute, 0), "compute(image, keypoints[, imgDescriptor]) -> imgDescriptor\n. @overload\n. @param keypointDescriptors Computed descriptors to match with vocabulary.\n. @param imgDescriptor Computed output image descriptor.\n. @param pointIdxsOfClusters Indices of keypoints that belong to the cluster. This means that\n. pointIdxsOfClusters[i] are keypoint indices that belong to the i -th cluster (word of vocabulary)\n. returned if it is non-zero."},
| 2365 | {"descriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_descriptorSize, 0), "descriptorSize() -> retval\n. @brief Returns an image descriptor size if the vocabulary is set. Otherwise, it returns 0."}, |  | 2365 | {"descriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_descriptorSize, 0), "descriptorSize() -> retval\n. @brief Returns an image descriptor size if the vocabulary is set. Otherwise, it returns 0."},
| 2366 | {"descriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_descriptorType, 0), "descriptorType() -> retval\n. @brief Returns an image descriptor type."}, |  | 2366 | {"descriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_descriptorType, 0), "descriptorType() -> retval\n. @brief Returns an image descriptor type."},
| 2367 | {"getVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_getVocabulary, 0), "getVocabulary() -> retval\n. @brief Returns the set vocabulary."}, |  | 2367 | {"getVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_getVocabulary, 0), "getVocabulary() -> retval\n. @brief Returns the set vocabulary."},
| 2368 | {"setVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_setVocabulary, 0), "setVocabulary(vocabulary) -> None\n. @brief Sets a visual vocabulary.\n. \n. @param vocabulary Vocabulary (can be trained using the inheritor of BOWTrainer ). Each row of the\n. vocabulary is a visual word (cluster center)."}, |  | 2368 | {"setVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWImgDescriptorExtractor_setVocabulary, 0), "setVocabulary(vocabulary) -> None\n. @brief Sets a visual vocabulary.\n. \n. @param vocabulary Vocabulary (can be trained using the inheritor of BOWTrainer ). Each row of the\n. vocabulary is a visual word (cluster center)."},
| 2369 |  |  | 2369 |
| 2370 | {NULL, NULL} |  | 2370 | {NULL, NULL}
| 2371 | }; |  | 2371 | };
| 2372 |  |  | 2372 |
| 2373 | // Converter (BOWImgDescriptorExtractor) |  | 2373 | // Converter (BOWImgDescriptorExtractor)
| 2374 |  |  | 2374 |
| 2375 | template<> |  | 2375 | template<>
| 2376 | struct PyOpenCV_Converter< Ptr<cv::BOWImgDescriptorExtractor> > |  | 2376 | struct PyOpenCV_Converter< Ptr<cv::BOWImgDescriptorExtractor> >
| 2377 | { |  | 2377 | {
| 2378 | static PyObject* from(const Ptr<cv::BOWImgDescriptorExtractor>& r) |  | 2378 | static PyObject* from(const Ptr<cv::BOWImgDescriptorExtractor>& r)
| 2379 | { |  | 2379 | {
| 2380 | return pyopencv_BOWImgDescriptorExtractor_Instance(r); |  | 2380 | return pyopencv_BOWImgDescriptorExtractor_Instance(r);
| 2381 | } |  | 2381 | }
| 2382 | static bool to(PyObject* src, Ptr<cv::BOWImgDescriptorExtractor>& dst, const ArgInfo& info) |  | 2382 | static bool to(PyObject* src, Ptr<cv::BOWImgDescriptorExtractor>& dst, const ArgInfo& info)
| 2383 | { |  | 2383 | {
| 2384 | if(!src || src == Py_None) |  | 2384 | if(!src || src == Py_None)
| 2385 | return true; |  | 2385 | return true;
| 2386 | Ptr<cv::BOWImgDescriptorExtractor> * dst_; |  | 2386 | Ptr<cv::BOWImgDescriptorExtractor> * dst_;
| 2387 | if (pyopencv_BOWImgDescriptorExtractor_getp(src, dst_)) |  | 2387 | if (pyopencv_BOWImgDescriptorExtractor_getp(src, dst_))
| 2388 | { |  | 2388 | {
| 2389 | dst = *dst_; |  | 2389 | dst = *dst_;
| 2390 | return true; |  | 2390 | return true;
| 2391 | } |  | 2391 | }
| 2392 |  |  | 2392 |
| 2393 | failmsg("Expected Ptr<cv::BOWImgDescriptorExtractor> for argument '%s'", info.name); |  | 2393 | failmsg("Expected Ptr<cv::BOWImgDescriptorExtractor> for argument '%s'", info.name);
| 2394 | return false; |  | 2394 | return false;
| 2395 | } |  | 2395 | }
| 2396 | }; |  | 2396 | };
| 2397 |  |  | 2397 |
| 2398 | //================================================================================ |  | 2398 | //================================================================================
| 2399 | // BOWKMeansTrainer (Generic) |  | 2399 | // BOWKMeansTrainer (Generic)
| 2400 | //================================================================================ |  | 2400 | //================================================================================
| 2401 |  |  | 2401 |
| 2402 | // GetSet (BOWKMeansTrainer) |  | 2402 | // GetSet (BOWKMeansTrainer)
| 2403 |  |  | 2403 |
| 2404 |  |  | 2404 |
| 2405 |  |  | 2405 |
| 2406 | // Methods (BOWKMeansTrainer) |  | 2406 | // Methods (BOWKMeansTrainer)
| 2407 |  |  | 2407 |
| 2408 | static int pyopencv_cv_BOWKMeansTrainer_BOWKMeansTrainer(pyopencv_BOWKMeansTrainer_t* self, PyObject* py_args, PyObject* kw) |  | 2408 | static int pyopencv_cv_BOWKMeansTrainer_BOWKMeansTrainer(pyopencv_BOWKMeansTrainer_t* self, PyObject* py_args, PyObject* kw)
| 2409 | { |  | 2409 | {
| 2410 | using namespace cv; |  | 2410 | using namespace cv;
| 2411 |  |  | 2411 |
| 2412 | PyObject* pyobj_clusterCount = NULL; |  | 2412 | PyObject* pyobj_clusterCount = NULL;
| 2413 | int clusterCount=0; |  | 2413 | int clusterCount=0;
| 2414 | PyObject* pyobj_termcrit = NULL; |  | 2414 | PyObject* pyobj_termcrit = NULL;
| 2415 | TermCriteria termcrit; |  | 2415 | TermCriteria termcrit;
| 2416 | PyObject* pyobj_attempts = NULL; |  | 2416 | PyObject* pyobj_attempts = NULL;
| 2417 | int attempts=3; |  | 2417 | int attempts=3;
| 2418 | PyObject* pyobj_flags = NULL; |  | 2418 | PyObject* pyobj_flags = NULL;
| 2419 | int flags=KMEANS_PP_CENTERS; |  | 2419 | int flags=KMEANS_PP_CENTERS;
| 2420 |  |  | 2420 |
| 2421 | const char* keywords[] = { "clusterCount", "termcrit", "attempts", "flags", NULL }; |  | 2421 | const char* keywords[] = { "clusterCount", "termcrit", "attempts", "flags", NULL };
| 2422 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:BOWKMeansTrainer", (char**)keywords, &pyobj_clusterCount, &pyobj_termcrit, &pyobj_attempts, &pyobj_flags) && |  | 2422 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:BOWKMeansTrainer", (char**)keywords, &pyobj_clusterCount, &pyobj_termcrit, &pyobj_attempts, &pyobj_flags) &&
| 2423 | pyopencv_to_safe(pyobj_clusterCount, clusterCount, ArgInfo("clusterCount", 0)) && |  | 2423 | pyopencv_to_safe(pyobj_clusterCount, clusterCount, ArgInfo("clusterCount", 0)) &&
| 2424 | pyopencv_to_safe(pyobj_termcrit, termcrit, ArgInfo("termcrit", 0)) && |  | 2424 | pyopencv_to_safe(pyobj_termcrit, termcrit, ArgInfo("termcrit", 0)) &&
| 2425 | pyopencv_to_safe(pyobj_attempts, attempts, ArgInfo("attempts", 0)) && |  | 2425 | pyopencv_to_safe(pyobj_attempts, attempts, ArgInfo("attempts", 0)) &&
| 2426 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 2426 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 2427 | { |  | 2427 | {
| 2428 | new (&(self->v)) Ptr<cv::BOWKMeansTrainer>(); // init Ptr with placement new |  | 2428 | new (&(self->v)) Ptr<cv::BOWKMeansTrainer>(); // init Ptr with placement new
| 2429 | if(self) ERRWRAP2(self->v.reset(new cv::BOWKMeansTrainer(clusterCount, termcrit, attempts, flags))); |  | 2429 | if(self) ERRWRAP2(self->v.reset(new cv::BOWKMeansTrainer(clusterCount, termcrit, attempts, flags)));
| 2430 | return 0; |  | 2430 | return 0;
| 2431 | } |  | 2431 | }
| 2432 |  |  | 2432 |
| 2433 | return -1; |  | 2433 | return -1;
| 2434 | } |  | 2434 | }
| 2435 |  |  | 2435 |
| 2436 | static PyObject* pyopencv_cv_BOWKMeansTrainer_cluster(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2436 | static PyObject* pyopencv_cv_BOWKMeansTrainer_cluster(PyObject* self, PyObject* py_args, PyObject* kw)
| 2437 | { |  | 2437 | {
| 2438 | using namespace cv; |  | 2438 | using namespace cv;
| 2439 |  |  | 2439 |
| 2440 |  |  | 2440 |
| 2441 | Ptr<cv::BOWKMeansTrainer> * self1 = 0; |  | 2441 | Ptr<cv::BOWKMeansTrainer> * self1 = 0;
| 2442 | if (!pyopencv_BOWKMeansTrainer_getp(self, self1)) |  | 2442 | if (!pyopencv_BOWKMeansTrainer_getp(self, self1))
| 2443 | return failmsgp("Incorrect type of self (must be 'BOWKMeansTrainer' or its derivative)"); |  | 2443 | return failmsgp("Incorrect type of self (must be 'BOWKMeansTrainer' or its derivative)");
| 2444 | Ptr<cv::BOWKMeansTrainer> _self_ = *(self1); |  | 2444 | Ptr<cv::BOWKMeansTrainer> _self_ = *(self1);
| 2445 | pyPrepareArgumentConversionErrorsStorage(2); |  | 2445 | pyPrepareArgumentConversionErrorsStorage(2);
| 2446 |  |  | 2446 |
| 2447 | { |  | 2447 | {
| 2448 | Mat retval; |  | 2448 | Mat retval;
| 2449 |  |  | 2449 |
| 2450 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2450 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2451 | { |  | 2451 | {
| 2452 | ERRWRAP2(retval = _self_->cluster()); |  | 2452 | ERRWRAP2(retval = _self_->cluster());
| 2453 | return pyopencv_from(retval); |  | 2453 | return pyopencv_from(retval);
| 2454 | } |  | 2454 | }
| 2455 |  |  | 2455 |
| 2456 |  |  | 2456 |
| 2457 | pyPopulateArgumentConversionErrors(); |  | 2457 | pyPopulateArgumentConversionErrors();
| 2458 | } |  | 2458 | }
| 2459 |  |  | 2459 |
| 2460 |  |  | 2460 |
| 2461 | { |  | 2461 | {
| 2462 | PyObject* pyobj_descriptors = NULL; |  | 2462 | PyObject* pyobj_descriptors = NULL;
| 2463 | Mat descriptors; |  | 2463 | Mat descriptors;
| 2464 | Mat retval; |  | 2464 | Mat retval;
| 2465 |  |  | 2465 |
| 2466 | const char* keywords[] = { "descriptors", NULL }; |  | 2466 | const char* keywords[] = { "descriptors", NULL };
| 2467 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWKMeansTrainer.cluster", (char**)keywords, &pyobj_descriptors) && |  | 2467 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWKMeansTrainer.cluster", (char**)keywords, &pyobj_descriptors) &&
| 2468 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) ) |  | 2468 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) )
| 2469 | { |  | 2469 | {
| 2470 | ERRWRAP2(retval = _self_->cluster(descriptors)); |  | 2470 | ERRWRAP2(retval = _self_->cluster(descriptors));
| 2471 | return pyopencv_from(retval); |  | 2471 | return pyopencv_from(retval);
| 2472 | } |  | 2472 | }
| 2473 |  |  | 2473 |
| 2474 |  |  | 2474 |
| 2475 | pyPopulateArgumentConversionErrors(); |  | 2475 | pyPopulateArgumentConversionErrors();
| 2476 | } |  | 2476 | }
| 2477 | pyRaiseCVOverloadException("cluster"); |  | 2477 | pyRaiseCVOverloadException("cluster");
| 2478 |  |  | 2478 |
| 2479 | return NULL; |  | 2479 | return NULL;
| 2480 | } |  | 2480 | }
| 2481 |  |  | 2481 |
| 2482 |  |  | 2482 |
| 2483 |  |  | 2483 |
| 2484 | // Tables (BOWKMeansTrainer) |  | 2484 | // Tables (BOWKMeansTrainer)
| 2485 |  |  | 2485 |
| 2486 | static PyGetSetDef pyopencv_BOWKMeansTrainer_getseters[] = |  | 2486 | static PyGetSetDef pyopencv_BOWKMeansTrainer_getseters[] =
| 2487 | { |  | 2487 | {
| 2488 | {NULL} /* Sentinel */ |  | 2488 | {NULL} /* Sentinel */
| 2489 | }; |  | 2489 | };
| 2490 |  |  | 2490 |
| 2491 | static PyMethodDef pyopencv_BOWKMeansTrainer_methods[] = |  | 2491 | static PyMethodDef pyopencv_BOWKMeansTrainer_methods[] =
| 2492 | { |  | 2492 | {
| 2493 | {"cluster", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWKMeansTrainer_cluster, 0), "cluster() -> retval\n. \n\n\n\ncluster(descriptors) -> retval\n."}, |  | 2493 | {"cluster", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWKMeansTrainer_cluster, 0), "cluster() -> retval\n. \n\n\n\ncluster(descriptors) -> retval\n."},
| 2494 |  |  | 2494 |
| 2495 | {NULL, NULL} |  | 2495 | {NULL, NULL}
| 2496 | }; |  | 2496 | };
| 2497 |  |  | 2497 |
| 2498 | // Converter (BOWKMeansTrainer) |  | 2498 | // Converter (BOWKMeansTrainer)
| 2499 |  |  | 2499 |
| 2500 | template<> |  | 2500 | template<>
| 2501 | struct PyOpenCV_Converter< Ptr<cv::BOWKMeansTrainer> > |  | 2501 | struct PyOpenCV_Converter< Ptr<cv::BOWKMeansTrainer> >
| 2502 | { |  | 2502 | {
| 2503 | static PyObject* from(const Ptr<cv::BOWKMeansTrainer>& r) |  | 2503 | static PyObject* from(const Ptr<cv::BOWKMeansTrainer>& r)
| 2504 | { |  | 2504 | {
| 2505 | return pyopencv_BOWKMeansTrainer_Instance(r); |  | 2505 | return pyopencv_BOWKMeansTrainer_Instance(r);
| 2506 | } |  | 2506 | }
| 2507 | static bool to(PyObject* src, Ptr<cv::BOWKMeansTrainer>& dst, const ArgInfo& info) |  | 2507 | static bool to(PyObject* src, Ptr<cv::BOWKMeansTrainer>& dst, const ArgInfo& info)
| 2508 | { |  | 2508 | {
| 2509 | if(!src || src == Py_None) |  | 2509 | if(!src || src == Py_None)
| 2510 | return true; |  | 2510 | return true;
| 2511 | Ptr<cv::BOWKMeansTrainer> * dst_; |  | 2511 | Ptr<cv::BOWKMeansTrainer> * dst_;
| 2512 | if (pyopencv_BOWKMeansTrainer_getp(src, dst_)) |  | 2512 | if (pyopencv_BOWKMeansTrainer_getp(src, dst_))
| 2513 | { |  | 2513 | {
| 2514 | dst = *dst_; |  | 2514 | dst = *dst_;
| 2515 | return true; |  | 2515 | return true;
| 2516 | } |  | 2516 | }
| 2517 |  |  | 2517 |
| 2518 | failmsg("Expected Ptr<cv::BOWKMeansTrainer> for argument '%s'", info.name); |  | 2518 | failmsg("Expected Ptr<cv::BOWKMeansTrainer> for argument '%s'", info.name);
| 2519 | return false; |  | 2519 | return false;
| 2520 | } |  | 2520 | }
| 2521 | }; |  | 2521 | };
| 2522 |  |  | 2522 |
| 2523 | //================================================================================ |  | 2523 | //================================================================================
| 2524 | // BOWTrainer (Generic) |  | 2524 | // BOWTrainer (Generic)
| 2525 | //================================================================================ |  | 2525 | //================================================================================
| 2526 |  |  | 2526 |
| 2527 | // GetSet (BOWTrainer) |  | 2527 | // GetSet (BOWTrainer)
| 2528 |  |  | 2528 |
| 2529 |  |  | 2529 |
| 2530 |  |  | 2530 |
| 2531 | // Methods (BOWTrainer) |  | 2531 | // Methods (BOWTrainer)
| 2532 |  |  | 2532 |
| 2533 | static PyObject* pyopencv_cv_BOWTrainer_add(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2533 | static PyObject* pyopencv_cv_BOWTrainer_add(PyObject* self, PyObject* py_args, PyObject* kw)
| 2534 | { |  | 2534 | {
| 2535 | using namespace cv; |  | 2535 | using namespace cv;
| 2536 |  |  | 2536 |
| 2537 |  |  | 2537 |
| 2538 | Ptr<cv::BOWTrainer> * self1 = 0; |  | 2538 | Ptr<cv::BOWTrainer> * self1 = 0;
| 2539 | if (!pyopencv_BOWTrainer_getp(self, self1)) |  | 2539 | if (!pyopencv_BOWTrainer_getp(self, self1))
| 2540 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)"); |  | 2540 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)");
| 2541 | Ptr<cv::BOWTrainer> _self_ = *(self1); |  | 2541 | Ptr<cv::BOWTrainer> _self_ = *(self1);
| 2542 | PyObject* pyobj_descriptors = NULL; |  | 2542 | PyObject* pyobj_descriptors = NULL;
| 2543 | Mat descriptors; |  | 2543 | Mat descriptors;
| 2544 |  |  | 2544 |
| 2545 | const char* keywords[] = { "descriptors", NULL }; |  | 2545 | const char* keywords[] = { "descriptors", NULL };
| 2546 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWTrainer.add", (char**)keywords, &pyobj_descriptors) && |  | 2546 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWTrainer.add", (char**)keywords, &pyobj_descriptors) &&
| 2547 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) ) |  | 2547 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) )
| 2548 | { |  | 2548 | {
| 2549 | ERRWRAP2(_self_->add(descriptors)); |  | 2549 | ERRWRAP2(_self_->add(descriptors));
| 2550 | Py_RETURN_NONE; |  | 2550 | Py_RETURN_NONE;
| 2551 | } |  | 2551 | }
| 2552 |  |  | 2552 |
| 2553 | return NULL; |  | 2553 | return NULL;
| 2554 | } |  | 2554 | }
| 2555 |  |  | 2555 |
| 2556 | static PyObject* pyopencv_cv_BOWTrainer_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2556 | static PyObject* pyopencv_cv_BOWTrainer_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 2557 | { |  | 2557 | {
| 2558 | using namespace cv; |  | 2558 | using namespace cv;
| 2559 |  |  | 2559 |
| 2560 |  |  | 2560 |
| 2561 | Ptr<cv::BOWTrainer> * self1 = 0; |  | 2561 | Ptr<cv::BOWTrainer> * self1 = 0;
| 2562 | if (!pyopencv_BOWTrainer_getp(self, self1)) |  | 2562 | if (!pyopencv_BOWTrainer_getp(self, self1))
| 2563 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)"); |  | 2563 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)");
| 2564 | Ptr<cv::BOWTrainer> _self_ = *(self1); |  | 2564 | Ptr<cv::BOWTrainer> _self_ = *(self1);
| 2565 |  |  | 2565 |
| 2566 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2566 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2567 | { |  | 2567 | {
| 2568 | ERRWRAP2(_self_->clear()); |  | 2568 | ERRWRAP2(_self_->clear());
| 2569 | Py_RETURN_NONE; |  | 2569 | Py_RETURN_NONE;
| 2570 | } |  | 2570 | }
| 2571 |  |  | 2571 |
| 2572 | return NULL; |  | 2572 | return NULL;
| 2573 | } |  | 2573 | }
| 2574 |  |  | 2574 |
| 2575 | static PyObject* pyopencv_cv_BOWTrainer_cluster(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2575 | static PyObject* pyopencv_cv_BOWTrainer_cluster(PyObject* self, PyObject* py_args, PyObject* kw)
| 2576 | { |  | 2576 | {
| 2577 | using namespace cv; |  | 2577 | using namespace cv;
| 2578 |  |  | 2578 |
| 2579 |  |  | 2579 |
| 2580 | Ptr<cv::BOWTrainer> * self1 = 0; |  | 2580 | Ptr<cv::BOWTrainer> * self1 = 0;
| 2581 | if (!pyopencv_BOWTrainer_getp(self, self1)) |  | 2581 | if (!pyopencv_BOWTrainer_getp(self, self1))
| 2582 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)"); |  | 2582 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)");
| 2583 | Ptr<cv::BOWTrainer> _self_ = *(self1); |  | 2583 | Ptr<cv::BOWTrainer> _self_ = *(self1);
| 2584 | pyPrepareArgumentConversionErrorsStorage(2); |  | 2584 | pyPrepareArgumentConversionErrorsStorage(2);
| 2585 |  |  | 2585 |
| 2586 | { |  | 2586 | {
| 2587 | Mat retval; |  | 2587 | Mat retval;
| 2588 |  |  | 2588 |
| 2589 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2589 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2590 | { |  | 2590 | {
| 2591 | ERRWRAP2(retval = _self_->cluster()); |  | 2591 | ERRWRAP2(retval = _self_->cluster());
| 2592 | return pyopencv_from(retval); |  | 2592 | return pyopencv_from(retval);
| 2593 | } |  | 2593 | }
| 2594 |  |  | 2594 |
| 2595 |  |  | 2595 |
| 2596 | pyPopulateArgumentConversionErrors(); |  | 2596 | pyPopulateArgumentConversionErrors();
| 2597 | } |  | 2597 | }
| 2598 |  |  | 2598 |
| 2599 |  |  | 2599 |
| 2600 | { |  | 2600 | {
| 2601 | PyObject* pyobj_descriptors = NULL; |  | 2601 | PyObject* pyobj_descriptors = NULL;
| 2602 | Mat descriptors; |  | 2602 | Mat descriptors;
| 2603 | Mat retval; |  | 2603 | Mat retval;
| 2604 |  |  | 2604 |
| 2605 | const char* keywords[] = { "descriptors", NULL }; |  | 2605 | const char* keywords[] = { "descriptors", NULL };
| 2606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWTrainer.cluster", (char**)keywords, &pyobj_descriptors) && |  | 2606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BOWTrainer.cluster", (char**)keywords, &pyobj_descriptors) &&
| 2607 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) ) |  | 2607 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) )
| 2608 | { |  | 2608 | {
| 2609 | ERRWRAP2(retval = _self_->cluster(descriptors)); |  | 2609 | ERRWRAP2(retval = _self_->cluster(descriptors));
| 2610 | return pyopencv_from(retval); |  | 2610 | return pyopencv_from(retval);
| 2611 | } |  | 2611 | }
| 2612 |  |  | 2612 |
| 2613 |  |  | 2613 |
| 2614 | pyPopulateArgumentConversionErrors(); |  | 2614 | pyPopulateArgumentConversionErrors();
| 2615 | } |  | 2615 | }
| 2616 | pyRaiseCVOverloadException("cluster"); |  | 2616 | pyRaiseCVOverloadException("cluster");
| 2617 |  |  | 2617 |
| 2618 | return NULL; |  | 2618 | return NULL;
| 2619 | } |  | 2619 | }
| 2620 |  |  | 2620 |
| 2621 | static PyObject* pyopencv_cv_BOWTrainer_descriptorsCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2621 | static PyObject* pyopencv_cv_BOWTrainer_descriptorsCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 2622 | { |  | 2622 | {
| 2623 | using namespace cv; |  | 2623 | using namespace cv;
| 2624 |  |  | 2624 |
| 2625 |  |  | 2625 |
| 2626 | Ptr<cv::BOWTrainer> * self1 = 0; |  | 2626 | Ptr<cv::BOWTrainer> * self1 = 0;
| 2627 | if (!pyopencv_BOWTrainer_getp(self, self1)) |  | 2627 | if (!pyopencv_BOWTrainer_getp(self, self1))
| 2628 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)"); |  | 2628 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)");
| 2629 | Ptr<cv::BOWTrainer> _self_ = *(self1); |  | 2629 | Ptr<cv::BOWTrainer> _self_ = *(self1);
| 2630 | int retval; |  | 2630 | int retval;
| 2631 |  |  | 2631 |
| 2632 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2632 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2633 | { |  | 2633 | {
| 2634 | ERRWRAP2(retval = _self_->descriptorsCount()); |  | 2634 | ERRWRAP2(retval = _self_->descriptorsCount());
| 2635 | return pyopencv_from(retval); |  | 2635 | return pyopencv_from(retval);
| 2636 | } |  | 2636 | }
| 2637 |  |  | 2637 |
| 2638 | return NULL; |  | 2638 | return NULL;
| 2639 | } |  | 2639 | }
| 2640 |  |  | 2640 |
| 2641 | static PyObject* pyopencv_cv_BOWTrainer_getDescriptors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2641 | static PyObject* pyopencv_cv_BOWTrainer_getDescriptors(PyObject* self, PyObject* py_args, PyObject* kw)
| 2642 | { |  | 2642 | {
| 2643 | using namespace cv; |  | 2643 | using namespace cv;
| 2644 |  |  | 2644 |
| 2645 |  |  | 2645 |
| 2646 | Ptr<cv::BOWTrainer> * self1 = 0; |  | 2646 | Ptr<cv::BOWTrainer> * self1 = 0;
| 2647 | if (!pyopencv_BOWTrainer_getp(self, self1)) |  | 2647 | if (!pyopencv_BOWTrainer_getp(self, self1))
| 2648 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)"); |  | 2648 | return failmsgp("Incorrect type of self (must be 'BOWTrainer' or its derivative)");
| 2649 | Ptr<cv::BOWTrainer> _self_ = *(self1); |  | 2649 | Ptr<cv::BOWTrainer> _self_ = *(self1);
| 2650 | std::vector<Mat> retval; |  | 2650 | std::vector<Mat> retval;
| 2651 |  |  | 2651 |
| 2652 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2652 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2653 | { |  | 2653 | {
| 2654 | ERRWRAP2(retval = _self_->getDescriptors()); |  | 2654 | ERRWRAP2(retval = _self_->getDescriptors());
| 2655 | return pyopencv_from(retval); |  | 2655 | return pyopencv_from(retval);
| 2656 | } |  | 2656 | }
| 2657 |  |  | 2657 |
| 2658 | return NULL; |  | 2658 | return NULL;
| 2659 | } |  | 2659 | }
| 2660 |  |  | 2660 |
| 2661 |  |  | 2661 |
| 2662 |  |  | 2662 |
| 2663 | // Tables (BOWTrainer) |  | 2663 | // Tables (BOWTrainer)
| 2664 |  |  | 2664 |
| 2665 | static PyGetSetDef pyopencv_BOWTrainer_getseters[] = |  | 2665 | static PyGetSetDef pyopencv_BOWTrainer_getseters[] =
| 2666 | { |  | 2666 | {
| 2667 | {NULL} /* Sentinel */ |  | 2667 | {NULL} /* Sentinel */
| 2668 | }; |  | 2668 | };
| 2669 |  |  | 2669 |
| 2670 | static PyMethodDef pyopencv_BOWTrainer_methods[] = |  | 2670 | static PyMethodDef pyopencv_BOWTrainer_methods[] =
| 2671 | { |  | 2671 | {
| 2672 | {"add", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_add, 0), "add(descriptors) -> None\n. @brief Adds descriptors to a training set.\n. \n. @param descriptors Descriptors to add to a training set. Each row of the descriptors matrix is a\n. descriptor.\n. \n. The training set is clustered using clustermethod to construct the vocabulary."}, |  | 2672 | {"add", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_add, 0), "add(descriptors) -> None\n. @brief Adds descriptors to a training set.\n. \n. @param descriptors Descriptors to add to a training set. Each row of the descriptors matrix is a\n. descriptor.\n. \n. The training set is clustered using clustermethod to construct the vocabulary."},
| 2673 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_clear, 0), "clear() -> None\n."}, |  | 2673 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_clear, 0), "clear() -> None\n."},
| 2674 | {"cluster", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_cluster, 0), "cluster() -> retval\n. @overload\n\n\n\ncluster(descriptors) -> retval\n. @brief Clusters train descriptors.\n. \n. @param descriptors Descriptors to cluster. Each row of the descriptors matrix is a descriptor.\n. Descriptors are not added to the inner train descriptor set.\n. \n. The vocabulary consists of cluster centers. So, this method returns the vocabulary. In the first\n. variant of the method, train descriptors stored in the object are clustered. In the second variant,\n. input descriptors are clustered."}, |  | 2674 | {"cluster", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_cluster, 0), "cluster() -> retval\n. @overload\n\n\n\ncluster(descriptors) -> retval\n. @brief Clusters train descriptors.\n. \n. @param descriptors Descriptors to cluster. Each row of the descriptors matrix is a descriptor.\n. Descriptors are not added to the inner train descriptor set.\n. \n. The vocabulary consists of cluster centers. So, this method returns the vocabulary. In the first\n. variant of the method, train descriptors stored in the object are clustered. In the second variant,\n. input descriptors are clustered."},
| 2675 | {"descriptorsCount", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_descriptorsCount, 0), "descriptorsCount() -> retval\n. @brief Returns the count of all descriptors stored in the training set."}, |  | 2675 | {"descriptorsCount", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_descriptorsCount, 0), "descriptorsCount() -> retval\n. @brief Returns the count of all descriptors stored in the training set."},
| 2676 | {"getDescriptors", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_getDescriptors, 0), "getDescriptors() -> retval\n. @brief Returns a training set of descriptors."}, |  | 2676 | {"getDescriptors", CV_PY_FN_WITH_KW_(pyopencv_cv_BOWTrainer_getDescriptors, 0), "getDescriptors() -> retval\n. @brief Returns a training set of descriptors."},
| 2677 |  |  | 2677 |
| 2678 | {NULL, NULL} |  | 2678 | {NULL, NULL}
| 2679 | }; |  | 2679 | };
| 2680 |  |  | 2680 |
| 2681 | // Converter (BOWTrainer) |  | 2681 | // Converter (BOWTrainer)
| 2682 |  |  | 2682 |
| 2683 | template<> |  | 2683 | template<>
| 2684 | struct PyOpenCV_Converter< Ptr<cv::BOWTrainer> > |  | 2684 | struct PyOpenCV_Converter< Ptr<cv::BOWTrainer> >
| 2685 | { |  | 2685 | {
| 2686 | static PyObject* from(const Ptr<cv::BOWTrainer>& r) |  | 2686 | static PyObject* from(const Ptr<cv::BOWTrainer>& r)
| 2687 | { |  | 2687 | {
| 2688 | return pyopencv_BOWTrainer_Instance(r); |  | 2688 | return pyopencv_BOWTrainer_Instance(r);
| 2689 | } |  | 2689 | }
| 2690 | static bool to(PyObject* src, Ptr<cv::BOWTrainer>& dst, const ArgInfo& info) |  | 2690 | static bool to(PyObject* src, Ptr<cv::BOWTrainer>& dst, const ArgInfo& info)
| 2691 | { |  | 2691 | {
| 2692 | if(!src || src == Py_None) |  | 2692 | if(!src || src == Py_None)
| 2693 | return true; |  | 2693 | return true;
| 2694 | Ptr<cv::BOWTrainer> * dst_; |  | 2694 | Ptr<cv::BOWTrainer> * dst_;
| 2695 | if (pyopencv_BOWTrainer_getp(src, dst_)) |  | 2695 | if (pyopencv_BOWTrainer_getp(src, dst_))
| 2696 | { |  | 2696 | {
| 2697 | dst = *dst_; |  | 2697 | dst = *dst_;
| 2698 | return true; |  | 2698 | return true;
| 2699 | } |  | 2699 | }
| 2700 |  |  | 2700 |
| 2701 | failmsg("Expected Ptr<cv::BOWTrainer> for argument '%s'", info.name); |  | 2701 | failmsg("Expected Ptr<cv::BOWTrainer> for argument '%s'", info.name);
| 2702 | return false; |  | 2702 | return false;
| 2703 | } |  | 2703 | }
| 2704 | }; |  | 2704 | };
| 2705 |  |  | 2705 |
| 2706 | //================================================================================ |  | 2706 | //================================================================================
| 2707 | // BRISK (Generic) |  | 2707 | // BRISK (Generic)
| 2708 | //================================================================================ |  | 2708 | //================================================================================
| 2709 |  |  | 2709 |
| 2710 | // GetSet (BRISK) |  | 2710 | // GetSet (BRISK)
| 2711 |  |  | 2711 |
| 2712 |  |  | 2712 |
| 2713 |  |  | 2713 |
| 2714 | // Methods (BRISK) |  | 2714 | // Methods (BRISK)
| 2715 |  |  | 2715 |
| 2716 | static PyObject* pyopencv_cv_BRISK_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2716 | static PyObject* pyopencv_cv_BRISK_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 2717 | { |  | 2717 | {
| 2718 | using namespace cv; |  | 2718 | using namespace cv;
| 2719 |  |  | 2719 |
| 2720 | pyPrepareArgumentConversionErrorsStorage(3); |  | 2720 | pyPrepareArgumentConversionErrorsStorage(3);
| 2721 |  |  | 2721 |
| 2722 | { |  | 2722 | {
| 2723 | PyObject* pyobj_thresh = NULL; |  | 2723 | PyObject* pyobj_thresh = NULL;
| 2724 | int thresh=30; |  | 2724 | int thresh=30;
| 2725 | PyObject* pyobj_octaves = NULL; |  | 2725 | PyObject* pyobj_octaves = NULL;
| 2726 | int octaves=3; |  | 2726 | int octaves=3;
| 2727 | PyObject* pyobj_patternScale = NULL; |  | 2727 | PyObject* pyobj_patternScale = NULL;
| 2728 | float patternScale=1.0f; |  | 2728 | float patternScale=1.0f;
| 2729 | Ptr<BRISK> retval; |  | 2729 | Ptr<BRISK> retval;
| 2730 |  |  | 2730 |
| 2731 | const char* keywords[] = { "thresh", "octaves", "patternScale", NULL }; |  | 2731 | const char* keywords[] = { "thresh", "octaves", "patternScale", NULL };
| 2732 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:BRISK.create", (char**)keywords, &pyobj_thresh, &pyobj_octaves, &pyobj_patternScale) && |  | 2732 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:BRISK.create", (char**)keywords, &pyobj_thresh, &pyobj_octaves, &pyobj_patternScale) &&
| 2733 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) && |  | 2733 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) &&
| 2734 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) && |  | 2734 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) &&
| 2735 | pyopencv_to_safe(pyobj_patternScale, patternScale, ArgInfo("patternScale", 0)) ) |  | 2735 | pyopencv_to_safe(pyobj_patternScale, patternScale, ArgInfo("patternScale", 0)) )
| 2736 | { |  | 2736 | {
| 2737 | ERRWRAP2(retval = cv::BRISK::create(thresh, octaves, patternScale)); |  | 2737 | ERRWRAP2(retval = cv::BRISK::create(thresh, octaves, patternScale));
| 2738 | return pyopencv_from(retval); |  | 2738 | return pyopencv_from(retval);
| 2739 | } |  | 2739 | }
| 2740 |  |  | 2740 |
| 2741 |  |  | 2741 |
| 2742 | pyPopulateArgumentConversionErrors(); |  | 2742 | pyPopulateArgumentConversionErrors();
| 2743 | } |  | 2743 | }
| 2744 |  |  | 2744 |
| 2745 |  |  | 2745 |
| 2746 | { |  | 2746 | {
| 2747 | PyObject* pyobj_radiusList = NULL; |  | 2747 | PyObject* pyobj_radiusList = NULL;
| 2748 | vector_float radiusList; |  | 2748 | vector_float radiusList;
| 2749 | PyObject* pyobj_numberList = NULL; |  | 2749 | PyObject* pyobj_numberList = NULL;
| 2750 | vector_int numberList; |  | 2750 | vector_int numberList;
| 2751 | PyObject* pyobj_dMax = NULL; |  | 2751 | PyObject* pyobj_dMax = NULL;
| 2752 | float dMax=5.85f; |  | 2752 | float dMax=5.85f;
| 2753 | PyObject* pyobj_dMin = NULL; |  | 2753 | PyObject* pyobj_dMin = NULL;
| 2754 | float dMin=8.2f; |  | 2754 | float dMin=8.2f;
| 2755 | PyObject* pyobj_indexChange = NULL; |  | 2755 | PyObject* pyobj_indexChange = NULL;
| 2756 | vector_int indexChange=std::vector<int>(); |  | 2756 | vector_int indexChange=std::vector<int>();
| 2757 | Ptr<BRISK> retval; |  | 2757 | Ptr<BRISK> retval;
| 2758 |  |  | 2758 |
| 2759 | const char* keywords[] = { "radiusList", "numberList", "dMax", "dMin", "indexChange", NULL }; |  | 2759 | const char* keywords[] = { "radiusList", "numberList", "dMax", "dMin", "indexChange", NULL };
| 2760 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:BRISK.create", (char**)keywords, &pyobj_radiusList, &pyobj_numberList, &pyobj_dMax, &pyobj_dMin, &pyobj_indexChange) && |  | 2760 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:BRISK.create", (char**)keywords, &pyobj_radiusList, &pyobj_numberList, &pyobj_dMax, &pyobj_dMin, &pyobj_indexChange) &&
| 2761 | pyopencv_to_safe(pyobj_radiusList, radiusList, ArgInfo("radiusList", 0)) && |  | 2761 | pyopencv_to_safe(pyobj_radiusList, radiusList, ArgInfo("radiusList", 0)) &&
| 2762 | pyopencv_to_safe(pyobj_numberList, numberList, ArgInfo("numberList", 0)) && |  | 2762 | pyopencv_to_safe(pyobj_numberList, numberList, ArgInfo("numberList", 0)) &&
| 2763 | pyopencv_to_safe(pyobj_dMax, dMax, ArgInfo("dMax", 0)) && |  | 2763 | pyopencv_to_safe(pyobj_dMax, dMax, ArgInfo("dMax", 0)) &&
| 2764 | pyopencv_to_safe(pyobj_dMin, dMin, ArgInfo("dMin", 0)) && |  | 2764 | pyopencv_to_safe(pyobj_dMin, dMin, ArgInfo("dMin", 0)) &&
| 2765 | pyopencv_to_safe(pyobj_indexChange, indexChange, ArgInfo("indexChange", 0)) ) |  | 2765 | pyopencv_to_safe(pyobj_indexChange, indexChange, ArgInfo("indexChange", 0)) )
| 2766 | { |  | 2766 | {
| 2767 | ERRWRAP2(retval = cv::BRISK::create(radiusList, numberList, dMax, dMin, indexChange)); |  | 2767 | ERRWRAP2(retval = cv::BRISK::create(radiusList, numberList, dMax, dMin, indexChange));
| 2768 | return pyopencv_from(retval); |  | 2768 | return pyopencv_from(retval);
| 2769 | } |  | 2769 | }
| 2770 |  |  | 2770 |
| 2771 |  |  | 2771 |
| 2772 | pyPopulateArgumentConversionErrors(); |  | 2772 | pyPopulateArgumentConversionErrors();
| 2773 | } |  | 2773 | }
| 2774 |  |  | 2774 |
| 2775 |  |  | 2775 |
| 2776 | { |  | 2776 | {
| 2777 | PyObject* pyobj_thresh = NULL; |  | 2777 | PyObject* pyobj_thresh = NULL;
| 2778 | int thresh=0; |  | 2778 | int thresh=0;
| 2779 | PyObject* pyobj_octaves = NULL; |  | 2779 | PyObject* pyobj_octaves = NULL;
| 2780 | int octaves=0; |  | 2780 | int octaves=0;
| 2781 | PyObject* pyobj_radiusList = NULL; |  | 2781 | PyObject* pyobj_radiusList = NULL;
| 2782 | vector_float radiusList; |  | 2782 | vector_float radiusList;
| 2783 | PyObject* pyobj_numberList = NULL; |  | 2783 | PyObject* pyobj_numberList = NULL;
| 2784 | vector_int numberList; |  | 2784 | vector_int numberList;
| 2785 | PyObject* pyobj_dMax = NULL; |  | 2785 | PyObject* pyobj_dMax = NULL;
| 2786 | float dMax=5.85f; |  | 2786 | float dMax=5.85f;
| 2787 | PyObject* pyobj_dMin = NULL; |  | 2787 | PyObject* pyobj_dMin = NULL;
| 2788 | float dMin=8.2f; |  | 2788 | float dMin=8.2f;
| 2789 | PyObject* pyobj_indexChange = NULL; |  | 2789 | PyObject* pyobj_indexChange = NULL;
| 2790 | vector_int indexChange=std::vector<int>(); |  | 2790 | vector_int indexChange=std::vector<int>();
| 2791 | Ptr<BRISK> retval; |  | 2791 | Ptr<BRISK> retval;
| 2792 |  |  | 2792 |
| 2793 | const char* keywords[] = { "thresh", "octaves", "radiusList", "numberList", "dMax", "dMin", "indexChange", NULL }; |  | 2793 | const char* keywords[] = { "thresh", "octaves", "radiusList", "numberList", "dMax", "dMin", "indexChange", NULL };
| 2794 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OOO:BRISK.create", (char**)keywords, &pyobj_thresh, &pyobj_octaves, &pyobj_radiusList, &pyobj_numberList, &pyobj_dMax, &pyobj_dMin, &pyobj_indexChange) && |  | 2794 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OOO:BRISK.create", (char**)keywords, &pyobj_thresh, &pyobj_octaves, &pyobj_radiusList, &pyobj_numberList, &pyobj_dMax, &pyobj_dMin, &pyobj_indexChange) &&
| 2795 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) && |  | 2795 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) &&
| 2796 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) && |  | 2796 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) &&
| 2797 | pyopencv_to_safe(pyobj_radiusList, radiusList, ArgInfo("radiusList", 0)) && |  | 2797 | pyopencv_to_safe(pyobj_radiusList, radiusList, ArgInfo("radiusList", 0)) &&
| 2798 | pyopencv_to_safe(pyobj_numberList, numberList, ArgInfo("numberList", 0)) && |  | 2798 | pyopencv_to_safe(pyobj_numberList, numberList, ArgInfo("numberList", 0)) &&
| 2799 | pyopencv_to_safe(pyobj_dMax, dMax, ArgInfo("dMax", 0)) && |  | 2799 | pyopencv_to_safe(pyobj_dMax, dMax, ArgInfo("dMax", 0)) &&
| 2800 | pyopencv_to_safe(pyobj_dMin, dMin, ArgInfo("dMin", 0)) && |  | 2800 | pyopencv_to_safe(pyobj_dMin, dMin, ArgInfo("dMin", 0)) &&
| 2801 | pyopencv_to_safe(pyobj_indexChange, indexChange, ArgInfo("indexChange", 0)) ) |  | 2801 | pyopencv_to_safe(pyobj_indexChange, indexChange, ArgInfo("indexChange", 0)) )
| 2802 | { |  | 2802 | {
| 2803 | ERRWRAP2(retval = cv::BRISK::create(thresh, octaves, radiusList, numberList, dMax, dMin, indexChange)); |  | 2803 | ERRWRAP2(retval = cv::BRISK::create(thresh, octaves, radiusList, numberList, dMax, dMin, indexChange));
| 2804 | return pyopencv_from(retval); |  | 2804 | return pyopencv_from(retval);
| 2805 | } |  | 2805 | }
| 2806 |  |  | 2806 |
| 2807 |  |  | 2807 |
| 2808 | pyPopulateArgumentConversionErrors(); |  | 2808 | pyPopulateArgumentConversionErrors();
| 2809 | } |  | 2809 | }
| 2810 | pyRaiseCVOverloadException("create"); |  | 2810 | pyRaiseCVOverloadException("create");
| 2811 |  |  | 2811 |
| 2812 | return NULL; |  | 2812 | return NULL;
| 2813 | } |  | 2813 | }
| 2814 |  |  | 2814 |
| 2815 | static PyObject* pyopencv_cv_BRISK_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2815 | static PyObject* pyopencv_cv_BRISK_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 2816 | { |  | 2816 | {
| 2817 | using namespace cv; |  | 2817 | using namespace cv;
| 2818 |  |  | 2818 |
| 2819 |  |  | 2819 |
| 2820 | Ptr<cv::BRISK> * self1 = 0; |  | 2820 | Ptr<cv::BRISK> * self1 = 0;
| 2821 | if (!pyopencv_BRISK_getp(self, self1)) |  | 2821 | if (!pyopencv_BRISK_getp(self, self1))
| 2822 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)"); |  | 2822 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)");
| 2823 | Ptr<cv::BRISK> _self_ = *(self1); |  | 2823 | Ptr<cv::BRISK> _self_ = *(self1);
| 2824 | String retval; |  | 2824 | String retval;
| 2825 |  |  | 2825 |
| 2826 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2826 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2827 | { |  | 2827 | {
| 2828 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 2828 | ERRWRAP2(retval = _self_->getDefaultName());
| 2829 | return pyopencv_from(retval); |  | 2829 | return pyopencv_from(retval);
| 2830 | } |  | 2830 | }
| 2831 |  |  | 2831 |
| 2832 | return NULL; |  | 2832 | return NULL;
| 2833 | } |  | 2833 | }
| 2834 |  |  | 2834 |
| 2835 | static PyObject* pyopencv_cv_BRISK_getOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2835 | static PyObject* pyopencv_cv_BRISK_getOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 2836 | { |  | 2836 | {
| 2837 | using namespace cv; |  | 2837 | using namespace cv;
| 2838 |  |  | 2838 |
| 2839 |  |  | 2839 |
| 2840 | Ptr<cv::BRISK> * self1 = 0; |  | 2840 | Ptr<cv::BRISK> * self1 = 0;
| 2841 | if (!pyopencv_BRISK_getp(self, self1)) |  | 2841 | if (!pyopencv_BRISK_getp(self, self1))
| 2842 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)"); |  | 2842 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)");
| 2843 | Ptr<cv::BRISK> _self_ = *(self1); |  | 2843 | Ptr<cv::BRISK> _self_ = *(self1);
| 2844 | int retval; |  | 2844 | int retval;
| 2845 |  |  | 2845 |
| 2846 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2846 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2847 | { |  | 2847 | {
| 2848 | ERRWRAP2(retval = _self_->getOctaves()); |  | 2848 | ERRWRAP2(retval = _self_->getOctaves());
| 2849 | return pyopencv_from(retval); |  | 2849 | return pyopencv_from(retval);
| 2850 | } |  | 2850 | }
| 2851 |  |  | 2851 |
| 2852 | return NULL; |  | 2852 | return NULL;
| 2853 | } |  | 2853 | }
| 2854 |  |  | 2854 |
| 2855 | static PyObject* pyopencv_cv_BRISK_getPatternScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2855 | static PyObject* pyopencv_cv_BRISK_getPatternScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 2856 | { |  | 2856 | {
| 2857 | using namespace cv; |  | 2857 | using namespace cv;
| 2858 |  |  | 2858 |
| 2859 |  |  | 2859 |
| 2860 | Ptr<cv::BRISK> * self1 = 0; |  | 2860 | Ptr<cv::BRISK> * self1 = 0;
| 2861 | if (!pyopencv_BRISK_getp(self, self1)) |  | 2861 | if (!pyopencv_BRISK_getp(self, self1))
| 2862 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)"); |  | 2862 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)");
| 2863 | Ptr<cv::BRISK> _self_ = *(self1); |  | 2863 | Ptr<cv::BRISK> _self_ = *(self1);
| 2864 | float retval; |  | 2864 | float retval;
| 2865 |  |  | 2865 |
| 2866 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2866 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2867 | { |  | 2867 | {
| 2868 | ERRWRAP2(retval = _self_->getPatternScale()); |  | 2868 | ERRWRAP2(retval = _self_->getPatternScale());
| 2869 | return pyopencv_from(retval); |  | 2869 | return pyopencv_from(retval);
| 2870 | } |  | 2870 | }
| 2871 |  |  | 2871 |
| 2872 | return NULL; |  | 2872 | return NULL;
| 2873 | } |  | 2873 | }
| 2874 |  |  | 2874 |
| 2875 | static PyObject* pyopencv_cv_BRISK_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2875 | static PyObject* pyopencv_cv_BRISK_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 2876 | { |  | 2876 | {
| 2877 | using namespace cv; |  | 2877 | using namespace cv;
| 2878 |  |  | 2878 |
| 2879 |  |  | 2879 |
| 2880 | Ptr<cv::BRISK> * self1 = 0; |  | 2880 | Ptr<cv::BRISK> * self1 = 0;
| 2881 | if (!pyopencv_BRISK_getp(self, self1)) |  | 2881 | if (!pyopencv_BRISK_getp(self, self1))
| 2882 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)"); |  | 2882 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)");
| 2883 | Ptr<cv::BRISK> _self_ = *(self1); |  | 2883 | Ptr<cv::BRISK> _self_ = *(self1);
| 2884 | int retval; |  | 2884 | int retval;
| 2885 |  |  | 2885 |
| 2886 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 2886 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 2887 | { |  | 2887 | {
| 2888 | ERRWRAP2(retval = _self_->getThreshold()); |  | 2888 | ERRWRAP2(retval = _self_->getThreshold());
| 2889 | return pyopencv_from(retval); |  | 2889 | return pyopencv_from(retval);
| 2890 | } |  | 2890 | }
| 2891 |  |  | 2891 |
| 2892 | return NULL; |  | 2892 | return NULL;
| 2893 | } |  | 2893 | }
| 2894 |  |  | 2894 |
| 2895 | static PyObject* pyopencv_cv_BRISK_setOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2895 | static PyObject* pyopencv_cv_BRISK_setOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 2896 | { |  | 2896 | {
| 2897 | using namespace cv; |  | 2897 | using namespace cv;
| 2898 |  |  | 2898 |
| 2899 |  |  | 2899 |
| 2900 | Ptr<cv::BRISK> * self1 = 0; |  | 2900 | Ptr<cv::BRISK> * self1 = 0;
| 2901 | if (!pyopencv_BRISK_getp(self, self1)) |  | 2901 | if (!pyopencv_BRISK_getp(self, self1))
| 2902 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)"); |  | 2902 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)");
| 2903 | Ptr<cv::BRISK> _self_ = *(self1); |  | 2903 | Ptr<cv::BRISK> _self_ = *(self1);
| 2904 | PyObject* pyobj_octaves = NULL; |  | 2904 | PyObject* pyobj_octaves = NULL;
| 2905 | int octaves=0; |  | 2905 | int octaves=0;
| 2906 |  |  | 2906 |
| 2907 | const char* keywords[] = { "octaves", NULL }; |  | 2907 | const char* keywords[] = { "octaves", NULL };
| 2908 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BRISK.setOctaves", (char**)keywords, &pyobj_octaves) && |  | 2908 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BRISK.setOctaves", (char**)keywords, &pyobj_octaves) &&
| 2909 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) ) |  | 2909 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) )
| 2910 | { |  | 2910 | {
| 2911 | ERRWRAP2(_self_->setOctaves(octaves)); |  | 2911 | ERRWRAP2(_self_->setOctaves(octaves));
| 2912 | Py_RETURN_NONE; |  | 2912 | Py_RETURN_NONE;
| 2913 | } |  | 2913 | }
| 2914 |  |  | 2914 |
| 2915 | return NULL; |  | 2915 | return NULL;
| 2916 | } |  | 2916 | }
| 2917 |  |  | 2917 |
| 2918 | static PyObject* pyopencv_cv_BRISK_setPatternScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2918 | static PyObject* pyopencv_cv_BRISK_setPatternScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 2919 | { |  | 2919 | {
| 2920 | using namespace cv; |  | 2920 | using namespace cv;
| 2921 |  |  | 2921 |
| 2922 |  |  | 2922 |
| 2923 | Ptr<cv::BRISK> * self1 = 0; |  | 2923 | Ptr<cv::BRISK> * self1 = 0;
| 2924 | if (!pyopencv_BRISK_getp(self, self1)) |  | 2924 | if (!pyopencv_BRISK_getp(self, self1))
| 2925 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)"); |  | 2925 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)");
| 2926 | Ptr<cv::BRISK> _self_ = *(self1); |  | 2926 | Ptr<cv::BRISK> _self_ = *(self1);
| 2927 | PyObject* pyobj_patternScale = NULL; |  | 2927 | PyObject* pyobj_patternScale = NULL;
| 2928 | float patternScale=0.f; |  | 2928 | float patternScale=0.f;
| 2929 |  |  | 2929 |
| 2930 | const char* keywords[] = { "patternScale", NULL }; |  | 2930 | const char* keywords[] = { "patternScale", NULL };
| 2931 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BRISK.setPatternScale", (char**)keywords, &pyobj_patternScale) && |  | 2931 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BRISK.setPatternScale", (char**)keywords, &pyobj_patternScale) &&
| 2932 | pyopencv_to_safe(pyobj_patternScale, patternScale, ArgInfo("patternScale", 0)) ) |  | 2932 | pyopencv_to_safe(pyobj_patternScale, patternScale, ArgInfo("patternScale", 0)) )
| 2933 | { |  | 2933 | {
| 2934 | ERRWRAP2(_self_->setPatternScale(patternScale)); |  | 2934 | ERRWRAP2(_self_->setPatternScale(patternScale));
| 2935 | Py_RETURN_NONE; |  | 2935 | Py_RETURN_NONE;
| 2936 | } |  | 2936 | }
| 2937 |  |  | 2937 |
| 2938 | return NULL; |  | 2938 | return NULL;
| 2939 | } |  | 2939 | }
| 2940 |  |  | 2940 |
| 2941 | static PyObject* pyopencv_cv_BRISK_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 2941 | static PyObject* pyopencv_cv_BRISK_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 2942 | { |  | 2942 | {
| 2943 | using namespace cv; |  | 2943 | using namespace cv;
| 2944 |  |  | 2944 |
| 2945 |  |  | 2945 |
| 2946 | Ptr<cv::BRISK> * self1 = 0; |  | 2946 | Ptr<cv::BRISK> * self1 = 0;
| 2947 | if (!pyopencv_BRISK_getp(self, self1)) |  | 2947 | if (!pyopencv_BRISK_getp(self, self1))
| 2948 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)"); |  | 2948 | return failmsgp("Incorrect type of self (must be 'BRISK' or its derivative)");
| 2949 | Ptr<cv::BRISK> _self_ = *(self1); |  | 2949 | Ptr<cv::BRISK> _self_ = *(self1);
| 2950 | PyObject* pyobj_threshold = NULL; |  | 2950 | PyObject* pyobj_threshold = NULL;
| 2951 | int threshold=0; |  | 2951 | int threshold=0;
| 2952 |  |  | 2952 |
| 2953 | const char* keywords[] = { "threshold", NULL }; |  | 2953 | const char* keywords[] = { "threshold", NULL };
| 2954 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BRISK.setThreshold", (char**)keywords, &pyobj_threshold) && |  | 2954 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BRISK.setThreshold", (char**)keywords, &pyobj_threshold) &&
| 2955 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 2955 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 2956 | { |  | 2956 | {
| 2957 | ERRWRAP2(_self_->setThreshold(threshold)); |  | 2957 | ERRWRAP2(_self_->setThreshold(threshold));
| 2958 | Py_RETURN_NONE; |  | 2958 | Py_RETURN_NONE;
| 2959 | } |  | 2959 | }
| 2960 |  |  | 2960 |
| 2961 | return NULL; |  | 2961 | return NULL;
| 2962 | } |  | 2962 | }
| 2963 |  |  | 2963 |
| 2964 |  |  | 2964 |
| 2965 |  |  | 2965 |
| 2966 | // Tables (BRISK) |  | 2966 | // Tables (BRISK)
| 2967 |  |  | 2967 |
| 2968 | static PyGetSetDef pyopencv_BRISK_getseters[] = |  | 2968 | static PyGetSetDef pyopencv_BRISK_getseters[] =
| 2969 | { |  | 2969 | {
| 2970 | {NULL} /* Sentinel */ |  | 2970 | {NULL} /* Sentinel */
| 2971 | }; |  | 2971 | };
| 2972 |  |  | 2972 |
| 2973 | static PyMethodDef pyopencv_BRISK_methods[] = |  | 2973 | static PyMethodDef pyopencv_BRISK_methods[] =
| 2974 | { |  | 2974 | {
| 2975 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_create_static, METH_STATIC), "create([, thresh[, octaves[, patternScale]]]) -> retval\n. @brief The BRISK constructor\n. \n. @param thresh AGAST detection threshold score.\n. @param octaves detection octaves. Use 0 to do single scale.\n. @param patternScale apply this scale to the pattern used for sampling the neighbourhood of a\n. keypoint.\n\n\n\ncreate(radiusList, numberList[, dMax[, dMin[, indexChange]]]) -> retval\n. @brief The BRISK constructor for a custom pattern\n. \n. @param radiusList defines the radii (in pixels) where the samples around a keypoint are taken (for\n. keypoint scale 1).\n. @param numberList defines the number of sampling points on the sampling circle. Must be the same\n. size as radiusList..\n. @param dMax threshold for the short pairings used for descriptor formation (in pixels for keypoint\n. scale 1).\n. @param dMin threshold for the long pairings used for orientation determination (in pixels for\n. keypoint scale 1).\n. @param indexChange index remapping of the bits.\n\n\n\ncreate(thresh, octaves, radiusList, numberList[, dMax[, dMin[, indexChange]]]) -> retval\n. @brief The BRISK constructor for a custom pattern, detection threshold and octaves\n. \n. @param thresh AGAST detection threshold score.\n. @param octaves detection octaves. Use 0 to do single scale.\n. @param radiusList defines the radii (in pixels) where the samples around a keypoint are taken (for\n. keypoint scale 1).\n. @param numberList defines the number of sampling points on the sampling circle. Must be the same\n. size as radiusList..\n. @param dMax threshold for the short pairings used for descriptor formation (in pixels for keypoint\n. scale 1).\n. @param dMin threshold for the long pairings used for orientation determination (in pixels for\n. keypoint scale 1).\n. @param indexChange index remapping of the bits."}, |  | 2975 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_create_static, METH_STATIC), "create([, thresh[, octaves[, patternScale]]]) -> retval\n. @brief The BRISK constructor\n. \n. @param thresh AGAST detection threshold score.\n. @param octaves detection octaves. Use 0 to do single scale.\n. @param patternScale apply this scale to the pattern used for sampling the neighbourhood of a\n. keypoint.\n\n\n\ncreate(radiusList, numberList[, dMax[, dMin[, indexChange]]]) -> retval\n. @brief The BRISK constructor for a custom pattern\n. \n. @param radiusList defines the radii (in pixels) where the samples around a keypoint are taken (for\n. keypoint scale 1).\n. @param numberList defines the number of sampling points on the sampling circle. Must be the same\n. size as radiusList..\n. @param dMax threshold for the short pairings used for descriptor formation (in pixels for keypoint\n. scale 1).\n. @param dMin threshold for the long pairings used for orientation determination (in pixels for\n. keypoint scale 1).\n. @param indexChange index remapping of the bits.\n\n\n\ncreate(thresh, octaves, radiusList, numberList[, dMax[, dMin[, indexChange]]]) -> retval\n. @brief The BRISK constructor for a custom pattern, detection threshold and octaves\n. \n. @param thresh AGAST detection threshold score.\n. @param octaves detection octaves. Use 0 to do single scale.\n. @param radiusList defines the radii (in pixels) where the samples around a keypoint are taken (for\n. keypoint scale 1).\n. @param numberList defines the number of sampling points on the sampling circle. Must be the same\n. size as radiusList..\n. @param dMax threshold for the short pairings used for descriptor formation (in pixels for keypoint\n. scale 1).\n. @param dMin threshold for the long pairings used for orientation determination (in pixels for\n. keypoint scale 1).\n. @param indexChange index remapping of the bits."},
| 2976 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 2976 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 2977 | {"getOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getOctaves, 0), "getOctaves() -> retval\n."}, |  | 2977 | {"getOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getOctaves, 0), "getOctaves() -> retval\n."},
| 2978 | {"getPatternScale", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getPatternScale, 0), "getPatternScale() -> retval\n."}, |  | 2978 | {"getPatternScale", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getPatternScale, 0), "getPatternScale() -> retval\n."},
| 2979 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getThreshold, 0), "getThreshold() -> retval\n."}, |  | 2979 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_getThreshold, 0), "getThreshold() -> retval\n."},
| 2980 | {"setOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_setOctaves, 0), "setOctaves(octaves) -> None\n. @brief Set detection octaves.\n. @param octaves detection octaves. Use 0 to do single scale."}, |  | 2980 | {"setOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_setOctaves, 0), "setOctaves(octaves) -> None\n. @brief Set detection octaves.\n. @param octaves detection octaves. Use 0 to do single scale."},
| 2981 | {"setPatternScale", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_setPatternScale, 0), "setPatternScale(patternScale) -> None\n. @brief Set detection patternScale.\n. @param patternScale apply this scale to the pattern used for sampling the neighbourhood of a\n. keypoint."}, |  | 2981 | {"setPatternScale", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_setPatternScale, 0), "setPatternScale(patternScale) -> None\n. @brief Set detection patternScale.\n. @param patternScale apply this scale to the pattern used for sampling the neighbourhood of a\n. keypoint."},
| 2982 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_setThreshold, 0), "setThreshold(threshold) -> None\n. @brief Set detection threshold.\n. @param threshold AGAST detection threshold score."}, |  | 2982 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BRISK_setThreshold, 0), "setThreshold(threshold) -> None\n. @brief Set detection threshold.\n. @param threshold AGAST detection threshold score."},
| 2983 |  |  | 2983 |
| 2984 | {NULL, NULL} |  | 2984 | {NULL, NULL}
| 2985 | }; |  | 2985 | };
| 2986 |  |  | 2986 |
| 2987 | // Converter (BRISK) |  | 2987 | // Converter (BRISK)
| 2988 |  |  | 2988 |
| 2989 | template<> |  | 2989 | template<>
| 2990 | struct PyOpenCV_Converter< Ptr<cv::BRISK> > |  | 2990 | struct PyOpenCV_Converter< Ptr<cv::BRISK> >
| 2991 | { |  | 2991 | {
| 2992 | static PyObject* from(const Ptr<cv::BRISK>& r) |  | 2992 | static PyObject* from(const Ptr<cv::BRISK>& r)
| 2993 | { |  | 2993 | {
| 2994 | return pyopencv_BRISK_Instance(r); |  | 2994 | return pyopencv_BRISK_Instance(r);
| 2995 | } |  | 2995 | }
| 2996 | static bool to(PyObject* src, Ptr<cv::BRISK>& dst, const ArgInfo& info) |  | 2996 | static bool to(PyObject* src, Ptr<cv::BRISK>& dst, const ArgInfo& info)
| 2997 | { |  | 2997 | {
| 2998 | if(!src || src == Py_None) |  | 2998 | if(!src || src == Py_None)
| 2999 | return true; |  | 2999 | return true;
| 3000 | Ptr<cv::BRISK> * dst_; |  | 3000 | Ptr<cv::BRISK> * dst_;
| 3001 | if (pyopencv_BRISK_getp(src, dst_)) |  | 3001 | if (pyopencv_BRISK_getp(src, dst_))
| 3002 | { |  | 3002 | {
| 3003 | dst = *dst_; |  | 3003 | dst = *dst_;
| 3004 | return true; |  | 3004 | return true;
| 3005 | } |  | 3005 | }
| 3006 |  |  | 3006 |
| 3007 | failmsg("Expected Ptr<cv::BRISK> for argument '%s'", info.name); |  | 3007 | failmsg("Expected Ptr<cv::BRISK> for argument '%s'", info.name);
| 3008 | return false; |  | 3008 | return false;
| 3009 | } |  | 3009 | }
| 3010 | }; |  | 3010 | };
| 3011 |  |  | 3011 |
| 3012 | //================================================================================ |  | 3012 | //================================================================================
| 3013 | // BackgroundSubtractor (Generic) |  | 3013 | // BackgroundSubtractor (Generic)
| 3014 | //================================================================================ |  | 3014 | //================================================================================
| 3015 |  |  | 3015 |
| 3016 | // GetSet (BackgroundSubtractor) |  | 3016 | // GetSet (BackgroundSubtractor)
| 3017 |  |  | 3017 |
| 3018 |  |  | 3018 |
| 3019 |  |  | 3019 |
| 3020 | // Methods (BackgroundSubtractor) |  | 3020 | // Methods (BackgroundSubtractor)
| 3021 |  |  | 3021 |
| 3022 | static PyObject* pyopencv_cv_BackgroundSubtractor_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3022 | static PyObject* pyopencv_cv_BackgroundSubtractor_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 3023 | { |  | 3023 | {
| 3024 | using namespace cv; |  | 3024 | using namespace cv;
| 3025 |  |  | 3025 |
| 3026 |  |  | 3026 |
| 3027 | Ptr<cv::BackgroundSubtractor> * self1 = 0; |  | 3027 | Ptr<cv::BackgroundSubtractor> * self1 = 0;
| 3028 | if (!pyopencv_BackgroundSubtractor_getp(self, self1)) |  | 3028 | if (!pyopencv_BackgroundSubtractor_getp(self, self1))
| 3029 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractor' or its derivative)"); |  | 3029 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractor' or its derivative)");
| 3030 | Ptr<cv::BackgroundSubtractor> _self_ = *(self1); |  | 3030 | Ptr<cv::BackgroundSubtractor> _self_ = *(self1);
| 3031 | pyPrepareArgumentConversionErrorsStorage(2); |  | 3031 | pyPrepareArgumentConversionErrorsStorage(2);
| 3032 |  |  | 3032 |
| 3033 | { |  | 3033 | {
| 3034 | PyObject* pyobj_image = NULL; |  | 3034 | PyObject* pyobj_image = NULL;
| 3035 | Mat image; |  | 3035 | Mat image;
| 3036 | PyObject* pyobj_fgmask = NULL; |  | 3036 | PyObject* pyobj_fgmask = NULL;
| 3037 | Mat fgmask; |  | 3037 | Mat fgmask;
| 3038 | PyObject* pyobj_learningRate = NULL; |  | 3038 | PyObject* pyobj_learningRate = NULL;
| 3039 | double learningRate=-1; |  | 3039 | double learningRate=-1;
| 3040 |  |  | 3040 |
| 3041 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 3041 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 3042 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractor.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 3042 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractor.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 3043 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 3043 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 3044 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 3044 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 3045 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 3045 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 3046 | { |  | 3046 | {
| 3047 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 3047 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 3048 | return pyopencv_from(fgmask); |  | 3048 | return pyopencv_from(fgmask);
| 3049 | } |  | 3049 | }
| 3050 |  |  | 3050 |
| 3051 |  |  | 3051 |
| 3052 | pyPopulateArgumentConversionErrors(); |  | 3052 | pyPopulateArgumentConversionErrors();
| 3053 | } |  | 3053 | }
| 3054 |  |  | 3054 |
| 3055 |  |  | 3055 |
| 3056 | { |  | 3056 | {
| 3057 | PyObject* pyobj_image = NULL; |  | 3057 | PyObject* pyobj_image = NULL;
| 3058 | UMat image; |  | 3058 | UMat image;
| 3059 | PyObject* pyobj_fgmask = NULL; |  | 3059 | PyObject* pyobj_fgmask = NULL;
| 3060 | UMat fgmask; |  | 3060 | UMat fgmask;
| 3061 | PyObject* pyobj_learningRate = NULL; |  | 3061 | PyObject* pyobj_learningRate = NULL;
| 3062 | double learningRate=-1; |  | 3062 | double learningRate=-1;
| 3063 |  |  | 3063 |
| 3064 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 3064 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 3065 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractor.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 3065 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractor.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 3066 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 3066 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 3067 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 3067 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 3068 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 3068 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 3069 | { |  | 3069 | {
| 3070 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 3070 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 3071 | return pyopencv_from(fgmask); |  | 3071 | return pyopencv_from(fgmask);
| 3072 | } |  | 3072 | }
| 3073 |  |  | 3073 |
| 3074 |  |  | 3074 |
| 3075 | pyPopulateArgumentConversionErrors(); |  | 3075 | pyPopulateArgumentConversionErrors();
| 3076 | } |  | 3076 | }
| 3077 | pyRaiseCVOverloadException("apply"); |  | 3077 | pyRaiseCVOverloadException("apply");
| 3078 |  |  | 3078 |
| 3079 | return NULL; |  | 3079 | return NULL;
| 3080 | } |  | 3080 | }
| 3081 |  |  | 3081 |
| 3082 | static PyObject* pyopencv_cv_BackgroundSubtractor_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3082 | static PyObject* pyopencv_cv_BackgroundSubtractor_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 3083 | { |  | 3083 | {
| 3084 | using namespace cv; |  | 3084 | using namespace cv;
| 3085 |  |  | 3085 |
| 3086 |  |  | 3086 |
| 3087 | Ptr<cv::BackgroundSubtractor> * self1 = 0; |  | 3087 | Ptr<cv::BackgroundSubtractor> * self1 = 0;
| 3088 | if (!pyopencv_BackgroundSubtractor_getp(self, self1)) |  | 3088 | if (!pyopencv_BackgroundSubtractor_getp(self, self1))
| 3089 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractor' or its derivative)"); |  | 3089 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractor' or its derivative)");
| 3090 | Ptr<cv::BackgroundSubtractor> _self_ = *(self1); |  | 3090 | Ptr<cv::BackgroundSubtractor> _self_ = *(self1);
| 3091 | pyPrepareArgumentConversionErrorsStorage(2); |  | 3091 | pyPrepareArgumentConversionErrorsStorage(2);
| 3092 |  |  | 3092 |
| 3093 | { |  | 3093 | {
| 3094 | PyObject* pyobj_backgroundImage = NULL; |  | 3094 | PyObject* pyobj_backgroundImage = NULL;
| 3095 | Mat backgroundImage; |  | 3095 | Mat backgroundImage;
| 3096 |  |  | 3096 |
| 3097 | const char* keywords[] = { "backgroundImage", NULL }; |  | 3097 | const char* keywords[] = { "backgroundImage", NULL };
| 3098 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:BackgroundSubtractor.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 3098 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:BackgroundSubtractor.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 3099 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 3099 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 3100 | { |  | 3100 | {
| 3101 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 3101 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 3102 | return pyopencv_from(backgroundImage); |  | 3102 | return pyopencv_from(backgroundImage);
| 3103 | } |  | 3103 | }
| 3104 |  |  | 3104 |
| 3105 |  |  | 3105 |
| 3106 | pyPopulateArgumentConversionErrors(); |  | 3106 | pyPopulateArgumentConversionErrors();
| 3107 | } |  | 3107 | }
| 3108 |  |  | 3108 |
| 3109 |  |  | 3109 |
| 3110 | { |  | 3110 | {
| 3111 | PyObject* pyobj_backgroundImage = NULL; |  | 3111 | PyObject* pyobj_backgroundImage = NULL;
| 3112 | UMat backgroundImage; |  | 3112 | UMat backgroundImage;
| 3113 |  |  | 3113 |
| 3114 | const char* keywords[] = { "backgroundImage", NULL }; |  | 3114 | const char* keywords[] = { "backgroundImage", NULL };
| 3115 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:BackgroundSubtractor.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 3115 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:BackgroundSubtractor.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 3116 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 3116 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 3117 | { |  | 3117 | {
| 3118 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 3118 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 3119 | return pyopencv_from(backgroundImage); |  | 3119 | return pyopencv_from(backgroundImage);
| 3120 | } |  | 3120 | }
| 3121 |  |  | 3121 |
| 3122 |  |  | 3122 |
| 3123 | pyPopulateArgumentConversionErrors(); |  | 3123 | pyPopulateArgumentConversionErrors();
| 3124 | } |  | 3124 | }
| 3125 | pyRaiseCVOverloadException("getBackgroundImage"); |  | 3125 | pyRaiseCVOverloadException("getBackgroundImage");
| 3126 |  |  | 3126 |
| 3127 | return NULL; |  | 3127 | return NULL;
| 3128 | } |  | 3128 | }
| 3129 |  |  | 3129 |
| 3130 |  |  | 3130 |
| 3131 |  |  | 3131 |
| 3132 | // Tables (BackgroundSubtractor) |  | 3132 | // Tables (BackgroundSubtractor)
| 3133 |  |  | 3133 |
| 3134 | static PyGetSetDef pyopencv_BackgroundSubtractor_getseters[] = |  | 3134 | static PyGetSetDef pyopencv_BackgroundSubtractor_getseters[] =
| 3135 | { |  | 3135 | {
| 3136 | {NULL} /* Sentinel */ |  | 3136 | {NULL} /* Sentinel */
| 3137 | }; |  | 3137 | };
| 3138 |  |  | 3138 |
| 3139 | static PyMethodDef pyopencv_BackgroundSubtractor_methods[] = |  | 3139 | static PyMethodDef pyopencv_BackgroundSubtractor_methods[] =
| 3140 | { |  | 3140 | {
| 3141 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractor_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n. @brief Computes a foreground mask.\n. \n. @param image Next video frame.\n. @param fgmask The output foreground mask as an 8-bit binary image.\n. @param learningRate The value between 0 and 1 that indicates how fast the background model is\n. learnt. Negative parameter value makes the algorithm to use some automatically chosen learning\n. rate. 0 means that the background model is not updated at all, 1 means that the background model\n. is completely reinitialized from the last frame."}, |  | 3141 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractor_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n. @brief Computes a foreground mask.\n. \n. @param image Next video frame.\n. @param fgmask The output foreground mask as an 8-bit binary image.\n. @param learningRate The value between 0 and 1 that indicates how fast the background model is\n. learnt. Negative parameter value makes the algorithm to use some automatically chosen learning\n. rate. 0 means that the background model is not updated at all, 1 means that the background model\n. is completely reinitialized from the last frame."},
| 3142 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractor_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n. @brief Computes a background image.\n. \n. @param backgroundImage The output background image.\n. \n. @note Sometimes the background image can be very blurry, as it contain the average background\n. statistics."}, |  | 3142 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractor_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n. @brief Computes a background image.\n. \n. @param backgroundImage The output background image.\n. \n. @note Sometimes the background image can be very blurry, as it contain the average background\n. statistics."},
| 3143 |  |  | 3143 |
| 3144 | {NULL, NULL} |  | 3144 | {NULL, NULL}
| 3145 | }; |  | 3145 | };
| 3146 |  |  | 3146 |
| 3147 | // Converter (BackgroundSubtractor) |  | 3147 | // Converter (BackgroundSubtractor)
| 3148 |  |  | 3148 |
| 3149 | template<> |  | 3149 | template<>
| 3150 | struct PyOpenCV_Converter< Ptr<cv::BackgroundSubtractor> > |  | 3150 | struct PyOpenCV_Converter< Ptr<cv::BackgroundSubtractor> >
| 3151 | { |  | 3151 | {
| 3152 | static PyObject* from(const Ptr<cv::BackgroundSubtractor>& r) |  | 3152 | static PyObject* from(const Ptr<cv::BackgroundSubtractor>& r)
| 3153 | { |  | 3153 | {
| 3154 | return pyopencv_BackgroundSubtractor_Instance(r); |  | 3154 | return pyopencv_BackgroundSubtractor_Instance(r);
| 3155 | } |  | 3155 | }
| 3156 | static bool to(PyObject* src, Ptr<cv::BackgroundSubtractor>& dst, const ArgInfo& info) |  | 3156 | static bool to(PyObject* src, Ptr<cv::BackgroundSubtractor>& dst, const ArgInfo& info)
| 3157 | { |  | 3157 | {
| 3158 | if(!src || src == Py_None) |  | 3158 | if(!src || src == Py_None)
| 3159 | return true; |  | 3159 | return true;
| 3160 | Ptr<cv::BackgroundSubtractor> * dst_; |  | 3160 | Ptr<cv::BackgroundSubtractor> * dst_;
| 3161 | if (pyopencv_BackgroundSubtractor_getp(src, dst_)) |  | 3161 | if (pyopencv_BackgroundSubtractor_getp(src, dst_))
| 3162 | { |  | 3162 | {
| 3163 | dst = *dst_; |  | 3163 | dst = *dst_;
| 3164 | return true; |  | 3164 | return true;
| 3165 | } |  | 3165 | }
| 3166 |  |  | 3166 |
| 3167 | failmsg("Expected Ptr<cv::BackgroundSubtractor> for argument '%s'", info.name); |  | 3167 | failmsg("Expected Ptr<cv::BackgroundSubtractor> for argument '%s'", info.name);
| 3168 | return false; |  | 3168 | return false;
| 3169 | } |  | 3169 | }
| 3170 | }; |  | 3170 | };
| 3171 |  |  | 3171 |
| 3172 | //================================================================================ |  | 3172 | //================================================================================
| 3173 | // BackgroundSubtractorKNN (Generic) |  | 3173 | // BackgroundSubtractorKNN (Generic)
| 3174 | //================================================================================ |  | 3174 | //================================================================================
| 3175 |  |  | 3175 |
| 3176 | // GetSet (BackgroundSubtractorKNN) |  | 3176 | // GetSet (BackgroundSubtractorKNN)
| 3177 |  |  | 3177 |
| 3178 |  |  | 3178 |
| 3179 |  |  | 3179 |
| 3180 | // Methods (BackgroundSubtractorKNN) |  | 3180 | // Methods (BackgroundSubtractorKNN)
| 3181 |  |  | 3181 |
| 3182 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3182 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw)
| 3183 | { |  | 3183 | {
| 3184 | using namespace cv; |  | 3184 | using namespace cv;
| 3185 |  |  | 3185 |
| 3186 |  |  | 3186 |
| 3187 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3187 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3188 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3188 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3189 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3189 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3190 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3190 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3191 | bool retval; |  | 3191 | bool retval;
| 3192 |  |  | 3192 |
| 3193 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3193 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3194 | { |  | 3194 | {
| 3195 | ERRWRAP2(retval = _self_->getDetectShadows()); |  | 3195 | ERRWRAP2(retval = _self_->getDetectShadows());
| 3196 | return pyopencv_from(retval); |  | 3196 | return pyopencv_from(retval);
| 3197 | } |  | 3197 | }
| 3198 |  |  | 3198 |
| 3199 | return NULL; |  | 3199 | return NULL;
| 3200 | } |  | 3200 | }
| 3201 |  |  | 3201 |
| 3202 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getDist2Threshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3202 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getDist2Threshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3203 | { |  | 3203 | {
| 3204 | using namespace cv; |  | 3204 | using namespace cv;
| 3205 |  |  | 3205 |
| 3206 |  |  | 3206 |
| 3207 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3207 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3208 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3208 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3209 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3209 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3210 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3210 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3211 | double retval; |  | 3211 | double retval;
| 3212 |  |  | 3212 |
| 3213 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3213 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3214 | { |  | 3214 | {
| 3215 | ERRWRAP2(retval = _self_->getDist2Threshold()); |  | 3215 | ERRWRAP2(retval = _self_->getDist2Threshold());
| 3216 | return pyopencv_from(retval); |  | 3216 | return pyopencv_from(retval);
| 3217 | } |  | 3217 | }
| 3218 |  |  | 3218 |
| 3219 | return NULL; |  | 3219 | return NULL;
| 3220 | } |  | 3220 | }
| 3221 |  |  | 3221 |
| 3222 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3222 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 3223 | { |  | 3223 | {
| 3224 | using namespace cv; |  | 3224 | using namespace cv;
| 3225 |  |  | 3225 |
| 3226 |  |  | 3226 |
| 3227 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3227 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3228 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3228 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3229 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3229 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3230 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3230 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3231 | int retval; |  | 3231 | int retval;
| 3232 |  |  | 3232 |
| 3233 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3233 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3234 | { |  | 3234 | {
| 3235 | ERRWRAP2(retval = _self_->getHistory()); |  | 3235 | ERRWRAP2(retval = _self_->getHistory());
| 3236 | return pyopencv_from(retval); |  | 3236 | return pyopencv_from(retval);
| 3237 | } |  | 3237 | }
| 3238 |  |  | 3238 |
| 3239 | return NULL; |  | 3239 | return NULL;
| 3240 | } |  | 3240 | }
| 3241 |  |  | 3241 |
| 3242 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getNSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3242 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getNSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 3243 | { |  | 3243 | {
| 3244 | using namespace cv; |  | 3244 | using namespace cv;
| 3245 |  |  | 3245 |
| 3246 |  |  | 3246 |
| 3247 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3247 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3248 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3248 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3249 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3249 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3250 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3250 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3251 | int retval; |  | 3251 | int retval;
| 3252 |  |  | 3252 |
| 3253 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3253 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3254 | { |  | 3254 | {
| 3255 | ERRWRAP2(retval = _self_->getNSamples()); |  | 3255 | ERRWRAP2(retval = _self_->getNSamples());
| 3256 | return pyopencv_from(retval); |  | 3256 | return pyopencv_from(retval);
| 3257 | } |  | 3257 | }
| 3258 |  |  | 3258 |
| 3259 | return NULL; |  | 3259 | return NULL;
| 3260 | } |  | 3260 | }
| 3261 |  |  | 3261 |
| 3262 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3262 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3263 | { |  | 3263 | {
| 3264 | using namespace cv; |  | 3264 | using namespace cv;
| 3265 |  |  | 3265 |
| 3266 |  |  | 3266 |
| 3267 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3267 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3268 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3268 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3269 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3269 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3270 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3270 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3271 | double retval; |  | 3271 | double retval;
| 3272 |  |  | 3272 |
| 3273 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3273 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3274 | { |  | 3274 | {
| 3275 | ERRWRAP2(retval = _self_->getShadowThreshold()); |  | 3275 | ERRWRAP2(retval = _self_->getShadowThreshold());
| 3276 | return pyopencv_from(retval); |  | 3276 | return pyopencv_from(retval);
| 3277 | } |  | 3277 | }
| 3278 |  |  | 3278 |
| 3279 | return NULL; |  | 3279 | return NULL;
| 3280 | } |  | 3280 | }
| 3281 |  |  | 3281 |
| 3282 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getShadowValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3282 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getShadowValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 3283 | { |  | 3283 | {
| 3284 | using namespace cv; |  | 3284 | using namespace cv;
| 3285 |  |  | 3285 |
| 3286 |  |  | 3286 |
| 3287 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3287 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3288 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3288 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3289 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3289 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3290 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3290 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3291 | int retval; |  | 3291 | int retval;
| 3292 |  |  | 3292 |
| 3293 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3293 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3294 | { |  | 3294 | {
| 3295 | ERRWRAP2(retval = _self_->getShadowValue()); |  | 3295 | ERRWRAP2(retval = _self_->getShadowValue());
| 3296 | return pyopencv_from(retval); |  | 3296 | return pyopencv_from(retval);
| 3297 | } |  | 3297 | }
| 3298 |  |  | 3298 |
| 3299 | return NULL; |  | 3299 | return NULL;
| 3300 | } |  | 3300 | }
| 3301 |  |  | 3301 |
| 3302 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getkNNSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3302 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_getkNNSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 3303 | { |  | 3303 | {
| 3304 | using namespace cv; |  | 3304 | using namespace cv;
| 3305 |  |  | 3305 |
| 3306 |  |  | 3306 |
| 3307 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3307 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3308 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3308 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3309 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3309 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3310 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3310 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3311 | int retval; |  | 3311 | int retval;
| 3312 |  |  | 3312 |
| 3313 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3313 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3314 | { |  | 3314 | {
| 3315 | ERRWRAP2(retval = _self_->getkNNSamples()); |  | 3315 | ERRWRAP2(retval = _self_->getkNNSamples());
| 3316 | return pyopencv_from(retval); |  | 3316 | return pyopencv_from(retval);
| 3317 | } |  | 3317 | }
| 3318 |  |  | 3318 |
| 3319 | return NULL; |  | 3319 | return NULL;
| 3320 | } |  | 3320 | }
| 3321 |  |  | 3321 |
| 3322 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3322 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw)
| 3323 | { |  | 3323 | {
| 3324 | using namespace cv; |  | 3324 | using namespace cv;
| 3325 |  |  | 3325 |
| 3326 |  |  | 3326 |
| 3327 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3327 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3328 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3328 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3329 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3329 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3330 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3330 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3331 | PyObject* pyobj_detectShadows = NULL; |  | 3331 | PyObject* pyobj_detectShadows = NULL;
| 3332 | bool detectShadows=0; |  | 3332 | bool detectShadows=0;
| 3333 |  |  | 3333 |
| 3334 | const char* keywords[] = { "detectShadows", NULL }; |  | 3334 | const char* keywords[] = { "detectShadows", NULL };
| 3335 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setDetectShadows", (char**)keywords, &pyobj_detectShadows) && |  | 3335 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setDetectShadows", (char**)keywords, &pyobj_detectShadows) &&
| 3336 | pyopencv_to_safe(pyobj_detectShadows, detectShadows, ArgInfo("detectShadows", 0)) ) |  | 3336 | pyopencv_to_safe(pyobj_detectShadows, detectShadows, ArgInfo("detectShadows", 0)) )
| 3337 | { |  | 3337 | {
| 3338 | ERRWRAP2(_self_->setDetectShadows(detectShadows)); |  | 3338 | ERRWRAP2(_self_->setDetectShadows(detectShadows));
| 3339 | Py_RETURN_NONE; |  | 3339 | Py_RETURN_NONE;
| 3340 | } |  | 3340 | }
| 3341 |  |  | 3341 |
| 3342 | return NULL; |  | 3342 | return NULL;
| 3343 | } |  | 3343 | }
| 3344 |  |  | 3344 |
| 3345 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setDist2Threshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3345 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setDist2Threshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3346 | { |  | 3346 | {
| 3347 | using namespace cv; |  | 3347 | using namespace cv;
| 3348 |  |  | 3348 |
| 3349 |  |  | 3349 |
| 3350 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3350 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3351 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3351 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3352 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3352 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3353 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3353 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3354 | PyObject* pyobj__dist2Threshold = NULL; |  | 3354 | PyObject* pyobj__dist2Threshold = NULL;
| 3355 | double _dist2Threshold=0; |  | 3355 | double _dist2Threshold=0;
| 3356 |  |  | 3356 |
| 3357 | const char* keywords[] = { "_dist2Threshold", NULL }; |  | 3357 | const char* keywords[] = { "_dist2Threshold", NULL };
| 3358 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setDist2Threshold", (char**)keywords, &pyobj__dist2Threshold) && |  | 3358 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setDist2Threshold", (char**)keywords, &pyobj__dist2Threshold) &&
| 3359 | pyopencv_to_safe(pyobj__dist2Threshold, _dist2Threshold, ArgInfo("_dist2Threshold", 0)) ) |  | 3359 | pyopencv_to_safe(pyobj__dist2Threshold, _dist2Threshold, ArgInfo("_dist2Threshold", 0)) )
| 3360 | { |  | 3360 | {
| 3361 | ERRWRAP2(_self_->setDist2Threshold(_dist2Threshold)); |  | 3361 | ERRWRAP2(_self_->setDist2Threshold(_dist2Threshold));
| 3362 | Py_RETURN_NONE; |  | 3362 | Py_RETURN_NONE;
| 3363 | } |  | 3363 | }
| 3364 |  |  | 3364 |
| 3365 | return NULL; |  | 3365 | return NULL;
| 3366 | } |  | 3366 | }
| 3367 |  |  | 3367 |
| 3368 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3368 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 3369 | { |  | 3369 | {
| 3370 | using namespace cv; |  | 3370 | using namespace cv;
| 3371 |  |  | 3371 |
| 3372 |  |  | 3372 |
| 3373 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3373 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3374 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3374 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3375 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3375 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3376 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3376 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3377 | PyObject* pyobj_history = NULL; |  | 3377 | PyObject* pyobj_history = NULL;
| 3378 | int history=0; |  | 3378 | int history=0;
| 3379 |  |  | 3379 |
| 3380 | const char* keywords[] = { "history", NULL }; |  | 3380 | const char* keywords[] = { "history", NULL };
| 3381 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setHistory", (char**)keywords, &pyobj_history) && |  | 3381 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setHistory", (char**)keywords, &pyobj_history) &&
| 3382 | pyopencv_to_safe(pyobj_history, history, ArgInfo("history", 0)) ) |  | 3382 | pyopencv_to_safe(pyobj_history, history, ArgInfo("history", 0)) )
| 3383 | { |  | 3383 | {
| 3384 | ERRWRAP2(_self_->setHistory(history)); |  | 3384 | ERRWRAP2(_self_->setHistory(history));
| 3385 | Py_RETURN_NONE; |  | 3385 | Py_RETURN_NONE;
| 3386 | } |  | 3386 | }
| 3387 |  |  | 3387 |
| 3388 | return NULL; |  | 3388 | return NULL;
| 3389 | } |  | 3389 | }
| 3390 |  |  | 3390 |
| 3391 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setNSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3391 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setNSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 3392 | { |  | 3392 | {
| 3393 | using namespace cv; |  | 3393 | using namespace cv;
| 3394 |  |  | 3394 |
| 3395 |  |  | 3395 |
| 3396 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3396 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3397 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3397 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3398 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3398 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3399 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3399 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3400 | PyObject* pyobj__nN = NULL; |  | 3400 | PyObject* pyobj__nN = NULL;
| 3401 | int _nN=0; |  | 3401 | int _nN=0;
| 3402 |  |  | 3402 |
| 3403 | const char* keywords[] = { "_nN", NULL }; |  | 3403 | const char* keywords[] = { "_nN", NULL };
| 3404 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setNSamples", (char**)keywords, &pyobj__nN) && |  | 3404 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setNSamples", (char**)keywords, &pyobj__nN) &&
| 3405 | pyopencv_to_safe(pyobj__nN, _nN, ArgInfo("_nN", 0)) ) |  | 3405 | pyopencv_to_safe(pyobj__nN, _nN, ArgInfo("_nN", 0)) )
| 3406 | { |  | 3406 | {
| 3407 | ERRWRAP2(_self_->setNSamples(_nN)); |  | 3407 | ERRWRAP2(_self_->setNSamples(_nN));
| 3408 | Py_RETURN_NONE; |  | 3408 | Py_RETURN_NONE;
| 3409 | } |  | 3409 | }
| 3410 |  |  | 3410 |
| 3411 | return NULL; |  | 3411 | return NULL;
| 3412 | } |  | 3412 | }
| 3413 |  |  | 3413 |
| 3414 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3414 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3415 | { |  | 3415 | {
| 3416 | using namespace cv; |  | 3416 | using namespace cv;
| 3417 |  |  | 3417 |
| 3418 |  |  | 3418 |
| 3419 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3419 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3420 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3420 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3421 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3421 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3422 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3422 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3423 | PyObject* pyobj_threshold = NULL; |  | 3423 | PyObject* pyobj_threshold = NULL;
| 3424 | double threshold=0; |  | 3424 | double threshold=0;
| 3425 |  |  | 3425 |
| 3426 | const char* keywords[] = { "threshold", NULL }; |  | 3426 | const char* keywords[] = { "threshold", NULL };
| 3427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setShadowThreshold", (char**)keywords, &pyobj_threshold) && |  | 3427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setShadowThreshold", (char**)keywords, &pyobj_threshold) &&
| 3428 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 3428 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 3429 | { |  | 3429 | {
| 3430 | ERRWRAP2(_self_->setShadowThreshold(threshold)); |  | 3430 | ERRWRAP2(_self_->setShadowThreshold(threshold));
| 3431 | Py_RETURN_NONE; |  | 3431 | Py_RETURN_NONE;
| 3432 | } |  | 3432 | }
| 3433 |  |  | 3433 |
| 3434 | return NULL; |  | 3434 | return NULL;
| 3435 | } |  | 3435 | }
| 3436 |  |  | 3436 |
| 3437 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setShadowValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3437 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setShadowValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 3438 | { |  | 3438 | {
| 3439 | using namespace cv; |  | 3439 | using namespace cv;
| 3440 |  |  | 3440 |
| 3441 |  |  | 3441 |
| 3442 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3442 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3443 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3443 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3444 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3444 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3445 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3445 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3446 | PyObject* pyobj_value = NULL; |  | 3446 | PyObject* pyobj_value = NULL;
| 3447 | int value=0; |  | 3447 | int value=0;
| 3448 |  |  | 3448 |
| 3449 | const char* keywords[] = { "value", NULL }; |  | 3449 | const char* keywords[] = { "value", NULL };
| 3450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setShadowValue", (char**)keywords, &pyobj_value) && |  | 3450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setShadowValue", (char**)keywords, &pyobj_value) &&
| 3451 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 3451 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 3452 | { |  | 3452 | {
| 3453 | ERRWRAP2(_self_->setShadowValue(value)); |  | 3453 | ERRWRAP2(_self_->setShadowValue(value));
| 3454 | Py_RETURN_NONE; |  | 3454 | Py_RETURN_NONE;
| 3455 | } |  | 3455 | }
| 3456 |  |  | 3456 |
| 3457 | return NULL; |  | 3457 | return NULL;
| 3458 | } |  | 3458 | }
| 3459 |  |  | 3459 |
| 3460 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setkNNSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3460 | static PyObject* pyopencv_cv_BackgroundSubtractorKNN_setkNNSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 3461 | { |  | 3461 | {
| 3462 | using namespace cv; |  | 3462 | using namespace cv;
| 3463 |  |  | 3463 |
| 3464 |  |  | 3464 |
| 3465 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0; |  | 3465 | Ptr<cv::BackgroundSubtractorKNN> * self1 = 0;
| 3466 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1)) |  | 3466 | if (!pyopencv_BackgroundSubtractorKNN_getp(self, self1))
| 3467 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)"); |  | 3467 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorKNN' or its derivative)");
| 3468 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1); |  | 3468 | Ptr<cv::BackgroundSubtractorKNN> _self_ = *(self1);
| 3469 | PyObject* pyobj__nkNN = NULL; |  | 3469 | PyObject* pyobj__nkNN = NULL;
| 3470 | int _nkNN=0; |  | 3470 | int _nkNN=0;
| 3471 |  |  | 3471 |
| 3472 | const char* keywords[] = { "_nkNN", NULL }; |  | 3472 | const char* keywords[] = { "_nkNN", NULL };
| 3473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setkNNSamples", (char**)keywords, &pyobj__nkNN) && |  | 3473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorKNN.setkNNSamples", (char**)keywords, &pyobj__nkNN) &&
| 3474 | pyopencv_to_safe(pyobj__nkNN, _nkNN, ArgInfo("_nkNN", 0)) ) |  | 3474 | pyopencv_to_safe(pyobj__nkNN, _nkNN, ArgInfo("_nkNN", 0)) )
| 3475 | { |  | 3475 | {
| 3476 | ERRWRAP2(_self_->setkNNSamples(_nkNN)); |  | 3476 | ERRWRAP2(_self_->setkNNSamples(_nkNN));
| 3477 | Py_RETURN_NONE; |  | 3477 | Py_RETURN_NONE;
| 3478 | } |  | 3478 | }
| 3479 |  |  | 3479 |
| 3480 | return NULL; |  | 3480 | return NULL;
| 3481 | } |  | 3481 | }
| 3482 |  |  | 3482 |
| 3483 |  |  | 3483 |
| 3484 |  |  | 3484 |
| 3485 | // Tables (BackgroundSubtractorKNN) |  | 3485 | // Tables (BackgroundSubtractorKNN)
| 3486 |  |  | 3486 |
| 3487 | static PyGetSetDef pyopencv_BackgroundSubtractorKNN_getseters[] = |  | 3487 | static PyGetSetDef pyopencv_BackgroundSubtractorKNN_getseters[] =
| 3488 | { |  | 3488 | {
| 3489 | {NULL} /* Sentinel */ |  | 3489 | {NULL} /* Sentinel */
| 3490 | }; |  | 3490 | };
| 3491 |  |  | 3491 |
| 3492 | static PyMethodDef pyopencv_BackgroundSubtractorKNN_methods[] = |  | 3492 | static PyMethodDef pyopencv_BackgroundSubtractorKNN_methods[] =
| 3493 | { |  | 3493 | {
| 3494 | {"getDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getDetectShadows, 0), "getDetectShadows() -> retval\n. @brief Returns the shadow detection flag\n. \n. If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorKNN for\n. details."}, |  | 3494 | {"getDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getDetectShadows, 0), "getDetectShadows() -> retval\n. @brief Returns the shadow detection flag\n. \n. If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorKNN for\n. details."},
| 3495 | {"getDist2Threshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getDist2Threshold, 0), "getDist2Threshold() -> retval\n. @brief Returns the threshold on the squared distance between the pixel and the sample\n. \n. The threshold on the squared distance between the pixel and the sample to decide whether a pixel is\n. close to a data sample."}, |  | 3495 | {"getDist2Threshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getDist2Threshold, 0), "getDist2Threshold() -> retval\n. @brief Returns the threshold on the squared distance between the pixel and the sample\n. \n. The threshold on the squared distance between the pixel and the sample to decide whether a pixel is\n. close to a data sample."},
| 3496 | {"getHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getHistory, 0), "getHistory() -> retval\n. @brief Returns the number of last frames that affect the background model"}, |  | 3496 | {"getHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getHistory, 0), "getHistory() -> retval\n. @brief Returns the number of last frames that affect the background model"},
| 3497 | {"getNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getNSamples, 0), "getNSamples() -> retval\n. @brief Returns the number of data samples in the background model"}, |  | 3497 | {"getNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getNSamples, 0), "getNSamples() -> retval\n. @brief Returns the number of data samples in the background model"},
| 3498 | {"getShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getShadowThreshold, 0), "getShadowThreshold() -> retval\n. @brief Returns the shadow threshold\n. \n. A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in\n. the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel\n. is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,\n. *Detecting Moving Shadows...*, IEEE PAMI,2003."}, |  | 3498 | {"getShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getShadowThreshold, 0), "getShadowThreshold() -> retval\n. @brief Returns the shadow threshold\n. \n. A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in\n. the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel\n. is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,\n. *Detecting Moving Shadows...*, IEEE PAMI,2003."},
| 3499 | {"getShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getShadowValue, 0), "getShadowValue() -> retval\n. @brief Returns the shadow value\n. \n. Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0\n. in the mask always means background, 255 means foreground."}, |  | 3499 | {"getShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getShadowValue, 0), "getShadowValue() -> retval\n. @brief Returns the shadow value\n. \n. Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0\n. in the mask always means background, 255 means foreground."},
| 3500 | {"getkNNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getkNNSamples, 0), "getkNNSamples() -> retval\n. @brief Returns the number of neighbours, the k in the kNN.\n. \n. K is the number of samples that need to be within dist2Threshold in order to decide that that\n. pixel is matching the kNN background model."}, |  | 3500 | {"getkNNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_getkNNSamples, 0), "getkNNSamples() -> retval\n. @brief Returns the number of neighbours, the k in the kNN.\n. \n. K is the number of samples that need to be within dist2Threshold in order to decide that that\n. pixel is matching the kNN background model."},
| 3501 | {"setDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setDetectShadows, 0), "setDetectShadows(detectShadows) -> None\n. @brief Enables or disables shadow detection"}, |  | 3501 | {"setDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setDetectShadows, 0), "setDetectShadows(detectShadows) -> None\n. @brief Enables or disables shadow detection"},
| 3502 | {"setDist2Threshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setDist2Threshold, 0), "setDist2Threshold(_dist2Threshold) -> None\n. @brief Sets the threshold on the squared distance"}, |  | 3502 | {"setDist2Threshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setDist2Threshold, 0), "setDist2Threshold(_dist2Threshold) -> None\n. @brief Sets the threshold on the squared distance"},
| 3503 | {"setHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setHistory, 0), "setHistory(history) -> None\n. @brief Sets the number of last frames that affect the background model"}, |  | 3503 | {"setHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setHistory, 0), "setHistory(history) -> None\n. @brief Sets the number of last frames that affect the background model"},
| 3504 | {"setNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setNSamples, 0), "setNSamples(_nN) -> None\n. @brief Sets the number of data samples in the background model.\n. \n. The model needs to be reinitalized to reserve memory."}, |  | 3504 | {"setNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setNSamples, 0), "setNSamples(_nN) -> None\n. @brief Sets the number of data samples in the background model.\n. \n. The model needs to be reinitalized to reserve memory."},
| 3505 | {"setShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setShadowThreshold, 0), "setShadowThreshold(threshold) -> None\n. @brief Sets the shadow threshold"}, |  | 3505 | {"setShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setShadowThreshold, 0), "setShadowThreshold(threshold) -> None\n. @brief Sets the shadow threshold"},
| 3506 | {"setShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setShadowValue, 0), "setShadowValue(value) -> None\n. @brief Sets the shadow value"}, |  | 3506 | {"setShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setShadowValue, 0), "setShadowValue(value) -> None\n. @brief Sets the shadow value"},
| 3507 | {"setkNNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setkNNSamples, 0), "setkNNSamples(_nkNN) -> None\n. @brief Sets the k in the kNN. How many nearest neighbours need to match."}, |  | 3507 | {"setkNNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorKNN_setkNNSamples, 0), "setkNNSamples(_nkNN) -> None\n. @brief Sets the k in the kNN. How many nearest neighbours need to match."},
| 3508 |  |  | 3508 |
| 3509 | {NULL, NULL} |  | 3509 | {NULL, NULL}
| 3510 | }; |  | 3510 | };
| 3511 |  |  | 3511 |
| 3512 | // Converter (BackgroundSubtractorKNN) |  | 3512 | // Converter (BackgroundSubtractorKNN)
| 3513 |  |  | 3513 |
| 3514 | template<> |  | 3514 | template<>
| 3515 | struct PyOpenCV_Converter< Ptr<cv::BackgroundSubtractorKNN> > |  | 3515 | struct PyOpenCV_Converter< Ptr<cv::BackgroundSubtractorKNN> >
| 3516 | { |  | 3516 | {
| 3517 | static PyObject* from(const Ptr<cv::BackgroundSubtractorKNN>& r) |  | 3517 | static PyObject* from(const Ptr<cv::BackgroundSubtractorKNN>& r)
| 3518 | { |  | 3518 | {
| 3519 | return pyopencv_BackgroundSubtractorKNN_Instance(r); |  | 3519 | return pyopencv_BackgroundSubtractorKNN_Instance(r);
| 3520 | } |  | 3520 | }
| 3521 | static bool to(PyObject* src, Ptr<cv::BackgroundSubtractorKNN>& dst, const ArgInfo& info) |  | 3521 | static bool to(PyObject* src, Ptr<cv::BackgroundSubtractorKNN>& dst, const ArgInfo& info)
| 3522 | { |  | 3522 | {
| 3523 | if(!src || src == Py_None) |  | 3523 | if(!src || src == Py_None)
| 3524 | return true; |  | 3524 | return true;
| 3525 | Ptr<cv::BackgroundSubtractorKNN> * dst_; |  | 3525 | Ptr<cv::BackgroundSubtractorKNN> * dst_;
| 3526 | if (pyopencv_BackgroundSubtractorKNN_getp(src, dst_)) |  | 3526 | if (pyopencv_BackgroundSubtractorKNN_getp(src, dst_))
| 3527 | { |  | 3527 | {
| 3528 | dst = *dst_; |  | 3528 | dst = *dst_;
| 3529 | return true; |  | 3529 | return true;
| 3530 | } |  | 3530 | }
| 3531 |  |  | 3531 |
| 3532 | failmsg("Expected Ptr<cv::BackgroundSubtractorKNN> for argument '%s'", info.name); |  | 3532 | failmsg("Expected Ptr<cv::BackgroundSubtractorKNN> for argument '%s'", info.name);
| 3533 | return false; |  | 3533 | return false;
| 3534 | } |  | 3534 | }
| 3535 | }; |  | 3535 | };
| 3536 |  |  | 3536 |
| 3537 | //================================================================================ |  | 3537 | //================================================================================
| 3538 | // BackgroundSubtractorMOG2 (Generic) |  | 3538 | // BackgroundSubtractorMOG2 (Generic)
| 3539 | //================================================================================ |  | 3539 | //================================================================================
| 3540 |  |  | 3540 |
| 3541 | // GetSet (BackgroundSubtractorMOG2) |  | 3541 | // GetSet (BackgroundSubtractorMOG2)
| 3542 |  |  | 3542 |
| 3543 |  |  | 3543 |
| 3544 |  |  | 3544 |
| 3545 | // Methods (BackgroundSubtractorMOG2) |  | 3545 | // Methods (BackgroundSubtractorMOG2)
| 3546 |  |  | 3546 |
| 3547 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3547 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 3548 | { |  | 3548 | {
| 3549 | using namespace cv; |  | 3549 | using namespace cv;
| 3550 |  |  | 3550 |
| 3551 |  |  | 3551 |
| 3552 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3552 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3553 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3553 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3554 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3554 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3555 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3555 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3556 | pyPrepareArgumentConversionErrorsStorage(2); |  | 3556 | pyPrepareArgumentConversionErrorsStorage(2);
| 3557 |  |  | 3557 |
| 3558 | { |  | 3558 | {
| 3559 | PyObject* pyobj_image = NULL; |  | 3559 | PyObject* pyobj_image = NULL;
| 3560 | Mat image; |  | 3560 | Mat image;
| 3561 | PyObject* pyobj_fgmask = NULL; |  | 3561 | PyObject* pyobj_fgmask = NULL;
| 3562 | Mat fgmask; |  | 3562 | Mat fgmask;
| 3563 | PyObject* pyobj_learningRate = NULL; |  | 3563 | PyObject* pyobj_learningRate = NULL;
| 3564 | double learningRate=-1; |  | 3564 | double learningRate=-1;
| 3565 |  |  | 3565 |
| 3566 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 3566 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 3567 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractorMOG2.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 3567 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractorMOG2.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 3568 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 3568 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 3569 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 3569 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 3570 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 3570 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 3571 | { |  | 3571 | {
| 3572 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 3572 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 3573 | return pyopencv_from(fgmask); |  | 3573 | return pyopencv_from(fgmask);
| 3574 | } |  | 3574 | }
| 3575 |  |  | 3575 |
| 3576 |  |  | 3576 |
| 3577 | pyPopulateArgumentConversionErrors(); |  | 3577 | pyPopulateArgumentConversionErrors();
| 3578 | } |  | 3578 | }
| 3579 |  |  | 3579 |
| 3580 |  |  | 3580 |
| 3581 | { |  | 3581 | {
| 3582 | PyObject* pyobj_image = NULL; |  | 3582 | PyObject* pyobj_image = NULL;
| 3583 | UMat image; |  | 3583 | UMat image;
| 3584 | PyObject* pyobj_fgmask = NULL; |  | 3584 | PyObject* pyobj_fgmask = NULL;
| 3585 | UMat fgmask; |  | 3585 | UMat fgmask;
| 3586 | PyObject* pyobj_learningRate = NULL; |  | 3586 | PyObject* pyobj_learningRate = NULL;
| 3587 | double learningRate=-1; |  | 3587 | double learningRate=-1;
| 3588 |  |  | 3588 |
| 3589 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 3589 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 3590 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractorMOG2.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 3590 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:BackgroundSubtractorMOG2.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 3591 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 3591 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 3592 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 3592 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 3593 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 3593 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 3594 | { |  | 3594 | {
| 3595 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 3595 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 3596 | return pyopencv_from(fgmask); |  | 3596 | return pyopencv_from(fgmask);
| 3597 | } |  | 3597 | }
| 3598 |  |  | 3598 |
| 3599 |  |  | 3599 |
| 3600 | pyPopulateArgumentConversionErrors(); |  | 3600 | pyPopulateArgumentConversionErrors();
| 3601 | } |  | 3601 | }
| 3602 | pyRaiseCVOverloadException("apply"); |  | 3602 | pyRaiseCVOverloadException("apply");
| 3603 |  |  | 3603 |
| 3604 | return NULL; |  | 3604 | return NULL;
| 3605 | } |  | 3605 | }
| 3606 |  |  | 3606 |
| 3607 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3607 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 3608 | { |  | 3608 | {
| 3609 | using namespace cv; |  | 3609 | using namespace cv;
| 3610 |  |  | 3610 |
| 3611 |  |  | 3611 |
| 3612 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3612 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3613 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3613 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3614 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3614 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3615 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3615 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3616 | double retval; |  | 3616 | double retval;
| 3617 |  |  | 3617 |
| 3618 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3618 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3619 | { |  | 3619 | {
| 3620 | ERRWRAP2(retval = _self_->getBackgroundRatio()); |  | 3620 | ERRWRAP2(retval = _self_->getBackgroundRatio());
| 3621 | return pyopencv_from(retval); |  | 3621 | return pyopencv_from(retval);
| 3622 | } |  | 3622 | }
| 3623 |  |  | 3623 |
| 3624 | return NULL; |  | 3624 | return NULL;
| 3625 | } |  | 3625 | }
| 3626 |  |  | 3626 |
| 3627 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getComplexityReductionThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3627 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getComplexityReductionThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3628 | { |  | 3628 | {
| 3629 | using namespace cv; |  | 3629 | using namespace cv;
| 3630 |  |  | 3630 |
| 3631 |  |  | 3631 |
| 3632 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3632 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3633 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3633 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3634 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3634 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3635 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3635 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3636 | double retval; |  | 3636 | double retval;
| 3637 |  |  | 3637 |
| 3638 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3638 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3639 | { |  | 3639 | {
| 3640 | ERRWRAP2(retval = _self_->getComplexityReductionThreshold()); |  | 3640 | ERRWRAP2(retval = _self_->getComplexityReductionThreshold());
| 3641 | return pyopencv_from(retval); |  | 3641 | return pyopencv_from(retval);
| 3642 | } |  | 3642 | }
| 3643 |  |  | 3643 |
| 3644 | return NULL; |  | 3644 | return NULL;
| 3645 | } |  | 3645 | }
| 3646 |  |  | 3646 |
| 3647 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3647 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw)
| 3648 | { |  | 3648 | {
| 3649 | using namespace cv; |  | 3649 | using namespace cv;
| 3650 |  |  | 3650 |
| 3651 |  |  | 3651 |
| 3652 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3652 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3653 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3653 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3654 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3654 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3655 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3655 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3656 | bool retval; |  | 3656 | bool retval;
| 3657 |  |  | 3657 |
| 3658 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3658 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3659 | { |  | 3659 | {
| 3660 | ERRWRAP2(retval = _self_->getDetectShadows()); |  | 3660 | ERRWRAP2(retval = _self_->getDetectShadows());
| 3661 | return pyopencv_from(retval); |  | 3661 | return pyopencv_from(retval);
| 3662 | } |  | 3662 | }
| 3663 |  |  | 3663 |
| 3664 | return NULL; |  | 3664 | return NULL;
| 3665 | } |  | 3665 | }
| 3666 |  |  | 3666 |
| 3667 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3667 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 3668 | { |  | 3668 | {
| 3669 | using namespace cv; |  | 3669 | using namespace cv;
| 3670 |  |  | 3670 |
| 3671 |  |  | 3671 |
| 3672 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3672 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3673 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3673 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3674 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3674 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3675 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3675 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3676 | int retval; |  | 3676 | int retval;
| 3677 |  |  | 3677 |
| 3678 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3678 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3679 | { |  | 3679 | {
| 3680 | ERRWRAP2(retval = _self_->getHistory()); |  | 3680 | ERRWRAP2(retval = _self_->getHistory());
| 3681 | return pyopencv_from(retval); |  | 3681 | return pyopencv_from(retval);
| 3682 | } |  | 3682 | }
| 3683 |  |  | 3683 |
| 3684 | return NULL; |  | 3684 | return NULL;
| 3685 | } |  | 3685 | }
| 3686 |  |  | 3686 |
| 3687 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getNMixtures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3687 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getNMixtures(PyObject* self, PyObject* py_args, PyObject* kw)
| 3688 | { |  | 3688 | {
| 3689 | using namespace cv; |  | 3689 | using namespace cv;
| 3690 |  |  | 3690 |
| 3691 |  |  | 3691 |
| 3692 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3692 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3693 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3693 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3694 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3694 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3695 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3695 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3696 | int retval; |  | 3696 | int retval;
| 3697 |  |  | 3697 |
| 3698 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3698 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3699 | { |  | 3699 | {
| 3700 | ERRWRAP2(retval = _self_->getNMixtures()); |  | 3700 | ERRWRAP2(retval = _self_->getNMixtures());
| 3701 | return pyopencv_from(retval); |  | 3701 | return pyopencv_from(retval);
| 3702 | } |  | 3702 | }
| 3703 |  |  | 3703 |
| 3704 | return NULL; |  | 3704 | return NULL;
| 3705 | } |  | 3705 | }
| 3706 |  |  | 3706 |
| 3707 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3707 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3708 | { |  | 3708 | {
| 3709 | using namespace cv; |  | 3709 | using namespace cv;
| 3710 |  |  | 3710 |
| 3711 |  |  | 3711 |
| 3712 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3712 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3713 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3713 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3714 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3714 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3715 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3715 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3716 | double retval; |  | 3716 | double retval;
| 3717 |  |  | 3717 |
| 3718 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3718 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3719 | { |  | 3719 | {
| 3720 | ERRWRAP2(retval = _self_->getShadowThreshold()); |  | 3720 | ERRWRAP2(retval = _self_->getShadowThreshold());
| 3721 | return pyopencv_from(retval); |  | 3721 | return pyopencv_from(retval);
| 3722 | } |  | 3722 | }
| 3723 |  |  | 3723 |
| 3724 | return NULL; |  | 3724 | return NULL;
| 3725 | } |  | 3725 | }
| 3726 |  |  | 3726 |
| 3727 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getShadowValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3727 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getShadowValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 3728 | { |  | 3728 | {
| 3729 | using namespace cv; |  | 3729 | using namespace cv;
| 3730 |  |  | 3730 |
| 3731 |  |  | 3731 |
| 3732 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3732 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3733 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3733 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3734 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3734 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3735 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3735 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3736 | int retval; |  | 3736 | int retval;
| 3737 |  |  | 3737 |
| 3738 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3738 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3739 | { |  | 3739 | {
| 3740 | ERRWRAP2(retval = _self_->getShadowValue()); |  | 3740 | ERRWRAP2(retval = _self_->getShadowValue());
| 3741 | return pyopencv_from(retval); |  | 3741 | return pyopencv_from(retval);
| 3742 | } |  | 3742 | }
| 3743 |  |  | 3743 |
| 3744 | return NULL; |  | 3744 | return NULL;
| 3745 | } |  | 3745 | }
| 3746 |  |  | 3746 |
| 3747 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarInit(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3747 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarInit(PyObject* self, PyObject* py_args, PyObject* kw)
| 3748 | { |  | 3748 | {
| 3749 | using namespace cv; |  | 3749 | using namespace cv;
| 3750 |  |  | 3750 |
| 3751 |  |  | 3751 |
| 3752 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3752 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3753 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3753 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3754 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3754 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3755 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3755 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3756 | double retval; |  | 3756 | double retval;
| 3757 |  |  | 3757 |
| 3758 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3758 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3759 | { |  | 3759 | {
| 3760 | ERRWRAP2(retval = _self_->getVarInit()); |  | 3760 | ERRWRAP2(retval = _self_->getVarInit());
| 3761 | return pyopencv_from(retval); |  | 3761 | return pyopencv_from(retval);
| 3762 | } |  | 3762 | }
| 3763 |  |  | 3763 |
| 3764 | return NULL; |  | 3764 | return NULL;
| 3765 | } |  | 3765 | }
| 3766 |  |  | 3766 |
| 3767 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarMax(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3767 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarMax(PyObject* self, PyObject* py_args, PyObject* kw)
| 3768 | { |  | 3768 | {
| 3769 | using namespace cv; |  | 3769 | using namespace cv;
| 3770 |  |  | 3770 |
| 3771 |  |  | 3771 |
| 3772 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3772 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3773 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3773 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3774 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3774 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3775 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3775 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3776 | double retval; |  | 3776 | double retval;
| 3777 |  |  | 3777 |
| 3778 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3778 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3779 | { |  | 3779 | {
| 3780 | ERRWRAP2(retval = _self_->getVarMax()); |  | 3780 | ERRWRAP2(retval = _self_->getVarMax());
| 3781 | return pyopencv_from(retval); |  | 3781 | return pyopencv_from(retval);
| 3782 | } |  | 3782 | }
| 3783 |  |  | 3783 |
| 3784 | return NULL; |  | 3784 | return NULL;
| 3785 | } |  | 3785 | }
| 3786 |  |  | 3786 |
| 3787 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarMin(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3787 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarMin(PyObject* self, PyObject* py_args, PyObject* kw)
| 3788 | { |  | 3788 | {
| 3789 | using namespace cv; |  | 3789 | using namespace cv;
| 3790 |  |  | 3790 |
| 3791 |  |  | 3791 |
| 3792 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3792 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3793 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3793 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3794 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3794 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3795 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3795 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3796 | double retval; |  | 3796 | double retval;
| 3797 |  |  | 3797 |
| 3798 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3798 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3799 | { |  | 3799 | {
| 3800 | ERRWRAP2(retval = _self_->getVarMin()); |  | 3800 | ERRWRAP2(retval = _self_->getVarMin());
| 3801 | return pyopencv_from(retval); |  | 3801 | return pyopencv_from(retval);
| 3802 | } |  | 3802 | }
| 3803 |  |  | 3803 |
| 3804 | return NULL; |  | 3804 | return NULL;
| 3805 | } |  | 3805 | }
| 3806 |  |  | 3806 |
| 3807 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3807 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3808 | { |  | 3808 | {
| 3809 | using namespace cv; |  | 3809 | using namespace cv;
| 3810 |  |  | 3810 |
| 3811 |  |  | 3811 |
| 3812 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3812 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3813 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3813 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3814 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3814 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3815 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3815 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3816 | double retval; |  | 3816 | double retval;
| 3817 |  |  | 3817 |
| 3818 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3818 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3819 | { |  | 3819 | {
| 3820 | ERRWRAP2(retval = _self_->getVarThreshold()); |  | 3820 | ERRWRAP2(retval = _self_->getVarThreshold());
| 3821 | return pyopencv_from(retval); |  | 3821 | return pyopencv_from(retval);
| 3822 | } |  | 3822 | }
| 3823 |  |  | 3823 |
| 3824 | return NULL; |  | 3824 | return NULL;
| 3825 | } |  | 3825 | }
| 3826 |  |  | 3826 |
| 3827 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarThresholdGen(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3827 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_getVarThresholdGen(PyObject* self, PyObject* py_args, PyObject* kw)
| 3828 | { |  | 3828 | {
| 3829 | using namespace cv; |  | 3829 | using namespace cv;
| 3830 |  |  | 3830 |
| 3831 |  |  | 3831 |
| 3832 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3832 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3833 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3833 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3834 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3834 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3835 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3835 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3836 | double retval; |  | 3836 | double retval;
| 3837 |  |  | 3837 |
| 3838 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 3838 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 3839 | { |  | 3839 | {
| 3840 | ERRWRAP2(retval = _self_->getVarThresholdGen()); |  | 3840 | ERRWRAP2(retval = _self_->getVarThresholdGen());
| 3841 | return pyopencv_from(retval); |  | 3841 | return pyopencv_from(retval);
| 3842 | } |  | 3842 | }
| 3843 |  |  | 3843 |
| 3844 | return NULL; |  | 3844 | return NULL;
| 3845 | } |  | 3845 | }
| 3846 |  |  | 3846 |
| 3847 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3847 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 3848 | { |  | 3848 | {
| 3849 | using namespace cv; |  | 3849 | using namespace cv;
| 3850 |  |  | 3850 |
| 3851 |  |  | 3851 |
| 3852 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3852 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3853 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3853 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3854 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3854 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3855 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3855 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3856 | PyObject* pyobj_ratio = NULL; |  | 3856 | PyObject* pyobj_ratio = NULL;
| 3857 | double ratio=0; |  | 3857 | double ratio=0;
| 3858 |  |  | 3858 |
| 3859 | const char* keywords[] = { "ratio", NULL }; |  | 3859 | const char* keywords[] = { "ratio", NULL };
| 3860 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setBackgroundRatio", (char**)keywords, &pyobj_ratio) && |  | 3860 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setBackgroundRatio", (char**)keywords, &pyobj_ratio) &&
| 3861 | pyopencv_to_safe(pyobj_ratio, ratio, ArgInfo("ratio", 0)) ) |  | 3861 | pyopencv_to_safe(pyobj_ratio, ratio, ArgInfo("ratio", 0)) )
| 3862 | { |  | 3862 | {
| 3863 | ERRWRAP2(_self_->setBackgroundRatio(ratio)); |  | 3863 | ERRWRAP2(_self_->setBackgroundRatio(ratio));
| 3864 | Py_RETURN_NONE; |  | 3864 | Py_RETURN_NONE;
| 3865 | } |  | 3865 | }
| 3866 |  |  | 3866 |
| 3867 | return NULL; |  | 3867 | return NULL;
| 3868 | } |  | 3868 | }
| 3869 |  |  | 3869 |
| 3870 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3870 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3871 | { |  | 3871 | {
| 3872 | using namespace cv; |  | 3872 | using namespace cv;
| 3873 |  |  | 3873 |
| 3874 |  |  | 3874 |
| 3875 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3875 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3876 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3876 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3877 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3877 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3878 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3878 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3879 | PyObject* pyobj_ct = NULL; |  | 3879 | PyObject* pyobj_ct = NULL;
| 3880 | double ct=0; |  | 3880 | double ct=0;
| 3881 |  |  | 3881 |
| 3882 | const char* keywords[] = { "ct", NULL }; |  | 3882 | const char* keywords[] = { "ct", NULL };
| 3883 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setComplexityReductionThreshold", (char**)keywords, &pyobj_ct) && |  | 3883 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setComplexityReductionThreshold", (char**)keywords, &pyobj_ct) &&
| 3884 | pyopencv_to_safe(pyobj_ct, ct, ArgInfo("ct", 0)) ) |  | 3884 | pyopencv_to_safe(pyobj_ct, ct, ArgInfo("ct", 0)) )
| 3885 | { |  | 3885 | {
| 3886 | ERRWRAP2(_self_->setComplexityReductionThreshold(ct)); |  | 3886 | ERRWRAP2(_self_->setComplexityReductionThreshold(ct));
| 3887 | Py_RETURN_NONE; |  | 3887 | Py_RETURN_NONE;
| 3888 | } |  | 3888 | }
| 3889 |  |  | 3889 |
| 3890 | return NULL; |  | 3890 | return NULL;
| 3891 | } |  | 3891 | }
| 3892 |  |  | 3892 |
| 3893 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3893 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setDetectShadows(PyObject* self, PyObject* py_args, PyObject* kw)
| 3894 | { |  | 3894 | {
| 3895 | using namespace cv; |  | 3895 | using namespace cv;
| 3896 |  |  | 3896 |
| 3897 |  |  | 3897 |
| 3898 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3898 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3899 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3899 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3900 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3900 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3901 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3901 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3902 | PyObject* pyobj_detectShadows = NULL; |  | 3902 | PyObject* pyobj_detectShadows = NULL;
| 3903 | bool detectShadows=0; |  | 3903 | bool detectShadows=0;
| 3904 |  |  | 3904 |
| 3905 | const char* keywords[] = { "detectShadows", NULL }; |  | 3905 | const char* keywords[] = { "detectShadows", NULL };
| 3906 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setDetectShadows", (char**)keywords, &pyobj_detectShadows) && |  | 3906 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setDetectShadows", (char**)keywords, &pyobj_detectShadows) &&
| 3907 | pyopencv_to_safe(pyobj_detectShadows, detectShadows, ArgInfo("detectShadows", 0)) ) |  | 3907 | pyopencv_to_safe(pyobj_detectShadows, detectShadows, ArgInfo("detectShadows", 0)) )
| 3908 | { |  | 3908 | {
| 3909 | ERRWRAP2(_self_->setDetectShadows(detectShadows)); |  | 3909 | ERRWRAP2(_self_->setDetectShadows(detectShadows));
| 3910 | Py_RETURN_NONE; |  | 3910 | Py_RETURN_NONE;
| 3911 | } |  | 3911 | }
| 3912 |  |  | 3912 |
| 3913 | return NULL; |  | 3913 | return NULL;
| 3914 | } |  | 3914 | }
| 3915 |  |  | 3915 |
| 3916 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3916 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 3917 | { |  | 3917 | {
| 3918 | using namespace cv; |  | 3918 | using namespace cv;
| 3919 |  |  | 3919 |
| 3920 |  |  | 3920 |
| 3921 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3921 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3922 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3922 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3923 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3923 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3924 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3924 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3925 | PyObject* pyobj_history = NULL; |  | 3925 | PyObject* pyobj_history = NULL;
| 3926 | int history=0; |  | 3926 | int history=0;
| 3927 |  |  | 3927 |
| 3928 | const char* keywords[] = { "history", NULL }; |  | 3928 | const char* keywords[] = { "history", NULL };
| 3929 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setHistory", (char**)keywords, &pyobj_history) && |  | 3929 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setHistory", (char**)keywords, &pyobj_history) &&
| 3930 | pyopencv_to_safe(pyobj_history, history, ArgInfo("history", 0)) ) |  | 3930 | pyopencv_to_safe(pyobj_history, history, ArgInfo("history", 0)) )
| 3931 | { |  | 3931 | {
| 3932 | ERRWRAP2(_self_->setHistory(history)); |  | 3932 | ERRWRAP2(_self_->setHistory(history));
| 3933 | Py_RETURN_NONE; |  | 3933 | Py_RETURN_NONE;
| 3934 | } |  | 3934 | }
| 3935 |  |  | 3935 |
| 3936 | return NULL; |  | 3936 | return NULL;
| 3937 | } |  | 3937 | }
| 3938 |  |  | 3938 |
| 3939 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setNMixtures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3939 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setNMixtures(PyObject* self, PyObject* py_args, PyObject* kw)
| 3940 | { |  | 3940 | {
| 3941 | using namespace cv; |  | 3941 | using namespace cv;
| 3942 |  |  | 3942 |
| 3943 |  |  | 3943 |
| 3944 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3944 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3945 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3945 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3946 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3946 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3947 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3947 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3948 | PyObject* pyobj_nmixtures = NULL; |  | 3948 | PyObject* pyobj_nmixtures = NULL;
| 3949 | int nmixtures=0; |  | 3949 | int nmixtures=0;
| 3950 |  |  | 3950 |
| 3951 | const char* keywords[] = { "nmixtures", NULL }; |  | 3951 | const char* keywords[] = { "nmixtures", NULL };
| 3952 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setNMixtures", (char**)keywords, &pyobj_nmixtures) && |  | 3952 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setNMixtures", (char**)keywords, &pyobj_nmixtures) &&
| 3953 | pyopencv_to_safe(pyobj_nmixtures, nmixtures, ArgInfo("nmixtures", 0)) ) |  | 3953 | pyopencv_to_safe(pyobj_nmixtures, nmixtures, ArgInfo("nmixtures", 0)) )
| 3954 | { |  | 3954 | {
| 3955 | ERRWRAP2(_self_->setNMixtures(nmixtures)); |  | 3955 | ERRWRAP2(_self_->setNMixtures(nmixtures));
| 3956 | Py_RETURN_NONE; |  | 3956 | Py_RETURN_NONE;
| 3957 | } |  | 3957 | }
| 3958 |  |  | 3958 |
| 3959 | return NULL; |  | 3959 | return NULL;
| 3960 | } |  | 3960 | }
| 3961 |  |  | 3961 |
| 3962 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3962 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setShadowThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 3963 | { |  | 3963 | {
| 3964 | using namespace cv; |  | 3964 | using namespace cv;
| 3965 |  |  | 3965 |
| 3966 |  |  | 3966 |
| 3967 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3967 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3968 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3968 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3969 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3969 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3970 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3970 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3971 | PyObject* pyobj_threshold = NULL; |  | 3971 | PyObject* pyobj_threshold = NULL;
| 3972 | double threshold=0; |  | 3972 | double threshold=0;
| 3973 |  |  | 3973 |
| 3974 | const char* keywords[] = { "threshold", NULL }; |  | 3974 | const char* keywords[] = { "threshold", NULL };
| 3975 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setShadowThreshold", (char**)keywords, &pyobj_threshold) && |  | 3975 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setShadowThreshold", (char**)keywords, &pyobj_threshold) &&
| 3976 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 3976 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 3977 | { |  | 3977 | {
| 3978 | ERRWRAP2(_self_->setShadowThreshold(threshold)); |  | 3978 | ERRWRAP2(_self_->setShadowThreshold(threshold));
| 3979 | Py_RETURN_NONE; |  | 3979 | Py_RETURN_NONE;
| 3980 | } |  | 3980 | }
| 3981 |  |  | 3981 |
| 3982 | return NULL; |  | 3982 | return NULL;
| 3983 | } |  | 3983 | }
| 3984 |  |  | 3984 |
| 3985 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setShadowValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 3985 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setShadowValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 3986 | { |  | 3986 | {
| 3987 | using namespace cv; |  | 3987 | using namespace cv;
| 3988 |  |  | 3988 |
| 3989 |  |  | 3989 |
| 3990 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 3990 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 3991 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 3991 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 3992 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 3992 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 3993 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 3993 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 3994 | PyObject* pyobj_value = NULL; |  | 3994 | PyObject* pyobj_value = NULL;
| 3995 | int value=0; |  | 3995 | int value=0;
| 3996 |  |  | 3996 |
| 3997 | const char* keywords[] = { "value", NULL }; |  | 3997 | const char* keywords[] = { "value", NULL };
| 3998 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setShadowValue", (char**)keywords, &pyobj_value) && |  | 3998 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setShadowValue", (char**)keywords, &pyobj_value) &&
| 3999 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 3999 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 4000 | { |  | 4000 | {
| 4001 | ERRWRAP2(_self_->setShadowValue(value)); |  | 4001 | ERRWRAP2(_self_->setShadowValue(value));
| 4002 | Py_RETURN_NONE; |  | 4002 | Py_RETURN_NONE;
| 4003 | } |  | 4003 | }
| 4004 |  |  | 4004 |
| 4005 | return NULL; |  | 4005 | return NULL;
| 4006 | } |  | 4006 | }
| 4007 |  |  | 4007 |
| 4008 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarInit(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4008 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarInit(PyObject* self, PyObject* py_args, PyObject* kw)
| 4009 | { |  | 4009 | {
| 4010 | using namespace cv; |  | 4010 | using namespace cv;
| 4011 |  |  | 4011 |
| 4012 |  |  | 4012 |
| 4013 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 4013 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 4014 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 4014 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 4015 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 4015 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 4016 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 4016 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 4017 | PyObject* pyobj_varInit = NULL; |  | 4017 | PyObject* pyobj_varInit = NULL;
| 4018 | double varInit=0; |  | 4018 | double varInit=0;
| 4019 |  |  | 4019 |
| 4020 | const char* keywords[] = { "varInit", NULL }; |  | 4020 | const char* keywords[] = { "varInit", NULL };
| 4021 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarInit", (char**)keywords, &pyobj_varInit) && |  | 4021 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarInit", (char**)keywords, &pyobj_varInit) &&
| 4022 | pyopencv_to_safe(pyobj_varInit, varInit, ArgInfo("varInit", 0)) ) |  | 4022 | pyopencv_to_safe(pyobj_varInit, varInit, ArgInfo("varInit", 0)) )
| 4023 | { |  | 4023 | {
| 4024 | ERRWRAP2(_self_->setVarInit(varInit)); |  | 4024 | ERRWRAP2(_self_->setVarInit(varInit));
| 4025 | Py_RETURN_NONE; |  | 4025 | Py_RETURN_NONE;
| 4026 | } |  | 4026 | }
| 4027 |  |  | 4027 |
| 4028 | return NULL; |  | 4028 | return NULL;
| 4029 | } |  | 4029 | }
| 4030 |  |  | 4030 |
| 4031 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarMax(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4031 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarMax(PyObject* self, PyObject* py_args, PyObject* kw)
| 4032 | { |  | 4032 | {
| 4033 | using namespace cv; |  | 4033 | using namespace cv;
| 4034 |  |  | 4034 |
| 4035 |  |  | 4035 |
| 4036 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 4036 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 4037 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 4037 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 4038 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 4038 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 4039 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 4039 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 4040 | PyObject* pyobj_varMax = NULL; |  | 4040 | PyObject* pyobj_varMax = NULL;
| 4041 | double varMax=0; |  | 4041 | double varMax=0;
| 4042 |  |  | 4042 |
| 4043 | const char* keywords[] = { "varMax", NULL }; |  | 4043 | const char* keywords[] = { "varMax", NULL };
| 4044 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarMax", (char**)keywords, &pyobj_varMax) && |  | 4044 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarMax", (char**)keywords, &pyobj_varMax) &&
| 4045 | pyopencv_to_safe(pyobj_varMax, varMax, ArgInfo("varMax", 0)) ) |  | 4045 | pyopencv_to_safe(pyobj_varMax, varMax, ArgInfo("varMax", 0)) )
| 4046 | { |  | 4046 | {
| 4047 | ERRWRAP2(_self_->setVarMax(varMax)); |  | 4047 | ERRWRAP2(_self_->setVarMax(varMax));
| 4048 | Py_RETURN_NONE; |  | 4048 | Py_RETURN_NONE;
| 4049 | } |  | 4049 | }
| 4050 |  |  | 4050 |
| 4051 | return NULL; |  | 4051 | return NULL;
| 4052 | } |  | 4052 | }
| 4053 |  |  | 4053 |
| 4054 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarMin(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4054 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarMin(PyObject* self, PyObject* py_args, PyObject* kw)
| 4055 | { |  | 4055 | {
| 4056 | using namespace cv; |  | 4056 | using namespace cv;
| 4057 |  |  | 4057 |
| 4058 |  |  | 4058 |
| 4059 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 4059 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 4060 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 4060 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 4061 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 4061 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 4062 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 4062 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 4063 | PyObject* pyobj_varMin = NULL; |  | 4063 | PyObject* pyobj_varMin = NULL;
| 4064 | double varMin=0; |  | 4064 | double varMin=0;
| 4065 |  |  | 4065 |
| 4066 | const char* keywords[] = { "varMin", NULL }; |  | 4066 | const char* keywords[] = { "varMin", NULL };
| 4067 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarMin", (char**)keywords, &pyobj_varMin) && |  | 4067 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarMin", (char**)keywords, &pyobj_varMin) &&
| 4068 | pyopencv_to_safe(pyobj_varMin, varMin, ArgInfo("varMin", 0)) ) |  | 4068 | pyopencv_to_safe(pyobj_varMin, varMin, ArgInfo("varMin", 0)) )
| 4069 | { |  | 4069 | {
| 4070 | ERRWRAP2(_self_->setVarMin(varMin)); |  | 4070 | ERRWRAP2(_self_->setVarMin(varMin));
| 4071 | Py_RETURN_NONE; |  | 4071 | Py_RETURN_NONE;
| 4072 | } |  | 4072 | }
| 4073 |  |  | 4073 |
| 4074 | return NULL; |  | 4074 | return NULL;
| 4075 | } |  | 4075 | }
| 4076 |  |  | 4076 |
| 4077 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4077 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 4078 | { |  | 4078 | {
| 4079 | using namespace cv; |  | 4079 | using namespace cv;
| 4080 |  |  | 4080 |
| 4081 |  |  | 4081 |
| 4082 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 4082 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 4083 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 4083 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 4084 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 4084 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 4085 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 4085 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 4086 | PyObject* pyobj_varThreshold = NULL; |  | 4086 | PyObject* pyobj_varThreshold = NULL;
| 4087 | double varThreshold=0; |  | 4087 | double varThreshold=0;
| 4088 |  |  | 4088 |
| 4089 | const char* keywords[] = { "varThreshold", NULL }; |  | 4089 | const char* keywords[] = { "varThreshold", NULL };
| 4090 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarThreshold", (char**)keywords, &pyobj_varThreshold) && |  | 4090 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarThreshold", (char**)keywords, &pyobj_varThreshold) &&
| 4091 | pyopencv_to_safe(pyobj_varThreshold, varThreshold, ArgInfo("varThreshold", 0)) ) |  | 4091 | pyopencv_to_safe(pyobj_varThreshold, varThreshold, ArgInfo("varThreshold", 0)) )
| 4092 | { |  | 4092 | {
| 4093 | ERRWRAP2(_self_->setVarThreshold(varThreshold)); |  | 4093 | ERRWRAP2(_self_->setVarThreshold(varThreshold));
| 4094 | Py_RETURN_NONE; |  | 4094 | Py_RETURN_NONE;
| 4095 | } |  | 4095 | }
| 4096 |  |  | 4096 |
| 4097 | return NULL; |  | 4097 | return NULL;
| 4098 | } |  | 4098 | }
| 4099 |  |  | 4099 |
| 4100 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarThresholdGen(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4100 | static PyObject* pyopencv_cv_BackgroundSubtractorMOG2_setVarThresholdGen(PyObject* self, PyObject* py_args, PyObject* kw)
| 4101 | { |  | 4101 | {
| 4102 | using namespace cv; |  | 4102 | using namespace cv;
| 4103 |  |  | 4103 |
| 4104 |  |  | 4104 |
| 4105 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0; |  | 4105 | Ptr<cv::BackgroundSubtractorMOG2> * self1 = 0;
| 4106 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1)) |  | 4106 | if (!pyopencv_BackgroundSubtractorMOG2_getp(self, self1))
| 4107 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)"); |  | 4107 | return failmsgp("Incorrect type of self (must be 'BackgroundSubtractorMOG2' or its derivative)");
| 4108 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1); |  | 4108 | Ptr<cv::BackgroundSubtractorMOG2> _self_ = *(self1);
| 4109 | PyObject* pyobj_varThresholdGen = NULL; |  | 4109 | PyObject* pyobj_varThresholdGen = NULL;
| 4110 | double varThresholdGen=0; |  | 4110 | double varThresholdGen=0;
| 4111 |  |  | 4111 |
| 4112 | const char* keywords[] = { "varThresholdGen", NULL }; |  | 4112 | const char* keywords[] = { "varThresholdGen", NULL };
| 4113 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarThresholdGen", (char**)keywords, &pyobj_varThresholdGen) && |  | 4113 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BackgroundSubtractorMOG2.setVarThresholdGen", (char**)keywords, &pyobj_varThresholdGen) &&
| 4114 | pyopencv_to_safe(pyobj_varThresholdGen, varThresholdGen, ArgInfo("varThresholdGen", 0)) ) |  | 4114 | pyopencv_to_safe(pyobj_varThresholdGen, varThresholdGen, ArgInfo("varThresholdGen", 0)) )
| 4115 | { |  | 4115 | {
| 4116 | ERRWRAP2(_self_->setVarThresholdGen(varThresholdGen)); |  | 4116 | ERRWRAP2(_self_->setVarThresholdGen(varThresholdGen));
| 4117 | Py_RETURN_NONE; |  | 4117 | Py_RETURN_NONE;
| 4118 | } |  | 4118 | }
| 4119 |  |  | 4119 |
| 4120 | return NULL; |  | 4120 | return NULL;
| 4121 | } |  | 4121 | }
| 4122 |  |  | 4122 |
| 4123 |  |  | 4123 |
| 4124 |  |  | 4124 |
| 4125 | // Tables (BackgroundSubtractorMOG2) |  | 4125 | // Tables (BackgroundSubtractorMOG2)
| 4126 |  |  | 4126 |
| 4127 | static PyGetSetDef pyopencv_BackgroundSubtractorMOG2_getseters[] = |  | 4127 | static PyGetSetDef pyopencv_BackgroundSubtractorMOG2_getseters[] =
| 4128 | { |  | 4128 | {
| 4129 | {NULL} /* Sentinel */ |  | 4129 | {NULL} /* Sentinel */
| 4130 | }; |  | 4130 | };
| 4131 |  |  | 4131 |
| 4132 | static PyMethodDef pyopencv_BackgroundSubtractorMOG2_methods[] = |  | 4132 | static PyMethodDef pyopencv_BackgroundSubtractorMOG2_methods[] =
| 4133 | { |  | 4133 | {
| 4134 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n. @brief Computes a foreground mask.\n. \n. @param image Next video frame. Floating point frame will be used without scaling and should be in range \\f$[0,255]\\f$.\n. @param fgmask The output foreground mask as an 8-bit binary image.\n. @param learningRate The value between 0 and 1 that indicates how fast the background model is\n. learnt. Negative parameter value makes the algorithm to use some automatically chosen learning\n. rate. 0 means that the background model is not updated at all, 1 means that the background model\n. is completely reinitialized from the last frame."}, |  | 4134 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n. @brief Computes a foreground mask.\n. \n. @param image Next video frame. Floating point frame will be used without scaling and should be in range \\f$[0,255]\\f$.\n. @param fgmask The output foreground mask as an 8-bit binary image.\n. @param learningRate The value between 0 and 1 that indicates how fast the background model is\n. learnt. Negative parameter value makes the algorithm to use some automatically chosen learning\n. rate. 0 means that the background model is not updated at all, 1 means that the background model\n. is completely reinitialized from the last frame."},
| 4135 | {"getBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getBackgroundRatio, 0), "getBackgroundRatio() -> retval\n. @brief Returns the \"background ratio\" parameter of the algorithm\n. \n. If a foreground pixel keeps semi-constant value for about backgroundRatio\\*history frames, it's\n. considered background and added to the model as a center of a new component. It corresponds to TB\n. parameter in the paper."}, |  | 4135 | {"getBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getBackgroundRatio, 0), "getBackgroundRatio() -> retval\n. @brief Returns the \"background ratio\" parameter of the algorithm\n. \n. If a foreground pixel keeps semi-constant value for about backgroundRatio\\*history frames, it's\n. considered background and added to the model as a center of a new component. It corresponds to TB\n. parameter in the paper."},
| 4136 | {"getComplexityReductionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getComplexityReductionThreshold, 0), "getComplexityReductionThreshold() -> retval\n. @brief Returns the complexity reduction threshold\n. \n. This parameter defines the number of samples needed to accept to prove the component exists. CT=0.05\n. is a default value for all the samples. By setting CT=0 you get an algorithm very similar to the\n. standard Stauffer&Grimson algorithm."}, |  | 4136 | {"getComplexityReductionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getComplexityReductionThreshold, 0), "getComplexityReductionThreshold() -> retval\n. @brief Returns the complexity reduction threshold\n. \n. This parameter defines the number of samples needed to accept to prove the component exists. CT=0.05\n. is a default value for all the samples. By setting CT=0 you get an algorithm very similar to the\n. standard Stauffer&Grimson algorithm."},
| 4137 | {"getDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getDetectShadows, 0), "getDetectShadows() -> retval\n. @brief Returns the shadow detection flag\n. \n. If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorMOG2 for\n. details."}, |  | 4137 | {"getDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getDetectShadows, 0), "getDetectShadows() -> retval\n. @brief Returns the shadow detection flag\n. \n. If true, the algorithm detects shadows and marks them. See createBackgroundSubtractorMOG2 for\n. details."},
| 4138 | {"getHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getHistory, 0), "getHistory() -> retval\n. @brief Returns the number of last frames that affect the background model"}, |  | 4138 | {"getHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getHistory, 0), "getHistory() -> retval\n. @brief Returns the number of last frames that affect the background model"},
| 4139 | {"getNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getNMixtures, 0), "getNMixtures() -> retval\n. @brief Returns the number of gaussian components in the background model"}, |  | 4139 | {"getNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getNMixtures, 0), "getNMixtures() -> retval\n. @brief Returns the number of gaussian components in the background model"},
| 4140 | {"getShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getShadowThreshold, 0), "getShadowThreshold() -> retval\n. @brief Returns the shadow threshold\n. \n. A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in\n. the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel\n. is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,\n. *Detecting Moving Shadows...*, IEEE PAMI,2003."}, |  | 4140 | {"getShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getShadowThreshold, 0), "getShadowThreshold() -> retval\n. @brief Returns the shadow threshold\n. \n. A shadow is detected if pixel is a darker version of the background. The shadow threshold (Tau in\n. the paper) is a threshold defining how much darker the shadow can be. Tau= 0.5 means that if a pixel\n. is more than twice darker then it is not shadow. See Prati, Mikic, Trivedi and Cucchiara,\n. *Detecting Moving Shadows...*, IEEE PAMI,2003."},
| 4141 | {"getShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getShadowValue, 0), "getShadowValue() -> retval\n. @brief Returns the shadow value\n. \n. Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0\n. in the mask always means background, 255 means foreground."}, |  | 4141 | {"getShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getShadowValue, 0), "getShadowValue() -> retval\n. @brief Returns the shadow value\n. \n. Shadow value is the value used to mark shadows in the foreground mask. Default value is 127. Value 0\n. in the mask always means background, 255 means foreground."},
| 4142 | {"getVarInit", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarInit, 0), "getVarInit() -> retval\n. @brief Returns the initial variance of each gaussian component"}, |  | 4142 | {"getVarInit", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarInit, 0), "getVarInit() -> retval\n. @brief Returns the initial variance of each gaussian component"},
| 4143 | {"getVarMax", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarMax, 0), "getVarMax() -> retval\n."}, |  | 4143 | {"getVarMax", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarMax, 0), "getVarMax() -> retval\n."},
| 4144 | {"getVarMin", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarMin, 0), "getVarMin() -> retval\n."}, |  | 4144 | {"getVarMin", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarMin, 0), "getVarMin() -> retval\n."},
| 4145 | {"getVarThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarThreshold, 0), "getVarThreshold() -> retval\n. @brief Returns the variance threshold for the pixel-model match\n. \n. The main threshold on the squared Mahalanobis distance to decide if the sample is well described by\n. the background model or not. Related to Cthr from the paper."}, |  | 4145 | {"getVarThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarThreshold, 0), "getVarThreshold() -> retval\n. @brief Returns the variance threshold for the pixel-model match\n. \n. The main threshold on the squared Mahalanobis distance to decide if the sample is well described by\n. the background model or not. Related to Cthr from the paper."},
| 4146 | {"getVarThresholdGen", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarThresholdGen, 0), "getVarThresholdGen() -> retval\n. @brief Returns the variance threshold for the pixel-model match used for new mixture component generation\n. \n. Threshold for the squared Mahalanobis distance that helps decide when a sample is close to the\n. existing components (corresponds to Tg in the paper). If a pixel is not close to any component, it\n. is considered foreground or added as a new component. 3 sigma =\\> Tg=3\\*3=9 is default. A smaller Tg\n. value generates more components. A higher Tg value may result in a small number of components but\n. they can grow too large."}, |  | 4146 | {"getVarThresholdGen", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_getVarThresholdGen, 0), "getVarThresholdGen() -> retval\n. @brief Returns the variance threshold for the pixel-model match used for new mixture component generation\n. \n. Threshold for the squared Mahalanobis distance that helps decide when a sample is close to the\n. existing components (corresponds to Tg in the paper). If a pixel is not close to any component, it\n. is considered foreground or added as a new component. 3 sigma =\\> Tg=3\\*3=9 is default. A smaller Tg\n. value generates more components. A higher Tg value may result in a small number of components but\n. they can grow too large."},
| 4147 | {"setBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setBackgroundRatio, 0), "setBackgroundRatio(ratio) -> None\n. @brief Sets the \"background ratio\" parameter of the algorithm"}, |  | 4147 | {"setBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setBackgroundRatio, 0), "setBackgroundRatio(ratio) -> None\n. @brief Sets the \"background ratio\" parameter of the algorithm"},
| 4148 | {"setComplexityReductionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold, 0), "setComplexityReductionThreshold(ct) -> None\n. @brief Sets the complexity reduction threshold"}, |  | 4148 | {"setComplexityReductionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setComplexityReductionThreshold, 0), "setComplexityReductionThreshold(ct) -> None\n. @brief Sets the complexity reduction threshold"},
| 4149 | {"setDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setDetectShadows, 0), "setDetectShadows(detectShadows) -> None\n. @brief Enables or disables shadow detection"}, |  | 4149 | {"setDetectShadows", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setDetectShadows, 0), "setDetectShadows(detectShadows) -> None\n. @brief Enables or disables shadow detection"},
| 4150 | {"setHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setHistory, 0), "setHistory(history) -> None\n. @brief Sets the number of last frames that affect the background model"}, |  | 4150 | {"setHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setHistory, 0), "setHistory(history) -> None\n. @brief Sets the number of last frames that affect the background model"},
| 4151 | {"setNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setNMixtures, 0), "setNMixtures(nmixtures) -> None\n. @brief Sets the number of gaussian components in the background model.\n. \n. The model needs to be reinitalized to reserve memory."}, |  | 4151 | {"setNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setNMixtures, 0), "setNMixtures(nmixtures) -> None\n. @brief Sets the number of gaussian components in the background model.\n. \n. The model needs to be reinitalized to reserve memory."},
| 4152 | {"setShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setShadowThreshold, 0), "setShadowThreshold(threshold) -> None\n. @brief Sets the shadow threshold"}, |  | 4152 | {"setShadowThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setShadowThreshold, 0), "setShadowThreshold(threshold) -> None\n. @brief Sets the shadow threshold"},
| 4153 | {"setShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setShadowValue, 0), "setShadowValue(value) -> None\n. @brief Sets the shadow value"}, |  | 4153 | {"setShadowValue", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setShadowValue, 0), "setShadowValue(value) -> None\n. @brief Sets the shadow value"},
| 4154 | {"setVarInit", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarInit, 0), "setVarInit(varInit) -> None\n. @brief Sets the initial variance of each gaussian component"}, |  | 4154 | {"setVarInit", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarInit, 0), "setVarInit(varInit) -> None\n. @brief Sets the initial variance of each gaussian component"},
| 4155 | {"setVarMax", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarMax, 0), "setVarMax(varMax) -> None\n."}, |  | 4155 | {"setVarMax", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarMax, 0), "setVarMax(varMax) -> None\n."},
| 4156 | {"setVarMin", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarMin, 0), "setVarMin(varMin) -> None\n."}, |  | 4156 | {"setVarMin", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarMin, 0), "setVarMin(varMin) -> None\n."},
| 4157 | {"setVarThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarThreshold, 0), "setVarThreshold(varThreshold) -> None\n. @brief Sets the variance threshold for the pixel-model match"}, |  | 4157 | {"setVarThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarThreshold, 0), "setVarThreshold(varThreshold) -> None\n. @brief Sets the variance threshold for the pixel-model match"},
| 4158 | {"setVarThresholdGen", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarThresholdGen, 0), "setVarThresholdGen(varThresholdGen) -> None\n. @brief Sets the variance threshold for the pixel-model match used for new mixture component generation"}, |  | 4158 | {"setVarThresholdGen", CV_PY_FN_WITH_KW_(pyopencv_cv_BackgroundSubtractorMOG2_setVarThresholdGen, 0), "setVarThresholdGen(varThresholdGen) -> None\n. @brief Sets the variance threshold for the pixel-model match used for new mixture component generation"},
| 4159 |  |  | 4159 |
| 4160 | {NULL, NULL} |  | 4160 | {NULL, NULL}
| 4161 | }; |  | 4161 | };
| 4162 |  |  | 4162 |
| 4163 | // Converter (BackgroundSubtractorMOG2) |  | 4163 | // Converter (BackgroundSubtractorMOG2)
| 4164 |  |  | 4164 |
| 4165 | template<> |  | 4165 | template<>
| 4166 | struct PyOpenCV_Converter< Ptr<cv::BackgroundSubtractorMOG2> > |  | 4166 | struct PyOpenCV_Converter< Ptr<cv::BackgroundSubtractorMOG2> >
| 4167 | { |  | 4167 | {
| 4168 | static PyObject* from(const Ptr<cv::BackgroundSubtractorMOG2>& r) |  | 4168 | static PyObject* from(const Ptr<cv::BackgroundSubtractorMOG2>& r)
| 4169 | { |  | 4169 | {
| 4170 | return pyopencv_BackgroundSubtractorMOG2_Instance(r); |  | 4170 | return pyopencv_BackgroundSubtractorMOG2_Instance(r);
| 4171 | } |  | 4171 | }
| 4172 | static bool to(PyObject* src, Ptr<cv::BackgroundSubtractorMOG2>& dst, const ArgInfo& info) |  | 4172 | static bool to(PyObject* src, Ptr<cv::BackgroundSubtractorMOG2>& dst, const ArgInfo& info)
| 4173 | { |  | 4173 | {
| 4174 | if(!src || src == Py_None) |  | 4174 | if(!src || src == Py_None)
| 4175 | return true; |  | 4175 | return true;
| 4176 | Ptr<cv::BackgroundSubtractorMOG2> * dst_; |  | 4176 | Ptr<cv::BackgroundSubtractorMOG2> * dst_;
| 4177 | if (pyopencv_BackgroundSubtractorMOG2_getp(src, dst_)) |  | 4177 | if (pyopencv_BackgroundSubtractorMOG2_getp(src, dst_))
| 4178 | { |  | 4178 | {
| 4179 | dst = *dst_; |  | 4179 | dst = *dst_;
| 4180 | return true; |  | 4180 | return true;
| 4181 | } |  | 4181 | }
| 4182 |  |  | 4182 |
| 4183 | failmsg("Expected Ptr<cv::BackgroundSubtractorMOG2> for argument '%s'", info.name); |  | 4183 | failmsg("Expected Ptr<cv::BackgroundSubtractorMOG2> for argument '%s'", info.name);
| 4184 | return false; |  | 4184 | return false;
| 4185 | } |  | 4185 | }
| 4186 | }; |  | 4186 | };
| 4187 |  |  | 4187 |
| 4188 | //================================================================================ |  | 4188 | //================================================================================
| 4189 | // BaseCascadeClassifier (Generic) |  | 4189 | // BaseCascadeClassifier (Generic)
| 4190 | //================================================================================ |  | 4190 | //================================================================================
| 4191 |  |  | 4191 |
| 4192 | // GetSet (BaseCascadeClassifier) |  | 4192 | // GetSet (BaseCascadeClassifier)
| 4193 |  |  | 4193 |
| 4194 |  |  | 4194 |
| 4195 |  |  | 4195 |
| 4196 | // Methods (BaseCascadeClassifier) |  | 4196 | // Methods (BaseCascadeClassifier)
| 4197 |  |  | 4197 |
| 4198 |  |  | 4198 |
| 4199 |  |  | 4199 |
| 4200 | // Tables (BaseCascadeClassifier) |  | 4200 | // Tables (BaseCascadeClassifier)
| 4201 |  |  | 4201 |
| 4202 | static PyGetSetDef pyopencv_BaseCascadeClassifier_getseters[] = |  | 4202 | static PyGetSetDef pyopencv_BaseCascadeClassifier_getseters[] =
| 4203 | { |  | 4203 | {
| 4204 | {NULL} /* Sentinel */ |  | 4204 | {NULL} /* Sentinel */
| 4205 | }; |  | 4205 | };
| 4206 |  |  | 4206 |
| 4207 | static PyMethodDef pyopencv_BaseCascadeClassifier_methods[] = |  | 4207 | static PyMethodDef pyopencv_BaseCascadeClassifier_methods[] =
| 4208 | { |  | 4208 | {
| 4209 |  |  | 4209 |
| 4210 | {NULL, NULL} |  | 4210 | {NULL, NULL}
| 4211 | }; |  | 4211 | };
| 4212 |  |  | 4212 |
| 4213 | // Converter (BaseCascadeClassifier) |  | 4213 | // Converter (BaseCascadeClassifier)
| 4214 |  |  | 4214 |
| 4215 | template<> |  | 4215 | template<>
| 4216 | struct PyOpenCV_Converter< Ptr<cv::BaseCascadeClassifier> > |  | 4216 | struct PyOpenCV_Converter< Ptr<cv::BaseCascadeClassifier> >
| 4217 | { |  | 4217 | {
| 4218 | static PyObject* from(const Ptr<cv::BaseCascadeClassifier>& r) |  | 4218 | static PyObject* from(const Ptr<cv::BaseCascadeClassifier>& r)
| 4219 | { |  | 4219 | {
| 4220 | return pyopencv_BaseCascadeClassifier_Instance(r); |  | 4220 | return pyopencv_BaseCascadeClassifier_Instance(r);
| 4221 | } |  | 4221 | }
| 4222 | static bool to(PyObject* src, Ptr<cv::BaseCascadeClassifier>& dst, const ArgInfo& info) |  | 4222 | static bool to(PyObject* src, Ptr<cv::BaseCascadeClassifier>& dst, const ArgInfo& info)
| 4223 | { |  | 4223 | {
| 4224 | if(!src || src == Py_None) |  | 4224 | if(!src || src == Py_None)
| 4225 | return true; |  | 4225 | return true;
| 4226 | Ptr<cv::BaseCascadeClassifier> * dst_; |  | 4226 | Ptr<cv::BaseCascadeClassifier> * dst_;
| 4227 | if (pyopencv_BaseCascadeClassifier_getp(src, dst_)) |  | 4227 | if (pyopencv_BaseCascadeClassifier_getp(src, dst_))
| 4228 | { |  | 4228 | {
| 4229 | dst = *dst_; |  | 4229 | dst = *dst_;
| 4230 | return true; |  | 4230 | return true;
| 4231 | } |  | 4231 | }
| 4232 |  |  | 4232 |
| 4233 | failmsg("Expected Ptr<cv::BaseCascadeClassifier> for argument '%s'", info.name); |  | 4233 | failmsg("Expected Ptr<cv::BaseCascadeClassifier> for argument '%s'", info.name);
| 4234 | return false; |  | 4234 | return false;
| 4235 | } |  | 4235 | }
| 4236 | }; |  | 4236 | };
| 4237 |  |  | 4237 |
| 4238 | //================================================================================ |  | 4238 | //================================================================================
| 4239 | // CLAHE (Generic) |  | 4239 | // CLAHE (Generic)
| 4240 | //================================================================================ |  | 4240 | //================================================================================
| 4241 |  |  | 4241 |
| 4242 | // GetSet (CLAHE) |  | 4242 | // GetSet (CLAHE)
| 4243 |  |  | 4243 |
| 4244 |  |  | 4244 |
| 4245 |  |  | 4245 |
| 4246 | // Methods (CLAHE) |  | 4246 | // Methods (CLAHE)
| 4247 |  |  | 4247 |
| 4248 | static PyObject* pyopencv_cv_CLAHE_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4248 | static PyObject* pyopencv_cv_CLAHE_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 4249 | { |  | 4249 | {
| 4250 | using namespace cv; |  | 4250 | using namespace cv;
| 4251 |  |  | 4251 |
| 4252 |  |  | 4252 |
| 4253 | Ptr<cv::CLAHE> * self1 = 0; |  | 4253 | Ptr<cv::CLAHE> * self1 = 0;
| 4254 | if (!pyopencv_CLAHE_getp(self, self1)) |  | 4254 | if (!pyopencv_CLAHE_getp(self, self1))
| 4255 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)"); |  | 4255 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)");
| 4256 | Ptr<cv::CLAHE> _self_ = *(self1); |  | 4256 | Ptr<cv::CLAHE> _self_ = *(self1);
| 4257 | pyPrepareArgumentConversionErrorsStorage(2); |  | 4257 | pyPrepareArgumentConversionErrorsStorage(2);
| 4258 |  |  | 4258 |
| 4259 | { |  | 4259 | {
| 4260 | PyObject* pyobj_src = NULL; |  | 4260 | PyObject* pyobj_src = NULL;
| 4261 | Mat src; |  | 4261 | Mat src;
| 4262 | PyObject* pyobj_dst = NULL; |  | 4262 | PyObject* pyobj_dst = NULL;
| 4263 | Mat dst; |  | 4263 | Mat dst;
| 4264 |  |  | 4264 |
| 4265 | const char* keywords[] = { "src", "dst", NULL }; |  | 4265 | const char* keywords[] = { "src", "dst", NULL };
| 4266 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:CLAHE.apply", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 4266 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:CLAHE.apply", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 4267 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 4267 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 4268 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 4268 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 4269 | { |  | 4269 | {
| 4270 | ERRWRAP2(_self_->apply(src, dst)); |  | 4270 | ERRWRAP2(_self_->apply(src, dst));
| 4271 | return pyopencv_from(dst); |  | 4271 | return pyopencv_from(dst);
| 4272 | } |  | 4272 | }
| 4273 |  |  | 4273 |
| 4274 |  |  | 4274 |
| 4275 | pyPopulateArgumentConversionErrors(); |  | 4275 | pyPopulateArgumentConversionErrors();
| 4276 | } |  | 4276 | }
| 4277 |  |  | 4277 |
| 4278 |  |  | 4278 |
| 4279 | { |  | 4279 | {
| 4280 | PyObject* pyobj_src = NULL; |  | 4280 | PyObject* pyobj_src = NULL;
| 4281 | UMat src; |  | 4281 | UMat src;
| 4282 | PyObject* pyobj_dst = NULL; |  | 4282 | PyObject* pyobj_dst = NULL;
| 4283 | UMat dst; |  | 4283 | UMat dst;
| 4284 |  |  | 4284 |
| 4285 | const char* keywords[] = { "src", "dst", NULL }; |  | 4285 | const char* keywords[] = { "src", "dst", NULL };
| 4286 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:CLAHE.apply", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 4286 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:CLAHE.apply", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 4287 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 4287 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 4288 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 4288 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 4289 | { |  | 4289 | {
| 4290 | ERRWRAP2(_self_->apply(src, dst)); |  | 4290 | ERRWRAP2(_self_->apply(src, dst));
| 4291 | return pyopencv_from(dst); |  | 4291 | return pyopencv_from(dst);
| 4292 | } |  | 4292 | }
| 4293 |  |  | 4293 |
| 4294 |  |  | 4294 |
| 4295 | pyPopulateArgumentConversionErrors(); |  | 4295 | pyPopulateArgumentConversionErrors();
| 4296 | } |  | 4296 | }
| 4297 | pyRaiseCVOverloadException("apply"); |  | 4297 | pyRaiseCVOverloadException("apply");
| 4298 |  |  | 4298 |
| 4299 | return NULL; |  | 4299 | return NULL;
| 4300 | } |  | 4300 | }
| 4301 |  |  | 4301 |
| 4302 | static PyObject* pyopencv_cv_CLAHE_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4302 | static PyObject* pyopencv_cv_CLAHE_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw)
| 4303 | { |  | 4303 | {
| 4304 | using namespace cv; |  | 4304 | using namespace cv;
| 4305 |  |  | 4305 |
| 4306 |  |  | 4306 |
| 4307 | Ptr<cv::CLAHE> * self1 = 0; |  | 4307 | Ptr<cv::CLAHE> * self1 = 0;
| 4308 | if (!pyopencv_CLAHE_getp(self, self1)) |  | 4308 | if (!pyopencv_CLAHE_getp(self, self1))
| 4309 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)"); |  | 4309 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)");
| 4310 | Ptr<cv::CLAHE> _self_ = *(self1); |  | 4310 | Ptr<cv::CLAHE> _self_ = *(self1);
| 4311 |  |  | 4311 |
| 4312 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4312 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4313 | { |  | 4313 | {
| 4314 | ERRWRAP2(_self_->collectGarbage()); |  | 4314 | ERRWRAP2(_self_->collectGarbage());
| 4315 | Py_RETURN_NONE; |  | 4315 | Py_RETURN_NONE;
| 4316 | } |  | 4316 | }
| 4317 |  |  | 4317 |
| 4318 | return NULL; |  | 4318 | return NULL;
| 4319 | } |  | 4319 | }
| 4320 |  |  | 4320 |
| 4321 | static PyObject* pyopencv_cv_CLAHE_getClipLimit(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4321 | static PyObject* pyopencv_cv_CLAHE_getClipLimit(PyObject* self, PyObject* py_args, PyObject* kw)
| 4322 | { |  | 4322 | {
| 4323 | using namespace cv; |  | 4323 | using namespace cv;
| 4324 |  |  | 4324 |
| 4325 |  |  | 4325 |
| 4326 | Ptr<cv::CLAHE> * self1 = 0; |  | 4326 | Ptr<cv::CLAHE> * self1 = 0;
| 4327 | if (!pyopencv_CLAHE_getp(self, self1)) |  | 4327 | if (!pyopencv_CLAHE_getp(self, self1))
| 4328 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)"); |  | 4328 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)");
| 4329 | Ptr<cv::CLAHE> _self_ = *(self1); |  | 4329 | Ptr<cv::CLAHE> _self_ = *(self1);
| 4330 | double retval; |  | 4330 | double retval;
| 4331 |  |  | 4331 |
| 4332 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4332 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4333 | { |  | 4333 | {
| 4334 | ERRWRAP2(retval = _self_->getClipLimit()); |  | 4334 | ERRWRAP2(retval = _self_->getClipLimit());
| 4335 | return pyopencv_from(retval); |  | 4335 | return pyopencv_from(retval);
| 4336 | } |  | 4336 | }
| 4337 |  |  | 4337 |
| 4338 | return NULL; |  | 4338 | return NULL;
| 4339 | } |  | 4339 | }
| 4340 |  |  | 4340 |
| 4341 | static PyObject* pyopencv_cv_CLAHE_getTilesGridSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4341 | static PyObject* pyopencv_cv_CLAHE_getTilesGridSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 4342 | { |  | 4342 | {
| 4343 | using namespace cv; |  | 4343 | using namespace cv;
| 4344 |  |  | 4344 |
| 4345 |  |  | 4345 |
| 4346 | Ptr<cv::CLAHE> * self1 = 0; |  | 4346 | Ptr<cv::CLAHE> * self1 = 0;
| 4347 | if (!pyopencv_CLAHE_getp(self, self1)) |  | 4347 | if (!pyopencv_CLAHE_getp(self, self1))
| 4348 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)"); |  | 4348 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)");
| 4349 | Ptr<cv::CLAHE> _self_ = *(self1); |  | 4349 | Ptr<cv::CLAHE> _self_ = *(self1);
| 4350 | Size retval; |  | 4350 | Size retval;
| 4351 |  |  | 4351 |
| 4352 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4352 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4353 | { |  | 4353 | {
| 4354 | ERRWRAP2(retval = _self_->getTilesGridSize()); |  | 4354 | ERRWRAP2(retval = _self_->getTilesGridSize());
| 4355 | return pyopencv_from(retval); |  | 4355 | return pyopencv_from(retval);
| 4356 | } |  | 4356 | }
| 4357 |  |  | 4357 |
| 4358 | return NULL; |  | 4358 | return NULL;
| 4359 | } |  | 4359 | }
| 4360 |  |  | 4360 |
| 4361 | static PyObject* pyopencv_cv_CLAHE_setClipLimit(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4361 | static PyObject* pyopencv_cv_CLAHE_setClipLimit(PyObject* self, PyObject* py_args, PyObject* kw)
| 4362 | { |  | 4362 | {
| 4363 | using namespace cv; |  | 4363 | using namespace cv;
| 4364 |  |  | 4364 |
| 4365 |  |  | 4365 |
| 4366 | Ptr<cv::CLAHE> * self1 = 0; |  | 4366 | Ptr<cv::CLAHE> * self1 = 0;
| 4367 | if (!pyopencv_CLAHE_getp(self, self1)) |  | 4367 | if (!pyopencv_CLAHE_getp(self, self1))
| 4368 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)"); |  | 4368 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)");
| 4369 | Ptr<cv::CLAHE> _self_ = *(self1); |  | 4369 | Ptr<cv::CLAHE> _self_ = *(self1);
| 4370 | PyObject* pyobj_clipLimit = NULL; |  | 4370 | PyObject* pyobj_clipLimit = NULL;
| 4371 | double clipLimit=0; |  | 4371 | double clipLimit=0;
| 4372 |  |  | 4372 |
| 4373 | const char* keywords[] = { "clipLimit", NULL }; |  | 4373 | const char* keywords[] = { "clipLimit", NULL };
| 4374 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CLAHE.setClipLimit", (char**)keywords, &pyobj_clipLimit) && |  | 4374 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CLAHE.setClipLimit", (char**)keywords, &pyobj_clipLimit) &&
| 4375 | pyopencv_to_safe(pyobj_clipLimit, clipLimit, ArgInfo("clipLimit", 0)) ) |  | 4375 | pyopencv_to_safe(pyobj_clipLimit, clipLimit, ArgInfo("clipLimit", 0)) )
| 4376 | { |  | 4376 | {
| 4377 | ERRWRAP2(_self_->setClipLimit(clipLimit)); |  | 4377 | ERRWRAP2(_self_->setClipLimit(clipLimit));
| 4378 | Py_RETURN_NONE; |  | 4378 | Py_RETURN_NONE;
| 4379 | } |  | 4379 | }
| 4380 |  |  | 4380 |
| 4381 | return NULL; |  | 4381 | return NULL;
| 4382 | } |  | 4382 | }
| 4383 |  |  | 4383 |
| 4384 | static PyObject* pyopencv_cv_CLAHE_setTilesGridSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4384 | static PyObject* pyopencv_cv_CLAHE_setTilesGridSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 4385 | { |  | 4385 | {
| 4386 | using namespace cv; |  | 4386 | using namespace cv;
| 4387 |  |  | 4387 |
| 4388 |  |  | 4388 |
| 4389 | Ptr<cv::CLAHE> * self1 = 0; |  | 4389 | Ptr<cv::CLAHE> * self1 = 0;
| 4390 | if (!pyopencv_CLAHE_getp(self, self1)) |  | 4390 | if (!pyopencv_CLAHE_getp(self, self1))
| 4391 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)"); |  | 4391 | return failmsgp("Incorrect type of self (must be 'CLAHE' or its derivative)");
| 4392 | Ptr<cv::CLAHE> _self_ = *(self1); |  | 4392 | Ptr<cv::CLAHE> _self_ = *(self1);
| 4393 | PyObject* pyobj_tileGridSize = NULL; |  | 4393 | PyObject* pyobj_tileGridSize = NULL;
| 4394 | Size tileGridSize; |  | 4394 | Size tileGridSize;
| 4395 |  |  | 4395 |
| 4396 | const char* keywords[] = { "tileGridSize", NULL }; |  | 4396 | const char* keywords[] = { "tileGridSize", NULL };
| 4397 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CLAHE.setTilesGridSize", (char**)keywords, &pyobj_tileGridSize) && |  | 4397 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CLAHE.setTilesGridSize", (char**)keywords, &pyobj_tileGridSize) &&
| 4398 | pyopencv_to_safe(pyobj_tileGridSize, tileGridSize, ArgInfo("tileGridSize", 0)) ) |  | 4398 | pyopencv_to_safe(pyobj_tileGridSize, tileGridSize, ArgInfo("tileGridSize", 0)) )
| 4399 | { |  | 4399 | {
| 4400 | ERRWRAP2(_self_->setTilesGridSize(tileGridSize)); |  | 4400 | ERRWRAP2(_self_->setTilesGridSize(tileGridSize));
| 4401 | Py_RETURN_NONE; |  | 4401 | Py_RETURN_NONE;
| 4402 | } |  | 4402 | }
| 4403 |  |  | 4403 |
| 4404 | return NULL; |  | 4404 | return NULL;
| 4405 | } |  | 4405 | }
| 4406 |  |  | 4406 |
| 4407 |  |  | 4407 |
| 4408 |  |  | 4408 |
| 4409 | // Tables (CLAHE) |  | 4409 | // Tables (CLAHE)
| 4410 |  |  | 4410 |
| 4411 | static PyGetSetDef pyopencv_CLAHE_getseters[] = |  | 4411 | static PyGetSetDef pyopencv_CLAHE_getseters[] =
| 4412 | { |  | 4412 | {
| 4413 | {NULL} /* Sentinel */ |  | 4413 | {NULL} /* Sentinel */
| 4414 | }; |  | 4414 | };
| 4415 |  |  | 4415 |
| 4416 | static PyMethodDef pyopencv_CLAHE_methods[] = |  | 4416 | static PyMethodDef pyopencv_CLAHE_methods[] =
| 4417 | { |  | 4417 | {
| 4418 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_apply, 0), "apply(src[, dst]) -> dst\n. @brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.\n. \n. @param src Source image of type CV_8UC1 or CV_16UC1.\n. @param dst Destination image."}, |  | 4418 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_apply, 0), "apply(src[, dst]) -> dst\n. @brief Equalizes the histogram of a grayscale image using Contrast Limited Adaptive Histogram Equalization.\n. \n. @param src Source image of type CV_8UC1 or CV_16UC1.\n. @param dst Destination image."},
| 4419 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_collectGarbage, 0), "collectGarbage() -> None\n."}, |  | 4419 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_collectGarbage, 0), "collectGarbage() -> None\n."},
| 4420 | {"getClipLimit", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_getClipLimit, 0), "getClipLimit() -> retval\n."}, |  | 4420 | {"getClipLimit", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_getClipLimit, 0), "getClipLimit() -> retval\n."},
| 4421 | {"getTilesGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_getTilesGridSize, 0), "getTilesGridSize() -> retval\n."}, |  | 4421 | {"getTilesGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_getTilesGridSize, 0), "getTilesGridSize() -> retval\n."},
| 4422 | {"setClipLimit", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_setClipLimit, 0), "setClipLimit(clipLimit) -> None\n. @brief Sets threshold for contrast limiting.\n. \n. @param clipLimit threshold value."}, |  | 4422 | {"setClipLimit", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_setClipLimit, 0), "setClipLimit(clipLimit) -> None\n. @brief Sets threshold for contrast limiting.\n. \n. @param clipLimit threshold value."},
| 4423 | {"setTilesGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_setTilesGridSize, 0), "setTilesGridSize(tileGridSize) -> None\n. @brief Sets size of grid for histogram equalization. Input image will be divided into\n. equally sized rectangular tiles.\n. \n. @param tileGridSize defines the number of tiles in row and column."}, |  | 4423 | {"setTilesGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_CLAHE_setTilesGridSize, 0), "setTilesGridSize(tileGridSize) -> None\n. @brief Sets size of grid for histogram equalization. Input image will be divided into\n. equally sized rectangular tiles.\n. \n. @param tileGridSize defines the number of tiles in row and column."},
| 4424 |  |  | 4424 |
| 4425 | {NULL, NULL} |  | 4425 | {NULL, NULL}
| 4426 | }; |  | 4426 | };
| 4427 |  |  | 4427 |
| 4428 | // Converter (CLAHE) |  | 4428 | // Converter (CLAHE)
| 4429 |  |  | 4429 |
| 4430 | template<> |  | 4430 | template<>
| 4431 | struct PyOpenCV_Converter< Ptr<cv::CLAHE> > |  | 4431 | struct PyOpenCV_Converter< Ptr<cv::CLAHE> >
| 4432 | { |  | 4432 | {
| 4433 | static PyObject* from(const Ptr<cv::CLAHE>& r) |  | 4433 | static PyObject* from(const Ptr<cv::CLAHE>& r)
| 4434 | { |  | 4434 | {
| 4435 | return pyopencv_CLAHE_Instance(r); |  | 4435 | return pyopencv_CLAHE_Instance(r);
| 4436 | } |  | 4436 | }
| 4437 | static bool to(PyObject* src, Ptr<cv::CLAHE>& dst, const ArgInfo& info) |  | 4437 | static bool to(PyObject* src, Ptr<cv::CLAHE>& dst, const ArgInfo& info)
| 4438 | { |  | 4438 | {
| 4439 | if(!src || src == Py_None) |  | 4439 | if(!src || src == Py_None)
| 4440 | return true; |  | 4440 | return true;
| 4441 | Ptr<cv::CLAHE> * dst_; |  | 4441 | Ptr<cv::CLAHE> * dst_;
| 4442 | if (pyopencv_CLAHE_getp(src, dst_)) |  | 4442 | if (pyopencv_CLAHE_getp(src, dst_))
| 4443 | { |  | 4443 | {
| 4444 | dst = *dst_; |  | 4444 | dst = *dst_;
| 4445 | return true; |  | 4445 | return true;
| 4446 | } |  | 4446 | }
| 4447 |  |  | 4447 |
| 4448 | failmsg("Expected Ptr<cv::CLAHE> for argument '%s'", info.name); |  | 4448 | failmsg("Expected Ptr<cv::CLAHE> for argument '%s'", info.name);
| 4449 | return false; |  | 4449 | return false;
| 4450 | } |  | 4450 | }
| 4451 | }; |  | 4451 | };
| 4452 |  |  | 4452 |
| 4453 | //================================================================================ |  | 4453 | //================================================================================
| 4454 | // CalibrateCRF (Generic) |  | 4454 | // CalibrateCRF (Generic)
| 4455 | //================================================================================ |  | 4455 | //================================================================================
| 4456 |  |  | 4456 |
| 4457 | // GetSet (CalibrateCRF) |  | 4457 | // GetSet (CalibrateCRF)
| 4458 |  |  | 4458 |
| 4459 |  |  | 4459 |
| 4460 |  |  | 4460 |
| 4461 | // Methods (CalibrateCRF) |  | 4461 | // Methods (CalibrateCRF)
| 4462 |  |  | 4462 |
| 4463 | static PyObject* pyopencv_cv_CalibrateCRF_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4463 | static PyObject* pyopencv_cv_CalibrateCRF_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 4464 | { |  | 4464 | {
| 4465 | using namespace cv; |  | 4465 | using namespace cv;
| 4466 |  |  | 4466 |
| 4467 |  |  | 4467 |
| 4468 | Ptr<cv::CalibrateCRF> * self1 = 0; |  | 4468 | Ptr<cv::CalibrateCRF> * self1 = 0;
| 4469 | if (!pyopencv_CalibrateCRF_getp(self, self1)) |  | 4469 | if (!pyopencv_CalibrateCRF_getp(self, self1))
| 4470 | return failmsgp("Incorrect type of self (must be 'CalibrateCRF' or its derivative)"); |  | 4470 | return failmsgp("Incorrect type of self (must be 'CalibrateCRF' or its derivative)");
| 4471 | Ptr<cv::CalibrateCRF> _self_ = *(self1); |  | 4471 | Ptr<cv::CalibrateCRF> _self_ = *(self1);
| 4472 | pyPrepareArgumentConversionErrorsStorage(2); |  | 4472 | pyPrepareArgumentConversionErrorsStorage(2);
| 4473 |  |  | 4473 |
| 4474 | { |  | 4474 | {
| 4475 | PyObject* pyobj_src = NULL; |  | 4475 | PyObject* pyobj_src = NULL;
| 4476 | vector_Mat src; |  | 4476 | vector_Mat src;
| 4477 | PyObject* pyobj_dst = NULL; |  | 4477 | PyObject* pyobj_dst = NULL;
| 4478 | Mat dst; |  | 4478 | Mat dst;
| 4479 | PyObject* pyobj_times = NULL; |  | 4479 | PyObject* pyobj_times = NULL;
| 4480 | Mat times; |  | 4480 | Mat times;
| 4481 |  |  | 4481 |
| 4482 | const char* keywords[] = { "src", "times", "dst", NULL }; |  | 4482 | const char* keywords[] = { "src", "times", "dst", NULL };
| 4483 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:CalibrateCRF.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) && |  | 4483 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:CalibrateCRF.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) &&
| 4484 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 4484 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 4485 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 4485 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 4486 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) ) |  | 4486 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) )
| 4487 | { |  | 4487 | {
| 4488 | ERRWRAP2(_self_->process(src, dst, times)); |  | 4488 | ERRWRAP2(_self_->process(src, dst, times));
| 4489 | return pyopencv_from(dst); |  | 4489 | return pyopencv_from(dst);
| 4490 | } |  | 4490 | }
| 4491 |  |  | 4491 |
| 4492 |  |  | 4492 |
| 4493 | pyPopulateArgumentConversionErrors(); |  | 4493 | pyPopulateArgumentConversionErrors();
| 4494 | } |  | 4494 | }
| 4495 |  |  | 4495 |
| 4496 |  |  | 4496 |
| 4497 | { |  | 4497 | {
| 4498 | PyObject* pyobj_src = NULL; |  | 4498 | PyObject* pyobj_src = NULL;
| 4499 | vector_UMat src; |  | 4499 | vector_UMat src;
| 4500 | PyObject* pyobj_dst = NULL; |  | 4500 | PyObject* pyobj_dst = NULL;
| 4501 | UMat dst; |  | 4501 | UMat dst;
| 4502 | PyObject* pyobj_times = NULL; |  | 4502 | PyObject* pyobj_times = NULL;
| 4503 | UMat times; |  | 4503 | UMat times;
| 4504 |  |  | 4504 |
| 4505 | const char* keywords[] = { "src", "times", "dst", NULL }; |  | 4505 | const char* keywords[] = { "src", "times", "dst", NULL };
| 4506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:CalibrateCRF.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) && |  | 4506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:CalibrateCRF.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) &&
| 4507 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 4507 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 4508 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 4508 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 4509 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) ) |  | 4509 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) )
| 4510 | { |  | 4510 | {
| 4511 | ERRWRAP2(_self_->process(src, dst, times)); |  | 4511 | ERRWRAP2(_self_->process(src, dst, times));
| 4512 | return pyopencv_from(dst); |  | 4512 | return pyopencv_from(dst);
| 4513 | } |  | 4513 | }
| 4514 |  |  | 4514 |
| 4515 |  |  | 4515 |
| 4516 | pyPopulateArgumentConversionErrors(); |  | 4516 | pyPopulateArgumentConversionErrors();
| 4517 | } |  | 4517 | }
| 4518 | pyRaiseCVOverloadException("process"); |  | 4518 | pyRaiseCVOverloadException("process");
| 4519 |  |  | 4519 |
| 4520 | return NULL; |  | 4520 | return NULL;
| 4521 | } |  | 4521 | }
| 4522 |  |  | 4522 |
| 4523 |  |  | 4523 |
| 4524 |  |  | 4524 |
| 4525 | // Tables (CalibrateCRF) |  | 4525 | // Tables (CalibrateCRF)
| 4526 |  |  | 4526 |
| 4527 | static PyGetSetDef pyopencv_CalibrateCRF_getseters[] = |  | 4527 | static PyGetSetDef pyopencv_CalibrateCRF_getseters[] =
| 4528 | { |  | 4528 | {
| 4529 | {NULL} /* Sentinel */ |  | 4529 | {NULL} /* Sentinel */
| 4530 | }; |  | 4530 | };
| 4531 |  |  | 4531 |
| 4532 | static PyMethodDef pyopencv_CalibrateCRF_methods[] = |  | 4532 | static PyMethodDef pyopencv_CalibrateCRF_methods[] =
| 4533 | { |  | 4533 | {
| 4534 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateCRF_process, 0), "process(src, times[, dst]) -> dst\n. @brief Recovers inverse camera response.\n. \n. @param src vector of input images\n. @param dst 256x1 matrix with inverse camera response function\n. @param times vector of exposure time values for each image"}, |  | 4534 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateCRF_process, 0), "process(src, times[, dst]) -> dst\n. @brief Recovers inverse camera response.\n. \n. @param src vector of input images\n. @param dst 256x1 matrix with inverse camera response function\n. @param times vector of exposure time values for each image"},
| 4535 |  |  | 4535 |
| 4536 | {NULL, NULL} |  | 4536 | {NULL, NULL}
| 4537 | }; |  | 4537 | };
| 4538 |  |  | 4538 |
| 4539 | // Converter (CalibrateCRF) |  | 4539 | // Converter (CalibrateCRF)
| 4540 |  |  | 4540 |
| 4541 | template<> |  | 4541 | template<>
| 4542 | struct PyOpenCV_Converter< Ptr<cv::CalibrateCRF> > |  | 4542 | struct PyOpenCV_Converter< Ptr<cv::CalibrateCRF> >
| 4543 | { |  | 4543 | {
| 4544 | static PyObject* from(const Ptr<cv::CalibrateCRF>& r) |  | 4544 | static PyObject* from(const Ptr<cv::CalibrateCRF>& r)
| 4545 | { |  | 4545 | {
| 4546 | return pyopencv_CalibrateCRF_Instance(r); |  | 4546 | return pyopencv_CalibrateCRF_Instance(r);
| 4547 | } |  | 4547 | }
| 4548 | static bool to(PyObject* src, Ptr<cv::CalibrateCRF>& dst, const ArgInfo& info) |  | 4548 | static bool to(PyObject* src, Ptr<cv::CalibrateCRF>& dst, const ArgInfo& info)
| 4549 | { |  | 4549 | {
| 4550 | if(!src || src == Py_None) |  | 4550 | if(!src || src == Py_None)
| 4551 | return true; |  | 4551 | return true;
| 4552 | Ptr<cv::CalibrateCRF> * dst_; |  | 4552 | Ptr<cv::CalibrateCRF> * dst_;
| 4553 | if (pyopencv_CalibrateCRF_getp(src, dst_)) |  | 4553 | if (pyopencv_CalibrateCRF_getp(src, dst_))
| 4554 | { |  | 4554 | {
| 4555 | dst = *dst_; |  | 4555 | dst = *dst_;
| 4556 | return true; |  | 4556 | return true;
| 4557 | } |  | 4557 | }
| 4558 |  |  | 4558 |
| 4559 | failmsg("Expected Ptr<cv::CalibrateCRF> for argument '%s'", info.name); |  | 4559 | failmsg("Expected Ptr<cv::CalibrateCRF> for argument '%s'", info.name);
| 4560 | return false; |  | 4560 | return false;
| 4561 | } |  | 4561 | }
| 4562 | }; |  | 4562 | };
| 4563 |  |  | 4563 |
| 4564 | //================================================================================ |  | 4564 | //================================================================================
| 4565 | // CalibrateDebevec (Generic) |  | 4565 | // CalibrateDebevec (Generic)
| 4566 | //================================================================================ |  | 4566 | //================================================================================
| 4567 |  |  | 4567 |
| 4568 | // GetSet (CalibrateDebevec) |  | 4568 | // GetSet (CalibrateDebevec)
| 4569 |  |  | 4569 |
| 4570 |  |  | 4570 |
| 4571 |  |  | 4571 |
| 4572 | // Methods (CalibrateDebevec) |  | 4572 | // Methods (CalibrateDebevec)
| 4573 |  |  | 4573 |
| 4574 | static PyObject* pyopencv_cv_CalibrateDebevec_getLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4574 | static PyObject* pyopencv_cv_CalibrateDebevec_getLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 4575 | { |  | 4575 | {
| 4576 | using namespace cv; |  | 4576 | using namespace cv;
| 4577 |  |  | 4577 |
| 4578 |  |  | 4578 |
| 4579 | Ptr<cv::CalibrateDebevec> * self1 = 0; |  | 4579 | Ptr<cv::CalibrateDebevec> * self1 = 0;
| 4580 | if (!pyopencv_CalibrateDebevec_getp(self, self1)) |  | 4580 | if (!pyopencv_CalibrateDebevec_getp(self, self1))
| 4581 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)"); |  | 4581 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)");
| 4582 | Ptr<cv::CalibrateDebevec> _self_ = *(self1); |  | 4582 | Ptr<cv::CalibrateDebevec> _self_ = *(self1);
| 4583 | float retval; |  | 4583 | float retval;
| 4584 |  |  | 4584 |
| 4585 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4585 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4586 | { |  | 4586 | {
| 4587 | ERRWRAP2(retval = _self_->getLambda()); |  | 4587 | ERRWRAP2(retval = _self_->getLambda());
| 4588 | return pyopencv_from(retval); |  | 4588 | return pyopencv_from(retval);
| 4589 | } |  | 4589 | }
| 4590 |  |  | 4590 |
| 4591 | return NULL; |  | 4591 | return NULL;
| 4592 | } |  | 4592 | }
| 4593 |  |  | 4593 |
| 4594 | static PyObject* pyopencv_cv_CalibrateDebevec_getRandom(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4594 | static PyObject* pyopencv_cv_CalibrateDebevec_getRandom(PyObject* self, PyObject* py_args, PyObject* kw)
| 4595 | { |  | 4595 | {
| 4596 | using namespace cv; |  | 4596 | using namespace cv;
| 4597 |  |  | 4597 |
| 4598 |  |  | 4598 |
| 4599 | Ptr<cv::CalibrateDebevec> * self1 = 0; |  | 4599 | Ptr<cv::CalibrateDebevec> * self1 = 0;
| 4600 | if (!pyopencv_CalibrateDebevec_getp(self, self1)) |  | 4600 | if (!pyopencv_CalibrateDebevec_getp(self, self1))
| 4601 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)"); |  | 4601 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)");
| 4602 | Ptr<cv::CalibrateDebevec> _self_ = *(self1); |  | 4602 | Ptr<cv::CalibrateDebevec> _self_ = *(self1);
| 4603 | bool retval; |  | 4603 | bool retval;
| 4604 |  |  | 4604 |
| 4605 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4605 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4606 | { |  | 4606 | {
| 4607 | ERRWRAP2(retval = _self_->getRandom()); |  | 4607 | ERRWRAP2(retval = _self_->getRandom());
| 4608 | return pyopencv_from(retval); |  | 4608 | return pyopencv_from(retval);
| 4609 | } |  | 4609 | }
| 4610 |  |  | 4610 |
| 4611 | return NULL; |  | 4611 | return NULL;
| 4612 | } |  | 4612 | }
| 4613 |  |  | 4613 |
| 4614 | static PyObject* pyopencv_cv_CalibrateDebevec_getSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4614 | static PyObject* pyopencv_cv_CalibrateDebevec_getSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 4615 | { |  | 4615 | {
| 4616 | using namespace cv; |  | 4616 | using namespace cv;
| 4617 |  |  | 4617 |
| 4618 |  |  | 4618 |
| 4619 | Ptr<cv::CalibrateDebevec> * self1 = 0; |  | 4619 | Ptr<cv::CalibrateDebevec> * self1 = 0;
| 4620 | if (!pyopencv_CalibrateDebevec_getp(self, self1)) |  | 4620 | if (!pyopencv_CalibrateDebevec_getp(self, self1))
| 4621 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)"); |  | 4621 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)");
| 4622 | Ptr<cv::CalibrateDebevec> _self_ = *(self1); |  | 4622 | Ptr<cv::CalibrateDebevec> _self_ = *(self1);
| 4623 | int retval; |  | 4623 | int retval;
| 4624 |  |  | 4624 |
| 4625 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4625 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4626 | { |  | 4626 | {
| 4627 | ERRWRAP2(retval = _self_->getSamples()); |  | 4627 | ERRWRAP2(retval = _self_->getSamples());
| 4628 | return pyopencv_from(retval); |  | 4628 | return pyopencv_from(retval);
| 4629 | } |  | 4629 | }
| 4630 |  |  | 4630 |
| 4631 | return NULL; |  | 4631 | return NULL;
| 4632 | } |  | 4632 | }
| 4633 |  |  | 4633 |
| 4634 | static PyObject* pyopencv_cv_CalibrateDebevec_setLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4634 | static PyObject* pyopencv_cv_CalibrateDebevec_setLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 4635 | { |  | 4635 | {
| 4636 | using namespace cv; |  | 4636 | using namespace cv;
| 4637 |  |  | 4637 |
| 4638 |  |  | 4638 |
| 4639 | Ptr<cv::CalibrateDebevec> * self1 = 0; |  | 4639 | Ptr<cv::CalibrateDebevec> * self1 = 0;
| 4640 | if (!pyopencv_CalibrateDebevec_getp(self, self1)) |  | 4640 | if (!pyopencv_CalibrateDebevec_getp(self, self1))
| 4641 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)"); |  | 4641 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)");
| 4642 | Ptr<cv::CalibrateDebevec> _self_ = *(self1); |  | 4642 | Ptr<cv::CalibrateDebevec> _self_ = *(self1);
| 4643 | PyObject* pyobj_lambda = NULL; |  | 4643 | PyObject* pyobj_lambda = NULL;
| 4644 | float lambda=0.f; |  | 4644 | float lambda=0.f;
| 4645 |  |  | 4645 |
| 4646 | const char* keywords[] = { "lambda_", NULL }; |  | 4646 | const char* keywords[] = { "lambda_", NULL };
| 4647 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateDebevec.setLambda", (char**)keywords, &pyobj_lambda) && |  | 4647 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateDebevec.setLambda", (char**)keywords, &pyobj_lambda) &&
| 4648 | pyopencv_to_safe(pyobj_lambda, lambda, ArgInfo("lambda", 0)) ) |  | 4648 | pyopencv_to_safe(pyobj_lambda, lambda, ArgInfo("lambda", 0)) )
| 4649 | { |  | 4649 | {
| 4650 | ERRWRAP2(_self_->setLambda(lambda)); |  | 4650 | ERRWRAP2(_self_->setLambda(lambda));
| 4651 | Py_RETURN_NONE; |  | 4651 | Py_RETURN_NONE;
| 4652 | } |  | 4652 | }
| 4653 |  |  | 4653 |
| 4654 | return NULL; |  | 4654 | return NULL;
| 4655 | } |  | 4655 | }
| 4656 |  |  | 4656 |
| 4657 | static PyObject* pyopencv_cv_CalibrateDebevec_setRandom(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4657 | static PyObject* pyopencv_cv_CalibrateDebevec_setRandom(PyObject* self, PyObject* py_args, PyObject* kw)
| 4658 | { |  | 4658 | {
| 4659 | using namespace cv; |  | 4659 | using namespace cv;
| 4660 |  |  | 4660 |
| 4661 |  |  | 4661 |
| 4662 | Ptr<cv::CalibrateDebevec> * self1 = 0; |  | 4662 | Ptr<cv::CalibrateDebevec> * self1 = 0;
| 4663 | if (!pyopencv_CalibrateDebevec_getp(self, self1)) |  | 4663 | if (!pyopencv_CalibrateDebevec_getp(self, self1))
| 4664 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)"); |  | 4664 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)");
| 4665 | Ptr<cv::CalibrateDebevec> _self_ = *(self1); |  | 4665 | Ptr<cv::CalibrateDebevec> _self_ = *(self1);
| 4666 | PyObject* pyobj_random = NULL; |  | 4666 | PyObject* pyobj_random = NULL;
| 4667 | bool random=0; |  | 4667 | bool random=0;
| 4668 |  |  | 4668 |
| 4669 | const char* keywords[] = { "random", NULL }; |  | 4669 | const char* keywords[] = { "random", NULL };
| 4670 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateDebevec.setRandom", (char**)keywords, &pyobj_random) && |  | 4670 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateDebevec.setRandom", (char**)keywords, &pyobj_random) &&
| 4671 | pyopencv_to_safe(pyobj_random, random, ArgInfo("random", 0)) ) |  | 4671 | pyopencv_to_safe(pyobj_random, random, ArgInfo("random", 0)) )
| 4672 | { |  | 4672 | {
| 4673 | ERRWRAP2(_self_->setRandom(random)); |  | 4673 | ERRWRAP2(_self_->setRandom(random));
| 4674 | Py_RETURN_NONE; |  | 4674 | Py_RETURN_NONE;
| 4675 | } |  | 4675 | }
| 4676 |  |  | 4676 |
| 4677 | return NULL; |  | 4677 | return NULL;
| 4678 | } |  | 4678 | }
| 4679 |  |  | 4679 |
| 4680 | static PyObject* pyopencv_cv_CalibrateDebevec_setSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4680 | static PyObject* pyopencv_cv_CalibrateDebevec_setSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 4681 | { |  | 4681 | {
| 4682 | using namespace cv; |  | 4682 | using namespace cv;
| 4683 |  |  | 4683 |
| 4684 |  |  | 4684 |
| 4685 | Ptr<cv::CalibrateDebevec> * self1 = 0; |  | 4685 | Ptr<cv::CalibrateDebevec> * self1 = 0;
| 4686 | if (!pyopencv_CalibrateDebevec_getp(self, self1)) |  | 4686 | if (!pyopencv_CalibrateDebevec_getp(self, self1))
| 4687 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)"); |  | 4687 | return failmsgp("Incorrect type of self (must be 'CalibrateDebevec' or its derivative)");
| 4688 | Ptr<cv::CalibrateDebevec> _self_ = *(self1); |  | 4688 | Ptr<cv::CalibrateDebevec> _self_ = *(self1);
| 4689 | PyObject* pyobj_samples = NULL; |  | 4689 | PyObject* pyobj_samples = NULL;
| 4690 | int samples=0; |  | 4690 | int samples=0;
| 4691 |  |  | 4691 |
| 4692 | const char* keywords[] = { "samples", NULL }; |  | 4692 | const char* keywords[] = { "samples", NULL };
| 4693 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateDebevec.setSamples", (char**)keywords, &pyobj_samples) && |  | 4693 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateDebevec.setSamples", (char**)keywords, &pyobj_samples) &&
| 4694 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) ) |  | 4694 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) )
| 4695 | { |  | 4695 | {
| 4696 | ERRWRAP2(_self_->setSamples(samples)); |  | 4696 | ERRWRAP2(_self_->setSamples(samples));
| 4697 | Py_RETURN_NONE; |  | 4697 | Py_RETURN_NONE;
| 4698 | } |  | 4698 | }
| 4699 |  |  | 4699 |
| 4700 | return NULL; |  | 4700 | return NULL;
| 4701 | } |  | 4701 | }
| 4702 |  |  | 4702 |
| 4703 |  |  | 4703 |
| 4704 |  |  | 4704 |
| 4705 | // Tables (CalibrateDebevec) |  | 4705 | // Tables (CalibrateDebevec)
| 4706 |  |  | 4706 |
| 4707 | static PyGetSetDef pyopencv_CalibrateDebevec_getseters[] = |  | 4707 | static PyGetSetDef pyopencv_CalibrateDebevec_getseters[] =
| 4708 | { |  | 4708 | {
| 4709 | {NULL} /* Sentinel */ |  | 4709 | {NULL} /* Sentinel */
| 4710 | }; |  | 4710 | };
| 4711 |  |  | 4711 |
| 4712 | static PyMethodDef pyopencv_CalibrateDebevec_methods[] = |  | 4712 | static PyMethodDef pyopencv_CalibrateDebevec_methods[] =
| 4713 | { |  | 4713 | {
| 4714 | {"getLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_getLambda, 0), "getLambda() -> retval\n."}, |  | 4714 | {"getLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_getLambda, 0), "getLambda() -> retval\n."},
| 4715 | {"getRandom", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_getRandom, 0), "getRandom() -> retval\n."}, |  | 4715 | {"getRandom", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_getRandom, 0), "getRandom() -> retval\n."},
| 4716 | {"getSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_getSamples, 0), "getSamples() -> retval\n."}, |  | 4716 | {"getSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_getSamples, 0), "getSamples() -> retval\n."},
| 4717 | {"setLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_setLambda, 0), "setLambda(lambda_) -> None\n."}, |  | 4717 | {"setLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_setLambda, 0), "setLambda(lambda_) -> None\n."},
| 4718 | {"setRandom", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_setRandom, 0), "setRandom(random) -> None\n."}, |  | 4718 | {"setRandom", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_setRandom, 0), "setRandom(random) -> None\n."},
| 4719 | {"setSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_setSamples, 0), "setSamples(samples) -> None\n."}, |  | 4719 | {"setSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateDebevec_setSamples, 0), "setSamples(samples) -> None\n."},
| 4720 |  |  | 4720 |
| 4721 | {NULL, NULL} |  | 4721 | {NULL, NULL}
| 4722 | }; |  | 4722 | };
| 4723 |  |  | 4723 |
| 4724 | // Converter (CalibrateDebevec) |  | 4724 | // Converter (CalibrateDebevec)
| 4725 |  |  | 4725 |
| 4726 | template<> |  | 4726 | template<>
| 4727 | struct PyOpenCV_Converter< Ptr<cv::CalibrateDebevec> > |  | 4727 | struct PyOpenCV_Converter< Ptr<cv::CalibrateDebevec> >
| 4728 | { |  | 4728 | {
| 4729 | static PyObject* from(const Ptr<cv::CalibrateDebevec>& r) |  | 4729 | static PyObject* from(const Ptr<cv::CalibrateDebevec>& r)
| 4730 | { |  | 4730 | {
| 4731 | return pyopencv_CalibrateDebevec_Instance(r); |  | 4731 | return pyopencv_CalibrateDebevec_Instance(r);
| 4732 | } |  | 4732 | }
| 4733 | static bool to(PyObject* src, Ptr<cv::CalibrateDebevec>& dst, const ArgInfo& info) |  | 4733 | static bool to(PyObject* src, Ptr<cv::CalibrateDebevec>& dst, const ArgInfo& info)
| 4734 | { |  | 4734 | {
| 4735 | if(!src || src == Py_None) |  | 4735 | if(!src || src == Py_None)
| 4736 | return true; |  | 4736 | return true;
| 4737 | Ptr<cv::CalibrateDebevec> * dst_; |  | 4737 | Ptr<cv::CalibrateDebevec> * dst_;
| 4738 | if (pyopencv_CalibrateDebevec_getp(src, dst_)) |  | 4738 | if (pyopencv_CalibrateDebevec_getp(src, dst_))
| 4739 | { |  | 4739 | {
| 4740 | dst = *dst_; |  | 4740 | dst = *dst_;
| 4741 | return true; |  | 4741 | return true;
| 4742 | } |  | 4742 | }
| 4743 |  |  | 4743 |
| 4744 | failmsg("Expected Ptr<cv::CalibrateDebevec> for argument '%s'", info.name); |  | 4744 | failmsg("Expected Ptr<cv::CalibrateDebevec> for argument '%s'", info.name);
| 4745 | return false; |  | 4745 | return false;
| 4746 | } |  | 4746 | }
| 4747 | }; |  | 4747 | };
| 4748 |  |  | 4748 |
| 4749 | //================================================================================ |  | 4749 | //================================================================================
| 4750 | // CalibrateRobertson (Generic) |  | 4750 | // CalibrateRobertson (Generic)
| 4751 | //================================================================================ |  | 4751 | //================================================================================
| 4752 |  |  | 4752 |
| 4753 | // GetSet (CalibrateRobertson) |  | 4753 | // GetSet (CalibrateRobertson)
| 4754 |  |  | 4754 |
| 4755 |  |  | 4755 |
| 4756 |  |  | 4756 |
| 4757 | // Methods (CalibrateRobertson) |  | 4757 | // Methods (CalibrateRobertson)
| 4758 |  |  | 4758 |
| 4759 | static PyObject* pyopencv_cv_CalibrateRobertson_getMaxIter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4759 | static PyObject* pyopencv_cv_CalibrateRobertson_getMaxIter(PyObject* self, PyObject* py_args, PyObject* kw)
| 4760 | { |  | 4760 | {
| 4761 | using namespace cv; |  | 4761 | using namespace cv;
| 4762 |  |  | 4762 |
| 4763 |  |  | 4763 |
| 4764 | Ptr<cv::CalibrateRobertson> * self1 = 0; |  | 4764 | Ptr<cv::CalibrateRobertson> * self1 = 0;
| 4765 | if (!pyopencv_CalibrateRobertson_getp(self, self1)) |  | 4765 | if (!pyopencv_CalibrateRobertson_getp(self, self1))
| 4766 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)"); |  | 4766 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)");
| 4767 | Ptr<cv::CalibrateRobertson> _self_ = *(self1); |  | 4767 | Ptr<cv::CalibrateRobertson> _self_ = *(self1);
| 4768 | int retval; |  | 4768 | int retval;
| 4769 |  |  | 4769 |
| 4770 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4770 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4771 | { |  | 4771 | {
| 4772 | ERRWRAP2(retval = _self_->getMaxIter()); |  | 4772 | ERRWRAP2(retval = _self_->getMaxIter());
| 4773 | return pyopencv_from(retval); |  | 4773 | return pyopencv_from(retval);
| 4774 | } |  | 4774 | }
| 4775 |  |  | 4775 |
| 4776 | return NULL; |  | 4776 | return NULL;
| 4777 | } |  | 4777 | }
| 4778 |  |  | 4778 |
| 4779 | static PyObject* pyopencv_cv_CalibrateRobertson_getRadiance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4779 | static PyObject* pyopencv_cv_CalibrateRobertson_getRadiance(PyObject* self, PyObject* py_args, PyObject* kw)
| 4780 | { |  | 4780 | {
| 4781 | using namespace cv; |  | 4781 | using namespace cv;
| 4782 |  |  | 4782 |
| 4783 |  |  | 4783 |
| 4784 | Ptr<cv::CalibrateRobertson> * self1 = 0; |  | 4784 | Ptr<cv::CalibrateRobertson> * self1 = 0;
| 4785 | if (!pyopencv_CalibrateRobertson_getp(self, self1)) |  | 4785 | if (!pyopencv_CalibrateRobertson_getp(self, self1))
| 4786 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)"); |  | 4786 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)");
| 4787 | Ptr<cv::CalibrateRobertson> _self_ = *(self1); |  | 4787 | Ptr<cv::CalibrateRobertson> _self_ = *(self1);
| 4788 | Mat retval; |  | 4788 | Mat retval;
| 4789 |  |  | 4789 |
| 4790 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4790 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4791 | { |  | 4791 | {
| 4792 | ERRWRAP2(retval = _self_->getRadiance()); |  | 4792 | ERRWRAP2(retval = _self_->getRadiance());
| 4793 | return pyopencv_from(retval); |  | 4793 | return pyopencv_from(retval);
| 4794 | } |  | 4794 | }
| 4795 |  |  | 4795 |
| 4796 | return NULL; |  | 4796 | return NULL;
| 4797 | } |  | 4797 | }
| 4798 |  |  | 4798 |
| 4799 | static PyObject* pyopencv_cv_CalibrateRobertson_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4799 | static PyObject* pyopencv_cv_CalibrateRobertson_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 4800 | { |  | 4800 | {
| 4801 | using namespace cv; |  | 4801 | using namespace cv;
| 4802 |  |  | 4802 |
| 4803 |  |  | 4803 |
| 4804 | Ptr<cv::CalibrateRobertson> * self1 = 0; |  | 4804 | Ptr<cv::CalibrateRobertson> * self1 = 0;
| 4805 | if (!pyopencv_CalibrateRobertson_getp(self, self1)) |  | 4805 | if (!pyopencv_CalibrateRobertson_getp(self, self1))
| 4806 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)"); |  | 4806 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)");
| 4807 | Ptr<cv::CalibrateRobertson> _self_ = *(self1); |  | 4807 | Ptr<cv::CalibrateRobertson> _self_ = *(self1);
| 4808 | float retval; |  | 4808 | float retval;
| 4809 |  |  | 4809 |
| 4810 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4810 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4811 | { |  | 4811 | {
| 4812 | ERRWRAP2(retval = _self_->getThreshold()); |  | 4812 | ERRWRAP2(retval = _self_->getThreshold());
| 4813 | return pyopencv_from(retval); |  | 4813 | return pyopencv_from(retval);
| 4814 | } |  | 4814 | }
| 4815 |  |  | 4815 |
| 4816 | return NULL; |  | 4816 | return NULL;
| 4817 | } |  | 4817 | }
| 4818 |  |  | 4818 |
| 4819 | static PyObject* pyopencv_cv_CalibrateRobertson_setMaxIter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4819 | static PyObject* pyopencv_cv_CalibrateRobertson_setMaxIter(PyObject* self, PyObject* py_args, PyObject* kw)
| 4820 | { |  | 4820 | {
| 4821 | using namespace cv; |  | 4821 | using namespace cv;
| 4822 |  |  | 4822 |
| 4823 |  |  | 4823 |
| 4824 | Ptr<cv::CalibrateRobertson> * self1 = 0; |  | 4824 | Ptr<cv::CalibrateRobertson> * self1 = 0;
| 4825 | if (!pyopencv_CalibrateRobertson_getp(self, self1)) |  | 4825 | if (!pyopencv_CalibrateRobertson_getp(self, self1))
| 4826 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)"); |  | 4826 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)");
| 4827 | Ptr<cv::CalibrateRobertson> _self_ = *(self1); |  | 4827 | Ptr<cv::CalibrateRobertson> _self_ = *(self1);
| 4828 | PyObject* pyobj_max_iter = NULL; |  | 4828 | PyObject* pyobj_max_iter = NULL;
| 4829 | int max_iter=0; |  | 4829 | int max_iter=0;
| 4830 |  |  | 4830 |
| 4831 | const char* keywords[] = { "max_iter", NULL }; |  | 4831 | const char* keywords[] = { "max_iter", NULL };
| 4832 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateRobertson.setMaxIter", (char**)keywords, &pyobj_max_iter) && |  | 4832 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateRobertson.setMaxIter", (char**)keywords, &pyobj_max_iter) &&
| 4833 | pyopencv_to_safe(pyobj_max_iter, max_iter, ArgInfo("max_iter", 0)) ) |  | 4833 | pyopencv_to_safe(pyobj_max_iter, max_iter, ArgInfo("max_iter", 0)) )
| 4834 | { |  | 4834 | {
| 4835 | ERRWRAP2(_self_->setMaxIter(max_iter)); |  | 4835 | ERRWRAP2(_self_->setMaxIter(max_iter));
| 4836 | Py_RETURN_NONE; |  | 4836 | Py_RETURN_NONE;
| 4837 | } |  | 4837 | }
| 4838 |  |  | 4838 |
| 4839 | return NULL; |  | 4839 | return NULL;
| 4840 | } |  | 4840 | }
| 4841 |  |  | 4841 |
| 4842 | static PyObject* pyopencv_cv_CalibrateRobertson_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4842 | static PyObject* pyopencv_cv_CalibrateRobertson_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 4843 | { |  | 4843 | {
| 4844 | using namespace cv; |  | 4844 | using namespace cv;
| 4845 |  |  | 4845 |
| 4846 |  |  | 4846 |
| 4847 | Ptr<cv::CalibrateRobertson> * self1 = 0; |  | 4847 | Ptr<cv::CalibrateRobertson> * self1 = 0;
| 4848 | if (!pyopencv_CalibrateRobertson_getp(self, self1)) |  | 4848 | if (!pyopencv_CalibrateRobertson_getp(self, self1))
| 4849 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)"); |  | 4849 | return failmsgp("Incorrect type of self (must be 'CalibrateRobertson' or its derivative)");
| 4850 | Ptr<cv::CalibrateRobertson> _self_ = *(self1); |  | 4850 | Ptr<cv::CalibrateRobertson> _self_ = *(self1);
| 4851 | PyObject* pyobj_threshold = NULL; |  | 4851 | PyObject* pyobj_threshold = NULL;
| 4852 | float threshold=0.f; |  | 4852 | float threshold=0.f;
| 4853 |  |  | 4853 |
| 4854 | const char* keywords[] = { "threshold", NULL }; |  | 4854 | const char* keywords[] = { "threshold", NULL };
| 4855 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateRobertson.setThreshold", (char**)keywords, &pyobj_threshold) && |  | 4855 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CalibrateRobertson.setThreshold", (char**)keywords, &pyobj_threshold) &&
| 4856 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 4856 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 4857 | { |  | 4857 | {
| 4858 | ERRWRAP2(_self_->setThreshold(threshold)); |  | 4858 | ERRWRAP2(_self_->setThreshold(threshold));
| 4859 | Py_RETURN_NONE; |  | 4859 | Py_RETURN_NONE;
| 4860 | } |  | 4860 | }
| 4861 |  |  | 4861 |
| 4862 | return NULL; |  | 4862 | return NULL;
| 4863 | } |  | 4863 | }
| 4864 |  |  | 4864 |
| 4865 |  |  | 4865 |
| 4866 |  |  | 4866 |
| 4867 | // Tables (CalibrateRobertson) |  | 4867 | // Tables (CalibrateRobertson)
| 4868 |  |  | 4868 |
| 4869 | static PyGetSetDef pyopencv_CalibrateRobertson_getseters[] = |  | 4869 | static PyGetSetDef pyopencv_CalibrateRobertson_getseters[] =
| 4870 | { |  | 4870 | {
| 4871 | {NULL} /* Sentinel */ |  | 4871 | {NULL} /* Sentinel */
| 4872 | }; |  | 4872 | };
| 4873 |  |  | 4873 |
| 4874 | static PyMethodDef pyopencv_CalibrateRobertson_methods[] = |  | 4874 | static PyMethodDef pyopencv_CalibrateRobertson_methods[] =
| 4875 | { |  | 4875 | {
| 4876 | {"getMaxIter", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_getMaxIter, 0), "getMaxIter() -> retval\n."}, |  | 4876 | {"getMaxIter", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_getMaxIter, 0), "getMaxIter() -> retval\n."},
| 4877 | {"getRadiance", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_getRadiance, 0), "getRadiance() -> retval\n."}, |  | 4877 | {"getRadiance", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_getRadiance, 0), "getRadiance() -> retval\n."},
| 4878 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_getThreshold, 0), "getThreshold() -> retval\n."}, |  | 4878 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_getThreshold, 0), "getThreshold() -> retval\n."},
| 4879 | {"setMaxIter", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_setMaxIter, 0), "setMaxIter(max_iter) -> None\n."}, |  | 4879 | {"setMaxIter", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_setMaxIter, 0), "setMaxIter(max_iter) -> None\n."},
| 4880 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_setThreshold, 0), "setThreshold(threshold) -> None\n."}, |  | 4880 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_CalibrateRobertson_setThreshold, 0), "setThreshold(threshold) -> None\n."},
| 4881 |  |  | 4881 |
| 4882 | {NULL, NULL} |  | 4882 | {NULL, NULL}
| 4883 | }; |  | 4883 | };
| 4884 |  |  | 4884 |
| 4885 | // Converter (CalibrateRobertson) |  | 4885 | // Converter (CalibrateRobertson)
| 4886 |  |  | 4886 |
| 4887 | template<> |  | 4887 | template<>
| 4888 | struct PyOpenCV_Converter< Ptr<cv::CalibrateRobertson> > |  | 4888 | struct PyOpenCV_Converter< Ptr<cv::CalibrateRobertson> >
| 4889 | { |  | 4889 | {
| 4890 | static PyObject* from(const Ptr<cv::CalibrateRobertson>& r) |  | 4890 | static PyObject* from(const Ptr<cv::CalibrateRobertson>& r)
| 4891 | { |  | 4891 | {
| 4892 | return pyopencv_CalibrateRobertson_Instance(r); |  | 4892 | return pyopencv_CalibrateRobertson_Instance(r);
| 4893 | } |  | 4893 | }
| 4894 | static bool to(PyObject* src, Ptr<cv::CalibrateRobertson>& dst, const ArgInfo& info) |  | 4894 | static bool to(PyObject* src, Ptr<cv::CalibrateRobertson>& dst, const ArgInfo& info)
| 4895 | { |  | 4895 | {
| 4896 | if(!src || src == Py_None) |  | 4896 | if(!src || src == Py_None)
| 4897 | return true; |  | 4897 | return true;
| 4898 | Ptr<cv::CalibrateRobertson> * dst_; |  | 4898 | Ptr<cv::CalibrateRobertson> * dst_;
| 4899 | if (pyopencv_CalibrateRobertson_getp(src, dst_)) |  | 4899 | if (pyopencv_CalibrateRobertson_getp(src, dst_))
| 4900 | { |  | 4900 | {
| 4901 | dst = *dst_; |  | 4901 | dst = *dst_;
| 4902 | return true; |  | 4902 | return true;
| 4903 | } |  | 4903 | }
| 4904 |  |  | 4904 |
| 4905 | failmsg("Expected Ptr<cv::CalibrateRobertson> for argument '%s'", info.name); |  | 4905 | failmsg("Expected Ptr<cv::CalibrateRobertson> for argument '%s'", info.name);
| 4906 | return false; |  | 4906 | return false;
| 4907 | } |  | 4907 | }
| 4908 | }; |  | 4908 | };
| 4909 |  |  | 4909 |
| 4910 | //================================================================================ |  | 4910 | //================================================================================
| 4911 | // CascadeClassifier (Generic) |  | 4911 | // CascadeClassifier (Generic)
| 4912 | //================================================================================ |  | 4912 | //================================================================================
| 4913 |  |  | 4913 |
| 4914 | // GetSet (CascadeClassifier) |  | 4914 | // GetSet (CascadeClassifier)
| 4915 |  |  | 4915 |
| 4916 |  |  | 4916 |
| 4917 |  |  | 4917 |
| 4918 | // Methods (CascadeClassifier) |  | 4918 | // Methods (CascadeClassifier)
| 4919 |  |  | 4919 |
| 4920 | static int pyopencv_cv_CascadeClassifier_CascadeClassifier(pyopencv_CascadeClassifier_t* self, PyObject* py_args, PyObject* kw) |  | 4920 | static int pyopencv_cv_CascadeClassifier_CascadeClassifier(pyopencv_CascadeClassifier_t* self, PyObject* py_args, PyObject* kw)
| 4921 | { |  | 4921 | {
| 4922 | using namespace cv; |  | 4922 | using namespace cv;
| 4923 |  |  | 4923 |
| 4924 | pyPrepareArgumentConversionErrorsStorage(2); |  | 4924 | pyPrepareArgumentConversionErrorsStorage(2);
| 4925 |  |  | 4925 |
| 4926 | { |  | 4926 | {
| 4927 |  |  | 4927 |
| 4928 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 4928 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 4929 | { |  | 4929 | {
| 4930 | new (&(self->v)) Ptr<cv::CascadeClassifier>(); // init Ptr with placement new |  | 4930 | new (&(self->v)) Ptr<cv::CascadeClassifier>(); // init Ptr with placement new
| 4931 | if(self) ERRWRAP2(self->v.reset(new cv::CascadeClassifier())); |  | 4931 | if(self) ERRWRAP2(self->v.reset(new cv::CascadeClassifier()));
| 4932 | return 0; |  | 4932 | return 0;
| 4933 | } |  | 4933 | }
| 4934 |  |  | 4934 |
| 4935 |  |  | 4935 |
| 4936 | pyPopulateArgumentConversionErrors(); |  | 4936 | pyPopulateArgumentConversionErrors();
| 4937 | } |  | 4937 | }
| 4938 |  |  | 4938 |
| 4939 |  |  | 4939 |
| 4940 | { |  | 4940 | {
| 4941 | PyObject* pyobj_filename = NULL; |  | 4941 | PyObject* pyobj_filename = NULL;
| 4942 | String filename; |  | 4942 | String filename;
| 4943 |  |  | 4943 |
| 4944 | const char* keywords[] = { "filename", NULL }; |  | 4944 | const char* keywords[] = { "filename", NULL };
| 4945 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CascadeClassifier", (char**)keywords, &pyobj_filename) && |  | 4945 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CascadeClassifier", (char**)keywords, &pyobj_filename) &&
| 4946 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 4946 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 4947 | { |  | 4947 | {
| 4948 | new (&(self->v)) Ptr<cv::CascadeClassifier>(); // init Ptr with placement new |  | 4948 | new (&(self->v)) Ptr<cv::CascadeClassifier>(); // init Ptr with placement new
| 4949 | if(self) ERRWRAP2(self->v.reset(new cv::CascadeClassifier(filename))); |  | 4949 | if(self) ERRWRAP2(self->v.reset(new cv::CascadeClassifier(filename)));
| 4950 | return 0; |  | 4950 | return 0;
| 4951 | } |  | 4951 | }
| 4952 |  |  | 4952 |
| 4953 |  |  | 4953 |
| 4954 | pyPopulateArgumentConversionErrors(); |  | 4954 | pyPopulateArgumentConversionErrors();
| 4955 | } |  | 4955 | }
| 4956 | pyRaiseCVOverloadException("CascadeClassifier"); |  | 4956 | pyRaiseCVOverloadException("CascadeClassifier");
| 4957 |  |  | 4957 |
| 4958 | return -1; |  | 4958 | return -1;
| 4959 | } |  | 4959 | }
| 4960 |  |  | 4960 |
| 4961 | static PyObject* pyopencv_cv_CascadeClassifier_convert_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4961 | static PyObject* pyopencv_cv_CascadeClassifier_convert_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 4962 | { |  | 4962 | {
| 4963 | using namespace cv; |  | 4963 | using namespace cv;
| 4964 |  |  | 4964 |
| 4965 | PyObject* pyobj_oldcascade = NULL; |  | 4965 | PyObject* pyobj_oldcascade = NULL;
| 4966 | String oldcascade; |  | 4966 | String oldcascade;
| 4967 | PyObject* pyobj_newcascade = NULL; |  | 4967 | PyObject* pyobj_newcascade = NULL;
| 4968 | String newcascade; |  | 4968 | String newcascade;
| 4969 | bool retval; |  | 4969 | bool retval;
| 4970 |  |  | 4970 |
| 4971 | const char* keywords[] = { "oldcascade", "newcascade", NULL }; |  | 4971 | const char* keywords[] = { "oldcascade", "newcascade", NULL };
| 4972 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:CascadeClassifier.convert", (char**)keywords, &pyobj_oldcascade, &pyobj_newcascade) && |  | 4972 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:CascadeClassifier.convert", (char**)keywords, &pyobj_oldcascade, &pyobj_newcascade) &&
| 4973 | pyopencv_to_safe(pyobj_oldcascade, oldcascade, ArgInfo("oldcascade", 0)) && |  | 4973 | pyopencv_to_safe(pyobj_oldcascade, oldcascade, ArgInfo("oldcascade", 0)) &&
| 4974 | pyopencv_to_safe(pyobj_newcascade, newcascade, ArgInfo("newcascade", 0)) ) |  | 4974 | pyopencv_to_safe(pyobj_newcascade, newcascade, ArgInfo("newcascade", 0)) )
| 4975 | { |  | 4975 | {
| 4976 | ERRWRAP2(retval = cv::CascadeClassifier::convert(oldcascade, newcascade)); |  | 4976 | ERRWRAP2(retval = cv::CascadeClassifier::convert(oldcascade, newcascade));
| 4977 | return pyopencv_from(retval); |  | 4977 | return pyopencv_from(retval);
| 4978 | } |  | 4978 | }
| 4979 |  |  | 4979 |
| 4980 | return NULL; |  | 4980 | return NULL;
| 4981 | } |  | 4981 | }
| 4982 |  |  | 4982 |
| 4983 | static PyObject* pyopencv_cv_CascadeClassifier_detectMultiScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 4983 | static PyObject* pyopencv_cv_CascadeClassifier_detectMultiScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 4984 | { |  | 4984 | {
| 4985 | using namespace cv; |  | 4985 | using namespace cv;
| 4986 |  |  | 4986 |
| 4987 |  |  | 4987 |
| 4988 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 4988 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 4989 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 4989 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 4990 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 4990 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 4991 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 4991 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 4992 | pyPrepareArgumentConversionErrorsStorage(2); |  | 4992 | pyPrepareArgumentConversionErrorsStorage(2);
| 4993 |  |  | 4993 |
| 4994 | { |  | 4994 | {
| 4995 | PyObject* pyobj_image = NULL; |  | 4995 | PyObject* pyobj_image = NULL;
| 4996 | Mat image; |  | 4996 | Mat image;
| 4997 | vector_Rect objects; |  | 4997 | vector_Rect objects;
| 4998 | PyObject* pyobj_scaleFactor = NULL; |  | 4998 | PyObject* pyobj_scaleFactor = NULL;
| 4999 | double scaleFactor=1.1; |  | 4999 | double scaleFactor=1.1;
| 5000 | PyObject* pyobj_minNeighbors = NULL; |  | 5000 | PyObject* pyobj_minNeighbors = NULL;
| 5001 | int minNeighbors=3; |  | 5001 | int minNeighbors=3;
| 5002 | PyObject* pyobj_flags = NULL; |  | 5002 | PyObject* pyobj_flags = NULL;
| 5003 | int flags=0; |  | 5003 | int flags=0;
| 5004 | PyObject* pyobj_minSize = NULL; |  | 5004 | PyObject* pyobj_minSize = NULL;
| 5005 | Size minSize; |  | 5005 | Size minSize;
| 5006 | PyObject* pyobj_maxSize = NULL; |  | 5006 | PyObject* pyobj_maxSize = NULL;
| 5007 | Size maxSize; |  | 5007 | Size maxSize;
| 5008 |  |  | 5008 |
| 5009 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL }; |  | 5009 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL };
| 5010 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) && |  | 5010 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) &&
| 5011 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 5011 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 5012 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) && |  | 5012 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) &&
| 5013 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) && |  | 5013 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) &&
| 5014 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 5014 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 5015 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) && |  | 5015 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) &&
| 5016 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) ) |  | 5016 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) )
| 5017 | { |  | 5017 | {
| 5018 | ERRWRAP2(_self_->detectMultiScale(image, objects, scaleFactor, minNeighbors, flags, minSize, maxSize)); |  | 5018 | ERRWRAP2(_self_->detectMultiScale(image, objects, scaleFactor, minNeighbors, flags, minSize, maxSize));
| 5019 | return pyopencv_from(objects); |  | 5019 | return pyopencv_from(objects);
| 5020 | } |  | 5020 | }
| 5021 |  |  | 5021 |
| 5022 |  |  | 5022 |
| 5023 | pyPopulateArgumentConversionErrors(); |  | 5023 | pyPopulateArgumentConversionErrors();
| 5024 | } |  | 5024 | }
| 5025 |  |  | 5025 |
| 5026 |  |  | 5026 |
| 5027 | { |  | 5027 | {
| 5028 | PyObject* pyobj_image = NULL; |  | 5028 | PyObject* pyobj_image = NULL;
| 5029 | UMat image; |  | 5029 | UMat image;
| 5030 | vector_Rect objects; |  | 5030 | vector_Rect objects;
| 5031 | PyObject* pyobj_scaleFactor = NULL; |  | 5031 | PyObject* pyobj_scaleFactor = NULL;
| 5032 | double scaleFactor=1.1; |  | 5032 | double scaleFactor=1.1;
| 5033 | PyObject* pyobj_minNeighbors = NULL; |  | 5033 | PyObject* pyobj_minNeighbors = NULL;
| 5034 | int minNeighbors=3; |  | 5034 | int minNeighbors=3;
| 5035 | PyObject* pyobj_flags = NULL; |  | 5035 | PyObject* pyobj_flags = NULL;
| 5036 | int flags=0; |  | 5036 | int flags=0;
| 5037 | PyObject* pyobj_minSize = NULL; |  | 5037 | PyObject* pyobj_minSize = NULL;
| 5038 | Size minSize; |  | 5038 | Size minSize;
| 5039 | PyObject* pyobj_maxSize = NULL; |  | 5039 | PyObject* pyobj_maxSize = NULL;
| 5040 | Size maxSize; |  | 5040 | Size maxSize;
| 5041 |  |  | 5041 |
| 5042 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL }; |  | 5042 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL };
| 5043 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) && |  | 5043 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) &&
| 5044 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 5044 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 5045 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) && |  | 5045 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) &&
| 5046 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) && |  | 5046 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) &&
| 5047 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 5047 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 5048 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) && |  | 5048 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) &&
| 5049 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) ) |  | 5049 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) )
| 5050 | { |  | 5050 | {
| 5051 | ERRWRAP2(_self_->detectMultiScale(image, objects, scaleFactor, minNeighbors, flags, minSize, maxSize)); |  | 5051 | ERRWRAP2(_self_->detectMultiScale(image, objects, scaleFactor, minNeighbors, flags, minSize, maxSize));
| 5052 | return pyopencv_from(objects); |  | 5052 | return pyopencv_from(objects);
| 5053 | } |  | 5053 | }
| 5054 |  |  | 5054 |
| 5055 |  |  | 5055 |
| 5056 | pyPopulateArgumentConversionErrors(); |  | 5056 | pyPopulateArgumentConversionErrors();
| 5057 | } |  | 5057 | }
| 5058 | pyRaiseCVOverloadException("detectMultiScale"); |  | 5058 | pyRaiseCVOverloadException("detectMultiScale");
| 5059 |  |  | 5059 |
| 5060 | return NULL; |  | 5060 | return NULL;
| 5061 | } |  | 5061 | }
| 5062 |  |  | 5062 |
| 5063 | static PyObject* pyopencv_cv_CascadeClassifier_detectMultiScale2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5063 | static PyObject* pyopencv_cv_CascadeClassifier_detectMultiScale2(PyObject* self, PyObject* py_args, PyObject* kw)
| 5064 | { |  | 5064 | {
| 5065 | using namespace cv; |  | 5065 | using namespace cv;
| 5066 |  |  | 5066 |
| 5067 |  |  | 5067 |
| 5068 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5068 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5069 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5069 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5070 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5070 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5071 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5071 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5072 | pyPrepareArgumentConversionErrorsStorage(2); |  | 5072 | pyPrepareArgumentConversionErrorsStorage(2);
| 5073 |  |  | 5073 |
| 5074 | { |  | 5074 | {
| 5075 | PyObject* pyobj_image = NULL; |  | 5075 | PyObject* pyobj_image = NULL;
| 5076 | Mat image; |  | 5076 | Mat image;
| 5077 | vector_Rect objects; |  | 5077 | vector_Rect objects;
| 5078 | vector_int numDetections; |  | 5078 | vector_int numDetections;
| 5079 | PyObject* pyobj_scaleFactor = NULL; |  | 5079 | PyObject* pyobj_scaleFactor = NULL;
| 5080 | double scaleFactor=1.1; |  | 5080 | double scaleFactor=1.1;
| 5081 | PyObject* pyobj_minNeighbors = NULL; |  | 5081 | PyObject* pyobj_minNeighbors = NULL;
| 5082 | int minNeighbors=3; |  | 5082 | int minNeighbors=3;
| 5083 | PyObject* pyobj_flags = NULL; |  | 5083 | PyObject* pyobj_flags = NULL;
| 5084 | int flags=0; |  | 5084 | int flags=0;
| 5085 | PyObject* pyobj_minSize = NULL; |  | 5085 | PyObject* pyobj_minSize = NULL;
| 5086 | Size minSize; |  | 5086 | Size minSize;
| 5087 | PyObject* pyobj_maxSize = NULL; |  | 5087 | PyObject* pyobj_maxSize = NULL;
| 5088 | Size maxSize; |  | 5088 | Size maxSize;
| 5089 |  |  | 5089 |
| 5090 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL }; |  | 5090 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL };
| 5091 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale2", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) && |  | 5091 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale2", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) &&
| 5092 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 5092 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 5093 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) && |  | 5093 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) &&
| 5094 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) && |  | 5094 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) &&
| 5095 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 5095 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 5096 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) && |  | 5096 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) &&
| 5097 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) ) |  | 5097 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) )
| 5098 | { |  | 5098 | {
| 5099 | ERRWRAP2(_self_->detectMultiScale(image, objects, numDetections, scaleFactor, minNeighbors, flags, minSize, maxSize)); |  | 5099 | ERRWRAP2(_self_->detectMultiScale(image, objects, numDetections, scaleFactor, minNeighbors, flags, minSize, maxSize));
| 5100 | return Py_BuildValue("(NN)", pyopencv_from(objects), pyopencv_from(numDetections)); |  | 5100 | return Py_BuildValue("(NN)", pyopencv_from(objects), pyopencv_from(numDetections));
| 5101 | } |  | 5101 | }
| 5102 |  |  | 5102 |
| 5103 |  |  | 5103 |
| 5104 | pyPopulateArgumentConversionErrors(); |  | 5104 | pyPopulateArgumentConversionErrors();
| 5105 | } |  | 5105 | }
| 5106 |  |  | 5106 |
| 5107 |  |  | 5107 |
| 5108 | { |  | 5108 | {
| 5109 | PyObject* pyobj_image = NULL; |  | 5109 | PyObject* pyobj_image = NULL;
| 5110 | UMat image; |  | 5110 | UMat image;
| 5111 | vector_Rect objects; |  | 5111 | vector_Rect objects;
| 5112 | vector_int numDetections; |  | 5112 | vector_int numDetections;
| 5113 | PyObject* pyobj_scaleFactor = NULL; |  | 5113 | PyObject* pyobj_scaleFactor = NULL;
| 5114 | double scaleFactor=1.1; |  | 5114 | double scaleFactor=1.1;
| 5115 | PyObject* pyobj_minNeighbors = NULL; |  | 5115 | PyObject* pyobj_minNeighbors = NULL;
| 5116 | int minNeighbors=3; |  | 5116 | int minNeighbors=3;
| 5117 | PyObject* pyobj_flags = NULL; |  | 5117 | PyObject* pyobj_flags = NULL;
| 5118 | int flags=0; |  | 5118 | int flags=0;
| 5119 | PyObject* pyobj_minSize = NULL; |  | 5119 | PyObject* pyobj_minSize = NULL;
| 5120 | Size minSize; |  | 5120 | Size minSize;
| 5121 | PyObject* pyobj_maxSize = NULL; |  | 5121 | PyObject* pyobj_maxSize = NULL;
| 5122 | Size maxSize; |  | 5122 | Size maxSize;
| 5123 |  |  | 5123 |
| 5124 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL }; |  | 5124 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", NULL };
| 5125 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale2", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) && |  | 5125 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:CascadeClassifier.detectMultiScale2", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize) &&
| 5126 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 5126 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 5127 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) && |  | 5127 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) &&
| 5128 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) && |  | 5128 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) &&
| 5129 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 5129 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 5130 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) && |  | 5130 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) &&
| 5131 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) ) |  | 5131 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) )
| 5132 | { |  | 5132 | {
| 5133 | ERRWRAP2(_self_->detectMultiScale(image, objects, numDetections, scaleFactor, minNeighbors, flags, minSize, maxSize)); |  | 5133 | ERRWRAP2(_self_->detectMultiScale(image, objects, numDetections, scaleFactor, minNeighbors, flags, minSize, maxSize));
| 5134 | return Py_BuildValue("(NN)", pyopencv_from(objects), pyopencv_from(numDetections)); |  | 5134 | return Py_BuildValue("(NN)", pyopencv_from(objects), pyopencv_from(numDetections));
| 5135 | } |  | 5135 | }
| 5136 |  |  | 5136 |
| 5137 |  |  | 5137 |
| 5138 | pyPopulateArgumentConversionErrors(); |  | 5138 | pyPopulateArgumentConversionErrors();
| 5139 | } |  | 5139 | }
| 5140 | pyRaiseCVOverloadException("detectMultiScale2"); |  | 5140 | pyRaiseCVOverloadException("detectMultiScale2");
| 5141 |  |  | 5141 |
| 5142 | return NULL; |  | 5142 | return NULL;
| 5143 | } |  | 5143 | }
| 5144 |  |  | 5144 |
| 5145 | static PyObject* pyopencv_cv_CascadeClassifier_detectMultiScale3(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5145 | static PyObject* pyopencv_cv_CascadeClassifier_detectMultiScale3(PyObject* self, PyObject* py_args, PyObject* kw)
| 5146 | { |  | 5146 | {
| 5147 | using namespace cv; |  | 5147 | using namespace cv;
| 5148 |  |  | 5148 |
| 5149 |  |  | 5149 |
| 5150 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5150 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5151 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5151 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5152 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5152 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5153 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5153 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5154 | pyPrepareArgumentConversionErrorsStorage(2); |  | 5154 | pyPrepareArgumentConversionErrorsStorage(2);
| 5155 |  |  | 5155 |
| 5156 | { |  | 5156 | {
| 5157 | PyObject* pyobj_image = NULL; |  | 5157 | PyObject* pyobj_image = NULL;
| 5158 | Mat image; |  | 5158 | Mat image;
| 5159 | vector_Rect objects; |  | 5159 | vector_Rect objects;
| 5160 | vector_int rejectLevels; |  | 5160 | vector_int rejectLevels;
| 5161 | vector_double levelWeights; |  | 5161 | vector_double levelWeights;
| 5162 | PyObject* pyobj_scaleFactor = NULL; |  | 5162 | PyObject* pyobj_scaleFactor = NULL;
| 5163 | double scaleFactor=1.1; |  | 5163 | double scaleFactor=1.1;
| 5164 | PyObject* pyobj_minNeighbors = NULL; |  | 5164 | PyObject* pyobj_minNeighbors = NULL;
| 5165 | int minNeighbors=3; |  | 5165 | int minNeighbors=3;
| 5166 | PyObject* pyobj_flags = NULL; |  | 5166 | PyObject* pyobj_flags = NULL;
| 5167 | int flags=0; |  | 5167 | int flags=0;
| 5168 | PyObject* pyobj_minSize = NULL; |  | 5168 | PyObject* pyobj_minSize = NULL;
| 5169 | Size minSize; |  | 5169 | Size minSize;
| 5170 | PyObject* pyobj_maxSize = NULL; |  | 5170 | PyObject* pyobj_maxSize = NULL;
| 5171 | Size maxSize; |  | 5171 | Size maxSize;
| 5172 | PyObject* pyobj_outputRejectLevels = NULL; |  | 5172 | PyObject* pyobj_outputRejectLevels = NULL;
| 5173 | bool outputRejectLevels=false; |  | 5173 | bool outputRejectLevels=false;
| 5174 |  |  | 5174 |
| 5175 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", "outputRejectLevels", NULL }; |  | 5175 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", "outputRejectLevels", NULL };
| 5176 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:CascadeClassifier.detectMultiScale3", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize, &pyobj_outputRejectLevels) && |  | 5176 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:CascadeClassifier.detectMultiScale3", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize, &pyobj_outputRejectLevels) &&
| 5177 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 5177 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 5178 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) && |  | 5178 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) &&
| 5179 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) && |  | 5179 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) &&
| 5180 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 5180 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 5181 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) && |  | 5181 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) &&
| 5182 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) && |  | 5182 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) &&
| 5183 | pyopencv_to_safe(pyobj_outputRejectLevels, outputRejectLevels, ArgInfo("outputRejectLevels", 0)) ) |  | 5183 | pyopencv_to_safe(pyobj_outputRejectLevels, outputRejectLevels, ArgInfo("outputRejectLevels", 0)) )
| 5184 | { |  | 5184 | {
| 5185 | ERRWRAP2(_self_->detectMultiScale(image, objects, rejectLevels, levelWeights, scaleFactor, minNeighbors, flags, minSize, maxSize, outputRejectLevels)); |  | 5185 | ERRWRAP2(_self_->detectMultiScale(image, objects, rejectLevels, levelWeights, scaleFactor, minNeighbors, flags, minSize, maxSize, outputRejectLevels));
| 5186 | return Py_BuildValue("(NNN)", pyopencv_from(objects), pyopencv_from(rejectLevels), pyopencv_from(levelWeights)); |  | 5186 | return Py_BuildValue("(NNN)", pyopencv_from(objects), pyopencv_from(rejectLevels), pyopencv_from(levelWeights));
| 5187 | } |  | 5187 | }
| 5188 |  |  | 5188 |
| 5189 |  |  | 5189 |
| 5190 | pyPopulateArgumentConversionErrors(); |  | 5190 | pyPopulateArgumentConversionErrors();
| 5191 | } |  | 5191 | }
| 5192 |  |  | 5192 |
| 5193 |  |  | 5193 |
| 5194 | { |  | 5194 | {
| 5195 | PyObject* pyobj_image = NULL; |  | 5195 | PyObject* pyobj_image = NULL;
| 5196 | UMat image; |  | 5196 | UMat image;
| 5197 | vector_Rect objects; |  | 5197 | vector_Rect objects;
| 5198 | vector_int rejectLevels; |  | 5198 | vector_int rejectLevels;
| 5199 | vector_double levelWeights; |  | 5199 | vector_double levelWeights;
| 5200 | PyObject* pyobj_scaleFactor = NULL; |  | 5200 | PyObject* pyobj_scaleFactor = NULL;
| 5201 | double scaleFactor=1.1; |  | 5201 | double scaleFactor=1.1;
| 5202 | PyObject* pyobj_minNeighbors = NULL; |  | 5202 | PyObject* pyobj_minNeighbors = NULL;
| 5203 | int minNeighbors=3; |  | 5203 | int minNeighbors=3;
| 5204 | PyObject* pyobj_flags = NULL; |  | 5204 | PyObject* pyobj_flags = NULL;
| 5205 | int flags=0; |  | 5205 | int flags=0;
| 5206 | PyObject* pyobj_minSize = NULL; |  | 5206 | PyObject* pyobj_minSize = NULL;
| 5207 | Size minSize; |  | 5207 | Size minSize;
| 5208 | PyObject* pyobj_maxSize = NULL; |  | 5208 | PyObject* pyobj_maxSize = NULL;
| 5209 | Size maxSize; |  | 5209 | Size maxSize;
| 5210 | PyObject* pyobj_outputRejectLevels = NULL; |  | 5210 | PyObject* pyobj_outputRejectLevels = NULL;
| 5211 | bool outputRejectLevels=false; |  | 5211 | bool outputRejectLevels=false;
| 5212 |  |  | 5212 |
| 5213 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", "outputRejectLevels", NULL }; |  | 5213 | const char* keywords[] = { "image", "scaleFactor", "minNeighbors", "flags", "minSize", "maxSize", "outputRejectLevels", NULL };
| 5214 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:CascadeClassifier.detectMultiScale3", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize, &pyobj_outputRejectLevels) && |  | 5214 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:CascadeClassifier.detectMultiScale3", (char**)keywords, &pyobj_image, &pyobj_scaleFactor, &pyobj_minNeighbors, &pyobj_flags, &pyobj_minSize, &pyobj_maxSize, &pyobj_outputRejectLevels) &&
| 5215 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 5215 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 5216 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) && |  | 5216 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) &&
| 5217 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) && |  | 5217 | pyopencv_to_safe(pyobj_minNeighbors, minNeighbors, ArgInfo("minNeighbors", 0)) &&
| 5218 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 5218 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 5219 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) && |  | 5219 | pyopencv_to_safe(pyobj_minSize, minSize, ArgInfo("minSize", 0)) &&
| 5220 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) && |  | 5220 | pyopencv_to_safe(pyobj_maxSize, maxSize, ArgInfo("maxSize", 0)) &&
| 5221 | pyopencv_to_safe(pyobj_outputRejectLevels, outputRejectLevels, ArgInfo("outputRejectLevels", 0)) ) |  | 5221 | pyopencv_to_safe(pyobj_outputRejectLevels, outputRejectLevels, ArgInfo("outputRejectLevels", 0)) )
| 5222 | { |  | 5222 | {
| 5223 | ERRWRAP2(_self_->detectMultiScale(image, objects, rejectLevels, levelWeights, scaleFactor, minNeighbors, flags, minSize, maxSize, outputRejectLevels)); |  | 5223 | ERRWRAP2(_self_->detectMultiScale(image, objects, rejectLevels, levelWeights, scaleFactor, minNeighbors, flags, minSize, maxSize, outputRejectLevels));
| 5224 | return Py_BuildValue("(NNN)", pyopencv_from(objects), pyopencv_from(rejectLevels), pyopencv_from(levelWeights)); |  | 5224 | return Py_BuildValue("(NNN)", pyopencv_from(objects), pyopencv_from(rejectLevels), pyopencv_from(levelWeights));
| 5225 | } |  | 5225 | }
| 5226 |  |  | 5226 |
| 5227 |  |  | 5227 |
| 5228 | pyPopulateArgumentConversionErrors(); |  | 5228 | pyPopulateArgumentConversionErrors();
| 5229 | } |  | 5229 | }
| 5230 | pyRaiseCVOverloadException("detectMultiScale3"); |  | 5230 | pyRaiseCVOverloadException("detectMultiScale3");
| 5231 |  |  | 5231 |
| 5232 | return NULL; |  | 5232 | return NULL;
| 5233 | } |  | 5233 | }
| 5234 |  |  | 5234 |
| 5235 | static PyObject* pyopencv_cv_CascadeClassifier_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5235 | static PyObject* pyopencv_cv_CascadeClassifier_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 5236 | { |  | 5236 | {
| 5237 | using namespace cv; |  | 5237 | using namespace cv;
| 5238 |  |  | 5238 |
| 5239 |  |  | 5239 |
| 5240 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5240 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5241 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5241 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5242 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5242 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5243 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5243 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5244 | bool retval; |  | 5244 | bool retval;
| 5245 |  |  | 5245 |
| 5246 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5246 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5247 | { |  | 5247 | {
| 5248 | ERRWRAP2(retval = _self_->empty()); |  | 5248 | ERRWRAP2(retval = _self_->empty());
| 5249 | return pyopencv_from(retval); |  | 5249 | return pyopencv_from(retval);
| 5250 | } |  | 5250 | }
| 5251 |  |  | 5251 |
| 5252 | return NULL; |  | 5252 | return NULL;
| 5253 | } |  | 5253 | }
| 5254 |  |  | 5254 |
| 5255 | static PyObject* pyopencv_cv_CascadeClassifier_getFeatureType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5255 | static PyObject* pyopencv_cv_CascadeClassifier_getFeatureType(PyObject* self, PyObject* py_args, PyObject* kw)
| 5256 | { |  | 5256 | {
| 5257 | using namespace cv; |  | 5257 | using namespace cv;
| 5258 |  |  | 5258 |
| 5259 |  |  | 5259 |
| 5260 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5260 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5261 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5261 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5262 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5262 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5263 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5263 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5264 | int retval; |  | 5264 | int retval;
| 5265 |  |  | 5265 |
| 5266 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5266 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5267 | { |  | 5267 | {
| 5268 | ERRWRAP2(retval = _self_->getFeatureType()); |  | 5268 | ERRWRAP2(retval = _self_->getFeatureType());
| 5269 | return pyopencv_from(retval); |  | 5269 | return pyopencv_from(retval);
| 5270 | } |  | 5270 | }
| 5271 |  |  | 5271 |
| 5272 | return NULL; |  | 5272 | return NULL;
| 5273 | } |  | 5273 | }
| 5274 |  |  | 5274 |
| 5275 | static PyObject* pyopencv_cv_CascadeClassifier_getOriginalWindowSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5275 | static PyObject* pyopencv_cv_CascadeClassifier_getOriginalWindowSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 5276 | { |  | 5276 | {
| 5277 | using namespace cv; |  | 5277 | using namespace cv;
| 5278 |  |  | 5278 |
| 5279 |  |  | 5279 |
| 5280 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5280 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5281 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5281 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5282 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5282 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5283 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5283 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5284 | Size retval; |  | 5284 | Size retval;
| 5285 |  |  | 5285 |
| 5286 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5286 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5287 | { |  | 5287 | {
| 5288 | ERRWRAP2(retval = _self_->getOriginalWindowSize()); |  | 5288 | ERRWRAP2(retval = _self_->getOriginalWindowSize());
| 5289 | return pyopencv_from(retval); |  | 5289 | return pyopencv_from(retval);
| 5290 | } |  | 5290 | }
| 5291 |  |  | 5291 |
| 5292 | return NULL; |  | 5292 | return NULL;
| 5293 | } |  | 5293 | }
| 5294 |  |  | 5294 |
| 5295 | static PyObject* pyopencv_cv_CascadeClassifier_isOldFormatCascade(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5295 | static PyObject* pyopencv_cv_CascadeClassifier_isOldFormatCascade(PyObject* self, PyObject* py_args, PyObject* kw)
| 5296 | { |  | 5296 | {
| 5297 | using namespace cv; |  | 5297 | using namespace cv;
| 5298 |  |  | 5298 |
| 5299 |  |  | 5299 |
| 5300 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5300 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5301 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5301 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5302 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5302 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5303 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5303 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5304 | bool retval; |  | 5304 | bool retval;
| 5305 |  |  | 5305 |
| 5306 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5306 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5307 | { |  | 5307 | {
| 5308 | ERRWRAP2(retval = _self_->isOldFormatCascade()); |  | 5308 | ERRWRAP2(retval = _self_->isOldFormatCascade());
| 5309 | return pyopencv_from(retval); |  | 5309 | return pyopencv_from(retval);
| 5310 | } |  | 5310 | }
| 5311 |  |  | 5311 |
| 5312 | return NULL; |  | 5312 | return NULL;
| 5313 | } |  | 5313 | }
| 5314 |  |  | 5314 |
| 5315 | static PyObject* pyopencv_cv_CascadeClassifier_load(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5315 | static PyObject* pyopencv_cv_CascadeClassifier_load(PyObject* self, PyObject* py_args, PyObject* kw)
| 5316 | { |  | 5316 | {
| 5317 | using namespace cv; |  | 5317 | using namespace cv;
| 5318 |  |  | 5318 |
| 5319 |  |  | 5319 |
| 5320 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5320 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5321 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5321 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5322 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5322 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5323 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5323 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5324 | PyObject* pyobj_filename = NULL; |  | 5324 | PyObject* pyobj_filename = NULL;
| 5325 | String filename; |  | 5325 | String filename;
| 5326 | bool retval; |  | 5326 | bool retval;
| 5327 |  |  | 5327 |
| 5328 | const char* keywords[] = { "filename", NULL }; |  | 5328 | const char* keywords[] = { "filename", NULL };
| 5329 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CascadeClassifier.load", (char**)keywords, &pyobj_filename) && |  | 5329 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CascadeClassifier.load", (char**)keywords, &pyobj_filename) &&
| 5330 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 5330 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 5331 | { |  | 5331 | {
| 5332 | ERRWRAP2(retval = _self_->load(filename)); |  | 5332 | ERRWRAP2(retval = _self_->load(filename));
| 5333 | return pyopencv_from(retval); |  | 5333 | return pyopencv_from(retval);
| 5334 | } |  | 5334 | }
| 5335 |  |  | 5335 |
| 5336 | return NULL; |  | 5336 | return NULL;
| 5337 | } |  | 5337 | }
| 5338 |  |  | 5338 |
| 5339 | static PyObject* pyopencv_cv_CascadeClassifier_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5339 | static PyObject* pyopencv_cv_CascadeClassifier_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 5340 | { |  | 5340 | {
| 5341 | using namespace cv; |  | 5341 | using namespace cv;
| 5342 |  |  | 5342 |
| 5343 |  |  | 5343 |
| 5344 | Ptr<cv::CascadeClassifier> * self1 = 0; |  | 5344 | Ptr<cv::CascadeClassifier> * self1 = 0;
| 5345 | if (!pyopencv_CascadeClassifier_getp(self, self1)) |  | 5345 | if (!pyopencv_CascadeClassifier_getp(self, self1))
| 5346 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)"); |  | 5346 | return failmsgp("Incorrect type of self (must be 'CascadeClassifier' or its derivative)");
| 5347 | Ptr<cv::CascadeClassifier> _self_ = *(self1); |  | 5347 | Ptr<cv::CascadeClassifier> _self_ = *(self1);
| 5348 | PyObject* pyobj_node = NULL; |  | 5348 | PyObject* pyobj_node = NULL;
| 5349 | cv::FileNode node; |  | 5349 | cv::FileNode node;
| 5350 | bool retval; |  | 5350 | bool retval;
| 5351 |  |  | 5351 |
| 5352 | const char* keywords[] = { "node", NULL }; |  | 5352 | const char* keywords[] = { "node", NULL };
| 5353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CascadeClassifier.read", (char**)keywords, &pyobj_node) && |  | 5353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CascadeClassifier.read", (char**)keywords, &pyobj_node) &&
| 5354 | pyopencv_to_safe(pyobj_node, node, ArgInfo("node", 0)) ) |  | 5354 | pyopencv_to_safe(pyobj_node, node, ArgInfo("node", 0)) )
| 5355 | { |  | 5355 | {
| 5356 | ERRWRAP2(retval = _self_->read(node)); |  | 5356 | ERRWRAP2(retval = _self_->read(node));
| 5357 | return pyopencv_from(retval); |  | 5357 | return pyopencv_from(retval);
| 5358 | } |  | 5358 | }
| 5359 |  |  | 5359 |
| 5360 | return NULL; |  | 5360 | return NULL;
| 5361 | } |  | 5361 | }
| 5362 |  |  | 5362 |
| 5363 |  |  | 5363 |
| 5364 |  |  | 5364 |
| 5365 | // Tables (CascadeClassifier) |  | 5365 | // Tables (CascadeClassifier)
| 5366 |  |  | 5366 |
| 5367 | static PyGetSetDef pyopencv_CascadeClassifier_getseters[] = |  | 5367 | static PyGetSetDef pyopencv_CascadeClassifier_getseters[] =
| 5368 | { |  | 5368 | {
| 5369 | {NULL} /* Sentinel */ |  | 5369 | {NULL} /* Sentinel */
| 5370 | }; |  | 5370 | };
| 5371 |  |  | 5371 |
| 5372 | static PyMethodDef pyopencv_CascadeClassifier_methods[] = |  | 5372 | static PyMethodDef pyopencv_CascadeClassifier_methods[] =
| 5373 | { |  | 5373 | {
| 5374 | {"convert", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_convert_static, METH_STATIC), "convert(oldcascade, newcascade) -> retval\n."}, |  | 5374 | {"convert", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_convert_static, METH_STATIC), "convert(oldcascade, newcascade) -> retval\n."},
| 5375 | {"detectMultiScale", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_detectMultiScale, 0), "detectMultiScale(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize]]]]]) -> objects\n. @brief Detects objects of different sizes in the input image. The detected objects are returned as a list\n. of rectangles.\n. \n. @param image Matrix of the type CV_8U containing an image where objects are detected.\n. @param objects Vector of rectangles where each rectangle contains the detected object, the\n. rectangles may be partially outside the original image.\n. @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.\n. @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have\n. to retain it.\n. @param flags Parameter with the same meaning for an old cascade as in the function\n. cvHaarDetectObjects. It is not used for a new cascade.\n. @param minSize Minimum possible object size. Objects smaller than that are ignored.\n. @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale."}, |  | 5375 | {"detectMultiScale", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_detectMultiScale, 0), "detectMultiScale(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize]]]]]) -> objects\n. @brief Detects objects of different sizes in the input image. The detected objects are returned as a list\n. of rectangles.\n. \n. @param image Matrix of the type CV_8U containing an image where objects are detected.\n. @param objects Vector of rectangles where each rectangle contains the detected object, the\n. rectangles may be partially outside the original image.\n. @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.\n. @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have\n. to retain it.\n. @param flags Parameter with the same meaning for an old cascade as in the function\n. cvHaarDetectObjects. It is not used for a new cascade.\n. @param minSize Minimum possible object size. Objects smaller than that are ignored.\n. @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale."},
| 5376 | {"detectMultiScale2", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_detectMultiScale2, 0), "detectMultiScale2(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize]]]]]) -> objects, numDetections\n. @overload\n. @param image Matrix of the type CV_8U containing an image where objects are detected.\n. @param objects Vector of rectangles where each rectangle contains the detected object, the\n. rectangles may be partially outside the original image.\n. @param numDetections Vector of detection numbers for the corresponding objects. An object's number\n. of detections is the number of neighboring positively classified rectangles that were joined\n. together to form the object.\n. @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.\n. @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have\n. to retain it.\n. @param flags Parameter with the same meaning for an old cascade as in the function\n. cvHaarDetectObjects. It is not used for a new cascade.\n. @param minSize Minimum possible object size. Objects smaller than that are ignored.\n. @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale."}, |  | 5376 | {"detectMultiScale2", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_detectMultiScale2, 0), "detectMultiScale2(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize]]]]]) -> objects, numDetections\n. @overload\n. @param image Matrix of the type CV_8U containing an image where objects are detected.\n. @param objects Vector of rectangles where each rectangle contains the detected object, the\n. rectangles may be partially outside the original image.\n. @param numDetections Vector of detection numbers for the corresponding objects. An object's number\n. of detections is the number of neighboring positively classified rectangles that were joined\n. together to form the object.\n. @param scaleFactor Parameter specifying how much the image size is reduced at each image scale.\n. @param minNeighbors Parameter specifying how many neighbors each candidate rectangle should have\n. to retain it.\n. @param flags Parameter with the same meaning for an old cascade as in the function\n. cvHaarDetectObjects. It is not used for a new cascade.\n. @param minSize Minimum possible object size. Objects smaller than that are ignored.\n. @param maxSize Maximum possible object size. Objects larger than that are ignored. If `maxSize == minSize` model is evaluated on single scale."},
| 5377 | {"detectMultiScale3", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_detectMultiScale3, 0), "detectMultiScale3(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize[, outputRejectLevels]]]]]]) -> objects, rejectLevels, levelWeights\n. @overload\n. This function allows you to retrieve the final stage decision certainty of classification.\n. For this, one needs to set `outputRejectLevels` on true and provide the `rejectLevels` and `levelWeights` parameter.\n. For each resulting detection, `levelWeights` will then contain the certainty of classification at the final stage.\n. This value can then be used to separate strong from weaker classifications.\n. \n. A code sample on how to use it efficiently can be found below:\n. @code\n. Mat img;\n. vector<double> weights;\n. vector<int> levels;\n. vector<Rect> detections;\n. CascadeClassifier model(\"/path/to/your/model.xml\");\n. model.detectMultiScale(img, detections, levels, weights, 1.1, 3, 0, Size(), Size(), true);\n. cerr << \"Detection \" << detections[0] << \" with weight \" << weights[0] << endl;\n. @endcode"}, |  | 5377 | {"detectMultiScale3", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_detectMultiScale3, 0), "detectMultiScale3(image[, scaleFactor[, minNeighbors[, flags[, minSize[, maxSize[, outputRejectLevels]]]]]]) -> objects, rejectLevels, levelWeights\n. @overload\n. This function allows you to retrieve the final stage decision certainty of classification.\n. For this, one needs to set `outputRejectLevels` on true and provide the `rejectLevels` and `levelWeights` parameter.\n. For each resulting detection, `levelWeights` will then contain the certainty of classification at the final stage.\n. This value can then be used to separate strong from weaker classifications.\n. \n. A code sample on how to use it efficiently can be found below:\n. @code\n. Mat img;\n. vector<double> weights;\n. vector<int> levels;\n. vector<Rect> detections;\n. CascadeClassifier model(\"/path/to/your/model.xml\");\n. model.detectMultiScale(img, detections, levels, weights, 1.1, 3, 0, Size(), Size(), true);\n. cerr << \"Detection \" << detections[0] << \" with weight \" << weights[0] << endl;\n. @endcode"},
| 5378 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_empty, 0), "empty() -> retval\n. @brief Checks whether the classifier has been loaded."}, |  | 5378 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_empty, 0), "empty() -> retval\n. @brief Checks whether the classifier has been loaded."},
| 5379 | {"getFeatureType", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_getFeatureType, 0), "getFeatureType() -> retval\n."}, |  | 5379 | {"getFeatureType", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_getFeatureType, 0), "getFeatureType() -> retval\n."},
| 5380 | {"getOriginalWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_getOriginalWindowSize, 0), "getOriginalWindowSize() -> retval\n."}, |  | 5380 | {"getOriginalWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_getOriginalWindowSize, 0), "getOriginalWindowSize() -> retval\n."},
| 5381 | {"isOldFormatCascade", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_isOldFormatCascade, 0), "isOldFormatCascade() -> retval\n."}, |  | 5381 | {"isOldFormatCascade", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_isOldFormatCascade, 0), "isOldFormatCascade() -> retval\n."},
| 5382 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_load, 0), "load(filename) -> retval\n. @brief Loads a classifier from a file.\n. \n. @param filename Name of the file from which the classifier is loaded. The file may contain an old\n. HAAR classifier trained by the haartraining application or a new cascade classifier trained by the\n. traincascade application."}, |  | 5382 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_load, 0), "load(filename) -> retval\n. @brief Loads a classifier from a file.\n. \n. @param filename Name of the file from which the classifier is loaded. The file may contain an old\n. HAAR classifier trained by the haartraining application or a new cascade classifier trained by the\n. traincascade application."},
| 5383 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_read, 0), "read(node) -> retval\n. @brief Reads a classifier from a FileStorage node.\n. \n. @note The file may contain a new cascade classifier (trained by the traincascade application) only."}, |  | 5383 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_CascadeClassifier_read, 0), "read(node) -> retval\n. @brief Reads a classifier from a FileStorage node.\n. \n. @note The file may contain a new cascade classifier (trained by the traincascade application) only."},
| 5384 |  |  | 5384 |
| 5385 | {NULL, NULL} |  | 5385 | {NULL, NULL}
| 5386 | }; |  | 5386 | };
| 5387 |  |  | 5387 |
| 5388 | // Converter (CascadeClassifier) |  | 5388 | // Converter (CascadeClassifier)
| 5389 |  |  | 5389 |
| 5390 | template<> |  | 5390 | template<>
| 5391 | struct PyOpenCV_Converter< Ptr<cv::CascadeClassifier> > |  | 5391 | struct PyOpenCV_Converter< Ptr<cv::CascadeClassifier> >
| 5392 | { |  | 5392 | {
| 5393 | static PyObject* from(const Ptr<cv::CascadeClassifier>& r) |  | 5393 | static PyObject* from(const Ptr<cv::CascadeClassifier>& r)
| 5394 | { |  | 5394 | {
| 5395 | return pyopencv_CascadeClassifier_Instance(r); |  | 5395 | return pyopencv_CascadeClassifier_Instance(r);
| 5396 | } |  | 5396 | }
| 5397 | static bool to(PyObject* src, Ptr<cv::CascadeClassifier>& dst, const ArgInfo& info) |  | 5397 | static bool to(PyObject* src, Ptr<cv::CascadeClassifier>& dst, const ArgInfo& info)
| 5398 | { |  | 5398 | {
| 5399 | if(!src || src == Py_None) |  | 5399 | if(!src || src == Py_None)
| 5400 | return true; |  | 5400 | return true;
| 5401 | Ptr<cv::CascadeClassifier> * dst_; |  | 5401 | Ptr<cv::CascadeClassifier> * dst_;
| 5402 | if (pyopencv_CascadeClassifier_getp(src, dst_)) |  | 5402 | if (pyopencv_CascadeClassifier_getp(src, dst_))
| 5403 | { |  | 5403 | {
| 5404 | dst = *dst_; |  | 5404 | dst = *dst_;
| 5405 | return true; |  | 5405 | return true;
| 5406 | } |  | 5406 | }
| 5407 |  |  | 5407 |
| 5408 | failmsg("Expected Ptr<cv::CascadeClassifier> for argument '%s'", info.name); |  | 5408 | failmsg("Expected Ptr<cv::CascadeClassifier> for argument '%s'", info.name);
| 5409 | return false; |  | 5409 | return false;
| 5410 | } |  | 5410 | }
| 5411 | }; |  | 5411 | };
| 5412 |  |  | 5412 |
| 5413 | //================================================================================ |  | 5413 | //================================================================================
| 5414 | // ChiHistogramCostExtractor (Generic) |  | 5414 | // ChiHistogramCostExtractor (Generic)
| 5415 | //================================================================================ |  | 5415 | //================================================================================
| 5416 |  |  | 5416 |
| 5417 | // GetSet (ChiHistogramCostExtractor) |  | 5417 | // GetSet (ChiHistogramCostExtractor)
| 5418 |  |  | 5418 |
| 5419 |  |  | 5419 |
| 5420 |  |  | 5420 |
| 5421 | // Methods (ChiHistogramCostExtractor) |  | 5421 | // Methods (ChiHistogramCostExtractor)
| 5422 |  |  | 5422 |
| 5423 |  |  | 5423 |
| 5424 |  |  | 5424 |
| 5425 | // Tables (ChiHistogramCostExtractor) |  | 5425 | // Tables (ChiHistogramCostExtractor)
| 5426 |  |  | 5426 |
| 5427 | static PyGetSetDef pyopencv_ChiHistogramCostExtractor_getseters[] = |  | 5427 | static PyGetSetDef pyopencv_ChiHistogramCostExtractor_getseters[] =
| 5428 | { |  | 5428 | {
| 5429 | {NULL} /* Sentinel */ |  | 5429 | {NULL} /* Sentinel */
| 5430 | }; |  | 5430 | };
| 5431 |  |  | 5431 |
| 5432 | static PyMethodDef pyopencv_ChiHistogramCostExtractor_methods[] = |  | 5432 | static PyMethodDef pyopencv_ChiHistogramCostExtractor_methods[] =
| 5433 | { |  | 5433 | {
| 5434 |  |  | 5434 |
| 5435 | {NULL, NULL} |  | 5435 | {NULL, NULL}
| 5436 | }; |  | 5436 | };
| 5437 |  |  | 5437 |
| 5438 | // Converter (ChiHistogramCostExtractor) |  | 5438 | // Converter (ChiHistogramCostExtractor)
| 5439 |  |  | 5439 |
| 5440 | template<> |  | 5440 | template<>
| 5441 | struct PyOpenCV_Converter< Ptr<cv::ChiHistogramCostExtractor> > |  | 5441 | struct PyOpenCV_Converter< Ptr<cv::ChiHistogramCostExtractor> >
| 5442 | { |  | 5442 | {
| 5443 | static PyObject* from(const Ptr<cv::ChiHistogramCostExtractor>& r) |  | 5443 | static PyObject* from(const Ptr<cv::ChiHistogramCostExtractor>& r)
| 5444 | { |  | 5444 | {
| 5445 | return pyopencv_ChiHistogramCostExtractor_Instance(r); |  | 5445 | return pyopencv_ChiHistogramCostExtractor_Instance(r);
| 5446 | } |  | 5446 | }
| 5447 | static bool to(PyObject* src, Ptr<cv::ChiHistogramCostExtractor>& dst, const ArgInfo& info) |  | 5447 | static bool to(PyObject* src, Ptr<cv::ChiHistogramCostExtractor>& dst, const ArgInfo& info)
| 5448 | { |  | 5448 | {
| 5449 | if(!src || src == Py_None) |  | 5449 | if(!src || src == Py_None)
| 5450 | return true; |  | 5450 | return true;
| 5451 | Ptr<cv::ChiHistogramCostExtractor> * dst_; |  | 5451 | Ptr<cv::ChiHistogramCostExtractor> * dst_;
| 5452 | if (pyopencv_ChiHistogramCostExtractor_getp(src, dst_)) |  | 5452 | if (pyopencv_ChiHistogramCostExtractor_getp(src, dst_))
| 5453 | { |  | 5453 | {
| 5454 | dst = *dst_; |  | 5454 | dst = *dst_;
| 5455 | return true; |  | 5455 | return true;
| 5456 | } |  | 5456 | }
| 5457 |  |  | 5457 |
| 5458 | failmsg("Expected Ptr<cv::ChiHistogramCostExtractor> for argument '%s'", info.name); |  | 5458 | failmsg("Expected Ptr<cv::ChiHistogramCostExtractor> for argument '%s'", info.name);
| 5459 | return false; |  | 5459 | return false;
| 5460 | } |  | 5460 | }
| 5461 | }; |  | 5461 | };
| 5462 |  |  | 5462 |
| 5463 | //================================================================================ |  | 5463 | //================================================================================
| 5464 | // CirclesGridFinderParameters (Generic) |  | 5464 | // CirclesGridFinderParameters (Generic)
| 5465 | //================================================================================ |  | 5465 | //================================================================================
| 5466 |  |  | 5466 |
| 5467 | // GetSet (CirclesGridFinderParameters) |  | 5467 | // GetSet (CirclesGridFinderParameters)
| 5468 |  |  | 5468 |
| 5469 |  |  | 5469 |
| 5470 | static PyObject* pyopencv_CirclesGridFinderParameters_get_convexHullFactor(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5470 | static PyObject* pyopencv_CirclesGridFinderParameters_get_convexHullFactor(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5471 | { |  | 5471 | {
| 5472 | return pyopencv_from(p->v.convexHullFactor); |  | 5472 | return pyopencv_from(p->v.convexHullFactor);
| 5473 | } |  | 5473 | }
| 5474 |  |  | 5474 |
| 5475 | static int pyopencv_CirclesGridFinderParameters_set_convexHullFactor(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5475 | static int pyopencv_CirclesGridFinderParameters_set_convexHullFactor(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5476 | { |  | 5476 | {
| 5477 | if (!value) |  | 5477 | if (!value)
| 5478 | { |  | 5478 | {
| 5479 | PyErr_SetString(PyExc_TypeError, "Cannot delete the convexHullFactor attribute"); |  | 5479 | PyErr_SetString(PyExc_TypeError, "Cannot delete the convexHullFactor attribute");
| 5480 | return -1; |  | 5480 | return -1;
| 5481 | } |  | 5481 | }
| 5482 | return pyopencv_to_safe(value, p->v.convexHullFactor, ArgInfo("value", 0)) ? 0 : -1; |  | 5482 | return pyopencv_to_safe(value, p->v.convexHullFactor, ArgInfo("value", 0)) ? 0 : -1;
| 5483 | } |  | 5483 | }
| 5484 |  |  | 5484 |
| 5485 | static PyObject* pyopencv_CirclesGridFinderParameters_get_densityNeighborhoodSize(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5485 | static PyObject* pyopencv_CirclesGridFinderParameters_get_densityNeighborhoodSize(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5486 | { |  | 5486 | {
| 5487 | return pyopencv_from(p->v.densityNeighborhoodSize); |  | 5487 | return pyopencv_from(p->v.densityNeighborhoodSize);
| 5488 | } |  | 5488 | }
| 5489 |  |  | 5489 |
| 5490 | static int pyopencv_CirclesGridFinderParameters_set_densityNeighborhoodSize(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5490 | static int pyopencv_CirclesGridFinderParameters_set_densityNeighborhoodSize(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5491 | { |  | 5491 | {
| 5492 | if (!value) |  | 5492 | if (!value)
| 5493 | { |  | 5493 | {
| 5494 | PyErr_SetString(PyExc_TypeError, "Cannot delete the densityNeighborhoodSize attribute"); |  | 5494 | PyErr_SetString(PyExc_TypeError, "Cannot delete the densityNeighborhoodSize attribute");
| 5495 | return -1; |  | 5495 | return -1;
| 5496 | } |  | 5496 | }
| 5497 | return pyopencv_to_safe(value, p->v.densityNeighborhoodSize, ArgInfo("value", 0)) ? 0 : -1; |  | 5497 | return pyopencv_to_safe(value, p->v.densityNeighborhoodSize, ArgInfo("value", 0)) ? 0 : -1;
| 5498 | } |  | 5498 | }
| 5499 |  |  | 5499 |
| 5500 | static PyObject* pyopencv_CirclesGridFinderParameters_get_edgeGain(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5500 | static PyObject* pyopencv_CirclesGridFinderParameters_get_edgeGain(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5501 | { |  | 5501 | {
| 5502 | return pyopencv_from(p->v.edgeGain); |  | 5502 | return pyopencv_from(p->v.edgeGain);
| 5503 | } |  | 5503 | }
| 5504 |  |  | 5504 |
| 5505 | static int pyopencv_CirclesGridFinderParameters_set_edgeGain(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5505 | static int pyopencv_CirclesGridFinderParameters_set_edgeGain(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5506 | { |  | 5506 | {
| 5507 | if (!value) |  | 5507 | if (!value)
| 5508 | { |  | 5508 | {
| 5509 | PyErr_SetString(PyExc_TypeError, "Cannot delete the edgeGain attribute"); |  | 5509 | PyErr_SetString(PyExc_TypeError, "Cannot delete the edgeGain attribute");
| 5510 | return -1; |  | 5510 | return -1;
| 5511 | } |  | 5511 | }
| 5512 | return pyopencv_to_safe(value, p->v.edgeGain, ArgInfo("value", 0)) ? 0 : -1; |  | 5512 | return pyopencv_to_safe(value, p->v.edgeGain, ArgInfo("value", 0)) ? 0 : -1;
| 5513 | } |  | 5513 | }
| 5514 |  |  | 5514 |
| 5515 | static PyObject* pyopencv_CirclesGridFinderParameters_get_edgePenalty(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5515 | static PyObject* pyopencv_CirclesGridFinderParameters_get_edgePenalty(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5516 | { |  | 5516 | {
| 5517 | return pyopencv_from(p->v.edgePenalty); |  | 5517 | return pyopencv_from(p->v.edgePenalty);
| 5518 | } |  | 5518 | }
| 5519 |  |  | 5519 |
| 5520 | static int pyopencv_CirclesGridFinderParameters_set_edgePenalty(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5520 | static int pyopencv_CirclesGridFinderParameters_set_edgePenalty(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5521 | { |  | 5521 | {
| 5522 | if (!value) |  | 5522 | if (!value)
| 5523 | { |  | 5523 | {
| 5524 | PyErr_SetString(PyExc_TypeError, "Cannot delete the edgePenalty attribute"); |  | 5524 | PyErr_SetString(PyExc_TypeError, "Cannot delete the edgePenalty attribute");
| 5525 | return -1; |  | 5525 | return -1;
| 5526 | } |  | 5526 | }
| 5527 | return pyopencv_to_safe(value, p->v.edgePenalty, ArgInfo("value", 0)) ? 0 : -1; |  | 5527 | return pyopencv_to_safe(value, p->v.edgePenalty, ArgInfo("value", 0)) ? 0 : -1;
| 5528 | } |  | 5528 | }
| 5529 |  |  | 5529 |
| 5530 | static PyObject* pyopencv_CirclesGridFinderParameters_get_existingVertexGain(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5530 | static PyObject* pyopencv_CirclesGridFinderParameters_get_existingVertexGain(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5531 | { |  | 5531 | {
| 5532 | return pyopencv_from(p->v.existingVertexGain); |  | 5532 | return pyopencv_from(p->v.existingVertexGain);
| 5533 | } |  | 5533 | }
| 5534 |  |  | 5534 |
| 5535 | static int pyopencv_CirclesGridFinderParameters_set_existingVertexGain(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5535 | static int pyopencv_CirclesGridFinderParameters_set_existingVertexGain(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5536 | { |  | 5536 | {
| 5537 | if (!value) |  | 5537 | if (!value)
| 5538 | { |  | 5538 | {
| 5539 | PyErr_SetString(PyExc_TypeError, "Cannot delete the existingVertexGain attribute"); |  | 5539 | PyErr_SetString(PyExc_TypeError, "Cannot delete the existingVertexGain attribute");
| 5540 | return -1; |  | 5540 | return -1;
| 5541 | } |  | 5541 | }
| 5542 | return pyopencv_to_safe(value, p->v.existingVertexGain, ArgInfo("value", 0)) ? 0 : -1; |  | 5542 | return pyopencv_to_safe(value, p->v.existingVertexGain, ArgInfo("value", 0)) ? 0 : -1;
| 5543 | } |  | 5543 | }
| 5544 |  |  | 5544 |
| 5545 | static PyObject* pyopencv_CirclesGridFinderParameters_get_keypointScale(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5545 | static PyObject* pyopencv_CirclesGridFinderParameters_get_keypointScale(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5546 | { |  | 5546 | {
| 5547 | return pyopencv_from(p->v.keypointScale); |  | 5547 | return pyopencv_from(p->v.keypointScale);
| 5548 | } |  | 5548 | }
| 5549 |  |  | 5549 |
| 5550 | static int pyopencv_CirclesGridFinderParameters_set_keypointScale(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5550 | static int pyopencv_CirclesGridFinderParameters_set_keypointScale(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5551 | { |  | 5551 | {
| 5552 | if (!value) |  | 5552 | if (!value)
| 5553 | { |  | 5553 | {
| 5554 | PyErr_SetString(PyExc_TypeError, "Cannot delete the keypointScale attribute"); |  | 5554 | PyErr_SetString(PyExc_TypeError, "Cannot delete the keypointScale attribute");
| 5555 | return -1; |  | 5555 | return -1;
| 5556 | } |  | 5556 | }
| 5557 | return pyopencv_to_safe(value, p->v.keypointScale, ArgInfo("value", 0)) ? 0 : -1; |  | 5557 | return pyopencv_to_safe(value, p->v.keypointScale, ArgInfo("value", 0)) ? 0 : -1;
| 5558 | } |  | 5558 | }
| 5559 |  |  | 5559 |
| 5560 | static PyObject* pyopencv_CirclesGridFinderParameters_get_kmeansAttempts(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5560 | static PyObject* pyopencv_CirclesGridFinderParameters_get_kmeansAttempts(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5561 | { |  | 5561 | {
| 5562 | return pyopencv_from(p->v.kmeansAttempts); |  | 5562 | return pyopencv_from(p->v.kmeansAttempts);
| 5563 | } |  | 5563 | }
| 5564 |  |  | 5564 |
| 5565 | static int pyopencv_CirclesGridFinderParameters_set_kmeansAttempts(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5565 | static int pyopencv_CirclesGridFinderParameters_set_kmeansAttempts(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5566 | { |  | 5566 | {
| 5567 | if (!value) |  | 5567 | if (!value)
| 5568 | { |  | 5568 | {
| 5569 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kmeansAttempts attribute"); |  | 5569 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kmeansAttempts attribute");
| 5570 | return -1; |  | 5570 | return -1;
| 5571 | } |  | 5571 | }
| 5572 | return pyopencv_to_safe(value, p->v.kmeansAttempts, ArgInfo("value", 0)) ? 0 : -1; |  | 5572 | return pyopencv_to_safe(value, p->v.kmeansAttempts, ArgInfo("value", 0)) ? 0 : -1;
| 5573 | } |  | 5573 | }
| 5574 |  |  | 5574 |
| 5575 | static PyObject* pyopencv_CirclesGridFinderParameters_get_maxRectifiedDistance(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5575 | static PyObject* pyopencv_CirclesGridFinderParameters_get_maxRectifiedDistance(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5576 | { |  | 5576 | {
| 5577 | return pyopencv_from(p->v.maxRectifiedDistance); |  | 5577 | return pyopencv_from(p->v.maxRectifiedDistance);
| 5578 | } |  | 5578 | }
| 5579 |  |  | 5579 |
| 5580 | static int pyopencv_CirclesGridFinderParameters_set_maxRectifiedDistance(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5580 | static int pyopencv_CirclesGridFinderParameters_set_maxRectifiedDistance(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5581 | { |  | 5581 | {
| 5582 | if (!value) |  | 5582 | if (!value)
| 5583 | { |  | 5583 | {
| 5584 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxRectifiedDistance attribute"); |  | 5584 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxRectifiedDistance attribute");
| 5585 | return -1; |  | 5585 | return -1;
| 5586 | } |  | 5586 | }
| 5587 | return pyopencv_to_safe(value, p->v.maxRectifiedDistance, ArgInfo("value", 0)) ? 0 : -1; |  | 5587 | return pyopencv_to_safe(value, p->v.maxRectifiedDistance, ArgInfo("value", 0)) ? 0 : -1;
| 5588 | } |  | 5588 | }
| 5589 |  |  | 5589 |
| 5590 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minDensity(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5590 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minDensity(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5591 | { |  | 5591 | {
| 5592 | return pyopencv_from(p->v.minDensity); |  | 5592 | return pyopencv_from(p->v.minDensity);
| 5593 | } |  | 5593 | }
| 5594 |  |  | 5594 |
| 5595 | static int pyopencv_CirclesGridFinderParameters_set_minDensity(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5595 | static int pyopencv_CirclesGridFinderParameters_set_minDensity(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5596 | { |  | 5596 | {
| 5597 | if (!value) |  | 5597 | if (!value)
| 5598 | { |  | 5598 | {
| 5599 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDensity attribute"); |  | 5599 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDensity attribute");
| 5600 | return -1; |  | 5600 | return -1;
| 5601 | } |  | 5601 | }
| 5602 | return pyopencv_to_safe(value, p->v.minDensity, ArgInfo("value", 0)) ? 0 : -1; |  | 5602 | return pyopencv_to_safe(value, p->v.minDensity, ArgInfo("value", 0)) ? 0 : -1;
| 5603 | } |  | 5603 | }
| 5604 |  |  | 5604 |
| 5605 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minDistanceToAddKeypoint(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5605 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minDistanceToAddKeypoint(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5606 | { |  | 5606 | {
| 5607 | return pyopencv_from(p->v.minDistanceToAddKeypoint); |  | 5607 | return pyopencv_from(p->v.minDistanceToAddKeypoint);
| 5608 | } |  | 5608 | }
| 5609 |  |  | 5609 |
| 5610 | static int pyopencv_CirclesGridFinderParameters_set_minDistanceToAddKeypoint(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5610 | static int pyopencv_CirclesGridFinderParameters_set_minDistanceToAddKeypoint(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5611 | { |  | 5611 | {
| 5612 | if (!value) |  | 5612 | if (!value)
| 5613 | { |  | 5613 | {
| 5614 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDistanceToAddKeypoint attribute"); |  | 5614 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDistanceToAddKeypoint attribute");
| 5615 | return -1; |  | 5615 | return -1;
| 5616 | } |  | 5616 | }
| 5617 | return pyopencv_to_safe(value, p->v.minDistanceToAddKeypoint, ArgInfo("value", 0)) ? 0 : -1; |  | 5617 | return pyopencv_to_safe(value, p->v.minDistanceToAddKeypoint, ArgInfo("value", 0)) ? 0 : -1;
| 5618 | } |  | 5618 | }
| 5619 |  |  | 5619 |
| 5620 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minGraphConfidence(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5620 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minGraphConfidence(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5621 | { |  | 5621 | {
| 5622 | return pyopencv_from(p->v.minGraphConfidence); |  | 5622 | return pyopencv_from(p->v.minGraphConfidence);
| 5623 | } |  | 5623 | }
| 5624 |  |  | 5624 |
| 5625 | static int pyopencv_CirclesGridFinderParameters_set_minGraphConfidence(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5625 | static int pyopencv_CirclesGridFinderParameters_set_minGraphConfidence(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5626 | { |  | 5626 | {
| 5627 | if (!value) |  | 5627 | if (!value)
| 5628 | { |  | 5628 | {
| 5629 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minGraphConfidence attribute"); |  | 5629 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minGraphConfidence attribute");
| 5630 | return -1; |  | 5630 | return -1;
| 5631 | } |  | 5631 | }
| 5632 | return pyopencv_to_safe(value, p->v.minGraphConfidence, ArgInfo("value", 0)) ? 0 : -1; |  | 5632 | return pyopencv_to_safe(value, p->v.minGraphConfidence, ArgInfo("value", 0)) ? 0 : -1;
| 5633 | } |  | 5633 | }
| 5634 |  |  | 5634 |
| 5635 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minRNGEdgeSwitchDist(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5635 | static PyObject* pyopencv_CirclesGridFinderParameters_get_minRNGEdgeSwitchDist(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5636 | { |  | 5636 | {
| 5637 | return pyopencv_from(p->v.minRNGEdgeSwitchDist); |  | 5637 | return pyopencv_from(p->v.minRNGEdgeSwitchDist);
| 5638 | } |  | 5638 | }
| 5639 |  |  | 5639 |
| 5640 | static int pyopencv_CirclesGridFinderParameters_set_minRNGEdgeSwitchDist(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5640 | static int pyopencv_CirclesGridFinderParameters_set_minRNGEdgeSwitchDist(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5641 | { |  | 5641 | {
| 5642 | if (!value) |  | 5642 | if (!value)
| 5643 | { |  | 5643 | {
| 5644 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minRNGEdgeSwitchDist attribute"); |  | 5644 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minRNGEdgeSwitchDist attribute");
| 5645 | return -1; |  | 5645 | return -1;
| 5646 | } |  | 5646 | }
| 5647 | return pyopencv_to_safe(value, p->v.minRNGEdgeSwitchDist, ArgInfo("value", 0)) ? 0 : -1; |  | 5647 | return pyopencv_to_safe(value, p->v.minRNGEdgeSwitchDist, ArgInfo("value", 0)) ? 0 : -1;
| 5648 | } |  | 5648 | }
| 5649 |  |  | 5649 |
| 5650 | static PyObject* pyopencv_CirclesGridFinderParameters_get_squareSize(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5650 | static PyObject* pyopencv_CirclesGridFinderParameters_get_squareSize(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5651 | { |  | 5651 | {
| 5652 | return pyopencv_from(p->v.squareSize); |  | 5652 | return pyopencv_from(p->v.squareSize);
| 5653 | } |  | 5653 | }
| 5654 |  |  | 5654 |
| 5655 | static int pyopencv_CirclesGridFinderParameters_set_squareSize(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5655 | static int pyopencv_CirclesGridFinderParameters_set_squareSize(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5656 | { |  | 5656 | {
| 5657 | if (!value) |  | 5657 | if (!value)
| 5658 | { |  | 5658 | {
| 5659 | PyErr_SetString(PyExc_TypeError, "Cannot delete the squareSize attribute"); |  | 5659 | PyErr_SetString(PyExc_TypeError, "Cannot delete the squareSize attribute");
| 5660 | return -1; |  | 5660 | return -1;
| 5661 | } |  | 5661 | }
| 5662 | return pyopencv_to_safe(value, p->v.squareSize, ArgInfo("value", 0)) ? 0 : -1; |  | 5662 | return pyopencv_to_safe(value, p->v.squareSize, ArgInfo("value", 0)) ? 0 : -1;
| 5663 | } |  | 5663 | }
| 5664 |  |  | 5664 |
| 5665 | static PyObject* pyopencv_CirclesGridFinderParameters_get_vertexGain(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5665 | static PyObject* pyopencv_CirclesGridFinderParameters_get_vertexGain(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5666 | { |  | 5666 | {
| 5667 | return pyopencv_from(p->v.vertexGain); |  | 5667 | return pyopencv_from(p->v.vertexGain);
| 5668 | } |  | 5668 | }
| 5669 |  |  | 5669 |
| 5670 | static int pyopencv_CirclesGridFinderParameters_set_vertexGain(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5670 | static int pyopencv_CirclesGridFinderParameters_set_vertexGain(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5671 | { |  | 5671 | {
| 5672 | if (!value) |  | 5672 | if (!value)
| 5673 | { |  | 5673 | {
| 5674 | PyErr_SetString(PyExc_TypeError, "Cannot delete the vertexGain attribute"); |  | 5674 | PyErr_SetString(PyExc_TypeError, "Cannot delete the vertexGain attribute");
| 5675 | return -1; |  | 5675 | return -1;
| 5676 | } |  | 5676 | }
| 5677 | return pyopencv_to_safe(value, p->v.vertexGain, ArgInfo("value", 0)) ? 0 : -1; |  | 5677 | return pyopencv_to_safe(value, p->v.vertexGain, ArgInfo("value", 0)) ? 0 : -1;
| 5678 | } |  | 5678 | }
| 5679 |  |  | 5679 |
| 5680 | static PyObject* pyopencv_CirclesGridFinderParameters_get_vertexPenalty(pyopencv_CirclesGridFinderParameters_t* p, void *closure) |  | 5680 | static PyObject* pyopencv_CirclesGridFinderParameters_get_vertexPenalty(pyopencv_CirclesGridFinderParameters_t* p, void *closure)
| 5681 | { |  | 5681 | {
| 5682 | return pyopencv_from(p->v.vertexPenalty); |  | 5682 | return pyopencv_from(p->v.vertexPenalty);
| 5683 | } |  | 5683 | }
| 5684 |  |  | 5684 |
| 5685 | static int pyopencv_CirclesGridFinderParameters_set_vertexPenalty(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure) |  | 5685 | static int pyopencv_CirclesGridFinderParameters_set_vertexPenalty(pyopencv_CirclesGridFinderParameters_t* p, PyObject *value, void *closure)
| 5686 | { |  | 5686 | {
| 5687 | if (!value) |  | 5687 | if (!value)
| 5688 | { |  | 5688 | {
| 5689 | PyErr_SetString(PyExc_TypeError, "Cannot delete the vertexPenalty attribute"); |  | 5689 | PyErr_SetString(PyExc_TypeError, "Cannot delete the vertexPenalty attribute");
| 5690 | return -1; |  | 5690 | return -1;
| 5691 | } |  | 5691 | }
| 5692 | return pyopencv_to_safe(value, p->v.vertexPenalty, ArgInfo("value", 0)) ? 0 : -1; |  | 5692 | return pyopencv_to_safe(value, p->v.vertexPenalty, ArgInfo("value", 0)) ? 0 : -1;
| 5693 | } |  | 5693 | }
| 5694 |  |  | 5694 |
| 5695 |  |  | 5695 |
| 5696 | // Methods (CirclesGridFinderParameters) |  | 5696 | // Methods (CirclesGridFinderParameters)
| 5697 |  |  | 5697 |
| 5698 | static int pyopencv_cv_CirclesGridFinderParameters_CirclesGridFinderParameters(pyopencv_CirclesGridFinderParameters_t* self, PyObject* py_args, PyObject* kw) |  | 5698 | static int pyopencv_cv_CirclesGridFinderParameters_CirclesGridFinderParameters(pyopencv_CirclesGridFinderParameters_t* self, PyObject* py_args, PyObject* kw)
| 5699 | { |  | 5699 | {
| 5700 | using namespace cv; |  | 5700 | using namespace cv;
| 5701 |  |  | 5701 |
| 5702 |  |  | 5702 |
| 5703 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5703 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5704 | { |  | 5704 | {
| 5705 | if(self) ERRWRAP2(new (&(self->v)) cv::CirclesGridFinderParameters()); |  | 5705 | if(self) ERRWRAP2(new (&(self->v)) cv::CirclesGridFinderParameters());
| 5706 | return 0; |  | 5706 | return 0;
| 5707 | } |  | 5707 | }
| 5708 |  |  | 5708 |
| 5709 | return -1; |  | 5709 | return -1;
| 5710 | } |  | 5710 | }
| 5711 |  |  | 5711 |
| 5712 |  |  | 5712 |
| 5713 |  |  | 5713 |
| 5714 | // Tables (CirclesGridFinderParameters) |  | 5714 | // Tables (CirclesGridFinderParameters)
| 5715 |  |  | 5715 |
| 5716 | static PyGetSetDef pyopencv_CirclesGridFinderParameters_getseters[] = |  | 5716 | static PyGetSetDef pyopencv_CirclesGridFinderParameters_getseters[] =
| 5717 | { |  | 5717 | {
| 5718 | {(char*)"convexHullFactor", (getter)pyopencv_CirclesGridFinderParameters_get_convexHullFactor, (setter)pyopencv_CirclesGridFinderParameters_set_convexHullFactor, (char*)"convexHullFactor", NULL}, |  | 5718 | {(char*)"convexHullFactor", (getter)pyopencv_CirclesGridFinderParameters_get_convexHullFactor, (setter)pyopencv_CirclesGridFinderParameters_set_convexHullFactor, (char*)"convexHullFactor", NULL},
| 5719 | {(char*)"densityNeighborhoodSize", (getter)pyopencv_CirclesGridFinderParameters_get_densityNeighborhoodSize, (setter)pyopencv_CirclesGridFinderParameters_set_densityNeighborhoodSize, (char*)"densityNeighborhoodSize", NULL}, |  | 5719 | {(char*)"densityNeighborhoodSize", (getter)pyopencv_CirclesGridFinderParameters_get_densityNeighborhoodSize, (setter)pyopencv_CirclesGridFinderParameters_set_densityNeighborhoodSize, (char*)"densityNeighborhoodSize", NULL},
| 5720 | {(char*)"edgeGain", (getter)pyopencv_CirclesGridFinderParameters_get_edgeGain, (setter)pyopencv_CirclesGridFinderParameters_set_edgeGain, (char*)"edgeGain", NULL}, |  | 5720 | {(char*)"edgeGain", (getter)pyopencv_CirclesGridFinderParameters_get_edgeGain, (setter)pyopencv_CirclesGridFinderParameters_set_edgeGain, (char*)"edgeGain", NULL},
| 5721 | {(char*)"edgePenalty", (getter)pyopencv_CirclesGridFinderParameters_get_edgePenalty, (setter)pyopencv_CirclesGridFinderParameters_set_edgePenalty, (char*)"edgePenalty", NULL}, |  | 5721 | {(char*)"edgePenalty", (getter)pyopencv_CirclesGridFinderParameters_get_edgePenalty, (setter)pyopencv_CirclesGridFinderParameters_set_edgePenalty, (char*)"edgePenalty", NULL},
| 5722 | {(char*)"existingVertexGain", (getter)pyopencv_CirclesGridFinderParameters_get_existingVertexGain, (setter)pyopencv_CirclesGridFinderParameters_set_existingVertexGain, (char*)"existingVertexGain", NULL}, |  | 5722 | {(char*)"existingVertexGain", (getter)pyopencv_CirclesGridFinderParameters_get_existingVertexGain, (setter)pyopencv_CirclesGridFinderParameters_set_existingVertexGain, (char*)"existingVertexGain", NULL},
| 5723 | {(char*)"keypointScale", (getter)pyopencv_CirclesGridFinderParameters_get_keypointScale, (setter)pyopencv_CirclesGridFinderParameters_set_keypointScale, (char*)"keypointScale", NULL}, |  | 5723 | {(char*)"keypointScale", (getter)pyopencv_CirclesGridFinderParameters_get_keypointScale, (setter)pyopencv_CirclesGridFinderParameters_set_keypointScale, (char*)"keypointScale", NULL},
| 5724 | {(char*)"kmeansAttempts", (getter)pyopencv_CirclesGridFinderParameters_get_kmeansAttempts, (setter)pyopencv_CirclesGridFinderParameters_set_kmeansAttempts, (char*)"kmeansAttempts", NULL}, |  | 5724 | {(char*)"kmeansAttempts", (getter)pyopencv_CirclesGridFinderParameters_get_kmeansAttempts, (setter)pyopencv_CirclesGridFinderParameters_set_kmeansAttempts, (char*)"kmeansAttempts", NULL},
| 5725 | {(char*)"maxRectifiedDistance", (getter)pyopencv_CirclesGridFinderParameters_get_maxRectifiedDistance, (setter)pyopencv_CirclesGridFinderParameters_set_maxRectifiedDistance, (char*)"maxRectifiedDistance", NULL}, |  | 5725 | {(char*)"maxRectifiedDistance", (getter)pyopencv_CirclesGridFinderParameters_get_maxRectifiedDistance, (setter)pyopencv_CirclesGridFinderParameters_set_maxRectifiedDistance, (char*)"maxRectifiedDistance", NULL},
| 5726 | {(char*)"minDensity", (getter)pyopencv_CirclesGridFinderParameters_get_minDensity, (setter)pyopencv_CirclesGridFinderParameters_set_minDensity, (char*)"minDensity", NULL}, |  | 5726 | {(char*)"minDensity", (getter)pyopencv_CirclesGridFinderParameters_get_minDensity, (setter)pyopencv_CirclesGridFinderParameters_set_minDensity, (char*)"minDensity", NULL},
| 5727 | {(char*)"minDistanceToAddKeypoint", (getter)pyopencv_CirclesGridFinderParameters_get_minDistanceToAddKeypoint, (setter)pyopencv_CirclesGridFinderParameters_set_minDistanceToAddKeypoint, (char*)"minDistanceToAddKeypoint", NULL}, |  | 5727 | {(char*)"minDistanceToAddKeypoint", (getter)pyopencv_CirclesGridFinderParameters_get_minDistanceToAddKeypoint, (setter)pyopencv_CirclesGridFinderParameters_set_minDistanceToAddKeypoint, (char*)"minDistanceToAddKeypoint", NULL},
| 5728 | {(char*)"minGraphConfidence", (getter)pyopencv_CirclesGridFinderParameters_get_minGraphConfidence, (setter)pyopencv_CirclesGridFinderParameters_set_minGraphConfidence, (char*)"minGraphConfidence", NULL}, |  | 5728 | {(char*)"minGraphConfidence", (getter)pyopencv_CirclesGridFinderParameters_get_minGraphConfidence, (setter)pyopencv_CirclesGridFinderParameters_set_minGraphConfidence, (char*)"minGraphConfidence", NULL},
| 5729 | {(char*)"minRNGEdgeSwitchDist", (getter)pyopencv_CirclesGridFinderParameters_get_minRNGEdgeSwitchDist, (setter)pyopencv_CirclesGridFinderParameters_set_minRNGEdgeSwitchDist, (char*)"minRNGEdgeSwitchDist", NULL}, |  | 5729 | {(char*)"minRNGEdgeSwitchDist", (getter)pyopencv_CirclesGridFinderParameters_get_minRNGEdgeSwitchDist, (setter)pyopencv_CirclesGridFinderParameters_set_minRNGEdgeSwitchDist, (char*)"minRNGEdgeSwitchDist", NULL},
| 5730 | {(char*)"squareSize", (getter)pyopencv_CirclesGridFinderParameters_get_squareSize, (setter)pyopencv_CirclesGridFinderParameters_set_squareSize, (char*)"squareSize", NULL}, |  | 5730 | {(char*)"squareSize", (getter)pyopencv_CirclesGridFinderParameters_get_squareSize, (setter)pyopencv_CirclesGridFinderParameters_set_squareSize, (char*)"squareSize", NULL},
| 5731 | {(char*)"vertexGain", (getter)pyopencv_CirclesGridFinderParameters_get_vertexGain, (setter)pyopencv_CirclesGridFinderParameters_set_vertexGain, (char*)"vertexGain", NULL}, |  | 5731 | {(char*)"vertexGain", (getter)pyopencv_CirclesGridFinderParameters_get_vertexGain, (setter)pyopencv_CirclesGridFinderParameters_set_vertexGain, (char*)"vertexGain", NULL},
| 5732 | {(char*)"vertexPenalty", (getter)pyopencv_CirclesGridFinderParameters_get_vertexPenalty, (setter)pyopencv_CirclesGridFinderParameters_set_vertexPenalty, (char*)"vertexPenalty", NULL}, |  | 5732 | {(char*)"vertexPenalty", (getter)pyopencv_CirclesGridFinderParameters_get_vertexPenalty, (setter)pyopencv_CirclesGridFinderParameters_set_vertexPenalty, (char*)"vertexPenalty", NULL},
| 5733 | {NULL} /* Sentinel */ |  | 5733 | {NULL} /* Sentinel */
| 5734 | }; |  | 5734 | };
| 5735 |  |  | 5735 |
| 5736 | static PyMethodDef pyopencv_CirclesGridFinderParameters_methods[] = |  | 5736 | static PyMethodDef pyopencv_CirclesGridFinderParameters_methods[] =
| 5737 | { |  | 5737 | {
| 5738 |  |  | 5738 |
| 5739 | {NULL, NULL} |  | 5739 | {NULL, NULL}
| 5740 | }; |  | 5740 | };
| 5741 |  |  | 5741 |
| 5742 | // Converter (CirclesGridFinderParameters) |  | 5742 | // Converter (CirclesGridFinderParameters)
| 5743 |  |  | 5743 |
| 5744 | template<> |  | 5744 | template<>
| 5745 | struct PyOpenCV_Converter< cv::CirclesGridFinderParameters > |  | 5745 | struct PyOpenCV_Converter< cv::CirclesGridFinderParameters >
| 5746 | { |  | 5746 | {
| 5747 | static PyObject* from(const cv::CirclesGridFinderParameters& r) |  | 5747 | static PyObject* from(const cv::CirclesGridFinderParameters& r)
| 5748 | { |  | 5748 | {
| 5749 | return pyopencv_CirclesGridFinderParameters_Instance(r); |  | 5749 | return pyopencv_CirclesGridFinderParameters_Instance(r);
| 5750 | } |  | 5750 | }
| 5751 | static bool to(PyObject* src, cv::CirclesGridFinderParameters& dst, const ArgInfo& info) |  | 5751 | static bool to(PyObject* src, cv::CirclesGridFinderParameters& dst, const ArgInfo& info)
| 5752 | { |  | 5752 | {
| 5753 | if(!src || src == Py_None) |  | 5753 | if(!src || src == Py_None)
| 5754 | return true; |  | 5754 | return true;
| 5755 | cv::CirclesGridFinderParameters * dst_; |  | 5755 | cv::CirclesGridFinderParameters * dst_;
| 5756 | if (pyopencv_CirclesGridFinderParameters_getp(src, dst_)) |  | 5756 | if (pyopencv_CirclesGridFinderParameters_getp(src, dst_))
| 5757 | { |  | 5757 | {
| 5758 | dst = *dst_; |  | 5758 | dst = *dst_;
| 5759 | return true; |  | 5759 | return true;
| 5760 | } |  | 5760 | }
| 5761 |  |  | 5761 |
| 5762 | failmsg("Expected cv::CirclesGridFinderParameters for argument '%s'", info.name); |  | 5762 | failmsg("Expected cv::CirclesGridFinderParameters for argument '%s'", info.name);
| 5763 | return false; |  | 5763 | return false;
| 5764 | } |  | 5764 | }
| 5765 | }; |  | 5765 | };
| 5766 |  |  | 5766 |
| 5767 | //================================================================================ |  | 5767 | //================================================================================
| 5768 | // DISOpticalFlow (Generic) |  | 5768 | // DISOpticalFlow (Generic)
| 5769 | //================================================================================ |  | 5769 | //================================================================================
| 5770 |  |  | 5770 |
| 5771 | // GetSet (DISOpticalFlow) |  | 5771 | // GetSet (DISOpticalFlow)
| 5772 |  |  | 5772 |
| 5773 |  |  | 5773 |
| 5774 |  |  | 5774 |
| 5775 | // Methods (DISOpticalFlow) |  | 5775 | // Methods (DISOpticalFlow)
| 5776 |  |  | 5776 |
| 5777 | static PyObject* pyopencv_cv_DISOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5777 | static PyObject* pyopencv_cv_DISOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 5778 | { |  | 5778 | {
| 5779 | using namespace cv; |  | 5779 | using namespace cv;
| 5780 |  |  | 5780 |
| 5781 | PyObject* pyobj_preset = NULL; |  | 5781 | PyObject* pyobj_preset = NULL;
| 5782 | int preset=DISOpticalFlow::PRESET_FAST; |  | 5782 | int preset=DISOpticalFlow::PRESET_FAST;
| 5783 | Ptr<DISOpticalFlow> retval; |  | 5783 | Ptr<DISOpticalFlow> retval;
| 5784 |  |  | 5784 |
| 5785 | const char* keywords[] = { "preset", NULL }; |  | 5785 | const char* keywords[] = { "preset", NULL };
| 5786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:DISOpticalFlow.create", (char**)keywords, &pyobj_preset) && |  | 5786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:DISOpticalFlow.create", (char**)keywords, &pyobj_preset) &&
| 5787 | pyopencv_to_safe(pyobj_preset, preset, ArgInfo("preset", 0)) ) |  | 5787 | pyopencv_to_safe(pyobj_preset, preset, ArgInfo("preset", 0)) )
| 5788 | { |  | 5788 | {
| 5789 | ERRWRAP2(retval = cv::DISOpticalFlow::create(preset)); |  | 5789 | ERRWRAP2(retval = cv::DISOpticalFlow::create(preset));
| 5790 | return pyopencv_from(retval); |  | 5790 | return pyopencv_from(retval);
| 5791 | } |  | 5791 | }
| 5792 |  |  | 5792 |
| 5793 | return NULL; |  | 5793 | return NULL;
| 5794 | } |  | 5794 | }
| 5795 |  |  | 5795 |
| 5796 | static PyObject* pyopencv_cv_DISOpticalFlow_getFinestScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5796 | static PyObject* pyopencv_cv_DISOpticalFlow_getFinestScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 5797 | { |  | 5797 | {
| 5798 | using namespace cv; |  | 5798 | using namespace cv;
| 5799 |  |  | 5799 |
| 5800 |  |  | 5800 |
| 5801 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5801 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5802 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5802 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5803 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5803 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5804 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5804 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5805 | int retval; |  | 5805 | int retval;
| 5806 |  |  | 5806 |
| 5807 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5807 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5808 | { |  | 5808 | {
| 5809 | ERRWRAP2(retval = _self_->getFinestScale()); |  | 5809 | ERRWRAP2(retval = _self_->getFinestScale());
| 5810 | return pyopencv_from(retval); |  | 5810 | return pyopencv_from(retval);
| 5811 | } |  | 5811 | }
| 5812 |  |  | 5812 |
| 5813 | return NULL; |  | 5813 | return NULL;
| 5814 | } |  | 5814 | }
| 5815 |  |  | 5815 |
| 5816 | static PyObject* pyopencv_cv_DISOpticalFlow_getGradientDescentIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5816 | static PyObject* pyopencv_cv_DISOpticalFlow_getGradientDescentIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 5817 | { |  | 5817 | {
| 5818 | using namespace cv; |  | 5818 | using namespace cv;
| 5819 |  |  | 5819 |
| 5820 |  |  | 5820 |
| 5821 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5821 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5822 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5822 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5823 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5823 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5824 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5824 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5825 | int retval; |  | 5825 | int retval;
| 5826 |  |  | 5826 |
| 5827 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5827 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5828 | { |  | 5828 | {
| 5829 | ERRWRAP2(retval = _self_->getGradientDescentIterations()); |  | 5829 | ERRWRAP2(retval = _self_->getGradientDescentIterations());
| 5830 | return pyopencv_from(retval); |  | 5830 | return pyopencv_from(retval);
| 5831 | } |  | 5831 | }
| 5832 |  |  | 5832 |
| 5833 | return NULL; |  | 5833 | return NULL;
| 5834 | } |  | 5834 | }
| 5835 |  |  | 5835 |
| 5836 | static PyObject* pyopencv_cv_DISOpticalFlow_getPatchSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5836 | static PyObject* pyopencv_cv_DISOpticalFlow_getPatchSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 5837 | { |  | 5837 | {
| 5838 | using namespace cv; |  | 5838 | using namespace cv;
| 5839 |  |  | 5839 |
| 5840 |  |  | 5840 |
| 5841 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5841 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5842 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5842 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5843 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5843 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5844 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5844 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5845 | int retval; |  | 5845 | int retval;
| 5846 |  |  | 5846 |
| 5847 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5847 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5848 | { |  | 5848 | {
| 5849 | ERRWRAP2(retval = _self_->getPatchSize()); |  | 5849 | ERRWRAP2(retval = _self_->getPatchSize());
| 5850 | return pyopencv_from(retval); |  | 5850 | return pyopencv_from(retval);
| 5851 | } |  | 5851 | }
| 5852 |  |  | 5852 |
| 5853 | return NULL; |  | 5853 | return NULL;
| 5854 | } |  | 5854 | }
| 5855 |  |  | 5855 |
| 5856 | static PyObject* pyopencv_cv_DISOpticalFlow_getPatchStride(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5856 | static PyObject* pyopencv_cv_DISOpticalFlow_getPatchStride(PyObject* self, PyObject* py_args, PyObject* kw)
| 5857 | { |  | 5857 | {
| 5858 | using namespace cv; |  | 5858 | using namespace cv;
| 5859 |  |  | 5859 |
| 5860 |  |  | 5860 |
| 5861 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5861 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5862 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5862 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5863 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5863 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5864 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5864 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5865 | int retval; |  | 5865 | int retval;
| 5866 |  |  | 5866 |
| 5867 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5867 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5868 | { |  | 5868 | {
| 5869 | ERRWRAP2(retval = _self_->getPatchStride()); |  | 5869 | ERRWRAP2(retval = _self_->getPatchStride());
| 5870 | return pyopencv_from(retval); |  | 5870 | return pyopencv_from(retval);
| 5871 | } |  | 5871 | }
| 5872 |  |  | 5872 |
| 5873 | return NULL; |  | 5873 | return NULL;
| 5874 | } |  | 5874 | }
| 5875 |  |  | 5875 |
| 5876 | static PyObject* pyopencv_cv_DISOpticalFlow_getUseMeanNormalization(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5876 | static PyObject* pyopencv_cv_DISOpticalFlow_getUseMeanNormalization(PyObject* self, PyObject* py_args, PyObject* kw)
| 5877 | { |  | 5877 | {
| 5878 | using namespace cv; |  | 5878 | using namespace cv;
| 5879 |  |  | 5879 |
| 5880 |  |  | 5880 |
| 5881 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5881 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5882 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5882 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5883 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5883 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5884 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5884 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5885 | bool retval; |  | 5885 | bool retval;
| 5886 |  |  | 5886 |
| 5887 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5887 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5888 | { |  | 5888 | {
| 5889 | ERRWRAP2(retval = _self_->getUseMeanNormalization()); |  | 5889 | ERRWRAP2(retval = _self_->getUseMeanNormalization());
| 5890 | return pyopencv_from(retval); |  | 5890 | return pyopencv_from(retval);
| 5891 | } |  | 5891 | }
| 5892 |  |  | 5892 |
| 5893 | return NULL; |  | 5893 | return NULL;
| 5894 | } |  | 5894 | }
| 5895 |  |  | 5895 |
| 5896 | static PyObject* pyopencv_cv_DISOpticalFlow_getUseSpatialPropagation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5896 | static PyObject* pyopencv_cv_DISOpticalFlow_getUseSpatialPropagation(PyObject* self, PyObject* py_args, PyObject* kw)
| 5897 | { |  | 5897 | {
| 5898 | using namespace cv; |  | 5898 | using namespace cv;
| 5899 |  |  | 5899 |
| 5900 |  |  | 5900 |
| 5901 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5901 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5902 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5902 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5903 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5903 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5904 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5904 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5905 | bool retval; |  | 5905 | bool retval;
| 5906 |  |  | 5906 |
| 5907 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5907 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5908 | { |  | 5908 | {
| 5909 | ERRWRAP2(retval = _self_->getUseSpatialPropagation()); |  | 5909 | ERRWRAP2(retval = _self_->getUseSpatialPropagation());
| 5910 | return pyopencv_from(retval); |  | 5910 | return pyopencv_from(retval);
| 5911 | } |  | 5911 | }
| 5912 |  |  | 5912 |
| 5913 | return NULL; |  | 5913 | return NULL;
| 5914 | } |  | 5914 | }
| 5915 |  |  | 5915 |
| 5916 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementAlpha(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5916 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementAlpha(PyObject* self, PyObject* py_args, PyObject* kw)
| 5917 | { |  | 5917 | {
| 5918 | using namespace cv; |  | 5918 | using namespace cv;
| 5919 |  |  | 5919 |
| 5920 |  |  | 5920 |
| 5921 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5921 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5922 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5922 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5923 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5923 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5924 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5924 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5925 | float retval; |  | 5925 | float retval;
| 5926 |  |  | 5926 |
| 5927 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5927 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5928 | { |  | 5928 | {
| 5929 | ERRWRAP2(retval = _self_->getVariationalRefinementAlpha()); |  | 5929 | ERRWRAP2(retval = _self_->getVariationalRefinementAlpha());
| 5930 | return pyopencv_from(retval); |  | 5930 | return pyopencv_from(retval);
| 5931 | } |  | 5931 | }
| 5932 |  |  | 5932 |
| 5933 | return NULL; |  | 5933 | return NULL;
| 5934 | } |  | 5934 | }
| 5935 |  |  | 5935 |
| 5936 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementDelta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5936 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementDelta(PyObject* self, PyObject* py_args, PyObject* kw)
| 5937 | { |  | 5937 | {
| 5938 | using namespace cv; |  | 5938 | using namespace cv;
| 5939 |  |  | 5939 |
| 5940 |  |  | 5940 |
| 5941 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5941 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5942 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5942 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5943 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5943 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5944 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5944 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5945 | float retval; |  | 5945 | float retval;
| 5946 |  |  | 5946 |
| 5947 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5947 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5948 | { |  | 5948 | {
| 5949 | ERRWRAP2(retval = _self_->getVariationalRefinementDelta()); |  | 5949 | ERRWRAP2(retval = _self_->getVariationalRefinementDelta());
| 5950 | return pyopencv_from(retval); |  | 5950 | return pyopencv_from(retval);
| 5951 | } |  | 5951 | }
| 5952 |  |  | 5952 |
| 5953 | return NULL; |  | 5953 | return NULL;
| 5954 | } |  | 5954 | }
| 5955 |  |  | 5955 |
| 5956 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5956 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 5957 | { |  | 5957 | {
| 5958 | using namespace cv; |  | 5958 | using namespace cv;
| 5959 |  |  | 5959 |
| 5960 |  |  | 5960 |
| 5961 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5961 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5962 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5962 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5963 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5963 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5964 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5964 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5965 | float retval; |  | 5965 | float retval;
| 5966 |  |  | 5966 |
| 5967 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5967 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5968 | { |  | 5968 | {
| 5969 | ERRWRAP2(retval = _self_->getVariationalRefinementEpsilon()); |  | 5969 | ERRWRAP2(retval = _self_->getVariationalRefinementEpsilon());
| 5970 | return pyopencv_from(retval); |  | 5970 | return pyopencv_from(retval);
| 5971 | } |  | 5971 | }
| 5972 |  |  | 5972 |
| 5973 | return NULL; |  | 5973 | return NULL;
| 5974 | } |  | 5974 | }
| 5975 |  |  | 5975 |
| 5976 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5976 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 5977 | { |  | 5977 | {
| 5978 | using namespace cv; |  | 5978 | using namespace cv;
| 5979 |  |  | 5979 |
| 5980 |  |  | 5980 |
| 5981 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 5981 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 5982 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 5982 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 5983 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 5983 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 5984 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 5984 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 5985 | float retval; |  | 5985 | float retval;
| 5986 |  |  | 5986 |
| 5987 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 5987 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 5988 | { |  | 5988 | {
| 5989 | ERRWRAP2(retval = _self_->getVariationalRefinementGamma()); |  | 5989 | ERRWRAP2(retval = _self_->getVariationalRefinementGamma());
| 5990 | return pyopencv_from(retval); |  | 5990 | return pyopencv_from(retval);
| 5991 | } |  | 5991 | }
| 5992 |  |  | 5992 |
| 5993 | return NULL; |  | 5993 | return NULL;
| 5994 | } |  | 5994 | }
| 5995 |  |  | 5995 |
| 5996 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 5996 | static PyObject* pyopencv_cv_DISOpticalFlow_getVariationalRefinementIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 5997 | { |  | 5997 | {
| 5998 | using namespace cv; |  | 5998 | using namespace cv;
| 5999 |  |  | 5999 |
| 6000 |  |  | 6000 |
| 6001 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6001 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6002 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6002 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6003 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6003 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6004 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6004 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6005 | int retval; |  | 6005 | int retval;
| 6006 |  |  | 6006 |
| 6007 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 6007 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 6008 | { |  | 6008 | {
| 6009 | ERRWRAP2(retval = _self_->getVariationalRefinementIterations()); |  | 6009 | ERRWRAP2(retval = _self_->getVariationalRefinementIterations());
| 6010 | return pyopencv_from(retval); |  | 6010 | return pyopencv_from(retval);
| 6011 | } |  | 6011 | }
| 6012 |  |  | 6012 |
| 6013 | return NULL; |  | 6013 | return NULL;
| 6014 | } |  | 6014 | }
| 6015 |  |  | 6015 |
| 6016 | static PyObject* pyopencv_cv_DISOpticalFlow_setFinestScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6016 | static PyObject* pyopencv_cv_DISOpticalFlow_setFinestScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 6017 | { |  | 6017 | {
| 6018 | using namespace cv; |  | 6018 | using namespace cv;
| 6019 |  |  | 6019 |
| 6020 |  |  | 6020 |
| 6021 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6021 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6022 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6022 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6023 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6023 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6024 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6024 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6025 | PyObject* pyobj_val = NULL; |  | 6025 | PyObject* pyobj_val = NULL;
| 6026 | int val=0; |  | 6026 | int val=0;
| 6027 |  |  | 6027 |
| 6028 | const char* keywords[] = { "val", NULL }; |  | 6028 | const char* keywords[] = { "val", NULL };
| 6029 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setFinestScale", (char**)keywords, &pyobj_val) && |  | 6029 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setFinestScale", (char**)keywords, &pyobj_val) &&
| 6030 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6030 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6031 | { |  | 6031 | {
| 6032 | ERRWRAP2(_self_->setFinestScale(val)); |  | 6032 | ERRWRAP2(_self_->setFinestScale(val));
| 6033 | Py_RETURN_NONE; |  | 6033 | Py_RETURN_NONE;
| 6034 | } |  | 6034 | }
| 6035 |  |  | 6035 |
| 6036 | return NULL; |  | 6036 | return NULL;
| 6037 | } |  | 6037 | }
| 6038 |  |  | 6038 |
| 6039 | static PyObject* pyopencv_cv_DISOpticalFlow_setGradientDescentIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6039 | static PyObject* pyopencv_cv_DISOpticalFlow_setGradientDescentIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 6040 | { |  | 6040 | {
| 6041 | using namespace cv; |  | 6041 | using namespace cv;
| 6042 |  |  | 6042 |
| 6043 |  |  | 6043 |
| 6044 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6044 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6045 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6045 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6046 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6046 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6047 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6047 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6048 | PyObject* pyobj_val = NULL; |  | 6048 | PyObject* pyobj_val = NULL;
| 6049 | int val=0; |  | 6049 | int val=0;
| 6050 |  |  | 6050 |
| 6051 | const char* keywords[] = { "val", NULL }; |  | 6051 | const char* keywords[] = { "val", NULL };
| 6052 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setGradientDescentIterations", (char**)keywords, &pyobj_val) && |  | 6052 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setGradientDescentIterations", (char**)keywords, &pyobj_val) &&
| 6053 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6053 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6054 | { |  | 6054 | {
| 6055 | ERRWRAP2(_self_->setGradientDescentIterations(val)); |  | 6055 | ERRWRAP2(_self_->setGradientDescentIterations(val));
| 6056 | Py_RETURN_NONE; |  | 6056 | Py_RETURN_NONE;
| 6057 | } |  | 6057 | }
| 6058 |  |  | 6058 |
| 6059 | return NULL; |  | 6059 | return NULL;
| 6060 | } |  | 6060 | }
| 6061 |  |  | 6061 |
| 6062 | static PyObject* pyopencv_cv_DISOpticalFlow_setPatchSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6062 | static PyObject* pyopencv_cv_DISOpticalFlow_setPatchSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 6063 | { |  | 6063 | {
| 6064 | using namespace cv; |  | 6064 | using namespace cv;
| 6065 |  |  | 6065 |
| 6066 |  |  | 6066 |
| 6067 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6067 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6068 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6068 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6069 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6069 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6070 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6070 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6071 | PyObject* pyobj_val = NULL; |  | 6071 | PyObject* pyobj_val = NULL;
| 6072 | int val=0; |  | 6072 | int val=0;
| 6073 |  |  | 6073 |
| 6074 | const char* keywords[] = { "val", NULL }; |  | 6074 | const char* keywords[] = { "val", NULL };
| 6075 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setPatchSize", (char**)keywords, &pyobj_val) && |  | 6075 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setPatchSize", (char**)keywords, &pyobj_val) &&
| 6076 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6076 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6077 | { |  | 6077 | {
| 6078 | ERRWRAP2(_self_->setPatchSize(val)); |  | 6078 | ERRWRAP2(_self_->setPatchSize(val));
| 6079 | Py_RETURN_NONE; |  | 6079 | Py_RETURN_NONE;
| 6080 | } |  | 6080 | }
| 6081 |  |  | 6081 |
| 6082 | return NULL; |  | 6082 | return NULL;
| 6083 | } |  | 6083 | }
| 6084 |  |  | 6084 |
| 6085 | static PyObject* pyopencv_cv_DISOpticalFlow_setPatchStride(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6085 | static PyObject* pyopencv_cv_DISOpticalFlow_setPatchStride(PyObject* self, PyObject* py_args, PyObject* kw)
| 6086 | { |  | 6086 | {
| 6087 | using namespace cv; |  | 6087 | using namespace cv;
| 6088 |  |  | 6088 |
| 6089 |  |  | 6089 |
| 6090 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6090 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6091 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6091 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6092 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6092 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6093 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6093 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6094 | PyObject* pyobj_val = NULL; |  | 6094 | PyObject* pyobj_val = NULL;
| 6095 | int val=0; |  | 6095 | int val=0;
| 6096 |  |  | 6096 |
| 6097 | const char* keywords[] = { "val", NULL }; |  | 6097 | const char* keywords[] = { "val", NULL };
| 6098 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setPatchStride", (char**)keywords, &pyobj_val) && |  | 6098 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setPatchStride", (char**)keywords, &pyobj_val) &&
| 6099 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6099 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6100 | { |  | 6100 | {
| 6101 | ERRWRAP2(_self_->setPatchStride(val)); |  | 6101 | ERRWRAP2(_self_->setPatchStride(val));
| 6102 | Py_RETURN_NONE; |  | 6102 | Py_RETURN_NONE;
| 6103 | } |  | 6103 | }
| 6104 |  |  | 6104 |
| 6105 | return NULL; |  | 6105 | return NULL;
| 6106 | } |  | 6106 | }
| 6107 |  |  | 6107 |
| 6108 | static PyObject* pyopencv_cv_DISOpticalFlow_setUseMeanNormalization(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6108 | static PyObject* pyopencv_cv_DISOpticalFlow_setUseMeanNormalization(PyObject* self, PyObject* py_args, PyObject* kw)
| 6109 | { |  | 6109 | {
| 6110 | using namespace cv; |  | 6110 | using namespace cv;
| 6111 |  |  | 6111 |
| 6112 |  |  | 6112 |
| 6113 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6113 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6114 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6114 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6115 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6115 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6116 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6116 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6117 | PyObject* pyobj_val = NULL; |  | 6117 | PyObject* pyobj_val = NULL;
| 6118 | bool val=0; |  | 6118 | bool val=0;
| 6119 |  |  | 6119 |
| 6120 | const char* keywords[] = { "val", NULL }; |  | 6120 | const char* keywords[] = { "val", NULL };
| 6121 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setUseMeanNormalization", (char**)keywords, &pyobj_val) && |  | 6121 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setUseMeanNormalization", (char**)keywords, &pyobj_val) &&
| 6122 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6122 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6123 | { |  | 6123 | {
| 6124 | ERRWRAP2(_self_->setUseMeanNormalization(val)); |  | 6124 | ERRWRAP2(_self_->setUseMeanNormalization(val));
| 6125 | Py_RETURN_NONE; |  | 6125 | Py_RETURN_NONE;
| 6126 | } |  | 6126 | }
| 6127 |  |  | 6127 |
| 6128 | return NULL; |  | 6128 | return NULL;
| 6129 | } |  | 6129 | }
| 6130 |  |  | 6130 |
| 6131 | static PyObject* pyopencv_cv_DISOpticalFlow_setUseSpatialPropagation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6131 | static PyObject* pyopencv_cv_DISOpticalFlow_setUseSpatialPropagation(PyObject* self, PyObject* py_args, PyObject* kw)
| 6132 | { |  | 6132 | {
| 6133 | using namespace cv; |  | 6133 | using namespace cv;
| 6134 |  |  | 6134 |
| 6135 |  |  | 6135 |
| 6136 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6136 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6137 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6137 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6138 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6138 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6139 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6139 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6140 | PyObject* pyobj_val = NULL; |  | 6140 | PyObject* pyobj_val = NULL;
| 6141 | bool val=0; |  | 6141 | bool val=0;
| 6142 |  |  | 6142 |
| 6143 | const char* keywords[] = { "val", NULL }; |  | 6143 | const char* keywords[] = { "val", NULL };
| 6144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setUseSpatialPropagation", (char**)keywords, &pyobj_val) && |  | 6144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setUseSpatialPropagation", (char**)keywords, &pyobj_val) &&
| 6145 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6145 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6146 | { |  | 6146 | {
| 6147 | ERRWRAP2(_self_->setUseSpatialPropagation(val)); |  | 6147 | ERRWRAP2(_self_->setUseSpatialPropagation(val));
| 6148 | Py_RETURN_NONE; |  | 6148 | Py_RETURN_NONE;
| 6149 | } |  | 6149 | }
| 6150 |  |  | 6150 |
| 6151 | return NULL; |  | 6151 | return NULL;
| 6152 | } |  | 6152 | }
| 6153 |  |  | 6153 |
| 6154 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementAlpha(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6154 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementAlpha(PyObject* self, PyObject* py_args, PyObject* kw)
| 6155 | { |  | 6155 | {
| 6156 | using namespace cv; |  | 6156 | using namespace cv;
| 6157 |  |  | 6157 |
| 6158 |  |  | 6158 |
| 6159 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6159 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6160 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6160 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6161 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6161 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6162 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6162 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6163 | PyObject* pyobj_val = NULL; |  | 6163 | PyObject* pyobj_val = NULL;
| 6164 | float val=0.f; |  | 6164 | float val=0.f;
| 6165 |  |  | 6165 |
| 6166 | const char* keywords[] = { "val", NULL }; |  | 6166 | const char* keywords[] = { "val", NULL };
| 6167 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementAlpha", (char**)keywords, &pyobj_val) && |  | 6167 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementAlpha", (char**)keywords, &pyobj_val) &&
| 6168 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6168 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6169 | { |  | 6169 | {
| 6170 | ERRWRAP2(_self_->setVariationalRefinementAlpha(val)); |  | 6170 | ERRWRAP2(_self_->setVariationalRefinementAlpha(val));
| 6171 | Py_RETURN_NONE; |  | 6171 | Py_RETURN_NONE;
| 6172 | } |  | 6172 | }
| 6173 |  |  | 6173 |
| 6174 | return NULL; |  | 6174 | return NULL;
| 6175 | } |  | 6175 | }
| 6176 |  |  | 6176 |
| 6177 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementDelta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6177 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementDelta(PyObject* self, PyObject* py_args, PyObject* kw)
| 6178 | { |  | 6178 | {
| 6179 | using namespace cv; |  | 6179 | using namespace cv;
| 6180 |  |  | 6180 |
| 6181 |  |  | 6181 |
| 6182 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6182 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6183 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6183 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6184 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6184 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6185 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6185 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6186 | PyObject* pyobj_val = NULL; |  | 6186 | PyObject* pyobj_val = NULL;
| 6187 | float val=0.f; |  | 6187 | float val=0.f;
| 6188 |  |  | 6188 |
| 6189 | const char* keywords[] = { "val", NULL }; |  | 6189 | const char* keywords[] = { "val", NULL };
| 6190 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementDelta", (char**)keywords, &pyobj_val) && |  | 6190 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementDelta", (char**)keywords, &pyobj_val) &&
| 6191 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6191 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6192 | { |  | 6192 | {
| 6193 | ERRWRAP2(_self_->setVariationalRefinementDelta(val)); |  | 6193 | ERRWRAP2(_self_->setVariationalRefinementDelta(val));
| 6194 | Py_RETURN_NONE; |  | 6194 | Py_RETURN_NONE;
| 6195 | } |  | 6195 | }
| 6196 |  |  | 6196 |
| 6197 | return NULL; |  | 6197 | return NULL;
| 6198 | } |  | 6198 | }
| 6199 |  |  | 6199 |
| 6200 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6200 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 6201 | { |  | 6201 | {
| 6202 | using namespace cv; |  | 6202 | using namespace cv;
| 6203 |  |  | 6203 |
| 6204 |  |  | 6204 |
| 6205 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6205 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6206 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6206 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6207 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6207 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6208 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6208 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6209 | PyObject* pyobj_val = NULL; |  | 6209 | PyObject* pyobj_val = NULL;
| 6210 | float val=0.f; |  | 6210 | float val=0.f;
| 6211 |  |  | 6211 |
| 6212 | const char* keywords[] = { "val", NULL }; |  | 6212 | const char* keywords[] = { "val", NULL };
| 6213 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementEpsilon", (char**)keywords, &pyobj_val) && |  | 6213 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementEpsilon", (char**)keywords, &pyobj_val) &&
| 6214 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6214 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6215 | { |  | 6215 | {
| 6216 | ERRWRAP2(_self_->setVariationalRefinementEpsilon(val)); |  | 6216 | ERRWRAP2(_self_->setVariationalRefinementEpsilon(val));
| 6217 | Py_RETURN_NONE; |  | 6217 | Py_RETURN_NONE;
| 6218 | } |  | 6218 | }
| 6219 |  |  | 6219 |
| 6220 | return NULL; |  | 6220 | return NULL;
| 6221 | } |  | 6221 | }
| 6222 |  |  | 6222 |
| 6223 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6223 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 6224 | { |  | 6224 | {
| 6225 | using namespace cv; |  | 6225 | using namespace cv;
| 6226 |  |  | 6226 |
| 6227 |  |  | 6227 |
| 6228 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6228 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6229 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6229 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6230 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6230 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6231 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6231 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6232 | PyObject* pyobj_val = NULL; |  | 6232 | PyObject* pyobj_val = NULL;
| 6233 | float val=0.f; |  | 6233 | float val=0.f;
| 6234 |  |  | 6234 |
| 6235 | const char* keywords[] = { "val", NULL }; |  | 6235 | const char* keywords[] = { "val", NULL };
| 6236 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementGamma", (char**)keywords, &pyobj_val) && |  | 6236 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementGamma", (char**)keywords, &pyobj_val) &&
| 6237 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6237 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6238 | { |  | 6238 | {
| 6239 | ERRWRAP2(_self_->setVariationalRefinementGamma(val)); |  | 6239 | ERRWRAP2(_self_->setVariationalRefinementGamma(val));
| 6240 | Py_RETURN_NONE; |  | 6240 | Py_RETURN_NONE;
| 6241 | } |  | 6241 | }
| 6242 |  |  | 6242 |
| 6243 | return NULL; |  | 6243 | return NULL;
| 6244 | } |  | 6244 | }
| 6245 |  |  | 6245 |
| 6246 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6246 | static PyObject* pyopencv_cv_DISOpticalFlow_setVariationalRefinementIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 6247 | { |  | 6247 | {
| 6248 | using namespace cv; |  | 6248 | using namespace cv;
| 6249 |  |  | 6249 |
| 6250 |  |  | 6250 |
| 6251 | Ptr<cv::DISOpticalFlow> * self1 = 0; |  | 6251 | Ptr<cv::DISOpticalFlow> * self1 = 0;
| 6252 | if (!pyopencv_DISOpticalFlow_getp(self, self1)) |  | 6252 | if (!pyopencv_DISOpticalFlow_getp(self, self1))
| 6253 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)"); |  | 6253 | return failmsgp("Incorrect type of self (must be 'DISOpticalFlow' or its derivative)");
| 6254 | Ptr<cv::DISOpticalFlow> _self_ = *(self1); |  | 6254 | Ptr<cv::DISOpticalFlow> _self_ = *(self1);
| 6255 | PyObject* pyobj_val = NULL; |  | 6255 | PyObject* pyobj_val = NULL;
| 6256 | int val=0; |  | 6256 | int val=0;
| 6257 |  |  | 6257 |
| 6258 | const char* keywords[] = { "val", NULL }; |  | 6258 | const char* keywords[] = { "val", NULL };
| 6259 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementIterations", (char**)keywords, &pyobj_val) && |  | 6259 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DISOpticalFlow.setVariationalRefinementIterations", (char**)keywords, &pyobj_val) &&
| 6260 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 6260 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 6261 | { |  | 6261 | {
| 6262 | ERRWRAP2(_self_->setVariationalRefinementIterations(val)); |  | 6262 | ERRWRAP2(_self_->setVariationalRefinementIterations(val));
| 6263 | Py_RETURN_NONE; |  | 6263 | Py_RETURN_NONE;
| 6264 | } |  | 6264 | }
| 6265 |  |  | 6265 |
| 6266 | return NULL; |  | 6266 | return NULL;
| 6267 | } |  | 6267 | }
| 6268 |  |  | 6268 |
| 6269 |  |  | 6269 |
| 6270 |  |  | 6270 |
| 6271 | // Tables (DISOpticalFlow) |  | 6271 | // Tables (DISOpticalFlow)
| 6272 |  |  | 6272 |
| 6273 | static PyGetSetDef pyopencv_DISOpticalFlow_getseters[] = |  | 6273 | static PyGetSetDef pyopencv_DISOpticalFlow_getseters[] =
| 6274 | { |  | 6274 | {
| 6275 | {NULL} /* Sentinel */ |  | 6275 | {NULL} /* Sentinel */
| 6276 | }; |  | 6276 | };
| 6277 |  |  | 6277 |
| 6278 | static PyMethodDef pyopencv_DISOpticalFlow_methods[] = |  | 6278 | static PyMethodDef pyopencv_DISOpticalFlow_methods[] =
| 6279 | { |  | 6279 | {
| 6280 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_create_static, METH_STATIC), "create([, preset]) -> retval\n. @brief Creates an instance of DISOpticalFlow\n. \n. @param preset one of PRESET_ULTRAFAST, PRESET_FAST and PRESET_MEDIUM"}, |  | 6280 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_create_static, METH_STATIC), "create([, preset]) -> retval\n. @brief Creates an instance of DISOpticalFlow\n. \n. @param preset one of PRESET_ULTRAFAST, PRESET_FAST and PRESET_MEDIUM"},
| 6281 | {"getFinestScale", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getFinestScale, 0), "getFinestScale() -> retval\n. @brief Finest level of the Gaussian pyramid on which the flow is computed (zero level\n. corresponds to the original image resolution). The final flow is obtained by bilinear upscaling.\n. @see setFinestScale"}, |  | 6281 | {"getFinestScale", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getFinestScale, 0), "getFinestScale() -> retval\n. @brief Finest level of the Gaussian pyramid on which the flow is computed (zero level\n. corresponds to the original image resolution). The final flow is obtained by bilinear upscaling.\n. @see setFinestScale"},
| 6282 | {"getGradientDescentIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getGradientDescentIterations, 0), "getGradientDescentIterations() -> retval\n. @brief Maximum number of gradient descent iterations in the patch inverse search stage. Higher values\n. may improve quality in some cases.\n. @see setGradientDescentIterations"}, |  | 6282 | {"getGradientDescentIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getGradientDescentIterations, 0), "getGradientDescentIterations() -> retval\n. @brief Maximum number of gradient descent iterations in the patch inverse search stage. Higher values\n. may improve quality in some cases.\n. @see setGradientDescentIterations"},
| 6283 | {"getPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getPatchSize, 0), "getPatchSize() -> retval\n. @brief Size of an image patch for matching (in pixels). Normally, default 8x8 patches work well\n. enough in most cases.\n. @see setPatchSize"}, |  | 6283 | {"getPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getPatchSize, 0), "getPatchSize() -> retval\n. @brief Size of an image patch for matching (in pixels). Normally, default 8x8 patches work well\n. enough in most cases.\n. @see setPatchSize"},
| 6284 | {"getPatchStride", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getPatchStride, 0), "getPatchStride() -> retval\n. @brief Stride between neighbor patches. Must be less than patch size. Lower values correspond\n. to higher flow quality.\n. @see setPatchStride"}, |  | 6284 | {"getPatchStride", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getPatchStride, 0), "getPatchStride() -> retval\n. @brief Stride between neighbor patches. Must be less than patch size. Lower values correspond\n. to higher flow quality.\n. @see setPatchStride"},
| 6285 | {"getUseMeanNormalization", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getUseMeanNormalization, 0), "getUseMeanNormalization() -> retval\n. @brief Whether to use mean-normalization of patches when computing patch distance. It is turned on\n. by default as it typically provides a noticeable quality boost because of increased robustness to\n. illumination variations. Turn it off if you are certain that your sequence doesn't contain any changes\n. in illumination.\n. @see setUseMeanNormalization"}, |  | 6285 | {"getUseMeanNormalization", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getUseMeanNormalization, 0), "getUseMeanNormalization() -> retval\n. @brief Whether to use mean-normalization of patches when computing patch distance. It is turned on\n. by default as it typically provides a noticeable quality boost because of increased robustness to\n. illumination variations. Turn it off if you are certain that your sequence doesn't contain any changes\n. in illumination.\n. @see setUseMeanNormalization"},
| 6286 | {"getUseSpatialPropagation", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getUseSpatialPropagation, 0), "getUseSpatialPropagation() -> retval\n. @brief Whether to use spatial propagation of good optical flow vectors. This option is turned on by\n. default, as it tends to work better on average and can sometimes help recover from major errors\n. introduced by the coarse-to-fine scheme employed by the DIS optical flow algorithm. Turning this\n. option off can make the output flow field a bit smoother, however.\n. @see setUseSpatialPropagation"}, |  | 6286 | {"getUseSpatialPropagation", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getUseSpatialPropagation, 0), "getUseSpatialPropagation() -> retval\n. @brief Whether to use spatial propagation of good optical flow vectors. This option is turned on by\n. default, as it tends to work better on average and can sometimes help recover from major errors\n. introduced by the coarse-to-fine scheme employed by the DIS optical flow algorithm. Turning this\n. option off can make the output flow field a bit smoother, however.\n. @see setUseSpatialPropagation"},
| 6287 | {"getVariationalRefinementAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementAlpha, 0), "getVariationalRefinementAlpha() -> retval\n. @brief Weight of the smoothness term\n. @see setVariationalRefinementAlpha"}, |  | 6287 | {"getVariationalRefinementAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementAlpha, 0), "getVariationalRefinementAlpha() -> retval\n. @brief Weight of the smoothness term\n. @see setVariationalRefinementAlpha"},
| 6288 | {"getVariationalRefinementDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementDelta, 0), "getVariationalRefinementDelta() -> retval\n. @brief Weight of the color constancy term\n. @see setVariationalRefinementDelta"}, |  | 6288 | {"getVariationalRefinementDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementDelta, 0), "getVariationalRefinementDelta() -> retval\n. @brief Weight of the color constancy term\n. @see setVariationalRefinementDelta"},
| 6289 | {"getVariationalRefinementEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementEpsilon, 0), "getVariationalRefinementEpsilon() -> retval\n. @brief Norm value shift for robust penalizer\n. @see setVariationalRefinementEpsilon"}, |  | 6289 | {"getVariationalRefinementEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementEpsilon, 0), "getVariationalRefinementEpsilon() -> retval\n. @brief Norm value shift for robust penalizer\n. @see setVariationalRefinementEpsilon"},
| 6290 | {"getVariationalRefinementGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementGamma, 0), "getVariationalRefinementGamma() -> retval\n. @brief Weight of the gradient constancy term\n. @see setVariationalRefinementGamma"}, |  | 6290 | {"getVariationalRefinementGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementGamma, 0), "getVariationalRefinementGamma() -> retval\n. @brief Weight of the gradient constancy term\n. @see setVariationalRefinementGamma"},
| 6291 | {"getVariationalRefinementIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementIterations, 0), "getVariationalRefinementIterations() -> retval\n. @brief Number of fixed point iterations of variational refinement per scale. Set to zero to\n. disable variational refinement completely. Higher values will typically result in more smooth and\n. high-quality flow.\n. @see setGradientDescentIterations"}, |  | 6291 | {"getVariationalRefinementIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_getVariationalRefinementIterations, 0), "getVariationalRefinementIterations() -> retval\n. @brief Number of fixed point iterations of variational refinement per scale. Set to zero to\n. disable variational refinement completely. Higher values will typically result in more smooth and\n. high-quality flow.\n. @see setGradientDescentIterations"},
| 6292 | {"setFinestScale", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setFinestScale, 0), "setFinestScale(val) -> None\n. @copybrief getFinestScale @see getFinestScale"}, |  | 6292 | {"setFinestScale", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setFinestScale, 0), "setFinestScale(val) -> None\n. @copybrief getFinestScale @see getFinestScale"},
| 6293 | {"setGradientDescentIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setGradientDescentIterations, 0), "setGradientDescentIterations(val) -> None\n. @copybrief getGradientDescentIterations @see getGradientDescentIterations"}, |  | 6293 | {"setGradientDescentIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setGradientDescentIterations, 0), "setGradientDescentIterations(val) -> None\n. @copybrief getGradientDescentIterations @see getGradientDescentIterations"},
| 6294 | {"setPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setPatchSize, 0), "setPatchSize(val) -> None\n. @copybrief getPatchSize @see getPatchSize"}, |  | 6294 | {"setPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setPatchSize, 0), "setPatchSize(val) -> None\n. @copybrief getPatchSize @see getPatchSize"},
| 6295 | {"setPatchStride", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setPatchStride, 0), "setPatchStride(val) -> None\n. @copybrief getPatchStride @see getPatchStride"}, |  | 6295 | {"setPatchStride", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setPatchStride, 0), "setPatchStride(val) -> None\n. @copybrief getPatchStride @see getPatchStride"},
| 6296 | {"setUseMeanNormalization", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setUseMeanNormalization, 0), "setUseMeanNormalization(val) -> None\n. @copybrief getUseMeanNormalization @see getUseMeanNormalization"}, |  | 6296 | {"setUseMeanNormalization", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setUseMeanNormalization, 0), "setUseMeanNormalization(val) -> None\n. @copybrief getUseMeanNormalization @see getUseMeanNormalization"},
| 6297 | {"setUseSpatialPropagation", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setUseSpatialPropagation, 0), "setUseSpatialPropagation(val) -> None\n. @copybrief getUseSpatialPropagation @see getUseSpatialPropagation"}, |  | 6297 | {"setUseSpatialPropagation", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setUseSpatialPropagation, 0), "setUseSpatialPropagation(val) -> None\n. @copybrief getUseSpatialPropagation @see getUseSpatialPropagation"},
| 6298 | {"setVariationalRefinementAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementAlpha, 0), "setVariationalRefinementAlpha(val) -> None\n. @copybrief getVariationalRefinementAlpha @see getVariationalRefinementAlpha"}, |  | 6298 | {"setVariationalRefinementAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementAlpha, 0), "setVariationalRefinementAlpha(val) -> None\n. @copybrief getVariationalRefinementAlpha @see getVariationalRefinementAlpha"},
| 6299 | {"setVariationalRefinementDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementDelta, 0), "setVariationalRefinementDelta(val) -> None\n. @copybrief getVariationalRefinementDelta @see getVariationalRefinementDelta"}, |  | 6299 | {"setVariationalRefinementDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementDelta, 0), "setVariationalRefinementDelta(val) -> None\n. @copybrief getVariationalRefinementDelta @see getVariationalRefinementDelta"},
| 6300 | {"setVariationalRefinementEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementEpsilon, 0), "setVariationalRefinementEpsilon(val) -> None\n. @copybrief getVariationalRefinementEpsilon @see getVariationalRefinementEpsilon"}, |  | 6300 | {"setVariationalRefinementEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementEpsilon, 0), "setVariationalRefinementEpsilon(val) -> None\n. @copybrief getVariationalRefinementEpsilon @see getVariationalRefinementEpsilon"},
| 6301 | {"setVariationalRefinementGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementGamma, 0), "setVariationalRefinementGamma(val) -> None\n. @copybrief getVariationalRefinementGamma @see getVariationalRefinementGamma"}, |  | 6301 | {"setVariationalRefinementGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementGamma, 0), "setVariationalRefinementGamma(val) -> None\n. @copybrief getVariationalRefinementGamma @see getVariationalRefinementGamma"},
| 6302 | {"setVariationalRefinementIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementIterations, 0), "setVariationalRefinementIterations(val) -> None\n. @copybrief getGradientDescentIterations @see getGradientDescentIterations"}, |  | 6302 | {"setVariationalRefinementIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_DISOpticalFlow_setVariationalRefinementIterations, 0), "setVariationalRefinementIterations(val) -> None\n. @copybrief getGradientDescentIterations @see getGradientDescentIterations"},
| 6303 |  |  | 6303 |
| 6304 | {NULL, NULL} |  | 6304 | {NULL, NULL}
| 6305 | }; |  | 6305 | };
| 6306 |  |  | 6306 |
| 6307 | // Converter (DISOpticalFlow) |  | 6307 | // Converter (DISOpticalFlow)
| 6308 |  |  | 6308 |
| 6309 | template<> |  | 6309 | template<>
| 6310 | struct PyOpenCV_Converter< Ptr<cv::DISOpticalFlow> > |  | 6310 | struct PyOpenCV_Converter< Ptr<cv::DISOpticalFlow> >
| 6311 | { |  | 6311 | {
| 6312 | static PyObject* from(const Ptr<cv::DISOpticalFlow>& r) |  | 6312 | static PyObject* from(const Ptr<cv::DISOpticalFlow>& r)
| 6313 | { |  | 6313 | {
| 6314 | return pyopencv_DISOpticalFlow_Instance(r); |  | 6314 | return pyopencv_DISOpticalFlow_Instance(r);
| 6315 | } |  | 6315 | }
| 6316 | static bool to(PyObject* src, Ptr<cv::DISOpticalFlow>& dst, const ArgInfo& info) |  | 6316 | static bool to(PyObject* src, Ptr<cv::DISOpticalFlow>& dst, const ArgInfo& info)
| 6317 | { |  | 6317 | {
| 6318 | if(!src || src == Py_None) |  | 6318 | if(!src || src == Py_None)
| 6319 | return true; |  | 6319 | return true;
| 6320 | Ptr<cv::DISOpticalFlow> * dst_; |  | 6320 | Ptr<cv::DISOpticalFlow> * dst_;
| 6321 | if (pyopencv_DISOpticalFlow_getp(src, dst_)) |  | 6321 | if (pyopencv_DISOpticalFlow_getp(src, dst_))
| 6322 | { |  | 6322 | {
| 6323 | dst = *dst_; |  | 6323 | dst = *dst_;
| 6324 | return true; |  | 6324 | return true;
| 6325 | } |  | 6325 | }
| 6326 |  |  | 6326 |
| 6327 | failmsg("Expected Ptr<cv::DISOpticalFlow> for argument '%s'", info.name); |  | 6327 | failmsg("Expected Ptr<cv::DISOpticalFlow> for argument '%s'", info.name);
| 6328 | return false; |  | 6328 | return false;
| 6329 | } |  | 6329 | }
| 6330 | }; |  | 6330 | };
| 6331 |  |  | 6331 |
| 6332 | //================================================================================ |  | 6332 | //================================================================================
| 6333 | // DMatch (Generic) |  | 6333 | // DMatch (Generic)
| 6334 | //================================================================================ |  | 6334 | //================================================================================
| 6335 |  |  | 6335 |
| 6336 | // GetSet (DMatch) |  | 6336 | // GetSet (DMatch)
| 6337 |  |  | 6337 |
| 6338 |  |  | 6338 |
| 6339 | static PyObject* pyopencv_DMatch_get_distance(pyopencv_DMatch_t* p, void *closure) |  | 6339 | static PyObject* pyopencv_DMatch_get_distance(pyopencv_DMatch_t* p, void *closure)
| 6340 | { |  | 6340 | {
| 6341 | return pyopencv_from(p->v.distance); |  | 6341 | return pyopencv_from(p->v.distance);
| 6342 | } |  | 6342 | }
| 6343 |  |  | 6343 |
| 6344 | static int pyopencv_DMatch_set_distance(pyopencv_DMatch_t* p, PyObject *value, void *closure) |  | 6344 | static int pyopencv_DMatch_set_distance(pyopencv_DMatch_t* p, PyObject *value, void *closure)
| 6345 | { |  | 6345 | {
| 6346 | if (!value) |  | 6346 | if (!value)
| 6347 | { |  | 6347 | {
| 6348 | PyErr_SetString(PyExc_TypeError, "Cannot delete the distance attribute"); |  | 6348 | PyErr_SetString(PyExc_TypeError, "Cannot delete the distance attribute");
| 6349 | return -1; |  | 6349 | return -1;
| 6350 | } |  | 6350 | }
| 6351 | return pyopencv_to_safe(value, p->v.distance, ArgInfo("value", 0)) ? 0 : -1; |  | 6351 | return pyopencv_to_safe(value, p->v.distance, ArgInfo("value", 0)) ? 0 : -1;
| 6352 | } |  | 6352 | }
| 6353 |  |  | 6353 |
| 6354 | static PyObject* pyopencv_DMatch_get_imgIdx(pyopencv_DMatch_t* p, void *closure) |  | 6354 | static PyObject* pyopencv_DMatch_get_imgIdx(pyopencv_DMatch_t* p, void *closure)
| 6355 | { |  | 6355 | {
| 6356 | return pyopencv_from(p->v.imgIdx); |  | 6356 | return pyopencv_from(p->v.imgIdx);
| 6357 | } |  | 6357 | }
| 6358 |  |  | 6358 |
| 6359 | static int pyopencv_DMatch_set_imgIdx(pyopencv_DMatch_t* p, PyObject *value, void *closure) |  | 6359 | static int pyopencv_DMatch_set_imgIdx(pyopencv_DMatch_t* p, PyObject *value, void *closure)
| 6360 | { |  | 6360 | {
| 6361 | if (!value) |  | 6361 | if (!value)
| 6362 | { |  | 6362 | {
| 6363 | PyErr_SetString(PyExc_TypeError, "Cannot delete the imgIdx attribute"); |  | 6363 | PyErr_SetString(PyExc_TypeError, "Cannot delete the imgIdx attribute");
| 6364 | return -1; |  | 6364 | return -1;
| 6365 | } |  | 6365 | }
| 6366 | return pyopencv_to_safe(value, p->v.imgIdx, ArgInfo("value", 0)) ? 0 : -1; |  | 6366 | return pyopencv_to_safe(value, p->v.imgIdx, ArgInfo("value", 0)) ? 0 : -1;
| 6367 | } |  | 6367 | }
| 6368 |  |  | 6368 |
| 6369 | static PyObject* pyopencv_DMatch_get_queryIdx(pyopencv_DMatch_t* p, void *closure) |  | 6369 | static PyObject* pyopencv_DMatch_get_queryIdx(pyopencv_DMatch_t* p, void *closure)
| 6370 | { |  | 6370 | {
| 6371 | return pyopencv_from(p->v.queryIdx); |  | 6371 | return pyopencv_from(p->v.queryIdx);
| 6372 | } |  | 6372 | }
| 6373 |  |  | 6373 |
| 6374 | static int pyopencv_DMatch_set_queryIdx(pyopencv_DMatch_t* p, PyObject *value, void *closure) |  | 6374 | static int pyopencv_DMatch_set_queryIdx(pyopencv_DMatch_t* p, PyObject *value, void *closure)
| 6375 | { |  | 6375 | {
| 6376 | if (!value) |  | 6376 | if (!value)
| 6377 | { |  | 6377 | {
| 6378 | PyErr_SetString(PyExc_TypeError, "Cannot delete the queryIdx attribute"); |  | 6378 | PyErr_SetString(PyExc_TypeError, "Cannot delete the queryIdx attribute");
| 6379 | return -1; |  | 6379 | return -1;
| 6380 | } |  | 6380 | }
| 6381 | return pyopencv_to_safe(value, p->v.queryIdx, ArgInfo("value", 0)) ? 0 : -1; |  | 6381 | return pyopencv_to_safe(value, p->v.queryIdx, ArgInfo("value", 0)) ? 0 : -1;
| 6382 | } |  | 6382 | }
| 6383 |  |  | 6383 |
| 6384 | static PyObject* pyopencv_DMatch_get_trainIdx(pyopencv_DMatch_t* p, void *closure) |  | 6384 | static PyObject* pyopencv_DMatch_get_trainIdx(pyopencv_DMatch_t* p, void *closure)
| 6385 | { |  | 6385 | {
| 6386 | return pyopencv_from(p->v.trainIdx); |  | 6386 | return pyopencv_from(p->v.trainIdx);
| 6387 | } |  | 6387 | }
| 6388 |  |  | 6388 |
| 6389 | static int pyopencv_DMatch_set_trainIdx(pyopencv_DMatch_t* p, PyObject *value, void *closure) |  | 6389 | static int pyopencv_DMatch_set_trainIdx(pyopencv_DMatch_t* p, PyObject *value, void *closure)
| 6390 | { |  | 6390 | {
| 6391 | if (!value) |  | 6391 | if (!value)
| 6392 | { |  | 6392 | {
| 6393 | PyErr_SetString(PyExc_TypeError, "Cannot delete the trainIdx attribute"); |  | 6393 | PyErr_SetString(PyExc_TypeError, "Cannot delete the trainIdx attribute");
| 6394 | return -1; |  | 6394 | return -1;
| 6395 | } |  | 6395 | }
| 6396 | return pyopencv_to_safe(value, p->v.trainIdx, ArgInfo("value", 0)) ? 0 : -1; |  | 6396 | return pyopencv_to_safe(value, p->v.trainIdx, ArgInfo("value", 0)) ? 0 : -1;
| 6397 | } |  | 6397 | }
| 6398 |  |  | 6398 |
| 6399 |  |  | 6399 |
| 6400 | // Methods (DMatch) |  | 6400 | // Methods (DMatch)
| 6401 |  |  | 6401 |
| 6402 | static int pyopencv_cv_DMatch_DMatch(pyopencv_DMatch_t* self, PyObject* py_args, PyObject* kw) |  | 6402 | static int pyopencv_cv_DMatch_DMatch(pyopencv_DMatch_t* self, PyObject* py_args, PyObject* kw)
| 6403 | { |  | 6403 | {
| 6404 | using namespace cv; |  | 6404 | using namespace cv;
| 6405 |  |  | 6405 |
| 6406 | pyPrepareArgumentConversionErrorsStorage(3); |  | 6406 | pyPrepareArgumentConversionErrorsStorage(3);
| 6407 |  |  | 6407 |
| 6408 | { |  | 6408 | {
| 6409 |  |  | 6409 |
| 6410 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 6410 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 6411 | { |  | 6411 | {
| 6412 | if(self) ERRWRAP2(new (&(self->v)) cv::DMatch()); |  | 6412 | if(self) ERRWRAP2(new (&(self->v)) cv::DMatch());
| 6413 | return 0; |  | 6413 | return 0;
| 6414 | } |  | 6414 | }
| 6415 |  |  | 6415 |
| 6416 |  |  | 6416 |
| 6417 | pyPopulateArgumentConversionErrors(); |  | 6417 | pyPopulateArgumentConversionErrors();
| 6418 | } |  | 6418 | }
| 6419 |  |  | 6419 |
| 6420 |  |  | 6420 |
| 6421 | { |  | 6421 | {
| 6422 | PyObject* pyobj__queryIdx = NULL; |  | 6422 | PyObject* pyobj__queryIdx = NULL;
| 6423 | int _queryIdx=0; |  | 6423 | int _queryIdx=0;
| 6424 | PyObject* pyobj__trainIdx = NULL; |  | 6424 | PyObject* pyobj__trainIdx = NULL;
| 6425 | int _trainIdx=0; |  | 6425 | int _trainIdx=0;
| 6426 | PyObject* pyobj__distance = NULL; |  | 6426 | PyObject* pyobj__distance = NULL;
| 6427 | float _distance=0.f; |  | 6427 | float _distance=0.f;
| 6428 |  |  | 6428 |
| 6429 | const char* keywords[] = { "_queryIdx", "_trainIdx", "_distance", NULL }; |  | 6429 | const char* keywords[] = { "_queryIdx", "_trainIdx", "_distance", NULL };
| 6430 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:DMatch", (char**)keywords, &pyobj__queryIdx, &pyobj__trainIdx, &pyobj__distance) && |  | 6430 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:DMatch", (char**)keywords, &pyobj__queryIdx, &pyobj__trainIdx, &pyobj__distance) &&
| 6431 | pyopencv_to_safe(pyobj__queryIdx, _queryIdx, ArgInfo("_queryIdx", 0)) && |  | 6431 | pyopencv_to_safe(pyobj__queryIdx, _queryIdx, ArgInfo("_queryIdx", 0)) &&
| 6432 | pyopencv_to_safe(pyobj__trainIdx, _trainIdx, ArgInfo("_trainIdx", 0)) && |  | 6432 | pyopencv_to_safe(pyobj__trainIdx, _trainIdx, ArgInfo("_trainIdx", 0)) &&
| 6433 | pyopencv_to_safe(pyobj__distance, _distance, ArgInfo("_distance", 0)) ) |  | 6433 | pyopencv_to_safe(pyobj__distance, _distance, ArgInfo("_distance", 0)) )
| 6434 | { |  | 6434 | {
| 6435 | if(self) ERRWRAP2(new (&(self->v)) cv::DMatch(_queryIdx, _trainIdx, _distance)); |  | 6435 | if(self) ERRWRAP2(new (&(self->v)) cv::DMatch(_queryIdx, _trainIdx, _distance));
| 6436 | return 0; |  | 6436 | return 0;
| 6437 | } |  | 6437 | }
| 6438 |  |  | 6438 |
| 6439 |  |  | 6439 |
| 6440 | pyPopulateArgumentConversionErrors(); |  | 6440 | pyPopulateArgumentConversionErrors();
| 6441 | } |  | 6441 | }
| 6442 |  |  | 6442 |
| 6443 |  |  | 6443 |
| 6444 | { |  | 6444 | {
| 6445 | PyObject* pyobj__queryIdx = NULL; |  | 6445 | PyObject* pyobj__queryIdx = NULL;
| 6446 | int _queryIdx=0; |  | 6446 | int _queryIdx=0;
| 6447 | PyObject* pyobj__trainIdx = NULL; |  | 6447 | PyObject* pyobj__trainIdx = NULL;
| 6448 | int _trainIdx=0; |  | 6448 | int _trainIdx=0;
| 6449 | PyObject* pyobj__imgIdx = NULL; |  | 6449 | PyObject* pyobj__imgIdx = NULL;
| 6450 | int _imgIdx=0; |  | 6450 | int _imgIdx=0;
| 6451 | PyObject* pyobj__distance = NULL; |  | 6451 | PyObject* pyobj__distance = NULL;
| 6452 | float _distance=0.f; |  | 6452 | float _distance=0.f;
| 6453 |  |  | 6453 |
| 6454 | const char* keywords[] = { "_queryIdx", "_trainIdx", "_imgIdx", "_distance", NULL }; |  | 6454 | const char* keywords[] = { "_queryIdx", "_trainIdx", "_imgIdx", "_distance", NULL };
| 6455 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:DMatch", (char**)keywords, &pyobj__queryIdx, &pyobj__trainIdx, &pyobj__imgIdx, &pyobj__distance) && |  | 6455 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:DMatch", (char**)keywords, &pyobj__queryIdx, &pyobj__trainIdx, &pyobj__imgIdx, &pyobj__distance) &&
| 6456 | pyopencv_to_safe(pyobj__queryIdx, _queryIdx, ArgInfo("_queryIdx", 0)) && |  | 6456 | pyopencv_to_safe(pyobj__queryIdx, _queryIdx, ArgInfo("_queryIdx", 0)) &&
| 6457 | pyopencv_to_safe(pyobj__trainIdx, _trainIdx, ArgInfo("_trainIdx", 0)) && |  | 6457 | pyopencv_to_safe(pyobj__trainIdx, _trainIdx, ArgInfo("_trainIdx", 0)) &&
| 6458 | pyopencv_to_safe(pyobj__imgIdx, _imgIdx, ArgInfo("_imgIdx", 0)) && |  | 6458 | pyopencv_to_safe(pyobj__imgIdx, _imgIdx, ArgInfo("_imgIdx", 0)) &&
| 6459 | pyopencv_to_safe(pyobj__distance, _distance, ArgInfo("_distance", 0)) ) |  | 6459 | pyopencv_to_safe(pyobj__distance, _distance, ArgInfo("_distance", 0)) )
| 6460 | { |  | 6460 | {
| 6461 | if(self) ERRWRAP2(new (&(self->v)) cv::DMatch(_queryIdx, _trainIdx, _imgIdx, _distance)); |  | 6461 | if(self) ERRWRAP2(new (&(self->v)) cv::DMatch(_queryIdx, _trainIdx, _imgIdx, _distance));
| 6462 | return 0; |  | 6462 | return 0;
| 6463 | } |  | 6463 | }
| 6464 |  |  | 6464 |
| 6465 |  |  | 6465 |
| 6466 | pyPopulateArgumentConversionErrors(); |  | 6466 | pyPopulateArgumentConversionErrors();
| 6467 | } |  | 6467 | }
| 6468 | pyRaiseCVOverloadException("DMatch"); |  | 6468 | pyRaiseCVOverloadException("DMatch");
| 6469 |  |  | 6469 |
| 6470 | return -1; |  | 6470 | return -1;
| 6471 | } |  | 6471 | }
| 6472 |  |  | 6472 |
| 6473 |  |  | 6473 |
| 6474 |  |  | 6474 |
| 6475 | // Tables (DMatch) |  | 6475 | // Tables (DMatch)
| 6476 |  |  | 6476 |
| 6477 | static PyGetSetDef pyopencv_DMatch_getseters[] = |  | 6477 | static PyGetSetDef pyopencv_DMatch_getseters[] =
| 6478 | { |  | 6478 | {
| 6479 | {(char*)"distance", (getter)pyopencv_DMatch_get_distance, (setter)pyopencv_DMatch_set_distance, (char*)"distance", NULL}, |  | 6479 | {(char*)"distance", (getter)pyopencv_DMatch_get_distance, (setter)pyopencv_DMatch_set_distance, (char*)"distance", NULL},
| 6480 | {(char*)"imgIdx", (getter)pyopencv_DMatch_get_imgIdx, (setter)pyopencv_DMatch_set_imgIdx, (char*)"imgIdx", NULL}, |  | 6480 | {(char*)"imgIdx", (getter)pyopencv_DMatch_get_imgIdx, (setter)pyopencv_DMatch_set_imgIdx, (char*)"imgIdx", NULL},
| 6481 | {(char*)"queryIdx", (getter)pyopencv_DMatch_get_queryIdx, (setter)pyopencv_DMatch_set_queryIdx, (char*)"queryIdx", NULL}, |  | 6481 | {(char*)"queryIdx", (getter)pyopencv_DMatch_get_queryIdx, (setter)pyopencv_DMatch_set_queryIdx, (char*)"queryIdx", NULL},
| 6482 | {(char*)"trainIdx", (getter)pyopencv_DMatch_get_trainIdx, (setter)pyopencv_DMatch_set_trainIdx, (char*)"trainIdx", NULL}, |  | 6482 | {(char*)"trainIdx", (getter)pyopencv_DMatch_get_trainIdx, (setter)pyopencv_DMatch_set_trainIdx, (char*)"trainIdx", NULL},
| 6483 | {NULL} /* Sentinel */ |  | 6483 | {NULL} /* Sentinel */
| 6484 | }; |  | 6484 | };
| 6485 |  |  | 6485 |
| 6486 | static PyMethodDef pyopencv_DMatch_methods[] = |  | 6486 | static PyMethodDef pyopencv_DMatch_methods[] =
| 6487 | { |  | 6487 | {
| 6488 |  |  | 6488 |
| 6489 | {NULL, NULL} |  | 6489 | {NULL, NULL}
| 6490 | }; |  | 6490 | };
| 6491 |  |  | 6491 |
| 6492 | // Converter (DMatch) |  | 6492 | // Converter (DMatch)
| 6493 |  |  | 6493 |
| 6494 | template<> |  | 6494 | template<>
| 6495 | struct PyOpenCV_Converter< cv::DMatch > |  | 6495 | struct PyOpenCV_Converter< cv::DMatch >
| 6496 | { |  | 6496 | {
| 6497 | static PyObject* from(const cv::DMatch& r) |  | 6497 | static PyObject* from(const cv::DMatch& r)
| 6498 | { |  | 6498 | {
| 6499 | return pyopencv_DMatch_Instance(r); |  | 6499 | return pyopencv_DMatch_Instance(r);
| 6500 | } |  | 6500 | }
| 6501 | static bool to(PyObject* src, cv::DMatch& dst, const ArgInfo& info) |  | 6501 | static bool to(PyObject* src, cv::DMatch& dst, const ArgInfo& info)
| 6502 | { |  | 6502 | {
| 6503 | if(!src || src == Py_None) |  | 6503 | if(!src || src == Py_None)
| 6504 | return true; |  | 6504 | return true;
| 6505 | cv::DMatch * dst_; |  | 6505 | cv::DMatch * dst_;
| 6506 | if (pyopencv_DMatch_getp(src, dst_)) |  | 6506 | if (pyopencv_DMatch_getp(src, dst_))
| 6507 | { |  | 6507 | {
| 6508 | dst = *dst_; |  | 6508 | dst = *dst_;
| 6509 | return true; |  | 6509 | return true;
| 6510 | } |  | 6510 | }
| 6511 |  |  | 6511 |
| 6512 | failmsg("Expected cv::DMatch for argument '%s'", info.name); |  | 6512 | failmsg("Expected cv::DMatch for argument '%s'", info.name);
| 6513 | return false; |  | 6513 | return false;
| 6514 | } |  | 6514 | }
| 6515 | }; |  | 6515 | };
| 6516 |  |  | 6516 |
| 6517 | //================================================================================ |  | 6517 | //================================================================================
| 6518 | // DenseOpticalFlow (Generic) |  | 6518 | // DenseOpticalFlow (Generic)
| 6519 | //================================================================================ |  | 6519 | //================================================================================
| 6520 |  |  | 6520 |
| 6521 | // GetSet (DenseOpticalFlow) |  | 6521 | // GetSet (DenseOpticalFlow)
| 6522 |  |  | 6522 |
| 6523 |  |  | 6523 |
| 6524 |  |  | 6524 |
| 6525 | // Methods (DenseOpticalFlow) |  | 6525 | // Methods (DenseOpticalFlow)
| 6526 |  |  | 6526 |
| 6527 | static PyObject* pyopencv_cv_DenseOpticalFlow_calc(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6527 | static PyObject* pyopencv_cv_DenseOpticalFlow_calc(PyObject* self, PyObject* py_args, PyObject* kw)
| 6528 | { |  | 6528 | {
| 6529 | using namespace cv; |  | 6529 | using namespace cv;
| 6530 |  |  | 6530 |
| 6531 |  |  | 6531 |
| 6532 | Ptr<cv::DenseOpticalFlow> * self1 = 0; |  | 6532 | Ptr<cv::DenseOpticalFlow> * self1 = 0;
| 6533 | if (!pyopencv_DenseOpticalFlow_getp(self, self1)) |  | 6533 | if (!pyopencv_DenseOpticalFlow_getp(self, self1))
| 6534 | return failmsgp("Incorrect type of self (must be 'DenseOpticalFlow' or its derivative)"); |  | 6534 | return failmsgp("Incorrect type of self (must be 'DenseOpticalFlow' or its derivative)");
| 6535 | Ptr<cv::DenseOpticalFlow> _self_ = *(self1); |  | 6535 | Ptr<cv::DenseOpticalFlow> _self_ = *(self1);
| 6536 | pyPrepareArgumentConversionErrorsStorage(2); |  | 6536 | pyPrepareArgumentConversionErrorsStorage(2);
| 6537 |  |  | 6537 |
| 6538 | { |  | 6538 | {
| 6539 | PyObject* pyobj_I0 = NULL; |  | 6539 | PyObject* pyobj_I0 = NULL;
| 6540 | Mat I0; |  | 6540 | Mat I0;
| 6541 | PyObject* pyobj_I1 = NULL; |  | 6541 | PyObject* pyobj_I1 = NULL;
| 6542 | Mat I1; |  | 6542 | Mat I1;
| 6543 | PyObject* pyobj_flow = NULL; |  | 6543 | PyObject* pyobj_flow = NULL;
| 6544 | Mat flow; |  | 6544 | Mat flow;
| 6545 |  |  | 6545 |
| 6546 | const char* keywords[] = { "I0", "I1", "flow", NULL }; |  | 6546 | const char* keywords[] = { "I0", "I1", "flow", NULL };
| 6547 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:DenseOpticalFlow.calc", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow) && |  | 6547 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:DenseOpticalFlow.calc", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow) &&
| 6548 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) && |  | 6548 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) &&
| 6549 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) && |  | 6549 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) &&
| 6550 | pyopencv_to_safe(pyobj_flow, flow, ArgInfo("flow", 1)) ) |  | 6550 | pyopencv_to_safe(pyobj_flow, flow, ArgInfo("flow", 1)) )
| 6551 | { |  | 6551 | {
| 6552 | ERRWRAP2(_self_->calc(I0, I1, flow)); |  | 6552 | ERRWRAP2(_self_->calc(I0, I1, flow));
| 6553 | return pyopencv_from(flow); |  | 6553 | return pyopencv_from(flow);
| 6554 | } |  | 6554 | }
| 6555 |  |  | 6555 |
| 6556 |  |  | 6556 |
| 6557 | pyPopulateArgumentConversionErrors(); |  | 6557 | pyPopulateArgumentConversionErrors();
| 6558 | } |  | 6558 | }
| 6559 |  |  | 6559 |
| 6560 |  |  | 6560 |
| 6561 | { |  | 6561 | {
| 6562 | PyObject* pyobj_I0 = NULL; |  | 6562 | PyObject* pyobj_I0 = NULL;
| 6563 | UMat I0; |  | 6563 | UMat I0;
| 6564 | PyObject* pyobj_I1 = NULL; |  | 6564 | PyObject* pyobj_I1 = NULL;
| 6565 | UMat I1; |  | 6565 | UMat I1;
| 6566 | PyObject* pyobj_flow = NULL; |  | 6566 | PyObject* pyobj_flow = NULL;
| 6567 | UMat flow; |  | 6567 | UMat flow;
| 6568 |  |  | 6568 |
| 6569 | const char* keywords[] = { "I0", "I1", "flow", NULL }; |  | 6569 | const char* keywords[] = { "I0", "I1", "flow", NULL };
| 6570 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:DenseOpticalFlow.calc", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow) && |  | 6570 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:DenseOpticalFlow.calc", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow) &&
| 6571 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) && |  | 6571 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) &&
| 6572 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) && |  | 6572 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) &&
| 6573 | pyopencv_to_safe(pyobj_flow, flow, ArgInfo("flow", 1)) ) |  | 6573 | pyopencv_to_safe(pyobj_flow, flow, ArgInfo("flow", 1)) )
| 6574 | { |  | 6574 | {
| 6575 | ERRWRAP2(_self_->calc(I0, I1, flow)); |  | 6575 | ERRWRAP2(_self_->calc(I0, I1, flow));
| 6576 | return pyopencv_from(flow); |  | 6576 | return pyopencv_from(flow);
| 6577 | } |  | 6577 | }
| 6578 |  |  | 6578 |
| 6579 |  |  | 6579 |
| 6580 | pyPopulateArgumentConversionErrors(); |  | 6580 | pyPopulateArgumentConversionErrors();
| 6581 | } |  | 6581 | }
| 6582 | pyRaiseCVOverloadException("calc"); |  | 6582 | pyRaiseCVOverloadException("calc");
| 6583 |  |  | 6583 |
| 6584 | return NULL; |  | 6584 | return NULL;
| 6585 | } |  | 6585 | }
| 6586 |  |  | 6586 |
| 6587 | static PyObject* pyopencv_cv_DenseOpticalFlow_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6587 | static PyObject* pyopencv_cv_DenseOpticalFlow_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw)
| 6588 | { |  | 6588 | {
| 6589 | using namespace cv; |  | 6589 | using namespace cv;
| 6590 |  |  | 6590 |
| 6591 |  |  | 6591 |
| 6592 | Ptr<cv::DenseOpticalFlow> * self1 = 0; |  | 6592 | Ptr<cv::DenseOpticalFlow> * self1 = 0;
| 6593 | if (!pyopencv_DenseOpticalFlow_getp(self, self1)) |  | 6593 | if (!pyopencv_DenseOpticalFlow_getp(self, self1))
| 6594 | return failmsgp("Incorrect type of self (must be 'DenseOpticalFlow' or its derivative)"); |  | 6594 | return failmsgp("Incorrect type of self (must be 'DenseOpticalFlow' or its derivative)");
| 6595 | Ptr<cv::DenseOpticalFlow> _self_ = *(self1); |  | 6595 | Ptr<cv::DenseOpticalFlow> _self_ = *(self1);
| 6596 |  |  | 6596 |
| 6597 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 6597 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 6598 | { |  | 6598 | {
| 6599 | ERRWRAP2(_self_->collectGarbage()); |  | 6599 | ERRWRAP2(_self_->collectGarbage());
| 6600 | Py_RETURN_NONE; |  | 6600 | Py_RETURN_NONE;
| 6601 | } |  | 6601 | }
| 6602 |  |  | 6602 |
| 6603 | return NULL; |  | 6603 | return NULL;
| 6604 | } |  | 6604 | }
| 6605 |  |  | 6605 |
| 6606 |  |  | 6606 |
| 6607 |  |  | 6607 |
| 6608 | // Tables (DenseOpticalFlow) |  | 6608 | // Tables (DenseOpticalFlow)
| 6609 |  |  | 6609 |
| 6610 | static PyGetSetDef pyopencv_DenseOpticalFlow_getseters[] = |  | 6610 | static PyGetSetDef pyopencv_DenseOpticalFlow_getseters[] =
| 6611 | { |  | 6611 | {
| 6612 | {NULL} /* Sentinel */ |  | 6612 | {NULL} /* Sentinel */
| 6613 | }; |  | 6613 | };
| 6614 |  |  | 6614 |
| 6615 | static PyMethodDef pyopencv_DenseOpticalFlow_methods[] = |  | 6615 | static PyMethodDef pyopencv_DenseOpticalFlow_methods[] =
| 6616 | { |  | 6616 | {
| 6617 | {"calc", CV_PY_FN_WITH_KW_(pyopencv_cv_DenseOpticalFlow_calc, 0), "calc(I0, I1, flow) -> flow\n. @brief Calculates an optical flow.\n. \n. @param I0 first 8-bit single-channel input image.\n. @param I1 second input image of the same size and the same type as prev.\n. @param flow computed flow image that has the same size as prev and type CV_32FC2."}, |  | 6617 | {"calc", CV_PY_FN_WITH_KW_(pyopencv_cv_DenseOpticalFlow_calc, 0), "calc(I0, I1, flow) -> flow\n. @brief Calculates an optical flow.\n. \n. @param I0 first 8-bit single-channel input image.\n. @param I1 second input image of the same size and the same type as prev.\n. @param flow computed flow image that has the same size as prev and type CV_32FC2."},
| 6618 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_DenseOpticalFlow_collectGarbage, 0), "collectGarbage() -> None\n. @brief Releases all inner buffers."}, |  | 6618 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_DenseOpticalFlow_collectGarbage, 0), "collectGarbage() -> None\n. @brief Releases all inner buffers."},
| 6619 |  |  | 6619 |
| 6620 | {NULL, NULL} |  | 6620 | {NULL, NULL}
| 6621 | }; |  | 6621 | };
| 6622 |  |  | 6622 |
| 6623 | // Converter (DenseOpticalFlow) |  | 6623 | // Converter (DenseOpticalFlow)
| 6624 |  |  | 6624 |
| 6625 | template<> |  | 6625 | template<>
| 6626 | struct PyOpenCV_Converter< Ptr<cv::DenseOpticalFlow> > |  | 6626 | struct PyOpenCV_Converter< Ptr<cv::DenseOpticalFlow> >
| 6627 | { |  | 6627 | {
| 6628 | static PyObject* from(const Ptr<cv::DenseOpticalFlow>& r) |  | 6628 | static PyObject* from(const Ptr<cv::DenseOpticalFlow>& r)
| 6629 | { |  | 6629 | {
| 6630 | return pyopencv_DenseOpticalFlow_Instance(r); |  | 6630 | return pyopencv_DenseOpticalFlow_Instance(r);
| 6631 | } |  | 6631 | }
| 6632 | static bool to(PyObject* src, Ptr<cv::DenseOpticalFlow>& dst, const ArgInfo& info) |  | 6632 | static bool to(PyObject* src, Ptr<cv::DenseOpticalFlow>& dst, const ArgInfo& info)
| 6633 | { |  | 6633 | {
| 6634 | if(!src || src == Py_None) |  | 6634 | if(!src || src == Py_None)
| 6635 | return true; |  | 6635 | return true;
| 6636 | Ptr<cv::DenseOpticalFlow> * dst_; |  | 6636 | Ptr<cv::DenseOpticalFlow> * dst_;
| 6637 | if (pyopencv_DenseOpticalFlow_getp(src, dst_)) |  | 6637 | if (pyopencv_DenseOpticalFlow_getp(src, dst_))
| 6638 | { |  | 6638 | {
| 6639 | dst = *dst_; |  | 6639 | dst = *dst_;
| 6640 | return true; |  | 6640 | return true;
| 6641 | } |  | 6641 | }
| 6642 |  |  | 6642 |
| 6643 | failmsg("Expected Ptr<cv::DenseOpticalFlow> for argument '%s'", info.name); |  | 6643 | failmsg("Expected Ptr<cv::DenseOpticalFlow> for argument '%s'", info.name);
| 6644 | return false; |  | 6644 | return false;
| 6645 | } |  | 6645 | }
| 6646 | }; |  | 6646 | };
| 6647 |  |  | 6647 |
| 6648 | //================================================================================ |  | 6648 | //================================================================================
| 6649 | // DescriptorMatcher (Generic) |  | 6649 | // DescriptorMatcher (Generic)
| 6650 | //================================================================================ |  | 6650 | //================================================================================
| 6651 |  |  | 6651 |
| 6652 | // GetSet (DescriptorMatcher) |  | 6652 | // GetSet (DescriptorMatcher)
| 6653 |  |  | 6653 |
| 6654 |  |  | 6654 |
| 6655 |  |  | 6655 |
| 6656 | // Methods (DescriptorMatcher) |  | 6656 | // Methods (DescriptorMatcher)
| 6657 |  |  | 6657 |
| 6658 | static PyObject* pyopencv_cv_DescriptorMatcher_add(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6658 | static PyObject* pyopencv_cv_DescriptorMatcher_add(PyObject* self, PyObject* py_args, PyObject* kw)
| 6659 | { |  | 6659 | {
| 6660 | using namespace cv; |  | 6660 | using namespace cv;
| 6661 |  |  | 6661 |
| 6662 |  |  | 6662 |
| 6663 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6663 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6664 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6664 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6665 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6665 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6666 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6666 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6667 | pyPrepareArgumentConversionErrorsStorage(2); |  | 6667 | pyPrepareArgumentConversionErrorsStorage(2);
| 6668 |  |  | 6668 |
| 6669 | { |  | 6669 | {
| 6670 | PyObject* pyobj_descriptors = NULL; |  | 6670 | PyObject* pyobj_descriptors = NULL;
| 6671 | vector_Mat descriptors; |  | 6671 | vector_Mat descriptors;
| 6672 |  |  | 6672 |
| 6673 | const char* keywords[] = { "descriptors", NULL }; |  | 6673 | const char* keywords[] = { "descriptors", NULL };
| 6674 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.add", (char**)keywords, &pyobj_descriptors) && |  | 6674 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.add", (char**)keywords, &pyobj_descriptors) &&
| 6675 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) ) |  | 6675 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) )
| 6676 | { |  | 6676 | {
| 6677 | ERRWRAP2(_self_->add(descriptors)); |  | 6677 | ERRWRAP2(_self_->add(descriptors));
| 6678 | Py_RETURN_NONE; |  | 6678 | Py_RETURN_NONE;
| 6679 | } |  | 6679 | }
| 6680 |  |  | 6680 |
| 6681 |  |  | 6681 |
| 6682 | pyPopulateArgumentConversionErrors(); |  | 6682 | pyPopulateArgumentConversionErrors();
| 6683 | } |  | 6683 | }
| 6684 |  |  | 6684 |
| 6685 |  |  | 6685 |
| 6686 | { |  | 6686 | {
| 6687 | PyObject* pyobj_descriptors = NULL; |  | 6687 | PyObject* pyobj_descriptors = NULL;
| 6688 | vector_UMat descriptors; |  | 6688 | vector_UMat descriptors;
| 6689 |  |  | 6689 |
| 6690 | const char* keywords[] = { "descriptors", NULL }; |  | 6690 | const char* keywords[] = { "descriptors", NULL };
| 6691 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.add", (char**)keywords, &pyobj_descriptors) && |  | 6691 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.add", (char**)keywords, &pyobj_descriptors) &&
| 6692 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) ) |  | 6692 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 0)) )
| 6693 | { |  | 6693 | {
| 6694 | ERRWRAP2(_self_->add(descriptors)); |  | 6694 | ERRWRAP2(_self_->add(descriptors));
| 6695 | Py_RETURN_NONE; |  | 6695 | Py_RETURN_NONE;
| 6696 | } |  | 6696 | }
| 6697 |  |  | 6697 |
| 6698 |  |  | 6698 |
| 6699 | pyPopulateArgumentConversionErrors(); |  | 6699 | pyPopulateArgumentConversionErrors();
| 6700 | } |  | 6700 | }
| 6701 | pyRaiseCVOverloadException("add"); |  | 6701 | pyRaiseCVOverloadException("add");
| 6702 |  |  | 6702 |
| 6703 | return NULL; |  | 6703 | return NULL;
| 6704 | } |  | 6704 | }
| 6705 |  |  | 6705 |
| 6706 | static PyObject* pyopencv_cv_DescriptorMatcher_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6706 | static PyObject* pyopencv_cv_DescriptorMatcher_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 6707 | { |  | 6707 | {
| 6708 | using namespace cv; |  | 6708 | using namespace cv;
| 6709 |  |  | 6709 |
| 6710 |  |  | 6710 |
| 6711 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6711 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6712 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6712 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6713 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6713 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6714 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6714 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6715 |  |  | 6715 |
| 6716 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 6716 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 6717 | { |  | 6717 | {
| 6718 | ERRWRAP2(_self_->clear()); |  | 6718 | ERRWRAP2(_self_->clear());
| 6719 | Py_RETURN_NONE; |  | 6719 | Py_RETURN_NONE;
| 6720 | } |  | 6720 | }
| 6721 |  |  | 6721 |
| 6722 | return NULL; |  | 6722 | return NULL;
| 6723 | } |  | 6723 | }
| 6724 |  |  | 6724 |
| 6725 | static PyObject* pyopencv_cv_DescriptorMatcher_clone(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6725 | static PyObject* pyopencv_cv_DescriptorMatcher_clone(PyObject* self, PyObject* py_args, PyObject* kw)
| 6726 | { |  | 6726 | {
| 6727 | using namespace cv; |  | 6727 | using namespace cv;
| 6728 |  |  | 6728 |
| 6729 |  |  | 6729 |
| 6730 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6730 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6731 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6731 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6732 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6732 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6733 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6733 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6734 | PyObject* pyobj_emptyTrainData = NULL; |  | 6734 | PyObject* pyobj_emptyTrainData = NULL;
| 6735 | bool emptyTrainData=false; |  | 6735 | bool emptyTrainData=false;
| 6736 | Ptr<DescriptorMatcher> retval; |  | 6736 | Ptr<DescriptorMatcher> retval;
| 6737 |  |  | 6737 |
| 6738 | const char* keywords[] = { "emptyTrainData", NULL }; |  | 6738 | const char* keywords[] = { "emptyTrainData", NULL };
| 6739 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:DescriptorMatcher.clone", (char**)keywords, &pyobj_emptyTrainData) && |  | 6739 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:DescriptorMatcher.clone", (char**)keywords, &pyobj_emptyTrainData) &&
| 6740 | pyopencv_to_safe(pyobj_emptyTrainData, emptyTrainData, ArgInfo("emptyTrainData", 0)) ) |  | 6740 | pyopencv_to_safe(pyobj_emptyTrainData, emptyTrainData, ArgInfo("emptyTrainData", 0)) )
| 6741 | { |  | 6741 | {
| 6742 | ERRWRAP2(retval = _self_->clone(emptyTrainData)); |  | 6742 | ERRWRAP2(retval = _self_->clone(emptyTrainData));
| 6743 | return pyopencv_from(retval); |  | 6743 | return pyopencv_from(retval);
| 6744 | } |  | 6744 | }
| 6745 |  |  | 6745 |
| 6746 | return NULL; |  | 6746 | return NULL;
| 6747 | } |  | 6747 | }
| 6748 |  |  | 6748 |
| 6749 | static PyObject* pyopencv_cv_DescriptorMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6749 | static PyObject* pyopencv_cv_DescriptorMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 6750 | { |  | 6750 | {
| 6751 | using namespace cv; |  | 6751 | using namespace cv;
| 6752 |  |  | 6752 |
| 6753 | pyPrepareArgumentConversionErrorsStorage(2); |  | 6753 | pyPrepareArgumentConversionErrorsStorage(2);
| 6754 |  |  | 6754 |
| 6755 | { |  | 6755 | {
| 6756 | PyObject* pyobj_descriptorMatcherType = NULL; |  | 6756 | PyObject* pyobj_descriptorMatcherType = NULL;
| 6757 | String descriptorMatcherType; |  | 6757 | String descriptorMatcherType;
| 6758 | Ptr<DescriptorMatcher> retval; |  | 6758 | Ptr<DescriptorMatcher> retval;
| 6759 |  |  | 6759 |
| 6760 | const char* keywords[] = { "descriptorMatcherType", NULL }; |  | 6760 | const char* keywords[] = { "descriptorMatcherType", NULL };
| 6761 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.create", (char**)keywords, &pyobj_descriptorMatcherType) && |  | 6761 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.create", (char**)keywords, &pyobj_descriptorMatcherType) &&
| 6762 | pyopencv_to_safe(pyobj_descriptorMatcherType, descriptorMatcherType, ArgInfo("descriptorMatcherType", 0)) ) |  | 6762 | pyopencv_to_safe(pyobj_descriptorMatcherType, descriptorMatcherType, ArgInfo("descriptorMatcherType", 0)) )
| 6763 | { |  | 6763 | {
| 6764 | ERRWRAP2(retval = cv::DescriptorMatcher::create(descriptorMatcherType)); |  | 6764 | ERRWRAP2(retval = cv::DescriptorMatcher::create(descriptorMatcherType));
| 6765 | return pyopencv_from(retval); |  | 6765 | return pyopencv_from(retval);
| 6766 | } |  | 6766 | }
| 6767 |  |  | 6767 |
| 6768 |  |  | 6768 |
| 6769 | pyPopulateArgumentConversionErrors(); |  | 6769 | pyPopulateArgumentConversionErrors();
| 6770 | } |  | 6770 | }
| 6771 |  |  | 6771 |
| 6772 |  |  | 6772 |
| 6773 | { |  | 6773 | {
| 6774 | PyObject* pyobj_matcherType = NULL; |  | 6774 | PyObject* pyobj_matcherType = NULL;
| 6775 | DescriptorMatcher_MatcherType matcherType=static_cast<DescriptorMatcher_MatcherType>(0); |  | 6775 | DescriptorMatcher_MatcherType matcherType=static_cast<DescriptorMatcher_MatcherType>(0);
| 6776 | Ptr<DescriptorMatcher> retval; |  | 6776 | Ptr<DescriptorMatcher> retval;
| 6777 |  |  | 6777 |
| 6778 | const char* keywords[] = { "matcherType", NULL }; |  | 6778 | const char* keywords[] = { "matcherType", NULL };
| 6779 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.create", (char**)keywords, &pyobj_matcherType) && |  | 6779 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.create", (char**)keywords, &pyobj_matcherType) &&
| 6780 | pyopencv_to_safe(pyobj_matcherType, matcherType, ArgInfo("matcherType", 0)) ) |  | 6780 | pyopencv_to_safe(pyobj_matcherType, matcherType, ArgInfo("matcherType", 0)) )
| 6781 | { |  | 6781 | {
| 6782 | ERRWRAP2(retval = cv::DescriptorMatcher::create(matcherType)); |  | 6782 | ERRWRAP2(retval = cv::DescriptorMatcher::create(matcherType));
| 6783 | return pyopencv_from(retval); |  | 6783 | return pyopencv_from(retval);
| 6784 | } |  | 6784 | }
| 6785 |  |  | 6785 |
| 6786 |  |  | 6786 |
| 6787 | pyPopulateArgumentConversionErrors(); |  | 6787 | pyPopulateArgumentConversionErrors();
| 6788 | } |  | 6788 | }
| 6789 | pyRaiseCVOverloadException("create"); |  | 6789 | pyRaiseCVOverloadException("create");
| 6790 |  |  | 6790 |
| 6791 | return NULL; |  | 6791 | return NULL;
| 6792 | } |  | 6792 | }
| 6793 |  |  | 6793 |
| 6794 | static PyObject* pyopencv_cv_DescriptorMatcher_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6794 | static PyObject* pyopencv_cv_DescriptorMatcher_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 6795 | { |  | 6795 | {
| 6796 | using namespace cv; |  | 6796 | using namespace cv;
| 6797 |  |  | 6797 |
| 6798 |  |  | 6798 |
| 6799 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6799 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6800 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6800 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6801 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6801 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6802 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6802 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6803 | bool retval; |  | 6803 | bool retval;
| 6804 |  |  | 6804 |
| 6805 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 6805 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 6806 | { |  | 6806 | {
| 6807 | ERRWRAP2(retval = _self_->empty()); |  | 6807 | ERRWRAP2(retval = _self_->empty());
| 6808 | return pyopencv_from(retval); |  | 6808 | return pyopencv_from(retval);
| 6809 | } |  | 6809 | }
| 6810 |  |  | 6810 |
| 6811 | return NULL; |  | 6811 | return NULL;
| 6812 | } |  | 6812 | }
| 6813 |  |  | 6813 |
| 6814 | static PyObject* pyopencv_cv_DescriptorMatcher_getTrainDescriptors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6814 | static PyObject* pyopencv_cv_DescriptorMatcher_getTrainDescriptors(PyObject* self, PyObject* py_args, PyObject* kw)
| 6815 | { |  | 6815 | {
| 6816 | using namespace cv; |  | 6816 | using namespace cv;
| 6817 |  |  | 6817 |
| 6818 |  |  | 6818 |
| 6819 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6819 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6820 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6820 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6821 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6821 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6822 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6822 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6823 | std::vector<Mat> retval; |  | 6823 | std::vector<Mat> retval;
| 6824 |  |  | 6824 |
| 6825 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 6825 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 6826 | { |  | 6826 | {
| 6827 | ERRWRAP2(retval = _self_->getTrainDescriptors()); |  | 6827 | ERRWRAP2(retval = _self_->getTrainDescriptors());
| 6828 | return pyopencv_from(retval); |  | 6828 | return pyopencv_from(retval);
| 6829 | } |  | 6829 | }
| 6830 |  |  | 6830 |
| 6831 | return NULL; |  | 6831 | return NULL;
| 6832 | } |  | 6832 | }
| 6833 |  |  | 6833 |
| 6834 | static PyObject* pyopencv_cv_DescriptorMatcher_isMaskSupported(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6834 | static PyObject* pyopencv_cv_DescriptorMatcher_isMaskSupported(PyObject* self, PyObject* py_args, PyObject* kw)
| 6835 | { |  | 6835 | {
| 6836 | using namespace cv; |  | 6836 | using namespace cv;
| 6837 |  |  | 6837 |
| 6838 |  |  | 6838 |
| 6839 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6839 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6840 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6840 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6841 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6841 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6842 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6842 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6843 | bool retval; |  | 6843 | bool retval;
| 6844 |  |  | 6844 |
| 6845 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 6845 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 6846 | { |  | 6846 | {
| 6847 | ERRWRAP2(retval = _self_->isMaskSupported()); |  | 6847 | ERRWRAP2(retval = _self_->isMaskSupported());
| 6848 | return pyopencv_from(retval); |  | 6848 | return pyopencv_from(retval);
| 6849 | } |  | 6849 | }
| 6850 |  |  | 6850 |
| 6851 | return NULL; |  | 6851 | return NULL;
| 6852 | } |  | 6852 | }
| 6853 |  |  | 6853 |
| 6854 | static PyObject* pyopencv_cv_DescriptorMatcher_knnMatch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6854 | static PyObject* pyopencv_cv_DescriptorMatcher_knnMatch(PyObject* self, PyObject* py_args, PyObject* kw)
| 6855 | { |  | 6855 | {
| 6856 | using namespace cv; |  | 6856 | using namespace cv;
| 6857 |  |  | 6857 |
| 6858 |  |  | 6858 |
| 6859 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6859 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6860 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6860 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6861 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6861 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6862 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6862 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6863 | pyPrepareArgumentConversionErrorsStorage(4); |  | 6863 | pyPrepareArgumentConversionErrorsStorage(4);
| 6864 |  |  | 6864 |
| 6865 | { |  | 6865 | {
| 6866 | PyObject* pyobj_queryDescriptors = NULL; |  | 6866 | PyObject* pyobj_queryDescriptors = NULL;
| 6867 | Mat queryDescriptors; |  | 6867 | Mat queryDescriptors;
| 6868 | PyObject* pyobj_trainDescriptors = NULL; |  | 6868 | PyObject* pyobj_trainDescriptors = NULL;
| 6869 | Mat trainDescriptors; |  | 6869 | Mat trainDescriptors;
| 6870 | vector_vector_DMatch matches; |  | 6870 | vector_vector_DMatch matches;
| 6871 | PyObject* pyobj_k = NULL; |  | 6871 | PyObject* pyobj_k = NULL;
| 6872 | int k=0; |  | 6872 | int k=0;
| 6873 | PyObject* pyobj_mask = NULL; |  | 6873 | PyObject* pyobj_mask = NULL;
| 6874 | Mat mask; |  | 6874 | Mat mask;
| 6875 | PyObject* pyobj_compactResult = NULL; |  | 6875 | PyObject* pyobj_compactResult = NULL;
| 6876 | bool compactResult=false; |  | 6876 | bool compactResult=false;
| 6877 |  |  | 6877 |
| 6878 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "k", "mask", "compactResult", NULL }; |  | 6878 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "k", "mask", "compactResult", NULL };
| 6879 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_k, &pyobj_mask, &pyobj_compactResult) && |  | 6879 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_k, &pyobj_mask, &pyobj_compactResult) &&
| 6880 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 6880 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 6881 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 6881 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 6882 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 6882 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 6883 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 6883 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 6884 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 6884 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 6885 | { |  | 6885 | {
| 6886 | ERRWRAP2(_self_->knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult)); |  | 6886 | ERRWRAP2(_self_->knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult));
| 6887 | return pyopencv_from(matches); |  | 6887 | return pyopencv_from(matches);
| 6888 | } |  | 6888 | }
| 6889 |  |  | 6889 |
| 6890 |  |  | 6890 |
| 6891 | pyPopulateArgumentConversionErrors(); |  | 6891 | pyPopulateArgumentConversionErrors();
| 6892 | } |  | 6892 | }
| 6893 |  |  | 6893 |
| 6894 |  |  | 6894 |
| 6895 | { |  | 6895 | {
| 6896 | PyObject* pyobj_queryDescriptors = NULL; |  | 6896 | PyObject* pyobj_queryDescriptors = NULL;
| 6897 | Mat queryDescriptors; |  | 6897 | Mat queryDescriptors;
| 6898 | vector_vector_DMatch matches; |  | 6898 | vector_vector_DMatch matches;
| 6899 | PyObject* pyobj_k = NULL; |  | 6899 | PyObject* pyobj_k = NULL;
| 6900 | int k=0; |  | 6900 | int k=0;
| 6901 | PyObject* pyobj_masks = NULL; |  | 6901 | PyObject* pyobj_masks = NULL;
| 6902 | vector_Mat masks; |  | 6902 | vector_Mat masks;
| 6903 | PyObject* pyobj_compactResult = NULL; |  | 6903 | PyObject* pyobj_compactResult = NULL;
| 6904 | bool compactResult=false; |  | 6904 | bool compactResult=false;
| 6905 |  |  | 6905 |
| 6906 | const char* keywords[] = { "queryDescriptors", "k", "masks", "compactResult", NULL }; |  | 6906 | const char* keywords[] = { "queryDescriptors", "k", "masks", "compactResult", NULL };
| 6907 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_k, &pyobj_masks, &pyobj_compactResult) && |  | 6907 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_k, &pyobj_masks, &pyobj_compactResult) &&
| 6908 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 6908 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 6909 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 6909 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 6910 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 6910 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 6911 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 6911 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 6912 | { |  | 6912 | {
| 6913 | ERRWRAP2(_self_->knnMatch(queryDescriptors, matches, k, masks, compactResult)); |  | 6913 | ERRWRAP2(_self_->knnMatch(queryDescriptors, matches, k, masks, compactResult));
| 6914 | return pyopencv_from(matches); |  | 6914 | return pyopencv_from(matches);
| 6915 | } |  | 6915 | }
| 6916 |  |  | 6916 |
| 6917 |  |  | 6917 |
| 6918 | pyPopulateArgumentConversionErrors(); |  | 6918 | pyPopulateArgumentConversionErrors();
| 6919 | } |  | 6919 | }
| 6920 |  |  | 6920 |
| 6921 |  |  | 6921 |
| 6922 | { |  | 6922 | {
| 6923 | PyObject* pyobj_queryDescriptors = NULL; |  | 6923 | PyObject* pyobj_queryDescriptors = NULL;
| 6924 | UMat queryDescriptors; |  | 6924 | UMat queryDescriptors;
| 6925 | PyObject* pyobj_trainDescriptors = NULL; |  | 6925 | PyObject* pyobj_trainDescriptors = NULL;
| 6926 | UMat trainDescriptors; |  | 6926 | UMat trainDescriptors;
| 6927 | vector_vector_DMatch matches; |  | 6927 | vector_vector_DMatch matches;
| 6928 | PyObject* pyobj_k = NULL; |  | 6928 | PyObject* pyobj_k = NULL;
| 6929 | int k=0; |  | 6929 | int k=0;
| 6930 | PyObject* pyobj_mask = NULL; |  | 6930 | PyObject* pyobj_mask = NULL;
| 6931 | UMat mask; |  | 6931 | UMat mask;
| 6932 | PyObject* pyobj_compactResult = NULL; |  | 6932 | PyObject* pyobj_compactResult = NULL;
| 6933 | bool compactResult=false; |  | 6933 | bool compactResult=false;
| 6934 |  |  | 6934 |
| 6935 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "k", "mask", "compactResult", NULL }; |  | 6935 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "k", "mask", "compactResult", NULL };
| 6936 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_k, &pyobj_mask, &pyobj_compactResult) && |  | 6936 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_k, &pyobj_mask, &pyobj_compactResult) &&
| 6937 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 6937 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 6938 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 6938 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 6939 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 6939 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 6940 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 6940 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 6941 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 6941 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 6942 | { |  | 6942 | {
| 6943 | ERRWRAP2(_self_->knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult)); |  | 6943 | ERRWRAP2(_self_->knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult));
| 6944 | return pyopencv_from(matches); |  | 6944 | return pyopencv_from(matches);
| 6945 | } |  | 6945 | }
| 6946 |  |  | 6946 |
| 6947 |  |  | 6947 |
| 6948 | pyPopulateArgumentConversionErrors(); |  | 6948 | pyPopulateArgumentConversionErrors();
| 6949 | } |  | 6949 | }
| 6950 |  |  | 6950 |
| 6951 |  |  | 6951 |
| 6952 | { |  | 6952 | {
| 6953 | PyObject* pyobj_queryDescriptors = NULL; |  | 6953 | PyObject* pyobj_queryDescriptors = NULL;
| 6954 | UMat queryDescriptors; |  | 6954 | UMat queryDescriptors;
| 6955 | vector_vector_DMatch matches; |  | 6955 | vector_vector_DMatch matches;
| 6956 | PyObject* pyobj_k = NULL; |  | 6956 | PyObject* pyobj_k = NULL;
| 6957 | int k=0; |  | 6957 | int k=0;
| 6958 | PyObject* pyobj_masks = NULL; |  | 6958 | PyObject* pyobj_masks = NULL;
| 6959 | vector_UMat masks; |  | 6959 | vector_UMat masks;
| 6960 | PyObject* pyobj_compactResult = NULL; |  | 6960 | PyObject* pyobj_compactResult = NULL;
| 6961 | bool compactResult=false; |  | 6961 | bool compactResult=false;
| 6962 |  |  | 6962 |
| 6963 | const char* keywords[] = { "queryDescriptors", "k", "masks", "compactResult", NULL }; |  | 6963 | const char* keywords[] = { "queryDescriptors", "k", "masks", "compactResult", NULL };
| 6964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_k, &pyobj_masks, &pyobj_compactResult) && |  | 6964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_k, &pyobj_masks, &pyobj_compactResult) &&
| 6965 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 6965 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 6966 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 6966 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 6967 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 6967 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 6968 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 6968 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 6969 | { |  | 6969 | {
| 6970 | ERRWRAP2(_self_->knnMatch(queryDescriptors, matches, k, masks, compactResult)); |  | 6970 | ERRWRAP2(_self_->knnMatch(queryDescriptors, matches, k, masks, compactResult));
| 6971 | return pyopencv_from(matches); |  | 6971 | return pyopencv_from(matches);
| 6972 | } |  | 6972 | }
| 6973 |  |  | 6973 |
| 6974 |  |  | 6974 |
| 6975 | pyPopulateArgumentConversionErrors(); |  | 6975 | pyPopulateArgumentConversionErrors();
| 6976 | } |  | 6976 | }
| 6977 | pyRaiseCVOverloadException("knnMatch"); |  | 6977 | pyRaiseCVOverloadException("knnMatch");
| 6978 |  |  | 6978 |
| 6979 | return NULL; |  | 6979 | return NULL;
| 6980 | } |  | 6980 | }
| 6981 |  |  | 6981 |
| 6982 | static PyObject* pyopencv_cv_DescriptorMatcher_match(PyObject* self, PyObject* py_args, PyObject* kw) |  | 6982 | static PyObject* pyopencv_cv_DescriptorMatcher_match(PyObject* self, PyObject* py_args, PyObject* kw)
| 6983 | { |  | 6983 | {
| 6984 | using namespace cv; |  | 6984 | using namespace cv;
| 6985 |  |  | 6985 |
| 6986 |  |  | 6986 |
| 6987 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 6987 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 6988 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 6988 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 6989 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 6989 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 6990 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 6990 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 6991 | pyPrepareArgumentConversionErrorsStorage(4); |  | 6991 | pyPrepareArgumentConversionErrorsStorage(4);
| 6992 |  |  | 6992 |
| 6993 | { |  | 6993 | {
| 6994 | PyObject* pyobj_queryDescriptors = NULL; |  | 6994 | PyObject* pyobj_queryDescriptors = NULL;
| 6995 | Mat queryDescriptors; |  | 6995 | Mat queryDescriptors;
| 6996 | PyObject* pyobj_trainDescriptors = NULL; |  | 6996 | PyObject* pyobj_trainDescriptors = NULL;
| 6997 | Mat trainDescriptors; |  | 6997 | Mat trainDescriptors;
| 6998 | vector_DMatch matches; |  | 6998 | vector_DMatch matches;
| 6999 | PyObject* pyobj_mask = NULL; |  | 6999 | PyObject* pyobj_mask = NULL;
| 7000 | Mat mask; |  | 7000 | Mat mask;
| 7001 |  |  | 7001 |
| 7002 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "mask", NULL }; |  | 7002 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "mask", NULL };
| 7003 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_mask) && |  | 7003 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_mask) &&
| 7004 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7004 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7005 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 7005 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 7006 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 7006 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 7007 | { |  | 7007 | {
| 7008 | ERRWRAP2(_self_->match(queryDescriptors, trainDescriptors, matches, mask)); |  | 7008 | ERRWRAP2(_self_->match(queryDescriptors, trainDescriptors, matches, mask));
| 7009 | return pyopencv_from(matches); |  | 7009 | return pyopencv_from(matches);
| 7010 | } |  | 7010 | }
| 7011 |  |  | 7011 |
| 7012 |  |  | 7012 |
| 7013 | pyPopulateArgumentConversionErrors(); |  | 7013 | pyPopulateArgumentConversionErrors();
| 7014 | } |  | 7014 | }
| 7015 |  |  | 7015 |
| 7016 |  |  | 7016 |
| 7017 | { |  | 7017 | {
| 7018 | PyObject* pyobj_queryDescriptors = NULL; |  | 7018 | PyObject* pyobj_queryDescriptors = NULL;
| 7019 | Mat queryDescriptors; |  | 7019 | Mat queryDescriptors;
| 7020 | vector_DMatch matches; |  | 7020 | vector_DMatch matches;
| 7021 | PyObject* pyobj_masks = NULL; |  | 7021 | PyObject* pyobj_masks = NULL;
| 7022 | vector_Mat masks; |  | 7022 | vector_Mat masks;
| 7023 |  |  | 7023 |
| 7024 | const char* keywords[] = { "queryDescriptors", "masks", NULL }; |  | 7024 | const char* keywords[] = { "queryDescriptors", "masks", NULL };
| 7025 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_masks) && |  | 7025 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_masks) &&
| 7026 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7026 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7027 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 7027 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 7028 | { |  | 7028 | {
| 7029 | ERRWRAP2(_self_->match(queryDescriptors, matches, masks)); |  | 7029 | ERRWRAP2(_self_->match(queryDescriptors, matches, masks));
| 7030 | return pyopencv_from(matches); |  | 7030 | return pyopencv_from(matches);
| 7031 | } |  | 7031 | }
| 7032 |  |  | 7032 |
| 7033 |  |  | 7033 |
| 7034 | pyPopulateArgumentConversionErrors(); |  | 7034 | pyPopulateArgumentConversionErrors();
| 7035 | } |  | 7035 | }
| 7036 |  |  | 7036 |
| 7037 |  |  | 7037 |
| 7038 | { |  | 7038 | {
| 7039 | PyObject* pyobj_queryDescriptors = NULL; |  | 7039 | PyObject* pyobj_queryDescriptors = NULL;
| 7040 | UMat queryDescriptors; |  | 7040 | UMat queryDescriptors;
| 7041 | PyObject* pyobj_trainDescriptors = NULL; |  | 7041 | PyObject* pyobj_trainDescriptors = NULL;
| 7042 | UMat trainDescriptors; |  | 7042 | UMat trainDescriptors;
| 7043 | vector_DMatch matches; |  | 7043 | vector_DMatch matches;
| 7044 | PyObject* pyobj_mask = NULL; |  | 7044 | PyObject* pyobj_mask = NULL;
| 7045 | UMat mask; |  | 7045 | UMat mask;
| 7046 |  |  | 7046 |
| 7047 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "mask", NULL }; |  | 7047 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "mask", NULL };
| 7048 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_mask) && |  | 7048 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_mask) &&
| 7049 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7049 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7050 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 7050 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 7051 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 7051 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 7052 | { |  | 7052 | {
| 7053 | ERRWRAP2(_self_->match(queryDescriptors, trainDescriptors, matches, mask)); |  | 7053 | ERRWRAP2(_self_->match(queryDescriptors, trainDescriptors, matches, mask));
| 7054 | return pyopencv_from(matches); |  | 7054 | return pyopencv_from(matches);
| 7055 | } |  | 7055 | }
| 7056 |  |  | 7056 |
| 7057 |  |  | 7057 |
| 7058 | pyPopulateArgumentConversionErrors(); |  | 7058 | pyPopulateArgumentConversionErrors();
| 7059 | } |  | 7059 | }
| 7060 |  |  | 7060 |
| 7061 |  |  | 7061 |
| 7062 | { |  | 7062 | {
| 7063 | PyObject* pyobj_queryDescriptors = NULL; |  | 7063 | PyObject* pyobj_queryDescriptors = NULL;
| 7064 | UMat queryDescriptors; |  | 7064 | UMat queryDescriptors;
| 7065 | vector_DMatch matches; |  | 7065 | vector_DMatch matches;
| 7066 | PyObject* pyobj_masks = NULL; |  | 7066 | PyObject* pyobj_masks = NULL;
| 7067 | vector_UMat masks; |  | 7067 | vector_UMat masks;
| 7068 |  |  | 7068 |
| 7069 | const char* keywords[] = { "queryDescriptors", "masks", NULL }; |  | 7069 | const char* keywords[] = { "queryDescriptors", "masks", NULL };
| 7070 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_masks) && |  | 7070 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:DescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_masks) &&
| 7071 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7071 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7072 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 7072 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 7073 | { |  | 7073 | {
| 7074 | ERRWRAP2(_self_->match(queryDescriptors, matches, masks)); |  | 7074 | ERRWRAP2(_self_->match(queryDescriptors, matches, masks));
| 7075 | return pyopencv_from(matches); |  | 7075 | return pyopencv_from(matches);
| 7076 | } |  | 7076 | }
| 7077 |  |  | 7077 |
| 7078 |  |  | 7078 |
| 7079 | pyPopulateArgumentConversionErrors(); |  | 7079 | pyPopulateArgumentConversionErrors();
| 7080 | } |  | 7080 | }
| 7081 | pyRaiseCVOverloadException("match"); |  | 7081 | pyRaiseCVOverloadException("match");
| 7082 |  |  | 7082 |
| 7083 | return NULL; |  | 7083 | return NULL;
| 7084 | } |  | 7084 | }
| 7085 |  |  | 7085 |
| 7086 | static PyObject* pyopencv_cv_DescriptorMatcher_radiusMatch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7086 | static PyObject* pyopencv_cv_DescriptorMatcher_radiusMatch(PyObject* self, PyObject* py_args, PyObject* kw)
| 7087 | { |  | 7087 | {
| 7088 | using namespace cv; |  | 7088 | using namespace cv;
| 7089 |  |  | 7089 |
| 7090 |  |  | 7090 |
| 7091 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 7091 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 7092 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 7092 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 7093 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 7093 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 7094 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 7094 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 7095 | pyPrepareArgumentConversionErrorsStorage(4); |  | 7095 | pyPrepareArgumentConversionErrorsStorage(4);
| 7096 |  |  | 7096 |
| 7097 | { |  | 7097 | {
| 7098 | PyObject* pyobj_queryDescriptors = NULL; |  | 7098 | PyObject* pyobj_queryDescriptors = NULL;
| 7099 | Mat queryDescriptors; |  | 7099 | Mat queryDescriptors;
| 7100 | PyObject* pyobj_trainDescriptors = NULL; |  | 7100 | PyObject* pyobj_trainDescriptors = NULL;
| 7101 | Mat trainDescriptors; |  | 7101 | Mat trainDescriptors;
| 7102 | vector_vector_DMatch matches; |  | 7102 | vector_vector_DMatch matches;
| 7103 | PyObject* pyobj_maxDistance = NULL; |  | 7103 | PyObject* pyobj_maxDistance = NULL;
| 7104 | float maxDistance=0.f; |  | 7104 | float maxDistance=0.f;
| 7105 | PyObject* pyobj_mask = NULL; |  | 7105 | PyObject* pyobj_mask = NULL;
| 7106 | Mat mask; |  | 7106 | Mat mask;
| 7107 | PyObject* pyobj_compactResult = NULL; |  | 7107 | PyObject* pyobj_compactResult = NULL;
| 7108 | bool compactResult=false; |  | 7108 | bool compactResult=false;
| 7109 |  |  | 7109 |
| 7110 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "maxDistance", "mask", "compactResult", NULL }; |  | 7110 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "maxDistance", "mask", "compactResult", NULL };
| 7111 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_maxDistance, &pyobj_mask, &pyobj_compactResult) && |  | 7111 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_maxDistance, &pyobj_mask, &pyobj_compactResult) &&
| 7112 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7112 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7113 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 7113 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 7114 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) && |  | 7114 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) &&
| 7115 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 7115 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 7116 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 7116 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 7117 | { |  | 7117 | {
| 7118 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance, mask, compactResult)); |  | 7118 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance, mask, compactResult));
| 7119 | return pyopencv_from(matches); |  | 7119 | return pyopencv_from(matches);
| 7120 | } |  | 7120 | }
| 7121 |  |  | 7121 |
| 7122 |  |  | 7122 |
| 7123 | pyPopulateArgumentConversionErrors(); |  | 7123 | pyPopulateArgumentConversionErrors();
| 7124 | } |  | 7124 | }
| 7125 |  |  | 7125 |
| 7126 |  |  | 7126 |
| 7127 | { |  | 7127 | {
| 7128 | PyObject* pyobj_queryDescriptors = NULL; |  | 7128 | PyObject* pyobj_queryDescriptors = NULL;
| 7129 | Mat queryDescriptors; |  | 7129 | Mat queryDescriptors;
| 7130 | vector_vector_DMatch matches; |  | 7130 | vector_vector_DMatch matches;
| 7131 | PyObject* pyobj_maxDistance = NULL; |  | 7131 | PyObject* pyobj_maxDistance = NULL;
| 7132 | float maxDistance=0.f; |  | 7132 | float maxDistance=0.f;
| 7133 | PyObject* pyobj_masks = NULL; |  | 7133 | PyObject* pyobj_masks = NULL;
| 7134 | vector_Mat masks; |  | 7134 | vector_Mat masks;
| 7135 | PyObject* pyobj_compactResult = NULL; |  | 7135 | PyObject* pyobj_compactResult = NULL;
| 7136 | bool compactResult=false; |  | 7136 | bool compactResult=false;
| 7137 |  |  | 7137 |
| 7138 | const char* keywords[] = { "queryDescriptors", "maxDistance", "masks", "compactResult", NULL }; |  | 7138 | const char* keywords[] = { "queryDescriptors", "maxDistance", "masks", "compactResult", NULL };
| 7139 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_maxDistance, &pyobj_masks, &pyobj_compactResult) && |  | 7139 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_maxDistance, &pyobj_masks, &pyobj_compactResult) &&
| 7140 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7140 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7141 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) && |  | 7141 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) &&
| 7142 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 7142 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 7143 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 7143 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 7144 | { |  | 7144 | {
| 7145 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, matches, maxDistance, masks, compactResult)); |  | 7145 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, matches, maxDistance, masks, compactResult));
| 7146 | return pyopencv_from(matches); |  | 7146 | return pyopencv_from(matches);
| 7147 | } |  | 7147 | }
| 7148 |  |  | 7148 |
| 7149 |  |  | 7149 |
| 7150 | pyPopulateArgumentConversionErrors(); |  | 7150 | pyPopulateArgumentConversionErrors();
| 7151 | } |  | 7151 | }
| 7152 |  |  | 7152 |
| 7153 |  |  | 7153 |
| 7154 | { |  | 7154 | {
| 7155 | PyObject* pyobj_queryDescriptors = NULL; |  | 7155 | PyObject* pyobj_queryDescriptors = NULL;
| 7156 | UMat queryDescriptors; |  | 7156 | UMat queryDescriptors;
| 7157 | PyObject* pyobj_trainDescriptors = NULL; |  | 7157 | PyObject* pyobj_trainDescriptors = NULL;
| 7158 | UMat trainDescriptors; |  | 7158 | UMat trainDescriptors;
| 7159 | vector_vector_DMatch matches; |  | 7159 | vector_vector_DMatch matches;
| 7160 | PyObject* pyobj_maxDistance = NULL; |  | 7160 | PyObject* pyobj_maxDistance = NULL;
| 7161 | float maxDistance=0.f; |  | 7161 | float maxDistance=0.f;
| 7162 | PyObject* pyobj_mask = NULL; |  | 7162 | PyObject* pyobj_mask = NULL;
| 7163 | UMat mask; |  | 7163 | UMat mask;
| 7164 | PyObject* pyobj_compactResult = NULL; |  | 7164 | PyObject* pyobj_compactResult = NULL;
| 7165 | bool compactResult=false; |  | 7165 | bool compactResult=false;
| 7166 |  |  | 7166 |
| 7167 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "maxDistance", "mask", "compactResult", NULL }; |  | 7167 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "maxDistance", "mask", "compactResult", NULL };
| 7168 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_maxDistance, &pyobj_mask, &pyobj_compactResult) && |  | 7168 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_maxDistance, &pyobj_mask, &pyobj_compactResult) &&
| 7169 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7169 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7170 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 7170 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 7171 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) && |  | 7171 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) &&
| 7172 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 7172 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 7173 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 7173 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 7174 | { |  | 7174 | {
| 7175 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance, mask, compactResult)); |  | 7175 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance, mask, compactResult));
| 7176 | return pyopencv_from(matches); |  | 7176 | return pyopencv_from(matches);
| 7177 | } |  | 7177 | }
| 7178 |  |  | 7178 |
| 7179 |  |  | 7179 |
| 7180 | pyPopulateArgumentConversionErrors(); |  | 7180 | pyPopulateArgumentConversionErrors();
| 7181 | } |  | 7181 | }
| 7182 |  |  | 7182 |
| 7183 |  |  | 7183 |
| 7184 | { |  | 7184 | {
| 7185 | PyObject* pyobj_queryDescriptors = NULL; |  | 7185 | PyObject* pyobj_queryDescriptors = NULL;
| 7186 | UMat queryDescriptors; |  | 7186 | UMat queryDescriptors;
| 7187 | vector_vector_DMatch matches; |  | 7187 | vector_vector_DMatch matches;
| 7188 | PyObject* pyobj_maxDistance = NULL; |  | 7188 | PyObject* pyobj_maxDistance = NULL;
| 7189 | float maxDistance=0.f; |  | 7189 | float maxDistance=0.f;
| 7190 | PyObject* pyobj_masks = NULL; |  | 7190 | PyObject* pyobj_masks = NULL;
| 7191 | vector_UMat masks; |  | 7191 | vector_UMat masks;
| 7192 | PyObject* pyobj_compactResult = NULL; |  | 7192 | PyObject* pyobj_compactResult = NULL;
| 7193 | bool compactResult=false; |  | 7193 | bool compactResult=false;
| 7194 |  |  | 7194 |
| 7195 | const char* keywords[] = { "queryDescriptors", "maxDistance", "masks", "compactResult", NULL }; |  | 7195 | const char* keywords[] = { "queryDescriptors", "maxDistance", "masks", "compactResult", NULL };
| 7196 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_maxDistance, &pyobj_masks, &pyobj_compactResult) && |  | 7196 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:DescriptorMatcher.radiusMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_maxDistance, &pyobj_masks, &pyobj_compactResult) &&
| 7197 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 7197 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 7198 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) && |  | 7198 | pyopencv_to_safe(pyobj_maxDistance, maxDistance, ArgInfo("maxDistance", 0)) &&
| 7199 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 7199 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 7200 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 7200 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 7201 | { |  | 7201 | {
| 7202 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, matches, maxDistance, masks, compactResult)); |  | 7202 | ERRWRAP2(_self_->radiusMatch(queryDescriptors, matches, maxDistance, masks, compactResult));
| 7203 | return pyopencv_from(matches); |  | 7203 | return pyopencv_from(matches);
| 7204 | } |  | 7204 | }
| 7205 |  |  | 7205 |
| 7206 |  |  | 7206 |
| 7207 | pyPopulateArgumentConversionErrors(); |  | 7207 | pyPopulateArgumentConversionErrors();
| 7208 | } |  | 7208 | }
| 7209 | pyRaiseCVOverloadException("radiusMatch"); |  | 7209 | pyRaiseCVOverloadException("radiusMatch");
| 7210 |  |  | 7210 |
| 7211 | return NULL; |  | 7211 | return NULL;
| 7212 | } |  | 7212 | }
| 7213 |  |  | 7213 |
| 7214 | static PyObject* pyopencv_cv_DescriptorMatcher_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7214 | static PyObject* pyopencv_cv_DescriptorMatcher_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 7215 | { |  | 7215 | {
| 7216 | using namespace cv; |  | 7216 | using namespace cv;
| 7217 |  |  | 7217 |
| 7218 |  |  | 7218 |
| 7219 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 7219 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 7220 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 7220 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 7221 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 7221 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 7222 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 7222 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 7223 | pyPrepareArgumentConversionErrorsStorage(2); |  | 7223 | pyPrepareArgumentConversionErrorsStorage(2);
| 7224 |  |  | 7224 |
| 7225 | { |  | 7225 | {
| 7226 | PyObject* pyobj_fileName = NULL; |  | 7226 | PyObject* pyobj_fileName = NULL;
| 7227 | String fileName; |  | 7227 | String fileName;
| 7228 |  |  | 7228 |
| 7229 | const char* keywords[] = { "fileName", NULL }; |  | 7229 | const char* keywords[] = { "fileName", NULL };
| 7230 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.read", (char**)keywords, &pyobj_fileName) && |  | 7230 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.read", (char**)keywords, &pyobj_fileName) &&
| 7231 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) ) |  | 7231 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) )
| 7232 | { |  | 7232 | {
| 7233 | ERRWRAP2(_self_->read(fileName)); |  | 7233 | ERRWRAP2(_self_->read(fileName));
| 7234 | Py_RETURN_NONE; |  | 7234 | Py_RETURN_NONE;
| 7235 | } |  | 7235 | }
| 7236 |  |  | 7236 |
| 7237 |  |  | 7237 |
| 7238 | pyPopulateArgumentConversionErrors(); |  | 7238 | pyPopulateArgumentConversionErrors();
| 7239 | } |  | 7239 | }
| 7240 |  |  | 7240 |
| 7241 |  |  | 7241 |
| 7242 | { |  | 7242 | {
| 7243 | PyObject* pyobj_arg1 = NULL; |  | 7243 | PyObject* pyobj_arg1 = NULL;
| 7244 | cv::FileNode arg1; |  | 7244 | cv::FileNode arg1;
| 7245 |  |  | 7245 |
| 7246 | const char* keywords[] = { "arg1", NULL }; |  | 7246 | const char* keywords[] = { "arg1", NULL };
| 7247 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.read", (char**)keywords, &pyobj_arg1) && |  | 7247 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.read", (char**)keywords, &pyobj_arg1) &&
| 7248 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) ) |  | 7248 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) )
| 7249 | { |  | 7249 | {
| 7250 | ERRWRAP2(_self_->read(arg1)); |  | 7250 | ERRWRAP2(_self_->read(arg1));
| 7251 | Py_RETURN_NONE; |  | 7251 | Py_RETURN_NONE;
| 7252 | } |  | 7252 | }
| 7253 |  |  | 7253 |
| 7254 |  |  | 7254 |
| 7255 | pyPopulateArgumentConversionErrors(); |  | 7255 | pyPopulateArgumentConversionErrors();
| 7256 | } |  | 7256 | }
| 7257 | pyRaiseCVOverloadException("read"); |  | 7257 | pyRaiseCVOverloadException("read");
| 7258 |  |  | 7258 |
| 7259 | return NULL; |  | 7259 | return NULL;
| 7260 | } |  | 7260 | }
| 7261 |  |  | 7261 |
| 7262 | static PyObject* pyopencv_cv_DescriptorMatcher_train(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7262 | static PyObject* pyopencv_cv_DescriptorMatcher_train(PyObject* self, PyObject* py_args, PyObject* kw)
| 7263 | { |  | 7263 | {
| 7264 | using namespace cv; |  | 7264 | using namespace cv;
| 7265 |  |  | 7265 |
| 7266 |  |  | 7266 |
| 7267 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 7267 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 7268 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 7268 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 7269 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 7269 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 7270 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 7270 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 7271 |  |  | 7271 |
| 7272 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 7272 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 7273 | { |  | 7273 | {
| 7274 | ERRWRAP2(_self_->train()); |  | 7274 | ERRWRAP2(_self_->train());
| 7275 | Py_RETURN_NONE; |  | 7275 | Py_RETURN_NONE;
| 7276 | } |  | 7276 | }
| 7277 |  |  | 7277 |
| 7278 | return NULL; |  | 7278 | return NULL;
| 7279 | } |  | 7279 | }
| 7280 |  |  | 7280 |
| 7281 | static PyObject* pyopencv_cv_DescriptorMatcher_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7281 | static PyObject* pyopencv_cv_DescriptorMatcher_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 7282 | { |  | 7282 | {
| 7283 | using namespace cv; |  | 7283 | using namespace cv;
| 7284 |  |  | 7284 |
| 7285 |  |  | 7285 |
| 7286 | Ptr<cv::DescriptorMatcher> * self1 = 0; |  | 7286 | Ptr<cv::DescriptorMatcher> * self1 = 0;
| 7287 | if (!pyopencv_DescriptorMatcher_getp(self, self1)) |  | 7287 | if (!pyopencv_DescriptorMatcher_getp(self, self1))
| 7288 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)"); |  | 7288 | return failmsgp("Incorrect type of self (must be 'DescriptorMatcher' or its derivative)");
| 7289 | Ptr<cv::DescriptorMatcher> _self_ = *(self1); |  | 7289 | Ptr<cv::DescriptorMatcher> _self_ = *(self1);
| 7290 | pyPrepareArgumentConversionErrorsStorage(2); |  | 7290 | pyPrepareArgumentConversionErrorsStorage(2);
| 7291 |  |  | 7291 |
| 7292 | { |  | 7292 | {
| 7293 | PyObject* pyobj_fileName = NULL; |  | 7293 | PyObject* pyobj_fileName = NULL;
| 7294 | String fileName; |  | 7294 | String fileName;
| 7295 |  |  | 7295 |
| 7296 | const char* keywords[] = { "fileName", NULL }; |  | 7296 | const char* keywords[] = { "fileName", NULL };
| 7297 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.write", (char**)keywords, &pyobj_fileName) && |  | 7297 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DescriptorMatcher.write", (char**)keywords, &pyobj_fileName) &&
| 7298 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) ) |  | 7298 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) )
| 7299 | { |  | 7299 | {
| 7300 | ERRWRAP2(_self_->write(fileName)); |  | 7300 | ERRWRAP2(_self_->write(fileName));
| 7301 | Py_RETURN_NONE; |  | 7301 | Py_RETURN_NONE;
| 7302 | } |  | 7302 | }
| 7303 |  |  | 7303 |
| 7304 |  |  | 7304 |
| 7305 | pyPopulateArgumentConversionErrors(); |  | 7305 | pyPopulateArgumentConversionErrors();
| 7306 | } |  | 7306 | }
| 7307 |  |  | 7307 |
| 7308 |  |  | 7308 |
| 7309 | { |  | 7309 | {
| 7310 | PyObject* pyobj_fs = NULL; |  | 7310 | PyObject* pyobj_fs = NULL;
| 7311 | Ptr<cv::FileStorage> fs; |  | 7311 | Ptr<cv::FileStorage> fs;
| 7312 | PyObject* pyobj_name = NULL; |  | 7312 | PyObject* pyobj_name = NULL;
| 7313 | String name; |  | 7313 | String name;
| 7314 |  |  | 7314 |
| 7315 | const char* keywords[] = { "fs", "name", NULL }; |  | 7315 | const char* keywords[] = { "fs", "name", NULL };
| 7316 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:DescriptorMatcher.write", (char**)keywords, &pyobj_fs, &pyobj_name) && |  | 7316 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:DescriptorMatcher.write", (char**)keywords, &pyobj_fs, &pyobj_name) &&
| 7317 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) && |  | 7317 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) &&
| 7318 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 7318 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 7319 | { |  | 7319 | {
| 7320 | ERRWRAP2(_self_->write(*fs, name)); |  | 7320 | ERRWRAP2(_self_->write(*fs, name));
| 7321 | Py_RETURN_NONE; |  | 7321 | Py_RETURN_NONE;
| 7322 | } |  | 7322 | }
| 7323 |  |  | 7323 |
| 7324 |  |  | 7324 |
| 7325 | pyPopulateArgumentConversionErrors(); |  | 7325 | pyPopulateArgumentConversionErrors();
| 7326 | } |  | 7326 | }
| 7327 | pyRaiseCVOverloadException("write"); |  | 7327 | pyRaiseCVOverloadException("write");
| 7328 |  |  | 7328 |
| 7329 | return NULL; |  | 7329 | return NULL;
| 7330 | } |  | 7330 | }
| 7331 |  |  | 7331 |
| 7332 |  |  | 7332 |
| 7333 |  |  | 7333 |
| 7334 | // Tables (DescriptorMatcher) |  | 7334 | // Tables (DescriptorMatcher)
| 7335 |  |  | 7335 |
| 7336 | static PyGetSetDef pyopencv_DescriptorMatcher_getseters[] = |  | 7336 | static PyGetSetDef pyopencv_DescriptorMatcher_getseters[] =
| 7337 | { |  | 7337 | {
| 7338 | {NULL} /* Sentinel */ |  | 7338 | {NULL} /* Sentinel */
| 7339 | }; |  | 7339 | };
| 7340 |  |  | 7340 |
| 7341 | static PyMethodDef pyopencv_DescriptorMatcher_methods[] = |  | 7341 | static PyMethodDef pyopencv_DescriptorMatcher_methods[] =
| 7342 | { |  | 7342 | {
| 7343 | {"add", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_add, 0), "add(descriptors) -> None\n. @brief Adds descriptors to train a CPU(trainDescCollectionis) or GPU(utrainDescCollectionis) descriptor\n. collection.\n. \n. If the collection is not empty, the new descriptors are added to existing train descriptors.\n. \n. @param descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same\n. train image."}, |  | 7343 | {"add", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_add, 0), "add(descriptors) -> None\n. @brief Adds descriptors to train a CPU(trainDescCollectionis) or GPU(utrainDescCollectionis) descriptor\n. collection.\n. \n. If the collection is not empty, the new descriptors are added to existing train descriptors.\n. \n. @param descriptors Descriptors to add. Each descriptors[i] is a set of descriptors from the same\n. train image."},
| 7344 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_clear, 0), "clear() -> None\n. @brief Clears the train descriptor collections."}, |  | 7344 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_clear, 0), "clear() -> None\n. @brief Clears the train descriptor collections."},
| 7345 | {"clone", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_clone, 0), "clone([, emptyTrainData]) -> retval\n. @brief Clones the matcher.\n. \n. @param emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object,\n. that is, copies both parameters and train data. If emptyTrainData is true, the method creates an\n. object copy with the current parameters but with empty train data."}, |  | 7345 | {"clone", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_clone, 0), "clone([, emptyTrainData]) -> retval\n. @brief Clones the matcher.\n. \n. @param emptyTrainData If emptyTrainData is false, the method creates a deep copy of the object,\n. that is, copies both parameters and train data. If emptyTrainData is true, the method creates an\n. object copy with the current parameters but with empty train data."},
| 7346 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_create_static, METH_STATIC), "create(descriptorMatcherType) -> retval\n. @brief Creates a descriptor matcher of a given type with the default parameters (using default\n. constructor).\n. \n. @param descriptorMatcherType Descriptor matcher type. Now the following matcher types are\n. supported:\n. - `BruteForce` (it uses L2 )\n. - `BruteForce-L1`\n. - `BruteForce-Hamming`\n. - `BruteForce-Hamming(2)`\n. - `FlannBased`\n\n\n\ncreate(matcherType) -> retval\n."}, |  | 7346 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_create_static, METH_STATIC), "create(descriptorMatcherType) -> retval\n. @brief Creates a descriptor matcher of a given type with the default parameters (using default\n. constructor).\n. \n. @param descriptorMatcherType Descriptor matcher type. Now the following matcher types are\n. supported:\n. - `BruteForce` (it uses L2 )\n. - `BruteForce-L1`\n. - `BruteForce-Hamming`\n. - `BruteForce-Hamming(2)`\n. - `FlannBased`\n\n\n\ncreate(matcherType) -> retval\n."},
| 7347 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_empty, 0), "empty() -> retval\n. @brief Returns true if there are no train descriptors in the both collections."}, |  | 7347 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_empty, 0), "empty() -> retval\n. @brief Returns true if there are no train descriptors in the both collections."},
| 7348 | {"getTrainDescriptors", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_getTrainDescriptors, 0), "getTrainDescriptors() -> retval\n. @brief Returns a constant link to the train descriptor collection trainDescCollection ."}, |  | 7348 | {"getTrainDescriptors", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_getTrainDescriptors, 0), "getTrainDescriptors() -> retval\n. @brief Returns a constant link to the train descriptor collection trainDescCollection ."},
| 7349 | {"isMaskSupported", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_isMaskSupported, 0), "isMaskSupported() -> retval\n. @brief Returns true if the descriptor matcher supports masking permissible matches."}, |  | 7349 | {"isMaskSupported", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_isMaskSupported, 0), "isMaskSupported() -> retval\n. @brief Returns true if the descriptor matcher supports masking permissible matches."},
| 7350 | {"knnMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_knnMatch, 0), "knnMatch(queryDescriptors, trainDescriptors, k[, mask[, compactResult]]) -> matches\n. @brief Finds the k best matches for each descriptor from a query set.\n. \n. @param queryDescriptors Query set of descriptors.\n. @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors\n. collection stored in the class object.\n. @param mask Mask specifying permissible matches between an input query and train matrices of\n. descriptors.\n. @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.\n. @param k Count of best matches found per each query descriptor or less if a query descriptor has\n. less than k possible matches in total.\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors.\n. \n. These extended variants of DescriptorMatcher::match methods find several best matches for each query\n. descriptor. The matches are returned in the distance increasing order. See DescriptorMatcher::match\n. for the details about query and train descriptors.\n\n\n\nknnMatch(queryDescriptors, k[, masks[, compactResult]]) -> matches\n. @overload\n. @param queryDescriptors Query set of descriptors.\n. @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.\n. @param k Count of best matches found per each query descriptor or less if a query descriptor has\n. less than k possible matches in total.\n. @param masks Set of masks. Each masks[i] specifies permissible matches between the input query\n. descriptors and stored train descriptors from the i-th image trainDescCollection[i].\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors."}, |  | 7350 | {"knnMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_knnMatch, 0), "knnMatch(queryDescriptors, trainDescriptors, k[, mask[, compactResult]]) -> matches\n. @brief Finds the k best matches for each descriptor from a query set.\n. \n. @param queryDescriptors Query set of descriptors.\n. @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors\n. collection stored in the class object.\n. @param mask Mask specifying permissible matches between an input query and train matrices of\n. descriptors.\n. @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.\n. @param k Count of best matches found per each query descriptor or less if a query descriptor has\n. less than k possible matches in total.\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors.\n. \n. These extended variants of DescriptorMatcher::match methods find several best matches for each query\n. descriptor. The matches are returned in the distance increasing order. See DescriptorMatcher::match\n. for the details about query and train descriptors.\n\n\n\nknnMatch(queryDescriptors, k[, masks[, compactResult]]) -> matches\n. @overload\n. @param queryDescriptors Query set of descriptors.\n. @param matches Matches. Each matches[i] is k or less matches for the same query descriptor.\n. @param k Count of best matches found per each query descriptor or less if a query descriptor has\n. less than k possible matches in total.\n. @param masks Set of masks. Each masks[i] specifies permissible matches between the input query\n. descriptors and stored train descriptors from the i-th image trainDescCollection[i].\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors."},
| 7351 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_match, 0), "match(queryDescriptors, trainDescriptors[, mask]) -> matches\n. @brief Finds the best match for each descriptor from a query set.\n. \n. @param queryDescriptors Query set of descriptors.\n. @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors\n. collection stored in the class object.\n. @param matches Matches. If a query descriptor is masked out in mask , no match is added for this\n. descriptor. So, matches size may be smaller than the query descriptors count.\n. @param mask Mask specifying permissible matches between an input query and train matrices of\n. descriptors.\n. \n. In the first variant of this method, the train descriptors are passed as an input argument. In the\n. second variant of the method, train descriptors collection that was set by DescriptorMatcher::add is\n. used. Optional mask (or masks) can be passed to specify which query and training descriptors can be\n. matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if\n. mask.at\\<uchar\\>(i,j) is non-zero.\n\n\n\nmatch(queryDescriptors[, masks]) -> matches\n. @overload\n. @param queryDescriptors Query set of descriptors.\n. @param matches Matches. If a query descriptor is masked out in mask , no match is added for this\n. descriptor. So, matches size may be smaller than the query descriptors count.\n. @param masks Set of masks. Each masks[i] specifies permissible matches between the input query\n. descriptors and stored train descriptors from the i-th image trainDescCollection[i]."}, |  | 7351 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_match, 0), "match(queryDescriptors, trainDescriptors[, mask]) -> matches\n. @brief Finds the best match for each descriptor from a query set.\n. \n. @param queryDescriptors Query set of descriptors.\n. @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors\n. collection stored in the class object.\n. @param matches Matches. If a query descriptor is masked out in mask , no match is added for this\n. descriptor. So, matches size may be smaller than the query descriptors count.\n. @param mask Mask specifying permissible matches between an input query and train matrices of\n. descriptors.\n. \n. In the first variant of this method, the train descriptors are passed as an input argument. In the\n. second variant of the method, train descriptors collection that was set by DescriptorMatcher::add is\n. used. Optional mask (or masks) can be passed to specify which query and training descriptors can be\n. matched. Namely, queryDescriptors[i] can be matched with trainDescriptors[j] only if\n. mask.at\\<uchar\\>(i,j) is non-zero.\n\n\n\nmatch(queryDescriptors[, masks]) -> matches\n. @overload\n. @param queryDescriptors Query set of descriptors.\n. @param matches Matches. If a query descriptor is masked out in mask , no match is added for this\n. descriptor. So, matches size may be smaller than the query descriptors count.\n. @param masks Set of masks. Each masks[i] specifies permissible matches between the input query\n. descriptors and stored train descriptors from the i-th image trainDescCollection[i]."},
| 7352 | {"radiusMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_radiusMatch, 0), "radiusMatch(queryDescriptors, trainDescriptors, maxDistance[, mask[, compactResult]]) -> matches\n. @brief For each query descriptor, finds the training descriptors not farther than the specified distance.\n. \n. @param queryDescriptors Query set of descriptors.\n. @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors\n. collection stored in the class object.\n. @param matches Found matches.\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors.\n. @param maxDistance Threshold for the distance between matched descriptors. Distance means here\n. metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured\n. in Pixels)!\n. @param mask Mask specifying permissible matches between an input query and train matrices of\n. descriptors.\n. \n. For each query descriptor, the methods find such training descriptors that the distance between the\n. query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches are\n. returned in the distance increasing order.\n\n\n\nradiusMatch(queryDescriptors, maxDistance[, masks[, compactResult]]) -> matches\n. @overload\n. @param queryDescriptors Query set of descriptors.\n. @param matches Found matches.\n. @param maxDistance Threshold for the distance between matched descriptors. Distance means here\n. metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured\n. in Pixels)!\n. @param masks Set of masks. Each masks[i] specifies permissible matches between the input query\n. descriptors and stored train descriptors from the i-th image trainDescCollection[i].\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors."}, |  | 7352 | {"radiusMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_radiusMatch, 0), "radiusMatch(queryDescriptors, trainDescriptors, maxDistance[, mask[, compactResult]]) -> matches\n. @brief For each query descriptor, finds the training descriptors not farther than the specified distance.\n. \n. @param queryDescriptors Query set of descriptors.\n. @param trainDescriptors Train set of descriptors. This set is not added to the train descriptors\n. collection stored in the class object.\n. @param matches Found matches.\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors.\n. @param maxDistance Threshold for the distance between matched descriptors. Distance means here\n. metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured\n. in Pixels)!\n. @param mask Mask specifying permissible matches between an input query and train matrices of\n. descriptors.\n. \n. For each query descriptor, the methods find such training descriptors that the distance between the\n. query descriptor and the training descriptor is equal or smaller than maxDistance. Found matches are\n. returned in the distance increasing order.\n\n\n\nradiusMatch(queryDescriptors, maxDistance[, masks[, compactResult]]) -> matches\n. @overload\n. @param queryDescriptors Query set of descriptors.\n. @param matches Found matches.\n. @param maxDistance Threshold for the distance between matched descriptors. Distance means here\n. metric distance (e.g. Hamming distance), not the distance between coordinates (which is measured\n. in Pixels)!\n. @param masks Set of masks. Each masks[i] specifies permissible matches between the input query\n. descriptors and stored train descriptors from the i-th image trainDescCollection[i].\n. @param compactResult Parameter used when the mask (or masks) is not empty. If compactResult is\n. false, the matches vector has the same size as queryDescriptors rows. If compactResult is true,\n. the matches vector does not contain matches for fully masked-out query descriptors."},
| 7353 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_read, 0), "read(fileName) -> None\n. \n\n\n\nread(arg1) -> None\n."}, |  | 7353 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_read, 0), "read(fileName) -> None\n. \n\n\n\nread(arg1) -> None\n."},
| 7354 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_train, 0), "train() -> None\n. @brief Trains a descriptor matcher\n. \n. Trains a descriptor matcher (for example, the flann index). In all methods to match, the method\n. train() is run every time before matching. Some descriptor matchers (for example, BruteForceMatcher)\n. have an empty implementation of this method. Other matchers really train their inner structures (for\n. example, FlannBasedMatcher trains flann::Index )."}, |  | 7354 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_train, 0), "train() -> None\n. @brief Trains a descriptor matcher\n. \n. Trains a descriptor matcher (for example, the flann index). In all methods to match, the method\n. train() is run every time before matching. Some descriptor matchers (for example, BruteForceMatcher)\n. have an empty implementation of this method. Other matchers really train their inner structures (for\n. example, FlannBasedMatcher trains flann::Index )."},
| 7355 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_write, 0), "write(fileName) -> None\n. \n\n\n\nwrite(fs, name) -> None\n."}, |  | 7355 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_DescriptorMatcher_write, 0), "write(fileName) -> None\n. \n\n\n\nwrite(fs, name) -> None\n."},
| 7356 |  |  | 7356 |
| 7357 | {NULL, NULL} |  | 7357 | {NULL, NULL}
| 7358 | }; |  | 7358 | };
| 7359 |  |  | 7359 |
| 7360 | // Converter (DescriptorMatcher) |  | 7360 | // Converter (DescriptorMatcher)
| 7361 |  |  | 7361 |
| 7362 | template<> |  | 7362 | template<>
| 7363 | struct PyOpenCV_Converter< Ptr<cv::DescriptorMatcher> > |  | 7363 | struct PyOpenCV_Converter< Ptr<cv::DescriptorMatcher> >
| 7364 | { |  | 7364 | {
| 7365 | static PyObject* from(const Ptr<cv::DescriptorMatcher>& r) |  | 7365 | static PyObject* from(const Ptr<cv::DescriptorMatcher>& r)
| 7366 | { |  | 7366 | {
| 7367 | return pyopencv_DescriptorMatcher_Instance(r); |  | 7367 | return pyopencv_DescriptorMatcher_Instance(r);
| 7368 | } |  | 7368 | }
| 7369 | static bool to(PyObject* src, Ptr<cv::DescriptorMatcher>& dst, const ArgInfo& info) |  | 7369 | static bool to(PyObject* src, Ptr<cv::DescriptorMatcher>& dst, const ArgInfo& info)
| 7370 | { |  | 7370 | {
| 7371 | if(!src || src == Py_None) |  | 7371 | if(!src || src == Py_None)
| 7372 | return true; |  | 7372 | return true;
| 7373 | Ptr<cv::DescriptorMatcher> * dst_; |  | 7373 | Ptr<cv::DescriptorMatcher> * dst_;
| 7374 | if (pyopencv_DescriptorMatcher_getp(src, dst_)) |  | 7374 | if (pyopencv_DescriptorMatcher_getp(src, dst_))
| 7375 | { |  | 7375 | {
| 7376 | dst = *dst_; |  | 7376 | dst = *dst_;
| 7377 | return true; |  | 7377 | return true;
| 7378 | } |  | 7378 | }
| 7379 |  |  | 7379 |
| 7380 | failmsg("Expected Ptr<cv::DescriptorMatcher> for argument '%s'", info.name); |  | 7380 | failmsg("Expected Ptr<cv::DescriptorMatcher> for argument '%s'", info.name);
| 7381 | return false; |  | 7381 | return false;
| 7382 | } |  | 7382 | }
| 7383 | }; |  | 7383 | };
| 7384 |  |  | 7384 |
| 7385 | //================================================================================ |  | 7385 | //================================================================================
| 7386 | // EMDHistogramCostExtractor (Generic) |  | 7386 | // EMDHistogramCostExtractor (Generic)
| 7387 | //================================================================================ |  | 7387 | //================================================================================
| 7388 |  |  | 7388 |
| 7389 | // GetSet (EMDHistogramCostExtractor) |  | 7389 | // GetSet (EMDHistogramCostExtractor)
| 7390 |  |  | 7390 |
| 7391 |  |  | 7391 |
| 7392 |  |  | 7392 |
| 7393 | // Methods (EMDHistogramCostExtractor) |  | 7393 | // Methods (EMDHistogramCostExtractor)
| 7394 |  |  | 7394 |
| 7395 | static PyObject* pyopencv_cv_EMDHistogramCostExtractor_getNormFlag(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7395 | static PyObject* pyopencv_cv_EMDHistogramCostExtractor_getNormFlag(PyObject* self, PyObject* py_args, PyObject* kw)
| 7396 | { |  | 7396 | {
| 7397 | using namespace cv; |  | 7397 | using namespace cv;
| 7398 |  |  | 7398 |
| 7399 |  |  | 7399 |
| 7400 | Ptr<cv::EMDHistogramCostExtractor> * self1 = 0; |  | 7400 | Ptr<cv::EMDHistogramCostExtractor> * self1 = 0;
| 7401 | if (!pyopencv_EMDHistogramCostExtractor_getp(self, self1)) |  | 7401 | if (!pyopencv_EMDHistogramCostExtractor_getp(self, self1))
| 7402 | return failmsgp("Incorrect type of self (must be 'EMDHistogramCostExtractor' or its derivative)"); |  | 7402 | return failmsgp("Incorrect type of self (must be 'EMDHistogramCostExtractor' or its derivative)");
| 7403 | Ptr<cv::EMDHistogramCostExtractor> _self_ = *(self1); |  | 7403 | Ptr<cv::EMDHistogramCostExtractor> _self_ = *(self1);
| 7404 | int retval; |  | 7404 | int retval;
| 7405 |  |  | 7405 |
| 7406 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 7406 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 7407 | { |  | 7407 | {
| 7408 | ERRWRAP2(retval = _self_->getNormFlag()); |  | 7408 | ERRWRAP2(retval = _self_->getNormFlag());
| 7409 | return pyopencv_from(retval); |  | 7409 | return pyopencv_from(retval);
| 7410 | } |  | 7410 | }
| 7411 |  |  | 7411 |
| 7412 | return NULL; |  | 7412 | return NULL;
| 7413 | } |  | 7413 | }
| 7414 |  |  | 7414 |
| 7415 | static PyObject* pyopencv_cv_EMDHistogramCostExtractor_setNormFlag(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7415 | static PyObject* pyopencv_cv_EMDHistogramCostExtractor_setNormFlag(PyObject* self, PyObject* py_args, PyObject* kw)
| 7416 | { |  | 7416 | {
| 7417 | using namespace cv; |  | 7417 | using namespace cv;
| 7418 |  |  | 7418 |
| 7419 |  |  | 7419 |
| 7420 | Ptr<cv::EMDHistogramCostExtractor> * self1 = 0; |  | 7420 | Ptr<cv::EMDHistogramCostExtractor> * self1 = 0;
| 7421 | if (!pyopencv_EMDHistogramCostExtractor_getp(self, self1)) |  | 7421 | if (!pyopencv_EMDHistogramCostExtractor_getp(self, self1))
| 7422 | return failmsgp("Incorrect type of self (must be 'EMDHistogramCostExtractor' or its derivative)"); |  | 7422 | return failmsgp("Incorrect type of self (must be 'EMDHistogramCostExtractor' or its derivative)");
| 7423 | Ptr<cv::EMDHistogramCostExtractor> _self_ = *(self1); |  | 7423 | Ptr<cv::EMDHistogramCostExtractor> _self_ = *(self1);
| 7424 | PyObject* pyobj_flag = NULL; |  | 7424 | PyObject* pyobj_flag = NULL;
| 7425 | int flag=0; |  | 7425 | int flag=0;
| 7426 |  |  | 7426 |
| 7427 | const char* keywords[] = { "flag", NULL }; |  | 7427 | const char* keywords[] = { "flag", NULL };
| 7428 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:EMDHistogramCostExtractor.setNormFlag", (char**)keywords, &pyobj_flag) && |  | 7428 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:EMDHistogramCostExtractor.setNormFlag", (char**)keywords, &pyobj_flag) &&
| 7429 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) ) |  | 7429 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) )
| 7430 | { |  | 7430 | {
| 7431 | ERRWRAP2(_self_->setNormFlag(flag)); |  | 7431 | ERRWRAP2(_self_->setNormFlag(flag));
| 7432 | Py_RETURN_NONE; |  | 7432 | Py_RETURN_NONE;
| 7433 | } |  | 7433 | }
| 7434 |  |  | 7434 |
| 7435 | return NULL; |  | 7435 | return NULL;
| 7436 | } |  | 7436 | }
| 7437 |  |  | 7437 |
| 7438 |  |  | 7438 |
| 7439 |  |  | 7439 |
| 7440 | // Tables (EMDHistogramCostExtractor) |  | 7440 | // Tables (EMDHistogramCostExtractor)
| 7441 |  |  | 7441 |
| 7442 | static PyGetSetDef pyopencv_EMDHistogramCostExtractor_getseters[] = |  | 7442 | static PyGetSetDef pyopencv_EMDHistogramCostExtractor_getseters[] =
| 7443 | { |  | 7443 | {
| 7444 | {NULL} /* Sentinel */ |  | 7444 | {NULL} /* Sentinel */
| 7445 | }; |  | 7445 | };
| 7446 |  |  | 7446 |
| 7447 | static PyMethodDef pyopencv_EMDHistogramCostExtractor_methods[] = |  | 7447 | static PyMethodDef pyopencv_EMDHistogramCostExtractor_methods[] =
| 7448 | { |  | 7448 | {
| 7449 | {"getNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_EMDHistogramCostExtractor_getNormFlag, 0), "getNormFlag() -> retval\n."}, |  | 7449 | {"getNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_EMDHistogramCostExtractor_getNormFlag, 0), "getNormFlag() -> retval\n."},
| 7450 | {"setNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_EMDHistogramCostExtractor_setNormFlag, 0), "setNormFlag(flag) -> None\n."}, |  | 7450 | {"setNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_EMDHistogramCostExtractor_setNormFlag, 0), "setNormFlag(flag) -> None\n."},
| 7451 |  |  | 7451 |
| 7452 | {NULL, NULL} |  | 7452 | {NULL, NULL}
| 7453 | }; |  | 7453 | };
| 7454 |  |  | 7454 |
| 7455 | // Converter (EMDHistogramCostExtractor) |  | 7455 | // Converter (EMDHistogramCostExtractor)
| 7456 |  |  | 7456 |
| 7457 | template<> |  | 7457 | template<>
| 7458 | struct PyOpenCV_Converter< Ptr<cv::EMDHistogramCostExtractor> > |  | 7458 | struct PyOpenCV_Converter< Ptr<cv::EMDHistogramCostExtractor> >
| 7459 | { |  | 7459 | {
| 7460 | static PyObject* from(const Ptr<cv::EMDHistogramCostExtractor>& r) |  | 7460 | static PyObject* from(const Ptr<cv::EMDHistogramCostExtractor>& r)
| 7461 | { |  | 7461 | {
| 7462 | return pyopencv_EMDHistogramCostExtractor_Instance(r); |  | 7462 | return pyopencv_EMDHistogramCostExtractor_Instance(r);
| 7463 | } |  | 7463 | }
| 7464 | static bool to(PyObject* src, Ptr<cv::EMDHistogramCostExtractor>& dst, const ArgInfo& info) |  | 7464 | static bool to(PyObject* src, Ptr<cv::EMDHistogramCostExtractor>& dst, const ArgInfo& info)
| 7465 | { |  | 7465 | {
| 7466 | if(!src || src == Py_None) |  | 7466 | if(!src || src == Py_None)
| 7467 | return true; |  | 7467 | return true;
| 7468 | Ptr<cv::EMDHistogramCostExtractor> * dst_; |  | 7468 | Ptr<cv::EMDHistogramCostExtractor> * dst_;
| 7469 | if (pyopencv_EMDHistogramCostExtractor_getp(src, dst_)) |  | 7469 | if (pyopencv_EMDHistogramCostExtractor_getp(src, dst_))
| 7470 | { |  | 7470 | {
| 7471 | dst = *dst_; |  | 7471 | dst = *dst_;
| 7472 | return true; |  | 7472 | return true;
| 7473 | } |  | 7473 | }
| 7474 |  |  | 7474 |
| 7475 | failmsg("Expected Ptr<cv::EMDHistogramCostExtractor> for argument '%s'", info.name); |  | 7475 | failmsg("Expected Ptr<cv::EMDHistogramCostExtractor> for argument '%s'", info.name);
| 7476 | return false; |  | 7476 | return false;
| 7477 | } |  | 7477 | }
| 7478 | }; |  | 7478 | };
| 7479 |  |  | 7479 |
| 7480 | //================================================================================ |  | 7480 | //================================================================================
| 7481 | // EMDL1HistogramCostExtractor (Generic) |  | 7481 | // EMDL1HistogramCostExtractor (Generic)
| 7482 | //================================================================================ |  | 7482 | //================================================================================
| 7483 |  |  | 7483 |
| 7484 | // GetSet (EMDL1HistogramCostExtractor) |  | 7484 | // GetSet (EMDL1HistogramCostExtractor)
| 7485 |  |  | 7485 |
| 7486 |  |  | 7486 |
| 7487 |  |  | 7487 |
| 7488 | // Methods (EMDL1HistogramCostExtractor) |  | 7488 | // Methods (EMDL1HistogramCostExtractor)
| 7489 |  |  | 7489 |
| 7490 |  |  | 7490 |
| 7491 |  |  | 7491 |
| 7492 | // Tables (EMDL1HistogramCostExtractor) |  | 7492 | // Tables (EMDL1HistogramCostExtractor)
| 7493 |  |  | 7493 |
| 7494 | static PyGetSetDef pyopencv_EMDL1HistogramCostExtractor_getseters[] = |  | 7494 | static PyGetSetDef pyopencv_EMDL1HistogramCostExtractor_getseters[] =
| 7495 | { |  | 7495 | {
| 7496 | {NULL} /* Sentinel */ |  | 7496 | {NULL} /* Sentinel */
| 7497 | }; |  | 7497 | };
| 7498 |  |  | 7498 |
| 7499 | static PyMethodDef pyopencv_EMDL1HistogramCostExtractor_methods[] = |  | 7499 | static PyMethodDef pyopencv_EMDL1HistogramCostExtractor_methods[] =
| 7500 | { |  | 7500 | {
| 7501 |  |  | 7501 |
| 7502 | {NULL, NULL} |  | 7502 | {NULL, NULL}
| 7503 | }; |  | 7503 | };
| 7504 |  |  | 7504 |
| 7505 | // Converter (EMDL1HistogramCostExtractor) |  | 7505 | // Converter (EMDL1HistogramCostExtractor)
| 7506 |  |  | 7506 |
| 7507 | template<> |  | 7507 | template<>
| 7508 | struct PyOpenCV_Converter< Ptr<cv::EMDL1HistogramCostExtractor> > |  | 7508 | struct PyOpenCV_Converter< Ptr<cv::EMDL1HistogramCostExtractor> >
| 7509 | { |  | 7509 | {
| 7510 | static PyObject* from(const Ptr<cv::EMDL1HistogramCostExtractor>& r) |  | 7510 | static PyObject* from(const Ptr<cv::EMDL1HistogramCostExtractor>& r)
| 7511 | { |  | 7511 | {
| 7512 | return pyopencv_EMDL1HistogramCostExtractor_Instance(r); |  | 7512 | return pyopencv_EMDL1HistogramCostExtractor_Instance(r);
| 7513 | } |  | 7513 | }
| 7514 | static bool to(PyObject* src, Ptr<cv::EMDL1HistogramCostExtractor>& dst, const ArgInfo& info) |  | 7514 | static bool to(PyObject* src, Ptr<cv::EMDL1HistogramCostExtractor>& dst, const ArgInfo& info)
| 7515 | { |  | 7515 | {
| 7516 | if(!src || src == Py_None) |  | 7516 | if(!src || src == Py_None)
| 7517 | return true; |  | 7517 | return true;
| 7518 | Ptr<cv::EMDL1HistogramCostExtractor> * dst_; |  | 7518 | Ptr<cv::EMDL1HistogramCostExtractor> * dst_;
| 7519 | if (pyopencv_EMDL1HistogramCostExtractor_getp(src, dst_)) |  | 7519 | if (pyopencv_EMDL1HistogramCostExtractor_getp(src, dst_))
| 7520 | { |  | 7520 | {
| 7521 | dst = *dst_; |  | 7521 | dst = *dst_;
| 7522 | return true; |  | 7522 | return true;
| 7523 | } |  | 7523 | }
| 7524 |  |  | 7524 |
| 7525 | failmsg("Expected Ptr<cv::EMDL1HistogramCostExtractor> for argument '%s'", info.name); |  | 7525 | failmsg("Expected Ptr<cv::EMDL1HistogramCostExtractor> for argument '%s'", info.name);
| 7526 | return false; |  | 7526 | return false;
| 7527 | } |  | 7527 | }
| 7528 | }; |  | 7528 | };
| 7529 |  |  | 7529 |
| 7530 | //================================================================================ |  | 7530 | //================================================================================
| 7531 | // FaceDetectorYN (Generic) |  | 7531 | // FaceDetectorYN (Generic)
| 7532 | //================================================================================ |  | 7532 | //================================================================================
| 7533 |  |  | 7533 |
| 7534 | // GetSet (FaceDetectorYN) |  | 7534 | // GetSet (FaceDetectorYN)
| 7535 |  |  | 7535 |
| 7536 |  |  | 7536 |
| 7537 |  |  | 7537 |
| 7538 | // Methods (FaceDetectorYN) |  | 7538 | // Methods (FaceDetectorYN)
| 7539 |  |  | 7539 |
| 7540 | static PyObject* pyopencv_cv_FaceDetectorYN_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7540 | static PyObject* pyopencv_cv_FaceDetectorYN_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 7541 | { |  | 7541 | {
| 7542 | using namespace cv; |  | 7542 | using namespace cv;
| 7543 |  |  | 7543 |
| 7544 | pyPrepareArgumentConversionErrorsStorage(2); |  | 7544 | pyPrepareArgumentConversionErrorsStorage(2);
| 7545 |  |  | 7545 |
| 7546 | { |  | 7546 | {
| 7547 | PyObject* pyobj_model = NULL; |  | 7547 | PyObject* pyobj_model = NULL;
| 7548 | String model; |  | 7548 | String model;
| 7549 | PyObject* pyobj_config = NULL; |  | 7549 | PyObject* pyobj_config = NULL;
| 7550 | String config; |  | 7550 | String config;
| 7551 | PyObject* pyobj_input_size = NULL; |  | 7551 | PyObject* pyobj_input_size = NULL;
| 7552 | Size input_size; |  | 7552 | Size input_size;
| 7553 | PyObject* pyobj_score_threshold = NULL; |  | 7553 | PyObject* pyobj_score_threshold = NULL;
| 7554 | float score_threshold=0.9f; |  | 7554 | float score_threshold=0.9f;
| 7555 | PyObject* pyobj_nms_threshold = NULL; |  | 7555 | PyObject* pyobj_nms_threshold = NULL;
| 7556 | float nms_threshold=0.3f; |  | 7556 | float nms_threshold=0.3f;
| 7557 | PyObject* pyobj_top_k = NULL; |  | 7557 | PyObject* pyobj_top_k = NULL;
| 7558 | int top_k=5000; |  | 7558 | int top_k=5000;
| 7559 | PyObject* pyobj_backend_id = NULL; |  | 7559 | PyObject* pyobj_backend_id = NULL;
| 7560 | int backend_id=0; |  | 7560 | int backend_id=0;
| 7561 | PyObject* pyobj_target_id = NULL; |  | 7561 | PyObject* pyobj_target_id = NULL;
| 7562 | int target_id=0; |  | 7562 | int target_id=0;
| 7563 | Ptr<FaceDetectorYN> retval; |  | 7563 | Ptr<FaceDetectorYN> retval;
| 7564 |  |  | 7564 |
| 7565 | const char* keywords[] = { "model", "config", "input_size", "score_threshold", "nms_threshold", "top_k", "backend_id", "target_id", NULL }; |  | 7565 | const char* keywords[] = { "model", "config", "input_size", "score_threshold", "nms_threshold", "top_k", "backend_id", "target_id", NULL };
| 7566 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOOO:FaceDetectorYN.create", (char**)keywords, &pyobj_model, &pyobj_config, &pyobj_input_size, &pyobj_score_threshold, &pyobj_nms_threshold, &pyobj_top_k, &pyobj_backend_id, &pyobj_target_id) && |  | 7566 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOOO:FaceDetectorYN.create", (char**)keywords, &pyobj_model, &pyobj_config, &pyobj_input_size, &pyobj_score_threshold, &pyobj_nms_threshold, &pyobj_top_k, &pyobj_backend_id, &pyobj_target_id) &&
| 7567 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 7567 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 7568 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) && |  | 7568 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) &&
| 7569 | pyopencv_to_safe(pyobj_input_size, input_size, ArgInfo("input_size", 0)) && |  | 7569 | pyopencv_to_safe(pyobj_input_size, input_size, ArgInfo("input_size", 0)) &&
| 7570 | pyopencv_to_safe(pyobj_score_threshold, score_threshold, ArgInfo("score_threshold", 0)) && |  | 7570 | pyopencv_to_safe(pyobj_score_threshold, score_threshold, ArgInfo("score_threshold", 0)) &&
| 7571 | pyopencv_to_safe(pyobj_nms_threshold, nms_threshold, ArgInfo("nms_threshold", 0)) && |  | 7571 | pyopencv_to_safe(pyobj_nms_threshold, nms_threshold, ArgInfo("nms_threshold", 0)) &&
| 7572 | pyopencv_to_safe(pyobj_top_k, top_k, ArgInfo("top_k", 0)) && |  | 7572 | pyopencv_to_safe(pyobj_top_k, top_k, ArgInfo("top_k", 0)) &&
| 7573 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) && |  | 7573 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) &&
| 7574 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) ) |  | 7574 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) )
| 7575 | { |  | 7575 | {
| 7576 | ERRWRAP2(retval = cv::FaceDetectorYN::create(model, config, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id)); |  | 7576 | ERRWRAP2(retval = cv::FaceDetectorYN::create(model, config, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id));
| 7577 | return pyopencv_from(retval); |  | 7577 | return pyopencv_from(retval);
| 7578 | } |  | 7578 | }
| 7579 |  |  | 7579 |
| 7580 |  |  | 7580 |
| 7581 | pyPopulateArgumentConversionErrors(); |  | 7581 | pyPopulateArgumentConversionErrors();
| 7582 | } |  | 7582 | }
| 7583 |  |  | 7583 |
| 7584 |  |  | 7584 |
| 7585 | { |  | 7585 | {
| 7586 | PyObject* pyobj_framework = NULL; |  | 7586 | PyObject* pyobj_framework = NULL;
| 7587 | String framework; |  | 7587 | String framework;
| 7588 | PyObject* pyobj_bufferModel = NULL; |  | 7588 | PyObject* pyobj_bufferModel = NULL;
| 7589 | vector_uchar bufferModel; |  | 7589 | vector_uchar bufferModel;
| 7590 | PyObject* pyobj_bufferConfig = NULL; |  | 7590 | PyObject* pyobj_bufferConfig = NULL;
| 7591 | vector_uchar bufferConfig; |  | 7591 | vector_uchar bufferConfig;
| 7592 | PyObject* pyobj_input_size = NULL; |  | 7592 | PyObject* pyobj_input_size = NULL;
| 7593 | Size input_size; |  | 7593 | Size input_size;
| 7594 | PyObject* pyobj_score_threshold = NULL; |  | 7594 | PyObject* pyobj_score_threshold = NULL;
| 7595 | float score_threshold=0.9f; |  | 7595 | float score_threshold=0.9f;
| 7596 | PyObject* pyobj_nms_threshold = NULL; |  | 7596 | PyObject* pyobj_nms_threshold = NULL;
| 7597 | float nms_threshold=0.3f; |  | 7597 | float nms_threshold=0.3f;
| 7598 | PyObject* pyobj_top_k = NULL; |  | 7598 | PyObject* pyobj_top_k = NULL;
| 7599 | int top_k=5000; |  | 7599 | int top_k=5000;
| 7600 | PyObject* pyobj_backend_id = NULL; |  | 7600 | PyObject* pyobj_backend_id = NULL;
| 7601 | int backend_id=0; |  | 7601 | int backend_id=0;
| 7602 | PyObject* pyobj_target_id = NULL; |  | 7602 | PyObject* pyobj_target_id = NULL;
| 7603 | int target_id=0; |  | 7603 | int target_id=0;
| 7604 | Ptr<FaceDetectorYN> retval; |  | 7604 | Ptr<FaceDetectorYN> retval;
| 7605 |  |  | 7605 |
| 7606 | const char* keywords[] = { "framework", "bufferModel", "bufferConfig", "input_size", "score_threshold", "nms_threshold", "top_k", "backend_id", "target_id", NULL }; |  | 7606 | const char* keywords[] = { "framework", "bufferModel", "bufferConfig", "input_size", "score_threshold", "nms_threshold", "top_k", "backend_id", "target_id", NULL };
| 7607 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OOOOO:FaceDetectorYN.create", (char**)keywords, &pyobj_framework, &pyobj_bufferModel, &pyobj_bufferConfig, &pyobj_input_size, &pyobj_score_threshold, &pyobj_nms_threshold, &pyobj_top_k, &pyobj_backend_id, &pyobj_target_id) && |  | 7607 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OOOOO:FaceDetectorYN.create", (char**)keywords, &pyobj_framework, &pyobj_bufferModel, &pyobj_bufferConfig, &pyobj_input_size, &pyobj_score_threshold, &pyobj_nms_threshold, &pyobj_top_k, &pyobj_backend_id, &pyobj_target_id) &&
| 7608 | pyopencv_to_safe(pyobj_framework, framework, ArgInfo("framework", 0)) && |  | 7608 | pyopencv_to_safe(pyobj_framework, framework, ArgInfo("framework", 0)) &&
| 7609 | pyopencv_to_safe(pyobj_bufferModel, bufferModel, ArgInfo("bufferModel", 0)) && |  | 7609 | pyopencv_to_safe(pyobj_bufferModel, bufferModel, ArgInfo("bufferModel", 0)) &&
| 7610 | pyopencv_to_safe(pyobj_bufferConfig, bufferConfig, ArgInfo("bufferConfig", 0)) && |  | 7610 | pyopencv_to_safe(pyobj_bufferConfig, bufferConfig, ArgInfo("bufferConfig", 0)) &&
| 7611 | pyopencv_to_safe(pyobj_input_size, input_size, ArgInfo("input_size", 0)) && |  | 7611 | pyopencv_to_safe(pyobj_input_size, input_size, ArgInfo("input_size", 0)) &&
| 7612 | pyopencv_to_safe(pyobj_score_threshold, score_threshold, ArgInfo("score_threshold", 0)) && |  | 7612 | pyopencv_to_safe(pyobj_score_threshold, score_threshold, ArgInfo("score_threshold", 0)) &&
| 7613 | pyopencv_to_safe(pyobj_nms_threshold, nms_threshold, ArgInfo("nms_threshold", 0)) && |  | 7613 | pyopencv_to_safe(pyobj_nms_threshold, nms_threshold, ArgInfo("nms_threshold", 0)) &&
| 7614 | pyopencv_to_safe(pyobj_top_k, top_k, ArgInfo("top_k", 0)) && |  | 7614 | pyopencv_to_safe(pyobj_top_k, top_k, ArgInfo("top_k", 0)) &&
| 7615 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) && |  | 7615 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) &&
| 7616 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) ) |  | 7616 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) )
| 7617 | { |  | 7617 | {
| 7618 | ERRWRAP2(retval = cv::FaceDetectorYN::create(framework, bufferModel, bufferConfig, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id)); |  | 7618 | ERRWRAP2(retval = cv::FaceDetectorYN::create(framework, bufferModel, bufferConfig, input_size, score_threshold, nms_threshold, top_k, backend_id, target_id));
| 7619 | return pyopencv_from(retval); |  | 7619 | return pyopencv_from(retval);
| 7620 | } |  | 7620 | }
| 7621 |  |  | 7621 |
| 7622 |  |  | 7622 |
| 7623 | pyPopulateArgumentConversionErrors(); |  | 7623 | pyPopulateArgumentConversionErrors();
| 7624 | } |  | 7624 | }
| 7625 | pyRaiseCVOverloadException("create"); |  | 7625 | pyRaiseCVOverloadException("create");
| 7626 |  |  | 7626 |
| 7627 | return NULL; |  | 7627 | return NULL;
| 7628 | } |  | 7628 | }
| 7629 |  |  | 7629 |
| 7630 | static PyObject* pyopencv_cv_FaceDetectorYN_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7630 | static PyObject* pyopencv_cv_FaceDetectorYN_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 7631 | { |  | 7631 | {
| 7632 | using namespace cv; |  | 7632 | using namespace cv;
| 7633 |  |  | 7633 |
| 7634 |  |  | 7634 |
| 7635 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7635 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7636 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7636 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7637 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7637 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7638 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7638 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7639 | pyPrepareArgumentConversionErrorsStorage(2); |  | 7639 | pyPrepareArgumentConversionErrorsStorage(2);
| 7640 |  |  | 7640 |
| 7641 | { |  | 7641 | {
| 7642 | PyObject* pyobj_image = NULL; |  | 7642 | PyObject* pyobj_image = NULL;
| 7643 | Mat image; |  | 7643 | Mat image;
| 7644 | PyObject* pyobj_faces = NULL; |  | 7644 | PyObject* pyobj_faces = NULL;
| 7645 | Mat faces; |  | 7645 | Mat faces;
| 7646 | int retval; |  | 7646 | int retval;
| 7647 |  |  | 7647 |
| 7648 | const char* keywords[] = { "image", "faces", NULL }; |  | 7648 | const char* keywords[] = { "image", "faces", NULL };
| 7649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceDetectorYN.detect", (char**)keywords, &pyobj_image, &pyobj_faces) && |  | 7649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceDetectorYN.detect", (char**)keywords, &pyobj_image, &pyobj_faces) &&
| 7650 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 7650 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 7651 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 1)) ) |  | 7651 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 1)) )
| 7652 | { |  | 7652 | {
| 7653 | ERRWRAP2(retval = _self_->detect(image, faces)); |  | 7653 | ERRWRAP2(retval = _self_->detect(image, faces));
| 7654 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(faces)); |  | 7654 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(faces));
| 7655 | } |  | 7655 | }
| 7656 |  |  | 7656 |
| 7657 |  |  | 7657 |
| 7658 | pyPopulateArgumentConversionErrors(); |  | 7658 | pyPopulateArgumentConversionErrors();
| 7659 | } |  | 7659 | }
| 7660 |  |  | 7660 |
| 7661 |  |  | 7661 |
| 7662 | { |  | 7662 | {
| 7663 | PyObject* pyobj_image = NULL; |  | 7663 | PyObject* pyobj_image = NULL;
| 7664 | UMat image; |  | 7664 | UMat image;
| 7665 | PyObject* pyobj_faces = NULL; |  | 7665 | PyObject* pyobj_faces = NULL;
| 7666 | UMat faces; |  | 7666 | UMat faces;
| 7667 | int retval; |  | 7667 | int retval;
| 7668 |  |  | 7668 |
| 7669 | const char* keywords[] = { "image", "faces", NULL }; |  | 7669 | const char* keywords[] = { "image", "faces", NULL };
| 7670 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceDetectorYN.detect", (char**)keywords, &pyobj_image, &pyobj_faces) && |  | 7670 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceDetectorYN.detect", (char**)keywords, &pyobj_image, &pyobj_faces) &&
| 7671 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 7671 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 7672 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 1)) ) |  | 7672 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 1)) )
| 7673 | { |  | 7673 | {
| 7674 | ERRWRAP2(retval = _self_->detect(image, faces)); |  | 7674 | ERRWRAP2(retval = _self_->detect(image, faces));
| 7675 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(faces)); |  | 7675 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(faces));
| 7676 | } |  | 7676 | }
| 7677 |  |  | 7677 |
| 7678 |  |  | 7678 |
| 7679 | pyPopulateArgumentConversionErrors(); |  | 7679 | pyPopulateArgumentConversionErrors();
| 7680 | } |  | 7680 | }
| 7681 | pyRaiseCVOverloadException("detect"); |  | 7681 | pyRaiseCVOverloadException("detect");
| 7682 |  |  | 7682 |
| 7683 | return NULL; |  | 7683 | return NULL;
| 7684 | } |  | 7684 | }
| 7685 |  |  | 7685 |
| 7686 | static PyObject* pyopencv_cv_FaceDetectorYN_getInputSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7686 | static PyObject* pyopencv_cv_FaceDetectorYN_getInputSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 7687 | { |  | 7687 | {
| 7688 | using namespace cv; |  | 7688 | using namespace cv;
| 7689 |  |  | 7689 |
| 7690 |  |  | 7690 |
| 7691 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7691 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7692 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7692 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7693 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7693 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7694 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7694 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7695 | Size retval; |  | 7695 | Size retval;
| 7696 |  |  | 7696 |
| 7697 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 7697 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 7698 | { |  | 7698 | {
| 7699 | ERRWRAP2(retval = _self_->getInputSize()); |  | 7699 | ERRWRAP2(retval = _self_->getInputSize());
| 7700 | return pyopencv_from(retval); |  | 7700 | return pyopencv_from(retval);
| 7701 | } |  | 7701 | }
| 7702 |  |  | 7702 |
| 7703 | return NULL; |  | 7703 | return NULL;
| 7704 | } |  | 7704 | }
| 7705 |  |  | 7705 |
| 7706 | static PyObject* pyopencv_cv_FaceDetectorYN_getNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7706 | static PyObject* pyopencv_cv_FaceDetectorYN_getNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 7707 | { |  | 7707 | {
| 7708 | using namespace cv; |  | 7708 | using namespace cv;
| 7709 |  |  | 7709 |
| 7710 |  |  | 7710 |
| 7711 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7711 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7712 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7712 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7713 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7713 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7714 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7714 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7715 | float retval; |  | 7715 | float retval;
| 7716 |  |  | 7716 |
| 7717 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 7717 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 7718 | { |  | 7718 | {
| 7719 | ERRWRAP2(retval = _self_->getNMSThreshold()); |  | 7719 | ERRWRAP2(retval = _self_->getNMSThreshold());
| 7720 | return pyopencv_from(retval); |  | 7720 | return pyopencv_from(retval);
| 7721 | } |  | 7721 | }
| 7722 |  |  | 7722 |
| 7723 | return NULL; |  | 7723 | return NULL;
| 7724 | } |  | 7724 | }
| 7725 |  |  | 7725 |
| 7726 | static PyObject* pyopencv_cv_FaceDetectorYN_getScoreThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7726 | static PyObject* pyopencv_cv_FaceDetectorYN_getScoreThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 7727 | { |  | 7727 | {
| 7728 | using namespace cv; |  | 7728 | using namespace cv;
| 7729 |  |  | 7729 |
| 7730 |  |  | 7730 |
| 7731 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7731 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7732 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7732 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7733 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7733 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7734 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7734 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7735 | float retval; |  | 7735 | float retval;
| 7736 |  |  | 7736 |
| 7737 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 7737 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 7738 | { |  | 7738 | {
| 7739 | ERRWRAP2(retval = _self_->getScoreThreshold()); |  | 7739 | ERRWRAP2(retval = _self_->getScoreThreshold());
| 7740 | return pyopencv_from(retval); |  | 7740 | return pyopencv_from(retval);
| 7741 | } |  | 7741 | }
| 7742 |  |  | 7742 |
| 7743 | return NULL; |  | 7743 | return NULL;
| 7744 | } |  | 7744 | }
| 7745 |  |  | 7745 |
| 7746 | static PyObject* pyopencv_cv_FaceDetectorYN_getTopK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7746 | static PyObject* pyopencv_cv_FaceDetectorYN_getTopK(PyObject* self, PyObject* py_args, PyObject* kw)
| 7747 | { |  | 7747 | {
| 7748 | using namespace cv; |  | 7748 | using namespace cv;
| 7749 |  |  | 7749 |
| 7750 |  |  | 7750 |
| 7751 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7751 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7752 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7752 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7753 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7753 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7754 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7754 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7755 | int retval; |  | 7755 | int retval;
| 7756 |  |  | 7756 |
| 7757 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 7757 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 7758 | { |  | 7758 | {
| 7759 | ERRWRAP2(retval = _self_->getTopK()); |  | 7759 | ERRWRAP2(retval = _self_->getTopK());
| 7760 | return pyopencv_from(retval); |  | 7760 | return pyopencv_from(retval);
| 7761 | } |  | 7761 | }
| 7762 |  |  | 7762 |
| 7763 | return NULL; |  | 7763 | return NULL;
| 7764 | } |  | 7764 | }
| 7765 |  |  | 7765 |
| 7766 | static PyObject* pyopencv_cv_FaceDetectorYN_setInputSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7766 | static PyObject* pyopencv_cv_FaceDetectorYN_setInputSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 7767 | { |  | 7767 | {
| 7768 | using namespace cv; |  | 7768 | using namespace cv;
| 7769 |  |  | 7769 |
| 7770 |  |  | 7770 |
| 7771 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7771 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7772 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7772 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7773 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7773 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7774 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7774 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7775 | PyObject* pyobj_input_size = NULL; |  | 7775 | PyObject* pyobj_input_size = NULL;
| 7776 | Size input_size; |  | 7776 | Size input_size;
| 7777 |  |  | 7777 |
| 7778 | const char* keywords[] = { "input_size", NULL }; |  | 7778 | const char* keywords[] = { "input_size", NULL };
| 7779 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setInputSize", (char**)keywords, &pyobj_input_size) && |  | 7779 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setInputSize", (char**)keywords, &pyobj_input_size) &&
| 7780 | pyopencv_to_safe(pyobj_input_size, input_size, ArgInfo("input_size", 0)) ) |  | 7780 | pyopencv_to_safe(pyobj_input_size, input_size, ArgInfo("input_size", 0)) )
| 7781 | { |  | 7781 | {
| 7782 | ERRWRAP2(_self_->setInputSize(input_size)); |  | 7782 | ERRWRAP2(_self_->setInputSize(input_size));
| 7783 | Py_RETURN_NONE; |  | 7783 | Py_RETURN_NONE;
| 7784 | } |  | 7784 | }
| 7785 |  |  | 7785 |
| 7786 | return NULL; |  | 7786 | return NULL;
| 7787 | } |  | 7787 | }
| 7788 |  |  | 7788 |
| 7789 | static PyObject* pyopencv_cv_FaceDetectorYN_setNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7789 | static PyObject* pyopencv_cv_FaceDetectorYN_setNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 7790 | { |  | 7790 | {
| 7791 | using namespace cv; |  | 7791 | using namespace cv;
| 7792 |  |  | 7792 |
| 7793 |  |  | 7793 |
| 7794 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7794 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7795 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7795 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7796 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7796 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7797 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7797 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7798 | PyObject* pyobj_nms_threshold = NULL; |  | 7798 | PyObject* pyobj_nms_threshold = NULL;
| 7799 | float nms_threshold=0.f; |  | 7799 | float nms_threshold=0.f;
| 7800 |  |  | 7800 |
| 7801 | const char* keywords[] = { "nms_threshold", NULL }; |  | 7801 | const char* keywords[] = { "nms_threshold", NULL };
| 7802 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setNMSThreshold", (char**)keywords, &pyobj_nms_threshold) && |  | 7802 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setNMSThreshold", (char**)keywords, &pyobj_nms_threshold) &&
| 7803 | pyopencv_to_safe(pyobj_nms_threshold, nms_threshold, ArgInfo("nms_threshold", 0)) ) |  | 7803 | pyopencv_to_safe(pyobj_nms_threshold, nms_threshold, ArgInfo("nms_threshold", 0)) )
| 7804 | { |  | 7804 | {
| 7805 | ERRWRAP2(_self_->setNMSThreshold(nms_threshold)); |  | 7805 | ERRWRAP2(_self_->setNMSThreshold(nms_threshold));
| 7806 | Py_RETURN_NONE; |  | 7806 | Py_RETURN_NONE;
| 7807 | } |  | 7807 | }
| 7808 |  |  | 7808 |
| 7809 | return NULL; |  | 7809 | return NULL;
| 7810 | } |  | 7810 | }
| 7811 |  |  | 7811 |
| 7812 | static PyObject* pyopencv_cv_FaceDetectorYN_setScoreThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7812 | static PyObject* pyopencv_cv_FaceDetectorYN_setScoreThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 7813 | { |  | 7813 | {
| 7814 | using namespace cv; |  | 7814 | using namespace cv;
| 7815 |  |  | 7815 |
| 7816 |  |  | 7816 |
| 7817 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7817 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7818 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7818 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7819 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7819 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7820 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7820 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7821 | PyObject* pyobj_score_threshold = NULL; |  | 7821 | PyObject* pyobj_score_threshold = NULL;
| 7822 | float score_threshold=0.f; |  | 7822 | float score_threshold=0.f;
| 7823 |  |  | 7823 |
| 7824 | const char* keywords[] = { "score_threshold", NULL }; |  | 7824 | const char* keywords[] = { "score_threshold", NULL };
| 7825 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setScoreThreshold", (char**)keywords, &pyobj_score_threshold) && |  | 7825 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setScoreThreshold", (char**)keywords, &pyobj_score_threshold) &&
| 7826 | pyopencv_to_safe(pyobj_score_threshold, score_threshold, ArgInfo("score_threshold", 0)) ) |  | 7826 | pyopencv_to_safe(pyobj_score_threshold, score_threshold, ArgInfo("score_threshold", 0)) )
| 7827 | { |  | 7827 | {
| 7828 | ERRWRAP2(_self_->setScoreThreshold(score_threshold)); |  | 7828 | ERRWRAP2(_self_->setScoreThreshold(score_threshold));
| 7829 | Py_RETURN_NONE; |  | 7829 | Py_RETURN_NONE;
| 7830 | } |  | 7830 | }
| 7831 |  |  | 7831 |
| 7832 | return NULL; |  | 7832 | return NULL;
| 7833 | } |  | 7833 | }
| 7834 |  |  | 7834 |
| 7835 | static PyObject* pyopencv_cv_FaceDetectorYN_setTopK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7835 | static PyObject* pyopencv_cv_FaceDetectorYN_setTopK(PyObject* self, PyObject* py_args, PyObject* kw)
| 7836 | { |  | 7836 | {
| 7837 | using namespace cv; |  | 7837 | using namespace cv;
| 7838 |  |  | 7838 |
| 7839 |  |  | 7839 |
| 7840 | Ptr<cv::FaceDetectorYN> * self1 = 0; |  | 7840 | Ptr<cv::FaceDetectorYN> * self1 = 0;
| 7841 | if (!pyopencv_FaceDetectorYN_getp(self, self1)) |  | 7841 | if (!pyopencv_FaceDetectorYN_getp(self, self1))
| 7842 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)"); |  | 7842 | return failmsgp("Incorrect type of self (must be 'FaceDetectorYN' or its derivative)");
| 7843 | Ptr<cv::FaceDetectorYN> _self_ = *(self1); |  | 7843 | Ptr<cv::FaceDetectorYN> _self_ = *(self1);
| 7844 | PyObject* pyobj_top_k = NULL; |  | 7844 | PyObject* pyobj_top_k = NULL;
| 7845 | int top_k=0; |  | 7845 | int top_k=0;
| 7846 |  |  | 7846 |
| 7847 | const char* keywords[] = { "top_k", NULL }; |  | 7847 | const char* keywords[] = { "top_k", NULL };
| 7848 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setTopK", (char**)keywords, &pyobj_top_k) && |  | 7848 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FaceDetectorYN.setTopK", (char**)keywords, &pyobj_top_k) &&
| 7849 | pyopencv_to_safe(pyobj_top_k, top_k, ArgInfo("top_k", 0)) ) |  | 7849 | pyopencv_to_safe(pyobj_top_k, top_k, ArgInfo("top_k", 0)) )
| 7850 | { |  | 7850 | {
| 7851 | ERRWRAP2(_self_->setTopK(top_k)); |  | 7851 | ERRWRAP2(_self_->setTopK(top_k));
| 7852 | Py_RETURN_NONE; |  | 7852 | Py_RETURN_NONE;
| 7853 | } |  | 7853 | }
| 7854 |  |  | 7854 |
| 7855 | return NULL; |  | 7855 | return NULL;
| 7856 | } |  | 7856 | }
| 7857 |  |  | 7857 |
| 7858 |  |  | 7858 |
| 7859 |  |  | 7859 |
| 7860 | // Tables (FaceDetectorYN) |  | 7860 | // Tables (FaceDetectorYN)
| 7861 |  |  | 7861 |
| 7862 | static PyGetSetDef pyopencv_FaceDetectorYN_getseters[] = |  | 7862 | static PyGetSetDef pyopencv_FaceDetectorYN_getseters[] =
| 7863 | { |  | 7863 | {
| 7864 | {NULL} /* Sentinel */ |  | 7864 | {NULL} /* Sentinel */
| 7865 | }; |  | 7865 | };
| 7866 |  |  | 7866 |
| 7867 | static PyMethodDef pyopencv_FaceDetectorYN_methods[] = |  | 7867 | static PyMethodDef pyopencv_FaceDetectorYN_methods[] =
| 7868 | { |  | 7868 | {
| 7869 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_create_static, METH_STATIC), "create(model, config, input_size[, score_threshold[, nms_threshold[, top_k[, backend_id[, target_id]]]]]) -> retval\n. @brief Creates an instance of face detector class with given parameters\n. *\n. * @param model the path to the requested model\n. * @param config the path to the config file for compability, which is not requested for ONNX models\n. * @param input_size the size of the input image\n. * @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value\n. * @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value\n. * @param top_k keep top K bboxes before NMS\n. * @param backend_id the id of backend\n. * @param target_id the id of target device\n\n\n\ncreate(framework, bufferModel, bufferConfig, input_size[, score_threshold[, nms_threshold[, top_k[, backend_id[, target_id]]]]]) -> retval\n. @overload\n. *\n. * @param framework Name of origin framework\n. * @param bufferModel A buffer with a content of binary file with weights\n. * @param bufferConfig A buffer with a content of text file contains network configuration\n. * @param input_size the size of the input image\n. * @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value\n. * @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value\n. * @param top_k keep top K bboxes before NMS\n. * @param backend_id the id of backend\n. * @param target_id the id of target device"}, |  | 7869 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_create_static, METH_STATIC), "create(model, config, input_size[, score_threshold[, nms_threshold[, top_k[, backend_id[, target_id]]]]]) -> retval\n. @brief Creates an instance of face detector class with given parameters\n. *\n. * @param model the path to the requested model\n. * @param config the path to the config file for compability, which is not requested for ONNX models\n. * @param input_size the size of the input image\n. * @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value\n. * @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value\n. * @param top_k keep top K bboxes before NMS\n. * @param backend_id the id of backend\n. * @param target_id the id of target device\n\n\n\ncreate(framework, bufferModel, bufferConfig, input_size[, score_threshold[, nms_threshold[, top_k[, backend_id[, target_id]]]]]) -> retval\n. @overload\n. *\n. * @param framework Name of origin framework\n. * @param bufferModel A buffer with a content of binary file with weights\n. * @param bufferConfig A buffer with a content of text file contains network configuration\n. * @param input_size the size of the input image\n. * @param score_threshold the threshold to filter out bounding boxes of score smaller than the given value\n. * @param nms_threshold the threshold to suppress bounding boxes of IoU bigger than the given value\n. * @param top_k keep top K bboxes before NMS\n. * @param backend_id the id of backend\n. * @param target_id the id of target device"},
| 7870 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_detect, 0), "detect(image[, faces]) -> retval, faces\n. @brief Detects faces in the input image. Following is an example output.\n. \n. * ![image](pics/lena-face-detection.jpg)\n. \n. * @param image an image to detect\n. * @param faces detection results stored in a 2D cv::Mat of shape [num_faces, 15]\n. * - 0-1: x, y of bbox top left corner\n. * - 2-3: width, height of bbox\n. * - 4-5: x, y of right eye (blue point in the example image)\n. * - 6-7: x, y of left eye (red point in the example image)\n. * - 8-9: x, y of nose tip (green point in the example image)\n. * - 10-11: x, y of right corner of mouth (pink point in the example image)\n. * - 12-13: x, y of left corner of mouth (yellow point in the example image)\n. * - 14: face score"}, |  | 7870 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_detect, 0), "detect(image[, faces]) -> retval, faces\n. @brief Detects faces in the input image. Following is an example output.\n. \n. * ![image](pics/lena-face-detection.jpg)\n. \n. * @param image an image to detect\n. * @param faces detection results stored in a 2D cv::Mat of shape [num_faces, 15]\n. * - 0-1: x, y of bbox top left corner\n. * - 2-3: width, height of bbox\n. * - 4-5: x, y of right eye (blue point in the example image)\n. * - 6-7: x, y of left eye (red point in the example image)\n. * - 8-9: x, y of nose tip (green point in the example image)\n. * - 10-11: x, y of right corner of mouth (pink point in the example image)\n. * - 12-13: x, y of left corner of mouth (yellow point in the example image)\n. * - 14: face score"},
| 7871 | {"getInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getInputSize, 0), "getInputSize() -> retval\n."}, |  | 7871 | {"getInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getInputSize, 0), "getInputSize() -> retval\n."},
| 7872 | {"getNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getNMSThreshold, 0), "getNMSThreshold() -> retval\n."}, |  | 7872 | {"getNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getNMSThreshold, 0), "getNMSThreshold() -> retval\n."},
| 7873 | {"getScoreThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getScoreThreshold, 0), "getScoreThreshold() -> retval\n."}, |  | 7873 | {"getScoreThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getScoreThreshold, 0), "getScoreThreshold() -> retval\n."},
| 7874 | {"getTopK", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getTopK, 0), "getTopK() -> retval\n."}, |  | 7874 | {"getTopK", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_getTopK, 0), "getTopK() -> retval\n."},
| 7875 | {"setInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setInputSize, 0), "setInputSize(input_size) -> None\n. @brief Set the size for the network input, which overwrites the input size of creating model. Call this method when the size of input image does not match the input size when creating model\n. *\n. * @param input_size the size of the input image"}, |  | 7875 | {"setInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setInputSize, 0), "setInputSize(input_size) -> None\n. @brief Set the size for the network input, which overwrites the input size of creating model. Call this method when the size of input image does not match the input size when creating model\n. *\n. * @param input_size the size of the input image"},
| 7876 | {"setNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setNMSThreshold, 0), "setNMSThreshold(nms_threshold) -> None\n. @brief Set the Non-maximum-suppression threshold to suppress bounding boxes that have IoU greater than the given value\n. *\n. * @param nms_threshold threshold for NMS operation"}, |  | 7876 | {"setNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setNMSThreshold, 0), "setNMSThreshold(nms_threshold) -> None\n. @brief Set the Non-maximum-suppression threshold to suppress bounding boxes that have IoU greater than the given value\n. *\n. * @param nms_threshold threshold for NMS operation"},
| 7877 | {"setScoreThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setScoreThreshold, 0), "setScoreThreshold(score_threshold) -> None\n. @brief Set the score threshold to filter out bounding boxes of score less than the given value\n. *\n. * @param score_threshold threshold for filtering out bounding boxes"}, |  | 7877 | {"setScoreThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setScoreThreshold, 0), "setScoreThreshold(score_threshold) -> None\n. @brief Set the score threshold to filter out bounding boxes of score less than the given value\n. *\n. * @param score_threshold threshold for filtering out bounding boxes"},
| 7878 | {"setTopK", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setTopK, 0), "setTopK(top_k) -> None\n. @brief Set the number of bounding boxes preserved before NMS\n. *\n. * @param top_k the number of bounding boxes to preserve from top rank based on score"}, |  | 7878 | {"setTopK", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceDetectorYN_setTopK, 0), "setTopK(top_k) -> None\n. @brief Set the number of bounding boxes preserved before NMS\n. *\n. * @param top_k the number of bounding boxes to preserve from top rank based on score"},
| 7879 |  |  | 7879 |
| 7880 | {NULL, NULL} |  | 7880 | {NULL, NULL}
| 7881 | }; |  | 7881 | };
| 7882 |  |  | 7882 |
| 7883 | // Converter (FaceDetectorYN) |  | 7883 | // Converter (FaceDetectorYN)
| 7884 |  |  | 7884 |
| 7885 | template<> |  | 7885 | template<>
| 7886 | struct PyOpenCV_Converter< Ptr<cv::FaceDetectorYN> > |  | 7886 | struct PyOpenCV_Converter< Ptr<cv::FaceDetectorYN> >
| 7887 | { |  | 7887 | {
| 7888 | static PyObject* from(const Ptr<cv::FaceDetectorYN>& r) |  | 7888 | static PyObject* from(const Ptr<cv::FaceDetectorYN>& r)
| 7889 | { |  | 7889 | {
| 7890 | return pyopencv_FaceDetectorYN_Instance(r); |  | 7890 | return pyopencv_FaceDetectorYN_Instance(r);
| 7891 | } |  | 7891 | }
| 7892 | static bool to(PyObject* src, Ptr<cv::FaceDetectorYN>& dst, const ArgInfo& info) |  | 7892 | static bool to(PyObject* src, Ptr<cv::FaceDetectorYN>& dst, const ArgInfo& info)
| 7893 | { |  | 7893 | {
| 7894 | if(!src || src == Py_None) |  | 7894 | if(!src || src == Py_None)
| 7895 | return true; |  | 7895 | return true;
| 7896 | Ptr<cv::FaceDetectorYN> * dst_; |  | 7896 | Ptr<cv::FaceDetectorYN> * dst_;
| 7897 | if (pyopencv_FaceDetectorYN_getp(src, dst_)) |  | 7897 | if (pyopencv_FaceDetectorYN_getp(src, dst_))
| 7898 | { |  | 7898 | {
| 7899 | dst = *dst_; |  | 7899 | dst = *dst_;
| 7900 | return true; |  | 7900 | return true;
| 7901 | } |  | 7901 | }
| 7902 |  |  | 7902 |
| 7903 | failmsg("Expected Ptr<cv::FaceDetectorYN> for argument '%s'", info.name); |  | 7903 | failmsg("Expected Ptr<cv::FaceDetectorYN> for argument '%s'", info.name);
| 7904 | return false; |  | 7904 | return false;
| 7905 | } |  | 7905 | }
| 7906 | }; |  | 7906 | };
| 7907 |  |  | 7907 |
| 7908 | //================================================================================ |  | 7908 | //================================================================================
| 7909 | // FaceRecognizerSF (Generic) |  | 7909 | // FaceRecognizerSF (Generic)
| 7910 | //================================================================================ |  | 7910 | //================================================================================
| 7911 |  |  | 7911 |
| 7912 | // GetSet (FaceRecognizerSF) |  | 7912 | // GetSet (FaceRecognizerSF)
| 7913 |  |  | 7913 |
| 7914 |  |  | 7914 |
| 7915 |  |  | 7915 |
| 7916 | // Methods (FaceRecognizerSF) |  | 7916 | // Methods (FaceRecognizerSF)
| 7917 |  |  | 7917 |
| 7918 | static PyObject* pyopencv_cv_FaceRecognizerSF_alignCrop(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7918 | static PyObject* pyopencv_cv_FaceRecognizerSF_alignCrop(PyObject* self, PyObject* py_args, PyObject* kw)
| 7919 | { |  | 7919 | {
| 7920 | using namespace cv; |  | 7920 | using namespace cv;
| 7921 |  |  | 7921 |
| 7922 |  |  | 7922 |
| 7923 | Ptr<cv::FaceRecognizerSF> * self1 = 0; |  | 7923 | Ptr<cv::FaceRecognizerSF> * self1 = 0;
| 7924 | if (!pyopencv_FaceRecognizerSF_getp(self, self1)) |  | 7924 | if (!pyopencv_FaceRecognizerSF_getp(self, self1))
| 7925 | return failmsgp("Incorrect type of self (must be 'FaceRecognizerSF' or its derivative)"); |  | 7925 | return failmsgp("Incorrect type of self (must be 'FaceRecognizerSF' or its derivative)");
| 7926 | Ptr<cv::FaceRecognizerSF> _self_ = *(self1); |  | 7926 | Ptr<cv::FaceRecognizerSF> _self_ = *(self1);
| 7927 | pyPrepareArgumentConversionErrorsStorage(2); |  | 7927 | pyPrepareArgumentConversionErrorsStorage(2);
| 7928 |  |  | 7928 |
| 7929 | { |  | 7929 | {
| 7930 | PyObject* pyobj_src_img = NULL; |  | 7930 | PyObject* pyobj_src_img = NULL;
| 7931 | Mat src_img; |  | 7931 | Mat src_img;
| 7932 | PyObject* pyobj_face_box = NULL; |  | 7932 | PyObject* pyobj_face_box = NULL;
| 7933 | Mat face_box; |  | 7933 | Mat face_box;
| 7934 | PyObject* pyobj_aligned_img = NULL; |  | 7934 | PyObject* pyobj_aligned_img = NULL;
| 7935 | Mat aligned_img; |  | 7935 | Mat aligned_img;
| 7936 |  |  | 7936 |
| 7937 | const char* keywords[] = { "src_img", "face_box", "aligned_img", NULL }; |  | 7937 | const char* keywords[] = { "src_img", "face_box", "aligned_img", NULL };
| 7938 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.alignCrop", (char**)keywords, &pyobj_src_img, &pyobj_face_box, &pyobj_aligned_img) && |  | 7938 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.alignCrop", (char**)keywords, &pyobj_src_img, &pyobj_face_box, &pyobj_aligned_img) &&
| 7939 | pyopencv_to_safe(pyobj_src_img, src_img, ArgInfo("src_img", 0)) && |  | 7939 | pyopencv_to_safe(pyobj_src_img, src_img, ArgInfo("src_img", 0)) &&
| 7940 | pyopencv_to_safe(pyobj_face_box, face_box, ArgInfo("face_box", 0)) && |  | 7940 | pyopencv_to_safe(pyobj_face_box, face_box, ArgInfo("face_box", 0)) &&
| 7941 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 1)) ) |  | 7941 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 1)) )
| 7942 | { |  | 7942 | {
| 7943 | ERRWRAP2(_self_->alignCrop(src_img, face_box, aligned_img)); |  | 7943 | ERRWRAP2(_self_->alignCrop(src_img, face_box, aligned_img));
| 7944 | return pyopencv_from(aligned_img); |  | 7944 | return pyopencv_from(aligned_img);
| 7945 | } |  | 7945 | }
| 7946 |  |  | 7946 |
| 7947 |  |  | 7947 |
| 7948 | pyPopulateArgumentConversionErrors(); |  | 7948 | pyPopulateArgumentConversionErrors();
| 7949 | } |  | 7949 | }
| 7950 |  |  | 7950 |
| 7951 |  |  | 7951 |
| 7952 | { |  | 7952 | {
| 7953 | PyObject* pyobj_src_img = NULL; |  | 7953 | PyObject* pyobj_src_img = NULL;
| 7954 | UMat src_img; |  | 7954 | UMat src_img;
| 7955 | PyObject* pyobj_face_box = NULL; |  | 7955 | PyObject* pyobj_face_box = NULL;
| 7956 | UMat face_box; |  | 7956 | UMat face_box;
| 7957 | PyObject* pyobj_aligned_img = NULL; |  | 7957 | PyObject* pyobj_aligned_img = NULL;
| 7958 | UMat aligned_img; |  | 7958 | UMat aligned_img;
| 7959 |  |  | 7959 |
| 7960 | const char* keywords[] = { "src_img", "face_box", "aligned_img", NULL }; |  | 7960 | const char* keywords[] = { "src_img", "face_box", "aligned_img", NULL };
| 7961 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.alignCrop", (char**)keywords, &pyobj_src_img, &pyobj_face_box, &pyobj_aligned_img) && |  | 7961 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.alignCrop", (char**)keywords, &pyobj_src_img, &pyobj_face_box, &pyobj_aligned_img) &&
| 7962 | pyopencv_to_safe(pyobj_src_img, src_img, ArgInfo("src_img", 0)) && |  | 7962 | pyopencv_to_safe(pyobj_src_img, src_img, ArgInfo("src_img", 0)) &&
| 7963 | pyopencv_to_safe(pyobj_face_box, face_box, ArgInfo("face_box", 0)) && |  | 7963 | pyopencv_to_safe(pyobj_face_box, face_box, ArgInfo("face_box", 0)) &&
| 7964 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 1)) ) |  | 7964 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 1)) )
| 7965 | { |  | 7965 | {
| 7966 | ERRWRAP2(_self_->alignCrop(src_img, face_box, aligned_img)); |  | 7966 | ERRWRAP2(_self_->alignCrop(src_img, face_box, aligned_img));
| 7967 | return pyopencv_from(aligned_img); |  | 7967 | return pyopencv_from(aligned_img);
| 7968 | } |  | 7968 | }
| 7969 |  |  | 7969 |
| 7970 |  |  | 7970 |
| 7971 | pyPopulateArgumentConversionErrors(); |  | 7971 | pyPopulateArgumentConversionErrors();
| 7972 | } |  | 7972 | }
| 7973 | pyRaiseCVOverloadException("alignCrop"); |  | 7973 | pyRaiseCVOverloadException("alignCrop");
| 7974 |  |  | 7974 |
| 7975 | return NULL; |  | 7975 | return NULL;
| 7976 | } |  | 7976 | }
| 7977 |  |  | 7977 |
| 7978 | static PyObject* pyopencv_cv_FaceRecognizerSF_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 7978 | static PyObject* pyopencv_cv_FaceRecognizerSF_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 7979 | { |  | 7979 | {
| 7980 | using namespace cv; |  | 7980 | using namespace cv;
| 7981 |  |  | 7981 |
| 7982 | pyPrepareArgumentConversionErrorsStorage(2); |  | 7982 | pyPrepareArgumentConversionErrorsStorage(2);
| 7983 |  |  | 7983 |
| 7984 | { |  | 7984 | {
| 7985 | PyObject* pyobj_model = NULL; |  | 7985 | PyObject* pyobj_model = NULL;
| 7986 | String model; |  | 7986 | String model;
| 7987 | PyObject* pyobj_config = NULL; |  | 7987 | PyObject* pyobj_config = NULL;
| 7988 | String config; |  | 7988 | String config;
| 7989 | PyObject* pyobj_backend_id = NULL; |  | 7989 | PyObject* pyobj_backend_id = NULL;
| 7990 | int backend_id=0; |  | 7990 | int backend_id=0;
| 7991 | PyObject* pyobj_target_id = NULL; |  | 7991 | PyObject* pyobj_target_id = NULL;
| 7992 | int target_id=0; |  | 7992 | int target_id=0;
| 7993 | Ptr<FaceRecognizerSF> retval; |  | 7993 | Ptr<FaceRecognizerSF> retval;
| 7994 |  |  | 7994 |
| 7995 | const char* keywords[] = { "model", "config", "backend_id", "target_id", NULL }; |  | 7995 | const char* keywords[] = { "model", "config", "backend_id", "target_id", NULL };
| 7996 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:FaceRecognizerSF.create", (char**)keywords, &pyobj_model, &pyobj_config, &pyobj_backend_id, &pyobj_target_id) && |  | 7996 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:FaceRecognizerSF.create", (char**)keywords, &pyobj_model, &pyobj_config, &pyobj_backend_id, &pyobj_target_id) &&
| 7997 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 7997 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 7998 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) && |  | 7998 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) &&
| 7999 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) && |  | 7999 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) &&
| 8000 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) ) |  | 8000 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) )
| 8001 | { |  | 8001 | {
| 8002 | ERRWRAP2(retval = cv::FaceRecognizerSF::create(model, config, backend_id, target_id)); |  | 8002 | ERRWRAP2(retval = cv::FaceRecognizerSF::create(model, config, backend_id, target_id));
| 8003 | return pyopencv_from(retval); |  | 8003 | return pyopencv_from(retval);
| 8004 | } |  | 8004 | }
| 8005 |  |  | 8005 |
| 8006 |  |  | 8006 |
| 8007 | pyPopulateArgumentConversionErrors(); |  | 8007 | pyPopulateArgumentConversionErrors();
| 8008 | } |  | 8008 | }
| 8009 |  |  | 8009 |
| 8010 |  |  | 8010 |
| 8011 | { |  | 8011 | {
| 8012 | PyObject* pyobj_framework = NULL; |  | 8012 | PyObject* pyobj_framework = NULL;
| 8013 | String framework; |  | 8013 | String framework;
| 8014 | PyObject* pyobj_bufferModel = NULL; |  | 8014 | PyObject* pyobj_bufferModel = NULL;
| 8015 | vector_uchar bufferModel; |  | 8015 | vector_uchar bufferModel;
| 8016 | PyObject* pyobj_bufferConfig = NULL; |  | 8016 | PyObject* pyobj_bufferConfig = NULL;
| 8017 | vector_uchar bufferConfig; |  | 8017 | vector_uchar bufferConfig;
| 8018 | PyObject* pyobj_backend_id = NULL; |  | 8018 | PyObject* pyobj_backend_id = NULL;
| 8019 | int backend_id=0; |  | 8019 | int backend_id=0;
| 8020 | PyObject* pyobj_target_id = NULL; |  | 8020 | PyObject* pyobj_target_id = NULL;
| 8021 | int target_id=0; |  | 8021 | int target_id=0;
| 8022 | Ptr<FaceRecognizerSF> retval; |  | 8022 | Ptr<FaceRecognizerSF> retval;
| 8023 |  |  | 8023 |
| 8024 | const char* keywords[] = { "framework", "bufferModel", "bufferConfig", "backend_id", "target_id", NULL }; |  | 8024 | const char* keywords[] = { "framework", "bufferModel", "bufferConfig", "backend_id", "target_id", NULL };
| 8025 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:FaceRecognizerSF.create", (char**)keywords, &pyobj_framework, &pyobj_bufferModel, &pyobj_bufferConfig, &pyobj_backend_id, &pyobj_target_id) && |  | 8025 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:FaceRecognizerSF.create", (char**)keywords, &pyobj_framework, &pyobj_bufferModel, &pyobj_bufferConfig, &pyobj_backend_id, &pyobj_target_id) &&
| 8026 | pyopencv_to_safe(pyobj_framework, framework, ArgInfo("framework", 0)) && |  | 8026 | pyopencv_to_safe(pyobj_framework, framework, ArgInfo("framework", 0)) &&
| 8027 | pyopencv_to_safe(pyobj_bufferModel, bufferModel, ArgInfo("bufferModel", 0)) && |  | 8027 | pyopencv_to_safe(pyobj_bufferModel, bufferModel, ArgInfo("bufferModel", 0)) &&
| 8028 | pyopencv_to_safe(pyobj_bufferConfig, bufferConfig, ArgInfo("bufferConfig", 0)) && |  | 8028 | pyopencv_to_safe(pyobj_bufferConfig, bufferConfig, ArgInfo("bufferConfig", 0)) &&
| 8029 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) && |  | 8029 | pyopencv_to_safe(pyobj_backend_id, backend_id, ArgInfo("backend_id", 0)) &&
| 8030 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) ) |  | 8030 | pyopencv_to_safe(pyobj_target_id, target_id, ArgInfo("target_id", 0)) )
| 8031 | { |  | 8031 | {
| 8032 | ERRWRAP2(retval = cv::FaceRecognizerSF::create(framework, bufferModel, bufferConfig, backend_id, target_id)); |  | 8032 | ERRWRAP2(retval = cv::FaceRecognizerSF::create(framework, bufferModel, bufferConfig, backend_id, target_id));
| 8033 | return pyopencv_from(retval); |  | 8033 | return pyopencv_from(retval);
| 8034 | } |  | 8034 | }
| 8035 |  |  | 8035 |
| 8036 |  |  | 8036 |
| 8037 | pyPopulateArgumentConversionErrors(); |  | 8037 | pyPopulateArgumentConversionErrors();
| 8038 | } |  | 8038 | }
| 8039 | pyRaiseCVOverloadException("create"); |  | 8039 | pyRaiseCVOverloadException("create");
| 8040 |  |  | 8040 |
| 8041 | return NULL; |  | 8041 | return NULL;
| 8042 | } |  | 8042 | }
| 8043 |  |  | 8043 |
| 8044 | static PyObject* pyopencv_cv_FaceRecognizerSF_feature(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8044 | static PyObject* pyopencv_cv_FaceRecognizerSF_feature(PyObject* self, PyObject* py_args, PyObject* kw)
| 8045 | { |  | 8045 | {
| 8046 | using namespace cv; |  | 8046 | using namespace cv;
| 8047 |  |  | 8047 |
| 8048 |  |  | 8048 |
| 8049 | Ptr<cv::FaceRecognizerSF> * self1 = 0; |  | 8049 | Ptr<cv::FaceRecognizerSF> * self1 = 0;
| 8050 | if (!pyopencv_FaceRecognizerSF_getp(self, self1)) |  | 8050 | if (!pyopencv_FaceRecognizerSF_getp(self, self1))
| 8051 | return failmsgp("Incorrect type of self (must be 'FaceRecognizerSF' or its derivative)"); |  | 8051 | return failmsgp("Incorrect type of self (must be 'FaceRecognizerSF' or its derivative)");
| 8052 | Ptr<cv::FaceRecognizerSF> _self_ = *(self1); |  | 8052 | Ptr<cv::FaceRecognizerSF> _self_ = *(self1);
| 8053 | pyPrepareArgumentConversionErrorsStorage(2); |  | 8053 | pyPrepareArgumentConversionErrorsStorage(2);
| 8054 |  |  | 8054 |
| 8055 | { |  | 8055 | {
| 8056 | PyObject* pyobj_aligned_img = NULL; |  | 8056 | PyObject* pyobj_aligned_img = NULL;
| 8057 | Mat aligned_img; |  | 8057 | Mat aligned_img;
| 8058 | PyObject* pyobj_face_feature = NULL; |  | 8058 | PyObject* pyobj_face_feature = NULL;
| 8059 | Mat face_feature; |  | 8059 | Mat face_feature;
| 8060 |  |  | 8060 |
| 8061 | const char* keywords[] = { "aligned_img", "face_feature", NULL }; |  | 8061 | const char* keywords[] = { "aligned_img", "face_feature", NULL };
| 8062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceRecognizerSF.feature", (char**)keywords, &pyobj_aligned_img, &pyobj_face_feature) && |  | 8062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceRecognizerSF.feature", (char**)keywords, &pyobj_aligned_img, &pyobj_face_feature) &&
| 8063 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 0)) && |  | 8063 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 0)) &&
| 8064 | pyopencv_to_safe(pyobj_face_feature, face_feature, ArgInfo("face_feature", 1)) ) |  | 8064 | pyopencv_to_safe(pyobj_face_feature, face_feature, ArgInfo("face_feature", 1)) )
| 8065 | { |  | 8065 | {
| 8066 | ERRWRAP2(_self_->feature(aligned_img, face_feature)); |  | 8066 | ERRWRAP2(_self_->feature(aligned_img, face_feature));
| 8067 | return pyopencv_from(face_feature); |  | 8067 | return pyopencv_from(face_feature);
| 8068 | } |  | 8068 | }
| 8069 |  |  | 8069 |
| 8070 |  |  | 8070 |
| 8071 | pyPopulateArgumentConversionErrors(); |  | 8071 | pyPopulateArgumentConversionErrors();
| 8072 | } |  | 8072 | }
| 8073 |  |  | 8073 |
| 8074 |  |  | 8074 |
| 8075 | { |  | 8075 | {
| 8076 | PyObject* pyobj_aligned_img = NULL; |  | 8076 | PyObject* pyobj_aligned_img = NULL;
| 8077 | UMat aligned_img; |  | 8077 | UMat aligned_img;
| 8078 | PyObject* pyobj_face_feature = NULL; |  | 8078 | PyObject* pyobj_face_feature = NULL;
| 8079 | UMat face_feature; |  | 8079 | UMat face_feature;
| 8080 |  |  | 8080 |
| 8081 | const char* keywords[] = { "aligned_img", "face_feature", NULL }; |  | 8081 | const char* keywords[] = { "aligned_img", "face_feature", NULL };
| 8082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceRecognizerSF.feature", (char**)keywords, &pyobj_aligned_img, &pyobj_face_feature) && |  | 8082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FaceRecognizerSF.feature", (char**)keywords, &pyobj_aligned_img, &pyobj_face_feature) &&
| 8083 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 0)) && |  | 8083 | pyopencv_to_safe(pyobj_aligned_img, aligned_img, ArgInfo("aligned_img", 0)) &&
| 8084 | pyopencv_to_safe(pyobj_face_feature, face_feature, ArgInfo("face_feature", 1)) ) |  | 8084 | pyopencv_to_safe(pyobj_face_feature, face_feature, ArgInfo("face_feature", 1)) )
| 8085 | { |  | 8085 | {
| 8086 | ERRWRAP2(_self_->feature(aligned_img, face_feature)); |  | 8086 | ERRWRAP2(_self_->feature(aligned_img, face_feature));
| 8087 | return pyopencv_from(face_feature); |  | 8087 | return pyopencv_from(face_feature);
| 8088 | } |  | 8088 | }
| 8089 |  |  | 8089 |
| 8090 |  |  | 8090 |
| 8091 | pyPopulateArgumentConversionErrors(); |  | 8091 | pyPopulateArgumentConversionErrors();
| 8092 | } |  | 8092 | }
| 8093 | pyRaiseCVOverloadException("feature"); |  | 8093 | pyRaiseCVOverloadException("feature");
| 8094 |  |  | 8094 |
| 8095 | return NULL; |  | 8095 | return NULL;
| 8096 | } |  | 8096 | }
| 8097 |  |  | 8097 |
| 8098 | static PyObject* pyopencv_cv_FaceRecognizerSF_match(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8098 | static PyObject* pyopencv_cv_FaceRecognizerSF_match(PyObject* self, PyObject* py_args, PyObject* kw)
| 8099 | { |  | 8099 | {
| 8100 | using namespace cv; |  | 8100 | using namespace cv;
| 8101 |  |  | 8101 |
| 8102 |  |  | 8102 |
| 8103 | Ptr<cv::FaceRecognizerSF> * self1 = 0; |  | 8103 | Ptr<cv::FaceRecognizerSF> * self1 = 0;
| 8104 | if (!pyopencv_FaceRecognizerSF_getp(self, self1)) |  | 8104 | if (!pyopencv_FaceRecognizerSF_getp(self, self1))
| 8105 | return failmsgp("Incorrect type of self (must be 'FaceRecognizerSF' or its derivative)"); |  | 8105 | return failmsgp("Incorrect type of self (must be 'FaceRecognizerSF' or its derivative)");
| 8106 | Ptr<cv::FaceRecognizerSF> _self_ = *(self1); |  | 8106 | Ptr<cv::FaceRecognizerSF> _self_ = *(self1);
| 8107 | pyPrepareArgumentConversionErrorsStorage(2); |  | 8107 | pyPrepareArgumentConversionErrorsStorage(2);
| 8108 |  |  | 8108 |
| 8109 | { |  | 8109 | {
| 8110 | PyObject* pyobj_face_feature1 = NULL; |  | 8110 | PyObject* pyobj_face_feature1 = NULL;
| 8111 | Mat face_feature1; |  | 8111 | Mat face_feature1;
| 8112 | PyObject* pyobj_face_feature2 = NULL; |  | 8112 | PyObject* pyobj_face_feature2 = NULL;
| 8113 | Mat face_feature2; |  | 8113 | Mat face_feature2;
| 8114 | PyObject* pyobj_dis_type = NULL; |  | 8114 | PyObject* pyobj_dis_type = NULL;
| 8115 | int dis_type=FaceRecognizerSF::FR_COSINE; |  | 8115 | int dis_type=FaceRecognizerSF::FR_COSINE;
| 8116 | double retval; |  | 8116 | double retval;
| 8117 |  |  | 8117 |
| 8118 | const char* keywords[] = { "face_feature1", "face_feature2", "dis_type", NULL }; |  | 8118 | const char* keywords[] = { "face_feature1", "face_feature2", "dis_type", NULL };
| 8119 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.match", (char**)keywords, &pyobj_face_feature1, &pyobj_face_feature2, &pyobj_dis_type) && |  | 8119 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.match", (char**)keywords, &pyobj_face_feature1, &pyobj_face_feature2, &pyobj_dis_type) &&
| 8120 | pyopencv_to_safe(pyobj_face_feature1, face_feature1, ArgInfo("face_feature1", 0)) && |  | 8120 | pyopencv_to_safe(pyobj_face_feature1, face_feature1, ArgInfo("face_feature1", 0)) &&
| 8121 | pyopencv_to_safe(pyobj_face_feature2, face_feature2, ArgInfo("face_feature2", 0)) && |  | 8121 | pyopencv_to_safe(pyobj_face_feature2, face_feature2, ArgInfo("face_feature2", 0)) &&
| 8122 | pyopencv_to_safe(pyobj_dis_type, dis_type, ArgInfo("dis_type", 0)) ) |  | 8122 | pyopencv_to_safe(pyobj_dis_type, dis_type, ArgInfo("dis_type", 0)) )
| 8123 | { |  | 8123 | {
| 8124 | ERRWRAP2(retval = _self_->match(face_feature1, face_feature2, dis_type)); |  | 8124 | ERRWRAP2(retval = _self_->match(face_feature1, face_feature2, dis_type));
| 8125 | return pyopencv_from(retval); |  | 8125 | return pyopencv_from(retval);
| 8126 | } |  | 8126 | }
| 8127 |  |  | 8127 |
| 8128 |  |  | 8128 |
| 8129 | pyPopulateArgumentConversionErrors(); |  | 8129 | pyPopulateArgumentConversionErrors();
| 8130 | } |  | 8130 | }
| 8131 |  |  | 8131 |
| 8132 |  |  | 8132 |
| 8133 | { |  | 8133 | {
| 8134 | PyObject* pyobj_face_feature1 = NULL; |  | 8134 | PyObject* pyobj_face_feature1 = NULL;
| 8135 | UMat face_feature1; |  | 8135 | UMat face_feature1;
| 8136 | PyObject* pyobj_face_feature2 = NULL; |  | 8136 | PyObject* pyobj_face_feature2 = NULL;
| 8137 | UMat face_feature2; |  | 8137 | UMat face_feature2;
| 8138 | PyObject* pyobj_dis_type = NULL; |  | 8138 | PyObject* pyobj_dis_type = NULL;
| 8139 | int dis_type=FaceRecognizerSF::FR_COSINE; |  | 8139 | int dis_type=FaceRecognizerSF::FR_COSINE;
| 8140 | double retval; |  | 8140 | double retval;
| 8141 |  |  | 8141 |
| 8142 | const char* keywords[] = { "face_feature1", "face_feature2", "dis_type", NULL }; |  | 8142 | const char* keywords[] = { "face_feature1", "face_feature2", "dis_type", NULL };
| 8143 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.match", (char**)keywords, &pyobj_face_feature1, &pyobj_face_feature2, &pyobj_dis_type) && |  | 8143 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FaceRecognizerSF.match", (char**)keywords, &pyobj_face_feature1, &pyobj_face_feature2, &pyobj_dis_type) &&
| 8144 | pyopencv_to_safe(pyobj_face_feature1, face_feature1, ArgInfo("face_feature1", 0)) && |  | 8144 | pyopencv_to_safe(pyobj_face_feature1, face_feature1, ArgInfo("face_feature1", 0)) &&
| 8145 | pyopencv_to_safe(pyobj_face_feature2, face_feature2, ArgInfo("face_feature2", 0)) && |  | 8145 | pyopencv_to_safe(pyobj_face_feature2, face_feature2, ArgInfo("face_feature2", 0)) &&
| 8146 | pyopencv_to_safe(pyobj_dis_type, dis_type, ArgInfo("dis_type", 0)) ) |  | 8146 | pyopencv_to_safe(pyobj_dis_type, dis_type, ArgInfo("dis_type", 0)) )
| 8147 | { |  | 8147 | {
| 8148 | ERRWRAP2(retval = _self_->match(face_feature1, face_feature2, dis_type)); |  | 8148 | ERRWRAP2(retval = _self_->match(face_feature1, face_feature2, dis_type));
| 8149 | return pyopencv_from(retval); |  | 8149 | return pyopencv_from(retval);
| 8150 | } |  | 8150 | }
| 8151 |  |  | 8151 |
| 8152 |  |  | 8152 |
| 8153 | pyPopulateArgumentConversionErrors(); |  | 8153 | pyPopulateArgumentConversionErrors();
| 8154 | } |  | 8154 | }
| 8155 | pyRaiseCVOverloadException("match"); |  | 8155 | pyRaiseCVOverloadException("match");
| 8156 |  |  | 8156 |
| 8157 | return NULL; |  | 8157 | return NULL;
| 8158 | } |  | 8158 | }
| 8159 |  |  | 8159 |
| 8160 |  |  | 8160 |
| 8161 |  |  | 8161 |
| 8162 | // Tables (FaceRecognizerSF) |  | 8162 | // Tables (FaceRecognizerSF)
| 8163 |  |  | 8163 |
| 8164 | static PyGetSetDef pyopencv_FaceRecognizerSF_getseters[] = |  | 8164 | static PyGetSetDef pyopencv_FaceRecognizerSF_getseters[] =
| 8165 | { |  | 8165 | {
| 8166 | {NULL} /* Sentinel */ |  | 8166 | {NULL} /* Sentinel */
| 8167 | }; |  | 8167 | };
| 8168 |  |  | 8168 |
| 8169 | static PyMethodDef pyopencv_FaceRecognizerSF_methods[] = |  | 8169 | static PyMethodDef pyopencv_FaceRecognizerSF_methods[] =
| 8170 | { |  | 8170 | {
| 8171 | {"alignCrop", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_alignCrop, 0), "alignCrop(src_img, face_box[, aligned_img]) -> aligned_img\n. @brief Aligns detected face with the source input image and crops it\n. * @param src_img input image\n. * @param face_box the detected face result from the input image\n. * @param aligned_img output aligned image"}, |  | 8171 | {"alignCrop", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_alignCrop, 0), "alignCrop(src_img, face_box[, aligned_img]) -> aligned_img\n. @brief Aligns detected face with the source input image and crops it\n. * @param src_img input image\n. * @param face_box the detected face result from the input image\n. * @param aligned_img output aligned image"},
| 8172 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_create_static, METH_STATIC), "create(model, config[, backend_id[, target_id]]) -> retval\n. @brief Creates an instance of this class with given parameters\n. * @param model the path of the onnx model used for face recognition\n. * @param config the path to the config file for compability, which is not requested for ONNX models\n. * @param backend_id the id of backend\n. * @param target_id the id of target device\n\n\n\ncreate(framework, bufferModel, bufferConfig[, backend_id[, target_id]]) -> retval\n. * @brief Creates an instance of this class from a buffer containing the model weights and configuration.\n. * @param framework Name of the framework (ONNX, etc.)\n. * @param bufferModel A buffer containing the binary model weights.\n. * @param bufferConfig A buffer containing the network configuration.\n. * @param backend_id The id of the backend.\n. * @param target_id The id of the target device.\n. *\n. * @return A pointer to the created instance of FaceRecognizerSF."}, |  | 8172 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_create_static, METH_STATIC), "create(model, config[, backend_id[, target_id]]) -> retval\n. @brief Creates an instance of this class with given parameters\n. * @param model the path of the onnx model used for face recognition\n. * @param config the path to the config file for compability, which is not requested for ONNX models\n. * @param backend_id the id of backend\n. * @param target_id the id of target device\n\n\n\ncreate(framework, bufferModel, bufferConfig[, backend_id[, target_id]]) -> retval\n. * @brief Creates an instance of this class from a buffer containing the model weights and configuration.\n. * @param framework Name of the framework (ONNX, etc.)\n. * @param bufferModel A buffer containing the binary model weights.\n. * @param bufferConfig A buffer containing the network configuration.\n. * @param backend_id The id of the backend.\n. * @param target_id The id of the target device.\n. *\n. * @return A pointer to the created instance of FaceRecognizerSF."},
| 8173 | {"feature", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_feature, 0), "feature(aligned_img[, face_feature]) -> face_feature\n. @brief Extracts face feature from aligned image\n. * @param aligned_img input aligned image\n. * @param face_feature output face feature"}, |  | 8173 | {"feature", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_feature, 0), "feature(aligned_img[, face_feature]) -> face_feature\n. @brief Extracts face feature from aligned image\n. * @param aligned_img input aligned image\n. * @param face_feature output face feature"},
| 8174 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_match, 0), "match(face_feature1, face_feature2[, dis_type]) -> retval\n. @brief Calculates the distance between two face features\n. * @param face_feature1 the first input feature\n. * @param face_feature2 the second input feature of the same size and the same type as face_feature1\n. * @param dis_type defines how to calculate the distance between two face features with optional values \"FR_COSINE\" or \"FR_NORM_L2\""}, |  | 8174 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_FaceRecognizerSF_match, 0), "match(face_feature1, face_feature2[, dis_type]) -> retval\n. @brief Calculates the distance between two face features\n. * @param face_feature1 the first input feature\n. * @param face_feature2 the second input feature of the same size and the same type as face_feature1\n. * @param dis_type defines how to calculate the distance between two face features with optional values \"FR_COSINE\" or \"FR_NORM_L2\""},
| 8175 |  |  | 8175 |
| 8176 | {NULL, NULL} |  | 8176 | {NULL, NULL}
| 8177 | }; |  | 8177 | };
| 8178 |  |  | 8178 |
| 8179 | // Converter (FaceRecognizerSF) |  | 8179 | // Converter (FaceRecognizerSF)
| 8180 |  |  | 8180 |
| 8181 | template<> |  | 8181 | template<>
| 8182 | struct PyOpenCV_Converter< Ptr<cv::FaceRecognizerSF> > |  | 8182 | struct PyOpenCV_Converter< Ptr<cv::FaceRecognizerSF> >
| 8183 | { |  | 8183 | {
| 8184 | static PyObject* from(const Ptr<cv::FaceRecognizerSF>& r) |  | 8184 | static PyObject* from(const Ptr<cv::FaceRecognizerSF>& r)
| 8185 | { |  | 8185 | {
| 8186 | return pyopencv_FaceRecognizerSF_Instance(r); |  | 8186 | return pyopencv_FaceRecognizerSF_Instance(r);
| 8187 | } |  | 8187 | }
| 8188 | static bool to(PyObject* src, Ptr<cv::FaceRecognizerSF>& dst, const ArgInfo& info) |  | 8188 | static bool to(PyObject* src, Ptr<cv::FaceRecognizerSF>& dst, const ArgInfo& info)
| 8189 | { |  | 8189 | {
| 8190 | if(!src || src == Py_None) |  | 8190 | if(!src || src == Py_None)
| 8191 | return true; |  | 8191 | return true;
| 8192 | Ptr<cv::FaceRecognizerSF> * dst_; |  | 8192 | Ptr<cv::FaceRecognizerSF> * dst_;
| 8193 | if (pyopencv_FaceRecognizerSF_getp(src, dst_)) |  | 8193 | if (pyopencv_FaceRecognizerSF_getp(src, dst_))
| 8194 | { |  | 8194 | {
| 8195 | dst = *dst_; |  | 8195 | dst = *dst_;
| 8196 | return true; |  | 8196 | return true;
| 8197 | } |  | 8197 | }
| 8198 |  |  | 8198 |
| 8199 | failmsg("Expected Ptr<cv::FaceRecognizerSF> for argument '%s'", info.name); |  | 8199 | failmsg("Expected Ptr<cv::FaceRecognizerSF> for argument '%s'", info.name);
| 8200 | return false; |  | 8200 | return false;
| 8201 | } |  | 8201 | }
| 8202 | }; |  | 8202 | };
| 8203 |  |  | 8203 |
| 8204 | //================================================================================ |  | 8204 | //================================================================================
| 8205 | // FarnebackOpticalFlow (Generic) |  | 8205 | // FarnebackOpticalFlow (Generic)
| 8206 | //================================================================================ |  | 8206 | //================================================================================
| 8207 |  |  | 8207 |
| 8208 | // GetSet (FarnebackOpticalFlow) |  | 8208 | // GetSet (FarnebackOpticalFlow)
| 8209 |  |  | 8209 |
| 8210 |  |  | 8210 |
| 8211 |  |  | 8211 |
| 8212 | // Methods (FarnebackOpticalFlow) |  | 8212 | // Methods (FarnebackOpticalFlow)
| 8213 |  |  | 8213 |
| 8214 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8214 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 8215 | { |  | 8215 | {
| 8216 | using namespace cv; |  | 8216 | using namespace cv;
| 8217 |  |  | 8217 |
| 8218 | PyObject* pyobj_numLevels = NULL; |  | 8218 | PyObject* pyobj_numLevels = NULL;
| 8219 | int numLevels=5; |  | 8219 | int numLevels=5;
| 8220 | PyObject* pyobj_pyrScale = NULL; |  | 8220 | PyObject* pyobj_pyrScale = NULL;
| 8221 | double pyrScale=0.5; |  | 8221 | double pyrScale=0.5;
| 8222 | PyObject* pyobj_fastPyramids = NULL; |  | 8222 | PyObject* pyobj_fastPyramids = NULL;
| 8223 | bool fastPyramids=false; |  | 8223 | bool fastPyramids=false;
| 8224 | PyObject* pyobj_winSize = NULL; |  | 8224 | PyObject* pyobj_winSize = NULL;
| 8225 | int winSize=13; |  | 8225 | int winSize=13;
| 8226 | PyObject* pyobj_numIters = NULL; |  | 8226 | PyObject* pyobj_numIters = NULL;
| 8227 | int numIters=10; |  | 8227 | int numIters=10;
| 8228 | PyObject* pyobj_polyN = NULL; |  | 8228 | PyObject* pyobj_polyN = NULL;
| 8229 | int polyN=5; |  | 8229 | int polyN=5;
| 8230 | PyObject* pyobj_polySigma = NULL; |  | 8230 | PyObject* pyobj_polySigma = NULL;
| 8231 | double polySigma=1.1; |  | 8231 | double polySigma=1.1;
| 8232 | PyObject* pyobj_flags = NULL; |  | 8232 | PyObject* pyobj_flags = NULL;
| 8233 | int flags=0; |  | 8233 | int flags=0;
| 8234 | Ptr<FarnebackOpticalFlow> retval; |  | 8234 | Ptr<FarnebackOpticalFlow> retval;
| 8235 |  |  | 8235 |
| 8236 | const char* keywords[] = { "numLevels", "pyrScale", "fastPyramids", "winSize", "numIters", "polyN", "polySigma", "flags", NULL }; |  | 8236 | const char* keywords[] = { "numLevels", "pyrScale", "fastPyramids", "winSize", "numIters", "polyN", "polySigma", "flags", NULL };
| 8237 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:FarnebackOpticalFlow.create", (char**)keywords, &pyobj_numLevels, &pyobj_pyrScale, &pyobj_fastPyramids, &pyobj_winSize, &pyobj_numIters, &pyobj_polyN, &pyobj_polySigma, &pyobj_flags) && |  | 8237 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:FarnebackOpticalFlow.create", (char**)keywords, &pyobj_numLevels, &pyobj_pyrScale, &pyobj_fastPyramids, &pyobj_winSize, &pyobj_numIters, &pyobj_polyN, &pyobj_polySigma, &pyobj_flags) &&
| 8238 | pyopencv_to_safe(pyobj_numLevels, numLevels, ArgInfo("numLevels", 0)) && |  | 8238 | pyopencv_to_safe(pyobj_numLevels, numLevels, ArgInfo("numLevels", 0)) &&
| 8239 | pyopencv_to_safe(pyobj_pyrScale, pyrScale, ArgInfo("pyrScale", 0)) && |  | 8239 | pyopencv_to_safe(pyobj_pyrScale, pyrScale, ArgInfo("pyrScale", 0)) &&
| 8240 | pyopencv_to_safe(pyobj_fastPyramids, fastPyramids, ArgInfo("fastPyramids", 0)) && |  | 8240 | pyopencv_to_safe(pyobj_fastPyramids, fastPyramids, ArgInfo("fastPyramids", 0)) &&
| 8241 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) && |  | 8241 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) &&
| 8242 | pyopencv_to_safe(pyobj_numIters, numIters, ArgInfo("numIters", 0)) && |  | 8242 | pyopencv_to_safe(pyobj_numIters, numIters, ArgInfo("numIters", 0)) &&
| 8243 | pyopencv_to_safe(pyobj_polyN, polyN, ArgInfo("polyN", 0)) && |  | 8243 | pyopencv_to_safe(pyobj_polyN, polyN, ArgInfo("polyN", 0)) &&
| 8244 | pyopencv_to_safe(pyobj_polySigma, polySigma, ArgInfo("polySigma", 0)) && |  | 8244 | pyopencv_to_safe(pyobj_polySigma, polySigma, ArgInfo("polySigma", 0)) &&
| 8245 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 8245 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 8246 | { |  | 8246 | {
| 8247 | ERRWRAP2(retval = cv::FarnebackOpticalFlow::create(numLevels, pyrScale, fastPyramids, winSize, numIters, polyN, polySigma, flags)); |  | 8247 | ERRWRAP2(retval = cv::FarnebackOpticalFlow::create(numLevels, pyrScale, fastPyramids, winSize, numIters, polyN, polySigma, flags));
| 8248 | return pyopencv_from(retval); |  | 8248 | return pyopencv_from(retval);
| 8249 | } |  | 8249 | }
| 8250 |  |  | 8250 |
| 8251 | return NULL; |  | 8251 | return NULL;
| 8252 | } |  | 8252 | }
| 8253 |  |  | 8253 |
| 8254 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getFastPyramids(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8254 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getFastPyramids(PyObject* self, PyObject* py_args, PyObject* kw)
| 8255 | { |  | 8255 | {
| 8256 | using namespace cv; |  | 8256 | using namespace cv;
| 8257 |  |  | 8257 |
| 8258 |  |  | 8258 |
| 8259 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8259 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8260 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8260 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8261 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8261 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8262 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8262 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8263 | bool retval; |  | 8263 | bool retval;
| 8264 |  |  | 8264 |
| 8265 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8265 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8266 | { |  | 8266 | {
| 8267 | ERRWRAP2(retval = _self_->getFastPyramids()); |  | 8267 | ERRWRAP2(retval = _self_->getFastPyramids());
| 8268 | return pyopencv_from(retval); |  | 8268 | return pyopencv_from(retval);
| 8269 | } |  | 8269 | }
| 8270 |  |  | 8270 |
| 8271 | return NULL; |  | 8271 | return NULL;
| 8272 | } |  | 8272 | }
| 8273 |  |  | 8273 |
| 8274 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getFlags(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8274 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getFlags(PyObject* self, PyObject* py_args, PyObject* kw)
| 8275 | { |  | 8275 | {
| 8276 | using namespace cv; |  | 8276 | using namespace cv;
| 8277 |  |  | 8277 |
| 8278 |  |  | 8278 |
| 8279 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8279 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8280 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8280 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8281 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8281 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8282 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8282 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8283 | int retval; |  | 8283 | int retval;
| 8284 |  |  | 8284 |
| 8285 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8285 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8286 | { |  | 8286 | {
| 8287 | ERRWRAP2(retval = _self_->getFlags()); |  | 8287 | ERRWRAP2(retval = _self_->getFlags());
| 8288 | return pyopencv_from(retval); |  | 8288 | return pyopencv_from(retval);
| 8289 | } |  | 8289 | }
| 8290 |  |  | 8290 |
| 8291 | return NULL; |  | 8291 | return NULL;
| 8292 | } |  | 8292 | }
| 8293 |  |  | 8293 |
| 8294 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getNumIters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8294 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getNumIters(PyObject* self, PyObject* py_args, PyObject* kw)
| 8295 | { |  | 8295 | {
| 8296 | using namespace cv; |  | 8296 | using namespace cv;
| 8297 |  |  | 8297 |
| 8298 |  |  | 8298 |
| 8299 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8299 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8300 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8300 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8301 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8301 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8302 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8302 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8303 | int retval; |  | 8303 | int retval;
| 8304 |  |  | 8304 |
| 8305 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8305 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8306 | { |  | 8306 | {
| 8307 | ERRWRAP2(retval = _self_->getNumIters()); |  | 8307 | ERRWRAP2(retval = _self_->getNumIters());
| 8308 | return pyopencv_from(retval); |  | 8308 | return pyopencv_from(retval);
| 8309 | } |  | 8309 | }
| 8310 |  |  | 8310 |
| 8311 | return NULL; |  | 8311 | return NULL;
| 8312 | } |  | 8312 | }
| 8313 |  |  | 8313 |
| 8314 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getNumLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8314 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getNumLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 8315 | { |  | 8315 | {
| 8316 | using namespace cv; |  | 8316 | using namespace cv;
| 8317 |  |  | 8317 |
| 8318 |  |  | 8318 |
| 8319 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8319 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8320 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8320 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8321 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8321 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8322 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8322 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8323 | int retval; |  | 8323 | int retval;
| 8324 |  |  | 8324 |
| 8325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8326 | { |  | 8326 | {
| 8327 | ERRWRAP2(retval = _self_->getNumLevels()); |  | 8327 | ERRWRAP2(retval = _self_->getNumLevels());
| 8328 | return pyopencv_from(retval); |  | 8328 | return pyopencv_from(retval);
| 8329 | } |  | 8329 | }
| 8330 |  |  | 8330 |
| 8331 | return NULL; |  | 8331 | return NULL;
| 8332 | } |  | 8332 | }
| 8333 |  |  | 8333 |
| 8334 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getPolyN(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8334 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getPolyN(PyObject* self, PyObject* py_args, PyObject* kw)
| 8335 | { |  | 8335 | {
| 8336 | using namespace cv; |  | 8336 | using namespace cv;
| 8337 |  |  | 8337 |
| 8338 |  |  | 8338 |
| 8339 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8339 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8340 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8340 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8341 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8341 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8342 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8342 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8343 | int retval; |  | 8343 | int retval;
| 8344 |  |  | 8344 |
| 8345 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8345 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8346 | { |  | 8346 | {
| 8347 | ERRWRAP2(retval = _self_->getPolyN()); |  | 8347 | ERRWRAP2(retval = _self_->getPolyN());
| 8348 | return pyopencv_from(retval); |  | 8348 | return pyopencv_from(retval);
| 8349 | } |  | 8349 | }
| 8350 |  |  | 8350 |
| 8351 | return NULL; |  | 8351 | return NULL;
| 8352 | } |  | 8352 | }
| 8353 |  |  | 8353 |
| 8354 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getPolySigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8354 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getPolySigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 8355 | { |  | 8355 | {
| 8356 | using namespace cv; |  | 8356 | using namespace cv;
| 8357 |  |  | 8357 |
| 8358 |  |  | 8358 |
| 8359 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8359 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8360 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8360 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8361 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8361 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8362 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8362 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8363 | double retval; |  | 8363 | double retval;
| 8364 |  |  | 8364 |
| 8365 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8365 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8366 | { |  | 8366 | {
| 8367 | ERRWRAP2(retval = _self_->getPolySigma()); |  | 8367 | ERRWRAP2(retval = _self_->getPolySigma());
| 8368 | return pyopencv_from(retval); |  | 8368 | return pyopencv_from(retval);
| 8369 | } |  | 8369 | }
| 8370 |  |  | 8370 |
| 8371 | return NULL; |  | 8371 | return NULL;
| 8372 | } |  | 8372 | }
| 8373 |  |  | 8373 |
| 8374 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getPyrScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8374 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getPyrScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 8375 | { |  | 8375 | {
| 8376 | using namespace cv; |  | 8376 | using namespace cv;
| 8377 |  |  | 8377 |
| 8378 |  |  | 8378 |
| 8379 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8379 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8380 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8380 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8381 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8381 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8382 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8382 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8383 | double retval; |  | 8383 | double retval;
| 8384 |  |  | 8384 |
| 8385 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8385 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8386 | { |  | 8386 | {
| 8387 | ERRWRAP2(retval = _self_->getPyrScale()); |  | 8387 | ERRWRAP2(retval = _self_->getPyrScale());
| 8388 | return pyopencv_from(retval); |  | 8388 | return pyopencv_from(retval);
| 8389 | } |  | 8389 | }
| 8390 |  |  | 8390 |
| 8391 | return NULL; |  | 8391 | return NULL;
| 8392 | } |  | 8392 | }
| 8393 |  |  | 8393 |
| 8394 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8394 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_getWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 8395 | { |  | 8395 | {
| 8396 | using namespace cv; |  | 8396 | using namespace cv;
| 8397 |  |  | 8397 |
| 8398 |  |  | 8398 |
| 8399 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8399 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8400 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8400 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8401 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8401 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8402 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8402 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8403 | int retval; |  | 8403 | int retval;
| 8404 |  |  | 8404 |
| 8405 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8405 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8406 | { |  | 8406 | {
| 8407 | ERRWRAP2(retval = _self_->getWinSize()); |  | 8407 | ERRWRAP2(retval = _self_->getWinSize());
| 8408 | return pyopencv_from(retval); |  | 8408 | return pyopencv_from(retval);
| 8409 | } |  | 8409 | }
| 8410 |  |  | 8410 |
| 8411 | return NULL; |  | 8411 | return NULL;
| 8412 | } |  | 8412 | }
| 8413 |  |  | 8413 |
| 8414 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setFastPyramids(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8414 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setFastPyramids(PyObject* self, PyObject* py_args, PyObject* kw)
| 8415 | { |  | 8415 | {
| 8416 | using namespace cv; |  | 8416 | using namespace cv;
| 8417 |  |  | 8417 |
| 8418 |  |  | 8418 |
| 8419 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8419 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8420 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8420 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8421 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8421 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8422 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8422 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8423 | PyObject* pyobj_fastPyramids = NULL; |  | 8423 | PyObject* pyobj_fastPyramids = NULL;
| 8424 | bool fastPyramids=0; |  | 8424 | bool fastPyramids=0;
| 8425 |  |  | 8425 |
| 8426 | const char* keywords[] = { "fastPyramids", NULL }; |  | 8426 | const char* keywords[] = { "fastPyramids", NULL };
| 8427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setFastPyramids", (char**)keywords, &pyobj_fastPyramids) && |  | 8427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setFastPyramids", (char**)keywords, &pyobj_fastPyramids) &&
| 8428 | pyopencv_to_safe(pyobj_fastPyramids, fastPyramids, ArgInfo("fastPyramids", 0)) ) |  | 8428 | pyopencv_to_safe(pyobj_fastPyramids, fastPyramids, ArgInfo("fastPyramids", 0)) )
| 8429 | { |  | 8429 | {
| 8430 | ERRWRAP2(_self_->setFastPyramids(fastPyramids)); |  | 8430 | ERRWRAP2(_self_->setFastPyramids(fastPyramids));
| 8431 | Py_RETURN_NONE; |  | 8431 | Py_RETURN_NONE;
| 8432 | } |  | 8432 | }
| 8433 |  |  | 8433 |
| 8434 | return NULL; |  | 8434 | return NULL;
| 8435 | } |  | 8435 | }
| 8436 |  |  | 8436 |
| 8437 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setFlags(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8437 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setFlags(PyObject* self, PyObject* py_args, PyObject* kw)
| 8438 | { |  | 8438 | {
| 8439 | using namespace cv; |  | 8439 | using namespace cv;
| 8440 |  |  | 8440 |
| 8441 |  |  | 8441 |
| 8442 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8442 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8443 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8443 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8444 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8444 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8445 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8445 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8446 | PyObject* pyobj_flags = NULL; |  | 8446 | PyObject* pyobj_flags = NULL;
| 8447 | int flags=0; |  | 8447 | int flags=0;
| 8448 |  |  | 8448 |
| 8449 | const char* keywords[] = { "flags", NULL }; |  | 8449 | const char* keywords[] = { "flags", NULL };
| 8450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setFlags", (char**)keywords, &pyobj_flags) && |  | 8450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setFlags", (char**)keywords, &pyobj_flags) &&
| 8451 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 8451 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 8452 | { |  | 8452 | {
| 8453 | ERRWRAP2(_self_->setFlags(flags)); |  | 8453 | ERRWRAP2(_self_->setFlags(flags));
| 8454 | Py_RETURN_NONE; |  | 8454 | Py_RETURN_NONE;
| 8455 | } |  | 8455 | }
| 8456 |  |  | 8456 |
| 8457 | return NULL; |  | 8457 | return NULL;
| 8458 | } |  | 8458 | }
| 8459 |  |  | 8459 |
| 8460 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setNumIters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8460 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setNumIters(PyObject* self, PyObject* py_args, PyObject* kw)
| 8461 | { |  | 8461 | {
| 8462 | using namespace cv; |  | 8462 | using namespace cv;
| 8463 |  |  | 8463 |
| 8464 |  |  | 8464 |
| 8465 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8465 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8466 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8466 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8467 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8467 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8468 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8468 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8469 | PyObject* pyobj_numIters = NULL; |  | 8469 | PyObject* pyobj_numIters = NULL;
| 8470 | int numIters=0; |  | 8470 | int numIters=0;
| 8471 |  |  | 8471 |
| 8472 | const char* keywords[] = { "numIters", NULL }; |  | 8472 | const char* keywords[] = { "numIters", NULL };
| 8473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setNumIters", (char**)keywords, &pyobj_numIters) && |  | 8473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setNumIters", (char**)keywords, &pyobj_numIters) &&
| 8474 | pyopencv_to_safe(pyobj_numIters, numIters, ArgInfo("numIters", 0)) ) |  | 8474 | pyopencv_to_safe(pyobj_numIters, numIters, ArgInfo("numIters", 0)) )
| 8475 | { |  | 8475 | {
| 8476 | ERRWRAP2(_self_->setNumIters(numIters)); |  | 8476 | ERRWRAP2(_self_->setNumIters(numIters));
| 8477 | Py_RETURN_NONE; |  | 8477 | Py_RETURN_NONE;
| 8478 | } |  | 8478 | }
| 8479 |  |  | 8479 |
| 8480 | return NULL; |  | 8480 | return NULL;
| 8481 | } |  | 8481 | }
| 8482 |  |  | 8482 |
| 8483 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setNumLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8483 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setNumLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 8484 | { |  | 8484 | {
| 8485 | using namespace cv; |  | 8485 | using namespace cv;
| 8486 |  |  | 8486 |
| 8487 |  |  | 8487 |
| 8488 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8488 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8489 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8489 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8490 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8490 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8491 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8491 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8492 | PyObject* pyobj_numLevels = NULL; |  | 8492 | PyObject* pyobj_numLevels = NULL;
| 8493 | int numLevels=0; |  | 8493 | int numLevels=0;
| 8494 |  |  | 8494 |
| 8495 | const char* keywords[] = { "numLevels", NULL }; |  | 8495 | const char* keywords[] = { "numLevels", NULL };
| 8496 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setNumLevels", (char**)keywords, &pyobj_numLevels) && |  | 8496 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setNumLevels", (char**)keywords, &pyobj_numLevels) &&
| 8497 | pyopencv_to_safe(pyobj_numLevels, numLevels, ArgInfo("numLevels", 0)) ) |  | 8497 | pyopencv_to_safe(pyobj_numLevels, numLevels, ArgInfo("numLevels", 0)) )
| 8498 | { |  | 8498 | {
| 8499 | ERRWRAP2(_self_->setNumLevels(numLevels)); |  | 8499 | ERRWRAP2(_self_->setNumLevels(numLevels));
| 8500 | Py_RETURN_NONE; |  | 8500 | Py_RETURN_NONE;
| 8501 | } |  | 8501 | }
| 8502 |  |  | 8502 |
| 8503 | return NULL; |  | 8503 | return NULL;
| 8504 | } |  | 8504 | }
| 8505 |  |  | 8505 |
| 8506 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setPolyN(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8506 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setPolyN(PyObject* self, PyObject* py_args, PyObject* kw)
| 8507 | { |  | 8507 | {
| 8508 | using namespace cv; |  | 8508 | using namespace cv;
| 8509 |  |  | 8509 |
| 8510 |  |  | 8510 |
| 8511 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8511 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8512 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8512 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8513 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8513 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8514 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8514 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8515 | PyObject* pyobj_polyN = NULL; |  | 8515 | PyObject* pyobj_polyN = NULL;
| 8516 | int polyN=0; |  | 8516 | int polyN=0;
| 8517 |  |  | 8517 |
| 8518 | const char* keywords[] = { "polyN", NULL }; |  | 8518 | const char* keywords[] = { "polyN", NULL };
| 8519 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setPolyN", (char**)keywords, &pyobj_polyN) && |  | 8519 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setPolyN", (char**)keywords, &pyobj_polyN) &&
| 8520 | pyopencv_to_safe(pyobj_polyN, polyN, ArgInfo("polyN", 0)) ) |  | 8520 | pyopencv_to_safe(pyobj_polyN, polyN, ArgInfo("polyN", 0)) )
| 8521 | { |  | 8521 | {
| 8522 | ERRWRAP2(_self_->setPolyN(polyN)); |  | 8522 | ERRWRAP2(_self_->setPolyN(polyN));
| 8523 | Py_RETURN_NONE; |  | 8523 | Py_RETURN_NONE;
| 8524 | } |  | 8524 | }
| 8525 |  |  | 8525 |
| 8526 | return NULL; |  | 8526 | return NULL;
| 8527 | } |  | 8527 | }
| 8528 |  |  | 8528 |
| 8529 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setPolySigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8529 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setPolySigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 8530 | { |  | 8530 | {
| 8531 | using namespace cv; |  | 8531 | using namespace cv;
| 8532 |  |  | 8532 |
| 8533 |  |  | 8533 |
| 8534 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8534 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8535 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8535 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8536 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8536 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8537 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8537 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8538 | PyObject* pyobj_polySigma = NULL; |  | 8538 | PyObject* pyobj_polySigma = NULL;
| 8539 | double polySigma=0; |  | 8539 | double polySigma=0;
| 8540 |  |  | 8540 |
| 8541 | const char* keywords[] = { "polySigma", NULL }; |  | 8541 | const char* keywords[] = { "polySigma", NULL };
| 8542 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setPolySigma", (char**)keywords, &pyobj_polySigma) && |  | 8542 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setPolySigma", (char**)keywords, &pyobj_polySigma) &&
| 8543 | pyopencv_to_safe(pyobj_polySigma, polySigma, ArgInfo("polySigma", 0)) ) |  | 8543 | pyopencv_to_safe(pyobj_polySigma, polySigma, ArgInfo("polySigma", 0)) )
| 8544 | { |  | 8544 | {
| 8545 | ERRWRAP2(_self_->setPolySigma(polySigma)); |  | 8545 | ERRWRAP2(_self_->setPolySigma(polySigma));
| 8546 | Py_RETURN_NONE; |  | 8546 | Py_RETURN_NONE;
| 8547 | } |  | 8547 | }
| 8548 |  |  | 8548 |
| 8549 | return NULL; |  | 8549 | return NULL;
| 8550 | } |  | 8550 | }
| 8551 |  |  | 8551 |
| 8552 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setPyrScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8552 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setPyrScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 8553 | { |  | 8553 | {
| 8554 | using namespace cv; |  | 8554 | using namespace cv;
| 8555 |  |  | 8555 |
| 8556 |  |  | 8556 |
| 8557 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8557 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8558 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8558 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8559 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8559 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8560 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8560 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8561 | PyObject* pyobj_pyrScale = NULL; |  | 8561 | PyObject* pyobj_pyrScale = NULL;
| 8562 | double pyrScale=0; |  | 8562 | double pyrScale=0;
| 8563 |  |  | 8563 |
| 8564 | const char* keywords[] = { "pyrScale", NULL }; |  | 8564 | const char* keywords[] = { "pyrScale", NULL };
| 8565 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setPyrScale", (char**)keywords, &pyobj_pyrScale) && |  | 8565 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setPyrScale", (char**)keywords, &pyobj_pyrScale) &&
| 8566 | pyopencv_to_safe(pyobj_pyrScale, pyrScale, ArgInfo("pyrScale", 0)) ) |  | 8566 | pyopencv_to_safe(pyobj_pyrScale, pyrScale, ArgInfo("pyrScale", 0)) )
| 8567 | { |  | 8567 | {
| 8568 | ERRWRAP2(_self_->setPyrScale(pyrScale)); |  | 8568 | ERRWRAP2(_self_->setPyrScale(pyrScale));
| 8569 | Py_RETURN_NONE; |  | 8569 | Py_RETURN_NONE;
| 8570 | } |  | 8570 | }
| 8571 |  |  | 8571 |
| 8572 | return NULL; |  | 8572 | return NULL;
| 8573 | } |  | 8573 | }
| 8574 |  |  | 8574 |
| 8575 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8575 | static PyObject* pyopencv_cv_FarnebackOpticalFlow_setWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 8576 | { |  | 8576 | {
| 8577 | using namespace cv; |  | 8577 | using namespace cv;
| 8578 |  |  | 8578 |
| 8579 |  |  | 8579 |
| 8580 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0; |  | 8580 | Ptr<cv::FarnebackOpticalFlow> * self1 = 0;
| 8581 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1)) |  | 8581 | if (!pyopencv_FarnebackOpticalFlow_getp(self, self1))
| 8582 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)"); |  | 8582 | return failmsgp("Incorrect type of self (must be 'FarnebackOpticalFlow' or its derivative)");
| 8583 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1); |  | 8583 | Ptr<cv::FarnebackOpticalFlow> _self_ = *(self1);
| 8584 | PyObject* pyobj_winSize = NULL; |  | 8584 | PyObject* pyobj_winSize = NULL;
| 8585 | int winSize=0; |  | 8585 | int winSize=0;
| 8586 |  |  | 8586 |
| 8587 | const char* keywords[] = { "winSize", NULL }; |  | 8587 | const char* keywords[] = { "winSize", NULL };
| 8588 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setWinSize", (char**)keywords, &pyobj_winSize) && |  | 8588 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FarnebackOpticalFlow.setWinSize", (char**)keywords, &pyobj_winSize) &&
| 8589 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) ) |  | 8589 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) )
| 8590 | { |  | 8590 | {
| 8591 | ERRWRAP2(_self_->setWinSize(winSize)); |  | 8591 | ERRWRAP2(_self_->setWinSize(winSize));
| 8592 | Py_RETURN_NONE; |  | 8592 | Py_RETURN_NONE;
| 8593 | } |  | 8593 | }
| 8594 |  |  | 8594 |
| 8595 | return NULL; |  | 8595 | return NULL;
| 8596 | } |  | 8596 | }
| 8597 |  |  | 8597 |
| 8598 |  |  | 8598 |
| 8599 |  |  | 8599 |
| 8600 | // Tables (FarnebackOpticalFlow) |  | 8600 | // Tables (FarnebackOpticalFlow)
| 8601 |  |  | 8601 |
| 8602 | static PyGetSetDef pyopencv_FarnebackOpticalFlow_getseters[] = |  | 8602 | static PyGetSetDef pyopencv_FarnebackOpticalFlow_getseters[] =
| 8603 | { |  | 8603 | {
| 8604 | {NULL} /* Sentinel */ |  | 8604 | {NULL} /* Sentinel */
| 8605 | }; |  | 8605 | };
| 8606 |  |  | 8606 |
| 8607 | static PyMethodDef pyopencv_FarnebackOpticalFlow_methods[] = |  | 8607 | static PyMethodDef pyopencv_FarnebackOpticalFlow_methods[] =
| 8608 | { |  | 8608 | {
| 8609 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_create_static, METH_STATIC), "create([, numLevels[, pyrScale[, fastPyramids[, winSize[, numIters[, polyN[, polySigma[, flags]]]]]]]]) -> retval\n."}, |  | 8609 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_create_static, METH_STATIC), "create([, numLevels[, pyrScale[, fastPyramids[, winSize[, numIters[, polyN[, polySigma[, flags]]]]]]]]) -> retval\n."},
| 8610 | {"getFastPyramids", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getFastPyramids, 0), "getFastPyramids() -> retval\n."}, |  | 8610 | {"getFastPyramids", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getFastPyramids, 0), "getFastPyramids() -> retval\n."},
| 8611 | {"getFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getFlags, 0), "getFlags() -> retval\n."}, |  | 8611 | {"getFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getFlags, 0), "getFlags() -> retval\n."},
| 8612 | {"getNumIters", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getNumIters, 0), "getNumIters() -> retval\n."}, |  | 8612 | {"getNumIters", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getNumIters, 0), "getNumIters() -> retval\n."},
| 8613 | {"getNumLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getNumLevels, 0), "getNumLevels() -> retval\n."}, |  | 8613 | {"getNumLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getNumLevels, 0), "getNumLevels() -> retval\n."},
| 8614 | {"getPolyN", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getPolyN, 0), "getPolyN() -> retval\n."}, |  | 8614 | {"getPolyN", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getPolyN, 0), "getPolyN() -> retval\n."},
| 8615 | {"getPolySigma", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getPolySigma, 0), "getPolySigma() -> retval\n."}, |  | 8615 | {"getPolySigma", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getPolySigma, 0), "getPolySigma() -> retval\n."},
| 8616 | {"getPyrScale", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getPyrScale, 0), "getPyrScale() -> retval\n."}, |  | 8616 | {"getPyrScale", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getPyrScale, 0), "getPyrScale() -> retval\n."},
| 8617 | {"getWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getWinSize, 0), "getWinSize() -> retval\n."}, |  | 8617 | {"getWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_getWinSize, 0), "getWinSize() -> retval\n."},
| 8618 | {"setFastPyramids", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setFastPyramids, 0), "setFastPyramids(fastPyramids) -> None\n."}, |  | 8618 | {"setFastPyramids", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setFastPyramids, 0), "setFastPyramids(fastPyramids) -> None\n."},
| 8619 | {"setFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setFlags, 0), "setFlags(flags) -> None\n."}, |  | 8619 | {"setFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setFlags, 0), "setFlags(flags) -> None\n."},
| 8620 | {"setNumIters", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setNumIters, 0), "setNumIters(numIters) -> None\n."}, |  | 8620 | {"setNumIters", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setNumIters, 0), "setNumIters(numIters) -> None\n."},
| 8621 | {"setNumLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setNumLevels, 0), "setNumLevels(numLevels) -> None\n."}, |  | 8621 | {"setNumLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setNumLevels, 0), "setNumLevels(numLevels) -> None\n."},
| 8622 | {"setPolyN", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setPolyN, 0), "setPolyN(polyN) -> None\n."}, |  | 8622 | {"setPolyN", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setPolyN, 0), "setPolyN(polyN) -> None\n."},
| 8623 | {"setPolySigma", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setPolySigma, 0), "setPolySigma(polySigma) -> None\n."}, |  | 8623 | {"setPolySigma", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setPolySigma, 0), "setPolySigma(polySigma) -> None\n."},
| 8624 | {"setPyrScale", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setPyrScale, 0), "setPyrScale(pyrScale) -> None\n."}, |  | 8624 | {"setPyrScale", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setPyrScale, 0), "setPyrScale(pyrScale) -> None\n."},
| 8625 | {"setWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setWinSize, 0), "setWinSize(winSize) -> None\n."}, |  | 8625 | {"setWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FarnebackOpticalFlow_setWinSize, 0), "setWinSize(winSize) -> None\n."},
| 8626 |  |  | 8626 |
| 8627 | {NULL, NULL} |  | 8627 | {NULL, NULL}
| 8628 | }; |  | 8628 | };
| 8629 |  |  | 8629 |
| 8630 | // Converter (FarnebackOpticalFlow) |  | 8630 | // Converter (FarnebackOpticalFlow)
| 8631 |  |  | 8631 |
| 8632 | template<> |  | 8632 | template<>
| 8633 | struct PyOpenCV_Converter< Ptr<cv::FarnebackOpticalFlow> > |  | 8633 | struct PyOpenCV_Converter< Ptr<cv::FarnebackOpticalFlow> >
| 8634 | { |  | 8634 | {
| 8635 | static PyObject* from(const Ptr<cv::FarnebackOpticalFlow>& r) |  | 8635 | static PyObject* from(const Ptr<cv::FarnebackOpticalFlow>& r)
| 8636 | { |  | 8636 | {
| 8637 | return pyopencv_FarnebackOpticalFlow_Instance(r); |  | 8637 | return pyopencv_FarnebackOpticalFlow_Instance(r);
| 8638 | } |  | 8638 | }
| 8639 | static bool to(PyObject* src, Ptr<cv::FarnebackOpticalFlow>& dst, const ArgInfo& info) |  | 8639 | static bool to(PyObject* src, Ptr<cv::FarnebackOpticalFlow>& dst, const ArgInfo& info)
| 8640 | { |  | 8640 | {
| 8641 | if(!src || src == Py_None) |  | 8641 | if(!src || src == Py_None)
| 8642 | return true; |  | 8642 | return true;
| 8643 | Ptr<cv::FarnebackOpticalFlow> * dst_; |  | 8643 | Ptr<cv::FarnebackOpticalFlow> * dst_;
| 8644 | if (pyopencv_FarnebackOpticalFlow_getp(src, dst_)) |  | 8644 | if (pyopencv_FarnebackOpticalFlow_getp(src, dst_))
| 8645 | { |  | 8645 | {
| 8646 | dst = *dst_; |  | 8646 | dst = *dst_;
| 8647 | return true; |  | 8647 | return true;
| 8648 | } |  | 8648 | }
| 8649 |  |  | 8649 |
| 8650 | failmsg("Expected Ptr<cv::FarnebackOpticalFlow> for argument '%s'", info.name); |  | 8650 | failmsg("Expected Ptr<cv::FarnebackOpticalFlow> for argument '%s'", info.name);
| 8651 | return false; |  | 8651 | return false;
| 8652 | } |  | 8652 | }
| 8653 | }; |  | 8653 | };
| 8654 |  |  | 8654 |
| 8655 | //================================================================================ |  | 8655 | //================================================================================
| 8656 | // FastFeatureDetector (Generic) |  | 8656 | // FastFeatureDetector (Generic)
| 8657 | //================================================================================ |  | 8657 | //================================================================================
| 8658 |  |  | 8658 |
| 8659 | // GetSet (FastFeatureDetector) |  | 8659 | // GetSet (FastFeatureDetector)
| 8660 |  |  | 8660 |
| 8661 |  |  | 8661 |
| 8662 |  |  | 8662 |
| 8663 | // Methods (FastFeatureDetector) |  | 8663 | // Methods (FastFeatureDetector)
| 8664 |  |  | 8664 |
| 8665 | static PyObject* pyopencv_cv_FastFeatureDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8665 | static PyObject* pyopencv_cv_FastFeatureDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 8666 | { |  | 8666 | {
| 8667 | using namespace cv; |  | 8667 | using namespace cv;
| 8668 |  |  | 8668 |
| 8669 | PyObject* pyobj_threshold = NULL; |  | 8669 | PyObject* pyobj_threshold = NULL;
| 8670 | int threshold=10; |  | 8670 | int threshold=10;
| 8671 | PyObject* pyobj_nonmaxSuppression = NULL; |  | 8671 | PyObject* pyobj_nonmaxSuppression = NULL;
| 8672 | bool nonmaxSuppression=true; |  | 8672 | bool nonmaxSuppression=true;
| 8673 | PyObject* pyobj_type = NULL; |  | 8673 | PyObject* pyobj_type = NULL;
| 8674 | FastFeatureDetector_DetectorType type=FastFeatureDetector::TYPE_9_16; |  | 8674 | FastFeatureDetector_DetectorType type=FastFeatureDetector::TYPE_9_16;
| 8675 | Ptr<FastFeatureDetector> retval; |  | 8675 | Ptr<FastFeatureDetector> retval;
| 8676 |  |  | 8676 |
| 8677 | const char* keywords[] = { "threshold", "nonmaxSuppression", "type", NULL }; |  | 8677 | const char* keywords[] = { "threshold", "nonmaxSuppression", "type", NULL };
| 8678 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:FastFeatureDetector.create", (char**)keywords, &pyobj_threshold, &pyobj_nonmaxSuppression, &pyobj_type) && |  | 8678 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:FastFeatureDetector.create", (char**)keywords, &pyobj_threshold, &pyobj_nonmaxSuppression, &pyobj_type) &&
| 8679 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) && |  | 8679 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) &&
| 8680 | pyopencv_to_safe(pyobj_nonmaxSuppression, nonmaxSuppression, ArgInfo("nonmaxSuppression", 0)) && |  | 8680 | pyopencv_to_safe(pyobj_nonmaxSuppression, nonmaxSuppression, ArgInfo("nonmaxSuppression", 0)) &&
| 8681 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 8681 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 8682 | { |  | 8682 | {
| 8683 | ERRWRAP2(retval = cv::FastFeatureDetector::create(threshold, nonmaxSuppression, type)); |  | 8683 | ERRWRAP2(retval = cv::FastFeatureDetector::create(threshold, nonmaxSuppression, type));
| 8684 | return pyopencv_from(retval); |  | 8684 | return pyopencv_from(retval);
| 8685 | } |  | 8685 | }
| 8686 |  |  | 8686 |
| 8687 | return NULL; |  | 8687 | return NULL;
| 8688 | } |  | 8688 | }
| 8689 |  |  | 8689 |
| 8690 | static PyObject* pyopencv_cv_FastFeatureDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8690 | static PyObject* pyopencv_cv_FastFeatureDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 8691 | { |  | 8691 | {
| 8692 | using namespace cv; |  | 8692 | using namespace cv;
| 8693 |  |  | 8693 |
| 8694 |  |  | 8694 |
| 8695 | Ptr<cv::FastFeatureDetector> * self1 = 0; |  | 8695 | Ptr<cv::FastFeatureDetector> * self1 = 0;
| 8696 | if (!pyopencv_FastFeatureDetector_getp(self, self1)) |  | 8696 | if (!pyopencv_FastFeatureDetector_getp(self, self1))
| 8697 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)"); |  | 8697 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)");
| 8698 | Ptr<cv::FastFeatureDetector> _self_ = *(self1); |  | 8698 | Ptr<cv::FastFeatureDetector> _self_ = *(self1);
| 8699 | String retval; |  | 8699 | String retval;
| 8700 |  |  | 8700 |
| 8701 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8701 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8702 | { |  | 8702 | {
| 8703 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 8703 | ERRWRAP2(retval = _self_->getDefaultName());
| 8704 | return pyopencv_from(retval); |  | 8704 | return pyopencv_from(retval);
| 8705 | } |  | 8705 | }
| 8706 |  |  | 8706 |
| 8707 | return NULL; |  | 8707 | return NULL;
| 8708 | } |  | 8708 | }
| 8709 |  |  | 8709 |
| 8710 | static PyObject* pyopencv_cv_FastFeatureDetector_getNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8710 | static PyObject* pyopencv_cv_FastFeatureDetector_getNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw)
| 8711 | { |  | 8711 | {
| 8712 | using namespace cv; |  | 8712 | using namespace cv;
| 8713 |  |  | 8713 |
| 8714 |  |  | 8714 |
| 8715 | Ptr<cv::FastFeatureDetector> * self1 = 0; |  | 8715 | Ptr<cv::FastFeatureDetector> * self1 = 0;
| 8716 | if (!pyopencv_FastFeatureDetector_getp(self, self1)) |  | 8716 | if (!pyopencv_FastFeatureDetector_getp(self, self1))
| 8717 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)"); |  | 8717 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)");
| 8718 | Ptr<cv::FastFeatureDetector> _self_ = *(self1); |  | 8718 | Ptr<cv::FastFeatureDetector> _self_ = *(self1);
| 8719 | bool retval; |  | 8719 | bool retval;
| 8720 |  |  | 8720 |
| 8721 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8721 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8722 | { |  | 8722 | {
| 8723 | ERRWRAP2(retval = _self_->getNonmaxSuppression()); |  | 8723 | ERRWRAP2(retval = _self_->getNonmaxSuppression());
| 8724 | return pyopencv_from(retval); |  | 8724 | return pyopencv_from(retval);
| 8725 | } |  | 8725 | }
| 8726 |  |  | 8726 |
| 8727 | return NULL; |  | 8727 | return NULL;
| 8728 | } |  | 8728 | }
| 8729 |  |  | 8729 |
| 8730 | static PyObject* pyopencv_cv_FastFeatureDetector_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8730 | static PyObject* pyopencv_cv_FastFeatureDetector_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 8731 | { |  | 8731 | {
| 8732 | using namespace cv; |  | 8732 | using namespace cv;
| 8733 |  |  | 8733 |
| 8734 |  |  | 8734 |
| 8735 | Ptr<cv::FastFeatureDetector> * self1 = 0; |  | 8735 | Ptr<cv::FastFeatureDetector> * self1 = 0;
| 8736 | if (!pyopencv_FastFeatureDetector_getp(self, self1)) |  | 8736 | if (!pyopencv_FastFeatureDetector_getp(self, self1))
| 8737 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)"); |  | 8737 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)");
| 8738 | Ptr<cv::FastFeatureDetector> _self_ = *(self1); |  | 8738 | Ptr<cv::FastFeatureDetector> _self_ = *(self1);
| 8739 | int retval; |  | 8739 | int retval;
| 8740 |  |  | 8740 |
| 8741 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8741 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8742 | { |  | 8742 | {
| 8743 | ERRWRAP2(retval = _self_->getThreshold()); |  | 8743 | ERRWRAP2(retval = _self_->getThreshold());
| 8744 | return pyopencv_from(retval); |  | 8744 | return pyopencv_from(retval);
| 8745 | } |  | 8745 | }
| 8746 |  |  | 8746 |
| 8747 | return NULL; |  | 8747 | return NULL;
| 8748 | } |  | 8748 | }
| 8749 |  |  | 8749 |
| 8750 | static PyObject* pyopencv_cv_FastFeatureDetector_getType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8750 | static PyObject* pyopencv_cv_FastFeatureDetector_getType(PyObject* self, PyObject* py_args, PyObject* kw)
| 8751 | { |  | 8751 | {
| 8752 | using namespace cv; |  | 8752 | using namespace cv;
| 8753 |  |  | 8753 |
| 8754 |  |  | 8754 |
| 8755 | Ptr<cv::FastFeatureDetector> * self1 = 0; |  | 8755 | Ptr<cv::FastFeatureDetector> * self1 = 0;
| 8756 | if (!pyopencv_FastFeatureDetector_getp(self, self1)) |  | 8756 | if (!pyopencv_FastFeatureDetector_getp(self, self1))
| 8757 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)"); |  | 8757 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)");
| 8758 | Ptr<cv::FastFeatureDetector> _self_ = *(self1); |  | 8758 | Ptr<cv::FastFeatureDetector> _self_ = *(self1);
| 8759 | FastFeatureDetector::DetectorType retval; |  | 8759 | FastFeatureDetector::DetectorType retval;
| 8760 |  |  | 8760 |
| 8761 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 8761 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 8762 | { |  | 8762 | {
| 8763 | ERRWRAP2(retval = _self_->getType()); |  | 8763 | ERRWRAP2(retval = _self_->getType());
| 8764 | return pyopencv_from(retval); |  | 8764 | return pyopencv_from(retval);
| 8765 | } |  | 8765 | }
| 8766 |  |  | 8766 |
| 8767 | return NULL; |  | 8767 | return NULL;
| 8768 | } |  | 8768 | }
| 8769 |  |  | 8769 |
| 8770 | static PyObject* pyopencv_cv_FastFeatureDetector_setNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8770 | static PyObject* pyopencv_cv_FastFeatureDetector_setNonmaxSuppression(PyObject* self, PyObject* py_args, PyObject* kw)
| 8771 | { |  | 8771 | {
| 8772 | using namespace cv; |  | 8772 | using namespace cv;
| 8773 |  |  | 8773 |
| 8774 |  |  | 8774 |
| 8775 | Ptr<cv::FastFeatureDetector> * self1 = 0; |  | 8775 | Ptr<cv::FastFeatureDetector> * self1 = 0;
| 8776 | if (!pyopencv_FastFeatureDetector_getp(self, self1)) |  | 8776 | if (!pyopencv_FastFeatureDetector_getp(self, self1))
| 8777 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)"); |  | 8777 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)");
| 8778 | Ptr<cv::FastFeatureDetector> _self_ = *(self1); |  | 8778 | Ptr<cv::FastFeatureDetector> _self_ = *(self1);
| 8779 | PyObject* pyobj_f = NULL; |  | 8779 | PyObject* pyobj_f = NULL;
| 8780 | bool f=0; |  | 8780 | bool f=0;
| 8781 |  |  | 8781 |
| 8782 | const char* keywords[] = { "f", NULL }; |  | 8782 | const char* keywords[] = { "f", NULL };
| 8783 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FastFeatureDetector.setNonmaxSuppression", (char**)keywords, &pyobj_f) && |  | 8783 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FastFeatureDetector.setNonmaxSuppression", (char**)keywords, &pyobj_f) &&
| 8784 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) ) |  | 8784 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) )
| 8785 | { |  | 8785 | {
| 8786 | ERRWRAP2(_self_->setNonmaxSuppression(f)); |  | 8786 | ERRWRAP2(_self_->setNonmaxSuppression(f));
| 8787 | Py_RETURN_NONE; |  | 8787 | Py_RETURN_NONE;
| 8788 | } |  | 8788 | }
| 8789 |  |  | 8789 |
| 8790 | return NULL; |  | 8790 | return NULL;
| 8791 | } |  | 8791 | }
| 8792 |  |  | 8792 |
| 8793 | static PyObject* pyopencv_cv_FastFeatureDetector_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8793 | static PyObject* pyopencv_cv_FastFeatureDetector_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 8794 | { |  | 8794 | {
| 8795 | using namespace cv; |  | 8795 | using namespace cv;
| 8796 |  |  | 8796 |
| 8797 |  |  | 8797 |
| 8798 | Ptr<cv::FastFeatureDetector> * self1 = 0; |  | 8798 | Ptr<cv::FastFeatureDetector> * self1 = 0;
| 8799 | if (!pyopencv_FastFeatureDetector_getp(self, self1)) |  | 8799 | if (!pyopencv_FastFeatureDetector_getp(self, self1))
| 8800 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)"); |  | 8800 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)");
| 8801 | Ptr<cv::FastFeatureDetector> _self_ = *(self1); |  | 8801 | Ptr<cv::FastFeatureDetector> _self_ = *(self1);
| 8802 | PyObject* pyobj_threshold = NULL; |  | 8802 | PyObject* pyobj_threshold = NULL;
| 8803 | int threshold=0; |  | 8803 | int threshold=0;
| 8804 |  |  | 8804 |
| 8805 | const char* keywords[] = { "threshold", NULL }; |  | 8805 | const char* keywords[] = { "threshold", NULL };
| 8806 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FastFeatureDetector.setThreshold", (char**)keywords, &pyobj_threshold) && |  | 8806 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FastFeatureDetector.setThreshold", (char**)keywords, &pyobj_threshold) &&
| 8807 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 8807 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 8808 | { |  | 8808 | {
| 8809 | ERRWRAP2(_self_->setThreshold(threshold)); |  | 8809 | ERRWRAP2(_self_->setThreshold(threshold));
| 8810 | Py_RETURN_NONE; |  | 8810 | Py_RETURN_NONE;
| 8811 | } |  | 8811 | }
| 8812 |  |  | 8812 |
| 8813 | return NULL; |  | 8813 | return NULL;
| 8814 | } |  | 8814 | }
| 8815 |  |  | 8815 |
| 8816 | static PyObject* pyopencv_cv_FastFeatureDetector_setType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8816 | static PyObject* pyopencv_cv_FastFeatureDetector_setType(PyObject* self, PyObject* py_args, PyObject* kw)
| 8817 | { |  | 8817 | {
| 8818 | using namespace cv; |  | 8818 | using namespace cv;
| 8819 |  |  | 8819 |
| 8820 |  |  | 8820 |
| 8821 | Ptr<cv::FastFeatureDetector> * self1 = 0; |  | 8821 | Ptr<cv::FastFeatureDetector> * self1 = 0;
| 8822 | if (!pyopencv_FastFeatureDetector_getp(self, self1)) |  | 8822 | if (!pyopencv_FastFeatureDetector_getp(self, self1))
| 8823 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)"); |  | 8823 | return failmsgp("Incorrect type of self (must be 'FastFeatureDetector' or its derivative)");
| 8824 | Ptr<cv::FastFeatureDetector> _self_ = *(self1); |  | 8824 | Ptr<cv::FastFeatureDetector> _self_ = *(self1);
| 8825 | PyObject* pyobj_type = NULL; |  | 8825 | PyObject* pyobj_type = NULL;
| 8826 | FastFeatureDetector_DetectorType type=static_cast<FastFeatureDetector_DetectorType>(0); |  | 8826 | FastFeatureDetector_DetectorType type=static_cast<FastFeatureDetector_DetectorType>(0);
| 8827 |  |  | 8827 |
| 8828 | const char* keywords[] = { "type", NULL }; |  | 8828 | const char* keywords[] = { "type", NULL };
| 8829 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FastFeatureDetector.setType", (char**)keywords, &pyobj_type) && |  | 8829 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FastFeatureDetector.setType", (char**)keywords, &pyobj_type) &&
| 8830 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 8830 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 8831 | { |  | 8831 | {
| 8832 | ERRWRAP2(_self_->setType(type)); |  | 8832 | ERRWRAP2(_self_->setType(type));
| 8833 | Py_RETURN_NONE; |  | 8833 | Py_RETURN_NONE;
| 8834 | } |  | 8834 | }
| 8835 |  |  | 8835 |
| 8836 | return NULL; |  | 8836 | return NULL;
| 8837 | } |  | 8837 | }
| 8838 |  |  | 8838 |
| 8839 |  |  | 8839 |
| 8840 |  |  | 8840 |
| 8841 | // Tables (FastFeatureDetector) |  | 8841 | // Tables (FastFeatureDetector)
| 8842 |  |  | 8842 |
| 8843 | static PyGetSetDef pyopencv_FastFeatureDetector_getseters[] = |  | 8843 | static PyGetSetDef pyopencv_FastFeatureDetector_getseters[] =
| 8844 | { |  | 8844 | {
| 8845 | {NULL} /* Sentinel */ |  | 8845 | {NULL} /* Sentinel */
| 8846 | }; |  | 8846 | };
| 8847 |  |  | 8847 |
| 8848 | static PyMethodDef pyopencv_FastFeatureDetector_methods[] = |  | 8848 | static PyMethodDef pyopencv_FastFeatureDetector_methods[] =
| 8849 | { |  | 8849 | {
| 8850 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_create_static, METH_STATIC), "create([, threshold[, nonmaxSuppression[, type]]]) -> retval\n."}, |  | 8850 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_create_static, METH_STATIC), "create([, threshold[, nonmaxSuppression[, type]]]) -> retval\n."},
| 8851 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 8851 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 8852 | {"getNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getNonmaxSuppression, 0), "getNonmaxSuppression() -> retval\n."}, |  | 8852 | {"getNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getNonmaxSuppression, 0), "getNonmaxSuppression() -> retval\n."},
| 8853 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getThreshold, 0), "getThreshold() -> retval\n."}, |  | 8853 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getThreshold, 0), "getThreshold() -> retval\n."},
| 8854 | {"getType", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getType, 0), "getType() -> retval\n."}, |  | 8854 | {"getType", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_getType, 0), "getType() -> retval\n."},
| 8855 | {"setNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_setNonmaxSuppression, 0), "setNonmaxSuppression(f) -> None\n."}, |  | 8855 | {"setNonmaxSuppression", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_setNonmaxSuppression, 0), "setNonmaxSuppression(f) -> None\n."},
| 8856 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_setThreshold, 0), "setThreshold(threshold) -> None\n."}, |  | 8856 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_setThreshold, 0), "setThreshold(threshold) -> None\n."},
| 8857 | {"setType", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_setType, 0), "setType(type) -> None\n."}, |  | 8857 | {"setType", CV_PY_FN_WITH_KW_(pyopencv_cv_FastFeatureDetector_setType, 0), "setType(type) -> None\n."},
| 8858 |  |  | 8858 |
| 8859 | {NULL, NULL} |  | 8859 | {NULL, NULL}
| 8860 | }; |  | 8860 | };
| 8861 |  |  | 8861 |
| 8862 | // Converter (FastFeatureDetector) |  | 8862 | // Converter (FastFeatureDetector)
| 8863 |  |  | 8863 |
| 8864 | template<> |  | 8864 | template<>
| 8865 | struct PyOpenCV_Converter< Ptr<cv::FastFeatureDetector> > |  | 8865 | struct PyOpenCV_Converter< Ptr<cv::FastFeatureDetector> >
| 8866 | { |  | 8866 | {
| 8867 | static PyObject* from(const Ptr<cv::FastFeatureDetector>& r) |  | 8867 | static PyObject* from(const Ptr<cv::FastFeatureDetector>& r)
| 8868 | { |  | 8868 | {
| 8869 | return pyopencv_FastFeatureDetector_Instance(r); |  | 8869 | return pyopencv_FastFeatureDetector_Instance(r);
| 8870 | } |  | 8870 | }
| 8871 | static bool to(PyObject* src, Ptr<cv::FastFeatureDetector>& dst, const ArgInfo& info) |  | 8871 | static bool to(PyObject* src, Ptr<cv::FastFeatureDetector>& dst, const ArgInfo& info)
| 8872 | { |  | 8872 | {
| 8873 | if(!src || src == Py_None) |  | 8873 | if(!src || src == Py_None)
| 8874 | return true; |  | 8874 | return true;
| 8875 | Ptr<cv::FastFeatureDetector> * dst_; |  | 8875 | Ptr<cv::FastFeatureDetector> * dst_;
| 8876 | if (pyopencv_FastFeatureDetector_getp(src, dst_)) |  | 8876 | if (pyopencv_FastFeatureDetector_getp(src, dst_))
| 8877 | { |  | 8877 | {
| 8878 | dst = *dst_; |  | 8878 | dst = *dst_;
| 8879 | return true; |  | 8879 | return true;
| 8880 | } |  | 8880 | }
| 8881 |  |  | 8881 |
| 8882 | failmsg("Expected Ptr<cv::FastFeatureDetector> for argument '%s'", info.name); |  | 8882 | failmsg("Expected Ptr<cv::FastFeatureDetector> for argument '%s'", info.name);
| 8883 | return false; |  | 8883 | return false;
| 8884 | } |  | 8884 | }
| 8885 | }; |  | 8885 | };
| 8886 |  |  | 8886 |
| 8887 | //================================================================================ |  | 8887 | //================================================================================
| 8888 | // Feature2D (Generic) |  | 8888 | // Feature2D (Generic)
| 8889 | //================================================================================ |  | 8889 | //================================================================================
| 8890 |  |  | 8890 |
| 8891 | // GetSet (Feature2D) |  | 8891 | // GetSet (Feature2D)
| 8892 |  |  | 8892 |
| 8893 |  |  | 8893 |
| 8894 |  |  | 8894 |
| 8895 | // Methods (Feature2D) |  | 8895 | // Methods (Feature2D)
| 8896 |  |  | 8896 |
| 8897 | static PyObject* pyopencv_cv_Feature2D_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 8897 | static PyObject* pyopencv_cv_Feature2D_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 8898 | { |  | 8898 | {
| 8899 | using namespace cv; |  | 8899 | using namespace cv;
| 8900 |  |  | 8900 |
| 8901 |  |  | 8901 |
| 8902 | Ptr<cv::Feature2D> * self1 = 0; |  | 8902 | Ptr<cv::Feature2D> * self1 = 0;
| 8903 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 8903 | if (!pyopencv_Feature2D_getp(self, self1))
| 8904 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 8904 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 8905 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 8905 | Ptr<cv::Feature2D> _self_ = *(self1);
| 8906 | pyPrepareArgumentConversionErrorsStorage(4); |  | 8906 | pyPrepareArgumentConversionErrorsStorage(4);
| 8907 |  |  | 8907 |
| 8908 | { |  | 8908 | {
| 8909 | PyObject* pyobj_image = NULL; |  | 8909 | PyObject* pyobj_image = NULL;
| 8910 | Mat image; |  | 8910 | Mat image;
| 8911 | PyObject* pyobj_keypoints = NULL; |  | 8911 | PyObject* pyobj_keypoints = NULL;
| 8912 | vector_KeyPoint keypoints; |  | 8912 | vector_KeyPoint keypoints;
| 8913 | PyObject* pyobj_descriptors = NULL; |  | 8913 | PyObject* pyobj_descriptors = NULL;
| 8914 | Mat descriptors; |  | 8914 | Mat descriptors;
| 8915 |  |  | 8915 |
| 8916 | const char* keywords[] = { "image", "keypoints", "descriptors", NULL }; |  | 8916 | const char* keywords[] = { "image", "keypoints", "descriptors", NULL };
| 8917 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_image, &pyobj_keypoints, &pyobj_descriptors) && |  | 8917 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_image, &pyobj_keypoints, &pyobj_descriptors) &&
| 8918 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 8918 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 8919 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) && |  | 8919 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) &&
| 8920 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) ) |  | 8920 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) )
| 8921 | { |  | 8921 | {
| 8922 | ERRWRAP2(_self_->compute(image, keypoints, descriptors)); |  | 8922 | ERRWRAP2(_self_->compute(image, keypoints, descriptors));
| 8923 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors)); |  | 8923 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors));
| 8924 | } |  | 8924 | }
| 8925 |  |  | 8925 |
| 8926 |  |  | 8926 |
| 8927 | pyPopulateArgumentConversionErrors(); |  | 8927 | pyPopulateArgumentConversionErrors();
| 8928 | } |  | 8928 | }
| 8929 |  |  | 8929 |
| 8930 |  |  | 8930 |
| 8931 | { |  | 8931 | {
| 8932 | PyObject* pyobj_images = NULL; |  | 8932 | PyObject* pyobj_images = NULL;
| 8933 | vector_Mat images; |  | 8933 | vector_Mat images;
| 8934 | PyObject* pyobj_keypoints = NULL; |  | 8934 | PyObject* pyobj_keypoints = NULL;
| 8935 | vector_vector_KeyPoint keypoints; |  | 8935 | vector_vector_KeyPoint keypoints;
| 8936 | PyObject* pyobj_descriptors = NULL; |  | 8936 | PyObject* pyobj_descriptors = NULL;
| 8937 | vector_Mat descriptors; |  | 8937 | vector_Mat descriptors;
| 8938 |  |  | 8938 |
| 8939 | const char* keywords[] = { "images", "keypoints", "descriptors", NULL }; |  | 8939 | const char* keywords[] = { "images", "keypoints", "descriptors", NULL };
| 8940 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_images, &pyobj_keypoints, &pyobj_descriptors) && |  | 8940 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_images, &pyobj_keypoints, &pyobj_descriptors) &&
| 8941 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 8941 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 8942 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) && |  | 8942 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) &&
| 8943 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) ) |  | 8943 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) )
| 8944 | { |  | 8944 | {
| 8945 | ERRWRAP2(_self_->compute(images, keypoints, descriptors)); |  | 8945 | ERRWRAP2(_self_->compute(images, keypoints, descriptors));
| 8946 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors)); |  | 8946 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors));
| 8947 | } |  | 8947 | }
| 8948 |  |  | 8948 |
| 8949 |  |  | 8949 |
| 8950 | pyPopulateArgumentConversionErrors(); |  | 8950 | pyPopulateArgumentConversionErrors();
| 8951 | } |  | 8951 | }
| 8952 |  |  | 8952 |
| 8953 |  |  | 8953 |
| 8954 | { |  | 8954 | {
| 8955 | PyObject* pyobj_image = NULL; |  | 8955 | PyObject* pyobj_image = NULL;
| 8956 | UMat image; |  | 8956 | UMat image;
| 8957 | PyObject* pyobj_keypoints = NULL; |  | 8957 | PyObject* pyobj_keypoints = NULL;
| 8958 | vector_KeyPoint keypoints; |  | 8958 | vector_KeyPoint keypoints;
| 8959 | PyObject* pyobj_descriptors = NULL; |  | 8959 | PyObject* pyobj_descriptors = NULL;
| 8960 | UMat descriptors; |  | 8960 | UMat descriptors;
| 8961 |  |  | 8961 |
| 8962 | const char* keywords[] = { "image", "keypoints", "descriptors", NULL }; |  | 8962 | const char* keywords[] = { "image", "keypoints", "descriptors", NULL };
| 8963 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_image, &pyobj_keypoints, &pyobj_descriptors) && |  | 8963 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_image, &pyobj_keypoints, &pyobj_descriptors) &&
| 8964 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 8964 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 8965 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) && |  | 8965 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) &&
| 8966 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) ) |  | 8966 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) )
| 8967 | { |  | 8967 | {
| 8968 | ERRWRAP2(_self_->compute(image, keypoints, descriptors)); |  | 8968 | ERRWRAP2(_self_->compute(image, keypoints, descriptors));
| 8969 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors)); |  | 8969 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors));
| 8970 | } |  | 8970 | }
| 8971 |  |  | 8971 |
| 8972 |  |  | 8972 |
| 8973 | pyPopulateArgumentConversionErrors(); |  | 8973 | pyPopulateArgumentConversionErrors();
| 8974 | } |  | 8974 | }
| 8975 |  |  | 8975 |
| 8976 |  |  | 8976 |
| 8977 | { |  | 8977 | {
| 8978 | PyObject* pyobj_images = NULL; |  | 8978 | PyObject* pyobj_images = NULL;
| 8979 | vector_UMat images; |  | 8979 | vector_UMat images;
| 8980 | PyObject* pyobj_keypoints = NULL; |  | 8980 | PyObject* pyobj_keypoints = NULL;
| 8981 | vector_vector_KeyPoint keypoints; |  | 8981 | vector_vector_KeyPoint keypoints;
| 8982 | PyObject* pyobj_descriptors = NULL; |  | 8982 | PyObject* pyobj_descriptors = NULL;
| 8983 | vector_UMat descriptors; |  | 8983 | vector_UMat descriptors;
| 8984 |  |  | 8984 |
| 8985 | const char* keywords[] = { "images", "keypoints", "descriptors", NULL }; |  | 8985 | const char* keywords[] = { "images", "keypoints", "descriptors", NULL };
| 8986 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_images, &pyobj_keypoints, &pyobj_descriptors) && |  | 8986 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Feature2D.compute", (char**)keywords, &pyobj_images, &pyobj_keypoints, &pyobj_descriptors) &&
| 8987 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 8987 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 8988 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) && |  | 8988 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) &&
| 8989 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) ) |  | 8989 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) )
| 8990 | { |  | 8990 | {
| 8991 | ERRWRAP2(_self_->compute(images, keypoints, descriptors)); |  | 8991 | ERRWRAP2(_self_->compute(images, keypoints, descriptors));
| 8992 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors)); |  | 8992 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors));
| 8993 | } |  | 8993 | }
| 8994 |  |  | 8994 |
| 8995 |  |  | 8995 |
| 8996 | pyPopulateArgumentConversionErrors(); |  | 8996 | pyPopulateArgumentConversionErrors();
| 8997 | } |  | 8997 | }
| 8998 | pyRaiseCVOverloadException("compute"); |  | 8998 | pyRaiseCVOverloadException("compute");
| 8999 |  |  | 8999 |
| 9000 | return NULL; |  | 9000 | return NULL;
| 9001 | } |  | 9001 | }
| 9002 |  |  | 9002 |
| 9003 | static PyObject* pyopencv_cv_Feature2D_defaultNorm(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9003 | static PyObject* pyopencv_cv_Feature2D_defaultNorm(PyObject* self, PyObject* py_args, PyObject* kw)
| 9004 | { |  | 9004 | {
| 9005 | using namespace cv; |  | 9005 | using namespace cv;
| 9006 |  |  | 9006 |
| 9007 |  |  | 9007 |
| 9008 | Ptr<cv::Feature2D> * self1 = 0; |  | 9008 | Ptr<cv::Feature2D> * self1 = 0;
| 9009 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9009 | if (!pyopencv_Feature2D_getp(self, self1))
| 9010 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9010 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9011 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9011 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9012 | int retval; |  | 9012 | int retval;
| 9013 |  |  | 9013 |
| 9014 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9014 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9015 | { |  | 9015 | {
| 9016 | ERRWRAP2(retval = _self_->defaultNorm()); |  | 9016 | ERRWRAP2(retval = _self_->defaultNorm());
| 9017 | return pyopencv_from(retval); |  | 9017 | return pyopencv_from(retval);
| 9018 | } |  | 9018 | }
| 9019 |  |  | 9019 |
| 9020 | return NULL; |  | 9020 | return NULL;
| 9021 | } |  | 9021 | }
| 9022 |  |  | 9022 |
| 9023 | static PyObject* pyopencv_cv_Feature2D_descriptorSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9023 | static PyObject* pyopencv_cv_Feature2D_descriptorSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 9024 | { |  | 9024 | {
| 9025 | using namespace cv; |  | 9025 | using namespace cv;
| 9026 |  |  | 9026 |
| 9027 |  |  | 9027 |
| 9028 | Ptr<cv::Feature2D> * self1 = 0; |  | 9028 | Ptr<cv::Feature2D> * self1 = 0;
| 9029 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9029 | if (!pyopencv_Feature2D_getp(self, self1))
| 9030 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9030 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9031 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9031 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9032 | int retval; |  | 9032 | int retval;
| 9033 |  |  | 9033 |
| 9034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9035 | { |  | 9035 | {
| 9036 | ERRWRAP2(retval = _self_->descriptorSize()); |  | 9036 | ERRWRAP2(retval = _self_->descriptorSize());
| 9037 | return pyopencv_from(retval); |  | 9037 | return pyopencv_from(retval);
| 9038 | } |  | 9038 | }
| 9039 |  |  | 9039 |
| 9040 | return NULL; |  | 9040 | return NULL;
| 9041 | } |  | 9041 | }
| 9042 |  |  | 9042 |
| 9043 | static PyObject* pyopencv_cv_Feature2D_descriptorType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9043 | static PyObject* pyopencv_cv_Feature2D_descriptorType(PyObject* self, PyObject* py_args, PyObject* kw)
| 9044 | { |  | 9044 | {
| 9045 | using namespace cv; |  | 9045 | using namespace cv;
| 9046 |  |  | 9046 |
| 9047 |  |  | 9047 |
| 9048 | Ptr<cv::Feature2D> * self1 = 0; |  | 9048 | Ptr<cv::Feature2D> * self1 = 0;
| 9049 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9049 | if (!pyopencv_Feature2D_getp(self, self1))
| 9050 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9050 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9051 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9051 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9052 | int retval; |  | 9052 | int retval;
| 9053 |  |  | 9053 |
| 9054 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9054 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9055 | { |  | 9055 | {
| 9056 | ERRWRAP2(retval = _self_->descriptorType()); |  | 9056 | ERRWRAP2(retval = _self_->descriptorType());
| 9057 | return pyopencv_from(retval); |  | 9057 | return pyopencv_from(retval);
| 9058 | } |  | 9058 | }
| 9059 |  |  | 9059 |
| 9060 | return NULL; |  | 9060 | return NULL;
| 9061 | } |  | 9061 | }
| 9062 |  |  | 9062 |
| 9063 | static PyObject* pyopencv_cv_Feature2D_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9063 | static PyObject* pyopencv_cv_Feature2D_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 9064 | { |  | 9064 | {
| 9065 | using namespace cv; |  | 9065 | using namespace cv;
| 9066 |  |  | 9066 |
| 9067 |  |  | 9067 |
| 9068 | Ptr<cv::Feature2D> * self1 = 0; |  | 9068 | Ptr<cv::Feature2D> * self1 = 0;
| 9069 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9069 | if (!pyopencv_Feature2D_getp(self, self1))
| 9070 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9070 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9071 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9071 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9072 | pyPrepareArgumentConversionErrorsStorage(4); |  | 9072 | pyPrepareArgumentConversionErrorsStorage(4);
| 9073 |  |  | 9073 |
| 9074 | { |  | 9074 | {
| 9075 | PyObject* pyobj_image = NULL; |  | 9075 | PyObject* pyobj_image = NULL;
| 9076 | Mat image; |  | 9076 | Mat image;
| 9077 | vector_KeyPoint keypoints; |  | 9077 | vector_KeyPoint keypoints;
| 9078 | PyObject* pyobj_mask = NULL; |  | 9078 | PyObject* pyobj_mask = NULL;
| 9079 | Mat mask; |  | 9079 | Mat mask;
| 9080 |  |  | 9080 |
| 9081 | const char* keywords[] = { "image", "mask", NULL }; |  | 9081 | const char* keywords[] = { "image", "mask", NULL };
| 9082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_image, &pyobj_mask) && |  | 9082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_image, &pyobj_mask) &&
| 9083 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 9083 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 9084 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 9084 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 9085 | { |  | 9085 | {
| 9086 | ERRWRAP2(_self_->detect(image, keypoints, mask)); |  | 9086 | ERRWRAP2(_self_->detect(image, keypoints, mask));
| 9087 | return pyopencv_from(keypoints); |  | 9087 | return pyopencv_from(keypoints);
| 9088 | } |  | 9088 | }
| 9089 |  |  | 9089 |
| 9090 |  |  | 9090 |
| 9091 | pyPopulateArgumentConversionErrors(); |  | 9091 | pyPopulateArgumentConversionErrors();
| 9092 | } |  | 9092 | }
| 9093 |  |  | 9093 |
| 9094 |  |  | 9094 |
| 9095 | { |  | 9095 | {
| 9096 | PyObject* pyobj_images = NULL; |  | 9096 | PyObject* pyobj_images = NULL;
| 9097 | vector_Mat images; |  | 9097 | vector_Mat images;
| 9098 | vector_vector_KeyPoint keypoints; |  | 9098 | vector_vector_KeyPoint keypoints;
| 9099 | PyObject* pyobj_masks = NULL; |  | 9099 | PyObject* pyobj_masks = NULL;
| 9100 | vector_Mat masks; |  | 9100 | vector_Mat masks;
| 9101 |  |  | 9101 |
| 9102 | const char* keywords[] = { "images", "masks", NULL }; |  | 9102 | const char* keywords[] = { "images", "masks", NULL };
| 9103 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_images, &pyobj_masks) && |  | 9103 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_images, &pyobj_masks) &&
| 9104 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 9104 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 9105 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 9105 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 9106 | { |  | 9106 | {
| 9107 | ERRWRAP2(_self_->detect(images, keypoints, masks)); |  | 9107 | ERRWRAP2(_self_->detect(images, keypoints, masks));
| 9108 | return pyopencv_from(keypoints); |  | 9108 | return pyopencv_from(keypoints);
| 9109 | } |  | 9109 | }
| 9110 |  |  | 9110 |
| 9111 |  |  | 9111 |
| 9112 | pyPopulateArgumentConversionErrors(); |  | 9112 | pyPopulateArgumentConversionErrors();
| 9113 | } |  | 9113 | }
| 9114 |  |  | 9114 |
| 9115 |  |  | 9115 |
| 9116 | { |  | 9116 | {
| 9117 | PyObject* pyobj_image = NULL; |  | 9117 | PyObject* pyobj_image = NULL;
| 9118 | UMat image; |  | 9118 | UMat image;
| 9119 | vector_KeyPoint keypoints; |  | 9119 | vector_KeyPoint keypoints;
| 9120 | PyObject* pyobj_mask = NULL; |  | 9120 | PyObject* pyobj_mask = NULL;
| 9121 | UMat mask; |  | 9121 | UMat mask;
| 9122 |  |  | 9122 |
| 9123 | const char* keywords[] = { "image", "mask", NULL }; |  | 9123 | const char* keywords[] = { "image", "mask", NULL };
| 9124 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_image, &pyobj_mask) && |  | 9124 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_image, &pyobj_mask) &&
| 9125 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 9125 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 9126 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 9126 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 9127 | { |  | 9127 | {
| 9128 | ERRWRAP2(_self_->detect(image, keypoints, mask)); |  | 9128 | ERRWRAP2(_self_->detect(image, keypoints, mask));
| 9129 | return pyopencv_from(keypoints); |  | 9129 | return pyopencv_from(keypoints);
| 9130 | } |  | 9130 | }
| 9131 |  |  | 9131 |
| 9132 |  |  | 9132 |
| 9133 | pyPopulateArgumentConversionErrors(); |  | 9133 | pyPopulateArgumentConversionErrors();
| 9134 | } |  | 9134 | }
| 9135 |  |  | 9135 |
| 9136 |  |  | 9136 |
| 9137 | { |  | 9137 | {
| 9138 | PyObject* pyobj_images = NULL; |  | 9138 | PyObject* pyobj_images = NULL;
| 9139 | vector_UMat images; |  | 9139 | vector_UMat images;
| 9140 | vector_vector_KeyPoint keypoints; |  | 9140 | vector_vector_KeyPoint keypoints;
| 9141 | PyObject* pyobj_masks = NULL; |  | 9141 | PyObject* pyobj_masks = NULL;
| 9142 | vector_UMat masks; |  | 9142 | vector_UMat masks;
| 9143 |  |  | 9143 |
| 9144 | const char* keywords[] = { "images", "masks", NULL }; |  | 9144 | const char* keywords[] = { "images", "masks", NULL };
| 9145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_images, &pyobj_masks) && |  | 9145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Feature2D.detect", (char**)keywords, &pyobj_images, &pyobj_masks) &&
| 9146 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 9146 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 9147 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 9147 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 9148 | { |  | 9148 | {
| 9149 | ERRWRAP2(_self_->detect(images, keypoints, masks)); |  | 9149 | ERRWRAP2(_self_->detect(images, keypoints, masks));
| 9150 | return pyopencv_from(keypoints); |  | 9150 | return pyopencv_from(keypoints);
| 9151 | } |  | 9151 | }
| 9152 |  |  | 9152 |
| 9153 |  |  | 9153 |
| 9154 | pyPopulateArgumentConversionErrors(); |  | 9154 | pyPopulateArgumentConversionErrors();
| 9155 | } |  | 9155 | }
| 9156 | pyRaiseCVOverloadException("detect"); |  | 9156 | pyRaiseCVOverloadException("detect");
| 9157 |  |  | 9157 |
| 9158 | return NULL; |  | 9158 | return NULL;
| 9159 | } |  | 9159 | }
| 9160 |  |  | 9160 |
| 9161 | static PyObject* pyopencv_cv_Feature2D_detectAndCompute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9161 | static PyObject* pyopencv_cv_Feature2D_detectAndCompute(PyObject* self, PyObject* py_args, PyObject* kw)
| 9162 | { |  | 9162 | {
| 9163 | using namespace cv; |  | 9163 | using namespace cv;
| 9164 |  |  | 9164 |
| 9165 |  |  | 9165 |
| 9166 | Ptr<cv::Feature2D> * self1 = 0; |  | 9166 | Ptr<cv::Feature2D> * self1 = 0;
| 9167 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9167 | if (!pyopencv_Feature2D_getp(self, self1))
| 9168 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9168 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9169 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9169 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9170 | pyPrepareArgumentConversionErrorsStorage(2); |  | 9170 | pyPrepareArgumentConversionErrorsStorage(2);
| 9171 |  |  | 9171 |
| 9172 | { |  | 9172 | {
| 9173 | PyObject* pyobj_image = NULL; |  | 9173 | PyObject* pyobj_image = NULL;
| 9174 | Mat image; |  | 9174 | Mat image;
| 9175 | PyObject* pyobj_mask = NULL; |  | 9175 | PyObject* pyobj_mask = NULL;
| 9176 | Mat mask; |  | 9176 | Mat mask;
| 9177 | vector_KeyPoint keypoints; |  | 9177 | vector_KeyPoint keypoints;
| 9178 | PyObject* pyobj_descriptors = NULL; |  | 9178 | PyObject* pyobj_descriptors = NULL;
| 9179 | Mat descriptors; |  | 9179 | Mat descriptors;
| 9180 | PyObject* pyobj_useProvidedKeypoints = NULL; |  | 9180 | PyObject* pyobj_useProvidedKeypoints = NULL;
| 9181 | bool useProvidedKeypoints=false; |  | 9181 | bool useProvidedKeypoints=false;
| 9182 |  |  | 9182 |
| 9183 | const char* keywords[] = { "image", "mask", "descriptors", "useProvidedKeypoints", NULL }; |  | 9183 | const char* keywords[] = { "image", "mask", "descriptors", "useProvidedKeypoints", NULL };
| 9184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:Feature2D.detectAndCompute", (char**)keywords, &pyobj_image, &pyobj_mask, &pyobj_descriptors, &pyobj_useProvidedKeypoints) && |  | 9184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:Feature2D.detectAndCompute", (char**)keywords, &pyobj_image, &pyobj_mask, &pyobj_descriptors, &pyobj_useProvidedKeypoints) &&
| 9185 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 9185 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 9186 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 9186 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 9187 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) && |  | 9187 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) &&
| 9188 | pyopencv_to_safe(pyobj_useProvidedKeypoints, useProvidedKeypoints, ArgInfo("useProvidedKeypoints", 0)) ) |  | 9188 | pyopencv_to_safe(pyobj_useProvidedKeypoints, useProvidedKeypoints, ArgInfo("useProvidedKeypoints", 0)) )
| 9189 | { |  | 9189 | {
| 9190 | ERRWRAP2(_self_->detectAndCompute(image, mask, keypoints, descriptors, useProvidedKeypoints)); |  | 9190 | ERRWRAP2(_self_->detectAndCompute(image, mask, keypoints, descriptors, useProvidedKeypoints));
| 9191 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors)); |  | 9191 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors));
| 9192 | } |  | 9192 | }
| 9193 |  |  | 9193 |
| 9194 |  |  | 9194 |
| 9195 | pyPopulateArgumentConversionErrors(); |  | 9195 | pyPopulateArgumentConversionErrors();
| 9196 | } |  | 9196 | }
| 9197 |  |  | 9197 |
| 9198 |  |  | 9198 |
| 9199 | { |  | 9199 | {
| 9200 | PyObject* pyobj_image = NULL; |  | 9200 | PyObject* pyobj_image = NULL;
| 9201 | UMat image; |  | 9201 | UMat image;
| 9202 | PyObject* pyobj_mask = NULL; |  | 9202 | PyObject* pyobj_mask = NULL;
| 9203 | UMat mask; |  | 9203 | UMat mask;
| 9204 | vector_KeyPoint keypoints; |  | 9204 | vector_KeyPoint keypoints;
| 9205 | PyObject* pyobj_descriptors = NULL; |  | 9205 | PyObject* pyobj_descriptors = NULL;
| 9206 | UMat descriptors; |  | 9206 | UMat descriptors;
| 9207 | PyObject* pyobj_useProvidedKeypoints = NULL; |  | 9207 | PyObject* pyobj_useProvidedKeypoints = NULL;
| 9208 | bool useProvidedKeypoints=false; |  | 9208 | bool useProvidedKeypoints=false;
| 9209 |  |  | 9209 |
| 9210 | const char* keywords[] = { "image", "mask", "descriptors", "useProvidedKeypoints", NULL }; |  | 9210 | const char* keywords[] = { "image", "mask", "descriptors", "useProvidedKeypoints", NULL };
| 9211 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:Feature2D.detectAndCompute", (char**)keywords, &pyobj_image, &pyobj_mask, &pyobj_descriptors, &pyobj_useProvidedKeypoints) && |  | 9211 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:Feature2D.detectAndCompute", (char**)keywords, &pyobj_image, &pyobj_mask, &pyobj_descriptors, &pyobj_useProvidedKeypoints) &&
| 9212 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 9212 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 9213 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 9213 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 9214 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) && |  | 9214 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) &&
| 9215 | pyopencv_to_safe(pyobj_useProvidedKeypoints, useProvidedKeypoints, ArgInfo("useProvidedKeypoints", 0)) ) |  | 9215 | pyopencv_to_safe(pyobj_useProvidedKeypoints, useProvidedKeypoints, ArgInfo("useProvidedKeypoints", 0)) )
| 9216 | { |  | 9216 | {
| 9217 | ERRWRAP2(_self_->detectAndCompute(image, mask, keypoints, descriptors, useProvidedKeypoints)); |  | 9217 | ERRWRAP2(_self_->detectAndCompute(image, mask, keypoints, descriptors, useProvidedKeypoints));
| 9218 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors)); |  | 9218 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors));
| 9219 | } |  | 9219 | }
| 9220 |  |  | 9220 |
| 9221 |  |  | 9221 |
| 9222 | pyPopulateArgumentConversionErrors(); |  | 9222 | pyPopulateArgumentConversionErrors();
| 9223 | } |  | 9223 | }
| 9224 | pyRaiseCVOverloadException("detectAndCompute"); |  | 9224 | pyRaiseCVOverloadException("detectAndCompute");
| 9225 |  |  | 9225 |
| 9226 | return NULL; |  | 9226 | return NULL;
| 9227 | } |  | 9227 | }
| 9228 |  |  | 9228 |
| 9229 | static PyObject* pyopencv_cv_Feature2D_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9229 | static PyObject* pyopencv_cv_Feature2D_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 9230 | { |  | 9230 | {
| 9231 | using namespace cv; |  | 9231 | using namespace cv;
| 9232 |  |  | 9232 |
| 9233 |  |  | 9233 |
| 9234 | Ptr<cv::Feature2D> * self1 = 0; |  | 9234 | Ptr<cv::Feature2D> * self1 = 0;
| 9235 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9235 | if (!pyopencv_Feature2D_getp(self, self1))
| 9236 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9236 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9237 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9237 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9238 | bool retval; |  | 9238 | bool retval;
| 9239 |  |  | 9239 |
| 9240 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9240 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9241 | { |  | 9241 | {
| 9242 | ERRWRAP2(retval = _self_->empty()); |  | 9242 | ERRWRAP2(retval = _self_->empty());
| 9243 | return pyopencv_from(retval); |  | 9243 | return pyopencv_from(retval);
| 9244 | } |  | 9244 | }
| 9245 |  |  | 9245 |
| 9246 | return NULL; |  | 9246 | return NULL;
| 9247 | } |  | 9247 | }
| 9248 |  |  | 9248 |
| 9249 | static PyObject* pyopencv_cv_Feature2D_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9249 | static PyObject* pyopencv_cv_Feature2D_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 9250 | { |  | 9250 | {
| 9251 | using namespace cv; |  | 9251 | using namespace cv;
| 9252 |  |  | 9252 |
| 9253 |  |  | 9253 |
| 9254 | Ptr<cv::Feature2D> * self1 = 0; |  | 9254 | Ptr<cv::Feature2D> * self1 = 0;
| 9255 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9255 | if (!pyopencv_Feature2D_getp(self, self1))
| 9256 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9256 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9257 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9257 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9258 | String retval; |  | 9258 | String retval;
| 9259 |  |  | 9259 |
| 9260 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9260 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9261 | { |  | 9261 | {
| 9262 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 9262 | ERRWRAP2(retval = _self_->getDefaultName());
| 9263 | return pyopencv_from(retval); |  | 9263 | return pyopencv_from(retval);
| 9264 | } |  | 9264 | }
| 9265 |  |  | 9265 |
| 9266 | return NULL; |  | 9266 | return NULL;
| 9267 | } |  | 9267 | }
| 9268 |  |  | 9268 |
| 9269 | static PyObject* pyopencv_cv_Feature2D_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9269 | static PyObject* pyopencv_cv_Feature2D_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 9270 | { |  | 9270 | {
| 9271 | using namespace cv; |  | 9271 | using namespace cv;
| 9272 |  |  | 9272 |
| 9273 |  |  | 9273 |
| 9274 | Ptr<cv::Feature2D> * self1 = 0; |  | 9274 | Ptr<cv::Feature2D> * self1 = 0;
| 9275 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9275 | if (!pyopencv_Feature2D_getp(self, self1))
| 9276 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9276 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9277 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9277 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9278 | pyPrepareArgumentConversionErrorsStorage(2); |  | 9278 | pyPrepareArgumentConversionErrorsStorage(2);
| 9279 |  |  | 9279 |
| 9280 | { |  | 9280 | {
| 9281 | PyObject* pyobj_fileName = NULL; |  | 9281 | PyObject* pyobj_fileName = NULL;
| 9282 | String fileName; |  | 9282 | String fileName;
| 9283 |  |  | 9283 |
| 9284 | const char* keywords[] = { "fileName", NULL }; |  | 9284 | const char* keywords[] = { "fileName", NULL };
| 9285 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Feature2D.read", (char**)keywords, &pyobj_fileName) && |  | 9285 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Feature2D.read", (char**)keywords, &pyobj_fileName) &&
| 9286 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) ) |  | 9286 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) )
| 9287 | { |  | 9287 | {
| 9288 | ERRWRAP2(_self_->read(fileName)); |  | 9288 | ERRWRAP2(_self_->read(fileName));
| 9289 | Py_RETURN_NONE; |  | 9289 | Py_RETURN_NONE;
| 9290 | } |  | 9290 | }
| 9291 |  |  | 9291 |
| 9292 |  |  | 9292 |
| 9293 | pyPopulateArgumentConversionErrors(); |  | 9293 | pyPopulateArgumentConversionErrors();
| 9294 | } |  | 9294 | }
| 9295 |  |  | 9295 |
| 9296 |  |  | 9296 |
| 9297 | { |  | 9297 | {
| 9298 | PyObject* pyobj_arg1 = NULL; |  | 9298 | PyObject* pyobj_arg1 = NULL;
| 9299 | cv::FileNode arg1; |  | 9299 | cv::FileNode arg1;
| 9300 |  |  | 9300 |
| 9301 | const char* keywords[] = { "arg1", NULL }; |  | 9301 | const char* keywords[] = { "arg1", NULL };
| 9302 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Feature2D.read", (char**)keywords, &pyobj_arg1) && |  | 9302 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Feature2D.read", (char**)keywords, &pyobj_arg1) &&
| 9303 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) ) |  | 9303 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) )
| 9304 | { |  | 9304 | {
| 9305 | ERRWRAP2(_self_->read(arg1)); |  | 9305 | ERRWRAP2(_self_->read(arg1));
| 9306 | Py_RETURN_NONE; |  | 9306 | Py_RETURN_NONE;
| 9307 | } |  | 9307 | }
| 9308 |  |  | 9308 |
| 9309 |  |  | 9309 |
| 9310 | pyPopulateArgumentConversionErrors(); |  | 9310 | pyPopulateArgumentConversionErrors();
| 9311 | } |  | 9311 | }
| 9312 | pyRaiseCVOverloadException("read"); |  | 9312 | pyRaiseCVOverloadException("read");
| 9313 |  |  | 9313 |
| 9314 | return NULL; |  | 9314 | return NULL;
| 9315 | } |  | 9315 | }
| 9316 |  |  | 9316 |
| 9317 | static PyObject* pyopencv_cv_Feature2D_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9317 | static PyObject* pyopencv_cv_Feature2D_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 9318 | { |  | 9318 | {
| 9319 | using namespace cv; |  | 9319 | using namespace cv;
| 9320 |  |  | 9320 |
| 9321 |  |  | 9321 |
| 9322 | Ptr<cv::Feature2D> * self1 = 0; |  | 9322 | Ptr<cv::Feature2D> * self1 = 0;
| 9323 | if (!pyopencv_Feature2D_getp(self, self1)) |  | 9323 | if (!pyopencv_Feature2D_getp(self, self1))
| 9324 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)"); |  | 9324 | return failmsgp("Incorrect type of self (must be 'Feature2D' or its derivative)");
| 9325 | Ptr<cv::Feature2D> _self_ = *(self1); |  | 9325 | Ptr<cv::Feature2D> _self_ = *(self1);
| 9326 | pyPrepareArgumentConversionErrorsStorage(2); |  | 9326 | pyPrepareArgumentConversionErrorsStorage(2);
| 9327 |  |  | 9327 |
| 9328 | { |  | 9328 | {
| 9329 | PyObject* pyobj_fileName = NULL; |  | 9329 | PyObject* pyobj_fileName = NULL;
| 9330 | String fileName; |  | 9330 | String fileName;
| 9331 |  |  | 9331 |
| 9332 | const char* keywords[] = { "fileName", NULL }; |  | 9332 | const char* keywords[] = { "fileName", NULL };
| 9333 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Feature2D.write", (char**)keywords, &pyobj_fileName) && |  | 9333 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Feature2D.write", (char**)keywords, &pyobj_fileName) &&
| 9334 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) ) |  | 9334 | pyopencv_to_safe(pyobj_fileName, fileName, ArgInfo("fileName", 4)) )
| 9335 | { |  | 9335 | {
| 9336 | ERRWRAP2(_self_->write(fileName)); |  | 9336 | ERRWRAP2(_self_->write(fileName));
| 9337 | Py_RETURN_NONE; |  | 9337 | Py_RETURN_NONE;
| 9338 | } |  | 9338 | }
| 9339 |  |  | 9339 |
| 9340 |  |  | 9340 |
| 9341 | pyPopulateArgumentConversionErrors(); |  | 9341 | pyPopulateArgumentConversionErrors();
| 9342 | } |  | 9342 | }
| 9343 |  |  | 9343 |
| 9344 |  |  | 9344 |
| 9345 | { |  | 9345 | {
| 9346 | PyObject* pyobj_fs = NULL; |  | 9346 | PyObject* pyobj_fs = NULL;
| 9347 | Ptr<cv::FileStorage> fs; |  | 9347 | Ptr<cv::FileStorage> fs;
| 9348 | PyObject* pyobj_name = NULL; |  | 9348 | PyObject* pyobj_name = NULL;
| 9349 | String name; |  | 9349 | String name;
| 9350 |  |  | 9350 |
| 9351 | const char* keywords[] = { "fs", "name", NULL }; |  | 9351 | const char* keywords[] = { "fs", "name", NULL };
| 9352 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Feature2D.write", (char**)keywords, &pyobj_fs, &pyobj_name) && |  | 9352 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Feature2D.write", (char**)keywords, &pyobj_fs, &pyobj_name) &&
| 9353 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) && |  | 9353 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) &&
| 9354 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 9354 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 9355 | { |  | 9355 | {
| 9356 | ERRWRAP2(_self_->write(*fs, name)); |  | 9356 | ERRWRAP2(_self_->write(*fs, name));
| 9357 | Py_RETURN_NONE; |  | 9357 | Py_RETURN_NONE;
| 9358 | } |  | 9358 | }
| 9359 |  |  | 9359 |
| 9360 |  |  | 9360 |
| 9361 | pyPopulateArgumentConversionErrors(); |  | 9361 | pyPopulateArgumentConversionErrors();
| 9362 | } |  | 9362 | }
| 9363 | pyRaiseCVOverloadException("write"); |  | 9363 | pyRaiseCVOverloadException("write");
| 9364 |  |  | 9364 |
| 9365 | return NULL; |  | 9365 | return NULL;
| 9366 | } |  | 9366 | }
| 9367 |  |  | 9367 |
| 9368 |  |  | 9368 |
| 9369 |  |  | 9369 |
| 9370 | // Tables (Feature2D) |  | 9370 | // Tables (Feature2D)
| 9371 |  |  | 9371 |
| 9372 | static PyGetSetDef pyopencv_Feature2D_getseters[] = |  | 9372 | static PyGetSetDef pyopencv_Feature2D_getseters[] =
| 9373 | { |  | 9373 | {
| 9374 | {NULL} /* Sentinel */ |  | 9374 | {NULL} /* Sentinel */
| 9375 | }; |  | 9375 | };
| 9376 |  |  | 9376 |
| 9377 | static PyMethodDef pyopencv_Feature2D_methods[] = |  | 9377 | static PyMethodDef pyopencv_Feature2D_methods[] =
| 9378 | { |  | 9378 | {
| 9379 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_compute, 0), "compute(image, keypoints[, descriptors]) -> keypoints, descriptors\n. @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set\n. (second variant).\n. \n. @param image Image.\n. @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be\n. computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint\n. with several dominant orientations (for each orientation).\n. @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are\n. descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the\n. descriptor for keypoint j-th keypoint.\n\n\n\ncompute(images, keypoints[, descriptors]) -> keypoints, descriptors\n. @overload\n. \n. @param images Image set.\n. @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be\n. computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint\n. with several dominant orientations (for each orientation).\n. @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are\n. descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the\n. descriptor for keypoint j-th keypoint."}, |  | 9379 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_compute, 0), "compute(image, keypoints[, descriptors]) -> keypoints, descriptors\n. @brief Computes the descriptors for a set of keypoints detected in an image (first variant) or image set\n. (second variant).\n. \n. @param image Image.\n. @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be\n. computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint\n. with several dominant orientations (for each orientation).\n. @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are\n. descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the\n. descriptor for keypoint j-th keypoint.\n\n\n\ncompute(images, keypoints[, descriptors]) -> keypoints, descriptors\n. @overload\n. \n. @param images Image set.\n. @param keypoints Input collection of keypoints. Keypoints for which a descriptor cannot be\n. computed are removed. Sometimes new keypoints can be added, for example: SIFT duplicates keypoint\n. with several dominant orientations (for each orientation).\n. @param descriptors Computed descriptors. In the second variant of the method descriptors[i] are\n. descriptors computed for a keypoints[i]. Row j is the keypoints (or keypoints[i]) is the\n. descriptor for keypoint j-th keypoint."},
| 9380 | {"defaultNorm", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_defaultNorm, 0), "defaultNorm() -> retval\n."}, |  | 9380 | {"defaultNorm", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_defaultNorm, 0), "defaultNorm() -> retval\n."},
| 9381 | {"descriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_descriptorSize, 0), "descriptorSize() -> retval\n."}, |  | 9381 | {"descriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_descriptorSize, 0), "descriptorSize() -> retval\n."},
| 9382 | {"descriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_descriptorType, 0), "descriptorType() -> retval\n."}, |  | 9382 | {"descriptorType", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_descriptorType, 0), "descriptorType() -> retval\n."},
| 9383 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_detect, 0), "detect(image[, mask]) -> keypoints\n. @brief Detects keypoints in an image (first variant) or image set (second variant).\n. \n. @param image Image.\n. @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set\n. of keypoints detected in images[i] .\n. @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer\n. matrix with non-zero values in the region of interest.\n\n\n\ndetect(images[, masks]) -> keypoints\n. @overload\n. @param images Image set.\n. @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set\n. of keypoints detected in images[i] .\n. @param masks Masks for each input image specifying where to look for keypoints (optional).\n. masks[i] is a mask for images[i]."}, |  | 9383 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_detect, 0), "detect(image[, mask]) -> keypoints\n. @brief Detects keypoints in an image (first variant) or image set (second variant).\n. \n. @param image Image.\n. @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set\n. of keypoints detected in images[i] .\n. @param mask Mask specifying where to look for keypoints (optional). It must be a 8-bit integer\n. matrix with non-zero values in the region of interest.\n\n\n\ndetect(images[, masks]) -> keypoints\n. @overload\n. @param images Image set.\n. @param keypoints The detected keypoints. In the second variant of the method keypoints[i] is a set\n. of keypoints detected in images[i] .\n. @param masks Masks for each input image specifying where to look for keypoints (optional).\n. masks[i] is a mask for images[i]."},
| 9384 | {"detectAndCompute", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_detectAndCompute, 0), "detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors\n. Detects keypoints and computes the descriptors"}, |  | 9384 | {"detectAndCompute", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_detectAndCompute, 0), "detectAndCompute(image, mask[, descriptors[, useProvidedKeypoints]]) -> keypoints, descriptors\n. Detects keypoints and computes the descriptors"},
| 9385 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_empty, 0), "empty() -> retval\n."}, |  | 9385 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_empty, 0), "empty() -> retval\n."},
| 9386 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 9386 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 9387 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_read, 0), "read(fileName) -> None\n. \n\n\n\nread(arg1) -> None\n."}, |  | 9387 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_read, 0), "read(fileName) -> None\n. \n\n\n\nread(arg1) -> None\n."},
| 9388 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_write, 0), "write(fileName) -> None\n. \n\n\n\nwrite(fs, name) -> None\n."}, |  | 9388 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_Feature2D_write, 0), "write(fileName) -> None\n. \n\n\n\nwrite(fs, name) -> None\n."},
| 9389 |  |  | 9389 |
| 9390 | {NULL, NULL} |  | 9390 | {NULL, NULL}
| 9391 | }; |  | 9391 | };
| 9392 |  |  | 9392 |
| 9393 | // Converter (Feature2D) |  | 9393 | // Converter (Feature2D)
| 9394 |  |  | 9394 |
| 9395 | template<> |  | 9395 | template<>
| 9396 | struct PyOpenCV_Converter< Ptr<cv::Feature2D> > |  | 9396 | struct PyOpenCV_Converter< Ptr<cv::Feature2D> >
| 9397 | { |  | 9397 | {
| 9398 | static PyObject* from(const Ptr<cv::Feature2D>& r) |  | 9398 | static PyObject* from(const Ptr<cv::Feature2D>& r)
| 9399 | { |  | 9399 | {
| 9400 | return pyopencv_Feature2D_Instance(r); |  | 9400 | return pyopencv_Feature2D_Instance(r);
| 9401 | } |  | 9401 | }
| 9402 | static bool to(PyObject* src, Ptr<cv::Feature2D>& dst, const ArgInfo& info) |  | 9402 | static bool to(PyObject* src, Ptr<cv::Feature2D>& dst, const ArgInfo& info)
| 9403 | { |  | 9403 | {
| 9404 | if(!src || src == Py_None) |  | 9404 | if(!src || src == Py_None)
| 9405 | return true; |  | 9405 | return true;
| 9406 | Ptr<cv::Feature2D> * dst_; |  | 9406 | Ptr<cv::Feature2D> * dst_;
| 9407 | if (pyopencv_Feature2D_getp(src, dst_)) |  | 9407 | if (pyopencv_Feature2D_getp(src, dst_))
| 9408 | { |  | 9408 | {
| 9409 | dst = *dst_; |  | 9409 | dst = *dst_;
| 9410 | return true; |  | 9410 | return true;
| 9411 | } |  | 9411 | }
| 9412 |  |  | 9412 |
| 9413 | failmsg("Expected Ptr<cv::Feature2D> for argument '%s'", info.name); |  | 9413 | failmsg("Expected Ptr<cv::Feature2D> for argument '%s'", info.name);
| 9414 | return false; |  | 9414 | return false;
| 9415 | } |  | 9415 | }
| 9416 | }; |  | 9416 | };
| 9417 |  |  | 9417 |
| 9418 | //================================================================================ |  | 9418 | //================================================================================
| 9419 | // FileNode (Generic) |  | 9419 | // FileNode (Generic)
| 9420 | //================================================================================ |  | 9420 | //================================================================================
| 9421 |  |  | 9421 |
| 9422 | // GetSet (FileNode) |  | 9422 | // GetSet (FileNode)
| 9423 |  |  | 9423 |
| 9424 |  |  | 9424 |
| 9425 |  |  | 9425 |
| 9426 | // Methods (FileNode) |  | 9426 | // Methods (FileNode)
| 9427 |  |  | 9427 |
| 9428 | static int pyopencv_cv_FileNode_FileNode(pyopencv_FileNode_t* self, PyObject* py_args, PyObject* kw) |  | 9428 | static int pyopencv_cv_FileNode_FileNode(pyopencv_FileNode_t* self, PyObject* py_args, PyObject* kw)
| 9429 | { |  | 9429 | {
| 9430 | using namespace cv; |  | 9430 | using namespace cv;
| 9431 |  |  | 9431 |
| 9432 |  |  | 9432 |
| 9433 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9433 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9434 | { |  | 9434 | {
| 9435 | if(self) ERRWRAP2(new (&(self->v)) cv::FileNode()); |  | 9435 | if(self) ERRWRAP2(new (&(self->v)) cv::FileNode());
| 9436 | return 0; |  | 9436 | return 0;
| 9437 | } |  | 9437 | }
| 9438 |  |  | 9438 |
| 9439 | return -1; |  | 9439 | return -1;
| 9440 | } |  | 9440 | }
| 9441 |  |  | 9441 |
| 9442 | static PyObject* pyopencv_cv_FileNode_at(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9442 | static PyObject* pyopencv_cv_FileNode_at(PyObject* self, PyObject* py_args, PyObject* kw)
| 9443 | { |  | 9443 | {
| 9444 | using namespace cv; |  | 9444 | using namespace cv;
| 9445 |  |  | 9445 |
| 9446 |  |  | 9446 |
| 9447 | cv::FileNode * self1 = 0; |  | 9447 | cv::FileNode * self1 = 0;
| 9448 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9448 | if (!pyopencv_FileNode_getp(self, self1))
| 9449 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9449 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9450 | cv::FileNode* _self_ = (self1); |  | 9450 | cv::FileNode* _self_ = (self1);
| 9451 | PyObject* pyobj_i = NULL; |  | 9451 | PyObject* pyobj_i = NULL;
| 9452 | int i=0; |  | 9452 | int i=0;
| 9453 | FileNode retval; |  | 9453 | FileNode retval;
| 9454 |  |  | 9454 |
| 9455 | const char* keywords[] = { "i", NULL }; |  | 9455 | const char* keywords[] = { "i", NULL };
| 9456 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FileNode.at", (char**)keywords, &pyobj_i) && |  | 9456 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:FileNode.at", (char**)keywords, &pyobj_i) &&
| 9457 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) ) |  | 9457 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) )
| 9458 | { |  | 9458 | {
| 9459 | ERRWRAP2(retval = _self_->operator[](i)); |  | 9459 | ERRWRAP2(retval = _self_->operator[](i));
| 9460 | return pyopencv_from(retval); |  | 9460 | return pyopencv_from(retval);
| 9461 | } |  | 9461 | }
| 9462 |  |  | 9462 |
| 9463 | return NULL; |  | 9463 | return NULL;
| 9464 | } |  | 9464 | }
| 9465 |  |  | 9465 |
| 9466 | static PyObject* pyopencv_cv_FileNode_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9466 | static PyObject* pyopencv_cv_FileNode_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 9467 | { |  | 9467 | {
| 9468 | using namespace cv; |  | 9468 | using namespace cv;
| 9469 |  |  | 9469 |
| 9470 |  |  | 9470 |
| 9471 | cv::FileNode * self1 = 0; |  | 9471 | cv::FileNode * self1 = 0;
| 9472 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9472 | if (!pyopencv_FileNode_getp(self, self1))
| 9473 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9473 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9474 | cv::FileNode* _self_ = (self1); |  | 9474 | cv::FileNode* _self_ = (self1);
| 9475 | bool retval; |  | 9475 | bool retval;
| 9476 |  |  | 9476 |
| 9477 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9477 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9478 | { |  | 9478 | {
| 9479 | ERRWRAP2(retval = _self_->empty()); |  | 9479 | ERRWRAP2(retval = _self_->empty());
| 9480 | return pyopencv_from(retval); |  | 9480 | return pyopencv_from(retval);
| 9481 | } |  | 9481 | }
| 9482 |  |  | 9482 |
| 9483 | return NULL; |  | 9483 | return NULL;
| 9484 | } |  | 9484 | }
| 9485 |  |  | 9485 |
| 9486 | static PyObject* pyopencv_cv_FileNode_getNode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9486 | static PyObject* pyopencv_cv_FileNode_getNode(PyObject* self, PyObject* py_args, PyObject* kw)
| 9487 | { |  | 9487 | {
| 9488 | using namespace cv; |  | 9488 | using namespace cv;
| 9489 |  |  | 9489 |
| 9490 |  |  | 9490 |
| 9491 | cv::FileNode * self1 = 0; |  | 9491 | cv::FileNode * self1 = 0;
| 9492 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9492 | if (!pyopencv_FileNode_getp(self, self1))
| 9493 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9493 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9494 | cv::FileNode* _self_ = (self1); |  | 9494 | cv::FileNode* _self_ = (self1);
| 9495 | char* nodename=(char*)""; |  | 9495 | char* nodename=(char*)"";
| 9496 | FileNode retval; |  | 9496 | FileNode retval;
| 9497 |  |  | 9497 |
| 9498 | const char* keywords[] = { "nodename", NULL }; |  | 9498 | const char* keywords[] = { "nodename", NULL };
| 9499 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "s:FileNode.getNode", (char**)keywords, &nodename) ) |  | 9499 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "s:FileNode.getNode", (char**)keywords, &nodename) )
| 9500 | { |  | 9500 | {
| 9501 | ERRWRAP2(retval = _self_->operator[](nodename)); |  | 9501 | ERRWRAP2(retval = _self_->operator[](nodename));
| 9502 | return pyopencv_from(retval); |  | 9502 | return pyopencv_from(retval);
| 9503 | } |  | 9503 | }
| 9504 |  |  | 9504 |
| 9505 | return NULL; |  | 9505 | return NULL;
| 9506 | } |  | 9506 | }
| 9507 |  |  | 9507 |
| 9508 | static PyObject* pyopencv_cv_FileNode_isInt(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9508 | static PyObject* pyopencv_cv_FileNode_isInt(PyObject* self, PyObject* py_args, PyObject* kw)
| 9509 | { |  | 9509 | {
| 9510 | using namespace cv; |  | 9510 | using namespace cv;
| 9511 |  |  | 9511 |
| 9512 |  |  | 9512 |
| 9513 | cv::FileNode * self1 = 0; |  | 9513 | cv::FileNode * self1 = 0;
| 9514 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9514 | if (!pyopencv_FileNode_getp(self, self1))
| 9515 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9515 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9516 | cv::FileNode* _self_ = (self1); |  | 9516 | cv::FileNode* _self_ = (self1);
| 9517 | bool retval; |  | 9517 | bool retval;
| 9518 |  |  | 9518 |
| 9519 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9519 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9520 | { |  | 9520 | {
| 9521 | ERRWRAP2(retval = _self_->isInt()); |  | 9521 | ERRWRAP2(retval = _self_->isInt());
| 9522 | return pyopencv_from(retval); |  | 9522 | return pyopencv_from(retval);
| 9523 | } |  | 9523 | }
| 9524 |  |  | 9524 |
| 9525 | return NULL; |  | 9525 | return NULL;
| 9526 | } |  | 9526 | }
| 9527 |  |  | 9527 |
| 9528 | static PyObject* pyopencv_cv_FileNode_isMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9528 | static PyObject* pyopencv_cv_FileNode_isMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 9529 | { |  | 9529 | {
| 9530 | using namespace cv; |  | 9530 | using namespace cv;
| 9531 |  |  | 9531 |
| 9532 |  |  | 9532 |
| 9533 | cv::FileNode * self1 = 0; |  | 9533 | cv::FileNode * self1 = 0;
| 9534 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9534 | if (!pyopencv_FileNode_getp(self, self1))
| 9535 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9535 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9536 | cv::FileNode* _self_ = (self1); |  | 9536 | cv::FileNode* _self_ = (self1);
| 9537 | bool retval; |  | 9537 | bool retval;
| 9538 |  |  | 9538 |
| 9539 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9539 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9540 | { |  | 9540 | {
| 9541 | ERRWRAP2(retval = _self_->isMap()); |  | 9541 | ERRWRAP2(retval = _self_->isMap());
| 9542 | return pyopencv_from(retval); |  | 9542 | return pyopencv_from(retval);
| 9543 | } |  | 9543 | }
| 9544 |  |  | 9544 |
| 9545 | return NULL; |  | 9545 | return NULL;
| 9546 | } |  | 9546 | }
| 9547 |  |  | 9547 |
| 9548 | static PyObject* pyopencv_cv_FileNode_isNamed(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9548 | static PyObject* pyopencv_cv_FileNode_isNamed(PyObject* self, PyObject* py_args, PyObject* kw)
| 9549 | { |  | 9549 | {
| 9550 | using namespace cv; |  | 9550 | using namespace cv;
| 9551 |  |  | 9551 |
| 9552 |  |  | 9552 |
| 9553 | cv::FileNode * self1 = 0; |  | 9553 | cv::FileNode * self1 = 0;
| 9554 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9554 | if (!pyopencv_FileNode_getp(self, self1))
| 9555 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9555 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9556 | cv::FileNode* _self_ = (self1); |  | 9556 | cv::FileNode* _self_ = (self1);
| 9557 | bool retval; |  | 9557 | bool retval;
| 9558 |  |  | 9558 |
| 9559 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9559 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9560 | { |  | 9560 | {
| 9561 | ERRWRAP2(retval = _self_->isNamed()); |  | 9561 | ERRWRAP2(retval = _self_->isNamed());
| 9562 | return pyopencv_from(retval); |  | 9562 | return pyopencv_from(retval);
| 9563 | } |  | 9563 | }
| 9564 |  |  | 9564 |
| 9565 | return NULL; |  | 9565 | return NULL;
| 9566 | } |  | 9566 | }
| 9567 |  |  | 9567 |
| 9568 | static PyObject* pyopencv_cv_FileNode_isNone(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9568 | static PyObject* pyopencv_cv_FileNode_isNone(PyObject* self, PyObject* py_args, PyObject* kw)
| 9569 | { |  | 9569 | {
| 9570 | using namespace cv; |  | 9570 | using namespace cv;
| 9571 |  |  | 9571 |
| 9572 |  |  | 9572 |
| 9573 | cv::FileNode * self1 = 0; |  | 9573 | cv::FileNode * self1 = 0;
| 9574 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9574 | if (!pyopencv_FileNode_getp(self, self1))
| 9575 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9575 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9576 | cv::FileNode* _self_ = (self1); |  | 9576 | cv::FileNode* _self_ = (self1);
| 9577 | bool retval; |  | 9577 | bool retval;
| 9578 |  |  | 9578 |
| 9579 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9579 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9580 | { |  | 9580 | {
| 9581 | ERRWRAP2(retval = _self_->isNone()); |  | 9581 | ERRWRAP2(retval = _self_->isNone());
| 9582 | return pyopencv_from(retval); |  | 9582 | return pyopencv_from(retval);
| 9583 | } |  | 9583 | }
| 9584 |  |  | 9584 |
| 9585 | return NULL; |  | 9585 | return NULL;
| 9586 | } |  | 9586 | }
| 9587 |  |  | 9587 |
| 9588 | static PyObject* pyopencv_cv_FileNode_isReal(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9588 | static PyObject* pyopencv_cv_FileNode_isReal(PyObject* self, PyObject* py_args, PyObject* kw)
| 9589 | { |  | 9589 | {
| 9590 | using namespace cv; |  | 9590 | using namespace cv;
| 9591 |  |  | 9591 |
| 9592 |  |  | 9592 |
| 9593 | cv::FileNode * self1 = 0; |  | 9593 | cv::FileNode * self1 = 0;
| 9594 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9594 | if (!pyopencv_FileNode_getp(self, self1))
| 9595 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9595 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9596 | cv::FileNode* _self_ = (self1); |  | 9596 | cv::FileNode* _self_ = (self1);
| 9597 | bool retval; |  | 9597 | bool retval;
| 9598 |  |  | 9598 |
| 9599 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9599 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9600 | { |  | 9600 | {
| 9601 | ERRWRAP2(retval = _self_->isReal()); |  | 9601 | ERRWRAP2(retval = _self_->isReal());
| 9602 | return pyopencv_from(retval); |  | 9602 | return pyopencv_from(retval);
| 9603 | } |  | 9603 | }
| 9604 |  |  | 9604 |
| 9605 | return NULL; |  | 9605 | return NULL;
| 9606 | } |  | 9606 | }
| 9607 |  |  | 9607 |
| 9608 | static PyObject* pyopencv_cv_FileNode_isSeq(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9608 | static PyObject* pyopencv_cv_FileNode_isSeq(PyObject* self, PyObject* py_args, PyObject* kw)
| 9609 | { |  | 9609 | {
| 9610 | using namespace cv; |  | 9610 | using namespace cv;
| 9611 |  |  | 9611 |
| 9612 |  |  | 9612 |
| 9613 | cv::FileNode * self1 = 0; |  | 9613 | cv::FileNode * self1 = 0;
| 9614 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9614 | if (!pyopencv_FileNode_getp(self, self1))
| 9615 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9615 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9616 | cv::FileNode* _self_ = (self1); |  | 9616 | cv::FileNode* _self_ = (self1);
| 9617 | bool retval; |  | 9617 | bool retval;
| 9618 |  |  | 9618 |
| 9619 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9619 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9620 | { |  | 9620 | {
| 9621 | ERRWRAP2(retval = _self_->isSeq()); |  | 9621 | ERRWRAP2(retval = _self_->isSeq());
| 9622 | return pyopencv_from(retval); |  | 9622 | return pyopencv_from(retval);
| 9623 | } |  | 9623 | }
| 9624 |  |  | 9624 |
| 9625 | return NULL; |  | 9625 | return NULL;
| 9626 | } |  | 9626 | }
| 9627 |  |  | 9627 |
| 9628 | static PyObject* pyopencv_cv_FileNode_isString(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9628 | static PyObject* pyopencv_cv_FileNode_isString(PyObject* self, PyObject* py_args, PyObject* kw)
| 9629 | { |  | 9629 | {
| 9630 | using namespace cv; |  | 9630 | using namespace cv;
| 9631 |  |  | 9631 |
| 9632 |  |  | 9632 |
| 9633 | cv::FileNode * self1 = 0; |  | 9633 | cv::FileNode * self1 = 0;
| 9634 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9634 | if (!pyopencv_FileNode_getp(self, self1))
| 9635 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9635 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9636 | cv::FileNode* _self_ = (self1); |  | 9636 | cv::FileNode* _self_ = (self1);
| 9637 | bool retval; |  | 9637 | bool retval;
| 9638 |  |  | 9638 |
| 9639 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9639 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9640 | { |  | 9640 | {
| 9641 | ERRWRAP2(retval = _self_->isString()); |  | 9641 | ERRWRAP2(retval = _self_->isString());
| 9642 | return pyopencv_from(retval); |  | 9642 | return pyopencv_from(retval);
| 9643 | } |  | 9643 | }
| 9644 |  |  | 9644 |
| 9645 | return NULL; |  | 9645 | return NULL;
| 9646 | } |  | 9646 | }
| 9647 |  |  | 9647 |
| 9648 | static PyObject* pyopencv_cv_FileNode_keys(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9648 | static PyObject* pyopencv_cv_FileNode_keys(PyObject* self, PyObject* py_args, PyObject* kw)
| 9649 | { |  | 9649 | {
| 9650 | using namespace cv; |  | 9650 | using namespace cv;
| 9651 |  |  | 9651 |
| 9652 |  |  | 9652 |
| 9653 | cv::FileNode * self1 = 0; |  | 9653 | cv::FileNode * self1 = 0;
| 9654 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9654 | if (!pyopencv_FileNode_getp(self, self1))
| 9655 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9655 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9656 | cv::FileNode* _self_ = (self1); |  | 9656 | cv::FileNode* _self_ = (self1);
| 9657 | std::vector<String> retval; |  | 9657 | std::vector<String> retval;
| 9658 |  |  | 9658 |
| 9659 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9659 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9660 | { |  | 9660 | {
| 9661 | ERRWRAP2(retval = _self_->keys()); |  | 9661 | ERRWRAP2(retval = _self_->keys());
| 9662 | return pyopencv_from(retval); |  | 9662 | return pyopencv_from(retval);
| 9663 | } |  | 9663 | }
| 9664 |  |  | 9664 |
| 9665 | return NULL; |  | 9665 | return NULL;
| 9666 | } |  | 9666 | }
| 9667 |  |  | 9667 |
| 9668 | static PyObject* pyopencv_cv_FileNode_mat(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9668 | static PyObject* pyopencv_cv_FileNode_mat(PyObject* self, PyObject* py_args, PyObject* kw)
| 9669 | { |  | 9669 | {
| 9670 | using namespace cv; |  | 9670 | using namespace cv;
| 9671 |  |  | 9671 |
| 9672 |  |  | 9672 |
| 9673 | cv::FileNode * self1 = 0; |  | 9673 | cv::FileNode * self1 = 0;
| 9674 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9674 | if (!pyopencv_FileNode_getp(self, self1))
| 9675 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9675 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9676 | cv::FileNode* _self_ = (self1); |  | 9676 | cv::FileNode* _self_ = (self1);
| 9677 | Mat retval; |  | 9677 | Mat retval;
| 9678 |  |  | 9678 |
| 9679 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9679 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9680 | { |  | 9680 | {
| 9681 | ERRWRAP2(retval = _self_->mat()); |  | 9681 | ERRWRAP2(retval = _self_->mat());
| 9682 | return pyopencv_from(retval); |  | 9682 | return pyopencv_from(retval);
| 9683 | } |  | 9683 | }
| 9684 |  |  | 9684 |
| 9685 | return NULL; |  | 9685 | return NULL;
| 9686 | } |  | 9686 | }
| 9687 |  |  | 9687 |
| 9688 | static PyObject* pyopencv_cv_FileNode_name(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9688 | static PyObject* pyopencv_cv_FileNode_name(PyObject* self, PyObject* py_args, PyObject* kw)
| 9689 | { |  | 9689 | {
| 9690 | using namespace cv; |  | 9690 | using namespace cv;
| 9691 |  |  | 9691 |
| 9692 |  |  | 9692 |
| 9693 | cv::FileNode * self1 = 0; |  | 9693 | cv::FileNode * self1 = 0;
| 9694 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9694 | if (!pyopencv_FileNode_getp(self, self1))
| 9695 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9695 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9696 | cv::FileNode* _self_ = (self1); |  | 9696 | cv::FileNode* _self_ = (self1);
| 9697 | std::string retval; |  | 9697 | std::string retval;
| 9698 |  |  | 9698 |
| 9699 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9699 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9700 | { |  | 9700 | {
| 9701 | ERRWRAP2(retval = _self_->name()); |  | 9701 | ERRWRAP2(retval = _self_->name());
| 9702 | return pyopencv_from(retval); |  | 9702 | return pyopencv_from(retval);
| 9703 | } |  | 9703 | }
| 9704 |  |  | 9704 |
| 9705 | return NULL; |  | 9705 | return NULL;
| 9706 | } |  | 9706 | }
| 9707 |  |  | 9707 |
| 9708 | static PyObject* pyopencv_cv_FileNode_rawSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9708 | static PyObject* pyopencv_cv_FileNode_rawSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 9709 | { |  | 9709 | {
| 9710 | using namespace cv; |  | 9710 | using namespace cv;
| 9711 |  |  | 9711 |
| 9712 |  |  | 9712 |
| 9713 | cv::FileNode * self1 = 0; |  | 9713 | cv::FileNode * self1 = 0;
| 9714 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9714 | if (!pyopencv_FileNode_getp(self, self1))
| 9715 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9715 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9716 | cv::FileNode* _self_ = (self1); |  | 9716 | cv::FileNode* _self_ = (self1);
| 9717 | size_t retval; |  | 9717 | size_t retval;
| 9718 |  |  | 9718 |
| 9719 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9719 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9720 | { |  | 9720 | {
| 9721 | ERRWRAP2(retval = _self_->rawSize()); |  | 9721 | ERRWRAP2(retval = _self_->rawSize());
| 9722 | return pyopencv_from(retval); |  | 9722 | return pyopencv_from(retval);
| 9723 | } |  | 9723 | }
| 9724 |  |  | 9724 |
| 9725 | return NULL; |  | 9725 | return NULL;
| 9726 | } |  | 9726 | }
| 9727 |  |  | 9727 |
| 9728 | static PyObject* pyopencv_cv_FileNode_real(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9728 | static PyObject* pyopencv_cv_FileNode_real(PyObject* self, PyObject* py_args, PyObject* kw)
| 9729 | { |  | 9729 | {
| 9730 | using namespace cv; |  | 9730 | using namespace cv;
| 9731 |  |  | 9731 |
| 9732 |  |  | 9732 |
| 9733 | cv::FileNode * self1 = 0; |  | 9733 | cv::FileNode * self1 = 0;
| 9734 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9734 | if (!pyopencv_FileNode_getp(self, self1))
| 9735 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9735 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9736 | cv::FileNode* _self_ = (self1); |  | 9736 | cv::FileNode* _self_ = (self1);
| 9737 | double retval; |  | 9737 | double retval;
| 9738 |  |  | 9738 |
| 9739 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9739 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9740 | { |  | 9740 | {
| 9741 | ERRWRAP2(retval = _self_->real()); |  | 9741 | ERRWRAP2(retval = _self_->real());
| 9742 | return pyopencv_from(retval); |  | 9742 | return pyopencv_from(retval);
| 9743 | } |  | 9743 | }
| 9744 |  |  | 9744 |
| 9745 | return NULL; |  | 9745 | return NULL;
| 9746 | } |  | 9746 | }
| 9747 |  |  | 9747 |
| 9748 | static PyObject* pyopencv_cv_FileNode_size(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9748 | static PyObject* pyopencv_cv_FileNode_size(PyObject* self, PyObject* py_args, PyObject* kw)
| 9749 | { |  | 9749 | {
| 9750 | using namespace cv; |  | 9750 | using namespace cv;
| 9751 |  |  | 9751 |
| 9752 |  |  | 9752 |
| 9753 | cv::FileNode * self1 = 0; |  | 9753 | cv::FileNode * self1 = 0;
| 9754 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9754 | if (!pyopencv_FileNode_getp(self, self1))
| 9755 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9755 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9756 | cv::FileNode* _self_ = (self1); |  | 9756 | cv::FileNode* _self_ = (self1);
| 9757 | size_t retval; |  | 9757 | size_t retval;
| 9758 |  |  | 9758 |
| 9759 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9759 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9760 | { |  | 9760 | {
| 9761 | ERRWRAP2(retval = _self_->size()); |  | 9761 | ERRWRAP2(retval = _self_->size());
| 9762 | return pyopencv_from(retval); |  | 9762 | return pyopencv_from(retval);
| 9763 | } |  | 9763 | }
| 9764 |  |  | 9764 |
| 9765 | return NULL; |  | 9765 | return NULL;
| 9766 | } |  | 9766 | }
| 9767 |  |  | 9767 |
| 9768 | static PyObject* pyopencv_cv_FileNode_string(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9768 | static PyObject* pyopencv_cv_FileNode_string(PyObject* self, PyObject* py_args, PyObject* kw)
| 9769 | { |  | 9769 | {
| 9770 | using namespace cv; |  | 9770 | using namespace cv;
| 9771 |  |  | 9771 |
| 9772 |  |  | 9772 |
| 9773 | cv::FileNode * self1 = 0; |  | 9773 | cv::FileNode * self1 = 0;
| 9774 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9774 | if (!pyopencv_FileNode_getp(self, self1))
| 9775 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9775 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9776 | cv::FileNode* _self_ = (self1); |  | 9776 | cv::FileNode* _self_ = (self1);
| 9777 | std::string retval; |  | 9777 | std::string retval;
| 9778 |  |  | 9778 |
| 9779 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9779 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9780 | { |  | 9780 | {
| 9781 | ERRWRAP2(retval = _self_->string()); |  | 9781 | ERRWRAP2(retval = _self_->string());
| 9782 | return pyopencv_from(retval); |  | 9782 | return pyopencv_from(retval);
| 9783 | } |  | 9783 | }
| 9784 |  |  | 9784 |
| 9785 | return NULL; |  | 9785 | return NULL;
| 9786 | } |  | 9786 | }
| 9787 |  |  | 9787 |
| 9788 | static PyObject* pyopencv_cv_FileNode_type(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9788 | static PyObject* pyopencv_cv_FileNode_type(PyObject* self, PyObject* py_args, PyObject* kw)
| 9789 | { |  | 9789 | {
| 9790 | using namespace cv; |  | 9790 | using namespace cv;
| 9791 |  |  | 9791 |
| 9792 |  |  | 9792 |
| 9793 | cv::FileNode * self1 = 0; |  | 9793 | cv::FileNode * self1 = 0;
| 9794 | if (!pyopencv_FileNode_getp(self, self1)) |  | 9794 | if (!pyopencv_FileNode_getp(self, self1))
| 9795 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)"); |  | 9795 | return failmsgp("Incorrect type of self (must be 'FileNode' or its derivative)");
| 9796 | cv::FileNode* _self_ = (self1); |  | 9796 | cv::FileNode* _self_ = (self1);
| 9797 | int retval; |  | 9797 | int retval;
| 9798 |  |  | 9798 |
| 9799 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9799 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9800 | { |  | 9800 | {
| 9801 | ERRWRAP2(retval = _self_->type()); |  | 9801 | ERRWRAP2(retval = _self_->type());
| 9802 | return pyopencv_from(retval); |  | 9802 | return pyopencv_from(retval);
| 9803 | } |  | 9803 | }
| 9804 |  |  | 9804 |
| 9805 | return NULL; |  | 9805 | return NULL;
| 9806 | } |  | 9806 | }
| 9807 |  |  | 9807 |
| 9808 |  |  | 9808 |
| 9809 |  |  | 9809 |
| 9810 | // Tables (FileNode) |  | 9810 | // Tables (FileNode)
| 9811 |  |  | 9811 |
| 9812 | static PyGetSetDef pyopencv_FileNode_getseters[] = |  | 9812 | static PyGetSetDef pyopencv_FileNode_getseters[] =
| 9813 | { |  | 9813 | {
| 9814 | {NULL} /* Sentinel */ |  | 9814 | {NULL} /* Sentinel */
| 9815 | }; |  | 9815 | };
| 9816 |  |  | 9816 |
| 9817 | static PyMethodDef pyopencv_FileNode_methods[] = |  | 9817 | static PyMethodDef pyopencv_FileNode_methods[] =
| 9818 | { |  | 9818 | {
| 9819 | {"at", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_at, 0), "at(i) -> retval\n. @overload\n. @param i Index of an element in the sequence node."}, |  | 9819 | {"at", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_at, 0), "at(i) -> retval\n. @overload\n. @param i Index of an element in the sequence node."},
| 9820 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_empty, 0), "empty() -> retval\n."}, |  | 9820 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_empty, 0), "empty() -> retval\n."},
| 9821 | {"getNode", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_getNode, 0), "getNode(nodename) -> retval\n. @overload\n. @param nodename Name of an element in the mapping node."}, |  | 9821 | {"getNode", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_getNode, 0), "getNode(nodename) -> retval\n. @overload\n. @param nodename Name of an element in the mapping node."},
| 9822 | {"isInt", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isInt, 0), "isInt() -> retval\n."}, |  | 9822 | {"isInt", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isInt, 0), "isInt() -> retval\n."},
| 9823 | {"isMap", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isMap, 0), "isMap() -> retval\n."}, |  | 9823 | {"isMap", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isMap, 0), "isMap() -> retval\n."},
| 9824 | {"isNamed", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isNamed, 0), "isNamed() -> retval\n."}, |  | 9824 | {"isNamed", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isNamed, 0), "isNamed() -> retval\n."},
| 9825 | {"isNone", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isNone, 0), "isNone() -> retval\n."}, |  | 9825 | {"isNone", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isNone, 0), "isNone() -> retval\n."},
| 9826 | {"isReal", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isReal, 0), "isReal() -> retval\n."}, |  | 9826 | {"isReal", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isReal, 0), "isReal() -> retval\n."},
| 9827 | {"isSeq", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isSeq, 0), "isSeq() -> retval\n."}, |  | 9827 | {"isSeq", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isSeq, 0), "isSeq() -> retval\n."},
| 9828 | {"isString", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isString, 0), "isString() -> retval\n."}, |  | 9828 | {"isString", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_isString, 0), "isString() -> retval\n."},
| 9829 | {"keys", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_keys, 0), "keys() -> retval\n. @brief Returns keys of a mapping node.\n. @returns Keys of a mapping node."}, |  | 9829 | {"keys", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_keys, 0), "keys() -> retval\n. @brief Returns keys of a mapping node.\n. @returns Keys of a mapping node."},
| 9830 | {"mat", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_mat, 0), "mat() -> retval\n."}, |  | 9830 | {"mat", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_mat, 0), "mat() -> retval\n."},
| 9831 | {"name", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_name, 0), "name() -> retval\n."}, |  | 9831 | {"name", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_name, 0), "name() -> retval\n."},
| 9832 | {"rawSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_rawSize, 0), "rawSize() -> retval\n."}, |  | 9832 | {"rawSize", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_rawSize, 0), "rawSize() -> retval\n."},
| 9833 | {"real", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_real, 0), "real() -> retval\n. Internal method used when reading FileStorage.\n. Sets the type (int, real or string) and value of the previously created node."}, |  | 9833 | {"real", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_real, 0), "real() -> retval\n. Internal method used when reading FileStorage.\n. Sets the type (int, real or string) and value of the previously created node."},
| 9834 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_size, 0), "size() -> retval\n."}, |  | 9834 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_size, 0), "size() -> retval\n."},
| 9835 | {"string", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_string, 0), "string() -> retval\n."}, |  | 9835 | {"string", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_string, 0), "string() -> retval\n."},
| 9836 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_type, 0), "type() -> retval\n. @brief Returns type of the node.\n. @returns Type of the node. See FileNode::Type"}, |  | 9836 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_FileNode_type, 0), "type() -> retval\n. @brief Returns type of the node.\n. @returns Type of the node. See FileNode::Type"},
| 9837 |  |  | 9837 |
| 9838 | {NULL, NULL} |  | 9838 | {NULL, NULL}
| 9839 | }; |  | 9839 | };
| 9840 |  |  | 9840 |
| 9841 | // Converter (FileNode) |  | 9841 | // Converter (FileNode)
| 9842 |  |  | 9842 |
| 9843 | template<> |  | 9843 | template<>
| 9844 | struct PyOpenCV_Converter< cv::FileNode > |  | 9844 | struct PyOpenCV_Converter< cv::FileNode >
| 9845 | { |  | 9845 | {
| 9846 | static PyObject* from(const cv::FileNode& r) |  | 9846 | static PyObject* from(const cv::FileNode& r)
| 9847 | { |  | 9847 | {
| 9848 | return pyopencv_FileNode_Instance(r); |  | 9848 | return pyopencv_FileNode_Instance(r);
| 9849 | } |  | 9849 | }
| 9850 | static bool to(PyObject* src, cv::FileNode& dst, const ArgInfo& info) |  | 9850 | static bool to(PyObject* src, cv::FileNode& dst, const ArgInfo& info)
| 9851 | { |  | 9851 | {
| 9852 | if(!src || src == Py_None) |  | 9852 | if(!src || src == Py_None)
| 9853 | return true; |  | 9853 | return true;
| 9854 | cv::FileNode * dst_; |  | 9854 | cv::FileNode * dst_;
| 9855 | if (pyopencv_FileNode_getp(src, dst_)) |  | 9855 | if (pyopencv_FileNode_getp(src, dst_))
| 9856 | { |  | 9856 | {
| 9857 | dst = *dst_; |  | 9857 | dst = *dst_;
| 9858 | return true; |  | 9858 | return true;
| 9859 | } |  | 9859 | }
| 9860 |  |  | 9860 |
| 9861 | failmsg("Expected cv::FileNode for argument '%s'", info.name); |  | 9861 | failmsg("Expected cv::FileNode for argument '%s'", info.name);
| 9862 | return false; |  | 9862 | return false;
| 9863 | } |  | 9863 | }
| 9864 | }; |  | 9864 | };
| 9865 |  |  | 9865 |
| 9866 | //================================================================================ |  | 9866 | //================================================================================
| 9867 | // FileStorage (Generic) |  | 9867 | // FileStorage (Generic)
| 9868 | //================================================================================ |  | 9868 | //================================================================================
| 9869 |  |  | 9869 |
| 9870 | // GetSet (FileStorage) |  | 9870 | // GetSet (FileStorage)
| 9871 |  |  | 9871 |
| 9872 |  |  | 9872 |
| 9873 |  |  | 9873 |
| 9874 | // Methods (FileStorage) |  | 9874 | // Methods (FileStorage)
| 9875 |  |  | 9875 |
| 9876 | static int pyopencv_cv_FileStorage_FileStorage(pyopencv_FileStorage_t* self, PyObject* py_args, PyObject* kw) |  | 9876 | static int pyopencv_cv_FileStorage_FileStorage(pyopencv_FileStorage_t* self, PyObject* py_args, PyObject* kw)
| 9877 | { |  | 9877 | {
| 9878 | using namespace cv; |  | 9878 | using namespace cv;
| 9879 |  |  | 9879 |
| 9880 | pyPrepareArgumentConversionErrorsStorage(2); |  | 9880 | pyPrepareArgumentConversionErrorsStorage(2);
| 9881 |  |  | 9881 |
| 9882 | { |  | 9882 | {
| 9883 |  |  | 9883 |
| 9884 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9884 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9885 | { |  | 9885 | {
| 9886 | new (&(self->v)) Ptr<cv::FileStorage>(); // init Ptr with placement new |  | 9886 | new (&(self->v)) Ptr<cv::FileStorage>(); // init Ptr with placement new
| 9887 | if(self) ERRWRAP2(self->v.reset(new cv::FileStorage())); |  | 9887 | if(self) ERRWRAP2(self->v.reset(new cv::FileStorage()));
| 9888 | return 0; |  | 9888 | return 0;
| 9889 | } |  | 9889 | }
| 9890 |  |  | 9890 |
| 9891 |  |  | 9891 |
| 9892 | pyPopulateArgumentConversionErrors(); |  | 9892 | pyPopulateArgumentConversionErrors();
| 9893 | } |  | 9893 | }
| 9894 |  |  | 9894 |
| 9895 |  |  | 9895 |
| 9896 | { |  | 9896 | {
| 9897 | PyObject* pyobj_filename = NULL; |  | 9897 | PyObject* pyobj_filename = NULL;
| 9898 | String filename; |  | 9898 | String filename;
| 9899 | PyObject* pyobj_flags = NULL; |  | 9899 | PyObject* pyobj_flags = NULL;
| 9900 | int flags=0; |  | 9900 | int flags=0;
| 9901 | PyObject* pyobj_encoding = NULL; |  | 9901 | PyObject* pyobj_encoding = NULL;
| 9902 | String encoding; |  | 9902 | String encoding;
| 9903 |  |  | 9903 |
| 9904 | const char* keywords[] = { "filename", "flags", "encoding", NULL }; |  | 9904 | const char* keywords[] = { "filename", "flags", "encoding", NULL };
| 9905 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FileStorage", (char**)keywords, &pyobj_filename, &pyobj_flags, &pyobj_encoding) && |  | 9905 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FileStorage", (char**)keywords, &pyobj_filename, &pyobj_flags, &pyobj_encoding) &&
| 9906 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 9906 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 9907 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 9907 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 9908 | pyopencv_to_safe(pyobj_encoding, encoding, ArgInfo("encoding", 0)) ) |  | 9908 | pyopencv_to_safe(pyobj_encoding, encoding, ArgInfo("encoding", 0)) )
| 9909 | { |  | 9909 | {
| 9910 | new (&(self->v)) Ptr<cv::FileStorage>(); // init Ptr with placement new |  | 9910 | new (&(self->v)) Ptr<cv::FileStorage>(); // init Ptr with placement new
| 9911 | if(self) ERRWRAP2(self->v.reset(new cv::FileStorage(filename, flags, encoding))); |  | 9911 | if(self) ERRWRAP2(self->v.reset(new cv::FileStorage(filename, flags, encoding)));
| 9912 | return 0; |  | 9912 | return 0;
| 9913 | } |  | 9913 | }
| 9914 |  |  | 9914 |
| 9915 |  |  | 9915 |
| 9916 | pyPopulateArgumentConversionErrors(); |  | 9916 | pyPopulateArgumentConversionErrors();
| 9917 | } |  | 9917 | }
| 9918 | pyRaiseCVOverloadException("FileStorage"); |  | 9918 | pyRaiseCVOverloadException("FileStorage");
| 9919 |  |  | 9919 |
| 9920 | return -1; |  | 9920 | return -1;
| 9921 | } |  | 9921 | }
| 9922 |  |  | 9922 |
| 9923 | static PyObject* pyopencv_cv_FileStorage_endWriteStruct(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9923 | static PyObject* pyopencv_cv_FileStorage_endWriteStruct(PyObject* self, PyObject* py_args, PyObject* kw)
| 9924 | { |  | 9924 | {
| 9925 | using namespace cv; |  | 9925 | using namespace cv;
| 9926 |  |  | 9926 |
| 9927 |  |  | 9927 |
| 9928 | Ptr<cv::FileStorage> * self1 = 0; |  | 9928 | Ptr<cv::FileStorage> * self1 = 0;
| 9929 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 9929 | if (!pyopencv_FileStorage_getp(self, self1))
| 9930 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 9930 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 9931 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 9931 | Ptr<cv::FileStorage> _self_ = *(self1);
| 9932 |  |  | 9932 |
| 9933 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9933 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9934 | { |  | 9934 | {
| 9935 | ERRWRAP2(_self_->endWriteStruct()); |  | 9935 | ERRWRAP2(_self_->endWriteStruct());
| 9936 | Py_RETURN_NONE; |  | 9936 | Py_RETURN_NONE;
| 9937 | } |  | 9937 | }
| 9938 |  |  | 9938 |
| 9939 | return NULL; |  | 9939 | return NULL;
| 9940 | } |  | 9940 | }
| 9941 |  |  | 9941 |
| 9942 | static PyObject* pyopencv_cv_FileStorage_getFirstTopLevelNode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9942 | static PyObject* pyopencv_cv_FileStorage_getFirstTopLevelNode(PyObject* self, PyObject* py_args, PyObject* kw)
| 9943 | { |  | 9943 | {
| 9944 | using namespace cv; |  | 9944 | using namespace cv;
| 9945 |  |  | 9945 |
| 9946 |  |  | 9946 |
| 9947 | Ptr<cv::FileStorage> * self1 = 0; |  | 9947 | Ptr<cv::FileStorage> * self1 = 0;
| 9948 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 9948 | if (!pyopencv_FileStorage_getp(self, self1))
| 9949 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 9949 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 9950 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 9950 | Ptr<cv::FileStorage> _self_ = *(self1);
| 9951 | FileNode retval; |  | 9951 | FileNode retval;
| 9952 |  |  | 9952 |
| 9953 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9953 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9954 | { |  | 9954 | {
| 9955 | ERRWRAP2(retval = _self_->getFirstTopLevelNode()); |  | 9955 | ERRWRAP2(retval = _self_->getFirstTopLevelNode());
| 9956 | return pyopencv_from(retval); |  | 9956 | return pyopencv_from(retval);
| 9957 | } |  | 9957 | }
| 9958 |  |  | 9958 |
| 9959 | return NULL; |  | 9959 | return NULL;
| 9960 | } |  | 9960 | }
| 9961 |  |  | 9961 |
| 9962 | static PyObject* pyopencv_cv_FileStorage_getFormat(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9962 | static PyObject* pyopencv_cv_FileStorage_getFormat(PyObject* self, PyObject* py_args, PyObject* kw)
| 9963 | { |  | 9963 | {
| 9964 | using namespace cv; |  | 9964 | using namespace cv;
| 9965 |  |  | 9965 |
| 9966 |  |  | 9966 |
| 9967 | Ptr<cv::FileStorage> * self1 = 0; |  | 9967 | Ptr<cv::FileStorage> * self1 = 0;
| 9968 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 9968 | if (!pyopencv_FileStorage_getp(self, self1))
| 9969 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 9969 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 9970 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 9970 | Ptr<cv::FileStorage> _self_ = *(self1);
| 9971 | int retval; |  | 9971 | int retval;
| 9972 |  |  | 9972 |
| 9973 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 9973 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 9974 | { |  | 9974 | {
| 9975 | ERRWRAP2(retval = _self_->getFormat()); |  | 9975 | ERRWRAP2(retval = _self_->getFormat());
| 9976 | return pyopencv_from(retval); |  | 9976 | return pyopencv_from(retval);
| 9977 | } |  | 9977 | }
| 9978 |  |  | 9978 |
| 9979 | return NULL; |  | 9979 | return NULL;
| 9980 | } |  | 9980 | }
| 9981 |  |  | 9981 |
| 9982 | static PyObject* pyopencv_cv_FileStorage_getNode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 9982 | static PyObject* pyopencv_cv_FileStorage_getNode(PyObject* self, PyObject* py_args, PyObject* kw)
| 9983 | { |  | 9983 | {
| 9984 | using namespace cv; |  | 9984 | using namespace cv;
| 9985 |  |  | 9985 |
| 9986 |  |  | 9986 |
| 9987 | Ptr<cv::FileStorage> * self1 = 0; |  | 9987 | Ptr<cv::FileStorage> * self1 = 0;
| 9988 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 9988 | if (!pyopencv_FileStorage_getp(self, self1))
| 9989 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 9989 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 9990 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 9990 | Ptr<cv::FileStorage> _self_ = *(self1);
| 9991 | char* nodename=(char*)""; |  | 9991 | char* nodename=(char*)"";
| 9992 | FileNode retval; |  | 9992 | FileNode retval;
| 9993 |  |  | 9993 |
| 9994 | const char* keywords[] = { "nodename", NULL }; |  | 9994 | const char* keywords[] = { "nodename", NULL };
| 9995 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "s:FileStorage.getNode", (char**)keywords, &nodename) ) |  | 9995 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "s:FileStorage.getNode", (char**)keywords, &nodename) )
| 9996 | { |  | 9996 | {
| 9997 | ERRWRAP2(retval = _self_->operator[](nodename)); |  | 9997 | ERRWRAP2(retval = _self_->operator[](nodename));
| 9998 | return pyopencv_from(retval); |  | 9998 | return pyopencv_from(retval);
| 9999 | } |  | 9999 | }
| 10000 |  |  | 10000 |
| 10001 | return NULL; |  | 10001 | return NULL;
| 10002 | } |  | 10002 | }
| 10003 |  |  | 10003 |
| 10004 | static PyObject* pyopencv_cv_FileStorage_isOpened(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10004 | static PyObject* pyopencv_cv_FileStorage_isOpened(PyObject* self, PyObject* py_args, PyObject* kw)
| 10005 | { |  | 10005 | {
| 10006 | using namespace cv; |  | 10006 | using namespace cv;
| 10007 |  |  | 10007 |
| 10008 |  |  | 10008 |
| 10009 | Ptr<cv::FileStorage> * self1 = 0; |  | 10009 | Ptr<cv::FileStorage> * self1 = 0;
| 10010 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10010 | if (!pyopencv_FileStorage_getp(self, self1))
| 10011 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10011 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10012 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10012 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10013 | bool retval; |  | 10013 | bool retval;
| 10014 |  |  | 10014 |
| 10015 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 10015 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 10016 | { |  | 10016 | {
| 10017 | ERRWRAP2(retval = _self_->isOpened()); |  | 10017 | ERRWRAP2(retval = _self_->isOpened());
| 10018 | return pyopencv_from(retval); |  | 10018 | return pyopencv_from(retval);
| 10019 | } |  | 10019 | }
| 10020 |  |  | 10020 |
| 10021 | return NULL; |  | 10021 | return NULL;
| 10022 | } |  | 10022 | }
| 10023 |  |  | 10023 |
| 10024 | static PyObject* pyopencv_cv_FileStorage_open(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10024 | static PyObject* pyopencv_cv_FileStorage_open(PyObject* self, PyObject* py_args, PyObject* kw)
| 10025 | { |  | 10025 | {
| 10026 | using namespace cv; |  | 10026 | using namespace cv;
| 10027 |  |  | 10027 |
| 10028 |  |  | 10028 |
| 10029 | Ptr<cv::FileStorage> * self1 = 0; |  | 10029 | Ptr<cv::FileStorage> * self1 = 0;
| 10030 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10030 | if (!pyopencv_FileStorage_getp(self, self1))
| 10031 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10031 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10032 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10032 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10033 | PyObject* pyobj_filename = NULL; |  | 10033 | PyObject* pyobj_filename = NULL;
| 10034 | String filename; |  | 10034 | String filename;
| 10035 | PyObject* pyobj_flags = NULL; |  | 10035 | PyObject* pyobj_flags = NULL;
| 10036 | int flags=0; |  | 10036 | int flags=0;
| 10037 | PyObject* pyobj_encoding = NULL; |  | 10037 | PyObject* pyobj_encoding = NULL;
| 10038 | String encoding; |  | 10038 | String encoding;
| 10039 | bool retval; |  | 10039 | bool retval;
| 10040 |  |  | 10040 |
| 10041 | const char* keywords[] = { "filename", "flags", "encoding", NULL }; |  | 10041 | const char* keywords[] = { "filename", "flags", "encoding", NULL };
| 10042 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FileStorage.open", (char**)keywords, &pyobj_filename, &pyobj_flags, &pyobj_encoding) && |  | 10042 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FileStorage.open", (char**)keywords, &pyobj_filename, &pyobj_flags, &pyobj_encoding) &&
| 10043 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 10043 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 10044 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 10044 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 10045 | pyopencv_to_safe(pyobj_encoding, encoding, ArgInfo("encoding", 0)) ) |  | 10045 | pyopencv_to_safe(pyobj_encoding, encoding, ArgInfo("encoding", 0)) )
| 10046 | { |  | 10046 | {
| 10047 | ERRWRAP2(retval = _self_->open(filename, flags, encoding)); |  | 10047 | ERRWRAP2(retval = _self_->open(filename, flags, encoding));
| 10048 | return pyopencv_from(retval); |  | 10048 | return pyopencv_from(retval);
| 10049 | } |  | 10049 | }
| 10050 |  |  | 10050 |
| 10051 | return NULL; |  | 10051 | return NULL;
| 10052 | } |  | 10052 | }
| 10053 |  |  | 10053 |
| 10054 | static PyObject* pyopencv_cv_FileStorage_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10054 | static PyObject* pyopencv_cv_FileStorage_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 10055 | { |  | 10055 | {
| 10056 | using namespace cv; |  | 10056 | using namespace cv;
| 10057 |  |  | 10057 |
| 10058 |  |  | 10058 |
| 10059 | Ptr<cv::FileStorage> * self1 = 0; |  | 10059 | Ptr<cv::FileStorage> * self1 = 0;
| 10060 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10060 | if (!pyopencv_FileStorage_getp(self, self1))
| 10061 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10061 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10062 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10062 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10063 |  |  | 10063 |
| 10064 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 10064 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 10065 | { |  | 10065 | {
| 10066 | ERRWRAP2(_self_->release()); |  | 10066 | ERRWRAP2(_self_->release());
| 10067 | Py_RETURN_NONE; |  | 10067 | Py_RETURN_NONE;
| 10068 | } |  | 10068 | }
| 10069 |  |  | 10069 |
| 10070 | return NULL; |  | 10070 | return NULL;
| 10071 | } |  | 10071 | }
| 10072 |  |  | 10072 |
| 10073 | static PyObject* pyopencv_cv_FileStorage_releaseAndGetString(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10073 | static PyObject* pyopencv_cv_FileStorage_releaseAndGetString(PyObject* self, PyObject* py_args, PyObject* kw)
| 10074 | { |  | 10074 | {
| 10075 | using namespace cv; |  | 10075 | using namespace cv;
| 10076 |  |  | 10076 |
| 10077 |  |  | 10077 |
| 10078 | Ptr<cv::FileStorage> * self1 = 0; |  | 10078 | Ptr<cv::FileStorage> * self1 = 0;
| 10079 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10079 | if (!pyopencv_FileStorage_getp(self, self1))
| 10080 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10080 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10081 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10081 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10082 | String retval; |  | 10082 | String retval;
| 10083 |  |  | 10083 |
| 10084 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 10084 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 10085 | { |  | 10085 | {
| 10086 | ERRWRAP2(retval = _self_->releaseAndGetString()); |  | 10086 | ERRWRAP2(retval = _self_->releaseAndGetString());
| 10087 | return pyopencv_from(retval); |  | 10087 | return pyopencv_from(retval);
| 10088 | } |  | 10088 | }
| 10089 |  |  | 10089 |
| 10090 | return NULL; |  | 10090 | return NULL;
| 10091 | } |  | 10091 | }
| 10092 |  |  | 10092 |
| 10093 | static PyObject* pyopencv_cv_FileStorage_root(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10093 | static PyObject* pyopencv_cv_FileStorage_root(PyObject* self, PyObject* py_args, PyObject* kw)
| 10094 | { |  | 10094 | {
| 10095 | using namespace cv; |  | 10095 | using namespace cv;
| 10096 |  |  | 10096 |
| 10097 |  |  | 10097 |
| 10098 | Ptr<cv::FileStorage> * self1 = 0; |  | 10098 | Ptr<cv::FileStorage> * self1 = 0;
| 10099 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10099 | if (!pyopencv_FileStorage_getp(self, self1))
| 10100 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10100 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10101 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10101 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10102 | PyObject* pyobj_streamidx = NULL; |  | 10102 | PyObject* pyobj_streamidx = NULL;
| 10103 | int streamidx=0; |  | 10103 | int streamidx=0;
| 10104 | FileNode retval; |  | 10104 | FileNode retval;
| 10105 |  |  | 10105 |
| 10106 | const char* keywords[] = { "streamidx", NULL }; |  | 10106 | const char* keywords[] = { "streamidx", NULL };
| 10107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:FileStorage.root", (char**)keywords, &pyobj_streamidx) && |  | 10107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:FileStorage.root", (char**)keywords, &pyobj_streamidx) &&
| 10108 | pyopencv_to_safe(pyobj_streamidx, streamidx, ArgInfo("streamidx", 0)) ) |  | 10108 | pyopencv_to_safe(pyobj_streamidx, streamidx, ArgInfo("streamidx", 0)) )
| 10109 | { |  | 10109 | {
| 10110 | ERRWRAP2(retval = _self_->root(streamidx)); |  | 10110 | ERRWRAP2(retval = _self_->root(streamidx));
| 10111 | return pyopencv_from(retval); |  | 10111 | return pyopencv_from(retval);
| 10112 | } |  | 10112 | }
| 10113 |  |  | 10113 |
| 10114 | return NULL; |  | 10114 | return NULL;
| 10115 | } |  | 10115 | }
| 10116 |  |  | 10116 |
| 10117 | static PyObject* pyopencv_cv_FileStorage_startWriteStruct(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10117 | static PyObject* pyopencv_cv_FileStorage_startWriteStruct(PyObject* self, PyObject* py_args, PyObject* kw)
| 10118 | { |  | 10118 | {
| 10119 | using namespace cv; |  | 10119 | using namespace cv;
| 10120 |  |  | 10120 |
| 10121 |  |  | 10121 |
| 10122 | Ptr<cv::FileStorage> * self1 = 0; |  | 10122 | Ptr<cv::FileStorage> * self1 = 0;
| 10123 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10123 | if (!pyopencv_FileStorage_getp(self, self1))
| 10124 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10124 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10125 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10125 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10126 | PyObject* pyobj_name = NULL; |  | 10126 | PyObject* pyobj_name = NULL;
| 10127 | String name; |  | 10127 | String name;
| 10128 | PyObject* pyobj_flags = NULL; |  | 10128 | PyObject* pyobj_flags = NULL;
| 10129 | int flags=0; |  | 10129 | int flags=0;
| 10130 | PyObject* pyobj_typeName = NULL; |  | 10130 | PyObject* pyobj_typeName = NULL;
| 10131 | String typeName; |  | 10131 | String typeName;
| 10132 |  |  | 10132 |
| 10133 | const char* keywords[] = { "name", "flags", "typeName", NULL }; |  | 10133 | const char* keywords[] = { "name", "flags", "typeName", NULL };
| 10134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FileStorage.startWriteStruct", (char**)keywords, &pyobj_name, &pyobj_flags, &pyobj_typeName) && |  | 10134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:FileStorage.startWriteStruct", (char**)keywords, &pyobj_name, &pyobj_flags, &pyobj_typeName) &&
| 10135 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 10135 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 10136 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 10136 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 10137 | pyopencv_to_safe(pyobj_typeName, typeName, ArgInfo("typeName", 0)) ) |  | 10137 | pyopencv_to_safe(pyobj_typeName, typeName, ArgInfo("typeName", 0)) )
| 10138 | { |  | 10138 | {
| 10139 | ERRWRAP2(_self_->startWriteStruct(name, flags, typeName)); |  | 10139 | ERRWRAP2(_self_->startWriteStruct(name, flags, typeName));
| 10140 | Py_RETURN_NONE; |  | 10140 | Py_RETURN_NONE;
| 10141 | } |  | 10141 | }
| 10142 |  |  | 10142 |
| 10143 | return NULL; |  | 10143 | return NULL;
| 10144 | } |  | 10144 | }
| 10145 |  |  | 10145 |
| 10146 | static PyObject* pyopencv_cv_FileStorage_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10146 | static PyObject* pyopencv_cv_FileStorage_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 10147 | { |  | 10147 | {
| 10148 | using namespace cv; |  | 10148 | using namespace cv;
| 10149 |  |  | 10149 |
| 10150 |  |  | 10150 |
| 10151 | Ptr<cv::FileStorage> * self1 = 0; |  | 10151 | Ptr<cv::FileStorage> * self1 = 0;
| 10152 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10152 | if (!pyopencv_FileStorage_getp(self, self1))
| 10153 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10153 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10154 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10154 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10155 | pyPrepareArgumentConversionErrorsStorage(6); |  | 10155 | pyPrepareArgumentConversionErrorsStorage(6);
| 10156 |  |  | 10156 |
| 10157 | { |  | 10157 | {
| 10158 | PyObject* pyobj_name = NULL; |  | 10158 | PyObject* pyobj_name = NULL;
| 10159 | String name; |  | 10159 | String name;
| 10160 | PyObject* pyobj_val = NULL; |  | 10160 | PyObject* pyobj_val = NULL;
| 10161 | int val=0; |  | 10161 | int val=0;
| 10162 |  |  | 10162 |
| 10163 | const char* keywords[] = { "name", "val", NULL }; |  | 10163 | const char* keywords[] = { "name", "val", NULL };
| 10164 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) && |  | 10164 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) &&
| 10165 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 10165 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 10166 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 10166 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 10167 | { |  | 10167 | {
| 10168 | ERRWRAP2(_self_->write(name, val)); |  | 10168 | ERRWRAP2(_self_->write(name, val));
| 10169 | Py_RETURN_NONE; |  | 10169 | Py_RETURN_NONE;
| 10170 | } |  | 10170 | }
| 10171 |  |  | 10171 |
| 10172 |  |  | 10172 |
| 10173 | pyPopulateArgumentConversionErrors(); |  | 10173 | pyPopulateArgumentConversionErrors();
| 10174 | } |  | 10174 | }
| 10175 |  |  | 10175 |
| 10176 |  |  | 10176 |
| 10177 | { |  | 10177 | {
| 10178 | PyObject* pyobj_name = NULL; |  | 10178 | PyObject* pyobj_name = NULL;
| 10179 | String name; |  | 10179 | String name;
| 10180 | PyObject* pyobj_val = NULL; |  | 10180 | PyObject* pyobj_val = NULL;
| 10181 | int64_t val; |  | 10181 | int64_t val;
| 10182 |  |  | 10182 |
| 10183 | const char* keywords[] = { "name", "val", NULL }; |  | 10183 | const char* keywords[] = { "name", "val", NULL };
| 10184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) && |  | 10184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) &&
| 10185 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 10185 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 10186 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 10186 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 10187 | { |  | 10187 | {
| 10188 | ERRWRAP2(_self_->write(name, val)); |  | 10188 | ERRWRAP2(_self_->write(name, val));
| 10189 | Py_RETURN_NONE; |  | 10189 | Py_RETURN_NONE;
| 10190 | } |  | 10190 | }
| 10191 |  |  | 10191 |
| 10192 |  |  | 10192 |
| 10193 | pyPopulateArgumentConversionErrors(); |  | 10193 | pyPopulateArgumentConversionErrors();
| 10194 | } |  | 10194 | }
| 10195 |  |  | 10195 |
| 10196 |  |  | 10196 |
| 10197 | { |  | 10197 | {
| 10198 | PyObject* pyobj_name = NULL; |  | 10198 | PyObject* pyobj_name = NULL;
| 10199 | String name; |  | 10199 | String name;
| 10200 | PyObject* pyobj_val = NULL; |  | 10200 | PyObject* pyobj_val = NULL;
| 10201 | double val=0; |  | 10201 | double val=0;
| 10202 |  |  | 10202 |
| 10203 | const char* keywords[] = { "name", "val", NULL }; |  | 10203 | const char* keywords[] = { "name", "val", NULL };
| 10204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) && |  | 10204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) &&
| 10205 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 10205 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 10206 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 10206 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 10207 | { |  | 10207 | {
| 10208 | ERRWRAP2(_self_->write(name, val)); |  | 10208 | ERRWRAP2(_self_->write(name, val));
| 10209 | Py_RETURN_NONE; |  | 10209 | Py_RETURN_NONE;
| 10210 | } |  | 10210 | }
| 10211 |  |  | 10211 |
| 10212 |  |  | 10212 |
| 10213 | pyPopulateArgumentConversionErrors(); |  | 10213 | pyPopulateArgumentConversionErrors();
| 10214 | } |  | 10214 | }
| 10215 |  |  | 10215 |
| 10216 |  |  | 10216 |
| 10217 | { |  | 10217 | {
| 10218 | PyObject* pyobj_name = NULL; |  | 10218 | PyObject* pyobj_name = NULL;
| 10219 | String name; |  | 10219 | String name;
| 10220 | PyObject* pyobj_val = NULL; |  | 10220 | PyObject* pyobj_val = NULL;
| 10221 | String val; |  | 10221 | String val;
| 10222 |  |  | 10222 |
| 10223 | const char* keywords[] = { "name", "val", NULL }; |  | 10223 | const char* keywords[] = { "name", "val", NULL };
| 10224 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) && |  | 10224 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) &&
| 10225 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 10225 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 10226 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 10226 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 10227 | { |  | 10227 | {
| 10228 | ERRWRAP2(_self_->write(name, val)); |  | 10228 | ERRWRAP2(_self_->write(name, val));
| 10229 | Py_RETURN_NONE; |  | 10229 | Py_RETURN_NONE;
| 10230 | } |  | 10230 | }
| 10231 |  |  | 10231 |
| 10232 |  |  | 10232 |
| 10233 | pyPopulateArgumentConversionErrors(); |  | 10233 | pyPopulateArgumentConversionErrors();
| 10234 | } |  | 10234 | }
| 10235 |  |  | 10235 |
| 10236 |  |  | 10236 |
| 10237 | { |  | 10237 | {
| 10238 | PyObject* pyobj_name = NULL; |  | 10238 | PyObject* pyobj_name = NULL;
| 10239 | String name; |  | 10239 | String name;
| 10240 | PyObject* pyobj_val = NULL; |  | 10240 | PyObject* pyobj_val = NULL;
| 10241 | Mat val; |  | 10241 | Mat val;
| 10242 |  |  | 10242 |
| 10243 | const char* keywords[] = { "name", "val", NULL }; |  | 10243 | const char* keywords[] = { "name", "val", NULL };
| 10244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) && |  | 10244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) &&
| 10245 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 10245 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 10246 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 10246 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 10247 | { |  | 10247 | {
| 10248 | ERRWRAP2(_self_->write(name, val)); |  | 10248 | ERRWRAP2(_self_->write(name, val));
| 10249 | Py_RETURN_NONE; |  | 10249 | Py_RETURN_NONE;
| 10250 | } |  | 10250 | }
| 10251 |  |  | 10251 |
| 10252 |  |  | 10252 |
| 10253 | pyPopulateArgumentConversionErrors(); |  | 10253 | pyPopulateArgumentConversionErrors();
| 10254 | } |  | 10254 | }
| 10255 |  |  | 10255 |
| 10256 |  |  | 10256 |
| 10257 | { |  | 10257 | {
| 10258 | PyObject* pyobj_name = NULL; |  | 10258 | PyObject* pyobj_name = NULL;
| 10259 | String name; |  | 10259 | String name;
| 10260 | PyObject* pyobj_val = NULL; |  | 10260 | PyObject* pyobj_val = NULL;
| 10261 | vector_String val; |  | 10261 | vector_String val;
| 10262 |  |  | 10262 |
| 10263 | const char* keywords[] = { "name", "val", NULL }; |  | 10263 | const char* keywords[] = { "name", "val", NULL };
| 10264 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) && |  | 10264 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:FileStorage.write", (char**)keywords, &pyobj_name, &pyobj_val) &&
| 10265 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 10265 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 10266 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 10266 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 10267 | { |  | 10267 | {
| 10268 | ERRWRAP2(_self_->write(name, val)); |  | 10268 | ERRWRAP2(_self_->write(name, val));
| 10269 | Py_RETURN_NONE; |  | 10269 | Py_RETURN_NONE;
| 10270 | } |  | 10270 | }
| 10271 |  |  | 10271 |
| 10272 |  |  | 10272 |
| 10273 | pyPopulateArgumentConversionErrors(); |  | 10273 | pyPopulateArgumentConversionErrors();
| 10274 | } |  | 10274 | }
| 10275 | pyRaiseCVOverloadException("write"); |  | 10275 | pyRaiseCVOverloadException("write");
| 10276 |  |  | 10276 |
| 10277 | return NULL; |  | 10277 | return NULL;
| 10278 | } |  | 10278 | }
| 10279 |  |  | 10279 |
| 10280 | static PyObject* pyopencv_cv_FileStorage_writeComment(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10280 | static PyObject* pyopencv_cv_FileStorage_writeComment(PyObject* self, PyObject* py_args, PyObject* kw)
| 10281 | { |  | 10281 | {
| 10282 | using namespace cv; |  | 10282 | using namespace cv;
| 10283 |  |  | 10283 |
| 10284 |  |  | 10284 |
| 10285 | Ptr<cv::FileStorage> * self1 = 0; |  | 10285 | Ptr<cv::FileStorage> * self1 = 0;
| 10286 | if (!pyopencv_FileStorage_getp(self, self1)) |  | 10286 | if (!pyopencv_FileStorage_getp(self, self1))
| 10287 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)"); |  | 10287 | return failmsgp("Incorrect type of self (must be 'FileStorage' or its derivative)");
| 10288 | Ptr<cv::FileStorage> _self_ = *(self1); |  | 10288 | Ptr<cv::FileStorage> _self_ = *(self1);
| 10289 | PyObject* pyobj_comment = NULL; |  | 10289 | PyObject* pyobj_comment = NULL;
| 10290 | String comment; |  | 10290 | String comment;
| 10291 | PyObject* pyobj_append = NULL; |  | 10291 | PyObject* pyobj_append = NULL;
| 10292 | bool append=false; |  | 10292 | bool append=false;
| 10293 |  |  | 10293 |
| 10294 | const char* keywords[] = { "comment", "append", NULL }; |  | 10294 | const char* keywords[] = { "comment", "append", NULL };
| 10295 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FileStorage.writeComment", (char**)keywords, &pyobj_comment, &pyobj_append) && |  | 10295 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:FileStorage.writeComment", (char**)keywords, &pyobj_comment, &pyobj_append) &&
| 10296 | pyopencv_to_safe(pyobj_comment, comment, ArgInfo("comment", 0)) && |  | 10296 | pyopencv_to_safe(pyobj_comment, comment, ArgInfo("comment", 0)) &&
| 10297 | pyopencv_to_safe(pyobj_append, append, ArgInfo("append", 0)) ) |  | 10297 | pyopencv_to_safe(pyobj_append, append, ArgInfo("append", 0)) )
| 10298 | { |  | 10298 | {
| 10299 | ERRWRAP2(_self_->writeComment(comment, append)); |  | 10299 | ERRWRAP2(_self_->writeComment(comment, append));
| 10300 | Py_RETURN_NONE; |  | 10300 | Py_RETURN_NONE;
| 10301 | } |  | 10301 | }
| 10302 |  |  | 10302 |
| 10303 | return NULL; |  | 10303 | return NULL;
| 10304 | } |  | 10304 | }
| 10305 |  |  | 10305 |
| 10306 |  |  | 10306 |
| 10307 |  |  | 10307 |
| 10308 | // Tables (FileStorage) |  | 10308 | // Tables (FileStorage)
| 10309 |  |  | 10309 |
| 10310 | static PyGetSetDef pyopencv_FileStorage_getseters[] = |  | 10310 | static PyGetSetDef pyopencv_FileStorage_getseters[] =
| 10311 | { |  | 10311 | {
| 10312 | {NULL} /* Sentinel */ |  | 10312 | {NULL} /* Sentinel */
| 10313 | }; |  | 10313 | };
| 10314 |  |  | 10314 |
| 10315 | static PyMethodDef pyopencv_FileStorage_methods[] = |  | 10315 | static PyMethodDef pyopencv_FileStorage_methods[] =
| 10316 | { |  | 10316 | {
| 10317 | {"endWriteStruct", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_endWriteStruct, 0), "endWriteStruct() -> None\n. @brief Finishes writing nested structure (should pair startWriteStruct())"}, |  | 10317 | {"endWriteStruct", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_endWriteStruct, 0), "endWriteStruct() -> None\n. @brief Finishes writing nested structure (should pair startWriteStruct())"},
| 10318 | {"getFirstTopLevelNode", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_getFirstTopLevelNode, 0), "getFirstTopLevelNode() -> retval\n. @brief Returns the first element of the top-level mapping.\n. @returns The first element of the top-level mapping."}, |  | 10318 | {"getFirstTopLevelNode", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_getFirstTopLevelNode, 0), "getFirstTopLevelNode() -> retval\n. @brief Returns the first element of the top-level mapping.\n. @returns The first element of the top-level mapping."},
| 10319 | {"getFormat", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_getFormat, 0), "getFormat() -> retval\n. @brief Returns the current format.\n. * @returns The current format, see FileStorage::Mode"}, |  | 10319 | {"getFormat", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_getFormat, 0), "getFormat() -> retval\n. @brief Returns the current format.\n. * @returns The current format, see FileStorage::Mode"},
| 10320 | {"getNode", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_getNode, 0), "getNode(nodename) -> retval\n. @overload"}, |  | 10320 | {"getNode", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_getNode, 0), "getNode(nodename) -> retval\n. @overload"},
| 10321 | {"isOpened", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_isOpened, 0), "isOpened() -> retval\n. @brief Checks whether the file is opened.\n. \n. @returns true if the object is associated with the current file and false otherwise. It is a\n. good practice to call this method after you tried to open a file."}, |  | 10321 | {"isOpened", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_isOpened, 0), "isOpened() -> retval\n. @brief Checks whether the file is opened.\n. \n. @returns true if the object is associated with the current file and false otherwise. It is a\n. good practice to call this method after you tried to open a file."},
| 10322 | {"open", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_open, 0), "open(filename, flags[, encoding]) -> retval\n. @brief Opens a file.\n. \n. See description of parameters in FileStorage::FileStorage. The method calls FileStorage::release\n. before opening the file.\n. @param filename Name of the file to open or the text string to read the data from.\n. Extension of the file (.xml, .yml/.yaml or .json) determines its format (XML, YAML or JSON\n. respectively). Also you can append .gz to work with compressed files, for example myHugeMatrix.xml.gz. If both\n. FileStorage::WRITE and FileStorage::MEMORY flags are specified, source is used just to specify\n. the output file format (e.g. mydata.xml, .yml etc.). A file name can also contain parameters.\n. You can use this format, \"*?base64\" (e.g. \"file.json?base64\" (case sensitive)), as an alternative to\n. FileStorage::BASE64 flag.\n. @param flags Mode of operation. One of FileStorage::Mode\n. @param encoding Encoding of the file. Note that UTF-16 XML encoding is not supported currently and\n. you should use 8-bit encoding instead of it."}, |  | 10322 | {"open", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_open, 0), "open(filename, flags[, encoding]) -> retval\n. @brief Opens a file.\n. \n. See description of parameters in FileStorage::FileStorage. The method calls FileStorage::release\n. before opening the file.\n. @param filename Name of the file to open or the text string to read the data from.\n. Extension of the file (.xml, .yml/.yaml or .json) determines its format (XML, YAML or JSON\n. respectively). Also you can append .gz to work with compressed files, for example myHugeMatrix.xml.gz. If both\n. FileStorage::WRITE and FileStorage::MEMORY flags are specified, source is used just to specify\n. the output file format (e.g. mydata.xml, .yml etc.). A file name can also contain parameters.\n. You can use this format, \"*?base64\" (e.g. \"file.json?base64\" (case sensitive)), as an alternative to\n. FileStorage::BASE64 flag.\n. @param flags Mode of operation. One of FileStorage::Mode\n. @param encoding Encoding of the file. Note that UTF-16 XML encoding is not supported currently and\n. you should use 8-bit encoding instead of it."},
| 10323 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_release, 0), "release() -> None\n. @brief Closes the file and releases all the memory buffers.\n. \n. Call this method after all I/O operations with the storage are finished."}, |  | 10323 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_release, 0), "release() -> None\n. @brief Closes the file and releases all the memory buffers.\n. \n. Call this method after all I/O operations with the storage are finished."},
| 10324 | {"releaseAndGetString", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_releaseAndGetString, 0), "releaseAndGetString() -> retval\n. @brief Closes the file and releases all the memory buffers.\n. \n. Call this method after all I/O operations with the storage are finished. If the storage was\n. opened for writing data and FileStorage::WRITE was specified"}, |  | 10324 | {"releaseAndGetString", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_releaseAndGetString, 0), "releaseAndGetString() -> retval\n. @brief Closes the file and releases all the memory buffers.\n. \n. Call this method after all I/O operations with the storage are finished. If the storage was\n. opened for writing data and FileStorage::WRITE was specified"},
| 10325 | {"root", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_root, 0), "root([, streamidx]) -> retval\n. @brief Returns the top-level mapping\n. @param streamidx Zero-based index of the stream. In most cases there is only one stream in the file.\n. However, YAML supports multiple streams and so there can be several.\n. @returns The top-level mapping."}, |  | 10325 | {"root", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_root, 0), "root([, streamidx]) -> retval\n. @brief Returns the top-level mapping\n. @param streamidx Zero-based index of the stream. In most cases there is only one stream in the file.\n. However, YAML supports multiple streams and so there can be several.\n. @returns The top-level mapping."},
| 10326 | {"startWriteStruct", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_startWriteStruct, 0), "startWriteStruct(name, flags[, typeName]) -> None\n. @brief Starts to write a nested structure (sequence or a mapping).\n. @param name name of the structure. When writing to sequences (a.k.a. \"arrays\"), pass an empty string.\n. @param flags type of the structure (FileNode::MAP or FileNode::SEQ (both with optional FileNode::FLOW)).\n. @param typeName optional name of the type you store. The effect of setting this depends on the storage format.\n. I.e. if the format has a specification for storing type information, this parameter is used."}, |  | 10326 | {"startWriteStruct", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_startWriteStruct, 0), "startWriteStruct(name, flags[, typeName]) -> None\n. @brief Starts to write a nested structure (sequence or a mapping).\n. @param name name of the structure. When writing to sequences (a.k.a. \"arrays\"), pass an empty string.\n. @param flags type of the structure (FileNode::MAP or FileNode::SEQ (both with optional FileNode::FLOW)).\n. @param typeName optional name of the type you store. The effect of setting this depends on the storage format.\n. I.e. if the format has a specification for storing type information, this parameter is used."},
| 10327 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_write, 0), "write(name, val) -> None\n. * @brief Simplified writing API to use with bindings.\n. * @param name Name of the written object. When writing to sequences (a.k.a. \"arrays\"), pass an empty string.\n. * @param val Value of the written object."}, |  | 10327 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_write, 0), "write(name, val) -> None\n. * @brief Simplified writing API to use with bindings.\n. * @param name Name of the written object. When writing to sequences (a.k.a. \"arrays\"), pass an empty string.\n. * @param val Value of the written object."},
| 10328 | {"writeComment", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_writeComment, 0), "writeComment(comment[, append]) -> None\n. @brief Writes a comment.\n. \n. The function writes a comment into file storage. The comments are skipped when the storage is read.\n. @param comment The written comment, single-line or multi-line\n. @param append If true, the function tries to put the comment at the end of current line.\n. Else if the comment is multi-line, or if it does not fit at the end of the current\n. line, the comment starts a new line."}, |  | 10328 | {"writeComment", CV_PY_FN_WITH_KW_(pyopencv_cv_FileStorage_writeComment, 0), "writeComment(comment[, append]) -> None\n. @brief Writes a comment.\n. \n. The function writes a comment into file storage. The comments are skipped when the storage is read.\n. @param comment The written comment, single-line or multi-line\n. @param append If true, the function tries to put the comment at the end of current line.\n. Else if the comment is multi-line, or if it does not fit at the end of the current\n. line, the comment starts a new line."},
| 10329 |  |  | 10329 |
| 10330 | {NULL, NULL} |  | 10330 | {NULL, NULL}
| 10331 | }; |  | 10331 | };
| 10332 |  |  | 10332 |
| 10333 | // Converter (FileStorage) |  | 10333 | // Converter (FileStorage)
| 10334 |  |  | 10334 |
| 10335 | template<> |  | 10335 | template<>
| 10336 | struct PyOpenCV_Converter< Ptr<cv::FileStorage> > |  | 10336 | struct PyOpenCV_Converter< Ptr<cv::FileStorage> >
| 10337 | { |  | 10337 | {
| 10338 | static PyObject* from(const Ptr<cv::FileStorage>& r) |  | 10338 | static PyObject* from(const Ptr<cv::FileStorage>& r)
| 10339 | { |  | 10339 | {
| 10340 | return pyopencv_FileStorage_Instance(r); |  | 10340 | return pyopencv_FileStorage_Instance(r);
| 10341 | } |  | 10341 | }
| 10342 | static bool to(PyObject* src, Ptr<cv::FileStorage>& dst, const ArgInfo& info) |  | 10342 | static bool to(PyObject* src, Ptr<cv::FileStorage>& dst, const ArgInfo& info)
| 10343 | { |  | 10343 | {
| 10344 | if(!src || src == Py_None) |  | 10344 | if(!src || src == Py_None)
| 10345 | return true; |  | 10345 | return true;
| 10346 | Ptr<cv::FileStorage> * dst_; |  | 10346 | Ptr<cv::FileStorage> * dst_;
| 10347 | if (pyopencv_FileStorage_getp(src, dst_)) |  | 10347 | if (pyopencv_FileStorage_getp(src, dst_))
| 10348 | { |  | 10348 | {
| 10349 | dst = *dst_; |  | 10349 | dst = *dst_;
| 10350 | return true; |  | 10350 | return true;
| 10351 | } |  | 10351 | }
| 10352 |  |  | 10352 |
| 10353 | failmsg("Expected Ptr<cv::FileStorage> for argument '%s'", info.name); |  | 10353 | failmsg("Expected Ptr<cv::FileStorage> for argument '%s'", info.name);
| 10354 | return false; |  | 10354 | return false;
| 10355 | } |  | 10355 | }
| 10356 | }; |  | 10356 | };
| 10357 |  |  | 10357 |
| 10358 | //================================================================================ |  | 10358 | //================================================================================
| 10359 | // FlannBasedMatcher (Generic) |  | 10359 | // FlannBasedMatcher (Generic)
| 10360 | //================================================================================ |  | 10360 | //================================================================================
| 10361 |  |  | 10361 |
| 10362 | // GetSet (FlannBasedMatcher) |  | 10362 | // GetSet (FlannBasedMatcher)
| 10363 |  |  | 10363 |
| 10364 |  |  | 10364 |
| 10365 |  |  | 10365 |
| 10366 | // Methods (FlannBasedMatcher) |  | 10366 | // Methods (FlannBasedMatcher)
| 10367 |  |  | 10367 |
| 10368 | static int pyopencv_cv_FlannBasedMatcher_FlannBasedMatcher(pyopencv_FlannBasedMatcher_t* self, PyObject* py_args, PyObject* kw) |  | 10368 | static int pyopencv_cv_FlannBasedMatcher_FlannBasedMatcher(pyopencv_FlannBasedMatcher_t* self, PyObject* py_args, PyObject* kw)
| 10369 | { |  | 10369 | {
| 10370 | using namespace cv; |  | 10370 | using namespace cv;
| 10371 |  |  | 10371 |
| 10372 | PyObject* pyobj_indexParams = NULL; |  | 10372 | PyObject* pyobj_indexParams = NULL;
| 10373 | Ptr<flann::IndexParams> indexParams=makePtr<flann::KDTreeIndexParams>(); |  | 10373 | Ptr<flann::IndexParams> indexParams=makePtr<flann::KDTreeIndexParams>();
| 10374 | PyObject* pyobj_searchParams = NULL; |  | 10374 | PyObject* pyobj_searchParams = NULL;
| 10375 | Ptr<flann::SearchParams> searchParams=makePtr<flann::SearchParams>(); |  | 10375 | Ptr<flann::SearchParams> searchParams=makePtr<flann::SearchParams>();
| 10376 |  |  | 10376 |
| 10377 | const char* keywords[] = { "indexParams", "searchParams", NULL }; |  | 10377 | const char* keywords[] = { "indexParams", "searchParams", NULL };
| 10378 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:FlannBasedMatcher", (char**)keywords, &pyobj_indexParams, &pyobj_searchParams) && |  | 10378 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:FlannBasedMatcher", (char**)keywords, &pyobj_indexParams, &pyobj_searchParams) &&
| 10379 | pyopencv_to_safe(pyobj_indexParams, indexParams, ArgInfo("indexParams", 0)) && |  | 10379 | pyopencv_to_safe(pyobj_indexParams, indexParams, ArgInfo("indexParams", 0)) &&
| 10380 | pyopencv_to_safe(pyobj_searchParams, searchParams, ArgInfo("searchParams", 0)) ) |  | 10380 | pyopencv_to_safe(pyobj_searchParams, searchParams, ArgInfo("searchParams", 0)) )
| 10381 | { |  | 10381 | {
| 10382 | new (&(self->v)) Ptr<cv::FlannBasedMatcher>(); // init Ptr with placement new |  | 10382 | new (&(self->v)) Ptr<cv::FlannBasedMatcher>(); // init Ptr with placement new
| 10383 | if(self) ERRWRAP2(self->v.reset(new cv::FlannBasedMatcher(indexParams, searchParams))); |  | 10383 | if(self) ERRWRAP2(self->v.reset(new cv::FlannBasedMatcher(indexParams, searchParams)));
| 10384 | return 0; |  | 10384 | return 0;
| 10385 | } |  | 10385 | }
| 10386 |  |  | 10386 |
| 10387 | return -1; |  | 10387 | return -1;
| 10388 | } |  | 10388 | }
| 10389 |  |  | 10389 |
| 10390 | static PyObject* pyopencv_cv_FlannBasedMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10390 | static PyObject* pyopencv_cv_FlannBasedMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 10391 | { |  | 10391 | {
| 10392 | using namespace cv; |  | 10392 | using namespace cv;
| 10393 |  |  | 10393 |
| 10394 | Ptr<FlannBasedMatcher> retval; |  | 10394 | Ptr<FlannBasedMatcher> retval;
| 10395 |  |  | 10395 |
| 10396 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 10396 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 10397 | { |  | 10397 | {
| 10398 | ERRWRAP2(retval = cv::FlannBasedMatcher::create()); |  | 10398 | ERRWRAP2(retval = cv::FlannBasedMatcher::create());
| 10399 | return pyopencv_from(retval); |  | 10399 | return pyopencv_from(retval);
| 10400 | } |  | 10400 | }
| 10401 |  |  | 10401 |
| 10402 | return NULL; |  | 10402 | return NULL;
| 10403 | } |  | 10403 | }
| 10404 |  |  | 10404 |
| 10405 |  |  | 10405 |
| 10406 |  |  | 10406 |
| 10407 | // Tables (FlannBasedMatcher) |  | 10407 | // Tables (FlannBasedMatcher)
| 10408 |  |  | 10408 |
| 10409 | static PyGetSetDef pyopencv_FlannBasedMatcher_getseters[] = |  | 10409 | static PyGetSetDef pyopencv_FlannBasedMatcher_getseters[] =
| 10410 | { |  | 10410 | {
| 10411 | {NULL} /* Sentinel */ |  | 10411 | {NULL} /* Sentinel */
| 10412 | }; |  | 10412 | };
| 10413 |  |  | 10413 |
| 10414 | static PyMethodDef pyopencv_FlannBasedMatcher_methods[] = |  | 10414 | static PyMethodDef pyopencv_FlannBasedMatcher_methods[] =
| 10415 | { |  | 10415 | {
| 10416 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FlannBasedMatcher_create_static, METH_STATIC), "create() -> retval\n."}, |  | 10416 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_FlannBasedMatcher_create_static, METH_STATIC), "create() -> retval\n."},
| 10417 |  |  | 10417 |
| 10418 | {NULL, NULL} |  | 10418 | {NULL, NULL}
| 10419 | }; |  | 10419 | };
| 10420 |  |  | 10420 |
| 10421 | // Converter (FlannBasedMatcher) |  | 10421 | // Converter (FlannBasedMatcher)
| 10422 |  |  | 10422 |
| 10423 | template<> |  | 10423 | template<>
| 10424 | struct PyOpenCV_Converter< Ptr<cv::FlannBasedMatcher> > |  | 10424 | struct PyOpenCV_Converter< Ptr<cv::FlannBasedMatcher> >
| 10425 | { |  | 10425 | {
| 10426 | static PyObject* from(const Ptr<cv::FlannBasedMatcher>& r) |  | 10426 | static PyObject* from(const Ptr<cv::FlannBasedMatcher>& r)
| 10427 | { |  | 10427 | {
| 10428 | return pyopencv_FlannBasedMatcher_Instance(r); |  | 10428 | return pyopencv_FlannBasedMatcher_Instance(r);
| 10429 | } |  | 10429 | }
| 10430 | static bool to(PyObject* src, Ptr<cv::FlannBasedMatcher>& dst, const ArgInfo& info) |  | 10430 | static bool to(PyObject* src, Ptr<cv::FlannBasedMatcher>& dst, const ArgInfo& info)
| 10431 | { |  | 10431 | {
| 10432 | if(!src || src == Py_None) |  | 10432 | if(!src || src == Py_None)
| 10433 | return true; |  | 10433 | return true;
| 10434 | Ptr<cv::FlannBasedMatcher> * dst_; |  | 10434 | Ptr<cv::FlannBasedMatcher> * dst_;
| 10435 | if (pyopencv_FlannBasedMatcher_getp(src, dst_)) |  | 10435 | if (pyopencv_FlannBasedMatcher_getp(src, dst_))
| 10436 | { |  | 10436 | {
| 10437 | dst = *dst_; |  | 10437 | dst = *dst_;
| 10438 | return true; |  | 10438 | return true;
| 10439 | } |  | 10439 | }
| 10440 |  |  | 10440 |
| 10441 | failmsg("Expected Ptr<cv::FlannBasedMatcher> for argument '%s'", info.name); |  | 10441 | failmsg("Expected Ptr<cv::FlannBasedMatcher> for argument '%s'", info.name);
| 10442 | return false; |  | 10442 | return false;
| 10443 | } |  | 10443 | }
| 10444 | }; |  | 10444 | };
| 10445 |  |  | 10445 |
| 10446 | //================================================================================ |  | 10446 | //================================================================================
| 10447 | // GArrayDesc (Generic) |  | 10447 | // GArrayDesc (Generic)
| 10448 | //================================================================================ |  | 10448 | //================================================================================
| 10449 |  |  | 10449 |
| 10450 | // GetSet (GArrayDesc) |  | 10450 | // GetSet (GArrayDesc)
| 10451 |  |  | 10451 |
| 10452 |  |  | 10452 |
| 10453 |  |  | 10453 |
| 10454 | // Methods (GArrayDesc) |  | 10454 | // Methods (GArrayDesc)
| 10455 |  |  | 10455 |
| 10456 |  |  | 10456 |
| 10457 |  |  | 10457 |
| 10458 | // Tables (GArrayDesc) |  | 10458 | // Tables (GArrayDesc)
| 10459 |  |  | 10459 |
| 10460 | static PyGetSetDef pyopencv_GArrayDesc_getseters[] = |  | 10460 | static PyGetSetDef pyopencv_GArrayDesc_getseters[] =
| 10461 | { |  | 10461 | {
| 10462 | {NULL} /* Sentinel */ |  | 10462 | {NULL} /* Sentinel */
| 10463 | }; |  | 10463 | };
| 10464 |  |  | 10464 |
| 10465 | static PyMethodDef pyopencv_GArrayDesc_methods[] = |  | 10465 | static PyMethodDef pyopencv_GArrayDesc_methods[] =
| 10466 | { |  | 10466 | {
| 10467 |  |  | 10467 |
| 10468 | {NULL, NULL} |  | 10468 | {NULL, NULL}
| 10469 | }; |  | 10469 | };
| 10470 |  |  | 10470 |
| 10471 | // Converter (GArrayDesc) |  | 10471 | // Converter (GArrayDesc)
| 10472 |  |  | 10472 |
| 10473 | template<> |  | 10473 | template<>
| 10474 | struct PyOpenCV_Converter< cv::GArrayDesc > |  | 10474 | struct PyOpenCV_Converter< cv::GArrayDesc >
| 10475 | { |  | 10475 | {
| 10476 | static PyObject* from(const cv::GArrayDesc& r) |  | 10476 | static PyObject* from(const cv::GArrayDesc& r)
| 10477 | { |  | 10477 | {
| 10478 | return pyopencv_GArrayDesc_Instance(r); |  | 10478 | return pyopencv_GArrayDesc_Instance(r);
| 10479 | } |  | 10479 | }
| 10480 | static bool to(PyObject* src, cv::GArrayDesc& dst, const ArgInfo& info) |  | 10480 | static bool to(PyObject* src, cv::GArrayDesc& dst, const ArgInfo& info)
| 10481 | { |  | 10481 | {
| 10482 | if(!src || src == Py_None) |  | 10482 | if(!src || src == Py_None)
| 10483 | return true; |  | 10483 | return true;
| 10484 | cv::GArrayDesc * dst_; |  | 10484 | cv::GArrayDesc * dst_;
| 10485 | if (pyopencv_GArrayDesc_getp(src, dst_)) |  | 10485 | if (pyopencv_GArrayDesc_getp(src, dst_))
| 10486 | { |  | 10486 | {
| 10487 | dst = *dst_; |  | 10487 | dst = *dst_;
| 10488 | return true; |  | 10488 | return true;
| 10489 | } |  | 10489 | }
| 10490 |  |  | 10490 |
| 10491 | failmsg("Expected cv::GArrayDesc for argument '%s'", info.name); |  | 10491 | failmsg("Expected cv::GArrayDesc for argument '%s'", info.name);
| 10492 | return false; |  | 10492 | return false;
| 10493 | } |  | 10493 | }
| 10494 | }; |  | 10494 | };
| 10495 |  |  | 10495 |
| 10496 | //================================================================================ |  | 10496 | //================================================================================
| 10497 | // GArrayT (Generic) |  | 10497 | // GArrayT (Generic)
| 10498 | //================================================================================ |  | 10498 | //================================================================================
| 10499 |  |  | 10499 |
| 10500 | // GetSet (GArrayT) |  | 10500 | // GetSet (GArrayT)
| 10501 |  |  | 10501 |
| 10502 |  |  | 10502 |
| 10503 |  |  | 10503 |
| 10504 | // Methods (GArrayT) |  | 10504 | // Methods (GArrayT)
| 10505 |  |  | 10505 |
| 10506 | static int pyopencv_cv_GArrayT_GArrayT(pyopencv_GArrayT_t* self, PyObject* py_args, PyObject* kw) |  | 10506 | static int pyopencv_cv_GArrayT_GArrayT(pyopencv_GArrayT_t* self, PyObject* py_args, PyObject* kw)
| 10507 | { |  | 10507 | {
| 10508 | using namespace cv; |  | 10508 | using namespace cv;
| 10509 |  |  | 10509 |
| 10510 | PyObject* pyobj_type = NULL; |  | 10510 | PyObject* pyobj_type = NULL;
| 10511 | gapi_ArgType type=static_cast<gapi_ArgType>(0); |  | 10511 | gapi_ArgType type=static_cast<gapi_ArgType>(0);
| 10512 |  |  | 10512 |
| 10513 | const char* keywords[] = { "type", NULL }; |  | 10513 | const char* keywords[] = { "type", NULL };
| 10514 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GArrayT", (char**)keywords, &pyobj_type) && |  | 10514 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GArrayT", (char**)keywords, &pyobj_type) &&
| 10515 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 10515 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 10516 | { |  | 10516 | {
| 10517 | if(self) ERRWRAP2(new (&(self->v)) cv::GArrayT(type)); |  | 10517 | if(self) ERRWRAP2(new (&(self->v)) cv::GArrayT(type));
| 10518 | return 0; |  | 10518 | return 0;
| 10519 | } |  | 10519 | }
| 10520 |  |  | 10520 |
| 10521 | return -1; |  | 10521 | return -1;
| 10522 | } |  | 10522 | }
| 10523 |  |  | 10523 |
| 10524 | static PyObject* pyopencv_cv_GArrayT_type(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10524 | static PyObject* pyopencv_cv_GArrayT_type(PyObject* self, PyObject* py_args, PyObject* kw)
| 10525 | { |  | 10525 | {
| 10526 | using namespace cv; |  | 10526 | using namespace cv;
| 10527 |  |  | 10527 |
| 10528 |  |  | 10528 |
| 10529 | cv::GArrayT * self1 = 0; |  | 10529 | cv::GArrayT * self1 = 0;
| 10530 | if (!pyopencv_GArrayT_getp(self, self1)) |  | 10530 | if (!pyopencv_GArrayT_getp(self, self1))
| 10531 | return failmsgp("Incorrect type of self (must be 'GArrayT' or its derivative)"); |  | 10531 | return failmsgp("Incorrect type of self (must be 'GArrayT' or its derivative)");
| 10532 | cv::GArrayT* _self_ = (self1); |  | 10532 | cv::GArrayT* _self_ = (self1);
| 10533 | gapi::ArgType retval; |  | 10533 | gapi::ArgType retval;
| 10534 |  |  | 10534 |
| 10535 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 10535 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 10536 | { |  | 10536 | {
| 10537 | ERRWRAP2(retval = _self_->type()); |  | 10537 | ERRWRAP2(retval = _self_->type());
| 10538 | return pyopencv_from(retval); |  | 10538 | return pyopencv_from(retval);
| 10539 | } |  | 10539 | }
| 10540 |  |  | 10540 |
| 10541 | return NULL; |  | 10541 | return NULL;
| 10542 | } |  | 10542 | }
| 10543 |  |  | 10543 |
| 10544 |  |  | 10544 |
| 10545 |  |  | 10545 |
| 10546 | // Tables (GArrayT) |  | 10546 | // Tables (GArrayT)
| 10547 |  |  | 10547 |
| 10548 | static PyGetSetDef pyopencv_GArrayT_getseters[] = |  | 10548 | static PyGetSetDef pyopencv_GArrayT_getseters[] =
| 10549 | { |  | 10549 | {
| 10550 | {NULL} /* Sentinel */ |  | 10550 | {NULL} /* Sentinel */
| 10551 | }; |  | 10551 | };
| 10552 |  |  | 10552 |
| 10553 | static PyMethodDef pyopencv_GArrayT_methods[] = |  | 10553 | static PyMethodDef pyopencv_GArrayT_methods[] =
| 10554 | { |  | 10554 | {
| 10555 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_GArrayT_type, 0), "type() -> retval\n."}, |  | 10555 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_GArrayT_type, 0), "type() -> retval\n."},
| 10556 |  |  | 10556 |
| 10557 | {NULL, NULL} |  | 10557 | {NULL, NULL}
| 10558 | }; |  | 10558 | };
| 10559 |  |  | 10559 |
| 10560 | // Converter (GArrayT) |  | 10560 | // Converter (GArrayT)
| 10561 |  |  | 10561 |
| 10562 | template<> |  | 10562 | template<>
| 10563 | struct PyOpenCV_Converter< cv::GArrayT > |  | 10563 | struct PyOpenCV_Converter< cv::GArrayT >
| 10564 | { |  | 10564 | {
| 10565 | static PyObject* from(const cv::GArrayT& r) |  | 10565 | static PyObject* from(const cv::GArrayT& r)
| 10566 | { |  | 10566 | {
| 10567 | return pyopencv_GArrayT_Instance(r); |  | 10567 | return pyopencv_GArrayT_Instance(r);
| 10568 | } |  | 10568 | }
| 10569 | static bool to(PyObject* src, cv::GArrayT& dst, const ArgInfo& info) |  | 10569 | static bool to(PyObject* src, cv::GArrayT& dst, const ArgInfo& info)
| 10570 | { |  | 10570 | {
| 10571 | if(!src || src == Py_None) |  | 10571 | if(!src || src == Py_None)
| 10572 | return true; |  | 10572 | return true;
| 10573 | cv::GArrayT * dst_; |  | 10573 | cv::GArrayT * dst_;
| 10574 | if (pyopencv_GArrayT_getp(src, dst_)) |  | 10574 | if (pyopencv_GArrayT_getp(src, dst_))
| 10575 | { |  | 10575 | {
| 10576 | dst = *dst_; |  | 10576 | dst = *dst_;
| 10577 | return true; |  | 10577 | return true;
| 10578 | } |  | 10578 | }
| 10579 |  |  | 10579 |
| 10580 | failmsg("Expected cv::GArrayT for argument '%s'", info.name); |  | 10580 | failmsg("Expected cv::GArrayT for argument '%s'", info.name);
| 10581 | return false; |  | 10581 | return false;
| 10582 | } |  | 10582 | }
| 10583 | }; |  | 10583 | };
| 10584 |  |  | 10584 |
| 10585 | //================================================================================ |  | 10585 | //================================================================================
| 10586 | // GCompileArg (Generic) |  | 10586 | // GCompileArg (Generic)
| 10587 | //================================================================================ |  | 10587 | //================================================================================
| 10588 |  |  | 10588 |
| 10589 | // GetSet (GCompileArg) |  | 10589 | // GetSet (GCompileArg)
| 10590 |  |  | 10590 |
| 10591 |  |  | 10591 |
| 10592 |  |  | 10592 |
| 10593 | // Methods (GCompileArg) |  | 10593 | // Methods (GCompileArg)
| 10594 |  |  | 10594 |
| 10595 | static int pyopencv_cv_GCompileArg_GCompileArg(pyopencv_GCompileArg_t* self, PyObject* py_args, PyObject* kw) |  | 10595 | static int pyopencv_cv_GCompileArg_GCompileArg(pyopencv_GCompileArg_t* self, PyObject* py_args, PyObject* kw)
| 10596 | { |  | 10596 | {
| 10597 | using namespace cv; |  | 10597 | using namespace cv;
| 10598 |  |  | 10598 |
| 10599 | pyPrepareArgumentConversionErrorsStorage(4); |  | 10599 | pyPrepareArgumentConversionErrorsStorage(4);
| 10600 |  |  | 10600 |
| 10601 | { |  | 10601 | {
| 10602 | PyObject* pyobj_arg = NULL; |  | 10602 | PyObject* pyobj_arg = NULL;
| 10603 | cv::GKernelPackage arg; |  | 10603 | cv::GKernelPackage arg;
| 10604 |  |  | 10604 |
| 10605 | const char* keywords[] = { "arg", NULL }; |  | 10605 | const char* keywords[] = { "arg", NULL };
| 10606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) && |  | 10606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) &&
| 10607 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) ) |  | 10607 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) )
| 10608 | { |  | 10608 | {
| 10609 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg)); |  | 10609 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg));
| 10610 | return 0; |  | 10610 | return 0;
| 10611 | } |  | 10611 | }
| 10612 |  |  | 10612 |
| 10613 |  |  | 10613 |
| 10614 | pyPopulateArgumentConversionErrors(); |  | 10614 | pyPopulateArgumentConversionErrors();
| 10615 | } |  | 10615 | }
| 10616 |  |  | 10616 |
| 10617 |  |  | 10617 |
| 10618 | { |  | 10618 | {
| 10619 | PyObject* pyobj_arg = NULL; |  | 10619 | PyObject* pyobj_arg = NULL;
| 10620 | cv::gapi::GNetPackage arg; |  | 10620 | cv::gapi::GNetPackage arg;
| 10621 |  |  | 10621 |
| 10622 | const char* keywords[] = { "arg", NULL }; |  | 10622 | const char* keywords[] = { "arg", NULL };
| 10623 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) && |  | 10623 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) &&
| 10624 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) ) |  | 10624 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) )
| 10625 | { |  | 10625 | {
| 10626 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg)); |  | 10626 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg));
| 10627 | return 0; |  | 10627 | return 0;
| 10628 | } |  | 10628 | }
| 10629 |  |  | 10629 |
| 10630 |  |  | 10630 |
| 10631 | pyPopulateArgumentConversionErrors(); |  | 10631 | pyPopulateArgumentConversionErrors();
| 10632 | } |  | 10632 | }
| 10633 |  |  | 10633 |
| 10634 |  |  | 10634 |
| 10635 | { |  | 10635 | {
| 10636 | PyObject* pyobj_arg = NULL; |  | 10636 | PyObject* pyobj_arg = NULL;
| 10637 | cv::gapi::streaming::queue_capacity arg; |  | 10637 | cv::gapi::streaming::queue_capacity arg;
| 10638 |  |  | 10638 |
| 10639 | const char* keywords[] = { "arg", NULL }; |  | 10639 | const char* keywords[] = { "arg", NULL };
| 10640 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) && |  | 10640 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) &&
| 10641 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) ) |  | 10641 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) )
| 10642 | { |  | 10642 | {
| 10643 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg)); |  | 10643 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg));
| 10644 | return 0; |  | 10644 | return 0;
| 10645 | } |  | 10645 | }
| 10646 |  |  | 10646 |
| 10647 |  |  | 10647 |
| 10648 | pyPopulateArgumentConversionErrors(); |  | 10648 | pyPopulateArgumentConversionErrors();
| 10649 | } |  | 10649 | }
| 10650 |  |  | 10650 |
| 10651 |  |  | 10651 |
| 10652 | { |  | 10652 | {
| 10653 | PyObject* pyobj_arg = NULL; |  | 10653 | PyObject* pyobj_arg = NULL;
| 10654 | cv::gapi::ot::ObjectTrackerParams arg; |  | 10654 | cv::gapi::ot::ObjectTrackerParams arg;
| 10655 |  |  | 10655 |
| 10656 | const char* keywords[] = { "arg", NULL }; |  | 10656 | const char* keywords[] = { "arg", NULL };
| 10657 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) && |  | 10657 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GCompileArg", (char**)keywords, &pyobj_arg) &&
| 10658 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) ) |  | 10658 | pyopencv_to_safe(pyobj_arg, arg, ArgInfo("arg", 0)) )
| 10659 | { |  | 10659 | {
| 10660 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg)); |  | 10660 | if(self) ERRWRAP2(new (&(self->v)) cv::GCompileArg(arg));
| 10661 | return 0; |  | 10661 | return 0;
| 10662 | } |  | 10662 | }
| 10663 |  |  | 10663 |
| 10664 |  |  | 10664 |
| 10665 | pyPopulateArgumentConversionErrors(); |  | 10665 | pyPopulateArgumentConversionErrors();
| 10666 | } |  | 10666 | }
| 10667 | pyRaiseCVOverloadException("GCompileArg"); |  | 10667 | pyRaiseCVOverloadException("GCompileArg");
| 10668 |  |  | 10668 |
| 10669 | return -1; |  | 10669 | return -1;
| 10670 | } |  | 10670 | }
| 10671 |  |  | 10671 |
| 10672 |  |  | 10672 |
| 10673 |  |  | 10673 |
| 10674 | // Tables (GCompileArg) |  | 10674 | // Tables (GCompileArg)
| 10675 |  |  | 10675 |
| 10676 | static PyGetSetDef pyopencv_GCompileArg_getseters[] = |  | 10676 | static PyGetSetDef pyopencv_GCompileArg_getseters[] =
| 10677 | { |  | 10677 | {
| 10678 | {NULL} /* Sentinel */ |  | 10678 | {NULL} /* Sentinel */
| 10679 | }; |  | 10679 | };
| 10680 |  |  | 10680 |
| 10681 | static PyMethodDef pyopencv_GCompileArg_methods[] = |  | 10681 | static PyMethodDef pyopencv_GCompileArg_methods[] =
| 10682 | { |  | 10682 | {
| 10683 |  |  | 10683 |
| 10684 | {NULL, NULL} |  | 10684 | {NULL, NULL}
| 10685 | }; |  | 10685 | };
| 10686 |  |  | 10686 |
| 10687 | // Converter (GCompileArg) |  | 10687 | // Converter (GCompileArg)
| 10688 |  |  | 10688 |
| 10689 | template<> |  | 10689 | template<>
| 10690 | struct PyOpenCV_Converter< cv::GCompileArg > |  | 10690 | struct PyOpenCV_Converter< cv::GCompileArg >
| 10691 | { |  | 10691 | {
| 10692 | static PyObject* from(const cv::GCompileArg& r) |  | 10692 | static PyObject* from(const cv::GCompileArg& r)
| 10693 | { |  | 10693 | {
| 10694 | return pyopencv_GCompileArg_Instance(r); |  | 10694 | return pyopencv_GCompileArg_Instance(r);
| 10695 | } |  | 10695 | }
| 10696 | static bool to(PyObject* src, cv::GCompileArg& dst, const ArgInfo& info) |  | 10696 | static bool to(PyObject* src, cv::GCompileArg& dst, const ArgInfo& info)
| 10697 | { |  | 10697 | {
| 10698 | if(!src || src == Py_None) |  | 10698 | if(!src || src == Py_None)
| 10699 | return true; |  | 10699 | return true;
| 10700 | cv::GCompileArg * dst_; |  | 10700 | cv::GCompileArg * dst_;
| 10701 | if (pyopencv_GCompileArg_getp(src, dst_)) |  | 10701 | if (pyopencv_GCompileArg_getp(src, dst_))
| 10702 | { |  | 10702 | {
| 10703 | dst = *dst_; |  | 10703 | dst = *dst_;
| 10704 | return true; |  | 10704 | return true;
| 10705 | } |  | 10705 | }
| 10706 |  |  | 10706 |
| 10707 | failmsg("Expected cv::GCompileArg for argument '%s'", info.name); |  | 10707 | failmsg("Expected cv::GCompileArg for argument '%s'", info.name);
| 10708 | return false; |  | 10708 | return false;
| 10709 | } |  | 10709 | }
| 10710 | }; |  | 10710 | };
| 10711 |  |  | 10711 |
| 10712 | //================================================================================ |  | 10712 | //================================================================================
| 10713 | // GComputation (Generic) |  | 10713 | // GComputation (Generic)
| 10714 | //================================================================================ |  | 10714 | //================================================================================
| 10715 |  |  | 10715 |
| 10716 | // GetSet (GComputation) |  | 10716 | // GetSet (GComputation)
| 10717 |  |  | 10717 |
| 10718 |  |  | 10718 |
| 10719 |  |  | 10719 |
| 10720 | // Methods (GComputation) |  | 10720 | // Methods (GComputation)
| 10721 |  |  | 10721 |
| 10722 | static int pyopencv_cv_GComputation_GComputation(pyopencv_GComputation_t* self, PyObject* py_args, PyObject* kw) |  | 10722 | static int pyopencv_cv_GComputation_GComputation(pyopencv_GComputation_t* self, PyObject* py_args, PyObject* kw)
| 10723 | { |  | 10723 | {
| 10724 | using namespace cv; |  | 10724 | using namespace cv;
| 10725 |  |  | 10725 |
| 10726 | pyPrepareArgumentConversionErrorsStorage(4); |  | 10726 | pyPrepareArgumentConversionErrorsStorage(4);
| 10727 |  |  | 10727 |
| 10728 | { |  | 10728 | {
| 10729 | PyObject* pyobj_ins = NULL; |  | 10729 | PyObject* pyobj_ins = NULL;
| 10730 | GProtoInputArgs ins; |  | 10730 | GProtoInputArgs ins;
| 10731 | PyObject* pyobj_outs = NULL; |  | 10731 | PyObject* pyobj_outs = NULL;
| 10732 | GProtoOutputArgs outs; |  | 10732 | GProtoOutputArgs outs;
| 10733 |  |  | 10733 |
| 10734 | const char* keywords[] = { "ins", "outs", NULL }; |  | 10734 | const char* keywords[] = { "ins", "outs", NULL };
| 10735 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GComputation", (char**)keywords, &pyobj_ins, &pyobj_outs) && |  | 10735 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GComputation", (char**)keywords, &pyobj_ins, &pyobj_outs) &&
| 10736 | pyopencv_to_safe(pyobj_ins, ins, ArgInfo("ins", 0)) && |  | 10736 | pyopencv_to_safe(pyobj_ins, ins, ArgInfo("ins", 0)) &&
| 10737 | pyopencv_to_safe(pyobj_outs, outs, ArgInfo("outs", 0)) ) |  | 10737 | pyopencv_to_safe(pyobj_outs, outs, ArgInfo("outs", 0)) )
| 10738 | { |  | 10738 | {
| 10739 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new |  | 10739 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new
| 10740 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(std::move(ins), std::move(outs)))); |  | 10740 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(std::move(ins), std::move(outs))));
| 10741 | return 0; |  | 10741 | return 0;
| 10742 | } |  | 10742 | }
| 10743 |  |  | 10743 |
| 10744 |  |  | 10744 |
| 10745 | pyPopulateArgumentConversionErrors(); |  | 10745 | pyPopulateArgumentConversionErrors();
| 10746 | } |  | 10746 | }
| 10747 |  |  | 10747 |
| 10748 |  |  | 10748 |
| 10749 | { |  | 10749 | {
| 10750 | PyObject* pyobj_in = NULL; |  | 10750 | PyObject* pyobj_in = NULL;
| 10751 | cv::GMat in; |  | 10751 | cv::GMat in;
| 10752 | PyObject* pyobj_out = NULL; |  | 10752 | PyObject* pyobj_out = NULL;
| 10753 | cv::GMat out; |  | 10753 | cv::GMat out;
| 10754 |  |  | 10754 |
| 10755 | const char* keywords[] = { "in_", "out", NULL }; |  | 10755 | const char* keywords[] = { "in_", "out", NULL };
| 10756 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GComputation", (char**)keywords, &pyobj_in, &pyobj_out) && |  | 10756 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GComputation", (char**)keywords, &pyobj_in, &pyobj_out) &&
| 10757 | pyopencv_to_safe(pyobj_in, in, ArgInfo("in", 0)) && |  | 10757 | pyopencv_to_safe(pyobj_in, in, ArgInfo("in", 0)) &&
| 10758 | pyopencv_to_safe(pyobj_out, out, ArgInfo("out", 0)) ) |  | 10758 | pyopencv_to_safe(pyobj_out, out, ArgInfo("out", 0)) )
| 10759 | { |  | 10759 | {
| 10760 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new |  | 10760 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new
| 10761 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(in, out))); |  | 10761 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(in, out)));
| 10762 | return 0; |  | 10762 | return 0;
| 10763 | } |  | 10763 | }
| 10764 |  |  | 10764 |
| 10765 |  |  | 10765 |
| 10766 | pyPopulateArgumentConversionErrors(); |  | 10766 | pyPopulateArgumentConversionErrors();
| 10767 | } |  | 10767 | }
| 10768 |  |  | 10768 |
| 10769 |  |  | 10769 |
| 10770 | { |  | 10770 | {
| 10771 | PyObject* pyobj_in = NULL; |  | 10771 | PyObject* pyobj_in = NULL;
| 10772 | cv::GMat in; |  | 10772 | cv::GMat in;
| 10773 | PyObject* pyobj_out = NULL; |  | 10773 | PyObject* pyobj_out = NULL;
| 10774 | cv::GScalar out; |  | 10774 | cv::GScalar out;
| 10775 |  |  | 10775 |
| 10776 | const char* keywords[] = { "in_", "out", NULL }; |  | 10776 | const char* keywords[] = { "in_", "out", NULL };
| 10777 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GComputation", (char**)keywords, &pyobj_in, &pyobj_out) && |  | 10777 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GComputation", (char**)keywords, &pyobj_in, &pyobj_out) &&
| 10778 | pyopencv_to_safe(pyobj_in, in, ArgInfo("in", 0)) && |  | 10778 | pyopencv_to_safe(pyobj_in, in, ArgInfo("in", 0)) &&
| 10779 | pyopencv_to_safe(pyobj_out, out, ArgInfo("out", 0)) ) |  | 10779 | pyopencv_to_safe(pyobj_out, out, ArgInfo("out", 0)) )
| 10780 | { |  | 10780 | {
| 10781 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new |  | 10781 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new
| 10782 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(in, out))); |  | 10782 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(in, out)));
| 10783 | return 0; |  | 10783 | return 0;
| 10784 | } |  | 10784 | }
| 10785 |  |  | 10785 |
| 10786 |  |  | 10786 |
| 10787 | pyPopulateArgumentConversionErrors(); |  | 10787 | pyPopulateArgumentConversionErrors();
| 10788 | } |  | 10788 | }
| 10789 |  |  | 10789 |
| 10790 |  |  | 10790 |
| 10791 | { |  | 10791 | {
| 10792 | PyObject* pyobj_in1 = NULL; |  | 10792 | PyObject* pyobj_in1 = NULL;
| 10793 | cv::GMat in1; |  | 10793 | cv::GMat in1;
| 10794 | PyObject* pyobj_in2 = NULL; |  | 10794 | PyObject* pyobj_in2 = NULL;
| 10795 | cv::GMat in2; |  | 10795 | cv::GMat in2;
| 10796 | PyObject* pyobj_out = NULL; |  | 10796 | PyObject* pyobj_out = NULL;
| 10797 | cv::GMat out; |  | 10797 | cv::GMat out;
| 10798 |  |  | 10798 |
| 10799 | const char* keywords[] = { "in1", "in2", "out", NULL }; |  | 10799 | const char* keywords[] = { "in1", "in2", "out", NULL };
| 10800 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:GComputation", (char**)keywords, &pyobj_in1, &pyobj_in2, &pyobj_out) && |  | 10800 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:GComputation", (char**)keywords, &pyobj_in1, &pyobj_in2, &pyobj_out) &&
| 10801 | pyopencv_to_safe(pyobj_in1, in1, ArgInfo("in1", 0)) && |  | 10801 | pyopencv_to_safe(pyobj_in1, in1, ArgInfo("in1", 0)) &&
| 10802 | pyopencv_to_safe(pyobj_in2, in2, ArgInfo("in2", 0)) && |  | 10802 | pyopencv_to_safe(pyobj_in2, in2, ArgInfo("in2", 0)) &&
| 10803 | pyopencv_to_safe(pyobj_out, out, ArgInfo("out", 0)) ) |  | 10803 | pyopencv_to_safe(pyobj_out, out, ArgInfo("out", 0)) )
| 10804 | { |  | 10804 | {
| 10805 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new |  | 10805 | new (&(self->v)) Ptr<cv::GComputation>(); // init Ptr with placement new
| 10806 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(in1, in2, out))); |  | 10806 | if(self) ERRWRAP2(self->v.reset(new cv::GComputation(in1, in2, out)));
| 10807 | return 0; |  | 10807 | return 0;
| 10808 | } |  | 10808 | }
| 10809 |  |  | 10809 |
| 10810 |  |  | 10810 |
| 10811 | pyPopulateArgumentConversionErrors(); |  | 10811 | pyPopulateArgumentConversionErrors();
| 10812 | } |  | 10812 | }
| 10813 | pyRaiseCVOverloadException("GComputation"); |  | 10813 | pyRaiseCVOverloadException("GComputation");
| 10814 |  |  | 10814 |
| 10815 | return -1; |  | 10815 | return -1;
| 10816 | } |  | 10816 | }
| 10817 |  |  | 10817 |
| 10818 | static PyObject* pyopencv_cv_GComputation_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10818 | static PyObject* pyopencv_cv_GComputation_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 10819 | { |  | 10819 | {
| 10820 | using namespace cv; |  | 10820 | using namespace cv;
| 10821 |  |  | 10821 |
| 10822 |  |  | 10822 |
| 10823 | Ptr<cv::GComputation> * self1 = 0; |  | 10823 | Ptr<cv::GComputation> * self1 = 0;
| 10824 | if (!pyopencv_GComputation_getp(self, self1)) |  | 10824 | if (!pyopencv_GComputation_getp(self, self1))
| 10825 | return failmsgp("Incorrect type of self (must be 'GComputation' or its derivative)"); |  | 10825 | return failmsgp("Incorrect type of self (must be 'GComputation' or its derivative)");
| 10826 | Ptr<cv::GComputation> _self_ = *(self1); |  | 10826 | Ptr<cv::GComputation> _self_ = *(self1);
| 10827 | PyObject* pyobj_callback = NULL; |  | 10827 | PyObject* pyobj_callback = NULL;
| 10828 | detail_ExtractArgsCallback callback; |  | 10828 | detail_ExtractArgsCallback callback;
| 10829 | PyObject* pyobj_args = NULL; |  | 10829 | PyObject* pyobj_args = NULL;
| 10830 | GCompileArgs args={}; |  | 10830 | GCompileArgs args={};
| 10831 | GRunArgs retval; |  | 10831 | GRunArgs retval;
| 10832 |  |  | 10832 |
| 10833 | const char* keywords[] = { "callback", "args", NULL }; |  | 10833 | const char* keywords[] = { "callback", "args", NULL };
| 10834 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GComputation.apply", (char**)keywords, &pyobj_callback, &pyobj_args) && |  | 10834 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GComputation.apply", (char**)keywords, &pyobj_callback, &pyobj_args) &&
| 10835 | pyopencv_to_safe(pyobj_callback, callback, ArgInfo("callback", 0)) && |  | 10835 | pyopencv_to_safe(pyobj_callback, callback, ArgInfo("callback", 0)) &&
| 10836 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) ) |  | 10836 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) )
| 10837 | { |  | 10837 | {
| 10838 | ERRWRAP2(retval = _self_->apply(callback, std::move(args))); |  | 10838 | ERRWRAP2(retval = _self_->apply(callback, std::move(args)));
| 10839 | return pyopencv_from(retval); |  | 10839 | return pyopencv_from(retval);
| 10840 | } |  | 10840 | }
| 10841 |  |  | 10841 |
| 10842 | return NULL; |  | 10842 | return NULL;
| 10843 | } |  | 10843 | }
| 10844 |  |  | 10844 |
| 10845 | static PyObject* pyopencv_cv_GComputation_compileStreaming(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10845 | static PyObject* pyopencv_cv_GComputation_compileStreaming(PyObject* self, PyObject* py_args, PyObject* kw)
| 10846 | { |  | 10846 | {
| 10847 | using namespace cv; |  | 10847 | using namespace cv;
| 10848 |  |  | 10848 |
| 10849 |  |  | 10849 |
| 10850 | Ptr<cv::GComputation> * self1 = 0; |  | 10850 | Ptr<cv::GComputation> * self1 = 0;
| 10851 | if (!pyopencv_GComputation_getp(self, self1)) |  | 10851 | if (!pyopencv_GComputation_getp(self, self1))
| 10852 | return failmsgp("Incorrect type of self (must be 'GComputation' or its derivative)"); |  | 10852 | return failmsgp("Incorrect type of self (must be 'GComputation' or its derivative)");
| 10853 | Ptr<cv::GComputation> _self_ = *(self1); |  | 10853 | Ptr<cv::GComputation> _self_ = *(self1);
| 10854 | pyPrepareArgumentConversionErrorsStorage(3); |  | 10854 | pyPrepareArgumentConversionErrorsStorage(3);
| 10855 |  |  | 10855 |
| 10856 | { |  | 10856 | {
| 10857 | PyObject* pyobj_in_metas = NULL; |  | 10857 | PyObject* pyobj_in_metas = NULL;
| 10858 | GMetaArgs in_metas; |  | 10858 | GMetaArgs in_metas;
| 10859 | PyObject* pyobj_args = NULL; |  | 10859 | PyObject* pyobj_args = NULL;
| 10860 | GCompileArgs args={}; |  | 10860 | GCompileArgs args={};
| 10861 | GStreamingCompiled retval; |  | 10861 | GStreamingCompiled retval;
| 10862 |  |  | 10862 |
| 10863 | const char* keywords[] = { "in_metas", "args", NULL }; |  | 10863 | const char* keywords[] = { "in_metas", "args", NULL };
| 10864 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GComputation.compileStreaming", (char**)keywords, &pyobj_in_metas, &pyobj_args) && |  | 10864 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GComputation.compileStreaming", (char**)keywords, &pyobj_in_metas, &pyobj_args) &&
| 10865 | pyopencv_to_safe(pyobj_in_metas, in_metas, ArgInfo("in_metas", 0)) && |  | 10865 | pyopencv_to_safe(pyobj_in_metas, in_metas, ArgInfo("in_metas", 0)) &&
| 10866 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) ) |  | 10866 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) )
| 10867 | { |  | 10867 | {
| 10868 | ERRWRAP2(retval = _self_->compileStreaming(std::move(in_metas), std::move(args))); |  | 10868 | ERRWRAP2(retval = _self_->compileStreaming(std::move(in_metas), std::move(args)));
| 10869 | return pyopencv_from(retval); |  | 10869 | return pyopencv_from(retval);
| 10870 | } |  | 10870 | }
| 10871 |  |  | 10871 |
| 10872 |  |  | 10872 |
| 10873 | pyPopulateArgumentConversionErrors(); |  | 10873 | pyPopulateArgumentConversionErrors();
| 10874 | } |  | 10874 | }
| 10875 |  |  | 10875 |
| 10876 |  |  | 10876 |
| 10877 | { |  | 10877 | {
| 10878 | PyObject* pyobj_args = NULL; |  | 10878 | PyObject* pyobj_args = NULL;
| 10879 | GCompileArgs args={}; |  | 10879 | GCompileArgs args={};
| 10880 | GStreamingCompiled retval; |  | 10880 | GStreamingCompiled retval;
| 10881 |  |  | 10881 |
| 10882 | const char* keywords[] = { "args", NULL }; |  | 10882 | const char* keywords[] = { "args", NULL };
| 10883 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:GComputation.compileStreaming", (char**)keywords, &pyobj_args) && |  | 10883 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:GComputation.compileStreaming", (char**)keywords, &pyobj_args) &&
| 10884 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) ) |  | 10884 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) )
| 10885 | { |  | 10885 | {
| 10886 | ERRWRAP2(retval = _self_->compileStreaming(std::move(args))); |  | 10886 | ERRWRAP2(retval = _self_->compileStreaming(std::move(args)));
| 10887 | return pyopencv_from(retval); |  | 10887 | return pyopencv_from(retval);
| 10888 | } |  | 10888 | }
| 10889 |  |  | 10889 |
| 10890 |  |  | 10890 |
| 10891 | pyPopulateArgumentConversionErrors(); |  | 10891 | pyPopulateArgumentConversionErrors();
| 10892 | } |  | 10892 | }
| 10893 |  |  | 10893 |
| 10894 |  |  | 10894 |
| 10895 | { |  | 10895 | {
| 10896 | PyObject* pyobj_callback = NULL; |  | 10896 | PyObject* pyobj_callback = NULL;
| 10897 | detail_ExtractMetaCallback callback; |  | 10897 | detail_ExtractMetaCallback callback;
| 10898 | PyObject* pyobj_args = NULL; |  | 10898 | PyObject* pyobj_args = NULL;
| 10899 | GCompileArgs args={}; |  | 10899 | GCompileArgs args={};
| 10900 | GStreamingCompiled retval; |  | 10900 | GStreamingCompiled retval;
| 10901 |  |  | 10901 |
| 10902 | const char* keywords[] = { "callback", "args", NULL }; |  | 10902 | const char* keywords[] = { "callback", "args", NULL };
| 10903 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GComputation.compileStreaming", (char**)keywords, &pyobj_callback, &pyobj_args) && |  | 10903 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GComputation.compileStreaming", (char**)keywords, &pyobj_callback, &pyobj_args) &&
| 10904 | pyopencv_to_safe(pyobj_callback, callback, ArgInfo("callback", 0)) && |  | 10904 | pyopencv_to_safe(pyobj_callback, callback, ArgInfo("callback", 0)) &&
| 10905 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) ) |  | 10905 | pyopencv_to_safe(pyobj_args, args, ArgInfo("args", 0)) )
| 10906 | { |  | 10906 | {
| 10907 | ERRWRAP2(retval = _self_->compileStreaming(callback, std::move(args))); |  | 10907 | ERRWRAP2(retval = _self_->compileStreaming(callback, std::move(args)));
| 10908 | return pyopencv_from(retval); |  | 10908 | return pyopencv_from(retval);
| 10909 | } |  | 10909 | }
| 10910 |  |  | 10910 |
| 10911 |  |  | 10911 |
| 10912 | pyPopulateArgumentConversionErrors(); |  | 10912 | pyPopulateArgumentConversionErrors();
| 10913 | } |  | 10913 | }
| 10914 | pyRaiseCVOverloadException("compileStreaming"); |  | 10914 | pyRaiseCVOverloadException("compileStreaming");
| 10915 |  |  | 10915 |
| 10916 | return NULL; |  | 10916 | return NULL;
| 10917 | } |  | 10917 | }
| 10918 |  |  | 10918 |
| 10919 |  |  | 10919 |
| 10920 |  |  | 10920 |
| 10921 | // Tables (GComputation) |  | 10921 | // Tables (GComputation)
| 10922 |  |  | 10922 |
| 10923 | static PyGetSetDef pyopencv_GComputation_getseters[] = |  | 10923 | static PyGetSetDef pyopencv_GComputation_getseters[] =
| 10924 | { |  | 10924 | {
| 10925 | {NULL} /* Sentinel */ |  | 10925 | {NULL} /* Sentinel */
| 10926 | }; |  | 10926 | };
| 10927 |  |  | 10927 |
| 10928 | static PyMethodDef pyopencv_GComputation_methods[] = |  | 10928 | static PyMethodDef pyopencv_GComputation_methods[] =
| 10929 | { |  | 10929 | {
| 10930 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_GComputation_apply, 0), "apply(callback[, args]) -> retval\n. * @brief Compile graph on-the-fly and immediately execute it on\n. * the inputs data vectors.\n. *\n. * Number of input/output data objects must match GComputation's\n. * protocol, also types of host data objects (cv::Mat, cv::Scalar)\n. * must match the shapes of data objects from protocol (cv::GMat,\n. * cv::GScalar). If there's a mismatch, a run-time exception will\n. * be generated.\n. *\n. * Internally, a cv::GCompiled object is created for the given\n. * input format configuration, which then is executed on the input\n. * data immediately. cv::GComputation caches compiled objects\n. * produced within apply() -- if this method would be called next\n. * time with the same input parameters (image formats, image\n. * resolution, etc), the underlying compiled graph will be reused\n. * without recompilation. If new metadata doesn't match the cached\n. * one, the underlying compiled graph is regenerated.\n. *\n. * @note compile() always triggers a compilation process and\n. * produces a new GCompiled object regardless if a similar one has\n. * been cached via apply() or not.\n. *\n. * @param ins vector of input data to process. Don't create\n. * GRunArgs object manually, use cv::gin() wrapper instead.\n. * @param outs vector of output data to fill results in. cv::Mat\n. * objects may be empty in this vector, G-API will automatically\n. * initialize it with the required format & dimensions. Don't\n. * create GRunArgsP object manually, use cv::gout() wrapper instead.\n. * @param args a list of compilation arguments to pass to the\n. * underlying compilation process. Don't create GCompileArgs\n. * object manually, use cv::compile_args() wrapper instead.\n. *\n. * @sa @ref gapi_data_objects, @ref gapi_compile_args"}, |  | 10930 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_GComputation_apply, 0), "apply(callback[, args]) -> retval\n. * @brief Compile graph on-the-fly and immediately execute it on\n. * the inputs data vectors.\n. *\n. * Number of input/output data objects must match GComputation's\n. * protocol, also types of host data objects (cv::Mat, cv::Scalar)\n. * must match the shapes of data objects from protocol (cv::GMat,\n. * cv::GScalar). If there's a mismatch, a run-time exception will\n. * be generated.\n. *\n. * Internally, a cv::GCompiled object is created for the given\n. * input format configuration, which then is executed on the input\n. * data immediately. cv::GComputation caches compiled objects\n. * produced within apply() -- if this method would be called next\n. * time with the same input parameters (image formats, image\n. * resolution, etc), the underlying compiled graph will be reused\n. * without recompilation. If new metadata doesn't match the cached\n. * one, the underlying compiled graph is regenerated.\n. *\n. * @note compile() always triggers a compilation process and\n. * produces a new GCompiled object regardless if a similar one has\n. * been cached via apply() or not.\n. *\n. * @param ins vector of input data to process. Don't create\n. * GRunArgs object manually, use cv::gin() wrapper instead.\n. * @param outs vector of output data to fill results in. cv::Mat\n. * objects may be empty in this vector, G-API will automatically\n. * initialize it with the required format & dimensions. Don't\n. * create GRunArgsP object manually, use cv::gout() wrapper instead.\n. * @param args a list of compilation arguments to pass to the\n. * underlying compilation process. Don't create GCompileArgs\n. * object manually, use cv::compile_args() wrapper instead.\n. *\n. * @sa @ref gapi_data_objects, @ref gapi_compile_args"},
| 10931 | {"compileStreaming", CV_PY_FN_WITH_KW_(pyopencv_cv_GComputation_compileStreaming, 0), "compileStreaming(in_metas[, args]) -> retval\n. * @brief Compile the computation for streaming mode.\n. *\n. * This method triggers compilation process and produces a new\n. * GStreamingCompiled object which then can process video stream\n. * data of the given format. Passing a stream in a different\n. * format to the compiled computation will generate a run-time\n. * exception.\n. *\n. * @param in_metas vector of input metadata configuration. Grab\n. * metadata from real data objects (like cv::Mat or cv::Scalar)\n. * using cv::descr_of(), or create it on your own.\n. *\n. * @param args compilation arguments for this compilation\n. * process. Compilation arguments directly affect what kind of\n. * executable object would be produced, e.g. which kernels (and\n. * thus, devices) would be used to execute computation.\n. *\n. * @return GStreamingCompiled, a streaming-oriented executable\n. * computation compiled specifically for the given input\n. * parameters.\n. *\n. * @sa @ref gapi_compile_args\n\n\n\ncompileStreaming([, args]) -> retval\n. * @brief Compile the computation for streaming mode.\n. *\n. * This method triggers compilation process and produces a new\n. * GStreamingCompiled object which then can process video stream\n. * data in any format. Underlying mechanisms will be adjusted to\n. * every new input video stream automatically, but please note that\n. * _not all_ existing backends support this (see reshape()).\n. *\n. * @param args compilation arguments for this compilation\n. * process. Compilation arguments directly affect what kind of\n. * executable object would be produced, e.g. which kernels (and\n. * thus, devices) would be used to execute computation.\n. *\n. * @return GStreamingCompiled, a streaming-oriented executable\n. * computation compiled for any input image format.\n. *\n. * @sa @ref gapi_compile_args\n\n\n\ncompileStreaming(callback[, args]) -> retval\n."}, |  | 10931 | {"compileStreaming", CV_PY_FN_WITH_KW_(pyopencv_cv_GComputation_compileStreaming, 0), "compileStreaming(in_metas[, args]) -> retval\n. * @brief Compile the computation for streaming mode.\n. *\n. * This method triggers compilation process and produces a new\n. * GStreamingCompiled object which then can process video stream\n. * data of the given format. Passing a stream in a different\n. * format to the compiled computation will generate a run-time\n. * exception.\n. *\n. * @param in_metas vector of input metadata configuration. Grab\n. * metadata from real data objects (like cv::Mat or cv::Scalar)\n. * using cv::descr_of(), or create it on your own.\n. *\n. * @param args compilation arguments for this compilation\n. * process. Compilation arguments directly affect what kind of\n. * executable object would be produced, e.g. which kernels (and\n. * thus, devices) would be used to execute computation.\n. *\n. * @return GStreamingCompiled, a streaming-oriented executable\n. * computation compiled specifically for the given input\n. * parameters.\n. *\n. * @sa @ref gapi_compile_args\n\n\n\ncompileStreaming([, args]) -> retval\n. * @brief Compile the computation for streaming mode.\n. *\n. * This method triggers compilation process and produces a new\n. * GStreamingCompiled object which then can process video stream\n. * data in any format. Underlying mechanisms will be adjusted to\n. * every new input video stream automatically, but please note that\n. * _not all_ existing backends support this (see reshape()).\n. *\n. * @param args compilation arguments for this compilation\n. * process. Compilation arguments directly affect what kind of\n. * executable object would be produced, e.g. which kernels (and\n. * thus, devices) would be used to execute computation.\n. *\n. * @return GStreamingCompiled, a streaming-oriented executable\n. * computation compiled for any input image format.\n. *\n. * @sa @ref gapi_compile_args\n\n\n\ncompileStreaming(callback[, args]) -> retval\n."},
| 10932 |  |  | 10932 |
| 10933 | {NULL, NULL} |  | 10933 | {NULL, NULL}
| 10934 | }; |  | 10934 | };
| 10935 |  |  | 10935 |
| 10936 | // Converter (GComputation) |  | 10936 | // Converter (GComputation)
| 10937 |  |  | 10937 |
| 10938 | template<> |  | 10938 | template<>
| 10939 | struct PyOpenCV_Converter< Ptr<cv::GComputation> > |  | 10939 | struct PyOpenCV_Converter< Ptr<cv::GComputation> >
| 10940 | { |  | 10940 | {
| 10941 | static PyObject* from(const Ptr<cv::GComputation>& r) |  | 10941 | static PyObject* from(const Ptr<cv::GComputation>& r)
| 10942 | { |  | 10942 | {
| 10943 | return pyopencv_GComputation_Instance(r); |  | 10943 | return pyopencv_GComputation_Instance(r);
| 10944 | } |  | 10944 | }
| 10945 | static bool to(PyObject* src, Ptr<cv::GComputation>& dst, const ArgInfo& info) |  | 10945 | static bool to(PyObject* src, Ptr<cv::GComputation>& dst, const ArgInfo& info)
| 10946 | { |  | 10946 | {
| 10947 | if(!src || src == Py_None) |  | 10947 | if(!src || src == Py_None)
| 10948 | return true; |  | 10948 | return true;
| 10949 | Ptr<cv::GComputation> * dst_; |  | 10949 | Ptr<cv::GComputation> * dst_;
| 10950 | if (pyopencv_GComputation_getp(src, dst_)) |  | 10950 | if (pyopencv_GComputation_getp(src, dst_))
| 10951 | { |  | 10951 | {
| 10952 | dst = *dst_; |  | 10952 | dst = *dst_;
| 10953 | return true; |  | 10953 | return true;
| 10954 | } |  | 10954 | }
| 10955 |  |  | 10955 |
| 10956 | failmsg("Expected Ptr<cv::GComputation> for argument '%s'", info.name); |  | 10956 | failmsg("Expected Ptr<cv::GComputation> for argument '%s'", info.name);
| 10957 | return false; |  | 10957 | return false;
| 10958 | } |  | 10958 | }
| 10959 | }; |  | 10959 | };
| 10960 |  |  | 10960 |
| 10961 | //================================================================================ |  | 10961 | //================================================================================
| 10962 | // GFTTDetector (Generic) |  | 10962 | // GFTTDetector (Generic)
| 10963 | //================================================================================ |  | 10963 | //================================================================================
| 10964 |  |  | 10964 |
| 10965 | // GetSet (GFTTDetector) |  | 10965 | // GetSet (GFTTDetector)
| 10966 |  |  | 10966 |
| 10967 |  |  | 10967 |
| 10968 |  |  | 10968 |
| 10969 | // Methods (GFTTDetector) |  | 10969 | // Methods (GFTTDetector)
| 10970 |  |  | 10970 |
| 10971 | static PyObject* pyopencv_cv_GFTTDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 10971 | static PyObject* pyopencv_cv_GFTTDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 10972 | { |  | 10972 | {
| 10973 | using namespace cv; |  | 10973 | using namespace cv;
| 10974 |  |  | 10974 |
| 10975 | pyPrepareArgumentConversionErrorsStorage(2); |  | 10975 | pyPrepareArgumentConversionErrorsStorage(2);
| 10976 |  |  | 10976 |
| 10977 | { |  | 10977 | {
| 10978 | PyObject* pyobj_maxCorners = NULL; |  | 10978 | PyObject* pyobj_maxCorners = NULL;
| 10979 | int maxCorners=1000; |  | 10979 | int maxCorners=1000;
| 10980 | PyObject* pyobj_qualityLevel = NULL; |  | 10980 | PyObject* pyobj_qualityLevel = NULL;
| 10981 | double qualityLevel=0.01; |  | 10981 | double qualityLevel=0.01;
| 10982 | PyObject* pyobj_minDistance = NULL; |  | 10982 | PyObject* pyobj_minDistance = NULL;
| 10983 | double minDistance=1; |  | 10983 | double minDistance=1;
| 10984 | PyObject* pyobj_blockSize = NULL; |  | 10984 | PyObject* pyobj_blockSize = NULL;
| 10985 | int blockSize=3; |  | 10985 | int blockSize=3;
| 10986 | PyObject* pyobj_useHarrisDetector = NULL; |  | 10986 | PyObject* pyobj_useHarrisDetector = NULL;
| 10987 | bool useHarrisDetector=false; |  | 10987 | bool useHarrisDetector=false;
| 10988 | PyObject* pyobj_k = NULL; |  | 10988 | PyObject* pyobj_k = NULL;
| 10989 | double k=0.04; |  | 10989 | double k=0.04;
| 10990 | Ptr<GFTTDetector> retval; |  | 10990 | Ptr<GFTTDetector> retval;
| 10991 |  |  | 10991 |
| 10992 | const char* keywords[] = { "maxCorners", "qualityLevel", "minDistance", "blockSize", "useHarrisDetector", "k", NULL }; |  | 10992 | const char* keywords[] = { "maxCorners", "qualityLevel", "minDistance", "blockSize", "useHarrisDetector", "k", NULL };
| 10993 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOO:GFTTDetector.create", (char**)keywords, &pyobj_maxCorners, &pyobj_qualityLevel, &pyobj_minDistance, &pyobj_blockSize, &pyobj_useHarrisDetector, &pyobj_k) && |  | 10993 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOO:GFTTDetector.create", (char**)keywords, &pyobj_maxCorners, &pyobj_qualityLevel, &pyobj_minDistance, &pyobj_blockSize, &pyobj_useHarrisDetector, &pyobj_k) &&
| 10994 | pyopencv_to_safe(pyobj_maxCorners, maxCorners, ArgInfo("maxCorners", 0)) && |  | 10994 | pyopencv_to_safe(pyobj_maxCorners, maxCorners, ArgInfo("maxCorners", 0)) &&
| 10995 | pyopencv_to_safe(pyobj_qualityLevel, qualityLevel, ArgInfo("qualityLevel", 0)) && |  | 10995 | pyopencv_to_safe(pyobj_qualityLevel, qualityLevel, ArgInfo("qualityLevel", 0)) &&
| 10996 | pyopencv_to_safe(pyobj_minDistance, minDistance, ArgInfo("minDistance", 0)) && |  | 10996 | pyopencv_to_safe(pyobj_minDistance, minDistance, ArgInfo("minDistance", 0)) &&
| 10997 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) && |  | 10997 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) &&
| 10998 | pyopencv_to_safe(pyobj_useHarrisDetector, useHarrisDetector, ArgInfo("useHarrisDetector", 0)) && |  | 10998 | pyopencv_to_safe(pyobj_useHarrisDetector, useHarrisDetector, ArgInfo("useHarrisDetector", 0)) &&
| 10999 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) ) |  | 10999 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) )
| 11000 | { |  | 11000 | {
| 11001 | ERRWRAP2(retval = cv::GFTTDetector::create(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k)); |  | 11001 | ERRWRAP2(retval = cv::GFTTDetector::create(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k));
| 11002 | return pyopencv_from(retval); |  | 11002 | return pyopencv_from(retval);
| 11003 | } |  | 11003 | }
| 11004 |  |  | 11004 |
| 11005 |  |  | 11005 |
| 11006 | pyPopulateArgumentConversionErrors(); |  | 11006 | pyPopulateArgumentConversionErrors();
| 11007 | } |  | 11007 | }
| 11008 |  |  | 11008 |
| 11009 |  |  | 11009 |
| 11010 | { |  | 11010 | {
| 11011 | PyObject* pyobj_maxCorners = NULL; |  | 11011 | PyObject* pyobj_maxCorners = NULL;
| 11012 | int maxCorners=0; |  | 11012 | int maxCorners=0;
| 11013 | PyObject* pyobj_qualityLevel = NULL; |  | 11013 | PyObject* pyobj_qualityLevel = NULL;
| 11014 | double qualityLevel=0; |  | 11014 | double qualityLevel=0;
| 11015 | PyObject* pyobj_minDistance = NULL; |  | 11015 | PyObject* pyobj_minDistance = NULL;
| 11016 | double minDistance=0; |  | 11016 | double minDistance=0;
| 11017 | PyObject* pyobj_blockSize = NULL; |  | 11017 | PyObject* pyobj_blockSize = NULL;
| 11018 | int blockSize=0; |  | 11018 | int blockSize=0;
| 11019 | PyObject* pyobj_gradiantSize = NULL; |  | 11019 | PyObject* pyobj_gradiantSize = NULL;
| 11020 | int gradiantSize=0; |  | 11020 | int gradiantSize=0;
| 11021 | PyObject* pyobj_useHarrisDetector = NULL; |  | 11021 | PyObject* pyobj_useHarrisDetector = NULL;
| 11022 | bool useHarrisDetector=false; |  | 11022 | bool useHarrisDetector=false;
| 11023 | PyObject* pyobj_k = NULL; |  | 11023 | PyObject* pyobj_k = NULL;
| 11024 | double k=0.04; |  | 11024 | double k=0.04;
| 11025 | Ptr<GFTTDetector> retval; |  | 11025 | Ptr<GFTTDetector> retval;
| 11026 |  |  | 11026 |
| 11027 | const char* keywords[] = { "maxCorners", "qualityLevel", "minDistance", "blockSize", "gradiantSize", "useHarrisDetector", "k", NULL }; |  | 11027 | const char* keywords[] = { "maxCorners", "qualityLevel", "minDistance", "blockSize", "gradiantSize", "useHarrisDetector", "k", NULL };
| 11028 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OO:GFTTDetector.create", (char**)keywords, &pyobj_maxCorners, &pyobj_qualityLevel, &pyobj_minDistance, &pyobj_blockSize, &pyobj_gradiantSize, &pyobj_useHarrisDetector, &pyobj_k) && |  | 11028 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OO:GFTTDetector.create", (char**)keywords, &pyobj_maxCorners, &pyobj_qualityLevel, &pyobj_minDistance, &pyobj_blockSize, &pyobj_gradiantSize, &pyobj_useHarrisDetector, &pyobj_k) &&
| 11029 | pyopencv_to_safe(pyobj_maxCorners, maxCorners, ArgInfo("maxCorners", 0)) && |  | 11029 | pyopencv_to_safe(pyobj_maxCorners, maxCorners, ArgInfo("maxCorners", 0)) &&
| 11030 | pyopencv_to_safe(pyobj_qualityLevel, qualityLevel, ArgInfo("qualityLevel", 0)) && |  | 11030 | pyopencv_to_safe(pyobj_qualityLevel, qualityLevel, ArgInfo("qualityLevel", 0)) &&
| 11031 | pyopencv_to_safe(pyobj_minDistance, minDistance, ArgInfo("minDistance", 0)) && |  | 11031 | pyopencv_to_safe(pyobj_minDistance, minDistance, ArgInfo("minDistance", 0)) &&
| 11032 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) && |  | 11032 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) &&
| 11033 | pyopencv_to_safe(pyobj_gradiantSize, gradiantSize, ArgInfo("gradiantSize", 0)) && |  | 11033 | pyopencv_to_safe(pyobj_gradiantSize, gradiantSize, ArgInfo("gradiantSize", 0)) &&
| 11034 | pyopencv_to_safe(pyobj_useHarrisDetector, useHarrisDetector, ArgInfo("useHarrisDetector", 0)) && |  | 11034 | pyopencv_to_safe(pyobj_useHarrisDetector, useHarrisDetector, ArgInfo("useHarrisDetector", 0)) &&
| 11035 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) ) |  | 11035 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) )
| 11036 | { |  | 11036 | {
| 11037 | ERRWRAP2(retval = cv::GFTTDetector::create(maxCorners, qualityLevel, minDistance, blockSize, gradiantSize, useHarrisDetector, k)); |  | 11037 | ERRWRAP2(retval = cv::GFTTDetector::create(maxCorners, qualityLevel, minDistance, blockSize, gradiantSize, useHarrisDetector, k));
| 11038 | return pyopencv_from(retval); |  | 11038 | return pyopencv_from(retval);
| 11039 | } |  | 11039 | }
| 11040 |  |  | 11040 |
| 11041 |  |  | 11041 |
| 11042 | pyPopulateArgumentConversionErrors(); |  | 11042 | pyPopulateArgumentConversionErrors();
| 11043 | } |  | 11043 | }
| 11044 | pyRaiseCVOverloadException("create"); |  | 11044 | pyRaiseCVOverloadException("create");
| 11045 |  |  | 11045 |
| 11046 | return NULL; |  | 11046 | return NULL;
| 11047 | } |  | 11047 | }
| 11048 |  |  | 11048 |
| 11049 | static PyObject* pyopencv_cv_GFTTDetector_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11049 | static PyObject* pyopencv_cv_GFTTDetector_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 11050 | { |  | 11050 | {
| 11051 | using namespace cv; |  | 11051 | using namespace cv;
| 11052 |  |  | 11052 |
| 11053 |  |  | 11053 |
| 11054 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11054 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11055 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11055 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11056 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11056 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11057 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11057 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11058 | int retval; |  | 11058 | int retval;
| 11059 |  |  | 11059 |
| 11060 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11060 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11061 | { |  | 11061 | {
| 11062 | ERRWRAP2(retval = _self_->getBlockSize()); |  | 11062 | ERRWRAP2(retval = _self_->getBlockSize());
| 11063 | return pyopencv_from(retval); |  | 11063 | return pyopencv_from(retval);
| 11064 | } |  | 11064 | }
| 11065 |  |  | 11065 |
| 11066 | return NULL; |  | 11066 | return NULL;
| 11067 | } |  | 11067 | }
| 11068 |  |  | 11068 |
| 11069 | static PyObject* pyopencv_cv_GFTTDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11069 | static PyObject* pyopencv_cv_GFTTDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 11070 | { |  | 11070 | {
| 11071 | using namespace cv; |  | 11071 | using namespace cv;
| 11072 |  |  | 11072 |
| 11073 |  |  | 11073 |
| 11074 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11074 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11075 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11075 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11076 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11076 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11077 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11077 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11078 | String retval; |  | 11078 | String retval;
| 11079 |  |  | 11079 |
| 11080 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11080 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11081 | { |  | 11081 | {
| 11082 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 11082 | ERRWRAP2(retval = _self_->getDefaultName());
| 11083 | return pyopencv_from(retval); |  | 11083 | return pyopencv_from(retval);
| 11084 | } |  | 11084 | }
| 11085 |  |  | 11085 |
| 11086 | return NULL; |  | 11086 | return NULL;
| 11087 | } |  | 11087 | }
| 11088 |  |  | 11088 |
| 11089 | static PyObject* pyopencv_cv_GFTTDetector_getGradientSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11089 | static PyObject* pyopencv_cv_GFTTDetector_getGradientSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 11090 | { |  | 11090 | {
| 11091 | using namespace cv; |  | 11091 | using namespace cv;
| 11092 |  |  | 11092 |
| 11093 |  |  | 11093 |
| 11094 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11094 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11095 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11095 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11096 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11096 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11097 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11097 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11098 | int retval; |  | 11098 | int retval;
| 11099 |  |  | 11099 |
| 11100 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11100 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11101 | { |  | 11101 | {
| 11102 | ERRWRAP2(retval = _self_->getGradientSize()); |  | 11102 | ERRWRAP2(retval = _self_->getGradientSize());
| 11103 | return pyopencv_from(retval); |  | 11103 | return pyopencv_from(retval);
| 11104 | } |  | 11104 | }
| 11105 |  |  | 11105 |
| 11106 | return NULL; |  | 11106 | return NULL;
| 11107 | } |  | 11107 | }
| 11108 |  |  | 11108 |
| 11109 | static PyObject* pyopencv_cv_GFTTDetector_getHarrisDetector(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11109 | static PyObject* pyopencv_cv_GFTTDetector_getHarrisDetector(PyObject* self, PyObject* py_args, PyObject* kw)
| 11110 | { |  | 11110 | {
| 11111 | using namespace cv; |  | 11111 | using namespace cv;
| 11112 |  |  | 11112 |
| 11113 |  |  | 11113 |
| 11114 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11114 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11115 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11115 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11116 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11116 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11117 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11117 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11118 | bool retval; |  | 11118 | bool retval;
| 11119 |  |  | 11119 |
| 11120 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11120 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11121 | { |  | 11121 | {
| 11122 | ERRWRAP2(retval = _self_->getHarrisDetector()); |  | 11122 | ERRWRAP2(retval = _self_->getHarrisDetector());
| 11123 | return pyopencv_from(retval); |  | 11123 | return pyopencv_from(retval);
| 11124 | } |  | 11124 | }
| 11125 |  |  | 11125 |
| 11126 | return NULL; |  | 11126 | return NULL;
| 11127 | } |  | 11127 | }
| 11128 |  |  | 11128 |
| 11129 | static PyObject* pyopencv_cv_GFTTDetector_getK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11129 | static PyObject* pyopencv_cv_GFTTDetector_getK(PyObject* self, PyObject* py_args, PyObject* kw)
| 11130 | { |  | 11130 | {
| 11131 | using namespace cv; |  | 11131 | using namespace cv;
| 11132 |  |  | 11132 |
| 11133 |  |  | 11133 |
| 11134 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11134 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11135 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11135 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11136 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11136 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11137 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11137 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11138 | double retval; |  | 11138 | double retval;
| 11139 |  |  | 11139 |
| 11140 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11140 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11141 | { |  | 11141 | {
| 11142 | ERRWRAP2(retval = _self_->getK()); |  | 11142 | ERRWRAP2(retval = _self_->getK());
| 11143 | return pyopencv_from(retval); |  | 11143 | return pyopencv_from(retval);
| 11144 | } |  | 11144 | }
| 11145 |  |  | 11145 |
| 11146 | return NULL; |  | 11146 | return NULL;
| 11147 | } |  | 11147 | }
| 11148 |  |  | 11148 |
| 11149 | static PyObject* pyopencv_cv_GFTTDetector_getMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11149 | static PyObject* pyopencv_cv_GFTTDetector_getMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 11150 | { |  | 11150 | {
| 11151 | using namespace cv; |  | 11151 | using namespace cv;
| 11152 |  |  | 11152 |
| 11153 |  |  | 11153 |
| 11154 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11154 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11155 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11155 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11156 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11156 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11157 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11157 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11158 | int retval; |  | 11158 | int retval;
| 11159 |  |  | 11159 |
| 11160 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11160 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11161 | { |  | 11161 | {
| 11162 | ERRWRAP2(retval = _self_->getMaxFeatures()); |  | 11162 | ERRWRAP2(retval = _self_->getMaxFeatures());
| 11163 | return pyopencv_from(retval); |  | 11163 | return pyopencv_from(retval);
| 11164 | } |  | 11164 | }
| 11165 |  |  | 11165 |
| 11166 | return NULL; |  | 11166 | return NULL;
| 11167 | } |  | 11167 | }
| 11168 |  |  | 11168 |
| 11169 | static PyObject* pyopencv_cv_GFTTDetector_getMinDistance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11169 | static PyObject* pyopencv_cv_GFTTDetector_getMinDistance(PyObject* self, PyObject* py_args, PyObject* kw)
| 11170 | { |  | 11170 | {
| 11171 | using namespace cv; |  | 11171 | using namespace cv;
| 11172 |  |  | 11172 |
| 11173 |  |  | 11173 |
| 11174 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11174 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11175 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11175 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11176 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11176 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11177 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11177 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11178 | double retval; |  | 11178 | double retval;
| 11179 |  |  | 11179 |
| 11180 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11180 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11181 | { |  | 11181 | {
| 11182 | ERRWRAP2(retval = _self_->getMinDistance()); |  | 11182 | ERRWRAP2(retval = _self_->getMinDistance());
| 11183 | return pyopencv_from(retval); |  | 11183 | return pyopencv_from(retval);
| 11184 | } |  | 11184 | }
| 11185 |  |  | 11185 |
| 11186 | return NULL; |  | 11186 | return NULL;
| 11187 | } |  | 11187 | }
| 11188 |  |  | 11188 |
| 11189 | static PyObject* pyopencv_cv_GFTTDetector_getQualityLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11189 | static PyObject* pyopencv_cv_GFTTDetector_getQualityLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 11190 | { |  | 11190 | {
| 11191 | using namespace cv; |  | 11191 | using namespace cv;
| 11192 |  |  | 11192 |
| 11193 |  |  | 11193 |
| 11194 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11194 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11195 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11195 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11196 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11196 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11197 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11197 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11198 | double retval; |  | 11198 | double retval;
| 11199 |  |  | 11199 |
| 11200 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11200 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11201 | { |  | 11201 | {
| 11202 | ERRWRAP2(retval = _self_->getQualityLevel()); |  | 11202 | ERRWRAP2(retval = _self_->getQualityLevel());
| 11203 | return pyopencv_from(retval); |  | 11203 | return pyopencv_from(retval);
| 11204 | } |  | 11204 | }
| 11205 |  |  | 11205 |
| 11206 | return NULL; |  | 11206 | return NULL;
| 11207 | } |  | 11207 | }
| 11208 |  |  | 11208 |
| 11209 | static PyObject* pyopencv_cv_GFTTDetector_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11209 | static PyObject* pyopencv_cv_GFTTDetector_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 11210 | { |  | 11210 | {
| 11211 | using namespace cv; |  | 11211 | using namespace cv;
| 11212 |  |  | 11212 |
| 11213 |  |  | 11213 |
| 11214 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11214 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11215 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11215 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11216 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11216 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11217 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11217 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11218 | PyObject* pyobj_blockSize = NULL; |  | 11218 | PyObject* pyobj_blockSize = NULL;
| 11219 | int blockSize=0; |  | 11219 | int blockSize=0;
| 11220 |  |  | 11220 |
| 11221 | const char* keywords[] = { "blockSize", NULL }; |  | 11221 | const char* keywords[] = { "blockSize", NULL };
| 11222 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setBlockSize", (char**)keywords, &pyobj_blockSize) && |  | 11222 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setBlockSize", (char**)keywords, &pyobj_blockSize) &&
| 11223 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) ) |  | 11223 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) )
| 11224 | { |  | 11224 | {
| 11225 | ERRWRAP2(_self_->setBlockSize(blockSize)); |  | 11225 | ERRWRAP2(_self_->setBlockSize(blockSize));
| 11226 | Py_RETURN_NONE; |  | 11226 | Py_RETURN_NONE;
| 11227 | } |  | 11227 | }
| 11228 |  |  | 11228 |
| 11229 | return NULL; |  | 11229 | return NULL;
| 11230 | } |  | 11230 | }
| 11231 |  |  | 11231 |
| 11232 | static PyObject* pyopencv_cv_GFTTDetector_setGradientSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11232 | static PyObject* pyopencv_cv_GFTTDetector_setGradientSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 11233 | { |  | 11233 | {
| 11234 | using namespace cv; |  | 11234 | using namespace cv;
| 11235 |  |  | 11235 |
| 11236 |  |  | 11236 |
| 11237 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11237 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11238 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11238 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11239 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11239 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11240 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11240 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11241 | PyObject* pyobj_gradientSize_ = NULL; |  | 11241 | PyObject* pyobj_gradientSize_ = NULL;
| 11242 | int gradientSize_=0; |  | 11242 | int gradientSize_=0;
| 11243 |  |  | 11243 |
| 11244 | const char* keywords[] = { "gradientSize_", NULL }; |  | 11244 | const char* keywords[] = { "gradientSize_", NULL };
| 11245 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setGradientSize", (char**)keywords, &pyobj_gradientSize_) && |  | 11245 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setGradientSize", (char**)keywords, &pyobj_gradientSize_) &&
| 11246 | pyopencv_to_safe(pyobj_gradientSize_, gradientSize_, ArgInfo("gradientSize_", 0)) ) |  | 11246 | pyopencv_to_safe(pyobj_gradientSize_, gradientSize_, ArgInfo("gradientSize_", 0)) )
| 11247 | { |  | 11247 | {
| 11248 | ERRWRAP2(_self_->setGradientSize(gradientSize_)); |  | 11248 | ERRWRAP2(_self_->setGradientSize(gradientSize_));
| 11249 | Py_RETURN_NONE; |  | 11249 | Py_RETURN_NONE;
| 11250 | } |  | 11250 | }
| 11251 |  |  | 11251 |
| 11252 | return NULL; |  | 11252 | return NULL;
| 11253 | } |  | 11253 | }
| 11254 |  |  | 11254 |
| 11255 | static PyObject* pyopencv_cv_GFTTDetector_setHarrisDetector(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11255 | static PyObject* pyopencv_cv_GFTTDetector_setHarrisDetector(PyObject* self, PyObject* py_args, PyObject* kw)
| 11256 | { |  | 11256 | {
| 11257 | using namespace cv; |  | 11257 | using namespace cv;
| 11258 |  |  | 11258 |
| 11259 |  |  | 11259 |
| 11260 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11260 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11261 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11261 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11262 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11262 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11263 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11263 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11264 | PyObject* pyobj_val = NULL; |  | 11264 | PyObject* pyobj_val = NULL;
| 11265 | bool val=0; |  | 11265 | bool val=0;
| 11266 |  |  | 11266 |
| 11267 | const char* keywords[] = { "val", NULL }; |  | 11267 | const char* keywords[] = { "val", NULL };
| 11268 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setHarrisDetector", (char**)keywords, &pyobj_val) && |  | 11268 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setHarrisDetector", (char**)keywords, &pyobj_val) &&
| 11269 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 11269 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 11270 | { |  | 11270 | {
| 11271 | ERRWRAP2(_self_->setHarrisDetector(val)); |  | 11271 | ERRWRAP2(_self_->setHarrisDetector(val));
| 11272 | Py_RETURN_NONE; |  | 11272 | Py_RETURN_NONE;
| 11273 | } |  | 11273 | }
| 11274 |  |  | 11274 |
| 11275 | return NULL; |  | 11275 | return NULL;
| 11276 | } |  | 11276 | }
| 11277 |  |  | 11277 |
| 11278 | static PyObject* pyopencv_cv_GFTTDetector_setK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11278 | static PyObject* pyopencv_cv_GFTTDetector_setK(PyObject* self, PyObject* py_args, PyObject* kw)
| 11279 | { |  | 11279 | {
| 11280 | using namespace cv; |  | 11280 | using namespace cv;
| 11281 |  |  | 11281 |
| 11282 |  |  | 11282 |
| 11283 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11283 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11284 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11284 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11285 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11285 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11286 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11286 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11287 | PyObject* pyobj_k = NULL; |  | 11287 | PyObject* pyobj_k = NULL;
| 11288 | double k=0; |  | 11288 | double k=0;
| 11289 |  |  | 11289 |
| 11290 | const char* keywords[] = { "k", NULL }; |  | 11290 | const char* keywords[] = { "k", NULL };
| 11291 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setK", (char**)keywords, &pyobj_k) && |  | 11291 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setK", (char**)keywords, &pyobj_k) &&
| 11292 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) ) |  | 11292 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) )
| 11293 | { |  | 11293 | {
| 11294 | ERRWRAP2(_self_->setK(k)); |  | 11294 | ERRWRAP2(_self_->setK(k));
| 11295 | Py_RETURN_NONE; |  | 11295 | Py_RETURN_NONE;
| 11296 | } |  | 11296 | }
| 11297 |  |  | 11297 |
| 11298 | return NULL; |  | 11298 | return NULL;
| 11299 | } |  | 11299 | }
| 11300 |  |  | 11300 |
| 11301 | static PyObject* pyopencv_cv_GFTTDetector_setMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11301 | static PyObject* pyopencv_cv_GFTTDetector_setMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 11302 | { |  | 11302 | {
| 11303 | using namespace cv; |  | 11303 | using namespace cv;
| 11304 |  |  | 11304 |
| 11305 |  |  | 11305 |
| 11306 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11306 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11307 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11307 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11308 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11308 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11309 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11309 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11310 | PyObject* pyobj_maxFeatures = NULL; |  | 11310 | PyObject* pyobj_maxFeatures = NULL;
| 11311 | int maxFeatures=0; |  | 11311 | int maxFeatures=0;
| 11312 |  |  | 11312 |
| 11313 | const char* keywords[] = { "maxFeatures", NULL }; |  | 11313 | const char* keywords[] = { "maxFeatures", NULL };
| 11314 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setMaxFeatures", (char**)keywords, &pyobj_maxFeatures) && |  | 11314 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setMaxFeatures", (char**)keywords, &pyobj_maxFeatures) &&
| 11315 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) ) |  | 11315 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) )
| 11316 | { |  | 11316 | {
| 11317 | ERRWRAP2(_self_->setMaxFeatures(maxFeatures)); |  | 11317 | ERRWRAP2(_self_->setMaxFeatures(maxFeatures));
| 11318 | Py_RETURN_NONE; |  | 11318 | Py_RETURN_NONE;
| 11319 | } |  | 11319 | }
| 11320 |  |  | 11320 |
| 11321 | return NULL; |  | 11321 | return NULL;
| 11322 | } |  | 11322 | }
| 11323 |  |  | 11323 |
| 11324 | static PyObject* pyopencv_cv_GFTTDetector_setMinDistance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11324 | static PyObject* pyopencv_cv_GFTTDetector_setMinDistance(PyObject* self, PyObject* py_args, PyObject* kw)
| 11325 | { |  | 11325 | {
| 11326 | using namespace cv; |  | 11326 | using namespace cv;
| 11327 |  |  | 11327 |
| 11328 |  |  | 11328 |
| 11329 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11329 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11330 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11330 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11331 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11331 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11332 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11332 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11333 | PyObject* pyobj_minDistance = NULL; |  | 11333 | PyObject* pyobj_minDistance = NULL;
| 11334 | double minDistance=0; |  | 11334 | double minDistance=0;
| 11335 |  |  | 11335 |
| 11336 | const char* keywords[] = { "minDistance", NULL }; |  | 11336 | const char* keywords[] = { "minDistance", NULL };
| 11337 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setMinDistance", (char**)keywords, &pyobj_minDistance) && |  | 11337 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setMinDistance", (char**)keywords, &pyobj_minDistance) &&
| 11338 | pyopencv_to_safe(pyobj_minDistance, minDistance, ArgInfo("minDistance", 0)) ) |  | 11338 | pyopencv_to_safe(pyobj_minDistance, minDistance, ArgInfo("minDistance", 0)) )
| 11339 | { |  | 11339 | {
| 11340 | ERRWRAP2(_self_->setMinDistance(minDistance)); |  | 11340 | ERRWRAP2(_self_->setMinDistance(minDistance));
| 11341 | Py_RETURN_NONE; |  | 11341 | Py_RETURN_NONE;
| 11342 | } |  | 11342 | }
| 11343 |  |  | 11343 |
| 11344 | return NULL; |  | 11344 | return NULL;
| 11345 | } |  | 11345 | }
| 11346 |  |  | 11346 |
| 11347 | static PyObject* pyopencv_cv_GFTTDetector_setQualityLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11347 | static PyObject* pyopencv_cv_GFTTDetector_setQualityLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 11348 | { |  | 11348 | {
| 11349 | using namespace cv; |  | 11349 | using namespace cv;
| 11350 |  |  | 11350 |
| 11351 |  |  | 11351 |
| 11352 | Ptr<cv::GFTTDetector> * self1 = 0; |  | 11352 | Ptr<cv::GFTTDetector> * self1 = 0;
| 11353 | if (!pyopencv_GFTTDetector_getp(self, self1)) |  | 11353 | if (!pyopencv_GFTTDetector_getp(self, self1))
| 11354 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)"); |  | 11354 | return failmsgp("Incorrect type of self (must be 'GFTTDetector' or its derivative)");
| 11355 | Ptr<cv::GFTTDetector> _self_ = *(self1); |  | 11355 | Ptr<cv::GFTTDetector> _self_ = *(self1);
| 11356 | PyObject* pyobj_qlevel = NULL; |  | 11356 | PyObject* pyobj_qlevel = NULL;
| 11357 | double qlevel=0; |  | 11357 | double qlevel=0;
| 11358 |  |  | 11358 |
| 11359 | const char* keywords[] = { "qlevel", NULL }; |  | 11359 | const char* keywords[] = { "qlevel", NULL };
| 11360 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setQualityLevel", (char**)keywords, &pyobj_qlevel) && |  | 11360 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GFTTDetector.setQualityLevel", (char**)keywords, &pyobj_qlevel) &&
| 11361 | pyopencv_to_safe(pyobj_qlevel, qlevel, ArgInfo("qlevel", 0)) ) |  | 11361 | pyopencv_to_safe(pyobj_qlevel, qlevel, ArgInfo("qlevel", 0)) )
| 11362 | { |  | 11362 | {
| 11363 | ERRWRAP2(_self_->setQualityLevel(qlevel)); |  | 11363 | ERRWRAP2(_self_->setQualityLevel(qlevel));
| 11364 | Py_RETURN_NONE; |  | 11364 | Py_RETURN_NONE;
| 11365 | } |  | 11365 | }
| 11366 |  |  | 11366 |
| 11367 | return NULL; |  | 11367 | return NULL;
| 11368 | } |  | 11368 | }
| 11369 |  |  | 11369 |
| 11370 |  |  | 11370 |
| 11371 |  |  | 11371 |
| 11372 | // Tables (GFTTDetector) |  | 11372 | // Tables (GFTTDetector)
| 11373 |  |  | 11373 |
| 11374 | static PyGetSetDef pyopencv_GFTTDetector_getseters[] = |  | 11374 | static PyGetSetDef pyopencv_GFTTDetector_getseters[] =
| 11375 | { |  | 11375 | {
| 11376 | {NULL} /* Sentinel */ |  | 11376 | {NULL} /* Sentinel */
| 11377 | }; |  | 11377 | };
| 11378 |  |  | 11378 |
| 11379 | static PyMethodDef pyopencv_GFTTDetector_methods[] = |  | 11379 | static PyMethodDef pyopencv_GFTTDetector_methods[] =
| 11380 | { |  | 11380 | {
| 11381 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_create_static, METH_STATIC), "create([, maxCorners[, qualityLevel[, minDistance[, blockSize[, useHarrisDetector[, k]]]]]]) -> retval\n. \n\n\n\ncreate(maxCorners, qualityLevel, minDistance, blockSize, gradiantSize[, useHarrisDetector[, k]]) -> retval\n."}, |  | 11381 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_create_static, METH_STATIC), "create([, maxCorners[, qualityLevel[, minDistance[, blockSize[, useHarrisDetector[, k]]]]]]) -> retval\n. \n\n\n\ncreate(maxCorners, qualityLevel, minDistance, blockSize, gradiantSize[, useHarrisDetector[, k]]) -> retval\n."},
| 11382 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getBlockSize, 0), "getBlockSize() -> retval\n."}, |  | 11382 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getBlockSize, 0), "getBlockSize() -> retval\n."},
| 11383 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 11383 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 11384 | {"getGradientSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getGradientSize, 0), "getGradientSize() -> retval\n."}, |  | 11384 | {"getGradientSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getGradientSize, 0), "getGradientSize() -> retval\n."},
| 11385 | {"getHarrisDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getHarrisDetector, 0), "getHarrisDetector() -> retval\n."}, |  | 11385 | {"getHarrisDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getHarrisDetector, 0), "getHarrisDetector() -> retval\n."},
| 11386 | {"getK", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getK, 0), "getK() -> retval\n."}, |  | 11386 | {"getK", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getK, 0), "getK() -> retval\n."},
| 11387 | {"getMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getMaxFeatures, 0), "getMaxFeatures() -> retval\n."}, |  | 11387 | {"getMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getMaxFeatures, 0), "getMaxFeatures() -> retval\n."},
| 11388 | {"getMinDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getMinDistance, 0), "getMinDistance() -> retval\n."}, |  | 11388 | {"getMinDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getMinDistance, 0), "getMinDistance() -> retval\n."},
| 11389 | {"getQualityLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getQualityLevel, 0), "getQualityLevel() -> retval\n."}, |  | 11389 | {"getQualityLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_getQualityLevel, 0), "getQualityLevel() -> retval\n."},
| 11390 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setBlockSize, 0), "setBlockSize(blockSize) -> None\n."}, |  | 11390 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setBlockSize, 0), "setBlockSize(blockSize) -> None\n."},
| 11391 | {"setGradientSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setGradientSize, 0), "setGradientSize(gradientSize_) -> None\n."}, |  | 11391 | {"setGradientSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setGradientSize, 0), "setGradientSize(gradientSize_) -> None\n."},
| 11392 | {"setHarrisDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setHarrisDetector, 0), "setHarrisDetector(val) -> None\n."}, |  | 11392 | {"setHarrisDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setHarrisDetector, 0), "setHarrisDetector(val) -> None\n."},
| 11393 | {"setK", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setK, 0), "setK(k) -> None\n."}, |  | 11393 | {"setK", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setK, 0), "setK(k) -> None\n."},
| 11394 | {"setMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setMaxFeatures, 0), "setMaxFeatures(maxFeatures) -> None\n."}, |  | 11394 | {"setMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setMaxFeatures, 0), "setMaxFeatures(maxFeatures) -> None\n."},
| 11395 | {"setMinDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setMinDistance, 0), "setMinDistance(minDistance) -> None\n."}, |  | 11395 | {"setMinDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setMinDistance, 0), "setMinDistance(minDistance) -> None\n."},
| 11396 | {"setQualityLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setQualityLevel, 0), "setQualityLevel(qlevel) -> None\n."}, |  | 11396 | {"setQualityLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_GFTTDetector_setQualityLevel, 0), "setQualityLevel(qlevel) -> None\n."},
| 11397 |  |  | 11397 |
| 11398 | {NULL, NULL} |  | 11398 | {NULL, NULL}
| 11399 | }; |  | 11399 | };
| 11400 |  |  | 11400 |
| 11401 | // Converter (GFTTDetector) |  | 11401 | // Converter (GFTTDetector)
| 11402 |  |  | 11402 |
| 11403 | template<> |  | 11403 | template<>
| 11404 | struct PyOpenCV_Converter< Ptr<cv::GFTTDetector> > |  | 11404 | struct PyOpenCV_Converter< Ptr<cv::GFTTDetector> >
| 11405 | { |  | 11405 | {
| 11406 | static PyObject* from(const Ptr<cv::GFTTDetector>& r) |  | 11406 | static PyObject* from(const Ptr<cv::GFTTDetector>& r)
| 11407 | { |  | 11407 | {
| 11408 | return pyopencv_GFTTDetector_Instance(r); |  | 11408 | return pyopencv_GFTTDetector_Instance(r);
| 11409 | } |  | 11409 | }
| 11410 | static bool to(PyObject* src, Ptr<cv::GFTTDetector>& dst, const ArgInfo& info) |  | 11410 | static bool to(PyObject* src, Ptr<cv::GFTTDetector>& dst, const ArgInfo& info)
| 11411 | { |  | 11411 | {
| 11412 | if(!src || src == Py_None) |  | 11412 | if(!src || src == Py_None)
| 11413 | return true; |  | 11413 | return true;
| 11414 | Ptr<cv::GFTTDetector> * dst_; |  | 11414 | Ptr<cv::GFTTDetector> * dst_;
| 11415 | if (pyopencv_GFTTDetector_getp(src, dst_)) |  | 11415 | if (pyopencv_GFTTDetector_getp(src, dst_))
| 11416 | { |  | 11416 | {
| 11417 | dst = *dst_; |  | 11417 | dst = *dst_;
| 11418 | return true; |  | 11418 | return true;
| 11419 | } |  | 11419 | }
| 11420 |  |  | 11420 |
| 11421 | failmsg("Expected Ptr<cv::GFTTDetector> for argument '%s'", info.name); |  | 11421 | failmsg("Expected Ptr<cv::GFTTDetector> for argument '%s'", info.name);
| 11422 | return false; |  | 11422 | return false;
| 11423 | } |  | 11423 | }
| 11424 | }; |  | 11424 | };
| 11425 |  |  | 11425 |
| 11426 | //================================================================================ |  | 11426 | //================================================================================
| 11427 | // GFrame (Generic) |  | 11427 | // GFrame (Generic)
| 11428 | //================================================================================ |  | 11428 | //================================================================================
| 11429 |  |  | 11429 |
| 11430 | // GetSet (GFrame) |  | 11430 | // GetSet (GFrame)
| 11431 |  |  | 11431 |
| 11432 |  |  | 11432 |
| 11433 |  |  | 11433 |
| 11434 | // Methods (GFrame) |  | 11434 | // Methods (GFrame)
| 11435 |  |  | 11435 |
| 11436 | static int pyopencv_cv_GFrame_GFrame(pyopencv_GFrame_t* self, PyObject* py_args, PyObject* kw) |  | 11436 | static int pyopencv_cv_GFrame_GFrame(pyopencv_GFrame_t* self, PyObject* py_args, PyObject* kw)
| 11437 | { |  | 11437 | {
| 11438 | using namespace cv; |  | 11438 | using namespace cv;
| 11439 |  |  | 11439 |
| 11440 |  |  | 11440 |
| 11441 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11441 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11442 | { |  | 11442 | {
| 11443 | if(self) ERRWRAP2(new (&(self->v)) cv::GFrame()); |  | 11443 | if(self) ERRWRAP2(new (&(self->v)) cv::GFrame());
| 11444 | return 0; |  | 11444 | return 0;
| 11445 | } |  | 11445 | }
| 11446 |  |  | 11446 |
| 11447 | return -1; |  | 11447 | return -1;
| 11448 | } |  | 11448 | }
| 11449 |  |  | 11449 |
| 11450 |  |  | 11450 |
| 11451 |  |  | 11451 |
| 11452 | // Tables (GFrame) |  | 11452 | // Tables (GFrame)
| 11453 |  |  | 11453 |
| 11454 | static PyGetSetDef pyopencv_GFrame_getseters[] = |  | 11454 | static PyGetSetDef pyopencv_GFrame_getseters[] =
| 11455 | { |  | 11455 | {
| 11456 | {NULL} /* Sentinel */ |  | 11456 | {NULL} /* Sentinel */
| 11457 | }; |  | 11457 | };
| 11458 |  |  | 11458 |
| 11459 | static PyMethodDef pyopencv_GFrame_methods[] = |  | 11459 | static PyMethodDef pyopencv_GFrame_methods[] =
| 11460 | { |  | 11460 | {
| 11461 |  |  | 11461 |
| 11462 | {NULL, NULL} |  | 11462 | {NULL, NULL}
| 11463 | }; |  | 11463 | };
| 11464 |  |  | 11464 |
| 11465 | // Converter (GFrame) |  | 11465 | // Converter (GFrame)
| 11466 |  |  | 11466 |
| 11467 | template<> |  | 11467 | template<>
| 11468 | struct PyOpenCV_Converter< cv::GFrame > |  | 11468 | struct PyOpenCV_Converter< cv::GFrame >
| 11469 | { |  | 11469 | {
| 11470 | static PyObject* from(const cv::GFrame& r) |  | 11470 | static PyObject* from(const cv::GFrame& r)
| 11471 | { |  | 11471 | {
| 11472 | return pyopencv_GFrame_Instance(r); |  | 11472 | return pyopencv_GFrame_Instance(r);
| 11473 | } |  | 11473 | }
| 11474 | static bool to(PyObject* src, cv::GFrame& dst, const ArgInfo& info) |  | 11474 | static bool to(PyObject* src, cv::GFrame& dst, const ArgInfo& info)
| 11475 | { |  | 11475 | {
| 11476 | if(!src || src == Py_None) |  | 11476 | if(!src || src == Py_None)
| 11477 | return true; |  | 11477 | return true;
| 11478 | cv::GFrame * dst_; |  | 11478 | cv::GFrame * dst_;
| 11479 | if (pyopencv_GFrame_getp(src, dst_)) |  | 11479 | if (pyopencv_GFrame_getp(src, dst_))
| 11480 | { |  | 11480 | {
| 11481 | dst = *dst_; |  | 11481 | dst = *dst_;
| 11482 | return true; |  | 11482 | return true;
| 11483 | } |  | 11483 | }
| 11484 |  |  | 11484 |
| 11485 | failmsg("Expected cv::GFrame for argument '%s'", info.name); |  | 11485 | failmsg("Expected cv::GFrame for argument '%s'", info.name);
| 11486 | return false; |  | 11486 | return false;
| 11487 | } |  | 11487 | }
| 11488 | }; |  | 11488 | };
| 11489 |  |  | 11489 |
| 11490 | //================================================================================ |  | 11490 | //================================================================================
| 11491 | // GInferInputs (Generic) |  | 11491 | // GInferInputs (Generic)
| 11492 | //================================================================================ |  | 11492 | //================================================================================
| 11493 |  |  | 11493 |
| 11494 | // GetSet (GInferInputs) |  | 11494 | // GetSet (GInferInputs)
| 11495 |  |  | 11495 |
| 11496 |  |  | 11496 |
| 11497 |  |  | 11497 |
| 11498 | // Methods (GInferInputs) |  | 11498 | // Methods (GInferInputs)
| 11499 |  |  | 11499 |
| 11500 | static int pyopencv_cv_GInferInputs_GInferInputs(pyopencv_GInferInputs_t* self, PyObject* py_args, PyObject* kw) |  | 11500 | static int pyopencv_cv_GInferInputs_GInferInputs(pyopencv_GInferInputs_t* self, PyObject* py_args, PyObject* kw)
| 11501 | { |  | 11501 | {
| 11502 | using namespace cv; |  | 11502 | using namespace cv;
| 11503 |  |  | 11503 |
| 11504 |  |  | 11504 |
| 11505 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11505 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11506 | { |  | 11506 | {
| 11507 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferInputs()); |  | 11507 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferInputs());
| 11508 | return 0; |  | 11508 | return 0;
| 11509 | } |  | 11509 | }
| 11510 |  |  | 11510 |
| 11511 | return -1; |  | 11511 | return -1;
| 11512 | } |  | 11512 | }
| 11513 |  |  | 11513 |
| 11514 | static PyObject* pyopencv_cv_GInferInputs_setInput(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11514 | static PyObject* pyopencv_cv_GInferInputs_setInput(PyObject* self, PyObject* py_args, PyObject* kw)
| 11515 | { |  | 11515 | {
| 11516 | using namespace cv; |  | 11516 | using namespace cv;
| 11517 |  |  | 11517 |
| 11518 |  |  | 11518 |
| 11519 | cv::GInferInputs * self1 = 0; |  | 11519 | cv::GInferInputs * self1 = 0;
| 11520 | if (!pyopencv_GInferInputs_getp(self, self1)) |  | 11520 | if (!pyopencv_GInferInputs_getp(self, self1))
| 11521 | return failmsgp("Incorrect type of self (must be 'GInferInputs' or its derivative)"); |  | 11521 | return failmsgp("Incorrect type of self (must be 'GInferInputs' or its derivative)");
| 11522 | cv::GInferInputs* _self_ = (self1); |  | 11522 | cv::GInferInputs* _self_ = (self1);
| 11523 | pyPrepareArgumentConversionErrorsStorage(2); |  | 11523 | pyPrepareArgumentConversionErrorsStorage(2);
| 11524 |  |  | 11524 |
| 11525 | { |  | 11525 | {
| 11526 | PyObject* pyobj_name = NULL; |  | 11526 | PyObject* pyobj_name = NULL;
| 11527 | std::string name; |  | 11527 | std::string name;
| 11528 | PyObject* pyobj_value = NULL; |  | 11528 | PyObject* pyobj_value = NULL;
| 11529 | cv::GMat value; |  | 11529 | cv::GMat value;
| 11530 | GInferInputs retval; |  | 11530 | GInferInputs retval;
| 11531 |  |  | 11531 |
| 11532 | const char* keywords[] = { "name", "value", NULL }; |  | 11532 | const char* keywords[] = { "name", "value", NULL };
| 11533 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) && |  | 11533 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) &&
| 11534 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 11534 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 11535 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 11535 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 11536 | { |  | 11536 | {
| 11537 | ERRWRAP2(retval = _self_->setInput(name, value)); |  | 11537 | ERRWRAP2(retval = _self_->setInput(name, value));
| 11538 | return pyopencv_from(retval); |  | 11538 | return pyopencv_from(retval);
| 11539 | } |  | 11539 | }
| 11540 |  |  | 11540 |
| 11541 |  |  | 11541 |
| 11542 | pyPopulateArgumentConversionErrors(); |  | 11542 | pyPopulateArgumentConversionErrors();
| 11543 | } |  | 11543 | }
| 11544 |  |  | 11544 |
| 11545 |  |  | 11545 |
| 11546 | { |  | 11546 | {
| 11547 | PyObject* pyobj_name = NULL; |  | 11547 | PyObject* pyobj_name = NULL;
| 11548 | std::string name; |  | 11548 | std::string name;
| 11549 | PyObject* pyobj_value = NULL; |  | 11549 | PyObject* pyobj_value = NULL;
| 11550 | cv::GFrame value; |  | 11550 | cv::GFrame value;
| 11551 | GInferInputs retval; |  | 11551 | GInferInputs retval;
| 11552 |  |  | 11552 |
| 11553 | const char* keywords[] = { "name", "value", NULL }; |  | 11553 | const char* keywords[] = { "name", "value", NULL };
| 11554 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) && |  | 11554 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) &&
| 11555 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 11555 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 11556 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 11556 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 11557 | { |  | 11557 | {
| 11558 | ERRWRAP2(retval = _self_->setInput(name, value)); |  | 11558 | ERRWRAP2(retval = _self_->setInput(name, value));
| 11559 | return pyopencv_from(retval); |  | 11559 | return pyopencv_from(retval);
| 11560 | } |  | 11560 | }
| 11561 |  |  | 11561 |
| 11562 |  |  | 11562 |
| 11563 | pyPopulateArgumentConversionErrors(); |  | 11563 | pyPopulateArgumentConversionErrors();
| 11564 | } |  | 11564 | }
| 11565 | pyRaiseCVOverloadException("setInput"); |  | 11565 | pyRaiseCVOverloadException("setInput");
| 11566 |  |  | 11566 |
| 11567 | return NULL; |  | 11567 | return NULL;
| 11568 | } |  | 11568 | }
| 11569 |  |  | 11569 |
| 11570 |  |  | 11570 |
| 11571 |  |  | 11571 |
| 11572 | // Tables (GInferInputs) |  | 11572 | // Tables (GInferInputs)
| 11573 |  |  | 11573 |
| 11574 | static PyGetSetDef pyopencv_GInferInputs_getseters[] = |  | 11574 | static PyGetSetDef pyopencv_GInferInputs_getseters[] =
| 11575 | { |  | 11575 | {
| 11576 | {NULL} /* Sentinel */ |  | 11576 | {NULL} /* Sentinel */
| 11577 | }; |  | 11577 | };
| 11578 |  |  | 11578 |
| 11579 | static PyMethodDef pyopencv_GInferInputs_methods[] = |  | 11579 | static PyMethodDef pyopencv_GInferInputs_methods[] =
| 11580 | { |  | 11580 | {
| 11581 | {"setInput", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferInputs_setInput, 0), "setInput(name, value) -> retval\n."}, |  | 11581 | {"setInput", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferInputs_setInput, 0), "setInput(name, value) -> retval\n."},
| 11582 |  |  | 11582 |
| 11583 | {NULL, NULL} |  | 11583 | {NULL, NULL}
| 11584 | }; |  | 11584 | };
| 11585 |  |  | 11585 |
| 11586 | // Converter (GInferInputs) |  | 11586 | // Converter (GInferInputs)
| 11587 |  |  | 11587 |
| 11588 | template<> |  | 11588 | template<>
| 11589 | struct PyOpenCV_Converter< cv::GInferInputs > |  | 11589 | struct PyOpenCV_Converter< cv::GInferInputs >
| 11590 | { |  | 11590 | {
| 11591 | static PyObject* from(const cv::GInferInputs& r) |  | 11591 | static PyObject* from(const cv::GInferInputs& r)
| 11592 | { |  | 11592 | {
| 11593 | return pyopencv_GInferInputs_Instance(r); |  | 11593 | return pyopencv_GInferInputs_Instance(r);
| 11594 | } |  | 11594 | }
| 11595 | static bool to(PyObject* src, cv::GInferInputs& dst, const ArgInfo& info) |  | 11595 | static bool to(PyObject* src, cv::GInferInputs& dst, const ArgInfo& info)
| 11596 | { |  | 11596 | {
| 11597 | if(!src || src == Py_None) |  | 11597 | if(!src || src == Py_None)
| 11598 | return true; |  | 11598 | return true;
| 11599 | cv::GInferInputs * dst_; |  | 11599 | cv::GInferInputs * dst_;
| 11600 | if (pyopencv_GInferInputs_getp(src, dst_)) |  | 11600 | if (pyopencv_GInferInputs_getp(src, dst_))
| 11601 | { |  | 11601 | {
| 11602 | dst = *dst_; |  | 11602 | dst = *dst_;
| 11603 | return true; |  | 11603 | return true;
| 11604 | } |  | 11604 | }
| 11605 |  |  | 11605 |
| 11606 | failmsg("Expected cv::GInferInputs for argument '%s'", info.name); |  | 11606 | failmsg("Expected cv::GInferInputs for argument '%s'", info.name);
| 11607 | return false; |  | 11607 | return false;
| 11608 | } |  | 11608 | }
| 11609 | }; |  | 11609 | };
| 11610 |  |  | 11610 |
| 11611 | //================================================================================ |  | 11611 | //================================================================================
| 11612 | // GInferListInputs (Generic) |  | 11612 | // GInferListInputs (Generic)
| 11613 | //================================================================================ |  | 11613 | //================================================================================
| 11614 |  |  | 11614 |
| 11615 | // GetSet (GInferListInputs) |  | 11615 | // GetSet (GInferListInputs)
| 11616 |  |  | 11616 |
| 11617 |  |  | 11617 |
| 11618 |  |  | 11618 |
| 11619 | // Methods (GInferListInputs) |  | 11619 | // Methods (GInferListInputs)
| 11620 |  |  | 11620 |
| 11621 | static int pyopencv_cv_GInferListInputs_GInferListInputs(pyopencv_GInferListInputs_t* self, PyObject* py_args, PyObject* kw) |  | 11621 | static int pyopencv_cv_GInferListInputs_GInferListInputs(pyopencv_GInferListInputs_t* self, PyObject* py_args, PyObject* kw)
| 11622 | { |  | 11622 | {
| 11623 | using namespace cv; |  | 11623 | using namespace cv;
| 11624 |  |  | 11624 |
| 11625 |  |  | 11625 |
| 11626 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11626 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11627 | { |  | 11627 | {
| 11628 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferListInputs()); |  | 11628 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferListInputs());
| 11629 | return 0; |  | 11629 | return 0;
| 11630 | } |  | 11630 | }
| 11631 |  |  | 11631 |
| 11632 | return -1; |  | 11632 | return -1;
| 11633 | } |  | 11633 | }
| 11634 |  |  | 11634 |
| 11635 | static PyObject* pyopencv_cv_GInferListInputs_setInput(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11635 | static PyObject* pyopencv_cv_GInferListInputs_setInput(PyObject* self, PyObject* py_args, PyObject* kw)
| 11636 | { |  | 11636 | {
| 11637 | using namespace cv; |  | 11637 | using namespace cv;
| 11638 |  |  | 11638 |
| 11639 |  |  | 11639 |
| 11640 | cv::GInferListInputs * self1 = 0; |  | 11640 | cv::GInferListInputs * self1 = 0;
| 11641 | if (!pyopencv_GInferListInputs_getp(self, self1)) |  | 11641 | if (!pyopencv_GInferListInputs_getp(self, self1))
| 11642 | return failmsgp("Incorrect type of self (must be 'GInferListInputs' or its derivative)"); |  | 11642 | return failmsgp("Incorrect type of self (must be 'GInferListInputs' or its derivative)");
| 11643 | cv::GInferListInputs* _self_ = (self1); |  | 11643 | cv::GInferListInputs* _self_ = (self1);
| 11644 | pyPrepareArgumentConversionErrorsStorage(2); |  | 11644 | pyPrepareArgumentConversionErrorsStorage(2);
| 11645 |  |  | 11645 |
| 11646 | { |  | 11646 | {
| 11647 | PyObject* pyobj_name = NULL; |  | 11647 | PyObject* pyobj_name = NULL;
| 11648 | std::string name; |  | 11648 | std::string name;
| 11649 | PyObject* pyobj_value = NULL; |  | 11649 | PyObject* pyobj_value = NULL;
| 11650 | GArray_GMat value; |  | 11650 | GArray_GMat value;
| 11651 | GInferListInputs retval; |  | 11651 | GInferListInputs retval;
| 11652 |  |  | 11652 |
| 11653 | const char* keywords[] = { "name", "value", NULL }; |  | 11653 | const char* keywords[] = { "name", "value", NULL };
| 11654 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferListInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) && |  | 11654 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferListInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) &&
| 11655 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 11655 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 11656 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 11656 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 11657 | { |  | 11657 | {
| 11658 | ERRWRAP2(retval = _self_->setInput(name, value)); |  | 11658 | ERRWRAP2(retval = _self_->setInput(name, value));
| 11659 | return pyopencv_from(retval); |  | 11659 | return pyopencv_from(retval);
| 11660 | } |  | 11660 | }
| 11661 |  |  | 11661 |
| 11662 |  |  | 11662 |
| 11663 | pyPopulateArgumentConversionErrors(); |  | 11663 | pyPopulateArgumentConversionErrors();
| 11664 | } |  | 11664 | }
| 11665 |  |  | 11665 |
| 11666 |  |  | 11666 |
| 11667 | { |  | 11667 | {
| 11668 | PyObject* pyobj_name = NULL; |  | 11668 | PyObject* pyobj_name = NULL;
| 11669 | std::string name; |  | 11669 | std::string name;
| 11670 | PyObject* pyobj_value = NULL; |  | 11670 | PyObject* pyobj_value = NULL;
| 11671 | GArray_Rect value; |  | 11671 | GArray_Rect value;
| 11672 | GInferListInputs retval; |  | 11672 | GInferListInputs retval;
| 11673 |  |  | 11673 |
| 11674 | const char* keywords[] = { "name", "value", NULL }; |  | 11674 | const char* keywords[] = { "name", "value", NULL };
| 11675 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferListInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) && |  | 11675 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GInferListInputs.setInput", (char**)keywords, &pyobj_name, &pyobj_value) &&
| 11676 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 11676 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 11677 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 11677 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 11678 | { |  | 11678 | {
| 11679 | ERRWRAP2(retval = _self_->setInput(name, value)); |  | 11679 | ERRWRAP2(retval = _self_->setInput(name, value));
| 11680 | return pyopencv_from(retval); |  | 11680 | return pyopencv_from(retval);
| 11681 | } |  | 11681 | }
| 11682 |  |  | 11682 |
| 11683 |  |  | 11683 |
| 11684 | pyPopulateArgumentConversionErrors(); |  | 11684 | pyPopulateArgumentConversionErrors();
| 11685 | } |  | 11685 | }
| 11686 | pyRaiseCVOverloadException("setInput"); |  | 11686 | pyRaiseCVOverloadException("setInput");
| 11687 |  |  | 11687 |
| 11688 | return NULL; |  | 11688 | return NULL;
| 11689 | } |  | 11689 | }
| 11690 |  |  | 11690 |
| 11691 |  |  | 11691 |
| 11692 |  |  | 11692 |
| 11693 | // Tables (GInferListInputs) |  | 11693 | // Tables (GInferListInputs)
| 11694 |  |  | 11694 |
| 11695 | static PyGetSetDef pyopencv_GInferListInputs_getseters[] = |  | 11695 | static PyGetSetDef pyopencv_GInferListInputs_getseters[] =
| 11696 | { |  | 11696 | {
| 11697 | {NULL} /* Sentinel */ |  | 11697 | {NULL} /* Sentinel */
| 11698 | }; |  | 11698 | };
| 11699 |  |  | 11699 |
| 11700 | static PyMethodDef pyopencv_GInferListInputs_methods[] = |  | 11700 | static PyMethodDef pyopencv_GInferListInputs_methods[] =
| 11701 | { |  | 11701 | {
| 11702 | {"setInput", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferListInputs_setInput, 0), "setInput(name, value) -> retval\n."}, |  | 11702 | {"setInput", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferListInputs_setInput, 0), "setInput(name, value) -> retval\n."},
| 11703 |  |  | 11703 |
| 11704 | {NULL, NULL} |  | 11704 | {NULL, NULL}
| 11705 | }; |  | 11705 | };
| 11706 |  |  | 11706 |
| 11707 | // Converter (GInferListInputs) |  | 11707 | // Converter (GInferListInputs)
| 11708 |  |  | 11708 |
| 11709 | template<> |  | 11709 | template<>
| 11710 | struct PyOpenCV_Converter< cv::GInferListInputs > |  | 11710 | struct PyOpenCV_Converter< cv::GInferListInputs >
| 11711 | { |  | 11711 | {
| 11712 | static PyObject* from(const cv::GInferListInputs& r) |  | 11712 | static PyObject* from(const cv::GInferListInputs& r)
| 11713 | { |  | 11713 | {
| 11714 | return pyopencv_GInferListInputs_Instance(r); |  | 11714 | return pyopencv_GInferListInputs_Instance(r);
| 11715 | } |  | 11715 | }
| 11716 | static bool to(PyObject* src, cv::GInferListInputs& dst, const ArgInfo& info) |  | 11716 | static bool to(PyObject* src, cv::GInferListInputs& dst, const ArgInfo& info)
| 11717 | { |  | 11717 | {
| 11718 | if(!src || src == Py_None) |  | 11718 | if(!src || src == Py_None)
| 11719 | return true; |  | 11719 | return true;
| 11720 | cv::GInferListInputs * dst_; |  | 11720 | cv::GInferListInputs * dst_;
| 11721 | if (pyopencv_GInferListInputs_getp(src, dst_)) |  | 11721 | if (pyopencv_GInferListInputs_getp(src, dst_))
| 11722 | { |  | 11722 | {
| 11723 | dst = *dst_; |  | 11723 | dst = *dst_;
| 11724 | return true; |  | 11724 | return true;
| 11725 | } |  | 11725 | }
| 11726 |  |  | 11726 |
| 11727 | failmsg("Expected cv::GInferListInputs for argument '%s'", info.name); |  | 11727 | failmsg("Expected cv::GInferListInputs for argument '%s'", info.name);
| 11728 | return false; |  | 11728 | return false;
| 11729 | } |  | 11729 | }
| 11730 | }; |  | 11730 | };
| 11731 |  |  | 11731 |
| 11732 | //================================================================================ |  | 11732 | //================================================================================
| 11733 | // GInferListOutputs (Generic) |  | 11733 | // GInferListOutputs (Generic)
| 11734 | //================================================================================ |  | 11734 | //================================================================================
| 11735 |  |  | 11735 |
| 11736 | // GetSet (GInferListOutputs) |  | 11736 | // GetSet (GInferListOutputs)
| 11737 |  |  | 11737 |
| 11738 |  |  | 11738 |
| 11739 |  |  | 11739 |
| 11740 | // Methods (GInferListOutputs) |  | 11740 | // Methods (GInferListOutputs)
| 11741 |  |  | 11741 |
| 11742 | static int pyopencv_cv_GInferListOutputs_GInferListOutputs(pyopencv_GInferListOutputs_t* self, PyObject* py_args, PyObject* kw) |  | 11742 | static int pyopencv_cv_GInferListOutputs_GInferListOutputs(pyopencv_GInferListOutputs_t* self, PyObject* py_args, PyObject* kw)
| 11743 | { |  | 11743 | {
| 11744 | using namespace cv; |  | 11744 | using namespace cv;
| 11745 |  |  | 11745 |
| 11746 |  |  | 11746 |
| 11747 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11747 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11748 | { |  | 11748 | {
| 11749 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferListOutputs()); |  | 11749 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferListOutputs());
| 11750 | return 0; |  | 11750 | return 0;
| 11751 | } |  | 11751 | }
| 11752 |  |  | 11752 |
| 11753 | return -1; |  | 11753 | return -1;
| 11754 | } |  | 11754 | }
| 11755 |  |  | 11755 |
| 11756 | static PyObject* pyopencv_cv_GInferListOutputs_at(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11756 | static PyObject* pyopencv_cv_GInferListOutputs_at(PyObject* self, PyObject* py_args, PyObject* kw)
| 11757 | { |  | 11757 | {
| 11758 | using namespace cv; |  | 11758 | using namespace cv;
| 11759 |  |  | 11759 |
| 11760 |  |  | 11760 |
| 11761 | cv::GInferListOutputs * self1 = 0; |  | 11761 | cv::GInferListOutputs * self1 = 0;
| 11762 | if (!pyopencv_GInferListOutputs_getp(self, self1)) |  | 11762 | if (!pyopencv_GInferListOutputs_getp(self, self1))
| 11763 | return failmsgp("Incorrect type of self (must be 'GInferListOutputs' or its derivative)"); |  | 11763 | return failmsgp("Incorrect type of self (must be 'GInferListOutputs' or its derivative)");
| 11764 | cv::GInferListOutputs* _self_ = (self1); |  | 11764 | cv::GInferListOutputs* _self_ = (self1);
| 11765 | PyObject* pyobj_name = NULL; |  | 11765 | PyObject* pyobj_name = NULL;
| 11766 | std::string name; |  | 11766 | std::string name;
| 11767 | cv::GArray<cv::GMat> retval; |  | 11767 | cv::GArray<cv::GMat> retval;
| 11768 |  |  | 11768 |
| 11769 | const char* keywords[] = { "name", NULL }; |  | 11769 | const char* keywords[] = { "name", NULL };
| 11770 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GInferListOutputs.at", (char**)keywords, &pyobj_name) && |  | 11770 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GInferListOutputs.at", (char**)keywords, &pyobj_name) &&
| 11771 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 11771 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 11772 | { |  | 11772 | {
| 11773 | ERRWRAP2(retval = _self_->at(name)); |  | 11773 | ERRWRAP2(retval = _self_->at(name));
| 11774 | return pyopencv_from(retval); |  | 11774 | return pyopencv_from(retval);
| 11775 | } |  | 11775 | }
| 11776 |  |  | 11776 |
| 11777 | return NULL; |  | 11777 | return NULL;
| 11778 | } |  | 11778 | }
| 11779 |  |  | 11779 |
| 11780 |  |  | 11780 |
| 11781 |  |  | 11781 |
| 11782 | // Tables (GInferListOutputs) |  | 11782 | // Tables (GInferListOutputs)
| 11783 |  |  | 11783 |
| 11784 | static PyGetSetDef pyopencv_GInferListOutputs_getseters[] = |  | 11784 | static PyGetSetDef pyopencv_GInferListOutputs_getseters[] =
| 11785 | { |  | 11785 | {
| 11786 | {NULL} /* Sentinel */ |  | 11786 | {NULL} /* Sentinel */
| 11787 | }; |  | 11787 | };
| 11788 |  |  | 11788 |
| 11789 | static PyMethodDef pyopencv_GInferListOutputs_methods[] = |  | 11789 | static PyMethodDef pyopencv_GInferListOutputs_methods[] =
| 11790 | { |  | 11790 | {
| 11791 | {"at", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferListOutputs_at, 0), "at(name) -> retval\n."}, |  | 11791 | {"at", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferListOutputs_at, 0), "at(name) -> retval\n."},
| 11792 |  |  | 11792 |
| 11793 | {NULL, NULL} |  | 11793 | {NULL, NULL}
| 11794 | }; |  | 11794 | };
| 11795 |  |  | 11795 |
| 11796 | // Converter (GInferListOutputs) |  | 11796 | // Converter (GInferListOutputs)
| 11797 |  |  | 11797 |
| 11798 | template<> |  | 11798 | template<>
| 11799 | struct PyOpenCV_Converter< cv::GInferListOutputs > |  | 11799 | struct PyOpenCV_Converter< cv::GInferListOutputs >
| 11800 | { |  | 11800 | {
| 11801 | static PyObject* from(const cv::GInferListOutputs& r) |  | 11801 | static PyObject* from(const cv::GInferListOutputs& r)
| 11802 | { |  | 11802 | {
| 11803 | return pyopencv_GInferListOutputs_Instance(r); |  | 11803 | return pyopencv_GInferListOutputs_Instance(r);
| 11804 | } |  | 11804 | }
| 11805 | static bool to(PyObject* src, cv::GInferListOutputs& dst, const ArgInfo& info) |  | 11805 | static bool to(PyObject* src, cv::GInferListOutputs& dst, const ArgInfo& info)
| 11806 | { |  | 11806 | {
| 11807 | if(!src || src == Py_None) |  | 11807 | if(!src || src == Py_None)
| 11808 | return true; |  | 11808 | return true;
| 11809 | cv::GInferListOutputs * dst_; |  | 11809 | cv::GInferListOutputs * dst_;
| 11810 | if (pyopencv_GInferListOutputs_getp(src, dst_)) |  | 11810 | if (pyopencv_GInferListOutputs_getp(src, dst_))
| 11811 | { |  | 11811 | {
| 11812 | dst = *dst_; |  | 11812 | dst = *dst_;
| 11813 | return true; |  | 11813 | return true;
| 11814 | } |  | 11814 | }
| 11815 |  |  | 11815 |
| 11816 | failmsg("Expected cv::GInferListOutputs for argument '%s'", info.name); |  | 11816 | failmsg("Expected cv::GInferListOutputs for argument '%s'", info.name);
| 11817 | return false; |  | 11817 | return false;
| 11818 | } |  | 11818 | }
| 11819 | }; |  | 11819 | };
| 11820 |  |  | 11820 |
| 11821 | //================================================================================ |  | 11821 | //================================================================================
| 11822 | // GInferOutputs (Generic) |  | 11822 | // GInferOutputs (Generic)
| 11823 | //================================================================================ |  | 11823 | //================================================================================
| 11824 |  |  | 11824 |
| 11825 | // GetSet (GInferOutputs) |  | 11825 | // GetSet (GInferOutputs)
| 11826 |  |  | 11826 |
| 11827 |  |  | 11827 |
| 11828 |  |  | 11828 |
| 11829 | // Methods (GInferOutputs) |  | 11829 | // Methods (GInferOutputs)
| 11830 |  |  | 11830 |
| 11831 | static int pyopencv_cv_GInferOutputs_GInferOutputs(pyopencv_GInferOutputs_t* self, PyObject* py_args, PyObject* kw) |  | 11831 | static int pyopencv_cv_GInferOutputs_GInferOutputs(pyopencv_GInferOutputs_t* self, PyObject* py_args, PyObject* kw)
| 11832 | { |  | 11832 | {
| 11833 | using namespace cv; |  | 11833 | using namespace cv;
| 11834 |  |  | 11834 |
| 11835 |  |  | 11835 |
| 11836 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11836 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11837 | { |  | 11837 | {
| 11838 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferOutputs()); |  | 11838 | if(self) ERRWRAP2(new (&(self->v)) cv::GInferOutputs());
| 11839 | return 0; |  | 11839 | return 0;
| 11840 | } |  | 11840 | }
| 11841 |  |  | 11841 |
| 11842 | return -1; |  | 11842 | return -1;
| 11843 | } |  | 11843 | }
| 11844 |  |  | 11844 |
| 11845 | static PyObject* pyopencv_cv_GInferOutputs_at(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11845 | static PyObject* pyopencv_cv_GInferOutputs_at(PyObject* self, PyObject* py_args, PyObject* kw)
| 11846 | { |  | 11846 | {
| 11847 | using namespace cv; |  | 11847 | using namespace cv;
| 11848 |  |  | 11848 |
| 11849 |  |  | 11849 |
| 11850 | cv::GInferOutputs * self1 = 0; |  | 11850 | cv::GInferOutputs * self1 = 0;
| 11851 | if (!pyopencv_GInferOutputs_getp(self, self1)) |  | 11851 | if (!pyopencv_GInferOutputs_getp(self, self1))
| 11852 | return failmsgp("Incorrect type of self (must be 'GInferOutputs' or its derivative)"); |  | 11852 | return failmsgp("Incorrect type of self (must be 'GInferOutputs' or its derivative)");
| 11853 | cv::GInferOutputs* _self_ = (self1); |  | 11853 | cv::GInferOutputs* _self_ = (self1);
| 11854 | PyObject* pyobj_name = NULL; |  | 11854 | PyObject* pyobj_name = NULL;
| 11855 | std::string name; |  | 11855 | std::string name;
| 11856 | cv::GMat retval; |  | 11856 | cv::GMat retval;
| 11857 |  |  | 11857 |
| 11858 | const char* keywords[] = { "name", NULL }; |  | 11858 | const char* keywords[] = { "name", NULL };
| 11859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GInferOutputs.at", (char**)keywords, &pyobj_name) && |  | 11859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GInferOutputs.at", (char**)keywords, &pyobj_name) &&
| 11860 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 11860 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 11861 | { |  | 11861 | {
| 11862 | ERRWRAP2(retval = _self_->at(name)); |  | 11862 | ERRWRAP2(retval = _self_->at(name));
| 11863 | return pyopencv_from(retval); |  | 11863 | return pyopencv_from(retval);
| 11864 | } |  | 11864 | }
| 11865 |  |  | 11865 |
| 11866 | return NULL; |  | 11866 | return NULL;
| 11867 | } |  | 11867 | }
| 11868 |  |  | 11868 |
| 11869 |  |  | 11869 |
| 11870 |  |  | 11870 |
| 11871 | // Tables (GInferOutputs) |  | 11871 | // Tables (GInferOutputs)
| 11872 |  |  | 11872 |
| 11873 | static PyGetSetDef pyopencv_GInferOutputs_getseters[] = |  | 11873 | static PyGetSetDef pyopencv_GInferOutputs_getseters[] =
| 11874 | { |  | 11874 | {
| 11875 | {NULL} /* Sentinel */ |  | 11875 | {NULL} /* Sentinel */
| 11876 | }; |  | 11876 | };
| 11877 |  |  | 11877 |
| 11878 | static PyMethodDef pyopencv_GInferOutputs_methods[] = |  | 11878 | static PyMethodDef pyopencv_GInferOutputs_methods[] =
| 11879 | { |  | 11879 | {
| 11880 | {"at", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferOutputs_at, 0), "at(name) -> retval\n."}, |  | 11880 | {"at", CV_PY_FN_WITH_KW_(pyopencv_cv_GInferOutputs_at, 0), "at(name) -> retval\n."},
| 11881 |  |  | 11881 |
| 11882 | {NULL, NULL} |  | 11882 | {NULL, NULL}
| 11883 | }; |  | 11883 | };
| 11884 |  |  | 11884 |
| 11885 | // Converter (GInferOutputs) |  | 11885 | // Converter (GInferOutputs)
| 11886 |  |  | 11886 |
| 11887 | template<> |  | 11887 | template<>
| 11888 | struct PyOpenCV_Converter< cv::GInferOutputs > |  | 11888 | struct PyOpenCV_Converter< cv::GInferOutputs >
| 11889 | { |  | 11889 | {
| 11890 | static PyObject* from(const cv::GInferOutputs& r) |  | 11890 | static PyObject* from(const cv::GInferOutputs& r)
| 11891 | { |  | 11891 | {
| 11892 | return pyopencv_GInferOutputs_Instance(r); |  | 11892 | return pyopencv_GInferOutputs_Instance(r);
| 11893 | } |  | 11893 | }
| 11894 | static bool to(PyObject* src, cv::GInferOutputs& dst, const ArgInfo& info) |  | 11894 | static bool to(PyObject* src, cv::GInferOutputs& dst, const ArgInfo& info)
| 11895 | { |  | 11895 | {
| 11896 | if(!src || src == Py_None) |  | 11896 | if(!src || src == Py_None)
| 11897 | return true; |  | 11897 | return true;
| 11898 | cv::GInferOutputs * dst_; |  | 11898 | cv::GInferOutputs * dst_;
| 11899 | if (pyopencv_GInferOutputs_getp(src, dst_)) |  | 11899 | if (pyopencv_GInferOutputs_getp(src, dst_))
| 11900 | { |  | 11900 | {
| 11901 | dst = *dst_; |  | 11901 | dst = *dst_;
| 11902 | return true; |  | 11902 | return true;
| 11903 | } |  | 11903 | }
| 11904 |  |  | 11904 |
| 11905 | failmsg("Expected cv::GInferOutputs for argument '%s'", info.name); |  | 11905 | failmsg("Expected cv::GInferOutputs for argument '%s'", info.name);
| 11906 | return false; |  | 11906 | return false;
| 11907 | } |  | 11907 | }
| 11908 | }; |  | 11908 | };
| 11909 |  |  | 11909 |
| 11910 | //================================================================================ |  | 11910 | //================================================================================
| 11911 | // GKernelPackage (Generic) |  | 11911 | // GKernelPackage (Generic)
| 11912 | //================================================================================ |  | 11912 | //================================================================================
| 11913 |  |  | 11913 |
| 11914 | // GetSet (GKernelPackage) |  | 11914 | // GetSet (GKernelPackage)
| 11915 |  |  | 11915 |
| 11916 |  |  | 11916 |
| 11917 |  |  | 11917 |
| 11918 | // Methods (GKernelPackage) |  | 11918 | // Methods (GKernelPackage)
| 11919 |  |  | 11919 |
| 11920 | static PyObject* pyopencv_cv_GKernelPackage_size(PyObject* self, PyObject* py_args, PyObject* kw) |  | 11920 | static PyObject* pyopencv_cv_GKernelPackage_size(PyObject* self, PyObject* py_args, PyObject* kw)
| 11921 | { |  | 11921 | {
| 11922 | using namespace cv; |  | 11922 | using namespace cv;
| 11923 |  |  | 11923 |
| 11924 |  |  | 11924 |
| 11925 | cv::GKernelPackage * self1 = 0; |  | 11925 | cv::GKernelPackage * self1 = 0;
| 11926 | if (!pyopencv_GKernelPackage_getp(self, self1)) |  | 11926 | if (!pyopencv_GKernelPackage_getp(self, self1))
| 11927 | return failmsgp("Incorrect type of self (must be 'GKernelPackage' or its derivative)"); |  | 11927 | return failmsgp("Incorrect type of self (must be 'GKernelPackage' or its derivative)");
| 11928 | cv::GKernelPackage* _self_ = (self1); |  | 11928 | cv::GKernelPackage* _self_ = (self1);
| 11929 | std::size_t retval; |  | 11929 | std::size_t retval;
| 11930 |  |  | 11930 |
| 11931 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11931 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 11932 | { |  | 11932 | {
| 11933 | ERRWRAP2(retval = _self_->size()); |  | 11933 | ERRWRAP2(retval = _self_->size());
| 11934 | return pyopencv_from(retval); |  | 11934 | return pyopencv_from(retval);
| 11935 | } |  | 11935 | }
| 11936 |  |  | 11936 |
| 11937 | return NULL; |  | 11937 | return NULL;
| 11938 | } |  | 11938 | }
| 11939 |  |  | 11939 |
| 11940 |  |  | 11940 |
| 11941 |  |  | 11941 |
| 11942 | // Tables (GKernelPackage) |  | 11942 | // Tables (GKernelPackage)
| 11943 |  |  | 11943 |
| 11944 | static PyGetSetDef pyopencv_GKernelPackage_getseters[] = |  | 11944 | static PyGetSetDef pyopencv_GKernelPackage_getseters[] =
| 11945 | { |  | 11945 | {
| 11946 | {NULL} /* Sentinel */ |  | 11946 | {NULL} /* Sentinel */
| 11947 | }; |  | 11947 | };
| 11948 |  |  | 11948 |
| 11949 | static PyMethodDef pyopencv_GKernelPackage_methods[] = |  | 11949 | static PyMethodDef pyopencv_GKernelPackage_methods[] =
| 11950 | { |  | 11950 | {
| 11951 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_GKernelPackage_size, 0), "size() -> retval\n. * @brief Returns total number of kernels\n. * in the package (across all backends included)\n. *\n. * @return a number of kernels in the package"}, |  | 11951 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_GKernelPackage_size, 0), "size() -> retval\n. * @brief Returns total number of kernels\n. * in the package (across all backends included)\n. *\n. * @return a number of kernels in the package"},
| 11952 |  |  | 11952 |
| 11953 | {NULL, NULL} |  | 11953 | {NULL, NULL}
| 11954 | }; |  | 11954 | };
| 11955 |  |  | 11955 |
| 11956 | // Converter (GKernelPackage) |  | 11956 | // Converter (GKernelPackage)
| 11957 |  |  | 11957 |
| 11958 | template<> |  | 11958 | template<>
| 11959 | struct PyOpenCV_Converter< cv::GKernelPackage > |  | 11959 | struct PyOpenCV_Converter< cv::GKernelPackage >
| 11960 | { |  | 11960 | {
| 11961 | static PyObject* from(const cv::GKernelPackage& r) |  | 11961 | static PyObject* from(const cv::GKernelPackage& r)
| 11962 | { |  | 11962 | {
| 11963 | return pyopencv_GKernelPackage_Instance(r); |  | 11963 | return pyopencv_GKernelPackage_Instance(r);
| 11964 | } |  | 11964 | }
| 11965 | static bool to(PyObject* src, cv::GKernelPackage& dst, const ArgInfo& info) |  | 11965 | static bool to(PyObject* src, cv::GKernelPackage& dst, const ArgInfo& info)
| 11966 | { |  | 11966 | {
| 11967 | if(!src || src == Py_None) |  | 11967 | if(!src || src == Py_None)
| 11968 | return true; |  | 11968 | return true;
| 11969 | cv::GKernelPackage * dst_; |  | 11969 | cv::GKernelPackage * dst_;
| 11970 | if (pyopencv_GKernelPackage_getp(src, dst_)) |  | 11970 | if (pyopencv_GKernelPackage_getp(src, dst_))
| 11971 | { |  | 11971 | {
| 11972 | dst = *dst_; |  | 11972 | dst = *dst_;
| 11973 | return true; |  | 11973 | return true;
| 11974 | } |  | 11974 | }
| 11975 |  |  | 11975 |
| 11976 | failmsg("Expected cv::GKernelPackage for argument '%s'", info.name); |  | 11976 | failmsg("Expected cv::GKernelPackage for argument '%s'", info.name);
| 11977 | return false; |  | 11977 | return false;
| 11978 | } |  | 11978 | }
| 11979 | }; |  | 11979 | };
| 11980 |  |  | 11980 |
| 11981 | //================================================================================ |  | 11981 | //================================================================================
| 11982 | // GMat (Generic) |  | 11982 | // GMat (Generic)
| 11983 | //================================================================================ |  | 11983 | //================================================================================
| 11984 |  |  | 11984 |
| 11985 | // GetSet (GMat) |  | 11985 | // GetSet (GMat)
| 11986 |  |  | 11986 |
| 11987 |  |  | 11987 |
| 11988 |  |  | 11988 |
| 11989 | // Methods (GMat) |  | 11989 | // Methods (GMat)
| 11990 |  |  | 11990 |
| 11991 | static int pyopencv_cv_GMat_GMat(pyopencv_GMat_t* self, PyObject* py_args, PyObject* kw) |  | 11991 | static int pyopencv_cv_GMat_GMat(pyopencv_GMat_t* self, PyObject* py_args, PyObject* kw)
| 11992 | { |  | 11992 | {
| 11993 | using namespace cv; |  | 11993 | using namespace cv;
| 11994 |  |  | 11994 |
| 11995 | pyPrepareArgumentConversionErrorsStorage(2); |  | 11995 | pyPrepareArgumentConversionErrorsStorage(2);
| 11996 |  |  | 11996 |
| 11997 | { |  | 11997 | {
| 11998 |  |  | 11998 |
| 11999 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 11999 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12000 | { |  | 12000 | {
| 12001 | if(self) ERRWRAP2(new (&(self->v)) cv::GMat()); |  | 12001 | if(self) ERRWRAP2(new (&(self->v)) cv::GMat());
| 12002 | return 0; |  | 12002 | return 0;
| 12003 | } |  | 12003 | }
| 12004 |  |  | 12004 |
| 12005 |  |  | 12005 |
| 12006 | pyPopulateArgumentConversionErrors(); |  | 12006 | pyPopulateArgumentConversionErrors();
| 12007 | } |  | 12007 | }
| 12008 |  |  | 12008 |
| 12009 |  |  | 12009 |
| 12010 | { |  | 12010 | {
| 12011 | PyObject* pyobj_m = NULL; |  | 12011 | PyObject* pyobj_m = NULL;
| 12012 | Mat m; |  | 12012 | Mat m;
| 12013 |  |  | 12013 |
| 12014 | const char* keywords[] = { "m", NULL }; |  | 12014 | const char* keywords[] = { "m", NULL };
| 12015 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMat", (char**)keywords, &pyobj_m) && |  | 12015 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMat", (char**)keywords, &pyobj_m) &&
| 12016 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) ) |  | 12016 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) )
| 12017 | { |  | 12017 | {
| 12018 | if(self) ERRWRAP2(new (&(self->v)) cv::GMat(m)); |  | 12018 | if(self) ERRWRAP2(new (&(self->v)) cv::GMat(m));
| 12019 | return 0; |  | 12019 | return 0;
| 12020 | } |  | 12020 | }
| 12021 |  |  | 12021 |
| 12022 |  |  | 12022 |
| 12023 | pyPopulateArgumentConversionErrors(); |  | 12023 | pyPopulateArgumentConversionErrors();
| 12024 | } |  | 12024 | }
| 12025 | pyRaiseCVOverloadException("GMat"); |  | 12025 | pyRaiseCVOverloadException("GMat");
| 12026 |  |  | 12026 |
| 12027 | return -1; |  | 12027 | return -1;
| 12028 | } |  | 12028 | }
| 12029 |  |  | 12029 |
| 12030 |  |  | 12030 |
| 12031 |  |  | 12031 |
| 12032 | // Tables (GMat) |  | 12032 | // Tables (GMat)
| 12033 |  |  | 12033 |
| 12034 | static PyGetSetDef pyopencv_GMat_getseters[] = |  | 12034 | static PyGetSetDef pyopencv_GMat_getseters[] =
| 12035 | { |  | 12035 | {
| 12036 | {NULL} /* Sentinel */ |  | 12036 | {NULL} /* Sentinel */
| 12037 | }; |  | 12037 | };
| 12038 |  |  | 12038 |
| 12039 | static PyMethodDef pyopencv_GMat_methods[] = |  | 12039 | static PyMethodDef pyopencv_GMat_methods[] =
| 12040 | { |  | 12040 | {
| 12041 |  |  | 12041 |
| 12042 | {NULL, NULL} |  | 12042 | {NULL, NULL}
| 12043 | }; |  | 12043 | };
| 12044 |  |  | 12044 |
| 12045 | // Converter (GMat) |  | 12045 | // Converter (GMat)
| 12046 |  |  | 12046 |
| 12047 | template<> |  | 12047 | template<>
| 12048 | struct PyOpenCV_Converter< cv::GMat > |  | 12048 | struct PyOpenCV_Converter< cv::GMat >
| 12049 | { |  | 12049 | {
| 12050 | static PyObject* from(const cv::GMat& r) |  | 12050 | static PyObject* from(const cv::GMat& r)
| 12051 | { |  | 12051 | {
| 12052 | return pyopencv_GMat_Instance(r); |  | 12052 | return pyopencv_GMat_Instance(r);
| 12053 | } |  | 12053 | }
| 12054 | static bool to(PyObject* src, cv::GMat& dst, const ArgInfo& info) |  | 12054 | static bool to(PyObject* src, cv::GMat& dst, const ArgInfo& info)
| 12055 | { |  | 12055 | {
| 12056 | if(!src || src == Py_None) |  | 12056 | if(!src || src == Py_None)
| 12057 | return true; |  | 12057 | return true;
| 12058 | cv::GMat * dst_; |  | 12058 | cv::GMat * dst_;
| 12059 | if (pyopencv_GMat_getp(src, dst_)) |  | 12059 | if (pyopencv_GMat_getp(src, dst_))
| 12060 | { |  | 12060 | {
| 12061 | dst = *dst_; |  | 12061 | dst = *dst_;
| 12062 | return true; |  | 12062 | return true;
| 12063 | } |  | 12063 | }
| 12064 |  |  | 12064 |
| 12065 | failmsg("Expected cv::GMat for argument '%s'", info.name); |  | 12065 | failmsg("Expected cv::GMat for argument '%s'", info.name);
| 12066 | return false; |  | 12066 | return false;
| 12067 | } |  | 12067 | }
| 12068 | }; |  | 12068 | };
| 12069 |  |  | 12069 |
| 12070 | //================================================================================ |  | 12070 | //================================================================================
| 12071 | // GMatDesc (Generic) |  | 12071 | // GMatDesc (Generic)
| 12072 | //================================================================================ |  | 12072 | //================================================================================
| 12073 |  |  | 12073 |
| 12074 | // GetSet (GMatDesc) |  | 12074 | // GetSet (GMatDesc)
| 12075 |  |  | 12075 |
| 12076 |  |  | 12076 |
| 12077 | static PyObject* pyopencv_GMatDesc_get_chan(pyopencv_GMatDesc_t* p, void *closure) |  | 12077 | static PyObject* pyopencv_GMatDesc_get_chan(pyopencv_GMatDesc_t* p, void *closure)
| 12078 | { |  | 12078 | {
| 12079 | return pyopencv_from(p->v.chan); |  | 12079 | return pyopencv_from(p->v.chan);
| 12080 | } |  | 12080 | }
| 12081 |  |  | 12081 |
| 12082 | static PyObject* pyopencv_GMatDesc_get_depth(pyopencv_GMatDesc_t* p, void *closure) |  | 12082 | static PyObject* pyopencv_GMatDesc_get_depth(pyopencv_GMatDesc_t* p, void *closure)
| 12083 | { |  | 12083 | {
| 12084 | return pyopencv_from(p->v.depth); |  | 12084 | return pyopencv_from(p->v.depth);
| 12085 | } |  | 12085 | }
| 12086 |  |  | 12086 |
| 12087 | static PyObject* pyopencv_GMatDesc_get_dims(pyopencv_GMatDesc_t* p, void *closure) |  | 12087 | static PyObject* pyopencv_GMatDesc_get_dims(pyopencv_GMatDesc_t* p, void *closure)
| 12088 | { |  | 12088 | {
| 12089 | return pyopencv_from(p->v.dims); |  | 12089 | return pyopencv_from(p->v.dims);
| 12090 | } |  | 12090 | }
| 12091 |  |  | 12091 |
| 12092 | static PyObject* pyopencv_GMatDesc_get_planar(pyopencv_GMatDesc_t* p, void *closure) |  | 12092 | static PyObject* pyopencv_GMatDesc_get_planar(pyopencv_GMatDesc_t* p, void *closure)
| 12093 | { |  | 12093 | {
| 12094 | return pyopencv_from(p->v.planar); |  | 12094 | return pyopencv_from(p->v.planar);
| 12095 | } |  | 12095 | }
| 12096 |  |  | 12096 |
| 12097 | static PyObject* pyopencv_GMatDesc_get_size(pyopencv_GMatDesc_t* p, void *closure) |  | 12097 | static PyObject* pyopencv_GMatDesc_get_size(pyopencv_GMatDesc_t* p, void *closure)
| 12098 | { |  | 12098 | {
| 12099 | return pyopencv_from(p->v.size); |  | 12099 | return pyopencv_from(p->v.size);
| 12100 | } |  | 12100 | }
| 12101 |  |  | 12101 |
| 12102 |  |  | 12102 |
| 12103 | // Methods (GMatDesc) |  | 12103 | // Methods (GMatDesc)
| 12104 |  |  | 12104 |
| 12105 | static int pyopencv_cv_GMatDesc_GMatDesc(pyopencv_GMatDesc_t* self, PyObject* py_args, PyObject* kw) |  | 12105 | static int pyopencv_cv_GMatDesc_GMatDesc(pyopencv_GMatDesc_t* self, PyObject* py_args, PyObject* kw)
| 12106 | { |  | 12106 | {
| 12107 | using namespace cv; |  | 12107 | using namespace cv;
| 12108 |  |  | 12108 |
| 12109 | pyPrepareArgumentConversionErrorsStorage(4); |  | 12109 | pyPrepareArgumentConversionErrorsStorage(4);
| 12110 |  |  | 12110 |
| 12111 | { |  | 12111 | {
| 12112 | PyObject* pyobj_d = NULL; |  | 12112 | PyObject* pyobj_d = NULL;
| 12113 | int d=0; |  | 12113 | int d=0;
| 12114 | PyObject* pyobj_c = NULL; |  | 12114 | PyObject* pyobj_c = NULL;
| 12115 | int c=0; |  | 12115 | int c=0;
| 12116 | PyObject* pyobj_s = NULL; |  | 12116 | PyObject* pyobj_s = NULL;
| 12117 | Size s; |  | 12117 | Size s;
| 12118 | PyObject* pyobj_p = NULL; |  | 12118 | PyObject* pyobj_p = NULL;
| 12119 | bool p=false; |  | 12119 | bool p=false;
| 12120 |  |  | 12120 |
| 12121 | const char* keywords[] = { "d", "c", "s", "p", NULL }; |  | 12121 | const char* keywords[] = { "d", "c", "s", "p", NULL };
| 12122 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GMatDesc", (char**)keywords, &pyobj_d, &pyobj_c, &pyobj_s, &pyobj_p) && |  | 12122 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GMatDesc", (char**)keywords, &pyobj_d, &pyobj_c, &pyobj_s, &pyobj_p) &&
| 12123 | pyopencv_to_safe(pyobj_d, d, ArgInfo("d", 0)) && |  | 12123 | pyopencv_to_safe(pyobj_d, d, ArgInfo("d", 0)) &&
| 12124 | pyopencv_to_safe(pyobj_c, c, ArgInfo("c", 0)) && |  | 12124 | pyopencv_to_safe(pyobj_c, c, ArgInfo("c", 0)) &&
| 12125 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 12125 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 12126 | pyopencv_to_safe(pyobj_p, p, ArgInfo("p", 0)) ) |  | 12126 | pyopencv_to_safe(pyobj_p, p, ArgInfo("p", 0)) )
| 12127 | { |  | 12127 | {
| 12128 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc(d, c, s, p)); |  | 12128 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc(d, c, s, p));
| 12129 | return 0; |  | 12129 | return 0;
| 12130 | } |  | 12130 | }
| 12131 |  |  | 12131 |
| 12132 |  |  | 12132 |
| 12133 | pyPopulateArgumentConversionErrors(); |  | 12133 | pyPopulateArgumentConversionErrors();
| 12134 | } |  | 12134 | }
| 12135 |  |  | 12135 |
| 12136 |  |  | 12136 |
| 12137 | { |  | 12137 | {
| 12138 | PyObject* pyobj_d = NULL; |  | 12138 | PyObject* pyobj_d = NULL;
| 12139 | int d=0; |  | 12139 | int d=0;
| 12140 | PyObject* pyobj_dd = NULL; |  | 12140 | PyObject* pyobj_dd = NULL;
| 12141 | vector_int dd; |  | 12141 | vector_int dd;
| 12142 |  |  | 12142 |
| 12143 | const char* keywords[] = { "d", "dd", NULL }; |  | 12143 | const char* keywords[] = { "d", "dd", NULL };
| 12144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc", (char**)keywords, &pyobj_d, &pyobj_dd) && |  | 12144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc", (char**)keywords, &pyobj_d, &pyobj_dd) &&
| 12145 | pyopencv_to_safe(pyobj_d, d, ArgInfo("d", 0)) && |  | 12145 | pyopencv_to_safe(pyobj_d, d, ArgInfo("d", 0)) &&
| 12146 | pyopencv_to_safe(pyobj_dd, dd, ArgInfo("dd", 0)) ) |  | 12146 | pyopencv_to_safe(pyobj_dd, dd, ArgInfo("dd", 0)) )
| 12147 | { |  | 12147 | {
| 12148 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc(d, dd)); |  | 12148 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc(d, dd));
| 12149 | return 0; |  | 12149 | return 0;
| 12150 | } |  | 12150 | }
| 12151 |  |  | 12151 |
| 12152 |  |  | 12152 |
| 12153 | pyPopulateArgumentConversionErrors(); |  | 12153 | pyPopulateArgumentConversionErrors();
| 12154 | } |  | 12154 | }
| 12155 |  |  | 12155 |
| 12156 |  |  | 12156 |
| 12157 | { |  | 12157 | {
| 12158 | PyObject* pyobj_d = NULL; |  | 12158 | PyObject* pyobj_d = NULL;
| 12159 | int d=0; |  | 12159 | int d=0;
| 12160 | PyObject* pyobj_dd = NULL; |  | 12160 | PyObject* pyobj_dd = NULL;
| 12161 | vector_int dd; |  | 12161 | vector_int dd;
| 12162 |  |  | 12162 |
| 12163 | const char* keywords[] = { "d", "dd", NULL }; |  | 12163 | const char* keywords[] = { "d", "dd", NULL };
| 12164 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc", (char**)keywords, &pyobj_d, &pyobj_dd) && |  | 12164 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc", (char**)keywords, &pyobj_d, &pyobj_dd) &&
| 12165 | pyopencv_to_safe(pyobj_d, d, ArgInfo("d", 0)) && |  | 12165 | pyopencv_to_safe(pyobj_d, d, ArgInfo("d", 0)) &&
| 12166 | pyopencv_to_safe(pyobj_dd, dd, ArgInfo("dd", 0)) ) |  | 12166 | pyopencv_to_safe(pyobj_dd, dd, ArgInfo("dd", 0)) )
| 12167 | { |  | 12167 | {
| 12168 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc(d, std::move(dd))); |  | 12168 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc(d, std::move(dd)));
| 12169 | return 0; |  | 12169 | return 0;
| 12170 | } |  | 12170 | }
| 12171 |  |  | 12171 |
| 12172 |  |  | 12172 |
| 12173 | pyPopulateArgumentConversionErrors(); |  | 12173 | pyPopulateArgumentConversionErrors();
| 12174 | } |  | 12174 | }
| 12175 |  |  | 12175 |
| 12176 |  |  | 12176 |
| 12177 | { |  | 12177 | {
| 12178 |  |  | 12178 |
| 12179 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12179 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12180 | { |  | 12180 | {
| 12181 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc()); |  | 12181 | if(self) ERRWRAP2(new (&(self->v)) cv::GMatDesc());
| 12182 | return 0; |  | 12182 | return 0;
| 12183 | } |  | 12183 | }
| 12184 |  |  | 12184 |
| 12185 |  |  | 12185 |
| 12186 | pyPopulateArgumentConversionErrors(); |  | 12186 | pyPopulateArgumentConversionErrors();
| 12187 | } |  | 12187 | }
| 12188 | pyRaiseCVOverloadException("GMatDesc"); |  | 12188 | pyRaiseCVOverloadException("GMatDesc");
| 12189 |  |  | 12189 |
| 12190 | return -1; |  | 12190 | return -1;
| 12191 | } |  | 12191 | }
| 12192 |  |  | 12192 |
| 12193 | static PyObject* pyopencv_cv_GMatDesc_asInterleaved(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12193 | static PyObject* pyopencv_cv_GMatDesc_asInterleaved(PyObject* self, PyObject* py_args, PyObject* kw)
| 12194 | { |  | 12194 | {
| 12195 | using namespace cv; |  | 12195 | using namespace cv;
| 12196 |  |  | 12196 |
| 12197 |  |  | 12197 |
| 12198 | cv::GMatDesc * self1 = 0; |  | 12198 | cv::GMatDesc * self1 = 0;
| 12199 | if (!pyopencv_GMatDesc_getp(self, self1)) |  | 12199 | if (!pyopencv_GMatDesc_getp(self, self1))
| 12200 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)"); |  | 12200 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)");
| 12201 | cv::GMatDesc* _self_ = (self1); |  | 12201 | cv::GMatDesc* _self_ = (self1);
| 12202 | GMatDesc retval; |  | 12202 | GMatDesc retval;
| 12203 |  |  | 12203 |
| 12204 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12204 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12205 | { |  | 12205 | {
| 12206 | ERRWRAP2(retval = _self_->asInterleaved()); |  | 12206 | ERRWRAP2(retval = _self_->asInterleaved());
| 12207 | return pyopencv_from(retval); |  | 12207 | return pyopencv_from(retval);
| 12208 | } |  | 12208 | }
| 12209 |  |  | 12209 |
| 12210 | return NULL; |  | 12210 | return NULL;
| 12211 | } |  | 12211 | }
| 12212 |  |  | 12212 |
| 12213 | static PyObject* pyopencv_cv_GMatDesc_asPlanar(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12213 | static PyObject* pyopencv_cv_GMatDesc_asPlanar(PyObject* self, PyObject* py_args, PyObject* kw)
| 12214 | { |  | 12214 | {
| 12215 | using namespace cv; |  | 12215 | using namespace cv;
| 12216 |  |  | 12216 |
| 12217 |  |  | 12217 |
| 12218 | cv::GMatDesc * self1 = 0; |  | 12218 | cv::GMatDesc * self1 = 0;
| 12219 | if (!pyopencv_GMatDesc_getp(self, self1)) |  | 12219 | if (!pyopencv_GMatDesc_getp(self, self1))
| 12220 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)"); |  | 12220 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)");
| 12221 | cv::GMatDesc* _self_ = (self1); |  | 12221 | cv::GMatDesc* _self_ = (self1);
| 12222 | pyPrepareArgumentConversionErrorsStorage(2); |  | 12222 | pyPrepareArgumentConversionErrorsStorage(2);
| 12223 |  |  | 12223 |
| 12224 | { |  | 12224 | {
| 12225 | GMatDesc retval; |  | 12225 | GMatDesc retval;
| 12226 |  |  | 12226 |
| 12227 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12227 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12228 | { |  | 12228 | {
| 12229 | ERRWRAP2(retval = _self_->asPlanar()); |  | 12229 | ERRWRAP2(retval = _self_->asPlanar());
| 12230 | return pyopencv_from(retval); |  | 12230 | return pyopencv_from(retval);
| 12231 | } |  | 12231 | }
| 12232 |  |  | 12232 |
| 12233 |  |  | 12233 |
| 12234 | pyPopulateArgumentConversionErrors(); |  | 12234 | pyPopulateArgumentConversionErrors();
| 12235 | } |  | 12235 | }
| 12236 |  |  | 12236 |
| 12237 |  |  | 12237 |
| 12238 | { |  | 12238 | {
| 12239 | PyObject* pyobj_planes = NULL; |  | 12239 | PyObject* pyobj_planes = NULL;
| 12240 | int planes=0; |  | 12240 | int planes=0;
| 12241 | GMatDesc retval; |  | 12241 | GMatDesc retval;
| 12242 |  |  | 12242 |
| 12243 | const char* keywords[] = { "planes", NULL }; |  | 12243 | const char* keywords[] = { "planes", NULL };
| 12244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.asPlanar", (char**)keywords, &pyobj_planes) && |  | 12244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.asPlanar", (char**)keywords, &pyobj_planes) &&
| 12245 | pyopencv_to_safe(pyobj_planes, planes, ArgInfo("planes", 0)) ) |  | 12245 | pyopencv_to_safe(pyobj_planes, planes, ArgInfo("planes", 0)) )
| 12246 | { |  | 12246 | {
| 12247 | ERRWRAP2(retval = _self_->asPlanar(planes)); |  | 12247 | ERRWRAP2(retval = _self_->asPlanar(planes));
| 12248 | return pyopencv_from(retval); |  | 12248 | return pyopencv_from(retval);
| 12249 | } |  | 12249 | }
| 12250 |  |  | 12250 |
| 12251 |  |  | 12251 |
| 12252 | pyPopulateArgumentConversionErrors(); |  | 12252 | pyPopulateArgumentConversionErrors();
| 12253 | } |  | 12253 | }
| 12254 | pyRaiseCVOverloadException("asPlanar"); |  | 12254 | pyRaiseCVOverloadException("asPlanar");
| 12255 |  |  | 12255 |
| 12256 | return NULL; |  | 12256 | return NULL;
| 12257 | } |  | 12257 | }
| 12258 |  |  | 12258 |
| 12259 | static PyObject* pyopencv_cv_GMatDesc_withDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12259 | static PyObject* pyopencv_cv_GMatDesc_withDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 12260 | { |  | 12260 | {
| 12261 | using namespace cv; |  | 12261 | using namespace cv;
| 12262 |  |  | 12262 |
| 12263 |  |  | 12263 |
| 12264 | cv::GMatDesc * self1 = 0; |  | 12264 | cv::GMatDesc * self1 = 0;
| 12265 | if (!pyopencv_GMatDesc_getp(self, self1)) |  | 12265 | if (!pyopencv_GMatDesc_getp(self, self1))
| 12266 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)"); |  | 12266 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)");
| 12267 | cv::GMatDesc* _self_ = (self1); |  | 12267 | cv::GMatDesc* _self_ = (self1);
| 12268 | PyObject* pyobj_ddepth = NULL; |  | 12268 | PyObject* pyobj_ddepth = NULL;
| 12269 | int ddepth=0; |  | 12269 | int ddepth=0;
| 12270 | GMatDesc retval; |  | 12270 | GMatDesc retval;
| 12271 |  |  | 12271 |
| 12272 | const char* keywords[] = { "ddepth", NULL }; |  | 12272 | const char* keywords[] = { "ddepth", NULL };
| 12273 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.withDepth", (char**)keywords, &pyobj_ddepth) && |  | 12273 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.withDepth", (char**)keywords, &pyobj_ddepth) &&
| 12274 | pyopencv_to_safe(pyobj_ddepth, ddepth, ArgInfo("ddepth", 0)) ) |  | 12274 | pyopencv_to_safe(pyobj_ddepth, ddepth, ArgInfo("ddepth", 0)) )
| 12275 | { |  | 12275 | {
| 12276 | ERRWRAP2(retval = _self_->withDepth(ddepth)); |  | 12276 | ERRWRAP2(retval = _self_->withDepth(ddepth));
| 12277 | return pyopencv_from(retval); |  | 12277 | return pyopencv_from(retval);
| 12278 | } |  | 12278 | }
| 12279 |  |  | 12279 |
| 12280 | return NULL; |  | 12280 | return NULL;
| 12281 | } |  | 12281 | }
| 12282 |  |  | 12282 |
| 12283 | static PyObject* pyopencv_cv_GMatDesc_withSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12283 | static PyObject* pyopencv_cv_GMatDesc_withSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 12284 | { |  | 12284 | {
| 12285 | using namespace cv; |  | 12285 | using namespace cv;
| 12286 |  |  | 12286 |
| 12287 |  |  | 12287 |
| 12288 | cv::GMatDesc * self1 = 0; |  | 12288 | cv::GMatDesc * self1 = 0;
| 12289 | if (!pyopencv_GMatDesc_getp(self, self1)) |  | 12289 | if (!pyopencv_GMatDesc_getp(self, self1))
| 12290 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)"); |  | 12290 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)");
| 12291 | cv::GMatDesc* _self_ = (self1); |  | 12291 | cv::GMatDesc* _self_ = (self1);
| 12292 | PyObject* pyobj_sz = NULL; |  | 12292 | PyObject* pyobj_sz = NULL;
| 12293 | Size sz; |  | 12293 | Size sz;
| 12294 | GMatDesc retval; |  | 12294 | GMatDesc retval;
| 12295 |  |  | 12295 |
| 12296 | const char* keywords[] = { "sz", NULL }; |  | 12296 | const char* keywords[] = { "sz", NULL };
| 12297 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.withSize", (char**)keywords, &pyobj_sz) && |  | 12297 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.withSize", (char**)keywords, &pyobj_sz) &&
| 12298 | pyopencv_to_safe(pyobj_sz, sz, ArgInfo("sz", 0)) ) |  | 12298 | pyopencv_to_safe(pyobj_sz, sz, ArgInfo("sz", 0)) )
| 12299 | { |  | 12299 | {
| 12300 | ERRWRAP2(retval = _self_->withSize(sz)); |  | 12300 | ERRWRAP2(retval = _self_->withSize(sz));
| 12301 | return pyopencv_from(retval); |  | 12301 | return pyopencv_from(retval);
| 12302 | } |  | 12302 | }
| 12303 |  |  | 12303 |
| 12304 | return NULL; |  | 12304 | return NULL;
| 12305 | } |  | 12305 | }
| 12306 |  |  | 12306 |
| 12307 | static PyObject* pyopencv_cv_GMatDesc_withSizeDelta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12307 | static PyObject* pyopencv_cv_GMatDesc_withSizeDelta(PyObject* self, PyObject* py_args, PyObject* kw)
| 12308 | { |  | 12308 | {
| 12309 | using namespace cv; |  | 12309 | using namespace cv;
| 12310 |  |  | 12310 |
| 12311 |  |  | 12311 |
| 12312 | cv::GMatDesc * self1 = 0; |  | 12312 | cv::GMatDesc * self1 = 0;
| 12313 | if (!pyopencv_GMatDesc_getp(self, self1)) |  | 12313 | if (!pyopencv_GMatDesc_getp(self, self1))
| 12314 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)"); |  | 12314 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)");
| 12315 | cv::GMatDesc* _self_ = (self1); |  | 12315 | cv::GMatDesc* _self_ = (self1);
| 12316 | pyPrepareArgumentConversionErrorsStorage(2); |  | 12316 | pyPrepareArgumentConversionErrorsStorage(2);
| 12317 |  |  | 12317 |
| 12318 | { |  | 12318 | {
| 12319 | PyObject* pyobj_delta = NULL; |  | 12319 | PyObject* pyobj_delta = NULL;
| 12320 | Size delta; |  | 12320 | Size delta;
| 12321 | GMatDesc retval; |  | 12321 | GMatDesc retval;
| 12322 |  |  | 12322 |
| 12323 | const char* keywords[] = { "delta", NULL }; |  | 12323 | const char* keywords[] = { "delta", NULL };
| 12324 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.withSizeDelta", (char**)keywords, &pyobj_delta) && |  | 12324 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GMatDesc.withSizeDelta", (char**)keywords, &pyobj_delta) &&
| 12325 | pyopencv_to_safe(pyobj_delta, delta, ArgInfo("delta", 0)) ) |  | 12325 | pyopencv_to_safe(pyobj_delta, delta, ArgInfo("delta", 0)) )
| 12326 | { |  | 12326 | {
| 12327 | ERRWRAP2(retval = _self_->withSizeDelta(delta)); |  | 12327 | ERRWRAP2(retval = _self_->withSizeDelta(delta));
| 12328 | return pyopencv_from(retval); |  | 12328 | return pyopencv_from(retval);
| 12329 | } |  | 12329 | }
| 12330 |  |  | 12330 |
| 12331 |  |  | 12331 |
| 12332 | pyPopulateArgumentConversionErrors(); |  | 12332 | pyPopulateArgumentConversionErrors();
| 12333 | } |  | 12333 | }
| 12334 |  |  | 12334 |
| 12335 |  |  | 12335 |
| 12336 | { |  | 12336 | {
| 12337 | PyObject* pyobj_dx = NULL; |  | 12337 | PyObject* pyobj_dx = NULL;
| 12338 | int dx=0; |  | 12338 | int dx=0;
| 12339 | PyObject* pyobj_dy = NULL; |  | 12339 | PyObject* pyobj_dy = NULL;
| 12340 | int dy=0; |  | 12340 | int dy=0;
| 12341 | GMatDesc retval; |  | 12341 | GMatDesc retval;
| 12342 |  |  | 12342 |
| 12343 | const char* keywords[] = { "dx", "dy", NULL }; |  | 12343 | const char* keywords[] = { "dx", "dy", NULL };
| 12344 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc.withSizeDelta", (char**)keywords, &pyobj_dx, &pyobj_dy) && |  | 12344 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc.withSizeDelta", (char**)keywords, &pyobj_dx, &pyobj_dy) &&
| 12345 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) && |  | 12345 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) &&
| 12346 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) ) |  | 12346 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) )
| 12347 | { |  | 12347 | {
| 12348 | ERRWRAP2(retval = _self_->withSizeDelta(dx, dy)); |  | 12348 | ERRWRAP2(retval = _self_->withSizeDelta(dx, dy));
| 12349 | return pyopencv_from(retval); |  | 12349 | return pyopencv_from(retval);
| 12350 | } |  | 12350 | }
| 12351 |  |  | 12351 |
| 12352 |  |  | 12352 |
| 12353 | pyPopulateArgumentConversionErrors(); |  | 12353 | pyPopulateArgumentConversionErrors();
| 12354 | } |  | 12354 | }
| 12355 | pyRaiseCVOverloadException("withSizeDelta"); |  | 12355 | pyRaiseCVOverloadException("withSizeDelta");
| 12356 |  |  | 12356 |
| 12357 | return NULL; |  | 12357 | return NULL;
| 12358 | } |  | 12358 | }
| 12359 |  |  | 12359 |
| 12360 | static PyObject* pyopencv_cv_GMatDesc_withType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12360 | static PyObject* pyopencv_cv_GMatDesc_withType(PyObject* self, PyObject* py_args, PyObject* kw)
| 12361 | { |  | 12361 | {
| 12362 | using namespace cv; |  | 12362 | using namespace cv;
| 12363 |  |  | 12363 |
| 12364 |  |  | 12364 |
| 12365 | cv::GMatDesc * self1 = 0; |  | 12365 | cv::GMatDesc * self1 = 0;
| 12366 | if (!pyopencv_GMatDesc_getp(self, self1)) |  | 12366 | if (!pyopencv_GMatDesc_getp(self, self1))
| 12367 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)"); |  | 12367 | return failmsgp("Incorrect type of self (must be 'GMatDesc' or its derivative)");
| 12368 | cv::GMatDesc* _self_ = (self1); |  | 12368 | cv::GMatDesc* _self_ = (self1);
| 12369 | PyObject* pyobj_ddepth = NULL; |  | 12369 | PyObject* pyobj_ddepth = NULL;
| 12370 | int ddepth=0; |  | 12370 | int ddepth=0;
| 12371 | PyObject* pyobj_dchan = NULL; |  | 12371 | PyObject* pyobj_dchan = NULL;
| 12372 | int dchan=0; |  | 12372 | int dchan=0;
| 12373 | GMatDesc retval; |  | 12373 | GMatDesc retval;
| 12374 |  |  | 12374 |
| 12375 | const char* keywords[] = { "ddepth", "dchan", NULL }; |  | 12375 | const char* keywords[] = { "ddepth", "dchan", NULL };
| 12376 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc.withType", (char**)keywords, &pyobj_ddepth, &pyobj_dchan) && |  | 12376 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GMatDesc.withType", (char**)keywords, &pyobj_ddepth, &pyobj_dchan) &&
| 12377 | pyopencv_to_safe(pyobj_ddepth, ddepth, ArgInfo("ddepth", 0)) && |  | 12377 | pyopencv_to_safe(pyobj_ddepth, ddepth, ArgInfo("ddepth", 0)) &&
| 12378 | pyopencv_to_safe(pyobj_dchan, dchan, ArgInfo("dchan", 0)) ) |  | 12378 | pyopencv_to_safe(pyobj_dchan, dchan, ArgInfo("dchan", 0)) )
| 12379 | { |  | 12379 | {
| 12380 | ERRWRAP2(retval = _self_->withType(ddepth, dchan)); |  | 12380 | ERRWRAP2(retval = _self_->withType(ddepth, dchan));
| 12381 | return pyopencv_from(retval); |  | 12381 | return pyopencv_from(retval);
| 12382 | } |  | 12382 | }
| 12383 |  |  | 12383 |
| 12384 | return NULL; |  | 12384 | return NULL;
| 12385 | } |  | 12385 | }
| 12386 |  |  | 12386 |
| 12387 |  |  | 12387 |
| 12388 |  |  | 12388 |
| 12389 | // Tables (GMatDesc) |  | 12389 | // Tables (GMatDesc)
| 12390 |  |  | 12390 |
| 12391 | static PyGetSetDef pyopencv_GMatDesc_getseters[] = |  | 12391 | static PyGetSetDef pyopencv_GMatDesc_getseters[] =
| 12392 | { |  | 12392 | {
| 12393 | {(char*)"chan", (getter)pyopencv_GMatDesc_get_chan, NULL, (char*)"chan", NULL}, |  | 12393 | {(char*)"chan", (getter)pyopencv_GMatDesc_get_chan, NULL, (char*)"chan", NULL},
| 12394 | {(char*)"depth", (getter)pyopencv_GMatDesc_get_depth, NULL, (char*)"depth", NULL}, |  | 12394 | {(char*)"depth", (getter)pyopencv_GMatDesc_get_depth, NULL, (char*)"depth", NULL},
| 12395 | {(char*)"dims", (getter)pyopencv_GMatDesc_get_dims, NULL, (char*)"dims", NULL}, |  | 12395 | {(char*)"dims", (getter)pyopencv_GMatDesc_get_dims, NULL, (char*)"dims", NULL},
| 12396 | {(char*)"planar", (getter)pyopencv_GMatDesc_get_planar, NULL, (char*)"planar", NULL}, |  | 12396 | {(char*)"planar", (getter)pyopencv_GMatDesc_get_planar, NULL, (char*)"planar", NULL},
| 12397 | {(char*)"size", (getter)pyopencv_GMatDesc_get_size, NULL, (char*)"size", NULL}, |  | 12397 | {(char*)"size", (getter)pyopencv_GMatDesc_get_size, NULL, (char*)"size", NULL},
| 12398 | {NULL} /* Sentinel */ |  | 12398 | {NULL} /* Sentinel */
| 12399 | }; |  | 12399 | };
| 12400 |  |  | 12400 |
| 12401 | static PyMethodDef pyopencv_GMatDesc_methods[] = |  | 12401 | static PyMethodDef pyopencv_GMatDesc_methods[] =
| 12402 | { |  | 12402 | {
| 12403 | {"asInterleaved", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_asInterleaved, 0), "asInterleaved() -> retval\n."}, |  | 12403 | {"asInterleaved", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_asInterleaved, 0), "asInterleaved() -> retval\n."},
| 12404 | {"asPlanar", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_asPlanar, 0), "asPlanar() -> retval\n. \n\n\n\nasPlanar(planes) -> retval\n."}, |  | 12404 | {"asPlanar", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_asPlanar, 0), "asPlanar() -> retval\n. \n\n\n\nasPlanar(planes) -> retval\n."},
| 12405 | {"withDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withDepth, 0), "withDepth(ddepth) -> retval\n."}, |  | 12405 | {"withDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withDepth, 0), "withDepth(ddepth) -> retval\n."},
| 12406 | {"withSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withSize, 0), "withSize(sz) -> retval\n."}, |  | 12406 | {"withSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withSize, 0), "withSize(sz) -> retval\n."},
| 12407 | {"withSizeDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withSizeDelta, 0), "withSizeDelta(delta) -> retval\n. \n\n\n\nwithSizeDelta(dx, dy) -> retval\n."}, |  | 12407 | {"withSizeDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withSizeDelta, 0), "withSizeDelta(delta) -> retval\n. \n\n\n\nwithSizeDelta(dx, dy) -> retval\n."},
| 12408 | {"withType", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withType, 0), "withType(ddepth, dchan) -> retval\n."}, |  | 12408 | {"withType", CV_PY_FN_WITH_KW_(pyopencv_cv_GMatDesc_withType, 0), "withType(ddepth, dchan) -> retval\n."},
| 12409 |  |  | 12409 |
| 12410 | {NULL, NULL} |  | 12410 | {NULL, NULL}
| 12411 | }; |  | 12411 | };
| 12412 |  |  | 12412 |
| 12413 | // Converter (GMatDesc) |  | 12413 | // Converter (GMatDesc)
| 12414 |  |  | 12414 |
| 12415 | template<> |  | 12415 | template<>
| 12416 | struct PyOpenCV_Converter< cv::GMatDesc > |  | 12416 | struct PyOpenCV_Converter< cv::GMatDesc >
| 12417 | { |  | 12417 | {
| 12418 | static PyObject* from(const cv::GMatDesc& r) |  | 12418 | static PyObject* from(const cv::GMatDesc& r)
| 12419 | { |  | 12419 | {
| 12420 | return pyopencv_GMatDesc_Instance(r); |  | 12420 | return pyopencv_GMatDesc_Instance(r);
| 12421 | } |  | 12421 | }
| 12422 | static bool to(PyObject* src, cv::GMatDesc& dst, const ArgInfo& info) |  | 12422 | static bool to(PyObject* src, cv::GMatDesc& dst, const ArgInfo& info)
| 12423 | { |  | 12423 | {
| 12424 | if(!src || src == Py_None) |  | 12424 | if(!src || src == Py_None)
| 12425 | return true; |  | 12425 | return true;
| 12426 | cv::GMatDesc * dst_; |  | 12426 | cv::GMatDesc * dst_;
| 12427 | if (pyopencv_GMatDesc_getp(src, dst_)) |  | 12427 | if (pyopencv_GMatDesc_getp(src, dst_))
| 12428 | { |  | 12428 | {
| 12429 | dst = *dst_; |  | 12429 | dst = *dst_;
| 12430 | return true; |  | 12430 | return true;
| 12431 | } |  | 12431 | }
| 12432 |  |  | 12432 |
| 12433 | failmsg("Expected cv::GMatDesc for argument '%s'", info.name); |  | 12433 | failmsg("Expected cv::GMatDesc for argument '%s'", info.name);
| 12434 | return false; |  | 12434 | return false;
| 12435 | } |  | 12435 | }
| 12436 | }; |  | 12436 | };
| 12437 |  |  | 12437 |
| 12438 | //================================================================================ |  | 12438 | //================================================================================
| 12439 | // GOpaqueDesc (Generic) |  | 12439 | // GOpaqueDesc (Generic)
| 12440 | //================================================================================ |  | 12440 | //================================================================================
| 12441 |  |  | 12441 |
| 12442 | // GetSet (GOpaqueDesc) |  | 12442 | // GetSet (GOpaqueDesc)
| 12443 |  |  | 12443 |
| 12444 |  |  | 12444 |
| 12445 |  |  | 12445 |
| 12446 | // Methods (GOpaqueDesc) |  | 12446 | // Methods (GOpaqueDesc)
| 12447 |  |  | 12447 |
| 12448 |  |  | 12448 |
| 12449 |  |  | 12449 |
| 12450 | // Tables (GOpaqueDesc) |  | 12450 | // Tables (GOpaqueDesc)
| 12451 |  |  | 12451 |
| 12452 | static PyGetSetDef pyopencv_GOpaqueDesc_getseters[] = |  | 12452 | static PyGetSetDef pyopencv_GOpaqueDesc_getseters[] =
| 12453 | { |  | 12453 | {
| 12454 | {NULL} /* Sentinel */ |  | 12454 | {NULL} /* Sentinel */
| 12455 | }; |  | 12455 | };
| 12456 |  |  | 12456 |
| 12457 | static PyMethodDef pyopencv_GOpaqueDesc_methods[] = |  | 12457 | static PyMethodDef pyopencv_GOpaqueDesc_methods[] =
| 12458 | { |  | 12458 | {
| 12459 |  |  | 12459 |
| 12460 | {NULL, NULL} |  | 12460 | {NULL, NULL}
| 12461 | }; |  | 12461 | };
| 12462 |  |  | 12462 |
| 12463 | // Converter (GOpaqueDesc) |  | 12463 | // Converter (GOpaqueDesc)
| 12464 |  |  | 12464 |
| 12465 | template<> |  | 12465 | template<>
| 12466 | struct PyOpenCV_Converter< cv::GOpaqueDesc > |  | 12466 | struct PyOpenCV_Converter< cv::GOpaqueDesc >
| 12467 | { |  | 12467 | {
| 12468 | static PyObject* from(const cv::GOpaqueDesc& r) |  | 12468 | static PyObject* from(const cv::GOpaqueDesc& r)
| 12469 | { |  | 12469 | {
| 12470 | return pyopencv_GOpaqueDesc_Instance(r); |  | 12470 | return pyopencv_GOpaqueDesc_Instance(r);
| 12471 | } |  | 12471 | }
| 12472 | static bool to(PyObject* src, cv::GOpaqueDesc& dst, const ArgInfo& info) |  | 12472 | static bool to(PyObject* src, cv::GOpaqueDesc& dst, const ArgInfo& info)
| 12473 | { |  | 12473 | {
| 12474 | if(!src || src == Py_None) |  | 12474 | if(!src || src == Py_None)
| 12475 | return true; |  | 12475 | return true;
| 12476 | cv::GOpaqueDesc * dst_; |  | 12476 | cv::GOpaqueDesc * dst_;
| 12477 | if (pyopencv_GOpaqueDesc_getp(src, dst_)) |  | 12477 | if (pyopencv_GOpaqueDesc_getp(src, dst_))
| 12478 | { |  | 12478 | {
| 12479 | dst = *dst_; |  | 12479 | dst = *dst_;
| 12480 | return true; |  | 12480 | return true;
| 12481 | } |  | 12481 | }
| 12482 |  |  | 12482 |
| 12483 | failmsg("Expected cv::GOpaqueDesc for argument '%s'", info.name); |  | 12483 | failmsg("Expected cv::GOpaqueDesc for argument '%s'", info.name);
| 12484 | return false; |  | 12484 | return false;
| 12485 | } |  | 12485 | }
| 12486 | }; |  | 12486 | };
| 12487 |  |  | 12487 |
| 12488 | //================================================================================ |  | 12488 | //================================================================================
| 12489 | // GOpaqueT (Generic) |  | 12489 | // GOpaqueT (Generic)
| 12490 | //================================================================================ |  | 12490 | //================================================================================
| 12491 |  |  | 12491 |
| 12492 | // GetSet (GOpaqueT) |  | 12492 | // GetSet (GOpaqueT)
| 12493 |  |  | 12493 |
| 12494 |  |  | 12494 |
| 12495 |  |  | 12495 |
| 12496 | // Methods (GOpaqueT) |  | 12496 | // Methods (GOpaqueT)
| 12497 |  |  | 12497 |
| 12498 | static int pyopencv_cv_GOpaqueT_GOpaqueT(pyopencv_GOpaqueT_t* self, PyObject* py_args, PyObject* kw) |  | 12498 | static int pyopencv_cv_GOpaqueT_GOpaqueT(pyopencv_GOpaqueT_t* self, PyObject* py_args, PyObject* kw)
| 12499 | { |  | 12499 | {
| 12500 | using namespace cv; |  | 12500 | using namespace cv;
| 12501 |  |  | 12501 |
| 12502 | PyObject* pyobj_type = NULL; |  | 12502 | PyObject* pyobj_type = NULL;
| 12503 | gapi_ArgType type=static_cast<gapi_ArgType>(0); |  | 12503 | gapi_ArgType type=static_cast<gapi_ArgType>(0);
| 12504 |  |  | 12504 |
| 12505 | const char* keywords[] = { "type", NULL }; |  | 12505 | const char* keywords[] = { "type", NULL };
| 12506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GOpaqueT", (char**)keywords, &pyobj_type) && |  | 12506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GOpaqueT", (char**)keywords, &pyobj_type) &&
| 12507 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 12507 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 12508 | { |  | 12508 | {
| 12509 | if(self) ERRWRAP2(new (&(self->v)) cv::GOpaqueT(type)); |  | 12509 | if(self) ERRWRAP2(new (&(self->v)) cv::GOpaqueT(type));
| 12510 | return 0; |  | 12510 | return 0;
| 12511 | } |  | 12511 | }
| 12512 |  |  | 12512 |
| 12513 | return -1; |  | 12513 | return -1;
| 12514 | } |  | 12514 | }
| 12515 |  |  | 12515 |
| 12516 | static PyObject* pyopencv_cv_GOpaqueT_type(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12516 | static PyObject* pyopencv_cv_GOpaqueT_type(PyObject* self, PyObject* py_args, PyObject* kw)
| 12517 | { |  | 12517 | {
| 12518 | using namespace cv; |  | 12518 | using namespace cv;
| 12519 |  |  | 12519 |
| 12520 |  |  | 12520 |
| 12521 | cv::GOpaqueT * self1 = 0; |  | 12521 | cv::GOpaqueT * self1 = 0;
| 12522 | if (!pyopencv_GOpaqueT_getp(self, self1)) |  | 12522 | if (!pyopencv_GOpaqueT_getp(self, self1))
| 12523 | return failmsgp("Incorrect type of self (must be 'GOpaqueT' or its derivative)"); |  | 12523 | return failmsgp("Incorrect type of self (must be 'GOpaqueT' or its derivative)");
| 12524 | cv::GOpaqueT* _self_ = (self1); |  | 12524 | cv::GOpaqueT* _self_ = (self1);
| 12525 | gapi::ArgType retval; |  | 12525 | gapi::ArgType retval;
| 12526 |  |  | 12526 |
| 12527 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12527 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12528 | { |  | 12528 | {
| 12529 | ERRWRAP2(retval = _self_->type()); |  | 12529 | ERRWRAP2(retval = _self_->type());
| 12530 | return pyopencv_from(retval); |  | 12530 | return pyopencv_from(retval);
| 12531 | } |  | 12531 | }
| 12532 |  |  | 12532 |
| 12533 | return NULL; |  | 12533 | return NULL;
| 12534 | } |  | 12534 | }
| 12535 |  |  | 12535 |
| 12536 |  |  | 12536 |
| 12537 |  |  | 12537 |
| 12538 | // Tables (GOpaqueT) |  | 12538 | // Tables (GOpaqueT)
| 12539 |  |  | 12539 |
| 12540 | static PyGetSetDef pyopencv_GOpaqueT_getseters[] = |  | 12540 | static PyGetSetDef pyopencv_GOpaqueT_getseters[] =
| 12541 | { |  | 12541 | {
| 12542 | {NULL} /* Sentinel */ |  | 12542 | {NULL} /* Sentinel */
| 12543 | }; |  | 12543 | };
| 12544 |  |  | 12544 |
| 12545 | static PyMethodDef pyopencv_GOpaqueT_methods[] = |  | 12545 | static PyMethodDef pyopencv_GOpaqueT_methods[] =
| 12546 | { |  | 12546 | {
| 12547 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_GOpaqueT_type, 0), "type() -> retval\n."}, |  | 12547 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_GOpaqueT_type, 0), "type() -> retval\n."},
| 12548 |  |  | 12548 |
| 12549 | {NULL, NULL} |  | 12549 | {NULL, NULL}
| 12550 | }; |  | 12550 | };
| 12551 |  |  | 12551 |
| 12552 | // Converter (GOpaqueT) |  | 12552 | // Converter (GOpaqueT)
| 12553 |  |  | 12553 |
| 12554 | template<> |  | 12554 | template<>
| 12555 | struct PyOpenCV_Converter< cv::GOpaqueT > |  | 12555 | struct PyOpenCV_Converter< cv::GOpaqueT >
| 12556 | { |  | 12556 | {
| 12557 | static PyObject* from(const cv::GOpaqueT& r) |  | 12557 | static PyObject* from(const cv::GOpaqueT& r)
| 12558 | { |  | 12558 | {
| 12559 | return pyopencv_GOpaqueT_Instance(r); |  | 12559 | return pyopencv_GOpaqueT_Instance(r);
| 12560 | } |  | 12560 | }
| 12561 | static bool to(PyObject* src, cv::GOpaqueT& dst, const ArgInfo& info) |  | 12561 | static bool to(PyObject* src, cv::GOpaqueT& dst, const ArgInfo& info)
| 12562 | { |  | 12562 | {
| 12563 | if(!src || src == Py_None) |  | 12563 | if(!src || src == Py_None)
| 12564 | return true; |  | 12564 | return true;
| 12565 | cv::GOpaqueT * dst_; |  | 12565 | cv::GOpaqueT * dst_;
| 12566 | if (pyopencv_GOpaqueT_getp(src, dst_)) |  | 12566 | if (pyopencv_GOpaqueT_getp(src, dst_))
| 12567 | { |  | 12567 | {
| 12568 | dst = *dst_; |  | 12568 | dst = *dst_;
| 12569 | return true; |  | 12569 | return true;
| 12570 | } |  | 12570 | }
| 12571 |  |  | 12571 |
| 12572 | failmsg("Expected cv::GOpaqueT for argument '%s'", info.name); |  | 12572 | failmsg("Expected cv::GOpaqueT for argument '%s'", info.name);
| 12573 | return false; |  | 12573 | return false;
| 12574 | } |  | 12574 | }
| 12575 | }; |  | 12575 | };
| 12576 |  |  | 12576 |
| 12577 | //================================================================================ |  | 12577 | //================================================================================
| 12578 | // GScalar (Generic) |  | 12578 | // GScalar (Generic)
| 12579 | //================================================================================ |  | 12579 | //================================================================================
| 12580 |  |  | 12580 |
| 12581 | // GetSet (GScalar) |  | 12581 | // GetSet (GScalar)
| 12582 |  |  | 12582 |
| 12583 |  |  | 12583 |
| 12584 |  |  | 12584 |
| 12585 | // Methods (GScalar) |  | 12585 | // Methods (GScalar)
| 12586 |  |  | 12586 |
| 12587 | static int pyopencv_cv_GScalar_GScalar(pyopencv_GScalar_t* self, PyObject* py_args, PyObject* kw) |  | 12587 | static int pyopencv_cv_GScalar_GScalar(pyopencv_GScalar_t* self, PyObject* py_args, PyObject* kw)
| 12588 | { |  | 12588 | {
| 12589 | using namespace cv; |  | 12589 | using namespace cv;
| 12590 |  |  | 12590 |
| 12591 | pyPrepareArgumentConversionErrorsStorage(2); |  | 12591 | pyPrepareArgumentConversionErrorsStorage(2);
| 12592 |  |  | 12592 |
| 12593 | { |  | 12593 | {
| 12594 |  |  | 12594 |
| 12595 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12595 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12596 | { |  | 12596 | {
| 12597 | if(self) ERRWRAP2(new (&(self->v)) cv::GScalar()); |  | 12597 | if(self) ERRWRAP2(new (&(self->v)) cv::GScalar());
| 12598 | return 0; |  | 12598 | return 0;
| 12599 | } |  | 12599 | }
| 12600 |  |  | 12600 |
| 12601 |  |  | 12601 |
| 12602 | pyPopulateArgumentConversionErrors(); |  | 12602 | pyPopulateArgumentConversionErrors();
| 12603 | } |  | 12603 | }
| 12604 |  |  | 12604 |
| 12605 |  |  | 12605 |
| 12606 | { |  | 12606 | {
| 12607 | PyObject* pyobj_s = NULL; |  | 12607 | PyObject* pyobj_s = NULL;
| 12608 | Scalar s; |  | 12608 | Scalar s;
| 12609 |  |  | 12609 |
| 12610 | const char* keywords[] = { "s", NULL }; |  | 12610 | const char* keywords[] = { "s", NULL };
| 12611 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GScalar", (char**)keywords, &pyobj_s) && |  | 12611 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GScalar", (char**)keywords, &pyobj_s) &&
| 12612 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) ) |  | 12612 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) )
| 12613 | { |  | 12613 | {
| 12614 | if(self) ERRWRAP2(new (&(self->v)) cv::GScalar(s)); |  | 12614 | if(self) ERRWRAP2(new (&(self->v)) cv::GScalar(s));
| 12615 | return 0; |  | 12615 | return 0;
| 12616 | } |  | 12616 | }
| 12617 |  |  | 12617 |
| 12618 |  |  | 12618 |
| 12619 | pyPopulateArgumentConversionErrors(); |  | 12619 | pyPopulateArgumentConversionErrors();
| 12620 | } |  | 12620 | }
| 12621 | pyRaiseCVOverloadException("GScalar"); |  | 12621 | pyRaiseCVOverloadException("GScalar");
| 12622 |  |  | 12622 |
| 12623 | return -1; |  | 12623 | return -1;
| 12624 | } |  | 12624 | }
| 12625 |  |  | 12625 |
| 12626 |  |  | 12626 |
| 12627 |  |  | 12627 |
| 12628 | // Tables (GScalar) |  | 12628 | // Tables (GScalar)
| 12629 |  |  | 12629 |
| 12630 | static PyGetSetDef pyopencv_GScalar_getseters[] = |  | 12630 | static PyGetSetDef pyopencv_GScalar_getseters[] =
| 12631 | { |  | 12631 | {
| 12632 | {NULL} /* Sentinel */ |  | 12632 | {NULL} /* Sentinel */
| 12633 | }; |  | 12633 | };
| 12634 |  |  | 12634 |
| 12635 | static PyMethodDef pyopencv_GScalar_methods[] = |  | 12635 | static PyMethodDef pyopencv_GScalar_methods[] =
| 12636 | { |  | 12636 | {
| 12637 |  |  | 12637 |
| 12638 | {NULL, NULL} |  | 12638 | {NULL, NULL}
| 12639 | }; |  | 12639 | };
| 12640 |  |  | 12640 |
| 12641 | // Converter (GScalar) |  | 12641 | // Converter (GScalar)
| 12642 |  |  | 12642 |
| 12643 | template<> |  | 12643 | template<>
| 12644 | struct PyOpenCV_Converter< cv::GScalar > |  | 12644 | struct PyOpenCV_Converter< cv::GScalar >
| 12645 | { |  | 12645 | {
| 12646 | static PyObject* from(const cv::GScalar& r) |  | 12646 | static PyObject* from(const cv::GScalar& r)
| 12647 | { |  | 12647 | {
| 12648 | return pyopencv_GScalar_Instance(r); |  | 12648 | return pyopencv_GScalar_Instance(r);
| 12649 | } |  | 12649 | }
| 12650 | static bool to(PyObject* src, cv::GScalar& dst, const ArgInfo& info) |  | 12650 | static bool to(PyObject* src, cv::GScalar& dst, const ArgInfo& info)
| 12651 | { |  | 12651 | {
| 12652 | if(!src || src == Py_None) |  | 12652 | if(!src || src == Py_None)
| 12653 | return true; |  | 12653 | return true;
| 12654 | cv::GScalar * dst_; |  | 12654 | cv::GScalar * dst_;
| 12655 | if (pyopencv_GScalar_getp(src, dst_)) |  | 12655 | if (pyopencv_GScalar_getp(src, dst_))
| 12656 | { |  | 12656 | {
| 12657 | dst = *dst_; |  | 12657 | dst = *dst_;
| 12658 | return true; |  | 12658 | return true;
| 12659 | } |  | 12659 | }
| 12660 |  |  | 12660 |
| 12661 | failmsg("Expected cv::GScalar for argument '%s'", info.name); |  | 12661 | failmsg("Expected cv::GScalar for argument '%s'", info.name);
| 12662 | return false; |  | 12662 | return false;
| 12663 | } |  | 12663 | }
| 12664 | }; |  | 12664 | };
| 12665 |  |  | 12665 |
| 12666 | //================================================================================ |  | 12666 | //================================================================================
| 12667 | // GScalarDesc (Generic) |  | 12667 | // GScalarDesc (Generic)
| 12668 | //================================================================================ |  | 12668 | //================================================================================
| 12669 |  |  | 12669 |
| 12670 | // GetSet (GScalarDesc) |  | 12670 | // GetSet (GScalarDesc)
| 12671 |  |  | 12671 |
| 12672 |  |  | 12672 |
| 12673 |  |  | 12673 |
| 12674 | // Methods (GScalarDesc) |  | 12674 | // Methods (GScalarDesc)
| 12675 |  |  | 12675 |
| 12676 |  |  | 12676 |
| 12677 |  |  | 12677 |
| 12678 | // Tables (GScalarDesc) |  | 12678 | // Tables (GScalarDesc)
| 12679 |  |  | 12679 |
| 12680 | static PyGetSetDef pyopencv_GScalarDesc_getseters[] = |  | 12680 | static PyGetSetDef pyopencv_GScalarDesc_getseters[] =
| 12681 | { |  | 12681 | {
| 12682 | {NULL} /* Sentinel */ |  | 12682 | {NULL} /* Sentinel */
| 12683 | }; |  | 12683 | };
| 12684 |  |  | 12684 |
| 12685 | static PyMethodDef pyopencv_GScalarDesc_methods[] = |  | 12685 | static PyMethodDef pyopencv_GScalarDesc_methods[] =
| 12686 | { |  | 12686 | {
| 12687 |  |  | 12687 |
| 12688 | {NULL, NULL} |  | 12688 | {NULL, NULL}
| 12689 | }; |  | 12689 | };
| 12690 |  |  | 12690 |
| 12691 | // Converter (GScalarDesc) |  | 12691 | // Converter (GScalarDesc)
| 12692 |  |  | 12692 |
| 12693 | template<> |  | 12693 | template<>
| 12694 | struct PyOpenCV_Converter< cv::GScalarDesc > |  | 12694 | struct PyOpenCV_Converter< cv::GScalarDesc >
| 12695 | { |  | 12695 | {
| 12696 | static PyObject* from(const cv::GScalarDesc& r) |  | 12696 | static PyObject* from(const cv::GScalarDesc& r)
| 12697 | { |  | 12697 | {
| 12698 | return pyopencv_GScalarDesc_Instance(r); |  | 12698 | return pyopencv_GScalarDesc_Instance(r);
| 12699 | } |  | 12699 | }
| 12700 | static bool to(PyObject* src, cv::GScalarDesc& dst, const ArgInfo& info) |  | 12700 | static bool to(PyObject* src, cv::GScalarDesc& dst, const ArgInfo& info)
| 12701 | { |  | 12701 | {
| 12702 | if(!src || src == Py_None) |  | 12702 | if(!src || src == Py_None)
| 12703 | return true; |  | 12703 | return true;
| 12704 | cv::GScalarDesc * dst_; |  | 12704 | cv::GScalarDesc * dst_;
| 12705 | if (pyopencv_GScalarDesc_getp(src, dst_)) |  | 12705 | if (pyopencv_GScalarDesc_getp(src, dst_))
| 12706 | { |  | 12706 | {
| 12707 | dst = *dst_; |  | 12707 | dst = *dst_;
| 12708 | return true; |  | 12708 | return true;
| 12709 | } |  | 12709 | }
| 12710 |  |  | 12710 |
| 12711 | failmsg("Expected cv::GScalarDesc for argument '%s'", info.name); |  | 12711 | failmsg("Expected cv::GScalarDesc for argument '%s'", info.name);
| 12712 | return false; |  | 12712 | return false;
| 12713 | } |  | 12713 | }
| 12714 | }; |  | 12714 | };
| 12715 |  |  | 12715 |
| 12716 | //================================================================================ |  | 12716 | //================================================================================
| 12717 | // GStreamingCompiled (Generic) |  | 12717 | // GStreamingCompiled (Generic)
| 12718 | //================================================================================ |  | 12718 | //================================================================================
| 12719 |  |  | 12719 |
| 12720 | // GetSet (GStreamingCompiled) |  | 12720 | // GetSet (GStreamingCompiled)
| 12721 |  |  | 12721 |
| 12722 |  |  | 12722 |
| 12723 |  |  | 12723 |
| 12724 | // Methods (GStreamingCompiled) |  | 12724 | // Methods (GStreamingCompiled)
| 12725 |  |  | 12725 |
| 12726 | static int pyopencv_cv_GStreamingCompiled_GStreamingCompiled(pyopencv_GStreamingCompiled_t* self, PyObject* py_args, PyObject* kw) |  | 12726 | static int pyopencv_cv_GStreamingCompiled_GStreamingCompiled(pyopencv_GStreamingCompiled_t* self, PyObject* py_args, PyObject* kw)
| 12727 | { |  | 12727 | {
| 12728 | using namespace cv; |  | 12728 | using namespace cv;
| 12729 |  |  | 12729 |
| 12730 |  |  | 12730 |
| 12731 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12731 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12732 | { |  | 12732 | {
| 12733 | if(self) ERRWRAP2(new (&(self->v)) cv::GStreamingCompiled()); |  | 12733 | if(self) ERRWRAP2(new (&(self->v)) cv::GStreamingCompiled());
| 12734 | return 0; |  | 12734 | return 0;
| 12735 | } |  | 12735 | }
| 12736 |  |  | 12736 |
| 12737 | return -1; |  | 12737 | return -1;
| 12738 | } |  | 12738 | }
| 12739 |  |  | 12739 |
| 12740 | static PyObject* pyopencv_cv_GStreamingCompiled_pull(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12740 | static PyObject* pyopencv_cv_GStreamingCompiled_pull(PyObject* self, PyObject* py_args, PyObject* kw)
| 12741 | { |  | 12741 | {
| 12742 | using namespace cv; |  | 12742 | using namespace cv;
| 12743 |  |  | 12743 |
| 12744 |  |  | 12744 |
| 12745 | cv::GStreamingCompiled * self1 = 0; |  | 12745 | cv::GStreamingCompiled * self1 = 0;
| 12746 | if (!pyopencv_GStreamingCompiled_getp(self, self1)) |  | 12746 | if (!pyopencv_GStreamingCompiled_getp(self, self1))
| 12747 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)"); |  | 12747 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)");
| 12748 | cv::GStreamingCompiled* _self_ = (self1); |  | 12748 | cv::GStreamingCompiled* _self_ = (self1);
| 12749 | std::tuple<bool, cv::util::variant<cv::GRunArgs, cv::GOptRunArgs>> retval; |  | 12749 | std::tuple<bool, cv::util::variant<cv::GRunArgs, cv::GOptRunArgs>> retval;
| 12750 |  |  | 12750 |
| 12751 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12751 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12752 | { |  | 12752 | {
| 12753 | ERRWRAP2(retval = _self_->pull()); |  | 12753 | ERRWRAP2(retval = _self_->pull());
| 12754 | return pyopencv_from(retval); |  | 12754 | return pyopencv_from(retval);
| 12755 | } |  | 12755 | }
| 12756 |  |  | 12756 |
| 12757 | return NULL; |  | 12757 | return NULL;
| 12758 | } |  | 12758 | }
| 12759 |  |  | 12759 |
| 12760 | static PyObject* pyopencv_cv_GStreamingCompiled_running(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12760 | static PyObject* pyopencv_cv_GStreamingCompiled_running(PyObject* self, PyObject* py_args, PyObject* kw)
| 12761 | { |  | 12761 | {
| 12762 | using namespace cv; |  | 12762 | using namespace cv;
| 12763 |  |  | 12763 |
| 12764 |  |  | 12764 |
| 12765 | cv::GStreamingCompiled * self1 = 0; |  | 12765 | cv::GStreamingCompiled * self1 = 0;
| 12766 | if (!pyopencv_GStreamingCompiled_getp(self, self1)) |  | 12766 | if (!pyopencv_GStreamingCompiled_getp(self, self1))
| 12767 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)"); |  | 12767 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)");
| 12768 | cv::GStreamingCompiled* _self_ = (self1); |  | 12768 | cv::GStreamingCompiled* _self_ = (self1);
| 12769 | bool retval; |  | 12769 | bool retval;
| 12770 |  |  | 12770 |
| 12771 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12771 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12772 | { |  | 12772 | {
| 12773 | ERRWRAP2(retval = _self_->running()); |  | 12773 | ERRWRAP2(retval = _self_->running());
| 12774 | return pyopencv_from(retval); |  | 12774 | return pyopencv_from(retval);
| 12775 | } |  | 12775 | }
| 12776 |  |  | 12776 |
| 12777 | return NULL; |  | 12777 | return NULL;
| 12778 | } |  | 12778 | }
| 12779 |  |  | 12779 |
| 12780 | static PyObject* pyopencv_cv_GStreamingCompiled_setSource(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12780 | static PyObject* pyopencv_cv_GStreamingCompiled_setSource(PyObject* self, PyObject* py_args, PyObject* kw)
| 12781 | { |  | 12781 | {
| 12782 | using namespace cv; |  | 12782 | using namespace cv;
| 12783 |  |  | 12783 |
| 12784 |  |  | 12784 |
| 12785 | cv::GStreamingCompiled * self1 = 0; |  | 12785 | cv::GStreamingCompiled * self1 = 0;
| 12786 | if (!pyopencv_GStreamingCompiled_getp(self, self1)) |  | 12786 | if (!pyopencv_GStreamingCompiled_getp(self, self1))
| 12787 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)"); |  | 12787 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)");
| 12788 | cv::GStreamingCompiled* _self_ = (self1); |  | 12788 | cv::GStreamingCompiled* _self_ = (self1);
| 12789 | PyObject* pyobj_callback = NULL; |  | 12789 | PyObject* pyobj_callback = NULL;
| 12790 | detail_ExtractArgsCallback callback; |  | 12790 | detail_ExtractArgsCallback callback;
| 12791 |  |  | 12791 |
| 12792 | const char* keywords[] = { "callback", NULL }; |  | 12792 | const char* keywords[] = { "callback", NULL };
| 12793 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GStreamingCompiled.setSource", (char**)keywords, &pyobj_callback) && |  | 12793 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GStreamingCompiled.setSource", (char**)keywords, &pyobj_callback) &&
| 12794 | pyopencv_to_safe(pyobj_callback, callback, ArgInfo("callback", 0)) ) |  | 12794 | pyopencv_to_safe(pyobj_callback, callback, ArgInfo("callback", 0)) )
| 12795 | { |  | 12795 | {
| 12796 | ERRWRAP2(_self_->setSource(callback)); |  | 12796 | ERRWRAP2(_self_->setSource(callback));
| 12797 | Py_RETURN_NONE; |  | 12797 | Py_RETURN_NONE;
| 12798 | } |  | 12798 | }
| 12799 |  |  | 12799 |
| 12800 | return NULL; |  | 12800 | return NULL;
| 12801 | } |  | 12801 | }
| 12802 |  |  | 12802 |
| 12803 | static PyObject* pyopencv_cv_GStreamingCompiled_start(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12803 | static PyObject* pyopencv_cv_GStreamingCompiled_start(PyObject* self, PyObject* py_args, PyObject* kw)
| 12804 | { |  | 12804 | {
| 12805 | using namespace cv; |  | 12805 | using namespace cv;
| 12806 |  |  | 12806 |
| 12807 |  |  | 12807 |
| 12808 | cv::GStreamingCompiled * self1 = 0; |  | 12808 | cv::GStreamingCompiled * self1 = 0;
| 12809 | if (!pyopencv_GStreamingCompiled_getp(self, self1)) |  | 12809 | if (!pyopencv_GStreamingCompiled_getp(self, self1))
| 12810 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)"); |  | 12810 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)");
| 12811 | cv::GStreamingCompiled* _self_ = (self1); |  | 12811 | cv::GStreamingCompiled* _self_ = (self1);
| 12812 |  |  | 12812 |
| 12813 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12813 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12814 | { |  | 12814 | {
| 12815 | ERRWRAP2(_self_->start()); |  | 12815 | ERRWRAP2(_self_->start());
| 12816 | Py_RETURN_NONE; |  | 12816 | Py_RETURN_NONE;
| 12817 | } |  | 12817 | }
| 12818 |  |  | 12818 |
| 12819 | return NULL; |  | 12819 | return NULL;
| 12820 | } |  | 12820 | }
| 12821 |  |  | 12821 |
| 12822 | static PyObject* pyopencv_cv_GStreamingCompiled_stop(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12822 | static PyObject* pyopencv_cv_GStreamingCompiled_stop(PyObject* self, PyObject* py_args, PyObject* kw)
| 12823 | { |  | 12823 | {
| 12824 | using namespace cv; |  | 12824 | using namespace cv;
| 12825 |  |  | 12825 |
| 12826 |  |  | 12826 |
| 12827 | cv::GStreamingCompiled * self1 = 0; |  | 12827 | cv::GStreamingCompiled * self1 = 0;
| 12828 | if (!pyopencv_GStreamingCompiled_getp(self, self1)) |  | 12828 | if (!pyopencv_GStreamingCompiled_getp(self, self1))
| 12829 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)"); |  | 12829 | return failmsgp("Incorrect type of self (must be 'GStreamingCompiled' or its derivative)");
| 12830 | cv::GStreamingCompiled* _self_ = (self1); |  | 12830 | cv::GStreamingCompiled* _self_ = (self1);
| 12831 |  |  | 12831 |
| 12832 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 12832 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 12833 | { |  | 12833 | {
| 12834 | ERRWRAP2(_self_->stop()); |  | 12834 | ERRWRAP2(_self_->stop());
| 12835 | Py_RETURN_NONE; |  | 12835 | Py_RETURN_NONE;
| 12836 | } |  | 12836 | }
| 12837 |  |  | 12837 |
| 12838 | return NULL; |  | 12838 | return NULL;
| 12839 | } |  | 12839 | }
| 12840 |  |  | 12840 |
| 12841 |  |  | 12841 |
| 12842 |  |  | 12842 |
| 12843 | // Tables (GStreamingCompiled) |  | 12843 | // Tables (GStreamingCompiled)
| 12844 |  |  | 12844 |
| 12845 | static PyGetSetDef pyopencv_GStreamingCompiled_getseters[] = |  | 12845 | static PyGetSetDef pyopencv_GStreamingCompiled_getseters[] =
| 12846 | { |  | 12846 | {
| 12847 | {NULL} /* Sentinel */ |  | 12847 | {NULL} /* Sentinel */
| 12848 | }; |  | 12848 | };
| 12849 |  |  | 12849 |
| 12850 | static PyMethodDef pyopencv_GStreamingCompiled_methods[] = |  | 12850 | static PyMethodDef pyopencv_GStreamingCompiled_methods[] =
| 12851 | { |  | 12851 | {
| 12852 | {"pull", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_pull, 0), "pull() -> retval\n. * @brief Get the next processed frame from the pipeline.\n. *\n. * Use gout() to create an output parameter vector.\n. *\n. * Output vectors must have the same number of elements as defined\n. * in the cv::GComputation protocol (at the moment of its\n. * construction). Shapes of elements also must conform to protocol\n. * (e.g. cv::Mat needs to be passed where cv::GMat has been\n. * declared as output, and so on). Run-time exception is generated\n. * on type mismatch.\n. *\n. * This method writes new data into objects passed via output\n. * vector. If there is no data ready yet, this method blocks. Use\n. * try_pull() if you need a non-blocking version.\n. *\n. * @param outs vector of output parameters to obtain.\n. * @return true if next result has been obtained,\n. * false marks end of the stream."}, |  | 12852 | {"pull", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_pull, 0), "pull() -> retval\n. * @brief Get the next processed frame from the pipeline.\n. *\n. * Use gout() to create an output parameter vector.\n. *\n. * Output vectors must have the same number of elements as defined\n. * in the cv::GComputation protocol (at the moment of its\n. * construction). Shapes of elements also must conform to protocol\n. * (e.g. cv::Mat needs to be passed where cv::GMat has been\n. * declared as output, and so on). Run-time exception is generated\n. * on type mismatch.\n. *\n. * This method writes new data into objects passed via output\n. * vector. If there is no data ready yet, this method blocks. Use\n. * try_pull() if you need a non-blocking version.\n. *\n. * @param outs vector of output parameters to obtain.\n. * @return true if next result has been obtained,\n. * false marks end of the stream."},
| 12853 | {"running", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_running, 0), "running() -> retval\n. * @brief Test if the pipeline is running.\n. *\n. * @note This method is not thread-safe (with respect to the user\n. * side) at the moment. Protect the access if\n. * start()/stop()/setSource() may be called on the same object in\n. * multiple threads in your application.\n. *\n. * @return true if the current stream is not over yet."}, |  | 12853 | {"running", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_running, 0), "running() -> retval\n. * @brief Test if the pipeline is running.\n. *\n. * @note This method is not thread-safe (with respect to the user\n. * side) at the moment. Protect the access if\n. * start()/stop()/setSource() may be called on the same object in\n. * multiple threads in your application.\n. *\n. * @return true if the current stream is not over yet."},
| 12854 | {"setSource", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_setSource, 0), "setSource(callback) -> None\n. * @brief Specify the input data to GStreamingCompiled for\n. * processing, a generic version.\n. *\n. * Use gin() to create an input parameter vector.\n. *\n. * Input vectors must have the same number of elements as defined\n. * in the cv::GComputation protocol (at the moment of its\n. * construction). Shapes of elements also must conform to protocol\n. * (e.g. cv::Mat needs to be passed where cv::GMat has been\n. * declared as input, and so on). Run-time exception is generated\n. * on type mismatch.\n. *\n. * In contrast with regular GCompiled, user can also pass an\n. * object of type GVideoCapture for a GMat parameter of the parent\n. * GComputation. The compiled pipeline will start fetching data\n. * from that GVideoCapture and feeding it into the\n. * pipeline. Pipeline stops when a GVideoCapture marks end of the\n. * stream (or when stop() is called).\n. *\n. * Passing a regular Mat for a GMat parameter makes it \"infinite\"\n. * source -- pipeline may run forever feeding with this Mat until\n. * stopped explicitly.\n. *\n. * Currently only a single GVideoCapture is supported as input. If\n. * the parent GComputation is declared with multiple input GMat's,\n. * one of those can be specified as GVideoCapture but all others\n. * must be regular Mat objects.\n. *\n. * Throws if pipeline is already running. Use stop() and then\n. * setSource() to run the graph on a new video stream.\n. *\n. * @note This method is not thread-safe (with respect to the user\n. * side) at the moment. Protect the access if\n. * start()/stop()/setSource() may be called on the same object in\n. * multiple threads in your application.\n. *\n. * @param ins vector of inputs to process.\n. * @sa gin"}, |  | 12854 | {"setSource", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_setSource, 0), "setSource(callback) -> None\n. * @brief Specify the input data to GStreamingCompiled for\n. * processing, a generic version.\n. *\n. * Use gin() to create an input parameter vector.\n. *\n. * Input vectors must have the same number of elements as defined\n. * in the cv::GComputation protocol (at the moment of its\n. * construction). Shapes of elements also must conform to protocol\n. * (e.g. cv::Mat needs to be passed where cv::GMat has been\n. * declared as input, and so on). Run-time exception is generated\n. * on type mismatch.\n. *\n. * In contrast with regular GCompiled, user can also pass an\n. * object of type GVideoCapture for a GMat parameter of the parent\n. * GComputation. The compiled pipeline will start fetching data\n. * from that GVideoCapture and feeding it into the\n. * pipeline. Pipeline stops when a GVideoCapture marks end of the\n. * stream (or when stop() is called).\n. *\n. * Passing a regular Mat for a GMat parameter makes it \"infinite\"\n. * source -- pipeline may run forever feeding with this Mat until\n. * stopped explicitly.\n. *\n. * Currently only a single GVideoCapture is supported as input. If\n. * the parent GComputation is declared with multiple input GMat's,\n. * one of those can be specified as GVideoCapture but all others\n. * must be regular Mat objects.\n. *\n. * Throws if pipeline is already running. Use stop() and then\n. * setSource() to run the graph on a new video stream.\n. *\n. * @note This method is not thread-safe (with respect to the user\n. * side) at the moment. Protect the access if\n. * start()/stop()/setSource() may be called on the same object in\n. * multiple threads in your application.\n. *\n. * @param ins vector of inputs to process.\n. * @sa gin"},
| 12855 | {"start", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_start, 0), "start() -> None\n. * @brief Start the pipeline execution.\n. *\n. * Use pull()/try_pull() to obtain data. Throws an exception if\n. * a video source was not specified.\n. *\n. * setSource() must be called first, even if the pipeline has been\n. * working already and then stopped (explicitly via stop() or due\n. * stream completion)\n. *\n. * @note This method is not thread-safe (with respect to the user\n. * side) at the moment. Protect the access if\n. * start()/stop()/setSource() may be called on the same object in\n. * multiple threads in your application."}, |  | 12855 | {"start", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_start, 0), "start() -> None\n. * @brief Start the pipeline execution.\n. *\n. * Use pull()/try_pull() to obtain data. Throws an exception if\n. * a video source was not specified.\n. *\n. * setSource() must be called first, even if the pipeline has been\n. * working already and then stopped (explicitly via stop() or due\n. * stream completion)\n. *\n. * @note This method is not thread-safe (with respect to the user\n. * side) at the moment. Protect the access if\n. * start()/stop()/setSource() may be called on the same object in\n. * multiple threads in your application."},
| 12856 | {"stop", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_stop, 0), "stop() -> None\n. * @brief Stop (abort) processing the pipeline.\n. *\n. * Note - it is not pause but a complete stop. Calling start()\n. * will cause G-API to start processing the stream from the early beginning.\n. *\n. * Throws if the pipeline is not running."}, |  | 12856 | {"stop", CV_PY_FN_WITH_KW_(pyopencv_cv_GStreamingCompiled_stop, 0), "stop() -> None\n. * @brief Stop (abort) processing the pipeline.\n. *\n. * Note - it is not pause but a complete stop. Calling start()\n. * will cause G-API to start processing the stream from the early beginning.\n. *\n. * Throws if the pipeline is not running."},
| 12857 |  |  | 12857 |
| 12858 | {NULL, NULL} |  | 12858 | {NULL, NULL}
| 12859 | }; |  | 12859 | };
| 12860 |  |  | 12860 |
| 12861 | // Converter (GStreamingCompiled) |  | 12861 | // Converter (GStreamingCompiled)
| 12862 |  |  | 12862 |
| 12863 | template<> |  | 12863 | template<>
| 12864 | struct PyOpenCV_Converter< cv::GStreamingCompiled > |  | 12864 | struct PyOpenCV_Converter< cv::GStreamingCompiled >
| 12865 | { |  | 12865 | {
| 12866 | static PyObject* from(const cv::GStreamingCompiled& r) |  | 12866 | static PyObject* from(const cv::GStreamingCompiled& r)
| 12867 | { |  | 12867 | {
| 12868 | return pyopencv_GStreamingCompiled_Instance(r); |  | 12868 | return pyopencv_GStreamingCompiled_Instance(r);
| 12869 | } |  | 12869 | }
| 12870 | static bool to(PyObject* src, cv::GStreamingCompiled& dst, const ArgInfo& info) |  | 12870 | static bool to(PyObject* src, cv::GStreamingCompiled& dst, const ArgInfo& info)
| 12871 | { |  | 12871 | {
| 12872 | if(!src || src == Py_None) |  | 12872 | if(!src || src == Py_None)
| 12873 | return true; |  | 12873 | return true;
| 12874 | cv::GStreamingCompiled * dst_; |  | 12874 | cv::GStreamingCompiled * dst_;
| 12875 | if (pyopencv_GStreamingCompiled_getp(src, dst_)) |  | 12875 | if (pyopencv_GStreamingCompiled_getp(src, dst_))
| 12876 | { |  | 12876 | {
| 12877 | dst = *dst_; |  | 12877 | dst = *dst_;
| 12878 | return true; |  | 12878 | return true;
| 12879 | } |  | 12879 | }
| 12880 |  |  | 12880 |
| 12881 | failmsg("Expected cv::GStreamingCompiled for argument '%s'", info.name); |  | 12881 | failmsg("Expected cv::GStreamingCompiled for argument '%s'", info.name);
| 12882 | return false; |  | 12882 | return false;
| 12883 | } |  | 12883 | }
| 12884 | }; |  | 12884 | };
| 12885 |  |  | 12885 |
| 12886 | //================================================================================ |  | 12886 | //================================================================================
| 12887 | // GeneralizedHough (Generic) |  | 12887 | // GeneralizedHough (Generic)
| 12888 | //================================================================================ |  | 12888 | //================================================================================
| 12889 |  |  | 12889 |
| 12890 | // GetSet (GeneralizedHough) |  | 12890 | // GetSet (GeneralizedHough)
| 12891 |  |  | 12891 |
| 12892 |  |  | 12892 |
| 12893 |  |  | 12893 |
| 12894 | // Methods (GeneralizedHough) |  | 12894 | // Methods (GeneralizedHough)
| 12895 |  |  | 12895 |
| 12896 | static PyObject* pyopencv_cv_GeneralizedHough_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 12896 | static PyObject* pyopencv_cv_GeneralizedHough_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 12897 | { |  | 12897 | {
| 12898 | using namespace cv; |  | 12898 | using namespace cv;
| 12899 |  |  | 12899 |
| 12900 |  |  | 12900 |
| 12901 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 12901 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 12902 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 12902 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 12903 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 12903 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 12904 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 12904 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 12905 | pyPrepareArgumentConversionErrorsStorage(4); |  | 12905 | pyPrepareArgumentConversionErrorsStorage(4);
| 12906 |  |  | 12906 |
| 12907 | { |  | 12907 | {
| 12908 | PyObject* pyobj_image = NULL; |  | 12908 | PyObject* pyobj_image = NULL;
| 12909 | Mat image; |  | 12909 | Mat image;
| 12910 | PyObject* pyobj_positions = NULL; |  | 12910 | PyObject* pyobj_positions = NULL;
| 12911 | Mat positions; |  | 12911 | Mat positions;
| 12912 | PyObject* pyobj_votes = NULL; |  | 12912 | PyObject* pyobj_votes = NULL;
| 12913 | Mat votes; |  | 12913 | Mat votes;
| 12914 |  |  | 12914 |
| 12915 | const char* keywords[] = { "image", "positions", "votes", NULL }; |  | 12915 | const char* keywords[] = { "image", "positions", "votes", NULL };
| 12916 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_image, &pyobj_positions, &pyobj_votes) && |  | 12916 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_image, &pyobj_positions, &pyobj_votes) &&
| 12917 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 12917 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 12918 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) && |  | 12918 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) &&
| 12919 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) ) |  | 12919 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) )
| 12920 | { |  | 12920 | {
| 12921 | ERRWRAP2(_self_->detect(image, positions, votes)); |  | 12921 | ERRWRAP2(_self_->detect(image, positions, votes));
| 12922 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes)); |  | 12922 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes));
| 12923 | } |  | 12923 | }
| 12924 |  |  | 12924 |
| 12925 |  |  | 12925 |
| 12926 | pyPopulateArgumentConversionErrors(); |  | 12926 | pyPopulateArgumentConversionErrors();
| 12927 | } |  | 12927 | }
| 12928 |  |  | 12928 |
| 12929 |  |  | 12929 |
| 12930 | { |  | 12930 | {
| 12931 | PyObject* pyobj_edges = NULL; |  | 12931 | PyObject* pyobj_edges = NULL;
| 12932 | Mat edges; |  | 12932 | Mat edges;
| 12933 | PyObject* pyobj_dx = NULL; |  | 12933 | PyObject* pyobj_dx = NULL;
| 12934 | Mat dx; |  | 12934 | Mat dx;
| 12935 | PyObject* pyobj_dy = NULL; |  | 12935 | PyObject* pyobj_dy = NULL;
| 12936 | Mat dy; |  | 12936 | Mat dy;
| 12937 | PyObject* pyobj_positions = NULL; |  | 12937 | PyObject* pyobj_positions = NULL;
| 12938 | Mat positions; |  | 12938 | Mat positions;
| 12939 | PyObject* pyobj_votes = NULL; |  | 12939 | PyObject* pyobj_votes = NULL;
| 12940 | Mat votes; |  | 12940 | Mat votes;
| 12941 |  |  | 12941 |
| 12942 | const char* keywords[] = { "edges", "dx", "dy", "positions", "votes", NULL }; |  | 12942 | const char* keywords[] = { "edges", "dx", "dy", "positions", "votes", NULL };
| 12943 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_positions, &pyobj_votes) && |  | 12943 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_positions, &pyobj_votes) &&
| 12944 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) && |  | 12944 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) &&
| 12945 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) && |  | 12945 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) &&
| 12946 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) && |  | 12946 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) &&
| 12947 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) && |  | 12947 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) &&
| 12948 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) ) |  | 12948 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) )
| 12949 | { |  | 12949 | {
| 12950 | ERRWRAP2(_self_->detect(edges, dx, dy, positions, votes)); |  | 12950 | ERRWRAP2(_self_->detect(edges, dx, dy, positions, votes));
| 12951 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes)); |  | 12951 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes));
| 12952 | } |  | 12952 | }
| 12953 |  |  | 12953 |
| 12954 |  |  | 12954 |
| 12955 | pyPopulateArgumentConversionErrors(); |  | 12955 | pyPopulateArgumentConversionErrors();
| 12956 | } |  | 12956 | }
| 12957 |  |  | 12957 |
| 12958 |  |  | 12958 |
| 12959 | { |  | 12959 | {
| 12960 | PyObject* pyobj_image = NULL; |  | 12960 | PyObject* pyobj_image = NULL;
| 12961 | UMat image; |  | 12961 | UMat image;
| 12962 | PyObject* pyobj_positions = NULL; |  | 12962 | PyObject* pyobj_positions = NULL;
| 12963 | UMat positions; |  | 12963 | UMat positions;
| 12964 | PyObject* pyobj_votes = NULL; |  | 12964 | PyObject* pyobj_votes = NULL;
| 12965 | UMat votes; |  | 12965 | UMat votes;
| 12966 |  |  | 12966 |
| 12967 | const char* keywords[] = { "image", "positions", "votes", NULL }; |  | 12967 | const char* keywords[] = { "image", "positions", "votes", NULL };
| 12968 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_image, &pyobj_positions, &pyobj_votes) && |  | 12968 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_image, &pyobj_positions, &pyobj_votes) &&
| 12969 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 12969 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 12970 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) && |  | 12970 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) &&
| 12971 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) ) |  | 12971 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) )
| 12972 | { |  | 12972 | {
| 12973 | ERRWRAP2(_self_->detect(image, positions, votes)); |  | 12973 | ERRWRAP2(_self_->detect(image, positions, votes));
| 12974 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes)); |  | 12974 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes));
| 12975 | } |  | 12975 | }
| 12976 |  |  | 12976 |
| 12977 |  |  | 12977 |
| 12978 | pyPopulateArgumentConversionErrors(); |  | 12978 | pyPopulateArgumentConversionErrors();
| 12979 | } |  | 12979 | }
| 12980 |  |  | 12980 |
| 12981 |  |  | 12981 |
| 12982 | { |  | 12982 | {
| 12983 | PyObject* pyobj_edges = NULL; |  | 12983 | PyObject* pyobj_edges = NULL;
| 12984 | UMat edges; |  | 12984 | UMat edges;
| 12985 | PyObject* pyobj_dx = NULL; |  | 12985 | PyObject* pyobj_dx = NULL;
| 12986 | UMat dx; |  | 12986 | UMat dx;
| 12987 | PyObject* pyobj_dy = NULL; |  | 12987 | PyObject* pyobj_dy = NULL;
| 12988 | UMat dy; |  | 12988 | UMat dy;
| 12989 | PyObject* pyobj_positions = NULL; |  | 12989 | PyObject* pyobj_positions = NULL;
| 12990 | UMat positions; |  | 12990 | UMat positions;
| 12991 | PyObject* pyobj_votes = NULL; |  | 12991 | PyObject* pyobj_votes = NULL;
| 12992 | UMat votes; |  | 12992 | UMat votes;
| 12993 |  |  | 12993 |
| 12994 | const char* keywords[] = { "edges", "dx", "dy", "positions", "votes", NULL }; |  | 12994 | const char* keywords[] = { "edges", "dx", "dy", "positions", "votes", NULL };
| 12995 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_positions, &pyobj_votes) && |  | 12995 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:GeneralizedHough.detect", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_positions, &pyobj_votes) &&
| 12996 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) && |  | 12996 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) &&
| 12997 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) && |  | 12997 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) &&
| 12998 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) && |  | 12998 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) &&
| 12999 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) && |  | 12999 | pyopencv_to_safe(pyobj_positions, positions, ArgInfo("positions", 1)) &&
| 13000 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) ) |  | 13000 | pyopencv_to_safe(pyobj_votes, votes, ArgInfo("votes", 1)) )
| 13001 | { |  | 13001 | {
| 13002 | ERRWRAP2(_self_->detect(edges, dx, dy, positions, votes)); |  | 13002 | ERRWRAP2(_self_->detect(edges, dx, dy, positions, votes));
| 13003 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes)); |  | 13003 | return Py_BuildValue("(NN)", pyopencv_from(positions), pyopencv_from(votes));
| 13004 | } |  | 13004 | }
| 13005 |  |  | 13005 |
| 13006 |  |  | 13006 |
| 13007 | pyPopulateArgumentConversionErrors(); |  | 13007 | pyPopulateArgumentConversionErrors();
| 13008 | } |  | 13008 | }
| 13009 | pyRaiseCVOverloadException("detect"); |  | 13009 | pyRaiseCVOverloadException("detect");
| 13010 |  |  | 13010 |
| 13011 | return NULL; |  | 13011 | return NULL;
| 13012 | } |  | 13012 | }
| 13013 |  |  | 13013 |
| 13014 | static PyObject* pyopencv_cv_GeneralizedHough_getCannyHighThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13014 | static PyObject* pyopencv_cv_GeneralizedHough_getCannyHighThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13015 | { |  | 13015 | {
| 13016 | using namespace cv; |  | 13016 | using namespace cv;
| 13017 |  |  | 13017 |
| 13018 |  |  | 13018 |
| 13019 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13019 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13020 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13020 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13021 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13021 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13022 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13022 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13023 | int retval; |  | 13023 | int retval;
| 13024 |  |  | 13024 |
| 13025 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13025 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13026 | { |  | 13026 | {
| 13027 | ERRWRAP2(retval = _self_->getCannyHighThresh()); |  | 13027 | ERRWRAP2(retval = _self_->getCannyHighThresh());
| 13028 | return pyopencv_from(retval); |  | 13028 | return pyopencv_from(retval);
| 13029 | } |  | 13029 | }
| 13030 |  |  | 13030 |
| 13031 | return NULL; |  | 13031 | return NULL;
| 13032 | } |  | 13032 | }
| 13033 |  |  | 13033 |
| 13034 | static PyObject* pyopencv_cv_GeneralizedHough_getCannyLowThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13034 | static PyObject* pyopencv_cv_GeneralizedHough_getCannyLowThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13035 | { |  | 13035 | {
| 13036 | using namespace cv; |  | 13036 | using namespace cv;
| 13037 |  |  | 13037 |
| 13038 |  |  | 13038 |
| 13039 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13039 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13040 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13040 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13041 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13041 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13042 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13042 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13043 | int retval; |  | 13043 | int retval;
| 13044 |  |  | 13044 |
| 13045 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13045 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13046 | { |  | 13046 | {
| 13047 | ERRWRAP2(retval = _self_->getCannyLowThresh()); |  | 13047 | ERRWRAP2(retval = _self_->getCannyLowThresh());
| 13048 | return pyopencv_from(retval); |  | 13048 | return pyopencv_from(retval);
| 13049 | } |  | 13049 | }
| 13050 |  |  | 13050 |
| 13051 | return NULL; |  | 13051 | return NULL;
| 13052 | } |  | 13052 | }
| 13053 |  |  | 13053 |
| 13054 | static PyObject* pyopencv_cv_GeneralizedHough_getDp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13054 | static PyObject* pyopencv_cv_GeneralizedHough_getDp(PyObject* self, PyObject* py_args, PyObject* kw)
| 13055 | { |  | 13055 | {
| 13056 | using namespace cv; |  | 13056 | using namespace cv;
| 13057 |  |  | 13057 |
| 13058 |  |  | 13058 |
| 13059 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13059 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13060 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13060 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13061 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13061 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13062 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13062 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13063 | double retval; |  | 13063 | double retval;
| 13064 |  |  | 13064 |
| 13065 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13065 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13066 | { |  | 13066 | {
| 13067 | ERRWRAP2(retval = _self_->getDp()); |  | 13067 | ERRWRAP2(retval = _self_->getDp());
| 13068 | return pyopencv_from(retval); |  | 13068 | return pyopencv_from(retval);
| 13069 | } |  | 13069 | }
| 13070 |  |  | 13070 |
| 13071 | return NULL; |  | 13071 | return NULL;
| 13072 | } |  | 13072 | }
| 13073 |  |  | 13073 |
| 13074 | static PyObject* pyopencv_cv_GeneralizedHough_getMaxBufferSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13074 | static PyObject* pyopencv_cv_GeneralizedHough_getMaxBufferSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 13075 | { |  | 13075 | {
| 13076 | using namespace cv; |  | 13076 | using namespace cv;
| 13077 |  |  | 13077 |
| 13078 |  |  | 13078 |
| 13079 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13079 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13080 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13080 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13081 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13081 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13082 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13082 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13083 | int retval; |  | 13083 | int retval;
| 13084 |  |  | 13084 |
| 13085 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13085 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13086 | { |  | 13086 | {
| 13087 | ERRWRAP2(retval = _self_->getMaxBufferSize()); |  | 13087 | ERRWRAP2(retval = _self_->getMaxBufferSize());
| 13088 | return pyopencv_from(retval); |  | 13088 | return pyopencv_from(retval);
| 13089 | } |  | 13089 | }
| 13090 |  |  | 13090 |
| 13091 | return NULL; |  | 13091 | return NULL;
| 13092 | } |  | 13092 | }
| 13093 |  |  | 13093 |
| 13094 | static PyObject* pyopencv_cv_GeneralizedHough_getMinDist(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13094 | static PyObject* pyopencv_cv_GeneralizedHough_getMinDist(PyObject* self, PyObject* py_args, PyObject* kw)
| 13095 | { |  | 13095 | {
| 13096 | using namespace cv; |  | 13096 | using namespace cv;
| 13097 |  |  | 13097 |
| 13098 |  |  | 13098 |
| 13099 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13099 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13100 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13100 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13101 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13101 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13102 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13102 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13103 | double retval; |  | 13103 | double retval;
| 13104 |  |  | 13104 |
| 13105 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13105 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13106 | { |  | 13106 | {
| 13107 | ERRWRAP2(retval = _self_->getMinDist()); |  | 13107 | ERRWRAP2(retval = _self_->getMinDist());
| 13108 | return pyopencv_from(retval); |  | 13108 | return pyopencv_from(retval);
| 13109 | } |  | 13109 | }
| 13110 |  |  | 13110 |
| 13111 | return NULL; |  | 13111 | return NULL;
| 13112 | } |  | 13112 | }
| 13113 |  |  | 13113 |
| 13114 | static PyObject* pyopencv_cv_GeneralizedHough_setCannyHighThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13114 | static PyObject* pyopencv_cv_GeneralizedHough_setCannyHighThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13115 | { |  | 13115 | {
| 13116 | using namespace cv; |  | 13116 | using namespace cv;
| 13117 |  |  | 13117 |
| 13118 |  |  | 13118 |
| 13119 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13119 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13120 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13120 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13121 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13121 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13122 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13122 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13123 | PyObject* pyobj_cannyHighThresh = NULL; |  | 13123 | PyObject* pyobj_cannyHighThresh = NULL;
| 13124 | int cannyHighThresh=0; |  | 13124 | int cannyHighThresh=0;
| 13125 |  |  | 13125 |
| 13126 | const char* keywords[] = { "cannyHighThresh", NULL }; |  | 13126 | const char* keywords[] = { "cannyHighThresh", NULL };
| 13127 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setCannyHighThresh", (char**)keywords, &pyobj_cannyHighThresh) && |  | 13127 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setCannyHighThresh", (char**)keywords, &pyobj_cannyHighThresh) &&
| 13128 | pyopencv_to_safe(pyobj_cannyHighThresh, cannyHighThresh, ArgInfo("cannyHighThresh", 0)) ) |  | 13128 | pyopencv_to_safe(pyobj_cannyHighThresh, cannyHighThresh, ArgInfo("cannyHighThresh", 0)) )
| 13129 | { |  | 13129 | {
| 13130 | ERRWRAP2(_self_->setCannyHighThresh(cannyHighThresh)); |  | 13130 | ERRWRAP2(_self_->setCannyHighThresh(cannyHighThresh));
| 13131 | Py_RETURN_NONE; |  | 13131 | Py_RETURN_NONE;
| 13132 | } |  | 13132 | }
| 13133 |  |  | 13133 |
| 13134 | return NULL; |  | 13134 | return NULL;
| 13135 | } |  | 13135 | }
| 13136 |  |  | 13136 |
| 13137 | static PyObject* pyopencv_cv_GeneralizedHough_setCannyLowThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13137 | static PyObject* pyopencv_cv_GeneralizedHough_setCannyLowThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13138 | { |  | 13138 | {
| 13139 | using namespace cv; |  | 13139 | using namespace cv;
| 13140 |  |  | 13140 |
| 13141 |  |  | 13141 |
| 13142 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13142 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13143 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13143 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13144 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13144 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13145 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13145 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13146 | PyObject* pyobj_cannyLowThresh = NULL; |  | 13146 | PyObject* pyobj_cannyLowThresh = NULL;
| 13147 | int cannyLowThresh=0; |  | 13147 | int cannyLowThresh=0;
| 13148 |  |  | 13148 |
| 13149 | const char* keywords[] = { "cannyLowThresh", NULL }; |  | 13149 | const char* keywords[] = { "cannyLowThresh", NULL };
| 13150 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setCannyLowThresh", (char**)keywords, &pyobj_cannyLowThresh) && |  | 13150 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setCannyLowThresh", (char**)keywords, &pyobj_cannyLowThresh) &&
| 13151 | pyopencv_to_safe(pyobj_cannyLowThresh, cannyLowThresh, ArgInfo("cannyLowThresh", 0)) ) |  | 13151 | pyopencv_to_safe(pyobj_cannyLowThresh, cannyLowThresh, ArgInfo("cannyLowThresh", 0)) )
| 13152 | { |  | 13152 | {
| 13153 | ERRWRAP2(_self_->setCannyLowThresh(cannyLowThresh)); |  | 13153 | ERRWRAP2(_self_->setCannyLowThresh(cannyLowThresh));
| 13154 | Py_RETURN_NONE; |  | 13154 | Py_RETURN_NONE;
| 13155 | } |  | 13155 | }
| 13156 |  |  | 13156 |
| 13157 | return NULL; |  | 13157 | return NULL;
| 13158 | } |  | 13158 | }
| 13159 |  |  | 13159 |
| 13160 | static PyObject* pyopencv_cv_GeneralizedHough_setDp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13160 | static PyObject* pyopencv_cv_GeneralizedHough_setDp(PyObject* self, PyObject* py_args, PyObject* kw)
| 13161 | { |  | 13161 | {
| 13162 | using namespace cv; |  | 13162 | using namespace cv;
| 13163 |  |  | 13163 |
| 13164 |  |  | 13164 |
| 13165 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13165 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13166 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13166 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13167 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13167 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13168 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13168 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13169 | PyObject* pyobj_dp = NULL; |  | 13169 | PyObject* pyobj_dp = NULL;
| 13170 | double dp=0; |  | 13170 | double dp=0;
| 13171 |  |  | 13171 |
| 13172 | const char* keywords[] = { "dp", NULL }; |  | 13172 | const char* keywords[] = { "dp", NULL };
| 13173 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setDp", (char**)keywords, &pyobj_dp) && |  | 13173 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setDp", (char**)keywords, &pyobj_dp) &&
| 13174 | pyopencv_to_safe(pyobj_dp, dp, ArgInfo("dp", 0)) ) |  | 13174 | pyopencv_to_safe(pyobj_dp, dp, ArgInfo("dp", 0)) )
| 13175 | { |  | 13175 | {
| 13176 | ERRWRAP2(_self_->setDp(dp)); |  | 13176 | ERRWRAP2(_self_->setDp(dp));
| 13177 | Py_RETURN_NONE; |  | 13177 | Py_RETURN_NONE;
| 13178 | } |  | 13178 | }
| 13179 |  |  | 13179 |
| 13180 | return NULL; |  | 13180 | return NULL;
| 13181 | } |  | 13181 | }
| 13182 |  |  | 13182 |
| 13183 | static PyObject* pyopencv_cv_GeneralizedHough_setMaxBufferSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13183 | static PyObject* pyopencv_cv_GeneralizedHough_setMaxBufferSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 13184 | { |  | 13184 | {
| 13185 | using namespace cv; |  | 13185 | using namespace cv;
| 13186 |  |  | 13186 |
| 13187 |  |  | 13187 |
| 13188 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13188 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13189 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13189 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13190 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13190 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13191 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13191 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13192 | PyObject* pyobj_maxBufferSize = NULL; |  | 13192 | PyObject* pyobj_maxBufferSize = NULL;
| 13193 | int maxBufferSize=0; |  | 13193 | int maxBufferSize=0;
| 13194 |  |  | 13194 |
| 13195 | const char* keywords[] = { "maxBufferSize", NULL }; |  | 13195 | const char* keywords[] = { "maxBufferSize", NULL };
| 13196 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setMaxBufferSize", (char**)keywords, &pyobj_maxBufferSize) && |  | 13196 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setMaxBufferSize", (char**)keywords, &pyobj_maxBufferSize) &&
| 13197 | pyopencv_to_safe(pyobj_maxBufferSize, maxBufferSize, ArgInfo("maxBufferSize", 0)) ) |  | 13197 | pyopencv_to_safe(pyobj_maxBufferSize, maxBufferSize, ArgInfo("maxBufferSize", 0)) )
| 13198 | { |  | 13198 | {
| 13199 | ERRWRAP2(_self_->setMaxBufferSize(maxBufferSize)); |  | 13199 | ERRWRAP2(_self_->setMaxBufferSize(maxBufferSize));
| 13200 | Py_RETURN_NONE; |  | 13200 | Py_RETURN_NONE;
| 13201 | } |  | 13201 | }
| 13202 |  |  | 13202 |
| 13203 | return NULL; |  | 13203 | return NULL;
| 13204 | } |  | 13204 | }
| 13205 |  |  | 13205 |
| 13206 | static PyObject* pyopencv_cv_GeneralizedHough_setMinDist(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13206 | static PyObject* pyopencv_cv_GeneralizedHough_setMinDist(PyObject* self, PyObject* py_args, PyObject* kw)
| 13207 | { |  | 13207 | {
| 13208 | using namespace cv; |  | 13208 | using namespace cv;
| 13209 |  |  | 13209 |
| 13210 |  |  | 13210 |
| 13211 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13211 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13212 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13212 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13213 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13213 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13214 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13214 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13215 | PyObject* pyobj_minDist = NULL; |  | 13215 | PyObject* pyobj_minDist = NULL;
| 13216 | double minDist=0; |  | 13216 | double minDist=0;
| 13217 |  |  | 13217 |
| 13218 | const char* keywords[] = { "minDist", NULL }; |  | 13218 | const char* keywords[] = { "minDist", NULL };
| 13219 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setMinDist", (char**)keywords, &pyobj_minDist) && |  | 13219 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHough.setMinDist", (char**)keywords, &pyobj_minDist) &&
| 13220 | pyopencv_to_safe(pyobj_minDist, minDist, ArgInfo("minDist", 0)) ) |  | 13220 | pyopencv_to_safe(pyobj_minDist, minDist, ArgInfo("minDist", 0)) )
| 13221 | { |  | 13221 | {
| 13222 | ERRWRAP2(_self_->setMinDist(minDist)); |  | 13222 | ERRWRAP2(_self_->setMinDist(minDist));
| 13223 | Py_RETURN_NONE; |  | 13223 | Py_RETURN_NONE;
| 13224 | } |  | 13224 | }
| 13225 |  |  | 13225 |
| 13226 | return NULL; |  | 13226 | return NULL;
| 13227 | } |  | 13227 | }
| 13228 |  |  | 13228 |
| 13229 | static PyObject* pyopencv_cv_GeneralizedHough_setTemplate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13229 | static PyObject* pyopencv_cv_GeneralizedHough_setTemplate(PyObject* self, PyObject* py_args, PyObject* kw)
| 13230 | { |  | 13230 | {
| 13231 | using namespace cv; |  | 13231 | using namespace cv;
| 13232 |  |  | 13232 |
| 13233 |  |  | 13233 |
| 13234 | Ptr<cv::GeneralizedHough> * self1 = 0; |  | 13234 | Ptr<cv::GeneralizedHough> * self1 = 0;
| 13235 | if (!pyopencv_GeneralizedHough_getp(self, self1)) |  | 13235 | if (!pyopencv_GeneralizedHough_getp(self, self1))
| 13236 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)"); |  | 13236 | return failmsgp("Incorrect type of self (must be 'GeneralizedHough' or its derivative)");
| 13237 | Ptr<cv::GeneralizedHough> _self_ = *(self1); |  | 13237 | Ptr<cv::GeneralizedHough> _self_ = *(self1);
| 13238 | pyPrepareArgumentConversionErrorsStorage(4); |  | 13238 | pyPrepareArgumentConversionErrorsStorage(4);
| 13239 |  |  | 13239 |
| 13240 | { |  | 13240 | {
| 13241 | PyObject* pyobj_templ = NULL; |  | 13241 | PyObject* pyobj_templ = NULL;
| 13242 | Mat templ; |  | 13242 | Mat templ;
| 13243 | PyObject* pyobj_templCenter = NULL; |  | 13243 | PyObject* pyobj_templCenter = NULL;
| 13244 | Point templCenter=Point(-1, -1); |  | 13244 | Point templCenter=Point(-1, -1);
| 13245 |  |  | 13245 |
| 13246 | const char* keywords[] = { "templ", "templCenter", NULL }; |  | 13246 | const char* keywords[] = { "templ", "templCenter", NULL };
| 13247 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_templ, &pyobj_templCenter) && |  | 13247 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_templ, &pyobj_templCenter) &&
| 13248 | pyopencv_to_safe(pyobj_templ, templ, ArgInfo("templ", 0)) && |  | 13248 | pyopencv_to_safe(pyobj_templ, templ, ArgInfo("templ", 0)) &&
| 13249 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) ) |  | 13249 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) )
| 13250 | { |  | 13250 | {
| 13251 | ERRWRAP2(_self_->setTemplate(templ, templCenter)); |  | 13251 | ERRWRAP2(_self_->setTemplate(templ, templCenter));
| 13252 | Py_RETURN_NONE; |  | 13252 | Py_RETURN_NONE;
| 13253 | } |  | 13253 | }
| 13254 |  |  | 13254 |
| 13255 |  |  | 13255 |
| 13256 | pyPopulateArgumentConversionErrors(); |  | 13256 | pyPopulateArgumentConversionErrors();
| 13257 | } |  | 13257 | }
| 13258 |  |  | 13258 |
| 13259 |  |  | 13259 |
| 13260 | { |  | 13260 | {
| 13261 | PyObject* pyobj_edges = NULL; |  | 13261 | PyObject* pyobj_edges = NULL;
| 13262 | Mat edges; |  | 13262 | Mat edges;
| 13263 | PyObject* pyobj_dx = NULL; |  | 13263 | PyObject* pyobj_dx = NULL;
| 13264 | Mat dx; |  | 13264 | Mat dx;
| 13265 | PyObject* pyobj_dy = NULL; |  | 13265 | PyObject* pyobj_dy = NULL;
| 13266 | Mat dy; |  | 13266 | Mat dy;
| 13267 | PyObject* pyobj_templCenter = NULL; |  | 13267 | PyObject* pyobj_templCenter = NULL;
| 13268 | Point templCenter=Point(-1, -1); |  | 13268 | Point templCenter=Point(-1, -1);
| 13269 |  |  | 13269 |
| 13270 | const char* keywords[] = { "edges", "dx", "dy", "templCenter", NULL }; |  | 13270 | const char* keywords[] = { "edges", "dx", "dy", "templCenter", NULL };
| 13271 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_templCenter) && |  | 13271 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_templCenter) &&
| 13272 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) && |  | 13272 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) &&
| 13273 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) && |  | 13273 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) &&
| 13274 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) && |  | 13274 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) &&
| 13275 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) ) |  | 13275 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) )
| 13276 | { |  | 13276 | {
| 13277 | ERRWRAP2(_self_->setTemplate(edges, dx, dy, templCenter)); |  | 13277 | ERRWRAP2(_self_->setTemplate(edges, dx, dy, templCenter));
| 13278 | Py_RETURN_NONE; |  | 13278 | Py_RETURN_NONE;
| 13279 | } |  | 13279 | }
| 13280 |  |  | 13280 |
| 13281 |  |  | 13281 |
| 13282 | pyPopulateArgumentConversionErrors(); |  | 13282 | pyPopulateArgumentConversionErrors();
| 13283 | } |  | 13283 | }
| 13284 |  |  | 13284 |
| 13285 |  |  | 13285 |
| 13286 | { |  | 13286 | {
| 13287 | PyObject* pyobj_templ = NULL; |  | 13287 | PyObject* pyobj_templ = NULL;
| 13288 | UMat templ; |  | 13288 | UMat templ;
| 13289 | PyObject* pyobj_templCenter = NULL; |  | 13289 | PyObject* pyobj_templCenter = NULL;
| 13290 | Point templCenter=Point(-1, -1); |  | 13290 | Point templCenter=Point(-1, -1);
| 13291 |  |  | 13291 |
| 13292 | const char* keywords[] = { "templ", "templCenter", NULL }; |  | 13292 | const char* keywords[] = { "templ", "templCenter", NULL };
| 13293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_templ, &pyobj_templCenter) && |  | 13293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_templ, &pyobj_templCenter) &&
| 13294 | pyopencv_to_safe(pyobj_templ, templ, ArgInfo("templ", 0)) && |  | 13294 | pyopencv_to_safe(pyobj_templ, templ, ArgInfo("templ", 0)) &&
| 13295 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) ) |  | 13295 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) )
| 13296 | { |  | 13296 | {
| 13297 | ERRWRAP2(_self_->setTemplate(templ, templCenter)); |  | 13297 | ERRWRAP2(_self_->setTemplate(templ, templCenter));
| 13298 | Py_RETURN_NONE; |  | 13298 | Py_RETURN_NONE;
| 13299 | } |  | 13299 | }
| 13300 |  |  | 13300 |
| 13301 |  |  | 13301 |
| 13302 | pyPopulateArgumentConversionErrors(); |  | 13302 | pyPopulateArgumentConversionErrors();
| 13303 | } |  | 13303 | }
| 13304 |  |  | 13304 |
| 13305 |  |  | 13305 |
| 13306 | { |  | 13306 | {
| 13307 | PyObject* pyobj_edges = NULL; |  | 13307 | PyObject* pyobj_edges = NULL;
| 13308 | UMat edges; |  | 13308 | UMat edges;
| 13309 | PyObject* pyobj_dx = NULL; |  | 13309 | PyObject* pyobj_dx = NULL;
| 13310 | UMat dx; |  | 13310 | UMat dx;
| 13311 | PyObject* pyobj_dy = NULL; |  | 13311 | PyObject* pyobj_dy = NULL;
| 13312 | UMat dy; |  | 13312 | UMat dy;
| 13313 | PyObject* pyobj_templCenter = NULL; |  | 13313 | PyObject* pyobj_templCenter = NULL;
| 13314 | Point templCenter=Point(-1, -1); |  | 13314 | Point templCenter=Point(-1, -1);
| 13315 |  |  | 13315 |
| 13316 | const char* keywords[] = { "edges", "dx", "dy", "templCenter", NULL }; |  | 13316 | const char* keywords[] = { "edges", "dx", "dy", "templCenter", NULL };
| 13317 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_templCenter) && |  | 13317 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GeneralizedHough.setTemplate", (char**)keywords, &pyobj_edges, &pyobj_dx, &pyobj_dy, &pyobj_templCenter) &&
| 13318 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) && |  | 13318 | pyopencv_to_safe(pyobj_edges, edges, ArgInfo("edges", 0)) &&
| 13319 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) && |  | 13319 | pyopencv_to_safe(pyobj_dx, dx, ArgInfo("dx", 0)) &&
| 13320 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) && |  | 13320 | pyopencv_to_safe(pyobj_dy, dy, ArgInfo("dy", 0)) &&
| 13321 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) ) |  | 13321 | pyopencv_to_safe(pyobj_templCenter, templCenter, ArgInfo("templCenter", 0)) )
| 13322 | { |  | 13322 | {
| 13323 | ERRWRAP2(_self_->setTemplate(edges, dx, dy, templCenter)); |  | 13323 | ERRWRAP2(_self_->setTemplate(edges, dx, dy, templCenter));
| 13324 | Py_RETURN_NONE; |  | 13324 | Py_RETURN_NONE;
| 13325 | } |  | 13325 | }
| 13326 |  |  | 13326 |
| 13327 |  |  | 13327 |
| 13328 | pyPopulateArgumentConversionErrors(); |  | 13328 | pyPopulateArgumentConversionErrors();
| 13329 | } |  | 13329 | }
| 13330 | pyRaiseCVOverloadException("setTemplate"); |  | 13330 | pyRaiseCVOverloadException("setTemplate");
| 13331 |  |  | 13331 |
| 13332 | return NULL; |  | 13332 | return NULL;
| 13333 | } |  | 13333 | }
| 13334 |  |  | 13334 |
| 13335 |  |  | 13335 |
| 13336 |  |  | 13336 |
| 13337 | // Tables (GeneralizedHough) |  | 13337 | // Tables (GeneralizedHough)
| 13338 |  |  | 13338 |
| 13339 | static PyGetSetDef pyopencv_GeneralizedHough_getseters[] = |  | 13339 | static PyGetSetDef pyopencv_GeneralizedHough_getseters[] =
| 13340 | { |  | 13340 | {
| 13341 | {NULL} /* Sentinel */ |  | 13341 | {NULL} /* Sentinel */
| 13342 | }; |  | 13342 | };
| 13343 |  |  | 13343 |
| 13344 | static PyMethodDef pyopencv_GeneralizedHough_methods[] = |  | 13344 | static PyMethodDef pyopencv_GeneralizedHough_methods[] =
| 13345 | { |  | 13345 | {
| 13346 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_detect, 0), "detect(image[, positions[, votes]]) -> positions, votes\n. \n\n\n\ndetect(edges, dx, dy[, positions[, votes]]) -> positions, votes\n."}, |  | 13346 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_detect, 0), "detect(image[, positions[, votes]]) -> positions, votes\n. \n\n\n\ndetect(edges, dx, dy[, positions[, votes]]) -> positions, votes\n."},
| 13347 | {"getCannyHighThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getCannyHighThresh, 0), "getCannyHighThresh() -> retval\n."}, |  | 13347 | {"getCannyHighThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getCannyHighThresh, 0), "getCannyHighThresh() -> retval\n."},
| 13348 | {"getCannyLowThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getCannyLowThresh, 0), "getCannyLowThresh() -> retval\n."}, |  | 13348 | {"getCannyLowThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getCannyLowThresh, 0), "getCannyLowThresh() -> retval\n."},
| 13349 | {"getDp", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getDp, 0), "getDp() -> retval\n."}, |  | 13349 | {"getDp", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getDp, 0), "getDp() -> retval\n."},
| 13350 | {"getMaxBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getMaxBufferSize, 0), "getMaxBufferSize() -> retval\n."}, |  | 13350 | {"getMaxBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getMaxBufferSize, 0), "getMaxBufferSize() -> retval\n."},
| 13351 | {"getMinDist", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getMinDist, 0), "getMinDist() -> retval\n."}, |  | 13351 | {"getMinDist", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_getMinDist, 0), "getMinDist() -> retval\n."},
| 13352 | {"setCannyHighThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setCannyHighThresh, 0), "setCannyHighThresh(cannyHighThresh) -> None\n."}, |  | 13352 | {"setCannyHighThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setCannyHighThresh, 0), "setCannyHighThresh(cannyHighThresh) -> None\n."},
| 13353 | {"setCannyLowThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setCannyLowThresh, 0), "setCannyLowThresh(cannyLowThresh) -> None\n."}, |  | 13353 | {"setCannyLowThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setCannyLowThresh, 0), "setCannyLowThresh(cannyLowThresh) -> None\n."},
| 13354 | {"setDp", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setDp, 0), "setDp(dp) -> None\n."}, |  | 13354 | {"setDp", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setDp, 0), "setDp(dp) -> None\n."},
| 13355 | {"setMaxBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setMaxBufferSize, 0), "setMaxBufferSize(maxBufferSize) -> None\n."}, |  | 13355 | {"setMaxBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setMaxBufferSize, 0), "setMaxBufferSize(maxBufferSize) -> None\n."},
| 13356 | {"setMinDist", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setMinDist, 0), "setMinDist(minDist) -> None\n."}, |  | 13356 | {"setMinDist", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setMinDist, 0), "setMinDist(minDist) -> None\n."},
| 13357 | {"setTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setTemplate, 0), "setTemplate(templ[, templCenter]) -> None\n. \n\n\n\nsetTemplate(edges, dx, dy[, templCenter]) -> None\n."}, |  | 13357 | {"setTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHough_setTemplate, 0), "setTemplate(templ[, templCenter]) -> None\n. \n\n\n\nsetTemplate(edges, dx, dy[, templCenter]) -> None\n."},
| 13358 |  |  | 13358 |
| 13359 | {NULL, NULL} |  | 13359 | {NULL, NULL}
| 13360 | }; |  | 13360 | };
| 13361 |  |  | 13361 |
| 13362 | // Converter (GeneralizedHough) |  | 13362 | // Converter (GeneralizedHough)
| 13363 |  |  | 13363 |
| 13364 | template<> |  | 13364 | template<>
| 13365 | struct PyOpenCV_Converter< Ptr<cv::GeneralizedHough> > |  | 13365 | struct PyOpenCV_Converter< Ptr<cv::GeneralizedHough> >
| 13366 | { |  | 13366 | {
| 13367 | static PyObject* from(const Ptr<cv::GeneralizedHough>& r) |  | 13367 | static PyObject* from(const Ptr<cv::GeneralizedHough>& r)
| 13368 | { |  | 13368 | {
| 13369 | return pyopencv_GeneralizedHough_Instance(r); |  | 13369 | return pyopencv_GeneralizedHough_Instance(r);
| 13370 | } |  | 13370 | }
| 13371 | static bool to(PyObject* src, Ptr<cv::GeneralizedHough>& dst, const ArgInfo& info) |  | 13371 | static bool to(PyObject* src, Ptr<cv::GeneralizedHough>& dst, const ArgInfo& info)
| 13372 | { |  | 13372 | {
| 13373 | if(!src || src == Py_None) |  | 13373 | if(!src || src == Py_None)
| 13374 | return true; |  | 13374 | return true;
| 13375 | Ptr<cv::GeneralizedHough> * dst_; |  | 13375 | Ptr<cv::GeneralizedHough> * dst_;
| 13376 | if (pyopencv_GeneralizedHough_getp(src, dst_)) |  | 13376 | if (pyopencv_GeneralizedHough_getp(src, dst_))
| 13377 | { |  | 13377 | {
| 13378 | dst = *dst_; |  | 13378 | dst = *dst_;
| 13379 | return true; |  | 13379 | return true;
| 13380 | } |  | 13380 | }
| 13381 |  |  | 13381 |
| 13382 | failmsg("Expected Ptr<cv::GeneralizedHough> for argument '%s'", info.name); |  | 13382 | failmsg("Expected Ptr<cv::GeneralizedHough> for argument '%s'", info.name);
| 13383 | return false; |  | 13383 | return false;
| 13384 | } |  | 13384 | }
| 13385 | }; |  | 13385 | };
| 13386 |  |  | 13386 |
| 13387 | //================================================================================ |  | 13387 | //================================================================================
| 13388 | // GeneralizedHoughBallard (Generic) |  | 13388 | // GeneralizedHoughBallard (Generic)
| 13389 | //================================================================================ |  | 13389 | //================================================================================
| 13390 |  |  | 13390 |
| 13391 | // GetSet (GeneralizedHoughBallard) |  | 13391 | // GetSet (GeneralizedHoughBallard)
| 13392 |  |  | 13392 |
| 13393 |  |  | 13393 |
| 13394 |  |  | 13394 |
| 13395 | // Methods (GeneralizedHoughBallard) |  | 13395 | // Methods (GeneralizedHoughBallard)
| 13396 |  |  | 13396 |
| 13397 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_getLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13397 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_getLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 13398 | { |  | 13398 | {
| 13399 | using namespace cv; |  | 13399 | using namespace cv;
| 13400 |  |  | 13400 |
| 13401 |  |  | 13401 |
| 13402 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0; |  | 13402 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0;
| 13403 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1)) |  | 13403 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1))
| 13404 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)"); |  | 13404 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)");
| 13405 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1); |  | 13405 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1);
| 13406 | int retval; |  | 13406 | int retval;
| 13407 |  |  | 13407 |
| 13408 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13408 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13409 | { |  | 13409 | {
| 13410 | ERRWRAP2(retval = _self_->getLevels()); |  | 13410 | ERRWRAP2(retval = _self_->getLevels());
| 13411 | return pyopencv_from(retval); |  | 13411 | return pyopencv_from(retval);
| 13412 | } |  | 13412 | }
| 13413 |  |  | 13413 |
| 13414 | return NULL; |  | 13414 | return NULL;
| 13415 | } |  | 13415 | }
| 13416 |  |  | 13416 |
| 13417 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_getVotesThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13417 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_getVotesThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 13418 | { |  | 13418 | {
| 13419 | using namespace cv; |  | 13419 | using namespace cv;
| 13420 |  |  | 13420 |
| 13421 |  |  | 13421 |
| 13422 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0; |  | 13422 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0;
| 13423 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1)) |  | 13423 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1))
| 13424 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)"); |  | 13424 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)");
| 13425 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1); |  | 13425 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1);
| 13426 | int retval; |  | 13426 | int retval;
| 13427 |  |  | 13427 |
| 13428 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13428 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13429 | { |  | 13429 | {
| 13430 | ERRWRAP2(retval = _self_->getVotesThreshold()); |  | 13430 | ERRWRAP2(retval = _self_->getVotesThreshold());
| 13431 | return pyopencv_from(retval); |  | 13431 | return pyopencv_from(retval);
| 13432 | } |  | 13432 | }
| 13433 |  |  | 13433 |
| 13434 | return NULL; |  | 13434 | return NULL;
| 13435 | } |  | 13435 | }
| 13436 |  |  | 13436 |
| 13437 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_setLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13437 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_setLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 13438 | { |  | 13438 | {
| 13439 | using namespace cv; |  | 13439 | using namespace cv;
| 13440 |  |  | 13440 |
| 13441 |  |  | 13441 |
| 13442 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0; |  | 13442 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0;
| 13443 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1)) |  | 13443 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1))
| 13444 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)"); |  | 13444 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)");
| 13445 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1); |  | 13445 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1);
| 13446 | PyObject* pyobj_levels = NULL; |  | 13446 | PyObject* pyobj_levels = NULL;
| 13447 | int levels=0; |  | 13447 | int levels=0;
| 13448 |  |  | 13448 |
| 13449 | const char* keywords[] = { "levels", NULL }; |  | 13449 | const char* keywords[] = { "levels", NULL };
| 13450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughBallard.setLevels", (char**)keywords, &pyobj_levels) && |  | 13450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughBallard.setLevels", (char**)keywords, &pyobj_levels) &&
| 13451 | pyopencv_to_safe(pyobj_levels, levels, ArgInfo("levels", 0)) ) |  | 13451 | pyopencv_to_safe(pyobj_levels, levels, ArgInfo("levels", 0)) )
| 13452 | { |  | 13452 | {
| 13453 | ERRWRAP2(_self_->setLevels(levels)); |  | 13453 | ERRWRAP2(_self_->setLevels(levels));
| 13454 | Py_RETURN_NONE; |  | 13454 | Py_RETURN_NONE;
| 13455 | } |  | 13455 | }
| 13456 |  |  | 13456 |
| 13457 | return NULL; |  | 13457 | return NULL;
| 13458 | } |  | 13458 | }
| 13459 |  |  | 13459 |
| 13460 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_setVotesThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13460 | static PyObject* pyopencv_cv_GeneralizedHoughBallard_setVotesThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 13461 | { |  | 13461 | {
| 13462 | using namespace cv; |  | 13462 | using namespace cv;
| 13463 |  |  | 13463 |
| 13464 |  |  | 13464 |
| 13465 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0; |  | 13465 | Ptr<cv::GeneralizedHoughBallard> * self1 = 0;
| 13466 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1)) |  | 13466 | if (!pyopencv_GeneralizedHoughBallard_getp(self, self1))
| 13467 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)"); |  | 13467 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughBallard' or its derivative)");
| 13468 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1); |  | 13468 | Ptr<cv::GeneralizedHoughBallard> _self_ = *(self1);
| 13469 | PyObject* pyobj_votesThreshold = NULL; |  | 13469 | PyObject* pyobj_votesThreshold = NULL;
| 13470 | int votesThreshold=0; |  | 13470 | int votesThreshold=0;
| 13471 |  |  | 13471 |
| 13472 | const char* keywords[] = { "votesThreshold", NULL }; |  | 13472 | const char* keywords[] = { "votesThreshold", NULL };
| 13473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughBallard.setVotesThreshold", (char**)keywords, &pyobj_votesThreshold) && |  | 13473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughBallard.setVotesThreshold", (char**)keywords, &pyobj_votesThreshold) &&
| 13474 | pyopencv_to_safe(pyobj_votesThreshold, votesThreshold, ArgInfo("votesThreshold", 0)) ) |  | 13474 | pyopencv_to_safe(pyobj_votesThreshold, votesThreshold, ArgInfo("votesThreshold", 0)) )
| 13475 | { |  | 13475 | {
| 13476 | ERRWRAP2(_self_->setVotesThreshold(votesThreshold)); |  | 13476 | ERRWRAP2(_self_->setVotesThreshold(votesThreshold));
| 13477 | Py_RETURN_NONE; |  | 13477 | Py_RETURN_NONE;
| 13478 | } |  | 13478 | }
| 13479 |  |  | 13479 |
| 13480 | return NULL; |  | 13480 | return NULL;
| 13481 | } |  | 13481 | }
| 13482 |  |  | 13482 |
| 13483 |  |  | 13483 |
| 13484 |  |  | 13484 |
| 13485 | // Tables (GeneralizedHoughBallard) |  | 13485 | // Tables (GeneralizedHoughBallard)
| 13486 |  |  | 13486 |
| 13487 | static PyGetSetDef pyopencv_GeneralizedHoughBallard_getseters[] = |  | 13487 | static PyGetSetDef pyopencv_GeneralizedHoughBallard_getseters[] =
| 13488 | { |  | 13488 | {
| 13489 | {NULL} /* Sentinel */ |  | 13489 | {NULL} /* Sentinel */
| 13490 | }; |  | 13490 | };
| 13491 |  |  | 13491 |
| 13492 | static PyMethodDef pyopencv_GeneralizedHoughBallard_methods[] = |  | 13492 | static PyMethodDef pyopencv_GeneralizedHoughBallard_methods[] =
| 13493 | { |  | 13493 | {
| 13494 | {"getLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_getLevels, 0), "getLevels() -> retval\n."}, |  | 13494 | {"getLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_getLevels, 0), "getLevels() -> retval\n."},
| 13495 | {"getVotesThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_getVotesThreshold, 0), "getVotesThreshold() -> retval\n."}, |  | 13495 | {"getVotesThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_getVotesThreshold, 0), "getVotesThreshold() -> retval\n."},
| 13496 | {"setLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_setLevels, 0), "setLevels(levels) -> None\n."}, |  | 13496 | {"setLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_setLevels, 0), "setLevels(levels) -> None\n."},
| 13497 | {"setVotesThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_setVotesThreshold, 0), "setVotesThreshold(votesThreshold) -> None\n."}, |  | 13497 | {"setVotesThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughBallard_setVotesThreshold, 0), "setVotesThreshold(votesThreshold) -> None\n."},
| 13498 |  |  | 13498 |
| 13499 | {NULL, NULL} |  | 13499 | {NULL, NULL}
| 13500 | }; |  | 13500 | };
| 13501 |  |  | 13501 |
| 13502 | // Converter (GeneralizedHoughBallard) |  | 13502 | // Converter (GeneralizedHoughBallard)
| 13503 |  |  | 13503 |
| 13504 | template<> |  | 13504 | template<>
| 13505 | struct PyOpenCV_Converter< Ptr<cv::GeneralizedHoughBallard> > |  | 13505 | struct PyOpenCV_Converter< Ptr<cv::GeneralizedHoughBallard> >
| 13506 | { |  | 13506 | {
| 13507 | static PyObject* from(const Ptr<cv::GeneralizedHoughBallard>& r) |  | 13507 | static PyObject* from(const Ptr<cv::GeneralizedHoughBallard>& r)
| 13508 | { |  | 13508 | {
| 13509 | return pyopencv_GeneralizedHoughBallard_Instance(r); |  | 13509 | return pyopencv_GeneralizedHoughBallard_Instance(r);
| 13510 | } |  | 13510 | }
| 13511 | static bool to(PyObject* src, Ptr<cv::GeneralizedHoughBallard>& dst, const ArgInfo& info) |  | 13511 | static bool to(PyObject* src, Ptr<cv::GeneralizedHoughBallard>& dst, const ArgInfo& info)
| 13512 | { |  | 13512 | {
| 13513 | if(!src || src == Py_None) |  | 13513 | if(!src || src == Py_None)
| 13514 | return true; |  | 13514 | return true;
| 13515 | Ptr<cv::GeneralizedHoughBallard> * dst_; |  | 13515 | Ptr<cv::GeneralizedHoughBallard> * dst_;
| 13516 | if (pyopencv_GeneralizedHoughBallard_getp(src, dst_)) |  | 13516 | if (pyopencv_GeneralizedHoughBallard_getp(src, dst_))
| 13517 | { |  | 13517 | {
| 13518 | dst = *dst_; |  | 13518 | dst = *dst_;
| 13519 | return true; |  | 13519 | return true;
| 13520 | } |  | 13520 | }
| 13521 |  |  | 13521 |
| 13522 | failmsg("Expected Ptr<cv::GeneralizedHoughBallard> for argument '%s'", info.name); |  | 13522 | failmsg("Expected Ptr<cv::GeneralizedHoughBallard> for argument '%s'", info.name);
| 13523 | return false; |  | 13523 | return false;
| 13524 | } |  | 13524 | }
| 13525 | }; |  | 13525 | };
| 13526 |  |  | 13526 |
| 13527 | //================================================================================ |  | 13527 | //================================================================================
| 13528 | // GeneralizedHoughGuil (Generic) |  | 13528 | // GeneralizedHoughGuil (Generic)
| 13529 | //================================================================================ |  | 13529 | //================================================================================
| 13530 |  |  | 13530 |
| 13531 | // GetSet (GeneralizedHoughGuil) |  | 13531 | // GetSet (GeneralizedHoughGuil)
| 13532 |  |  | 13532 |
| 13533 |  |  | 13533 |
| 13534 |  |  | 13534 |
| 13535 | // Methods (GeneralizedHoughGuil) |  | 13535 | // Methods (GeneralizedHoughGuil)
| 13536 |  |  | 13536 |
| 13537 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getAngleEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13537 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getAngleEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 13538 | { |  | 13538 | {
| 13539 | using namespace cv; |  | 13539 | using namespace cv;
| 13540 |  |  | 13540 |
| 13541 |  |  | 13541 |
| 13542 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13542 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13543 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13543 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13544 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13544 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13545 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13545 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13546 | double retval; |  | 13546 | double retval;
| 13547 |  |  | 13547 |
| 13548 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13548 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13549 | { |  | 13549 | {
| 13550 | ERRWRAP2(retval = _self_->getAngleEpsilon()); |  | 13550 | ERRWRAP2(retval = _self_->getAngleEpsilon());
| 13551 | return pyopencv_from(retval); |  | 13551 | return pyopencv_from(retval);
| 13552 | } |  | 13552 | }
| 13553 |  |  | 13553 |
| 13554 | return NULL; |  | 13554 | return NULL;
| 13555 | } |  | 13555 | }
| 13556 |  |  | 13556 |
| 13557 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getAngleStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13557 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getAngleStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 13558 | { |  | 13558 | {
| 13559 | using namespace cv; |  | 13559 | using namespace cv;
| 13560 |  |  | 13560 |
| 13561 |  |  | 13561 |
| 13562 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13562 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13563 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13563 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13564 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13564 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13565 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13565 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13566 | double retval; |  | 13566 | double retval;
| 13567 |  |  | 13567 |
| 13568 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13568 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13569 | { |  | 13569 | {
| 13570 | ERRWRAP2(retval = _self_->getAngleStep()); |  | 13570 | ERRWRAP2(retval = _self_->getAngleStep());
| 13571 | return pyopencv_from(retval); |  | 13571 | return pyopencv_from(retval);
| 13572 | } |  | 13572 | }
| 13573 |  |  | 13573 |
| 13574 | return NULL; |  | 13574 | return NULL;
| 13575 | } |  | 13575 | }
| 13576 |  |  | 13576 |
| 13577 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getAngleThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13577 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getAngleThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13578 | { |  | 13578 | {
| 13579 | using namespace cv; |  | 13579 | using namespace cv;
| 13580 |  |  | 13580 |
| 13581 |  |  | 13581 |
| 13582 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13582 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13583 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13583 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13584 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13584 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13585 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13585 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13586 | int retval; |  | 13586 | int retval;
| 13587 |  |  | 13587 |
| 13588 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13588 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13589 | { |  | 13589 | {
| 13590 | ERRWRAP2(retval = _self_->getAngleThresh()); |  | 13590 | ERRWRAP2(retval = _self_->getAngleThresh());
| 13591 | return pyopencv_from(retval); |  | 13591 | return pyopencv_from(retval);
| 13592 | } |  | 13592 | }
| 13593 |  |  | 13593 |
| 13594 | return NULL; |  | 13594 | return NULL;
| 13595 | } |  | 13595 | }
| 13596 |  |  | 13596 |
| 13597 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13597 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 13598 | { |  | 13598 | {
| 13599 | using namespace cv; |  | 13599 | using namespace cv;
| 13600 |  |  | 13600 |
| 13601 |  |  | 13601 |
| 13602 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13602 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13603 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13603 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13604 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13604 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13605 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13605 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13606 | int retval; |  | 13606 | int retval;
| 13607 |  |  | 13607 |
| 13608 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13608 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13609 | { |  | 13609 | {
| 13610 | ERRWRAP2(retval = _self_->getLevels()); |  | 13610 | ERRWRAP2(retval = _self_->getLevels());
| 13611 | return pyopencv_from(retval); |  | 13611 | return pyopencv_from(retval);
| 13612 | } |  | 13612 | }
| 13613 |  |  | 13613 |
| 13614 | return NULL; |  | 13614 | return NULL;
| 13615 | } |  | 13615 | }
| 13616 |  |  | 13616 |
| 13617 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMaxAngle(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13617 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMaxAngle(PyObject* self, PyObject* py_args, PyObject* kw)
| 13618 | { |  | 13618 | {
| 13619 | using namespace cv; |  | 13619 | using namespace cv;
| 13620 |  |  | 13620 |
| 13621 |  |  | 13621 |
| 13622 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13622 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13623 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13623 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13624 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13624 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13625 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13625 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13626 | double retval; |  | 13626 | double retval;
| 13627 |  |  | 13627 |
| 13628 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13628 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13629 | { |  | 13629 | {
| 13630 | ERRWRAP2(retval = _self_->getMaxAngle()); |  | 13630 | ERRWRAP2(retval = _self_->getMaxAngle());
| 13631 | return pyopencv_from(retval); |  | 13631 | return pyopencv_from(retval);
| 13632 | } |  | 13632 | }
| 13633 |  |  | 13633 |
| 13634 | return NULL; |  | 13634 | return NULL;
| 13635 | } |  | 13635 | }
| 13636 |  |  | 13636 |
| 13637 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMaxScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13637 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMaxScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 13638 | { |  | 13638 | {
| 13639 | using namespace cv; |  | 13639 | using namespace cv;
| 13640 |  |  | 13640 |
| 13641 |  |  | 13641 |
| 13642 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13642 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13643 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13643 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13644 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13644 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13645 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13645 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13646 | double retval; |  | 13646 | double retval;
| 13647 |  |  | 13647 |
| 13648 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13648 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13649 | { |  | 13649 | {
| 13650 | ERRWRAP2(retval = _self_->getMaxScale()); |  | 13650 | ERRWRAP2(retval = _self_->getMaxScale());
| 13651 | return pyopencv_from(retval); |  | 13651 | return pyopencv_from(retval);
| 13652 | } |  | 13652 | }
| 13653 |  |  | 13653 |
| 13654 | return NULL; |  | 13654 | return NULL;
| 13655 | } |  | 13655 | }
| 13656 |  |  | 13656 |
| 13657 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMinAngle(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13657 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMinAngle(PyObject* self, PyObject* py_args, PyObject* kw)
| 13658 | { |  | 13658 | {
| 13659 | using namespace cv; |  | 13659 | using namespace cv;
| 13660 |  |  | 13660 |
| 13661 |  |  | 13661 |
| 13662 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13662 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13663 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13663 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13664 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13664 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13665 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13665 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13666 | double retval; |  | 13666 | double retval;
| 13667 |  |  | 13667 |
| 13668 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13668 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13669 | { |  | 13669 | {
| 13670 | ERRWRAP2(retval = _self_->getMinAngle()); |  | 13670 | ERRWRAP2(retval = _self_->getMinAngle());
| 13671 | return pyopencv_from(retval); |  | 13671 | return pyopencv_from(retval);
| 13672 | } |  | 13672 | }
| 13673 |  |  | 13673 |
| 13674 | return NULL; |  | 13674 | return NULL;
| 13675 | } |  | 13675 | }
| 13676 |  |  | 13676 |
| 13677 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMinScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13677 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getMinScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 13678 | { |  | 13678 | {
| 13679 | using namespace cv; |  | 13679 | using namespace cv;
| 13680 |  |  | 13680 |
| 13681 |  |  | 13681 |
| 13682 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13682 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13683 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13683 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13684 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13684 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13685 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13685 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13686 | double retval; |  | 13686 | double retval;
| 13687 |  |  | 13687 |
| 13688 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13688 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13689 | { |  | 13689 | {
| 13690 | ERRWRAP2(retval = _self_->getMinScale()); |  | 13690 | ERRWRAP2(retval = _self_->getMinScale());
| 13691 | return pyopencv_from(retval); |  | 13691 | return pyopencv_from(retval);
| 13692 | } |  | 13692 | }
| 13693 |  |  | 13693 |
| 13694 | return NULL; |  | 13694 | return NULL;
| 13695 | } |  | 13695 | }
| 13696 |  |  | 13696 |
| 13697 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getPosThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13697 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getPosThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13698 | { |  | 13698 | {
| 13699 | using namespace cv; |  | 13699 | using namespace cv;
| 13700 |  |  | 13700 |
| 13701 |  |  | 13701 |
| 13702 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13702 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13703 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13703 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13704 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13704 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13705 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13705 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13706 | int retval; |  | 13706 | int retval;
| 13707 |  |  | 13707 |
| 13708 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13708 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13709 | { |  | 13709 | {
| 13710 | ERRWRAP2(retval = _self_->getPosThresh()); |  | 13710 | ERRWRAP2(retval = _self_->getPosThresh());
| 13711 | return pyopencv_from(retval); |  | 13711 | return pyopencv_from(retval);
| 13712 | } |  | 13712 | }
| 13713 |  |  | 13713 |
| 13714 | return NULL; |  | 13714 | return NULL;
| 13715 | } |  | 13715 | }
| 13716 |  |  | 13716 |
| 13717 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getScaleStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13717 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getScaleStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 13718 | { |  | 13718 | {
| 13719 | using namespace cv; |  | 13719 | using namespace cv;
| 13720 |  |  | 13720 |
| 13721 |  |  | 13721 |
| 13722 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13722 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13723 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13723 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13724 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13724 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13725 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13725 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13726 | double retval; |  | 13726 | double retval;
| 13727 |  |  | 13727 |
| 13728 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13728 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13729 | { |  | 13729 | {
| 13730 | ERRWRAP2(retval = _self_->getScaleStep()); |  | 13730 | ERRWRAP2(retval = _self_->getScaleStep());
| 13731 | return pyopencv_from(retval); |  | 13731 | return pyopencv_from(retval);
| 13732 | } |  | 13732 | }
| 13733 |  |  | 13733 |
| 13734 | return NULL; |  | 13734 | return NULL;
| 13735 | } |  | 13735 | }
| 13736 |  |  | 13736 |
| 13737 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getScaleThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13737 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getScaleThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13738 | { |  | 13738 | {
| 13739 | using namespace cv; |  | 13739 | using namespace cv;
| 13740 |  |  | 13740 |
| 13741 |  |  | 13741 |
| 13742 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13742 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13743 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13743 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13744 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13744 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13745 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13745 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13746 | int retval; |  | 13746 | int retval;
| 13747 |  |  | 13747 |
| 13748 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13748 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13749 | { |  | 13749 | {
| 13750 | ERRWRAP2(retval = _self_->getScaleThresh()); |  | 13750 | ERRWRAP2(retval = _self_->getScaleThresh());
| 13751 | return pyopencv_from(retval); |  | 13751 | return pyopencv_from(retval);
| 13752 | } |  | 13752 | }
| 13753 |  |  | 13753 |
| 13754 | return NULL; |  | 13754 | return NULL;
| 13755 | } |  | 13755 | }
| 13756 |  |  | 13756 |
| 13757 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getXi(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13757 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_getXi(PyObject* self, PyObject* py_args, PyObject* kw)
| 13758 | { |  | 13758 | {
| 13759 | using namespace cv; |  | 13759 | using namespace cv;
| 13760 |  |  | 13760 |
| 13761 |  |  | 13761 |
| 13762 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13762 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13763 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13763 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13764 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13764 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13765 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13765 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13766 | double retval; |  | 13766 | double retval;
| 13767 |  |  | 13767 |
| 13768 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 13768 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 13769 | { |  | 13769 | {
| 13770 | ERRWRAP2(retval = _self_->getXi()); |  | 13770 | ERRWRAP2(retval = _self_->getXi());
| 13771 | return pyopencv_from(retval); |  | 13771 | return pyopencv_from(retval);
| 13772 | } |  | 13772 | }
| 13773 |  |  | 13773 |
| 13774 | return NULL; |  | 13774 | return NULL;
| 13775 | } |  | 13775 | }
| 13776 |  |  | 13776 |
| 13777 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setAngleEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13777 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setAngleEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 13778 | { |  | 13778 | {
| 13779 | using namespace cv; |  | 13779 | using namespace cv;
| 13780 |  |  | 13780 |
| 13781 |  |  | 13781 |
| 13782 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13782 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13783 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13783 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13784 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13784 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13785 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13785 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13786 | PyObject* pyobj_angleEpsilon = NULL; |  | 13786 | PyObject* pyobj_angleEpsilon = NULL;
| 13787 | double angleEpsilon=0; |  | 13787 | double angleEpsilon=0;
| 13788 |  |  | 13788 |
| 13789 | const char* keywords[] = { "angleEpsilon", NULL }; |  | 13789 | const char* keywords[] = { "angleEpsilon", NULL };
| 13790 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setAngleEpsilon", (char**)keywords, &pyobj_angleEpsilon) && |  | 13790 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setAngleEpsilon", (char**)keywords, &pyobj_angleEpsilon) &&
| 13791 | pyopencv_to_safe(pyobj_angleEpsilon, angleEpsilon, ArgInfo("angleEpsilon", 0)) ) |  | 13791 | pyopencv_to_safe(pyobj_angleEpsilon, angleEpsilon, ArgInfo("angleEpsilon", 0)) )
| 13792 | { |  | 13792 | {
| 13793 | ERRWRAP2(_self_->setAngleEpsilon(angleEpsilon)); |  | 13793 | ERRWRAP2(_self_->setAngleEpsilon(angleEpsilon));
| 13794 | Py_RETURN_NONE; |  | 13794 | Py_RETURN_NONE;
| 13795 | } |  | 13795 | }
| 13796 |  |  | 13796 |
| 13797 | return NULL; |  | 13797 | return NULL;
| 13798 | } |  | 13798 | }
| 13799 |  |  | 13799 |
| 13800 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setAngleStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13800 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setAngleStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 13801 | { |  | 13801 | {
| 13802 | using namespace cv; |  | 13802 | using namespace cv;
| 13803 |  |  | 13803 |
| 13804 |  |  | 13804 |
| 13805 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13805 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13806 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13806 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13807 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13807 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13808 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13808 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13809 | PyObject* pyobj_angleStep = NULL; |  | 13809 | PyObject* pyobj_angleStep = NULL;
| 13810 | double angleStep=0; |  | 13810 | double angleStep=0;
| 13811 |  |  | 13811 |
| 13812 | const char* keywords[] = { "angleStep", NULL }; |  | 13812 | const char* keywords[] = { "angleStep", NULL };
| 13813 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setAngleStep", (char**)keywords, &pyobj_angleStep) && |  | 13813 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setAngleStep", (char**)keywords, &pyobj_angleStep) &&
| 13814 | pyopencv_to_safe(pyobj_angleStep, angleStep, ArgInfo("angleStep", 0)) ) |  | 13814 | pyopencv_to_safe(pyobj_angleStep, angleStep, ArgInfo("angleStep", 0)) )
| 13815 | { |  | 13815 | {
| 13816 | ERRWRAP2(_self_->setAngleStep(angleStep)); |  | 13816 | ERRWRAP2(_self_->setAngleStep(angleStep));
| 13817 | Py_RETURN_NONE; |  | 13817 | Py_RETURN_NONE;
| 13818 | } |  | 13818 | }
| 13819 |  |  | 13819 |
| 13820 | return NULL; |  | 13820 | return NULL;
| 13821 | } |  | 13821 | }
| 13822 |  |  | 13822 |
| 13823 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setAngleThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13823 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setAngleThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13824 | { |  | 13824 | {
| 13825 | using namespace cv; |  | 13825 | using namespace cv;
| 13826 |  |  | 13826 |
| 13827 |  |  | 13827 |
| 13828 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13828 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13829 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13829 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13830 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13830 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13831 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13831 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13832 | PyObject* pyobj_angleThresh = NULL; |  | 13832 | PyObject* pyobj_angleThresh = NULL;
| 13833 | int angleThresh=0; |  | 13833 | int angleThresh=0;
| 13834 |  |  | 13834 |
| 13835 | const char* keywords[] = { "angleThresh", NULL }; |  | 13835 | const char* keywords[] = { "angleThresh", NULL };
| 13836 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setAngleThresh", (char**)keywords, &pyobj_angleThresh) && |  | 13836 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setAngleThresh", (char**)keywords, &pyobj_angleThresh) &&
| 13837 | pyopencv_to_safe(pyobj_angleThresh, angleThresh, ArgInfo("angleThresh", 0)) ) |  | 13837 | pyopencv_to_safe(pyobj_angleThresh, angleThresh, ArgInfo("angleThresh", 0)) )
| 13838 | { |  | 13838 | {
| 13839 | ERRWRAP2(_self_->setAngleThresh(angleThresh)); |  | 13839 | ERRWRAP2(_self_->setAngleThresh(angleThresh));
| 13840 | Py_RETURN_NONE; |  | 13840 | Py_RETURN_NONE;
| 13841 | } |  | 13841 | }
| 13842 |  |  | 13842 |
| 13843 | return NULL; |  | 13843 | return NULL;
| 13844 | } |  | 13844 | }
| 13845 |  |  | 13845 |
| 13846 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13846 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 13847 | { |  | 13847 | {
| 13848 | using namespace cv; |  | 13848 | using namespace cv;
| 13849 |  |  | 13849 |
| 13850 |  |  | 13850 |
| 13851 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13851 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13852 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13852 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13853 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13853 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13854 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13854 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13855 | PyObject* pyobj_levels = NULL; |  | 13855 | PyObject* pyobj_levels = NULL;
| 13856 | int levels=0; |  | 13856 | int levels=0;
| 13857 |  |  | 13857 |
| 13858 | const char* keywords[] = { "levels", NULL }; |  | 13858 | const char* keywords[] = { "levels", NULL };
| 13859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setLevels", (char**)keywords, &pyobj_levels) && |  | 13859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setLevels", (char**)keywords, &pyobj_levels) &&
| 13860 | pyopencv_to_safe(pyobj_levels, levels, ArgInfo("levels", 0)) ) |  | 13860 | pyopencv_to_safe(pyobj_levels, levels, ArgInfo("levels", 0)) )
| 13861 | { |  | 13861 | {
| 13862 | ERRWRAP2(_self_->setLevels(levels)); |  | 13862 | ERRWRAP2(_self_->setLevels(levels));
| 13863 | Py_RETURN_NONE; |  | 13863 | Py_RETURN_NONE;
| 13864 | } |  | 13864 | }
| 13865 |  |  | 13865 |
| 13866 | return NULL; |  | 13866 | return NULL;
| 13867 | } |  | 13867 | }
| 13868 |  |  | 13868 |
| 13869 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMaxAngle(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13869 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMaxAngle(PyObject* self, PyObject* py_args, PyObject* kw)
| 13870 | { |  | 13870 | {
| 13871 | using namespace cv; |  | 13871 | using namespace cv;
| 13872 |  |  | 13872 |
| 13873 |  |  | 13873 |
| 13874 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13874 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13875 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13875 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13876 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13876 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13877 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13877 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13878 | PyObject* pyobj_maxAngle = NULL; |  | 13878 | PyObject* pyobj_maxAngle = NULL;
| 13879 | double maxAngle=0; |  | 13879 | double maxAngle=0;
| 13880 |  |  | 13880 |
| 13881 | const char* keywords[] = { "maxAngle", NULL }; |  | 13881 | const char* keywords[] = { "maxAngle", NULL };
| 13882 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMaxAngle", (char**)keywords, &pyobj_maxAngle) && |  | 13882 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMaxAngle", (char**)keywords, &pyobj_maxAngle) &&
| 13883 | pyopencv_to_safe(pyobj_maxAngle, maxAngle, ArgInfo("maxAngle", 0)) ) |  | 13883 | pyopencv_to_safe(pyobj_maxAngle, maxAngle, ArgInfo("maxAngle", 0)) )
| 13884 | { |  | 13884 | {
| 13885 | ERRWRAP2(_self_->setMaxAngle(maxAngle)); |  | 13885 | ERRWRAP2(_self_->setMaxAngle(maxAngle));
| 13886 | Py_RETURN_NONE; |  | 13886 | Py_RETURN_NONE;
| 13887 | } |  | 13887 | }
| 13888 |  |  | 13888 |
| 13889 | return NULL; |  | 13889 | return NULL;
| 13890 | } |  | 13890 | }
| 13891 |  |  | 13891 |
| 13892 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMaxScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13892 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMaxScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 13893 | { |  | 13893 | {
| 13894 | using namespace cv; |  | 13894 | using namespace cv;
| 13895 |  |  | 13895 |
| 13896 |  |  | 13896 |
| 13897 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13897 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13898 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13898 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13899 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13899 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13900 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13900 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13901 | PyObject* pyobj_maxScale = NULL; |  | 13901 | PyObject* pyobj_maxScale = NULL;
| 13902 | double maxScale=0; |  | 13902 | double maxScale=0;
| 13903 |  |  | 13903 |
| 13904 | const char* keywords[] = { "maxScale", NULL }; |  | 13904 | const char* keywords[] = { "maxScale", NULL };
| 13905 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMaxScale", (char**)keywords, &pyobj_maxScale) && |  | 13905 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMaxScale", (char**)keywords, &pyobj_maxScale) &&
| 13906 | pyopencv_to_safe(pyobj_maxScale, maxScale, ArgInfo("maxScale", 0)) ) |  | 13906 | pyopencv_to_safe(pyobj_maxScale, maxScale, ArgInfo("maxScale", 0)) )
| 13907 | { |  | 13907 | {
| 13908 | ERRWRAP2(_self_->setMaxScale(maxScale)); |  | 13908 | ERRWRAP2(_self_->setMaxScale(maxScale));
| 13909 | Py_RETURN_NONE; |  | 13909 | Py_RETURN_NONE;
| 13910 | } |  | 13910 | }
| 13911 |  |  | 13911 |
| 13912 | return NULL; |  | 13912 | return NULL;
| 13913 | } |  | 13913 | }
| 13914 |  |  | 13914 |
| 13915 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMinAngle(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13915 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMinAngle(PyObject* self, PyObject* py_args, PyObject* kw)
| 13916 | { |  | 13916 | {
| 13917 | using namespace cv; |  | 13917 | using namespace cv;
| 13918 |  |  | 13918 |
| 13919 |  |  | 13919 |
| 13920 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13920 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13921 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13921 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13922 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13922 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13923 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13923 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13924 | PyObject* pyobj_minAngle = NULL; |  | 13924 | PyObject* pyobj_minAngle = NULL;
| 13925 | double minAngle=0; |  | 13925 | double minAngle=0;
| 13926 |  |  | 13926 |
| 13927 | const char* keywords[] = { "minAngle", NULL }; |  | 13927 | const char* keywords[] = { "minAngle", NULL };
| 13928 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMinAngle", (char**)keywords, &pyobj_minAngle) && |  | 13928 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMinAngle", (char**)keywords, &pyobj_minAngle) &&
| 13929 | pyopencv_to_safe(pyobj_minAngle, minAngle, ArgInfo("minAngle", 0)) ) |  | 13929 | pyopencv_to_safe(pyobj_minAngle, minAngle, ArgInfo("minAngle", 0)) )
| 13930 | { |  | 13930 | {
| 13931 | ERRWRAP2(_self_->setMinAngle(minAngle)); |  | 13931 | ERRWRAP2(_self_->setMinAngle(minAngle));
| 13932 | Py_RETURN_NONE; |  | 13932 | Py_RETURN_NONE;
| 13933 | } |  | 13933 | }
| 13934 |  |  | 13934 |
| 13935 | return NULL; |  | 13935 | return NULL;
| 13936 | } |  | 13936 | }
| 13937 |  |  | 13937 |
| 13938 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMinScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13938 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setMinScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 13939 | { |  | 13939 | {
| 13940 | using namespace cv; |  | 13940 | using namespace cv;
| 13941 |  |  | 13941 |
| 13942 |  |  | 13942 |
| 13943 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13943 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13944 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13944 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13945 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13945 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13946 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13946 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13947 | PyObject* pyobj_minScale = NULL; |  | 13947 | PyObject* pyobj_minScale = NULL;
| 13948 | double minScale=0; |  | 13948 | double minScale=0;
| 13949 |  |  | 13949 |
| 13950 | const char* keywords[] = { "minScale", NULL }; |  | 13950 | const char* keywords[] = { "minScale", NULL };
| 13951 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMinScale", (char**)keywords, &pyobj_minScale) && |  | 13951 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setMinScale", (char**)keywords, &pyobj_minScale) &&
| 13952 | pyopencv_to_safe(pyobj_minScale, minScale, ArgInfo("minScale", 0)) ) |  | 13952 | pyopencv_to_safe(pyobj_minScale, minScale, ArgInfo("minScale", 0)) )
| 13953 | { |  | 13953 | {
| 13954 | ERRWRAP2(_self_->setMinScale(minScale)); |  | 13954 | ERRWRAP2(_self_->setMinScale(minScale));
| 13955 | Py_RETURN_NONE; |  | 13955 | Py_RETURN_NONE;
| 13956 | } |  | 13956 | }
| 13957 |  |  | 13957 |
| 13958 | return NULL; |  | 13958 | return NULL;
| 13959 | } |  | 13959 | }
| 13960 |  |  | 13960 |
| 13961 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setPosThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13961 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setPosThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 13962 | { |  | 13962 | {
| 13963 | using namespace cv; |  | 13963 | using namespace cv;
| 13964 |  |  | 13964 |
| 13965 |  |  | 13965 |
| 13966 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13966 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13967 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13967 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13968 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13968 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13969 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13969 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13970 | PyObject* pyobj_posThresh = NULL; |  | 13970 | PyObject* pyobj_posThresh = NULL;
| 13971 | int posThresh=0; |  | 13971 | int posThresh=0;
| 13972 |  |  | 13972 |
| 13973 | const char* keywords[] = { "posThresh", NULL }; |  | 13973 | const char* keywords[] = { "posThresh", NULL };
| 13974 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setPosThresh", (char**)keywords, &pyobj_posThresh) && |  | 13974 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setPosThresh", (char**)keywords, &pyobj_posThresh) &&
| 13975 | pyopencv_to_safe(pyobj_posThresh, posThresh, ArgInfo("posThresh", 0)) ) |  | 13975 | pyopencv_to_safe(pyobj_posThresh, posThresh, ArgInfo("posThresh", 0)) )
| 13976 | { |  | 13976 | {
| 13977 | ERRWRAP2(_self_->setPosThresh(posThresh)); |  | 13977 | ERRWRAP2(_self_->setPosThresh(posThresh));
| 13978 | Py_RETURN_NONE; |  | 13978 | Py_RETURN_NONE;
| 13979 | } |  | 13979 | }
| 13980 |  |  | 13980 |
| 13981 | return NULL; |  | 13981 | return NULL;
| 13982 | } |  | 13982 | }
| 13983 |  |  | 13983 |
| 13984 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setScaleStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 13984 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setScaleStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 13985 | { |  | 13985 | {
| 13986 | using namespace cv; |  | 13986 | using namespace cv;
| 13987 |  |  | 13987 |
| 13988 |  |  | 13988 |
| 13989 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 13989 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 13990 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 13990 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 13991 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 13991 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 13992 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 13992 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 13993 | PyObject* pyobj_scaleStep = NULL; |  | 13993 | PyObject* pyobj_scaleStep = NULL;
| 13994 | double scaleStep=0; |  | 13994 | double scaleStep=0;
| 13995 |  |  | 13995 |
| 13996 | const char* keywords[] = { "scaleStep", NULL }; |  | 13996 | const char* keywords[] = { "scaleStep", NULL };
| 13997 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setScaleStep", (char**)keywords, &pyobj_scaleStep) && |  | 13997 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setScaleStep", (char**)keywords, &pyobj_scaleStep) &&
| 13998 | pyopencv_to_safe(pyobj_scaleStep, scaleStep, ArgInfo("scaleStep", 0)) ) |  | 13998 | pyopencv_to_safe(pyobj_scaleStep, scaleStep, ArgInfo("scaleStep", 0)) )
| 13999 | { |  | 13999 | {
| 14000 | ERRWRAP2(_self_->setScaleStep(scaleStep)); |  | 14000 | ERRWRAP2(_self_->setScaleStep(scaleStep));
| 14001 | Py_RETURN_NONE; |  | 14001 | Py_RETURN_NONE;
| 14002 | } |  | 14002 | }
| 14003 |  |  | 14003 |
| 14004 | return NULL; |  | 14004 | return NULL;
| 14005 | } |  | 14005 | }
| 14006 |  |  | 14006 |
| 14007 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setScaleThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14007 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setScaleThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 14008 | { |  | 14008 | {
| 14009 | using namespace cv; |  | 14009 | using namespace cv;
| 14010 |  |  | 14010 |
| 14011 |  |  | 14011 |
| 14012 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 14012 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 14013 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 14013 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 14014 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 14014 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 14015 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 14015 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 14016 | PyObject* pyobj_scaleThresh = NULL; |  | 14016 | PyObject* pyobj_scaleThresh = NULL;
| 14017 | int scaleThresh=0; |  | 14017 | int scaleThresh=0;
| 14018 |  |  | 14018 |
| 14019 | const char* keywords[] = { "scaleThresh", NULL }; |  | 14019 | const char* keywords[] = { "scaleThresh", NULL };
| 14020 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setScaleThresh", (char**)keywords, &pyobj_scaleThresh) && |  | 14020 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setScaleThresh", (char**)keywords, &pyobj_scaleThresh) &&
| 14021 | pyopencv_to_safe(pyobj_scaleThresh, scaleThresh, ArgInfo("scaleThresh", 0)) ) |  | 14021 | pyopencv_to_safe(pyobj_scaleThresh, scaleThresh, ArgInfo("scaleThresh", 0)) )
| 14022 | { |  | 14022 | {
| 14023 | ERRWRAP2(_self_->setScaleThresh(scaleThresh)); |  | 14023 | ERRWRAP2(_self_->setScaleThresh(scaleThresh));
| 14024 | Py_RETURN_NONE; |  | 14024 | Py_RETURN_NONE;
| 14025 | } |  | 14025 | }
| 14026 |  |  | 14026 |
| 14027 | return NULL; |  | 14027 | return NULL;
| 14028 | } |  | 14028 | }
| 14029 |  |  | 14029 |
| 14030 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setXi(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14030 | static PyObject* pyopencv_cv_GeneralizedHoughGuil_setXi(PyObject* self, PyObject* py_args, PyObject* kw)
| 14031 | { |  | 14031 | {
| 14032 | using namespace cv; |  | 14032 | using namespace cv;
| 14033 |  |  | 14033 |
| 14034 |  |  | 14034 |
| 14035 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0; |  | 14035 | Ptr<cv::GeneralizedHoughGuil> * self1 = 0;
| 14036 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1)) |  | 14036 | if (!pyopencv_GeneralizedHoughGuil_getp(self, self1))
| 14037 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)"); |  | 14037 | return failmsgp("Incorrect type of self (must be 'GeneralizedHoughGuil' or its derivative)");
| 14038 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1); |  | 14038 | Ptr<cv::GeneralizedHoughGuil> _self_ = *(self1);
| 14039 | PyObject* pyobj_xi = NULL; |  | 14039 | PyObject* pyobj_xi = NULL;
| 14040 | double xi=0; |  | 14040 | double xi=0;
| 14041 |  |  | 14041 |
| 14042 | const char* keywords[] = { "xi", NULL }; |  | 14042 | const char* keywords[] = { "xi", NULL };
| 14043 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setXi", (char**)keywords, &pyobj_xi) && |  | 14043 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GeneralizedHoughGuil.setXi", (char**)keywords, &pyobj_xi) &&
| 14044 | pyopencv_to_safe(pyobj_xi, xi, ArgInfo("xi", 0)) ) |  | 14044 | pyopencv_to_safe(pyobj_xi, xi, ArgInfo("xi", 0)) )
| 14045 | { |  | 14045 | {
| 14046 | ERRWRAP2(_self_->setXi(xi)); |  | 14046 | ERRWRAP2(_self_->setXi(xi));
| 14047 | Py_RETURN_NONE; |  | 14047 | Py_RETURN_NONE;
| 14048 | } |  | 14048 | }
| 14049 |  |  | 14049 |
| 14050 | return NULL; |  | 14050 | return NULL;
| 14051 | } |  | 14051 | }
| 14052 |  |  | 14052 |
| 14053 |  |  | 14053 |
| 14054 |  |  | 14054 |
| 14055 | // Tables (GeneralizedHoughGuil) |  | 14055 | // Tables (GeneralizedHoughGuil)
| 14056 |  |  | 14056 |
| 14057 | static PyGetSetDef pyopencv_GeneralizedHoughGuil_getseters[] = |  | 14057 | static PyGetSetDef pyopencv_GeneralizedHoughGuil_getseters[] =
| 14058 | { |  | 14058 | {
| 14059 | {NULL} /* Sentinel */ |  | 14059 | {NULL} /* Sentinel */
| 14060 | }; |  | 14060 | };
| 14061 |  |  | 14061 |
| 14062 | static PyMethodDef pyopencv_GeneralizedHoughGuil_methods[] = |  | 14062 | static PyMethodDef pyopencv_GeneralizedHoughGuil_methods[] =
| 14063 | { |  | 14063 | {
| 14064 | {"getAngleEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getAngleEpsilon, 0), "getAngleEpsilon() -> retval\n."}, |  | 14064 | {"getAngleEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getAngleEpsilon, 0), "getAngleEpsilon() -> retval\n."},
| 14065 | {"getAngleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getAngleStep, 0), "getAngleStep() -> retval\n."}, |  | 14065 | {"getAngleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getAngleStep, 0), "getAngleStep() -> retval\n."},
| 14066 | {"getAngleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getAngleThresh, 0), "getAngleThresh() -> retval\n."}, |  | 14066 | {"getAngleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getAngleThresh, 0), "getAngleThresh() -> retval\n."},
| 14067 | {"getLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getLevels, 0), "getLevels() -> retval\n."}, |  | 14067 | {"getLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getLevels, 0), "getLevels() -> retval\n."},
| 14068 | {"getMaxAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMaxAngle, 0), "getMaxAngle() -> retval\n."}, |  | 14068 | {"getMaxAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMaxAngle, 0), "getMaxAngle() -> retval\n."},
| 14069 | {"getMaxScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMaxScale, 0), "getMaxScale() -> retval\n."}, |  | 14069 | {"getMaxScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMaxScale, 0), "getMaxScale() -> retval\n."},
| 14070 | {"getMinAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMinAngle, 0), "getMinAngle() -> retval\n."}, |  | 14070 | {"getMinAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMinAngle, 0), "getMinAngle() -> retval\n."},
| 14071 | {"getMinScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMinScale, 0), "getMinScale() -> retval\n."}, |  | 14071 | {"getMinScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getMinScale, 0), "getMinScale() -> retval\n."},
| 14072 | {"getPosThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getPosThresh, 0), "getPosThresh() -> retval\n."}, |  | 14072 | {"getPosThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getPosThresh, 0), "getPosThresh() -> retval\n."},
| 14073 | {"getScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getScaleStep, 0), "getScaleStep() -> retval\n."}, |  | 14073 | {"getScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getScaleStep, 0), "getScaleStep() -> retval\n."},
| 14074 | {"getScaleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getScaleThresh, 0), "getScaleThresh() -> retval\n."}, |  | 14074 | {"getScaleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getScaleThresh, 0), "getScaleThresh() -> retval\n."},
| 14075 | {"getXi", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getXi, 0), "getXi() -> retval\n."}, |  | 14075 | {"getXi", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_getXi, 0), "getXi() -> retval\n."},
| 14076 | {"setAngleEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setAngleEpsilon, 0), "setAngleEpsilon(angleEpsilon) -> None\n."}, |  | 14076 | {"setAngleEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setAngleEpsilon, 0), "setAngleEpsilon(angleEpsilon) -> None\n."},
| 14077 | {"setAngleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setAngleStep, 0), "setAngleStep(angleStep) -> None\n."}, |  | 14077 | {"setAngleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setAngleStep, 0), "setAngleStep(angleStep) -> None\n."},
| 14078 | {"setAngleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setAngleThresh, 0), "setAngleThresh(angleThresh) -> None\n."}, |  | 14078 | {"setAngleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setAngleThresh, 0), "setAngleThresh(angleThresh) -> None\n."},
| 14079 | {"setLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setLevels, 0), "setLevels(levels) -> None\n."}, |  | 14079 | {"setLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setLevels, 0), "setLevels(levels) -> None\n."},
| 14080 | {"setMaxAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMaxAngle, 0), "setMaxAngle(maxAngle) -> None\n."}, |  | 14080 | {"setMaxAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMaxAngle, 0), "setMaxAngle(maxAngle) -> None\n."},
| 14081 | {"setMaxScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMaxScale, 0), "setMaxScale(maxScale) -> None\n."}, |  | 14081 | {"setMaxScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMaxScale, 0), "setMaxScale(maxScale) -> None\n."},
| 14082 | {"setMinAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMinAngle, 0), "setMinAngle(minAngle) -> None\n."}, |  | 14082 | {"setMinAngle", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMinAngle, 0), "setMinAngle(minAngle) -> None\n."},
| 14083 | {"setMinScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMinScale, 0), "setMinScale(minScale) -> None\n."}, |  | 14083 | {"setMinScale", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setMinScale, 0), "setMinScale(minScale) -> None\n."},
| 14084 | {"setPosThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setPosThresh, 0), "setPosThresh(posThresh) -> None\n."}, |  | 14084 | {"setPosThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setPosThresh, 0), "setPosThresh(posThresh) -> None\n."},
| 14085 | {"setScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setScaleStep, 0), "setScaleStep(scaleStep) -> None\n."}, |  | 14085 | {"setScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setScaleStep, 0), "setScaleStep(scaleStep) -> None\n."},
| 14086 | {"setScaleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setScaleThresh, 0), "setScaleThresh(scaleThresh) -> None\n."}, |  | 14086 | {"setScaleThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setScaleThresh, 0), "setScaleThresh(scaleThresh) -> None\n."},
| 14087 | {"setXi", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setXi, 0), "setXi(xi) -> None\n."}, |  | 14087 | {"setXi", CV_PY_FN_WITH_KW_(pyopencv_cv_GeneralizedHoughGuil_setXi, 0), "setXi(xi) -> None\n."},
| 14088 |  |  | 14088 |
| 14089 | {NULL, NULL} |  | 14089 | {NULL, NULL}
| 14090 | }; |  | 14090 | };
| 14091 |  |  | 14091 |
| 14092 | // Converter (GeneralizedHoughGuil) |  | 14092 | // Converter (GeneralizedHoughGuil)
| 14093 |  |  | 14093 |
| 14094 | template<> |  | 14094 | template<>
| 14095 | struct PyOpenCV_Converter< Ptr<cv::GeneralizedHoughGuil> > |  | 14095 | struct PyOpenCV_Converter< Ptr<cv::GeneralizedHoughGuil> >
| 14096 | { |  | 14096 | {
| 14097 | static PyObject* from(const Ptr<cv::GeneralizedHoughGuil>& r) |  | 14097 | static PyObject* from(const Ptr<cv::GeneralizedHoughGuil>& r)
| 14098 | { |  | 14098 | {
| 14099 | return pyopencv_GeneralizedHoughGuil_Instance(r); |  | 14099 | return pyopencv_GeneralizedHoughGuil_Instance(r);
| 14100 | } |  | 14100 | }
| 14101 | static bool to(PyObject* src, Ptr<cv::GeneralizedHoughGuil>& dst, const ArgInfo& info) |  | 14101 | static bool to(PyObject* src, Ptr<cv::GeneralizedHoughGuil>& dst, const ArgInfo& info)
| 14102 | { |  | 14102 | {
| 14103 | if(!src || src == Py_None) |  | 14103 | if(!src || src == Py_None)
| 14104 | return true; |  | 14104 | return true;
| 14105 | Ptr<cv::GeneralizedHoughGuil> * dst_; |  | 14105 | Ptr<cv::GeneralizedHoughGuil> * dst_;
| 14106 | if (pyopencv_GeneralizedHoughGuil_getp(src, dst_)) |  | 14106 | if (pyopencv_GeneralizedHoughGuil_getp(src, dst_))
| 14107 | { |  | 14107 | {
| 14108 | dst = *dst_; |  | 14108 | dst = *dst_;
| 14109 | return true; |  | 14109 | return true;
| 14110 | } |  | 14110 | }
| 14111 |  |  | 14111 |
| 14112 | failmsg("Expected Ptr<cv::GeneralizedHoughGuil> for argument '%s'", info.name); |  | 14112 | failmsg("Expected Ptr<cv::GeneralizedHoughGuil> for argument '%s'", info.name);
| 14113 | return false; |  | 14113 | return false;
| 14114 | } |  | 14114 | }
| 14115 | }; |  | 14115 | };
| 14116 |  |  | 14116 |
| 14117 | //================================================================================ |  | 14117 | //================================================================================
| 14118 | // GraphicalCodeDetector (Generic) |  | 14118 | // GraphicalCodeDetector (Generic)
| 14119 | //================================================================================ |  | 14119 | //================================================================================
| 14120 |  |  | 14120 |
| 14121 | // GetSet (GraphicalCodeDetector) |  | 14121 | // GetSet (GraphicalCodeDetector)
| 14122 |  |  | 14122 |
| 14123 |  |  | 14123 |
| 14124 |  |  | 14124 |
| 14125 | // Methods (GraphicalCodeDetector) |  | 14125 | // Methods (GraphicalCodeDetector)
| 14126 |  |  | 14126 |
| 14127 | static PyObject* pyopencv_cv_GraphicalCodeDetector_decode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14127 | static PyObject* pyopencv_cv_GraphicalCodeDetector_decode(PyObject* self, PyObject* py_args, PyObject* kw)
| 14128 | { |  | 14128 | {
| 14129 | using namespace cv; |  | 14129 | using namespace cv;
| 14130 |  |  | 14130 |
| 14131 |  |  | 14131 |
| 14132 | cv::GraphicalCodeDetector * self1 = 0; |  | 14132 | cv::GraphicalCodeDetector * self1 = 0;
| 14133 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1)) |  | 14133 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1))
| 14134 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)"); |  | 14134 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)");
| 14135 | cv::GraphicalCodeDetector* _self_ = (self1); |  | 14135 | cv::GraphicalCodeDetector* _self_ = (self1);
| 14136 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14136 | pyPrepareArgumentConversionErrorsStorage(2);
| 14137 |  |  | 14137 |
| 14138 | { |  | 14138 | {
| 14139 | PyObject* pyobj_img = NULL; |  | 14139 | PyObject* pyobj_img = NULL;
| 14140 | Mat img; |  | 14140 | Mat img;
| 14141 | PyObject* pyobj_points = NULL; |  | 14141 | PyObject* pyobj_points = NULL;
| 14142 | Mat points; |  | 14142 | Mat points;
| 14143 | PyObject* pyobj_straight_code = NULL; |  | 14143 | PyObject* pyobj_straight_code = NULL;
| 14144 | Mat straight_code; |  | 14144 | Mat straight_code;
| 14145 | std::string retval; |  | 14145 | std::string retval;
| 14146 |  |  | 14146 |
| 14147 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14147 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14148 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14148 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14149 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14149 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14150 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 14150 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 14151 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14151 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14152 | { |  | 14152 | {
| 14153 | ERRWRAP2(retval = _self_->decode(img, points, straight_code)); |  | 14153 | ERRWRAP2(retval = _self_->decode(img, points, straight_code));
| 14154 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_code)); |  | 14154 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_code));
| 14155 | } |  | 14155 | }
| 14156 |  |  | 14156 |
| 14157 |  |  | 14157 |
| 14158 | pyPopulateArgumentConversionErrors(); |  | 14158 | pyPopulateArgumentConversionErrors();
| 14159 | } |  | 14159 | }
| 14160 |  |  | 14160 |
| 14161 |  |  | 14161 |
| 14162 | { |  | 14162 | {
| 14163 | PyObject* pyobj_img = NULL; |  | 14163 | PyObject* pyobj_img = NULL;
| 14164 | UMat img; |  | 14164 | UMat img;
| 14165 | PyObject* pyobj_points = NULL; |  | 14165 | PyObject* pyobj_points = NULL;
| 14166 | UMat points; |  | 14166 | UMat points;
| 14167 | PyObject* pyobj_straight_code = NULL; |  | 14167 | PyObject* pyobj_straight_code = NULL;
| 14168 | UMat straight_code; |  | 14168 | UMat straight_code;
| 14169 | std::string retval; |  | 14169 | std::string retval;
| 14170 |  |  | 14170 |
| 14171 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14171 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14172 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14172 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14173 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14173 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14174 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 14174 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 14175 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14175 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14176 | { |  | 14176 | {
| 14177 | ERRWRAP2(retval = _self_->decode(img, points, straight_code)); |  | 14177 | ERRWRAP2(retval = _self_->decode(img, points, straight_code));
| 14178 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_code)); |  | 14178 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_code));
| 14179 | } |  | 14179 | }
| 14180 |  |  | 14180 |
| 14181 |  |  | 14181 |
| 14182 | pyPopulateArgumentConversionErrors(); |  | 14182 | pyPopulateArgumentConversionErrors();
| 14183 | } |  | 14183 | }
| 14184 | pyRaiseCVOverloadException("decode"); |  | 14184 | pyRaiseCVOverloadException("decode");
| 14185 |  |  | 14185 |
| 14186 | return NULL; |  | 14186 | return NULL;
| 14187 | } |  | 14187 | }
| 14188 |  |  | 14188 |
| 14189 | static PyObject* pyopencv_cv_GraphicalCodeDetector_decodeMulti(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14189 | static PyObject* pyopencv_cv_GraphicalCodeDetector_decodeMulti(PyObject* self, PyObject* py_args, PyObject* kw)
| 14190 | { |  | 14190 | {
| 14191 | using namespace cv; |  | 14191 | using namespace cv;
| 14192 |  |  | 14192 |
| 14193 |  |  | 14193 |
| 14194 | cv::GraphicalCodeDetector * self1 = 0; |  | 14194 | cv::GraphicalCodeDetector * self1 = 0;
| 14195 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1)) |  | 14195 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1))
| 14196 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)"); |  | 14196 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)");
| 14197 | cv::GraphicalCodeDetector* _self_ = (self1); |  | 14197 | cv::GraphicalCodeDetector* _self_ = (self1);
| 14198 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14198 | pyPrepareArgumentConversionErrorsStorage(2);
| 14199 |  |  | 14199 |
| 14200 | { |  | 14200 | {
| 14201 | PyObject* pyobj_img = NULL; |  | 14201 | PyObject* pyobj_img = NULL;
| 14202 | Mat img; |  | 14202 | Mat img;
| 14203 | PyObject* pyobj_points = NULL; |  | 14203 | PyObject* pyobj_points = NULL;
| 14204 | Mat points; |  | 14204 | Mat points;
| 14205 | vector_string decoded_info; |  | 14205 | vector_string decoded_info;
| 14206 | PyObject* pyobj_straight_code = NULL; |  | 14206 | PyObject* pyobj_straight_code = NULL;
| 14207 | vector_Mat straight_code; |  | 14207 | vector_Mat straight_code;
| 14208 | bool retval; |  | 14208 | bool retval;
| 14209 |  |  | 14209 |
| 14210 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14210 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14211 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14211 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14212 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14212 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14213 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 14213 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 14214 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14214 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14215 | { |  | 14215 | {
| 14216 | ERRWRAP2(retval = _self_->decodeMulti(img, points, decoded_info, straight_code)); |  | 14216 | ERRWRAP2(retval = _self_->decodeMulti(img, points, decoded_info, straight_code));
| 14217 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(straight_code)); |  | 14217 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(straight_code));
| 14218 | } |  | 14218 | }
| 14219 |  |  | 14219 |
| 14220 |  |  | 14220 |
| 14221 | pyPopulateArgumentConversionErrors(); |  | 14221 | pyPopulateArgumentConversionErrors();
| 14222 | } |  | 14222 | }
| 14223 |  |  | 14223 |
| 14224 |  |  | 14224 |
| 14225 | { |  | 14225 | {
| 14226 | PyObject* pyobj_img = NULL; |  | 14226 | PyObject* pyobj_img = NULL;
| 14227 | UMat img; |  | 14227 | UMat img;
| 14228 | PyObject* pyobj_points = NULL; |  | 14228 | PyObject* pyobj_points = NULL;
| 14229 | UMat points; |  | 14229 | UMat points;
| 14230 | vector_string decoded_info; |  | 14230 | vector_string decoded_info;
| 14231 | PyObject* pyobj_straight_code = NULL; |  | 14231 | PyObject* pyobj_straight_code = NULL;
| 14232 | vector_UMat straight_code; |  | 14232 | vector_UMat straight_code;
| 14233 | bool retval; |  | 14233 | bool retval;
| 14234 |  |  | 14234 |
| 14235 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14235 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14236 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14236 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GraphicalCodeDetector.decodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14237 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14237 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14238 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 14238 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 14239 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14239 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14240 | { |  | 14240 | {
| 14241 | ERRWRAP2(retval = _self_->decodeMulti(img, points, decoded_info, straight_code)); |  | 14241 | ERRWRAP2(retval = _self_->decodeMulti(img, points, decoded_info, straight_code));
| 14242 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(straight_code)); |  | 14242 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(straight_code));
| 14243 | } |  | 14243 | }
| 14244 |  |  | 14244 |
| 14245 |  |  | 14245 |
| 14246 | pyPopulateArgumentConversionErrors(); |  | 14246 | pyPopulateArgumentConversionErrors();
| 14247 | } |  | 14247 | }
| 14248 | pyRaiseCVOverloadException("decodeMulti"); |  | 14248 | pyRaiseCVOverloadException("decodeMulti");
| 14249 |  |  | 14249 |
| 14250 | return NULL; |  | 14250 | return NULL;
| 14251 | } |  | 14251 | }
| 14252 |  |  | 14252 |
| 14253 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14253 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 14254 | { |  | 14254 | {
| 14255 | using namespace cv; |  | 14255 | using namespace cv;
| 14256 |  |  | 14256 |
| 14257 |  |  | 14257 |
| 14258 | cv::GraphicalCodeDetector * self1 = 0; |  | 14258 | cv::GraphicalCodeDetector * self1 = 0;
| 14259 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1)) |  | 14259 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1))
| 14260 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)"); |  | 14260 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)");
| 14261 | cv::GraphicalCodeDetector* _self_ = (self1); |  | 14261 | cv::GraphicalCodeDetector* _self_ = (self1);
| 14262 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14262 | pyPrepareArgumentConversionErrorsStorage(2);
| 14263 |  |  | 14263 |
| 14264 | { |  | 14264 | {
| 14265 | PyObject* pyobj_img = NULL; |  | 14265 | PyObject* pyobj_img = NULL;
| 14266 | Mat img; |  | 14266 | Mat img;
| 14267 | PyObject* pyobj_points = NULL; |  | 14267 | PyObject* pyobj_points = NULL;
| 14268 | Mat points; |  | 14268 | Mat points;
| 14269 | bool retval; |  | 14269 | bool retval;
| 14270 |  |  | 14270 |
| 14271 | const char* keywords[] = { "img", "points", NULL }; |  | 14271 | const char* keywords[] = { "img", "points", NULL };
| 14272 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detect", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 14272 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detect", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 14273 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14273 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14274 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 14274 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 14275 | { |  | 14275 | {
| 14276 | ERRWRAP2(retval = _self_->detect(img, points)); |  | 14276 | ERRWRAP2(retval = _self_->detect(img, points));
| 14277 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points)); |  | 14277 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points));
| 14278 | } |  | 14278 | }
| 14279 |  |  | 14279 |
| 14280 |  |  | 14280 |
| 14281 | pyPopulateArgumentConversionErrors(); |  | 14281 | pyPopulateArgumentConversionErrors();
| 14282 | } |  | 14282 | }
| 14283 |  |  | 14283 |
| 14284 |  |  | 14284 |
| 14285 | { |  | 14285 | {
| 14286 | PyObject* pyobj_img = NULL; |  | 14286 | PyObject* pyobj_img = NULL;
| 14287 | UMat img; |  | 14287 | UMat img;
| 14288 | PyObject* pyobj_points = NULL; |  | 14288 | PyObject* pyobj_points = NULL;
| 14289 | UMat points; |  | 14289 | UMat points;
| 14290 | bool retval; |  | 14290 | bool retval;
| 14291 |  |  | 14291 |
| 14292 | const char* keywords[] = { "img", "points", NULL }; |  | 14292 | const char* keywords[] = { "img", "points", NULL };
| 14293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detect", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 14293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detect", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 14294 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14294 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14295 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 14295 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 14296 | { |  | 14296 | {
| 14297 | ERRWRAP2(retval = _self_->detect(img, points)); |  | 14297 | ERRWRAP2(retval = _self_->detect(img, points));
| 14298 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points)); |  | 14298 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points));
| 14299 | } |  | 14299 | }
| 14300 |  |  | 14300 |
| 14301 |  |  | 14301 |
| 14302 | pyPopulateArgumentConversionErrors(); |  | 14302 | pyPopulateArgumentConversionErrors();
| 14303 | } |  | 14303 | }
| 14304 | pyRaiseCVOverloadException("detect"); |  | 14304 | pyRaiseCVOverloadException("detect");
| 14305 |  |  | 14305 |
| 14306 | return NULL; |  | 14306 | return NULL;
| 14307 | } |  | 14307 | }
| 14308 |  |  | 14308 |
| 14309 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detectAndDecode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14309 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detectAndDecode(PyObject* self, PyObject* py_args, PyObject* kw)
| 14310 | { |  | 14310 | {
| 14311 | using namespace cv; |  | 14311 | using namespace cv;
| 14312 |  |  | 14312 |
| 14313 |  |  | 14313 |
| 14314 | cv::GraphicalCodeDetector * self1 = 0; |  | 14314 | cv::GraphicalCodeDetector * self1 = 0;
| 14315 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1)) |  | 14315 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1))
| 14316 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)"); |  | 14316 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)");
| 14317 | cv::GraphicalCodeDetector* _self_ = (self1); |  | 14317 | cv::GraphicalCodeDetector* _self_ = (self1);
| 14318 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14318 | pyPrepareArgumentConversionErrorsStorage(2);
| 14319 |  |  | 14319 |
| 14320 | { |  | 14320 | {
| 14321 | PyObject* pyobj_img = NULL; |  | 14321 | PyObject* pyobj_img = NULL;
| 14322 | Mat img; |  | 14322 | Mat img;
| 14323 | PyObject* pyobj_points = NULL; |  | 14323 | PyObject* pyobj_points = NULL;
| 14324 | Mat points; |  | 14324 | Mat points;
| 14325 | PyObject* pyobj_straight_code = NULL; |  | 14325 | PyObject* pyobj_straight_code = NULL;
| 14326 | Mat straight_code; |  | 14326 | Mat straight_code;
| 14327 | std::string retval; |  | 14327 | std::string retval;
| 14328 |  |  | 14328 |
| 14329 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14329 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14330 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14330 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14331 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14331 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14332 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 14332 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 14333 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14333 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14334 | { |  | 14334 | {
| 14335 | ERRWRAP2(retval = _self_->detectAndDecode(img, points, straight_code)); |  | 14335 | ERRWRAP2(retval = _self_->detectAndDecode(img, points, straight_code));
| 14336 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_code)); |  | 14336 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_code));
| 14337 | } |  | 14337 | }
| 14338 |  |  | 14338 |
| 14339 |  |  | 14339 |
| 14340 | pyPopulateArgumentConversionErrors(); |  | 14340 | pyPopulateArgumentConversionErrors();
| 14341 | } |  | 14341 | }
| 14342 |  |  | 14342 |
| 14343 |  |  | 14343 |
| 14344 | { |  | 14344 | {
| 14345 | PyObject* pyobj_img = NULL; |  | 14345 | PyObject* pyobj_img = NULL;
| 14346 | UMat img; |  | 14346 | UMat img;
| 14347 | PyObject* pyobj_points = NULL; |  | 14347 | PyObject* pyobj_points = NULL;
| 14348 | UMat points; |  | 14348 | UMat points;
| 14349 | PyObject* pyobj_straight_code = NULL; |  | 14349 | PyObject* pyobj_straight_code = NULL;
| 14350 | UMat straight_code; |  | 14350 | UMat straight_code;
| 14351 | std::string retval; |  | 14351 | std::string retval;
| 14352 |  |  | 14352 |
| 14353 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14353 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14354 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14354 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecode", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14355 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14355 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14356 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 14356 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 14357 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14357 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14358 | { |  | 14358 | {
| 14359 | ERRWRAP2(retval = _self_->detectAndDecode(img, points, straight_code)); |  | 14359 | ERRWRAP2(retval = _self_->detectAndDecode(img, points, straight_code));
| 14360 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_code)); |  | 14360 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_code));
| 14361 | } |  | 14361 | }
| 14362 |  |  | 14362 |
| 14363 |  |  | 14363 |
| 14364 | pyPopulateArgumentConversionErrors(); |  | 14364 | pyPopulateArgumentConversionErrors();
| 14365 | } |  | 14365 | }
| 14366 | pyRaiseCVOverloadException("detectAndDecode"); |  | 14366 | pyRaiseCVOverloadException("detectAndDecode");
| 14367 |  |  | 14367 |
| 14368 | return NULL; |  | 14368 | return NULL;
| 14369 | } |  | 14369 | }
| 14370 |  |  | 14370 |
| 14371 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detectAndDecodeMulti(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14371 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detectAndDecodeMulti(PyObject* self, PyObject* py_args, PyObject* kw)
| 14372 | { |  | 14372 | {
| 14373 | using namespace cv; |  | 14373 | using namespace cv;
| 14374 |  |  | 14374 |
| 14375 |  |  | 14375 |
| 14376 | cv::GraphicalCodeDetector * self1 = 0; |  | 14376 | cv::GraphicalCodeDetector * self1 = 0;
| 14377 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1)) |  | 14377 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1))
| 14378 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)"); |  | 14378 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)");
| 14379 | cv::GraphicalCodeDetector* _self_ = (self1); |  | 14379 | cv::GraphicalCodeDetector* _self_ = (self1);
| 14380 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14380 | pyPrepareArgumentConversionErrorsStorage(2);
| 14381 |  |  | 14381 |
| 14382 | { |  | 14382 | {
| 14383 | PyObject* pyobj_img = NULL; |  | 14383 | PyObject* pyobj_img = NULL;
| 14384 | Mat img; |  | 14384 | Mat img;
| 14385 | vector_string decoded_info; |  | 14385 | vector_string decoded_info;
| 14386 | PyObject* pyobj_points = NULL; |  | 14386 | PyObject* pyobj_points = NULL;
| 14387 | Mat points; |  | 14387 | Mat points;
| 14388 | PyObject* pyobj_straight_code = NULL; |  | 14388 | PyObject* pyobj_straight_code = NULL;
| 14389 | vector_Mat straight_code; |  | 14389 | vector_Mat straight_code;
| 14390 | bool retval; |  | 14390 | bool retval;
| 14391 |  |  | 14391 |
| 14392 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14392 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14393 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14393 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14394 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14394 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14395 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 14395 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 14396 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14396 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14397 | { |  | 14397 | {
| 14398 | ERRWRAP2(retval = _self_->detectAndDecodeMulti(img, decoded_info, points, straight_code)); |  | 14398 | ERRWRAP2(retval = _self_->detectAndDecodeMulti(img, decoded_info, points, straight_code));
| 14399 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(points), pyopencv_from(straight_code)); |  | 14399 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(points), pyopencv_from(straight_code));
| 14400 | } |  | 14400 | }
| 14401 |  |  | 14401 |
| 14402 |  |  | 14402 |
| 14403 | pyPopulateArgumentConversionErrors(); |  | 14403 | pyPopulateArgumentConversionErrors();
| 14404 | } |  | 14404 | }
| 14405 |  |  | 14405 |
| 14406 |  |  | 14406 |
| 14407 | { |  | 14407 | {
| 14408 | PyObject* pyobj_img = NULL; |  | 14408 | PyObject* pyobj_img = NULL;
| 14409 | UMat img; |  | 14409 | UMat img;
| 14410 | vector_string decoded_info; |  | 14410 | vector_string decoded_info;
| 14411 | PyObject* pyobj_points = NULL; |  | 14411 | PyObject* pyobj_points = NULL;
| 14412 | UMat points; |  | 14412 | UMat points;
| 14413 | PyObject* pyobj_straight_code = NULL; |  | 14413 | PyObject* pyobj_straight_code = NULL;
| 14414 | vector_UMat straight_code; |  | 14414 | vector_UMat straight_code;
| 14415 | bool retval; |  | 14415 | bool retval;
| 14416 |  |  | 14416 |
| 14417 | const char* keywords[] = { "img", "points", "straight_code", NULL }; |  | 14417 | const char* keywords[] = { "img", "points", "straight_code", NULL };
| 14418 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) && |  | 14418 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphicalCodeDetector.detectAndDecodeMulti", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_code) &&
| 14419 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14419 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14420 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 14420 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 14421 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) ) |  | 14421 | pyopencv_to_safe(pyobj_straight_code, straight_code, ArgInfo("straight_code", 1)) )
| 14422 | { |  | 14422 | {
| 14423 | ERRWRAP2(retval = _self_->detectAndDecodeMulti(img, decoded_info, points, straight_code)); |  | 14423 | ERRWRAP2(retval = _self_->detectAndDecodeMulti(img, decoded_info, points, straight_code));
| 14424 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(points), pyopencv_from(straight_code)); |  | 14424 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(points), pyopencv_from(straight_code));
| 14425 | } |  | 14425 | }
| 14426 |  |  | 14426 |
| 14427 |  |  | 14427 |
| 14428 | pyPopulateArgumentConversionErrors(); |  | 14428 | pyPopulateArgumentConversionErrors();
| 14429 | } |  | 14429 | }
| 14430 | pyRaiseCVOverloadException("detectAndDecodeMulti"); |  | 14430 | pyRaiseCVOverloadException("detectAndDecodeMulti");
| 14431 |  |  | 14431 |
| 14432 | return NULL; |  | 14432 | return NULL;
| 14433 | } |  | 14433 | }
| 14434 |  |  | 14434 |
| 14435 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detectMulti(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14435 | static PyObject* pyopencv_cv_GraphicalCodeDetector_detectMulti(PyObject* self, PyObject* py_args, PyObject* kw)
| 14436 | { |  | 14436 | {
| 14437 | using namespace cv; |  | 14437 | using namespace cv;
| 14438 |  |  | 14438 |
| 14439 |  |  | 14439 |
| 14440 | cv::GraphicalCodeDetector * self1 = 0; |  | 14440 | cv::GraphicalCodeDetector * self1 = 0;
| 14441 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1)) |  | 14441 | if (!pyopencv_GraphicalCodeDetector_getp(self, self1))
| 14442 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)"); |  | 14442 | return failmsgp("Incorrect type of self (must be 'GraphicalCodeDetector' or its derivative)");
| 14443 | cv::GraphicalCodeDetector* _self_ = (self1); |  | 14443 | cv::GraphicalCodeDetector* _self_ = (self1);
| 14444 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14444 | pyPrepareArgumentConversionErrorsStorage(2);
| 14445 |  |  | 14445 |
| 14446 | { |  | 14446 | {
| 14447 | PyObject* pyobj_img = NULL; |  | 14447 | PyObject* pyobj_img = NULL;
| 14448 | Mat img; |  | 14448 | Mat img;
| 14449 | PyObject* pyobj_points = NULL; |  | 14449 | PyObject* pyobj_points = NULL;
| 14450 | Mat points; |  | 14450 | Mat points;
| 14451 | bool retval; |  | 14451 | bool retval;
| 14452 |  |  | 14452 |
| 14453 | const char* keywords[] = { "img", "points", NULL }; |  | 14453 | const char* keywords[] = { "img", "points", NULL };
| 14454 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detectMulti", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 14454 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detectMulti", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 14455 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14455 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14456 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 14456 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 14457 | { |  | 14457 | {
| 14458 | ERRWRAP2(retval = _self_->detectMulti(img, points)); |  | 14458 | ERRWRAP2(retval = _self_->detectMulti(img, points));
| 14459 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points)); |  | 14459 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points));
| 14460 | } |  | 14460 | }
| 14461 |  |  | 14461 |
| 14462 |  |  | 14462 |
| 14463 | pyPopulateArgumentConversionErrors(); |  | 14463 | pyPopulateArgumentConversionErrors();
| 14464 | } |  | 14464 | }
| 14465 |  |  | 14465 |
| 14466 |  |  | 14466 |
| 14467 | { |  | 14467 | {
| 14468 | PyObject* pyobj_img = NULL; |  | 14468 | PyObject* pyobj_img = NULL;
| 14469 | UMat img; |  | 14469 | UMat img;
| 14470 | PyObject* pyobj_points = NULL; |  | 14470 | PyObject* pyobj_points = NULL;
| 14471 | UMat points; |  | 14471 | UMat points;
| 14472 | bool retval; |  | 14472 | bool retval;
| 14473 |  |  | 14473 |
| 14474 | const char* keywords[] = { "img", "points", NULL }; |  | 14474 | const char* keywords[] = { "img", "points", NULL };
| 14475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detectMulti", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 14475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GraphicalCodeDetector.detectMulti", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 14476 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14476 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14477 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 14477 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 14478 | { |  | 14478 | {
| 14479 | ERRWRAP2(retval = _self_->detectMulti(img, points)); |  | 14479 | ERRWRAP2(retval = _self_->detectMulti(img, points));
| 14480 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points)); |  | 14480 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(points));
| 14481 | } |  | 14481 | }
| 14482 |  |  | 14482 |
| 14483 |  |  | 14483 |
| 14484 | pyPopulateArgumentConversionErrors(); |  | 14484 | pyPopulateArgumentConversionErrors();
| 14485 | } |  | 14485 | }
| 14486 | pyRaiseCVOverloadException("detectMulti"); |  | 14486 | pyRaiseCVOverloadException("detectMulti");
| 14487 |  |  | 14487 |
| 14488 | return NULL; |  | 14488 | return NULL;
| 14489 | } |  | 14489 | }
| 14490 |  |  | 14490 |
| 14491 |  |  | 14491 |
| 14492 |  |  | 14492 |
| 14493 | // Tables (GraphicalCodeDetector) |  | 14493 | // Tables (GraphicalCodeDetector)
| 14494 |  |  | 14494 |
| 14495 | static PyGetSetDef pyopencv_GraphicalCodeDetector_getseters[] = |  | 14495 | static PyGetSetDef pyopencv_GraphicalCodeDetector_getseters[] =
| 14496 | { |  | 14496 | {
| 14497 | {NULL} /* Sentinel */ |  | 14497 | {NULL} /* Sentinel */
| 14498 | }; |  | 14498 | };
| 14499 |  |  | 14499 |
| 14500 | static PyMethodDef pyopencv_GraphicalCodeDetector_methods[] = |  | 14500 | static PyMethodDef pyopencv_GraphicalCodeDetector_methods[] =
| 14501 | { |  | 14501 | {
| 14502 | {"decode", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_decode, 0), "decode(img, points[, straight_code]) -> retval, straight_code\n. @brief Decodes graphical code in image once it's found by the detect() method.\n. \n. Returns UTF8-encoded output string or empty string if the code cannot be decoded.\n. @param img grayscale or color (BGR) image containing graphical code.\n. @param points Quadrangle vertices found by detect() method (or some other algorithm).\n. @param straight_code The optional output image containing binarized code, will be empty if not found."}, |  | 14502 | {"decode", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_decode, 0), "decode(img, points[, straight_code]) -> retval, straight_code\n. @brief Decodes graphical code in image once it's found by the detect() method.\n. \n. Returns UTF8-encoded output string or empty string if the code cannot be decoded.\n. @param img grayscale or color (BGR) image containing graphical code.\n. @param points Quadrangle vertices found by detect() method (or some other algorithm).\n. @param straight_code The optional output image containing binarized code, will be empty if not found."},
| 14503 | {"decodeMulti", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_decodeMulti, 0), "decodeMulti(img, points[, straight_code]) -> retval, decoded_info, straight_code\n. @brief Decodes graphical codes in image once it's found by the detect() method.\n. @param img grayscale or color (BGR) image containing graphical codes.\n. @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.\n. @param points vector of Quadrangle vertices found by detect() method (or some other algorithm).\n. @param straight_code The optional output vector of images containing binarized codes"}, |  | 14503 | {"decodeMulti", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_decodeMulti, 0), "decodeMulti(img, points[, straight_code]) -> retval, decoded_info, straight_code\n. @brief Decodes graphical codes in image once it's found by the detect() method.\n. @param img grayscale or color (BGR) image containing graphical codes.\n. @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.\n. @param points vector of Quadrangle vertices found by detect() method (or some other algorithm).\n. @param straight_code The optional output vector of images containing binarized codes"},
| 14504 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detect, 0), "detect(img[, points]) -> retval, points\n. @brief Detects graphical code in image and returns the quadrangle containing the code.\n. @param img grayscale or color (BGR) image containing (or not) graphical code.\n. @param points Output vector of vertices of the minimum-area quadrangle containing the code."}, |  | 14504 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detect, 0), "detect(img[, points]) -> retval, points\n. @brief Detects graphical code in image and returns the quadrangle containing the code.\n. @param img grayscale or color (BGR) image containing (or not) graphical code.\n. @param points Output vector of vertices of the minimum-area quadrangle containing the code."},
| 14505 | {"detectAndDecode", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detectAndDecode, 0), "detectAndDecode(img[, points[, straight_code]]) -> retval, points, straight_code\n. @brief Both detects and decodes graphical code\n. \n. @param img grayscale or color (BGR) image containing graphical code.\n. @param points optional output array of vertices of the found graphical code quadrangle, will be empty if not found.\n. @param straight_code The optional output image containing binarized code"}, |  | 14505 | {"detectAndDecode", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detectAndDecode, 0), "detectAndDecode(img[, points[, straight_code]]) -> retval, points, straight_code\n. @brief Both detects and decodes graphical code\n. \n. @param img grayscale or color (BGR) image containing graphical code.\n. @param points optional output array of vertices of the found graphical code quadrangle, will be empty if not found.\n. @param straight_code The optional output image containing binarized code"},
| 14506 | {"detectAndDecodeMulti", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detectAndDecodeMulti, 0), "detectAndDecodeMulti(img[, points[, straight_code]]) -> retval, decoded_info, points, straight_code\n. @brief Both detects and decodes graphical codes\n. @param img grayscale or color (BGR) image containing graphical codes.\n. @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.\n. @param points optional output vector of vertices of the found graphical code quadrangles. Will be empty if not found.\n. @param straight_code The optional vector of images containing binarized codes\n. \n. - If there are QR codes encoded with a Structured Append mode on the image and all of them detected and decoded correctly,\n. method writes a full message to position corresponds to 0-th code in a sequence. The rest of QR codes from the same sequence\n. have empty string."}, |  | 14506 | {"detectAndDecodeMulti", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detectAndDecodeMulti, 0), "detectAndDecodeMulti(img[, points[, straight_code]]) -> retval, decoded_info, points, straight_code\n. @brief Both detects and decodes graphical codes\n. @param img grayscale or color (BGR) image containing graphical codes.\n. @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.\n. @param points optional output vector of vertices of the found graphical code quadrangles. Will be empty if not found.\n. @param straight_code The optional vector of images containing binarized codes\n. \n. - If there are QR codes encoded with a Structured Append mode on the image and all of them detected and decoded correctly,\n. method writes a full message to position corresponds to 0-th code in a sequence. The rest of QR codes from the same sequence\n. have empty string."},
| 14507 | {"detectMulti", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detectMulti, 0), "detectMulti(img[, points]) -> retval, points\n. @brief Detects graphical codes in image and returns the vector of the quadrangles containing the codes.\n. @param img grayscale or color (BGR) image containing (or not) graphical codes.\n. @param points Output vector of vector of vertices of the minimum-area quadrangle containing the codes."}, |  | 14507 | {"detectMulti", CV_PY_FN_WITH_KW_(pyopencv_cv_GraphicalCodeDetector_detectMulti, 0), "detectMulti(img[, points]) -> retval, points\n. @brief Detects graphical codes in image and returns the vector of the quadrangles containing the codes.\n. @param img grayscale or color (BGR) image containing (or not) graphical codes.\n. @param points Output vector of vector of vertices of the minimum-area quadrangle containing the codes."},
| 14508 |  |  | 14508 |
| 14509 | {NULL, NULL} |  | 14509 | {NULL, NULL}
| 14510 | }; |  | 14510 | };
| 14511 |  |  | 14511 |
| 14512 | // Converter (GraphicalCodeDetector) |  | 14512 | // Converter (GraphicalCodeDetector)
| 14513 |  |  | 14513 |
| 14514 | template<> |  | 14514 | template<>
| 14515 | struct PyOpenCV_Converter< cv::GraphicalCodeDetector > |  | 14515 | struct PyOpenCV_Converter< cv::GraphicalCodeDetector >
| 14516 | { |  | 14516 | {
| 14517 | static PyObject* from(const cv::GraphicalCodeDetector& r) |  | 14517 | static PyObject* from(const cv::GraphicalCodeDetector& r)
| 14518 | { |  | 14518 | {
| 14519 | return pyopencv_GraphicalCodeDetector_Instance(r); |  | 14519 | return pyopencv_GraphicalCodeDetector_Instance(r);
| 14520 | } |  | 14520 | }
| 14521 | static bool to(PyObject* src, cv::GraphicalCodeDetector& dst, const ArgInfo& info) |  | 14521 | static bool to(PyObject* src, cv::GraphicalCodeDetector& dst, const ArgInfo& info)
| 14522 | { |  | 14522 | {
| 14523 | if(!src || src == Py_None) |  | 14523 | if(!src || src == Py_None)
| 14524 | return true; |  | 14524 | return true;
| 14525 | cv::GraphicalCodeDetector * dst_; |  | 14525 | cv::GraphicalCodeDetector * dst_;
| 14526 | if (pyopencv_GraphicalCodeDetector_getp(src, dst_)) |  | 14526 | if (pyopencv_GraphicalCodeDetector_getp(src, dst_))
| 14527 | { |  | 14527 | {
| 14528 | dst = *dst_; |  | 14528 | dst = *dst_;
| 14529 | return true; |  | 14529 | return true;
| 14530 | } |  | 14530 | }
| 14531 |  |  | 14531 |
| 14532 | failmsg("Expected cv::GraphicalCodeDetector for argument '%s'", info.name); |  | 14532 | failmsg("Expected cv::GraphicalCodeDetector for argument '%s'", info.name);
| 14533 | return false; |  | 14533 | return false;
| 14534 | } |  | 14534 | }
| 14535 | }; |  | 14535 | };
| 14536 |  |  | 14536 |
| 14537 | //================================================================================ |  | 14537 | //================================================================================
| 14538 | // HOGDescriptor (Generic) |  | 14538 | // HOGDescriptor (Generic)
| 14539 | //================================================================================ |  | 14539 | //================================================================================
| 14540 |  |  | 14540 |
| 14541 | // GetSet (HOGDescriptor) |  | 14541 | // GetSet (HOGDescriptor)
| 14542 |  |  | 14542 |
| 14543 |  |  | 14543 |
| 14544 | static PyObject* pyopencv_HOGDescriptor_get_L2HysThreshold(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14544 | static PyObject* pyopencv_HOGDescriptor_get_L2HysThreshold(pyopencv_HOGDescriptor_t* p, void *closure)
| 14545 | { |  | 14545 | {
| 14546 | return pyopencv_from(p->v->L2HysThreshold); |  | 14546 | return pyopencv_from(p->v->L2HysThreshold);
| 14547 | } |  | 14547 | }
| 14548 |  |  | 14548 |
| 14549 | static PyObject* pyopencv_HOGDescriptor_get_blockSize(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14549 | static PyObject* pyopencv_HOGDescriptor_get_blockSize(pyopencv_HOGDescriptor_t* p, void *closure)
| 14550 | { |  | 14550 | {
| 14551 | return pyopencv_from(p->v->blockSize); |  | 14551 | return pyopencv_from(p->v->blockSize);
| 14552 | } |  | 14552 | }
| 14553 |  |  | 14553 |
| 14554 | static PyObject* pyopencv_HOGDescriptor_get_blockStride(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14554 | static PyObject* pyopencv_HOGDescriptor_get_blockStride(pyopencv_HOGDescriptor_t* p, void *closure)
| 14555 | { |  | 14555 | {
| 14556 | return pyopencv_from(p->v->blockStride); |  | 14556 | return pyopencv_from(p->v->blockStride);
| 14557 | } |  | 14557 | }
| 14558 |  |  | 14558 |
| 14559 | static PyObject* pyopencv_HOGDescriptor_get_cellSize(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14559 | static PyObject* pyopencv_HOGDescriptor_get_cellSize(pyopencv_HOGDescriptor_t* p, void *closure)
| 14560 | { |  | 14560 | {
| 14561 | return pyopencv_from(p->v->cellSize); |  | 14561 | return pyopencv_from(p->v->cellSize);
| 14562 | } |  | 14562 | }
| 14563 |  |  | 14563 |
| 14564 | static PyObject* pyopencv_HOGDescriptor_get_derivAperture(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14564 | static PyObject* pyopencv_HOGDescriptor_get_derivAperture(pyopencv_HOGDescriptor_t* p, void *closure)
| 14565 | { |  | 14565 | {
| 14566 | return pyopencv_from(p->v->derivAperture); |  | 14566 | return pyopencv_from(p->v->derivAperture);
| 14567 | } |  | 14567 | }
| 14568 |  |  | 14568 |
| 14569 | static PyObject* pyopencv_HOGDescriptor_get_gammaCorrection(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14569 | static PyObject* pyopencv_HOGDescriptor_get_gammaCorrection(pyopencv_HOGDescriptor_t* p, void *closure)
| 14570 | { |  | 14570 | {
| 14571 | return pyopencv_from(p->v->gammaCorrection); |  | 14571 | return pyopencv_from(p->v->gammaCorrection);
| 14572 | } |  | 14572 | }
| 14573 |  |  | 14573 |
| 14574 | static PyObject* pyopencv_HOGDescriptor_get_histogramNormType(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14574 | static PyObject* pyopencv_HOGDescriptor_get_histogramNormType(pyopencv_HOGDescriptor_t* p, void *closure)
| 14575 | { |  | 14575 | {
| 14576 | return pyopencv_from(p->v->histogramNormType); |  | 14576 | return pyopencv_from(p->v->histogramNormType);
| 14577 | } |  | 14577 | }
| 14578 |  |  | 14578 |
| 14579 | static PyObject* pyopencv_HOGDescriptor_get_nbins(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14579 | static PyObject* pyopencv_HOGDescriptor_get_nbins(pyopencv_HOGDescriptor_t* p, void *closure)
| 14580 | { |  | 14580 | {
| 14581 | return pyopencv_from(p->v->nbins); |  | 14581 | return pyopencv_from(p->v->nbins);
| 14582 | } |  | 14582 | }
| 14583 |  |  | 14583 |
| 14584 | static PyObject* pyopencv_HOGDescriptor_get_nlevels(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14584 | static PyObject* pyopencv_HOGDescriptor_get_nlevels(pyopencv_HOGDescriptor_t* p, void *closure)
| 14585 | { |  | 14585 | {
| 14586 | return pyopencv_from(p->v->nlevels); |  | 14586 | return pyopencv_from(p->v->nlevels);
| 14587 | } |  | 14587 | }
| 14588 |  |  | 14588 |
| 14589 | static PyObject* pyopencv_HOGDescriptor_get_signedGradient(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14589 | static PyObject* pyopencv_HOGDescriptor_get_signedGradient(pyopencv_HOGDescriptor_t* p, void *closure)
| 14590 | { |  | 14590 | {
| 14591 | return pyopencv_from(p->v->signedGradient); |  | 14591 | return pyopencv_from(p->v->signedGradient);
| 14592 | } |  | 14592 | }
| 14593 |  |  | 14593 |
| 14594 | static PyObject* pyopencv_HOGDescriptor_get_svmDetector(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14594 | static PyObject* pyopencv_HOGDescriptor_get_svmDetector(pyopencv_HOGDescriptor_t* p, void *closure)
| 14595 | { |  | 14595 | {
| 14596 | return pyopencv_from(p->v->svmDetector); |  | 14596 | return pyopencv_from(p->v->svmDetector);
| 14597 | } |  | 14597 | }
| 14598 |  |  | 14598 |
| 14599 | static PyObject* pyopencv_HOGDescriptor_get_winSigma(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14599 | static PyObject* pyopencv_HOGDescriptor_get_winSigma(pyopencv_HOGDescriptor_t* p, void *closure)
| 14600 | { |  | 14600 | {
| 14601 | return pyopencv_from(p->v->winSigma); |  | 14601 | return pyopencv_from(p->v->winSigma);
| 14602 | } |  | 14602 | }
| 14603 |  |  | 14603 |
| 14604 | static PyObject* pyopencv_HOGDescriptor_get_winSize(pyopencv_HOGDescriptor_t* p, void *closure) |  | 14604 | static PyObject* pyopencv_HOGDescriptor_get_winSize(pyopencv_HOGDescriptor_t* p, void *closure)
| 14605 | { |  | 14605 | {
| 14606 | return pyopencv_from(p->v->winSize); |  | 14606 | return pyopencv_from(p->v->winSize);
| 14607 | } |  | 14607 | }
| 14608 |  |  | 14608 |
| 14609 |  |  | 14609 |
| 14610 | // Methods (HOGDescriptor) |  | 14610 | // Methods (HOGDescriptor)
| 14611 |  |  | 14611 |
| 14612 | static int pyopencv_cv_HOGDescriptor_HOGDescriptor(pyopencv_HOGDescriptor_t* self, PyObject* py_args, PyObject* kw) |  | 14612 | static int pyopencv_cv_HOGDescriptor_HOGDescriptor(pyopencv_HOGDescriptor_t* self, PyObject* py_args, PyObject* kw)
| 14613 | { |  | 14613 | {
| 14614 | using namespace cv; |  | 14614 | using namespace cv;
| 14615 |  |  | 14615 |
| 14616 | pyPrepareArgumentConversionErrorsStorage(3); |  | 14616 | pyPrepareArgumentConversionErrorsStorage(3);
| 14617 |  |  | 14617 |
| 14618 | { |  | 14618 | {
| 14619 |  |  | 14619 |
| 14620 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 14620 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 14621 | { |  | 14621 | {
| 14622 | new (&(self->v)) Ptr<cv::HOGDescriptor>(); // init Ptr with placement new |  | 14622 | new (&(self->v)) Ptr<cv::HOGDescriptor>(); // init Ptr with placement new
| 14623 | if(self) ERRWRAP2(self->v.reset(new cv::HOGDescriptor())); |  | 14623 | if(self) ERRWRAP2(self->v.reset(new cv::HOGDescriptor()));
| 14624 | return 0; |  | 14624 | return 0;
| 14625 | } |  | 14625 | }
| 14626 |  |  | 14626 |
| 14627 |  |  | 14627 |
| 14628 | pyPopulateArgumentConversionErrors(); |  | 14628 | pyPopulateArgumentConversionErrors();
| 14629 | } |  | 14629 | }
| 14630 |  |  | 14630 |
| 14631 |  |  | 14631 |
| 14632 | { |  | 14632 | {
| 14633 | PyObject* pyobj__winSize = NULL; |  | 14633 | PyObject* pyobj__winSize = NULL;
| 14634 | Size _winSize; |  | 14634 | Size _winSize;
| 14635 | PyObject* pyobj__blockSize = NULL; |  | 14635 | PyObject* pyobj__blockSize = NULL;
| 14636 | Size _blockSize; |  | 14636 | Size _blockSize;
| 14637 | PyObject* pyobj__blockStride = NULL; |  | 14637 | PyObject* pyobj__blockStride = NULL;
| 14638 | Size _blockStride; |  | 14638 | Size _blockStride;
| 14639 | PyObject* pyobj__cellSize = NULL; |  | 14639 | PyObject* pyobj__cellSize = NULL;
| 14640 | Size _cellSize; |  | 14640 | Size _cellSize;
| 14641 | PyObject* pyobj__nbins = NULL; |  | 14641 | PyObject* pyobj__nbins = NULL;
| 14642 | int _nbins=0; |  | 14642 | int _nbins=0;
| 14643 | PyObject* pyobj__derivAperture = NULL; |  | 14643 | PyObject* pyobj__derivAperture = NULL;
| 14644 | int _derivAperture=1; |  | 14644 | int _derivAperture=1;
| 14645 | PyObject* pyobj__winSigma = NULL; |  | 14645 | PyObject* pyobj__winSigma = NULL;
| 14646 | double _winSigma=-1; |  | 14646 | double _winSigma=-1;
| 14647 | PyObject* pyobj__histogramNormType = NULL; |  | 14647 | PyObject* pyobj__histogramNormType = NULL;
| 14648 | HOGDescriptor_HistogramNormType _histogramNormType=HOGDescriptor::L2Hys; |  | 14648 | HOGDescriptor_HistogramNormType _histogramNormType=HOGDescriptor::L2Hys;
| 14649 | PyObject* pyobj__L2HysThreshold = NULL; |  | 14649 | PyObject* pyobj__L2HysThreshold = NULL;
| 14650 | double _L2HysThreshold=0.2; |  | 14650 | double _L2HysThreshold=0.2;
| 14651 | PyObject* pyobj__gammaCorrection = NULL; |  | 14651 | PyObject* pyobj__gammaCorrection = NULL;
| 14652 | bool _gammaCorrection=false; |  | 14652 | bool _gammaCorrection=false;
| 14653 | PyObject* pyobj__nlevels = NULL; |  | 14653 | PyObject* pyobj__nlevels = NULL;
| 14654 | int _nlevels=HOGDescriptor::DEFAULT_NLEVELS; |  | 14654 | int _nlevels=HOGDescriptor::DEFAULT_NLEVELS;
| 14655 | PyObject* pyobj__signedGradient = NULL; |  | 14655 | PyObject* pyobj__signedGradient = NULL;
| 14656 | bool _signedGradient=false; |  | 14656 | bool _signedGradient=false;
| 14657 |  |  | 14657 |
| 14658 | const char* keywords[] = { "_winSize", "_blockSize", "_blockStride", "_cellSize", "_nbins", "_derivAperture", "_winSigma", "_histogramNormType", "_L2HysThreshold", "_gammaCorrection", "_nlevels", "_signedGradient", NULL }; |  | 14658 | const char* keywords[] = { "_winSize", "_blockSize", "_blockStride", "_cellSize", "_nbins", "_derivAperture", "_winSigma", "_histogramNormType", "_L2HysThreshold", "_gammaCorrection", "_nlevels", "_signedGradient", NULL };
| 14659 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOOOOOO:HOGDescriptor", (char**)keywords, &pyobj__winSize, &pyobj__blockSize, &pyobj__blockStride, &pyobj__cellSize, &pyobj__nbins, &pyobj__derivAperture, &pyobj__winSigma, &pyobj__histogramNormType, &pyobj__L2HysThreshold, &pyobj__gammaCorrection, &pyobj__nlevels, &pyobj__signedGradient) && |  | 14659 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOOOOOO:HOGDescriptor", (char**)keywords, &pyobj__winSize, &pyobj__blockSize, &pyobj__blockStride, &pyobj__cellSize, &pyobj__nbins, &pyobj__derivAperture, &pyobj__winSigma, &pyobj__histogramNormType, &pyobj__L2HysThreshold, &pyobj__gammaCorrection, &pyobj__nlevels, &pyobj__signedGradient) &&
| 14660 | pyopencv_to_safe(pyobj__winSize, _winSize, ArgInfo("_winSize", 0)) && |  | 14660 | pyopencv_to_safe(pyobj__winSize, _winSize, ArgInfo("_winSize", 0)) &&
| 14661 | pyopencv_to_safe(pyobj__blockSize, _blockSize, ArgInfo("_blockSize", 0)) && |  | 14661 | pyopencv_to_safe(pyobj__blockSize, _blockSize, ArgInfo("_blockSize", 0)) &&
| 14662 | pyopencv_to_safe(pyobj__blockStride, _blockStride, ArgInfo("_blockStride", 0)) && |  | 14662 | pyopencv_to_safe(pyobj__blockStride, _blockStride, ArgInfo("_blockStride", 0)) &&
| 14663 | pyopencv_to_safe(pyobj__cellSize, _cellSize, ArgInfo("_cellSize", 0)) && |  | 14663 | pyopencv_to_safe(pyobj__cellSize, _cellSize, ArgInfo("_cellSize", 0)) &&
| 14664 | pyopencv_to_safe(pyobj__nbins, _nbins, ArgInfo("_nbins", 0)) && |  | 14664 | pyopencv_to_safe(pyobj__nbins, _nbins, ArgInfo("_nbins", 0)) &&
| 14665 | pyopencv_to_safe(pyobj__derivAperture, _derivAperture, ArgInfo("_derivAperture", 0)) && |  | 14665 | pyopencv_to_safe(pyobj__derivAperture, _derivAperture, ArgInfo("_derivAperture", 0)) &&
| 14666 | pyopencv_to_safe(pyobj__winSigma, _winSigma, ArgInfo("_winSigma", 0)) && |  | 14666 | pyopencv_to_safe(pyobj__winSigma, _winSigma, ArgInfo("_winSigma", 0)) &&
| 14667 | pyopencv_to_safe(pyobj__histogramNormType, _histogramNormType, ArgInfo("_histogramNormType", 0)) && |  | 14667 | pyopencv_to_safe(pyobj__histogramNormType, _histogramNormType, ArgInfo("_histogramNormType", 0)) &&
| 14668 | pyopencv_to_safe(pyobj__L2HysThreshold, _L2HysThreshold, ArgInfo("_L2HysThreshold", 0)) && |  | 14668 | pyopencv_to_safe(pyobj__L2HysThreshold, _L2HysThreshold, ArgInfo("_L2HysThreshold", 0)) &&
| 14669 | pyopencv_to_safe(pyobj__gammaCorrection, _gammaCorrection, ArgInfo("_gammaCorrection", 0)) && |  | 14669 | pyopencv_to_safe(pyobj__gammaCorrection, _gammaCorrection, ArgInfo("_gammaCorrection", 0)) &&
| 14670 | pyopencv_to_safe(pyobj__nlevels, _nlevels, ArgInfo("_nlevels", 0)) && |  | 14670 | pyopencv_to_safe(pyobj__nlevels, _nlevels, ArgInfo("_nlevels", 0)) &&
| 14671 | pyopencv_to_safe(pyobj__signedGradient, _signedGradient, ArgInfo("_signedGradient", 0)) ) |  | 14671 | pyopencv_to_safe(pyobj__signedGradient, _signedGradient, ArgInfo("_signedGradient", 0)) )
| 14672 | { |  | 14672 | {
| 14673 | new (&(self->v)) Ptr<cv::HOGDescriptor>(); // init Ptr with placement new |  | 14673 | new (&(self->v)) Ptr<cv::HOGDescriptor>(); // init Ptr with placement new
| 14674 | if(self) ERRWRAP2(self->v.reset(new cv::HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins, _derivAperture, _winSigma, _histogramNormType, _L2HysThreshold, _gammaCorrection, _nlevels, _signedGradient))); |  | 14674 | if(self) ERRWRAP2(self->v.reset(new cv::HOGDescriptor(_winSize, _blockSize, _blockStride, _cellSize, _nbins, _derivAperture, _winSigma, _histogramNormType, _L2HysThreshold, _gammaCorrection, _nlevels, _signedGradient)));
| 14675 | return 0; |  | 14675 | return 0;
| 14676 | } |  | 14676 | }
| 14677 |  |  | 14677 |
| 14678 |  |  | 14678 |
| 14679 | pyPopulateArgumentConversionErrors(); |  | 14679 | pyPopulateArgumentConversionErrors();
| 14680 | } |  | 14680 | }
| 14681 |  |  | 14681 |
| 14682 |  |  | 14682 |
| 14683 | { |  | 14683 | {
| 14684 | PyObject* pyobj_filename = NULL; |  | 14684 | PyObject* pyobj_filename = NULL;
| 14685 | String filename; |  | 14685 | String filename;
| 14686 |  |  | 14686 |
| 14687 | const char* keywords[] = { "filename", NULL }; |  | 14687 | const char* keywords[] = { "filename", NULL };
| 14688 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HOGDescriptor", (char**)keywords, &pyobj_filename) && |  | 14688 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HOGDescriptor", (char**)keywords, &pyobj_filename) &&
| 14689 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 14689 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 14690 | { |  | 14690 | {
| 14691 | new (&(self->v)) Ptr<cv::HOGDescriptor>(); // init Ptr with placement new |  | 14691 | new (&(self->v)) Ptr<cv::HOGDescriptor>(); // init Ptr with placement new
| 14692 | if(self) ERRWRAP2(self->v.reset(new cv::HOGDescriptor(filename))); |  | 14692 | if(self) ERRWRAP2(self->v.reset(new cv::HOGDescriptor(filename)));
| 14693 | return 0; |  | 14693 | return 0;
| 14694 | } |  | 14694 | }
| 14695 |  |  | 14695 |
| 14696 |  |  | 14696 |
| 14697 | pyPopulateArgumentConversionErrors(); |  | 14697 | pyPopulateArgumentConversionErrors();
| 14698 | } |  | 14698 | }
| 14699 | pyRaiseCVOverloadException("HOGDescriptor"); |  | 14699 | pyRaiseCVOverloadException("HOGDescriptor");
| 14700 |  |  | 14700 |
| 14701 | return -1; |  | 14701 | return -1;
| 14702 | } |  | 14702 | }
| 14703 |  |  | 14703 |
| 14704 | static PyObject* pyopencv_cv_HOGDescriptor_checkDetectorSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14704 | static PyObject* pyopencv_cv_HOGDescriptor_checkDetectorSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 14705 | { |  | 14705 | {
| 14706 | using namespace cv; |  | 14706 | using namespace cv;
| 14707 |  |  | 14707 |
| 14708 |  |  | 14708 |
| 14709 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 14709 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 14710 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 14710 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 14711 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 14711 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 14712 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 14712 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 14713 | bool retval; |  | 14713 | bool retval;
| 14714 |  |  | 14714 |
| 14715 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 14715 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 14716 | { |  | 14716 | {
| 14717 | ERRWRAP2(retval = _self_->checkDetectorSize()); |  | 14717 | ERRWRAP2(retval = _self_->checkDetectorSize());
| 14718 | return pyopencv_from(retval); |  | 14718 | return pyopencv_from(retval);
| 14719 | } |  | 14719 | }
| 14720 |  |  | 14720 |
| 14721 | return NULL; |  | 14721 | return NULL;
| 14722 | } |  | 14722 | }
| 14723 |  |  | 14723 |
| 14724 | static PyObject* pyopencv_cv_HOGDescriptor_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14724 | static PyObject* pyopencv_cv_HOGDescriptor_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 14725 | { |  | 14725 | {
| 14726 | using namespace cv; |  | 14726 | using namespace cv;
| 14727 |  |  | 14727 |
| 14728 |  |  | 14728 |
| 14729 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 14729 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 14730 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 14730 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 14731 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 14731 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 14732 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 14732 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 14733 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14733 | pyPrepareArgumentConversionErrorsStorage(2);
| 14734 |  |  | 14734 |
| 14735 | { |  | 14735 | {
| 14736 | PyObject* pyobj_img = NULL; |  | 14736 | PyObject* pyobj_img = NULL;
| 14737 | Mat img; |  | 14737 | Mat img;
| 14738 | vector_float descriptors; |  | 14738 | vector_float descriptors;
| 14739 | PyObject* pyobj_winStride = NULL; |  | 14739 | PyObject* pyobj_winStride = NULL;
| 14740 | Size winStride; |  | 14740 | Size winStride;
| 14741 | PyObject* pyobj_padding = NULL; |  | 14741 | PyObject* pyobj_padding = NULL;
| 14742 | Size padding; |  | 14742 | Size padding;
| 14743 | PyObject* pyobj_locations = NULL; |  | 14743 | PyObject* pyobj_locations = NULL;
| 14744 | vector_Point locations=std::vector<Point>(); |  | 14744 | vector_Point locations=std::vector<Point>();
| 14745 |  |  | 14745 |
| 14746 | const char* keywords[] = { "img", "winStride", "padding", "locations", NULL }; |  | 14746 | const char* keywords[] = { "img", "winStride", "padding", "locations", NULL };
| 14747 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:HOGDescriptor.compute", (char**)keywords, &pyobj_img, &pyobj_winStride, &pyobj_padding, &pyobj_locations) && |  | 14747 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:HOGDescriptor.compute", (char**)keywords, &pyobj_img, &pyobj_winStride, &pyobj_padding, &pyobj_locations) &&
| 14748 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14748 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14749 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) && |  | 14749 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) &&
| 14750 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) && |  | 14750 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) &&
| 14751 | pyopencv_to_safe(pyobj_locations, locations, ArgInfo("locations", 0)) ) |  | 14751 | pyopencv_to_safe(pyobj_locations, locations, ArgInfo("locations", 0)) )
| 14752 | { |  | 14752 | {
| 14753 | ERRWRAP2(_self_->compute(img, descriptors, winStride, padding, locations)); |  | 14753 | ERRWRAP2(_self_->compute(img, descriptors, winStride, padding, locations));
| 14754 | return pyopencv_from(descriptors); |  | 14754 | return pyopencv_from(descriptors);
| 14755 | } |  | 14755 | }
| 14756 |  |  | 14756 |
| 14757 |  |  | 14757 |
| 14758 | pyPopulateArgumentConversionErrors(); |  | 14758 | pyPopulateArgumentConversionErrors();
| 14759 | } |  | 14759 | }
| 14760 |  |  | 14760 |
| 14761 |  |  | 14761 |
| 14762 | { |  | 14762 | {
| 14763 | PyObject* pyobj_img = NULL; |  | 14763 | PyObject* pyobj_img = NULL;
| 14764 | UMat img; |  | 14764 | UMat img;
| 14765 | vector_float descriptors; |  | 14765 | vector_float descriptors;
| 14766 | PyObject* pyobj_winStride = NULL; |  | 14766 | PyObject* pyobj_winStride = NULL;
| 14767 | Size winStride; |  | 14767 | Size winStride;
| 14768 | PyObject* pyobj_padding = NULL; |  | 14768 | PyObject* pyobj_padding = NULL;
| 14769 | Size padding; |  | 14769 | Size padding;
| 14770 | PyObject* pyobj_locations = NULL; |  | 14770 | PyObject* pyobj_locations = NULL;
| 14771 | vector_Point locations=std::vector<Point>(); |  | 14771 | vector_Point locations=std::vector<Point>();
| 14772 |  |  | 14772 |
| 14773 | const char* keywords[] = { "img", "winStride", "padding", "locations", NULL }; |  | 14773 | const char* keywords[] = { "img", "winStride", "padding", "locations", NULL };
| 14774 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:HOGDescriptor.compute", (char**)keywords, &pyobj_img, &pyobj_winStride, &pyobj_padding, &pyobj_locations) && |  | 14774 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:HOGDescriptor.compute", (char**)keywords, &pyobj_img, &pyobj_winStride, &pyobj_padding, &pyobj_locations) &&
| 14775 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14775 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14776 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) && |  | 14776 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) &&
| 14777 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) && |  | 14777 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) &&
| 14778 | pyopencv_to_safe(pyobj_locations, locations, ArgInfo("locations", 0)) ) |  | 14778 | pyopencv_to_safe(pyobj_locations, locations, ArgInfo("locations", 0)) )
| 14779 | { |  | 14779 | {
| 14780 | ERRWRAP2(_self_->compute(img, descriptors, winStride, padding, locations)); |  | 14780 | ERRWRAP2(_self_->compute(img, descriptors, winStride, padding, locations));
| 14781 | return pyopencv_from(descriptors); |  | 14781 | return pyopencv_from(descriptors);
| 14782 | } |  | 14782 | }
| 14783 |  |  | 14783 |
| 14784 |  |  | 14784 |
| 14785 | pyPopulateArgumentConversionErrors(); |  | 14785 | pyPopulateArgumentConversionErrors();
| 14786 | } |  | 14786 | }
| 14787 | pyRaiseCVOverloadException("compute"); |  | 14787 | pyRaiseCVOverloadException("compute");
| 14788 |  |  | 14788 |
| 14789 | return NULL; |  | 14789 | return NULL;
| 14790 | } |  | 14790 | }
| 14791 |  |  | 14791 |
| 14792 | static PyObject* pyopencv_cv_HOGDescriptor_computeGradient(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14792 | static PyObject* pyopencv_cv_HOGDescriptor_computeGradient(PyObject* self, PyObject* py_args, PyObject* kw)
| 14793 | { |  | 14793 | {
| 14794 | using namespace cv; |  | 14794 | using namespace cv;
| 14795 |  |  | 14795 |
| 14796 |  |  | 14796 |
| 14797 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 14797 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 14798 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 14798 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 14799 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 14799 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 14800 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 14800 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 14801 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14801 | pyPrepareArgumentConversionErrorsStorage(2);
| 14802 |  |  | 14802 |
| 14803 | { |  | 14803 | {
| 14804 | PyObject* pyobj_img = NULL; |  | 14804 | PyObject* pyobj_img = NULL;
| 14805 | Mat img; |  | 14805 | Mat img;
| 14806 | PyObject* pyobj_grad = NULL; |  | 14806 | PyObject* pyobj_grad = NULL;
| 14807 | Mat grad; |  | 14807 | Mat grad;
| 14808 | PyObject* pyobj_angleOfs = NULL; |  | 14808 | PyObject* pyobj_angleOfs = NULL;
| 14809 | Mat angleOfs; |  | 14809 | Mat angleOfs;
| 14810 | PyObject* pyobj_paddingTL = NULL; |  | 14810 | PyObject* pyobj_paddingTL = NULL;
| 14811 | Size paddingTL; |  | 14811 | Size paddingTL;
| 14812 | PyObject* pyobj_paddingBR = NULL; |  | 14812 | PyObject* pyobj_paddingBR = NULL;
| 14813 | Size paddingBR; |  | 14813 | Size paddingBR;
| 14814 |  |  | 14814 |
| 14815 | const char* keywords[] = { "img", "grad", "angleOfs", "paddingTL", "paddingBR", NULL }; |  | 14815 | const char* keywords[] = { "img", "grad", "angleOfs", "paddingTL", "paddingBR", NULL };
| 14816 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:HOGDescriptor.computeGradient", (char**)keywords, &pyobj_img, &pyobj_grad, &pyobj_angleOfs, &pyobj_paddingTL, &pyobj_paddingBR) && |  | 14816 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:HOGDescriptor.computeGradient", (char**)keywords, &pyobj_img, &pyobj_grad, &pyobj_angleOfs, &pyobj_paddingTL, &pyobj_paddingBR) &&
| 14817 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14817 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14818 | pyopencv_to_safe(pyobj_grad, grad, ArgInfo("grad", 1)) && |  | 14818 | pyopencv_to_safe(pyobj_grad, grad, ArgInfo("grad", 1)) &&
| 14819 | pyopencv_to_safe(pyobj_angleOfs, angleOfs, ArgInfo("angleOfs", 1)) && |  | 14819 | pyopencv_to_safe(pyobj_angleOfs, angleOfs, ArgInfo("angleOfs", 1)) &&
| 14820 | pyopencv_to_safe(pyobj_paddingTL, paddingTL, ArgInfo("paddingTL", 0)) && |  | 14820 | pyopencv_to_safe(pyobj_paddingTL, paddingTL, ArgInfo("paddingTL", 0)) &&
| 14821 | pyopencv_to_safe(pyobj_paddingBR, paddingBR, ArgInfo("paddingBR", 0)) ) |  | 14821 | pyopencv_to_safe(pyobj_paddingBR, paddingBR, ArgInfo("paddingBR", 0)) )
| 14822 | { |  | 14822 | {
| 14823 | ERRWRAP2(_self_->computeGradient(img, grad, angleOfs, paddingTL, paddingBR)); |  | 14823 | ERRWRAP2(_self_->computeGradient(img, grad, angleOfs, paddingTL, paddingBR));
| 14824 | return Py_BuildValue("(NN)", pyopencv_from(grad), pyopencv_from(angleOfs)); |  | 14824 | return Py_BuildValue("(NN)", pyopencv_from(grad), pyopencv_from(angleOfs));
| 14825 | } |  | 14825 | }
| 14826 |  |  | 14826 |
| 14827 |  |  | 14827 |
| 14828 | pyPopulateArgumentConversionErrors(); |  | 14828 | pyPopulateArgumentConversionErrors();
| 14829 | } |  | 14829 | }
| 14830 |  |  | 14830 |
| 14831 |  |  | 14831 |
| 14832 | { |  | 14832 | {
| 14833 | PyObject* pyobj_img = NULL; |  | 14833 | PyObject* pyobj_img = NULL;
| 14834 | UMat img; |  | 14834 | UMat img;
| 14835 | PyObject* pyobj_grad = NULL; |  | 14835 | PyObject* pyobj_grad = NULL;
| 14836 | UMat grad; |  | 14836 | UMat grad;
| 14837 | PyObject* pyobj_angleOfs = NULL; |  | 14837 | PyObject* pyobj_angleOfs = NULL;
| 14838 | UMat angleOfs; |  | 14838 | UMat angleOfs;
| 14839 | PyObject* pyobj_paddingTL = NULL; |  | 14839 | PyObject* pyobj_paddingTL = NULL;
| 14840 | Size paddingTL; |  | 14840 | Size paddingTL;
| 14841 | PyObject* pyobj_paddingBR = NULL; |  | 14841 | PyObject* pyobj_paddingBR = NULL;
| 14842 | Size paddingBR; |  | 14842 | Size paddingBR;
| 14843 |  |  | 14843 |
| 14844 | const char* keywords[] = { "img", "grad", "angleOfs", "paddingTL", "paddingBR", NULL }; |  | 14844 | const char* keywords[] = { "img", "grad", "angleOfs", "paddingTL", "paddingBR", NULL };
| 14845 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:HOGDescriptor.computeGradient", (char**)keywords, &pyobj_img, &pyobj_grad, &pyobj_angleOfs, &pyobj_paddingTL, &pyobj_paddingBR) && |  | 14845 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:HOGDescriptor.computeGradient", (char**)keywords, &pyobj_img, &pyobj_grad, &pyobj_angleOfs, &pyobj_paddingTL, &pyobj_paddingBR) &&
| 14846 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14846 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14847 | pyopencv_to_safe(pyobj_grad, grad, ArgInfo("grad", 1)) && |  | 14847 | pyopencv_to_safe(pyobj_grad, grad, ArgInfo("grad", 1)) &&
| 14848 | pyopencv_to_safe(pyobj_angleOfs, angleOfs, ArgInfo("angleOfs", 1)) && |  | 14848 | pyopencv_to_safe(pyobj_angleOfs, angleOfs, ArgInfo("angleOfs", 1)) &&
| 14849 | pyopencv_to_safe(pyobj_paddingTL, paddingTL, ArgInfo("paddingTL", 0)) && |  | 14849 | pyopencv_to_safe(pyobj_paddingTL, paddingTL, ArgInfo("paddingTL", 0)) &&
| 14850 | pyopencv_to_safe(pyobj_paddingBR, paddingBR, ArgInfo("paddingBR", 0)) ) |  | 14850 | pyopencv_to_safe(pyobj_paddingBR, paddingBR, ArgInfo("paddingBR", 0)) )
| 14851 | { |  | 14851 | {
| 14852 | ERRWRAP2(_self_->computeGradient(img, grad, angleOfs, paddingTL, paddingBR)); |  | 14852 | ERRWRAP2(_self_->computeGradient(img, grad, angleOfs, paddingTL, paddingBR));
| 14853 | return Py_BuildValue("(NN)", pyopencv_from(grad), pyopencv_from(angleOfs)); |  | 14853 | return Py_BuildValue("(NN)", pyopencv_from(grad), pyopencv_from(angleOfs));
| 14854 | } |  | 14854 | }
| 14855 |  |  | 14855 |
| 14856 |  |  | 14856 |
| 14857 | pyPopulateArgumentConversionErrors(); |  | 14857 | pyPopulateArgumentConversionErrors();
| 14858 | } |  | 14858 | }
| 14859 | pyRaiseCVOverloadException("computeGradient"); |  | 14859 | pyRaiseCVOverloadException("computeGradient");
| 14860 |  |  | 14860 |
| 14861 | return NULL; |  | 14861 | return NULL;
| 14862 | } |  | 14862 | }
| 14863 |  |  | 14863 |
| 14864 | static PyObject* pyopencv_cv_HOGDescriptor_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14864 | static PyObject* pyopencv_cv_HOGDescriptor_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 14865 | { |  | 14865 | {
| 14866 | using namespace cv; |  | 14866 | using namespace cv;
| 14867 |  |  | 14867 |
| 14868 |  |  | 14868 |
| 14869 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 14869 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 14870 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 14870 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 14871 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 14871 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 14872 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 14872 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 14873 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14873 | pyPrepareArgumentConversionErrorsStorage(2);
| 14874 |  |  | 14874 |
| 14875 | { |  | 14875 | {
| 14876 | PyObject* pyobj_img = NULL; |  | 14876 | PyObject* pyobj_img = NULL;
| 14877 | Mat img; |  | 14877 | Mat img;
| 14878 | vector_Point foundLocations; |  | 14878 | vector_Point foundLocations;
| 14879 | vector_double weights; |  | 14879 | vector_double weights;
| 14880 | PyObject* pyobj_hitThreshold = NULL; |  | 14880 | PyObject* pyobj_hitThreshold = NULL;
| 14881 | double hitThreshold=0; |  | 14881 | double hitThreshold=0;
| 14882 | PyObject* pyobj_winStride = NULL; |  | 14882 | PyObject* pyobj_winStride = NULL;
| 14883 | Size winStride; |  | 14883 | Size winStride;
| 14884 | PyObject* pyobj_padding = NULL; |  | 14884 | PyObject* pyobj_padding = NULL;
| 14885 | Size padding; |  | 14885 | Size padding;
| 14886 | PyObject* pyobj_searchLocations = NULL; |  | 14886 | PyObject* pyobj_searchLocations = NULL;
| 14887 | vector_Point searchLocations=std::vector<Point>(); |  | 14887 | vector_Point searchLocations=std::vector<Point>();
| 14888 |  |  | 14888 |
| 14889 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "searchLocations", NULL }; |  | 14889 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "searchLocations", NULL };
| 14890 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:HOGDescriptor.detect", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_searchLocations) && |  | 14890 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:HOGDescriptor.detect", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_searchLocations) &&
| 14891 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14891 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14892 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) && |  | 14892 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) &&
| 14893 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) && |  | 14893 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) &&
| 14894 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) && |  | 14894 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) &&
| 14895 | pyopencv_to_safe(pyobj_searchLocations, searchLocations, ArgInfo("searchLocations", 0)) ) |  | 14895 | pyopencv_to_safe(pyobj_searchLocations, searchLocations, ArgInfo("searchLocations", 0)) )
| 14896 | { |  | 14896 | {
| 14897 | ERRWRAP2(_self_->detect(img, foundLocations, weights, hitThreshold, winStride, padding, searchLocations)); |  | 14897 | ERRWRAP2(_self_->detect(img, foundLocations, weights, hitThreshold, winStride, padding, searchLocations));
| 14898 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(weights)); |  | 14898 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(weights));
| 14899 | } |  | 14899 | }
| 14900 |  |  | 14900 |
| 14901 |  |  | 14901 |
| 14902 | pyPopulateArgumentConversionErrors(); |  | 14902 | pyPopulateArgumentConversionErrors();
| 14903 | } |  | 14903 | }
| 14904 |  |  | 14904 |
| 14905 |  |  | 14905 |
| 14906 | { |  | 14906 | {
| 14907 | PyObject* pyobj_img = NULL; |  | 14907 | PyObject* pyobj_img = NULL;
| 14908 | UMat img; |  | 14908 | UMat img;
| 14909 | vector_Point foundLocations; |  | 14909 | vector_Point foundLocations;
| 14910 | vector_double weights; |  | 14910 | vector_double weights;
| 14911 | PyObject* pyobj_hitThreshold = NULL; |  | 14911 | PyObject* pyobj_hitThreshold = NULL;
| 14912 | double hitThreshold=0; |  | 14912 | double hitThreshold=0;
| 14913 | PyObject* pyobj_winStride = NULL; |  | 14913 | PyObject* pyobj_winStride = NULL;
| 14914 | Size winStride; |  | 14914 | Size winStride;
| 14915 | PyObject* pyobj_padding = NULL; |  | 14915 | PyObject* pyobj_padding = NULL;
| 14916 | Size padding; |  | 14916 | Size padding;
| 14917 | PyObject* pyobj_searchLocations = NULL; |  | 14917 | PyObject* pyobj_searchLocations = NULL;
| 14918 | vector_Point searchLocations=std::vector<Point>(); |  | 14918 | vector_Point searchLocations=std::vector<Point>();
| 14919 |  |  | 14919 |
| 14920 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "searchLocations", NULL }; |  | 14920 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "searchLocations", NULL };
| 14921 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:HOGDescriptor.detect", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_searchLocations) && |  | 14921 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:HOGDescriptor.detect", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_searchLocations) &&
| 14922 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14922 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14923 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) && |  | 14923 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) &&
| 14924 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) && |  | 14924 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) &&
| 14925 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) && |  | 14925 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) &&
| 14926 | pyopencv_to_safe(pyobj_searchLocations, searchLocations, ArgInfo("searchLocations", 0)) ) |  | 14926 | pyopencv_to_safe(pyobj_searchLocations, searchLocations, ArgInfo("searchLocations", 0)) )
| 14927 | { |  | 14927 | {
| 14928 | ERRWRAP2(_self_->detect(img, foundLocations, weights, hitThreshold, winStride, padding, searchLocations)); |  | 14928 | ERRWRAP2(_self_->detect(img, foundLocations, weights, hitThreshold, winStride, padding, searchLocations));
| 14929 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(weights)); |  | 14929 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(weights));
| 14930 | } |  | 14930 | }
| 14931 |  |  | 14931 |
| 14932 |  |  | 14932 |
| 14933 | pyPopulateArgumentConversionErrors(); |  | 14933 | pyPopulateArgumentConversionErrors();
| 14934 | } |  | 14934 | }
| 14935 | pyRaiseCVOverloadException("detect"); |  | 14935 | pyRaiseCVOverloadException("detect");
| 14936 |  |  | 14936 |
| 14937 | return NULL; |  | 14937 | return NULL;
| 14938 | } |  | 14938 | }
| 14939 |  |  | 14939 |
| 14940 | static PyObject* pyopencv_cv_HOGDescriptor_detectMultiScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 14940 | static PyObject* pyopencv_cv_HOGDescriptor_detectMultiScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 14941 | { |  | 14941 | {
| 14942 | using namespace cv; |  | 14942 | using namespace cv;
| 14943 |  |  | 14943 |
| 14944 |  |  | 14944 |
| 14945 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 14945 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 14946 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 14946 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 14947 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 14947 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 14948 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 14948 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 14949 | pyPrepareArgumentConversionErrorsStorage(2); |  | 14949 | pyPrepareArgumentConversionErrorsStorage(2);
| 14950 |  |  | 14950 |
| 14951 | { |  | 14951 | {
| 14952 | PyObject* pyobj_img = NULL; |  | 14952 | PyObject* pyobj_img = NULL;
| 14953 | Mat img; |  | 14953 | Mat img;
| 14954 | vector_Rect foundLocations; |  | 14954 | vector_Rect foundLocations;
| 14955 | vector_double foundWeights; |  | 14955 | vector_double foundWeights;
| 14956 | PyObject* pyobj_hitThreshold = NULL; |  | 14956 | PyObject* pyobj_hitThreshold = NULL;
| 14957 | double hitThreshold=0; |  | 14957 | double hitThreshold=0;
| 14958 | PyObject* pyobj_winStride = NULL; |  | 14958 | PyObject* pyobj_winStride = NULL;
| 14959 | Size winStride; |  | 14959 | Size winStride;
| 14960 | PyObject* pyobj_padding = NULL; |  | 14960 | PyObject* pyobj_padding = NULL;
| 14961 | Size padding; |  | 14961 | Size padding;
| 14962 | PyObject* pyobj_scale = NULL; |  | 14962 | PyObject* pyobj_scale = NULL;
| 14963 | double scale=1.05; |  | 14963 | double scale=1.05;
| 14964 | PyObject* pyobj_groupThreshold = NULL; |  | 14964 | PyObject* pyobj_groupThreshold = NULL;
| 14965 | double groupThreshold=2.0; |  | 14965 | double groupThreshold=2.0;
| 14966 | PyObject* pyobj_useMeanshiftGrouping = NULL; |  | 14966 | PyObject* pyobj_useMeanshiftGrouping = NULL;
| 14967 | bool useMeanshiftGrouping=false; |  | 14967 | bool useMeanshiftGrouping=false;
| 14968 |  |  | 14968 |
| 14969 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "scale", "groupThreshold", "useMeanshiftGrouping", NULL }; |  | 14969 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "scale", "groupThreshold", "useMeanshiftGrouping", NULL };
| 14970 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:HOGDescriptor.detectMultiScale", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_scale, &pyobj_groupThreshold, &pyobj_useMeanshiftGrouping) && |  | 14970 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:HOGDescriptor.detectMultiScale", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_scale, &pyobj_groupThreshold, &pyobj_useMeanshiftGrouping) &&
| 14971 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 14971 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 14972 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) && |  | 14972 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) &&
| 14973 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) && |  | 14973 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) &&
| 14974 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) && |  | 14974 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) &&
| 14975 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) && |  | 14975 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) &&
| 14976 | pyopencv_to_safe(pyobj_groupThreshold, groupThreshold, ArgInfo("groupThreshold", 0)) && |  | 14976 | pyopencv_to_safe(pyobj_groupThreshold, groupThreshold, ArgInfo("groupThreshold", 0)) &&
| 14977 | pyopencv_to_safe(pyobj_useMeanshiftGrouping, useMeanshiftGrouping, ArgInfo("useMeanshiftGrouping", 0)) ) |  | 14977 | pyopencv_to_safe(pyobj_useMeanshiftGrouping, useMeanshiftGrouping, ArgInfo("useMeanshiftGrouping", 0)) )
| 14978 | { |  | 14978 | {
| 14979 | ERRWRAP2(_self_->detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride, padding, scale, groupThreshold, useMeanshiftGrouping)); |  | 14979 | ERRWRAP2(_self_->detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride, padding, scale, groupThreshold, useMeanshiftGrouping));
| 14980 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(foundWeights)); |  | 14980 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(foundWeights));
| 14981 | } |  | 14981 | }
| 14982 |  |  | 14982 |
| 14983 |  |  | 14983 |
| 14984 | pyPopulateArgumentConversionErrors(); |  | 14984 | pyPopulateArgumentConversionErrors();
| 14985 | } |  | 14985 | }
| 14986 |  |  | 14986 |
| 14987 |  |  | 14987 |
| 14988 | { |  | 14988 | {
| 14989 | PyObject* pyobj_img = NULL; |  | 14989 | PyObject* pyobj_img = NULL;
| 14990 | UMat img; |  | 14990 | UMat img;
| 14991 | vector_Rect foundLocations; |  | 14991 | vector_Rect foundLocations;
| 14992 | vector_double foundWeights; |  | 14992 | vector_double foundWeights;
| 14993 | PyObject* pyobj_hitThreshold = NULL; |  | 14993 | PyObject* pyobj_hitThreshold = NULL;
| 14994 | double hitThreshold=0; |  | 14994 | double hitThreshold=0;
| 14995 | PyObject* pyobj_winStride = NULL; |  | 14995 | PyObject* pyobj_winStride = NULL;
| 14996 | Size winStride; |  | 14996 | Size winStride;
| 14997 | PyObject* pyobj_padding = NULL; |  | 14997 | PyObject* pyobj_padding = NULL;
| 14998 | Size padding; |  | 14998 | Size padding;
| 14999 | PyObject* pyobj_scale = NULL; |  | 14999 | PyObject* pyobj_scale = NULL;
| 15000 | double scale=1.05; |  | 15000 | double scale=1.05;
| 15001 | PyObject* pyobj_groupThreshold = NULL; |  | 15001 | PyObject* pyobj_groupThreshold = NULL;
| 15002 | double groupThreshold=2.0; |  | 15002 | double groupThreshold=2.0;
| 15003 | PyObject* pyobj_useMeanshiftGrouping = NULL; |  | 15003 | PyObject* pyobj_useMeanshiftGrouping = NULL;
| 15004 | bool useMeanshiftGrouping=false; |  | 15004 | bool useMeanshiftGrouping=false;
| 15005 |  |  | 15005 |
| 15006 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "scale", "groupThreshold", "useMeanshiftGrouping", NULL }; |  | 15006 | const char* keywords[] = { "img", "hitThreshold", "winStride", "padding", "scale", "groupThreshold", "useMeanshiftGrouping", NULL };
| 15007 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:HOGDescriptor.detectMultiScale", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_scale, &pyobj_groupThreshold, &pyobj_useMeanshiftGrouping) && |  | 15007 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:HOGDescriptor.detectMultiScale", (char**)keywords, &pyobj_img, &pyobj_hitThreshold, &pyobj_winStride, &pyobj_padding, &pyobj_scale, &pyobj_groupThreshold, &pyobj_useMeanshiftGrouping) &&
| 15008 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 15008 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 15009 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) && |  | 15009 | pyopencv_to_safe(pyobj_hitThreshold, hitThreshold, ArgInfo("hitThreshold", 0)) &&
| 15010 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) && |  | 15010 | pyopencv_to_safe(pyobj_winStride, winStride, ArgInfo("winStride", 0)) &&
| 15011 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) && |  | 15011 | pyopencv_to_safe(pyobj_padding, padding, ArgInfo("padding", 0)) &&
| 15012 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) && |  | 15012 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) &&
| 15013 | pyopencv_to_safe(pyobj_groupThreshold, groupThreshold, ArgInfo("groupThreshold", 0)) && |  | 15013 | pyopencv_to_safe(pyobj_groupThreshold, groupThreshold, ArgInfo("groupThreshold", 0)) &&
| 15014 | pyopencv_to_safe(pyobj_useMeanshiftGrouping, useMeanshiftGrouping, ArgInfo("useMeanshiftGrouping", 0)) ) |  | 15014 | pyopencv_to_safe(pyobj_useMeanshiftGrouping, useMeanshiftGrouping, ArgInfo("useMeanshiftGrouping", 0)) )
| 15015 | { |  | 15015 | {
| 15016 | ERRWRAP2(_self_->detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride, padding, scale, groupThreshold, useMeanshiftGrouping)); |  | 15016 | ERRWRAP2(_self_->detectMultiScale(img, foundLocations, foundWeights, hitThreshold, winStride, padding, scale, groupThreshold, useMeanshiftGrouping));
| 15017 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(foundWeights)); |  | 15017 | return Py_BuildValue("(NN)", pyopencv_from(foundLocations), pyopencv_from(foundWeights));
| 15018 | } |  | 15018 | }
| 15019 |  |  | 15019 |
| 15020 |  |  | 15020 |
| 15021 | pyPopulateArgumentConversionErrors(); |  | 15021 | pyPopulateArgumentConversionErrors();
| 15022 | } |  | 15022 | }
| 15023 | pyRaiseCVOverloadException("detectMultiScale"); |  | 15023 | pyRaiseCVOverloadException("detectMultiScale");
| 15024 |  |  | 15024 |
| 15025 | return NULL; |  | 15025 | return NULL;
| 15026 | } |  | 15026 | }
| 15027 |  |  | 15027 |
| 15028 | static PyObject* pyopencv_cv_HOGDescriptor_getDaimlerPeopleDetector_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15028 | static PyObject* pyopencv_cv_HOGDescriptor_getDaimlerPeopleDetector_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 15029 | { |  | 15029 | {
| 15030 | using namespace cv; |  | 15030 | using namespace cv;
| 15031 |  |  | 15031 |
| 15032 | std::vector<float> retval; |  | 15032 | std::vector<float> retval;
| 15033 |  |  | 15033 |
| 15034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15035 | { |  | 15035 | {
| 15036 | ERRWRAP2(retval = cv::HOGDescriptor::getDaimlerPeopleDetector()); |  | 15036 | ERRWRAP2(retval = cv::HOGDescriptor::getDaimlerPeopleDetector());
| 15037 | return pyopencv_from(retval); |  | 15037 | return pyopencv_from(retval);
| 15038 | } |  | 15038 | }
| 15039 |  |  | 15039 |
| 15040 | return NULL; |  | 15040 | return NULL;
| 15041 | } |  | 15041 | }
| 15042 |  |  | 15042 |
| 15043 | static PyObject* pyopencv_cv_HOGDescriptor_getDefaultPeopleDetector_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15043 | static PyObject* pyopencv_cv_HOGDescriptor_getDefaultPeopleDetector_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 15044 | { |  | 15044 | {
| 15045 | using namespace cv; |  | 15045 | using namespace cv;
| 15046 |  |  | 15046 |
| 15047 | std::vector<float> retval; |  | 15047 | std::vector<float> retval;
| 15048 |  |  | 15048 |
| 15049 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15049 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15050 | { |  | 15050 | {
| 15051 | ERRWRAP2(retval = cv::HOGDescriptor::getDefaultPeopleDetector()); |  | 15051 | ERRWRAP2(retval = cv::HOGDescriptor::getDefaultPeopleDetector());
| 15052 | return pyopencv_from(retval); |  | 15052 | return pyopencv_from(retval);
| 15053 | } |  | 15053 | }
| 15054 |  |  | 15054 |
| 15055 | return NULL; |  | 15055 | return NULL;
| 15056 | } |  | 15056 | }
| 15057 |  |  | 15057 |
| 15058 | static PyObject* pyopencv_cv_HOGDescriptor_getDescriptorSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15058 | static PyObject* pyopencv_cv_HOGDescriptor_getDescriptorSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 15059 | { |  | 15059 | {
| 15060 | using namespace cv; |  | 15060 | using namespace cv;
| 15061 |  |  | 15061 |
| 15062 |  |  | 15062 |
| 15063 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 15063 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 15064 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 15064 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 15065 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 15065 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 15066 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 15066 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 15067 | size_t retval; |  | 15067 | size_t retval;
| 15068 |  |  | 15068 |
| 15069 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15069 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15070 | { |  | 15070 | {
| 15071 | ERRWRAP2(retval = _self_->getDescriptorSize()); |  | 15071 | ERRWRAP2(retval = _self_->getDescriptorSize());
| 15072 | return pyopencv_from(retval); |  | 15072 | return pyopencv_from(retval);
| 15073 | } |  | 15073 | }
| 15074 |  |  | 15074 |
| 15075 | return NULL; |  | 15075 | return NULL;
| 15076 | } |  | 15076 | }
| 15077 |  |  | 15077 |
| 15078 | static PyObject* pyopencv_cv_HOGDescriptor_getWinSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15078 | static PyObject* pyopencv_cv_HOGDescriptor_getWinSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 15079 | { |  | 15079 | {
| 15080 | using namespace cv; |  | 15080 | using namespace cv;
| 15081 |  |  | 15081 |
| 15082 |  |  | 15082 |
| 15083 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 15083 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 15084 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 15084 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 15085 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 15085 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 15086 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 15086 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 15087 | double retval; |  | 15087 | double retval;
| 15088 |  |  | 15088 |
| 15089 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15089 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15090 | { |  | 15090 | {
| 15091 | ERRWRAP2(retval = _self_->getWinSigma()); |  | 15091 | ERRWRAP2(retval = _self_->getWinSigma());
| 15092 | return pyopencv_from(retval); |  | 15092 | return pyopencv_from(retval);
| 15093 | } |  | 15093 | }
| 15094 |  |  | 15094 |
| 15095 | return NULL; |  | 15095 | return NULL;
| 15096 | } |  | 15096 | }
| 15097 |  |  | 15097 |
| 15098 | static PyObject* pyopencv_cv_HOGDescriptor_load(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15098 | static PyObject* pyopencv_cv_HOGDescriptor_load(PyObject* self, PyObject* py_args, PyObject* kw)
| 15099 | { |  | 15099 | {
| 15100 | using namespace cv; |  | 15100 | using namespace cv;
| 15101 |  |  | 15101 |
| 15102 |  |  | 15102 |
| 15103 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 15103 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 15104 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 15104 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 15105 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 15105 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 15106 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 15106 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 15107 | PyObject* pyobj_filename = NULL; |  | 15107 | PyObject* pyobj_filename = NULL;
| 15108 | String filename; |  | 15108 | String filename;
| 15109 | PyObject* pyobj_objname = NULL; |  | 15109 | PyObject* pyobj_objname = NULL;
| 15110 | String objname; |  | 15110 | String objname;
| 15111 | bool retval; |  | 15111 | bool retval;
| 15112 |  |  | 15112 |
| 15113 | const char* keywords[] = { "filename", "objname", NULL }; |  | 15113 | const char* keywords[] = { "filename", "objname", NULL };
| 15114 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HOGDescriptor.load", (char**)keywords, &pyobj_filename, &pyobj_objname) && |  | 15114 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HOGDescriptor.load", (char**)keywords, &pyobj_filename, &pyobj_objname) &&
| 15115 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 15115 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 15116 | pyopencv_to_safe(pyobj_objname, objname, ArgInfo("objname", 0)) ) |  | 15116 | pyopencv_to_safe(pyobj_objname, objname, ArgInfo("objname", 0)) )
| 15117 | { |  | 15117 | {
| 15118 | ERRWRAP2(retval = _self_->load(filename, objname)); |  | 15118 | ERRWRAP2(retval = _self_->load(filename, objname));
| 15119 | return pyopencv_from(retval); |  | 15119 | return pyopencv_from(retval);
| 15120 | } |  | 15120 | }
| 15121 |  |  | 15121 |
| 15122 | return NULL; |  | 15122 | return NULL;
| 15123 | } |  | 15123 | }
| 15124 |  |  | 15124 |
| 15125 | static PyObject* pyopencv_cv_HOGDescriptor_save(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15125 | static PyObject* pyopencv_cv_HOGDescriptor_save(PyObject* self, PyObject* py_args, PyObject* kw)
| 15126 | { |  | 15126 | {
| 15127 | using namespace cv; |  | 15127 | using namespace cv;
| 15128 |  |  | 15128 |
| 15129 |  |  | 15129 |
| 15130 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 15130 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 15131 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 15131 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 15132 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 15132 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 15133 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 15133 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 15134 | PyObject* pyobj_filename = NULL; |  | 15134 | PyObject* pyobj_filename = NULL;
| 15135 | String filename; |  | 15135 | String filename;
| 15136 | PyObject* pyobj_objname = NULL; |  | 15136 | PyObject* pyobj_objname = NULL;
| 15137 | String objname; |  | 15137 | String objname;
| 15138 |  |  | 15138 |
| 15139 | const char* keywords[] = { "filename", "objname", NULL }; |  | 15139 | const char* keywords[] = { "filename", "objname", NULL };
| 15140 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HOGDescriptor.save", (char**)keywords, &pyobj_filename, &pyobj_objname) && |  | 15140 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HOGDescriptor.save", (char**)keywords, &pyobj_filename, &pyobj_objname) &&
| 15141 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 15141 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 15142 | pyopencv_to_safe(pyobj_objname, objname, ArgInfo("objname", 0)) ) |  | 15142 | pyopencv_to_safe(pyobj_objname, objname, ArgInfo("objname", 0)) )
| 15143 | { |  | 15143 | {
| 15144 | ERRWRAP2(_self_->save(filename, objname)); |  | 15144 | ERRWRAP2(_self_->save(filename, objname));
| 15145 | Py_RETURN_NONE; |  | 15145 | Py_RETURN_NONE;
| 15146 | } |  | 15146 | }
| 15147 |  |  | 15147 |
| 15148 | return NULL; |  | 15148 | return NULL;
| 15149 | } |  | 15149 | }
| 15150 |  |  | 15150 |
| 15151 | static PyObject* pyopencv_cv_HOGDescriptor_setSVMDetector(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15151 | static PyObject* pyopencv_cv_HOGDescriptor_setSVMDetector(PyObject* self, PyObject* py_args, PyObject* kw)
| 15152 | { |  | 15152 | {
| 15153 | using namespace cv; |  | 15153 | using namespace cv;
| 15154 |  |  | 15154 |
| 15155 |  |  | 15155 |
| 15156 | Ptr<cv::HOGDescriptor> * self1 = 0; |  | 15156 | Ptr<cv::HOGDescriptor> * self1 = 0;
| 15157 | if (!pyopencv_HOGDescriptor_getp(self, self1)) |  | 15157 | if (!pyopencv_HOGDescriptor_getp(self, self1))
| 15158 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)"); |  | 15158 | return failmsgp("Incorrect type of self (must be 'HOGDescriptor' or its derivative)");
| 15159 | Ptr<cv::HOGDescriptor> _self_ = *(self1); |  | 15159 | Ptr<cv::HOGDescriptor> _self_ = *(self1);
| 15160 | pyPrepareArgumentConversionErrorsStorage(2); |  | 15160 | pyPrepareArgumentConversionErrorsStorage(2);
| 15161 |  |  | 15161 |
| 15162 | { |  | 15162 | {
| 15163 | PyObject* pyobj_svmdetector = NULL; |  | 15163 | PyObject* pyobj_svmdetector = NULL;
| 15164 | Mat svmdetector; |  | 15164 | Mat svmdetector;
| 15165 |  |  | 15165 |
| 15166 | const char* keywords[] = { "svmdetector", NULL }; |  | 15166 | const char* keywords[] = { "svmdetector", NULL };
| 15167 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HOGDescriptor.setSVMDetector", (char**)keywords, &pyobj_svmdetector) && |  | 15167 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HOGDescriptor.setSVMDetector", (char**)keywords, &pyobj_svmdetector) &&
| 15168 | pyopencv_to_safe(pyobj_svmdetector, svmdetector, ArgInfo("svmdetector", 0)) ) |  | 15168 | pyopencv_to_safe(pyobj_svmdetector, svmdetector, ArgInfo("svmdetector", 0)) )
| 15169 | { |  | 15169 | {
| 15170 | ERRWRAP2(_self_->setSVMDetector(svmdetector)); |  | 15170 | ERRWRAP2(_self_->setSVMDetector(svmdetector));
| 15171 | Py_RETURN_NONE; |  | 15171 | Py_RETURN_NONE;
| 15172 | } |  | 15172 | }
| 15173 |  |  | 15173 |
| 15174 |  |  | 15174 |
| 15175 | pyPopulateArgumentConversionErrors(); |  | 15175 | pyPopulateArgumentConversionErrors();
| 15176 | } |  | 15176 | }
| 15177 |  |  | 15177 |
| 15178 |  |  | 15178 |
| 15179 | { |  | 15179 | {
| 15180 | PyObject* pyobj_svmdetector = NULL; |  | 15180 | PyObject* pyobj_svmdetector = NULL;
| 15181 | UMat svmdetector; |  | 15181 | UMat svmdetector;
| 15182 |  |  | 15182 |
| 15183 | const char* keywords[] = { "svmdetector", NULL }; |  | 15183 | const char* keywords[] = { "svmdetector", NULL };
| 15184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HOGDescriptor.setSVMDetector", (char**)keywords, &pyobj_svmdetector) && |  | 15184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HOGDescriptor.setSVMDetector", (char**)keywords, &pyobj_svmdetector) &&
| 15185 | pyopencv_to_safe(pyobj_svmdetector, svmdetector, ArgInfo("svmdetector", 0)) ) |  | 15185 | pyopencv_to_safe(pyobj_svmdetector, svmdetector, ArgInfo("svmdetector", 0)) )
| 15186 | { |  | 15186 | {
| 15187 | ERRWRAP2(_self_->setSVMDetector(svmdetector)); |  | 15187 | ERRWRAP2(_self_->setSVMDetector(svmdetector));
| 15188 | Py_RETURN_NONE; |  | 15188 | Py_RETURN_NONE;
| 15189 | } |  | 15189 | }
| 15190 |  |  | 15190 |
| 15191 |  |  | 15191 |
| 15192 | pyPopulateArgumentConversionErrors(); |  | 15192 | pyPopulateArgumentConversionErrors();
| 15193 | } |  | 15193 | }
| 15194 | pyRaiseCVOverloadException("setSVMDetector"); |  | 15194 | pyRaiseCVOverloadException("setSVMDetector");
| 15195 |  |  | 15195 |
| 15196 | return NULL; |  | 15196 | return NULL;
| 15197 | } |  | 15197 | }
| 15198 |  |  | 15198 |
| 15199 |  |  | 15199 |
| 15200 |  |  | 15200 |
| 15201 | // Tables (HOGDescriptor) |  | 15201 | // Tables (HOGDescriptor)
| 15202 |  |  | 15202 |
| 15203 | static PyGetSetDef pyopencv_HOGDescriptor_getseters[] = |  | 15203 | static PyGetSetDef pyopencv_HOGDescriptor_getseters[] =
| 15204 | { |  | 15204 | {
| 15205 | {(char*)"L2HysThreshold", (getter)pyopencv_HOGDescriptor_get_L2HysThreshold, NULL, (char*)"L2HysThreshold", NULL}, |  | 15205 | {(char*)"L2HysThreshold", (getter)pyopencv_HOGDescriptor_get_L2HysThreshold, NULL, (char*)"L2HysThreshold", NULL},
| 15206 | {(char*)"blockSize", (getter)pyopencv_HOGDescriptor_get_blockSize, NULL, (char*)"blockSize", NULL}, |  | 15206 | {(char*)"blockSize", (getter)pyopencv_HOGDescriptor_get_blockSize, NULL, (char*)"blockSize", NULL},
| 15207 | {(char*)"blockStride", (getter)pyopencv_HOGDescriptor_get_blockStride, NULL, (char*)"blockStride", NULL}, |  | 15207 | {(char*)"blockStride", (getter)pyopencv_HOGDescriptor_get_blockStride, NULL, (char*)"blockStride", NULL},
| 15208 | {(char*)"cellSize", (getter)pyopencv_HOGDescriptor_get_cellSize, NULL, (char*)"cellSize", NULL}, |  | 15208 | {(char*)"cellSize", (getter)pyopencv_HOGDescriptor_get_cellSize, NULL, (char*)"cellSize", NULL},
| 15209 | {(char*)"derivAperture", (getter)pyopencv_HOGDescriptor_get_derivAperture, NULL, (char*)"derivAperture", NULL}, |  | 15209 | {(char*)"derivAperture", (getter)pyopencv_HOGDescriptor_get_derivAperture, NULL, (char*)"derivAperture", NULL},
| 15210 | {(char*)"gammaCorrection", (getter)pyopencv_HOGDescriptor_get_gammaCorrection, NULL, (char*)"gammaCorrection", NULL}, |  | 15210 | {(char*)"gammaCorrection", (getter)pyopencv_HOGDescriptor_get_gammaCorrection, NULL, (char*)"gammaCorrection", NULL},
| 15211 | {(char*)"histogramNormType", (getter)pyopencv_HOGDescriptor_get_histogramNormType, NULL, (char*)"histogramNormType", NULL}, |  | 15211 | {(char*)"histogramNormType", (getter)pyopencv_HOGDescriptor_get_histogramNormType, NULL, (char*)"histogramNormType", NULL},
| 15212 | {(char*)"nbins", (getter)pyopencv_HOGDescriptor_get_nbins, NULL, (char*)"nbins", NULL}, |  | 15212 | {(char*)"nbins", (getter)pyopencv_HOGDescriptor_get_nbins, NULL, (char*)"nbins", NULL},
| 15213 | {(char*)"nlevels", (getter)pyopencv_HOGDescriptor_get_nlevels, NULL, (char*)"nlevels", NULL}, |  | 15213 | {(char*)"nlevels", (getter)pyopencv_HOGDescriptor_get_nlevels, NULL, (char*)"nlevels", NULL},
| 15214 | {(char*)"signedGradient", (getter)pyopencv_HOGDescriptor_get_signedGradient, NULL, (char*)"signedGradient", NULL}, |  | 15214 | {(char*)"signedGradient", (getter)pyopencv_HOGDescriptor_get_signedGradient, NULL, (char*)"signedGradient", NULL},
| 15215 | {(char*)"svmDetector", (getter)pyopencv_HOGDescriptor_get_svmDetector, NULL, (char*)"svmDetector", NULL}, |  | 15215 | {(char*)"svmDetector", (getter)pyopencv_HOGDescriptor_get_svmDetector, NULL, (char*)"svmDetector", NULL},
| 15216 | {(char*)"winSigma", (getter)pyopencv_HOGDescriptor_get_winSigma, NULL, (char*)"winSigma", NULL}, |  | 15216 | {(char*)"winSigma", (getter)pyopencv_HOGDescriptor_get_winSigma, NULL, (char*)"winSigma", NULL},
| 15217 | {(char*)"winSize", (getter)pyopencv_HOGDescriptor_get_winSize, NULL, (char*)"winSize", NULL}, |  | 15217 | {(char*)"winSize", (getter)pyopencv_HOGDescriptor_get_winSize, NULL, (char*)"winSize", NULL},
| 15218 | {NULL} /* Sentinel */ |  | 15218 | {NULL} /* Sentinel */
| 15219 | }; |  | 15219 | };
| 15220 |  |  | 15220 |
| 15221 | static PyMethodDef pyopencv_HOGDescriptor_methods[] = |  | 15221 | static PyMethodDef pyopencv_HOGDescriptor_methods[] =
| 15222 | { |  | 15222 | {
| 15223 | {"checkDetectorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_checkDetectorSize, 0), "checkDetectorSize() -> retval\n. @brief Checks if detector size equal to descriptor size."}, |  | 15223 | {"checkDetectorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_checkDetectorSize, 0), "checkDetectorSize() -> retval\n. @brief Checks if detector size equal to descriptor size."},
| 15224 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_compute, 0), "compute(img[, winStride[, padding[, locations]]]) -> descriptors\n. @brief Computes HOG descriptors of given image.\n. @param img Matrix of the type CV_8U containing an image where HOG features will be calculated.\n. @param descriptors Matrix of the type CV_32F\n. @param winStride Window stride. It must be a multiple of block stride.\n. @param padding Padding\n. @param locations Vector of Point"}, |  | 15224 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_compute, 0), "compute(img[, winStride[, padding[, locations]]]) -> descriptors\n. @brief Computes HOG descriptors of given image.\n. @param img Matrix of the type CV_8U containing an image where HOG features will be calculated.\n. @param descriptors Matrix of the type CV_32F\n. @param winStride Window stride. It must be a multiple of block stride.\n. @param padding Padding\n. @param locations Vector of Point"},
| 15225 | {"computeGradient", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_computeGradient, 0), "computeGradient(img, grad, angleOfs[, paddingTL[, paddingBR]]) -> grad, angleOfs\n. @brief Computes gradients and quantized gradient orientations.\n. @param img Matrix contains the image to be computed\n. @param grad Matrix of type CV_32FC2 contains computed gradients\n. @param angleOfs Matrix of type CV_8UC2 contains quantized gradient orientations\n. @param paddingTL Padding from top-left\n. @param paddingBR Padding from bottom-right"}, |  | 15225 | {"computeGradient", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_computeGradient, 0), "computeGradient(img, grad, angleOfs[, paddingTL[, paddingBR]]) -> grad, angleOfs\n. @brief Computes gradients and quantized gradient orientations.\n. @param img Matrix contains the image to be computed\n. @param grad Matrix of type CV_32FC2 contains computed gradients\n. @param angleOfs Matrix of type CV_8UC2 contains quantized gradient orientations\n. @param paddingTL Padding from top-left\n. @param paddingBR Padding from bottom-right"},
| 15226 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_detect, 0), "detect(img[, hitThreshold[, winStride[, padding[, searchLocations]]]]) -> foundLocations, weights\n. @brief Performs object detection without a multi-scale window.\n. @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.\n. @param foundLocations Vector of point where each point contains left-top corner point of detected object boundaries.\n. @param weights Vector that will contain confidence values for each detected object.\n. @param hitThreshold Threshold for the distance between features and SVM classifying plane.\n. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).\n. But if the free coefficient is omitted (which is allowed), you can specify it manually here.\n. @param winStride Window stride. It must be a multiple of block stride.\n. @param padding Padding\n. @param searchLocations Vector of Point includes set of requested locations to be evaluated."}, |  | 15226 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_detect, 0), "detect(img[, hitThreshold[, winStride[, padding[, searchLocations]]]]) -> foundLocations, weights\n. @brief Performs object detection without a multi-scale window.\n. @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.\n. @param foundLocations Vector of point where each point contains left-top corner point of detected object boundaries.\n. @param weights Vector that will contain confidence values for each detected object.\n. @param hitThreshold Threshold for the distance between features and SVM classifying plane.\n. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).\n. But if the free coefficient is omitted (which is allowed), you can specify it manually here.\n. @param winStride Window stride. It must be a multiple of block stride.\n. @param padding Padding\n. @param searchLocations Vector of Point includes set of requested locations to be evaluated."},
| 15227 | {"detectMultiScale", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_detectMultiScale, 0), "detectMultiScale(img[, hitThreshold[, winStride[, padding[, scale[, groupThreshold[, useMeanshiftGrouping]]]]]]) -> foundLocations, foundWeights\n. @brief Detects objects of different sizes in the input image. The detected objects are returned as a list\n. of rectangles.\n. @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.\n. @param foundLocations Vector of rectangles where each rectangle contains the detected object.\n. @param foundWeights Vector that will contain confidence values for each detected object.\n. @param hitThreshold Threshold for the distance between features and SVM classifying plane.\n. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).\n. But if the free coefficient is omitted (which is allowed), you can specify it manually here.\n. @param winStride Window stride. It must be a multiple of block stride.\n. @param padding Padding\n. @param scale Coefficient of the detection window increase.\n. @param groupThreshold Coefficient to regulate the similarity threshold. When detected, some objects can be covered\n. by many rectangles. 0 means not to perform grouping.\n. @param useMeanshiftGrouping indicates grouping algorithm"}, |  | 15227 | {"detectMultiScale", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_detectMultiScale, 0), "detectMultiScale(img[, hitThreshold[, winStride[, padding[, scale[, groupThreshold[, useMeanshiftGrouping]]]]]]) -> foundLocations, foundWeights\n. @brief Detects objects of different sizes in the input image. The detected objects are returned as a list\n. of rectangles.\n. @param img Matrix of the type CV_8U or CV_8UC3 containing an image where objects are detected.\n. @param foundLocations Vector of rectangles where each rectangle contains the detected object.\n. @param foundWeights Vector that will contain confidence values for each detected object.\n. @param hitThreshold Threshold for the distance between features and SVM classifying plane.\n. Usually it is 0 and should be specified in the detector coefficients (as the last free coefficient).\n. But if the free coefficient is omitted (which is allowed), you can specify it manually here.\n. @param winStride Window stride. It must be a multiple of block stride.\n. @param padding Padding\n. @param scale Coefficient of the detection window increase.\n. @param groupThreshold Coefficient to regulate the similarity threshold. When detected, some objects can be covered\n. by many rectangles. 0 means not to perform grouping.\n. @param useMeanshiftGrouping indicates grouping algorithm"},
| 15228 | {"getDaimlerPeopleDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getDaimlerPeopleDetector_static, METH_STATIC), "getDaimlerPeopleDetector() -> retval\n. @brief Returns coefficients of the classifier trained for people detection (for 48x96 windows)."}, |  | 15228 | {"getDaimlerPeopleDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getDaimlerPeopleDetector_static, METH_STATIC), "getDaimlerPeopleDetector() -> retval\n. @brief Returns coefficients of the classifier trained for people detection (for 48x96 windows)."},
| 15229 | {"getDefaultPeopleDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getDefaultPeopleDetector_static, METH_STATIC), "getDefaultPeopleDetector() -> retval\n. @brief Returns coefficients of the classifier trained for people detection (for 64x128 windows)."}, |  | 15229 | {"getDefaultPeopleDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getDefaultPeopleDetector_static, METH_STATIC), "getDefaultPeopleDetector() -> retval\n. @brief Returns coefficients of the classifier trained for people detection (for 64x128 windows)."},
| 15230 | {"getDescriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getDescriptorSize, 0), "getDescriptorSize() -> retval\n. @brief Returns the number of coefficients required for the classification."}, |  | 15230 | {"getDescriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getDescriptorSize, 0), "getDescriptorSize() -> retval\n. @brief Returns the number of coefficients required for the classification."},
| 15231 | {"getWinSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getWinSigma, 0), "getWinSigma() -> retval\n. @brief Returns winSigma value"}, |  | 15231 | {"getWinSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_getWinSigma, 0), "getWinSigma() -> retval\n. @brief Returns winSigma value"},
| 15232 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_load, 0), "load(filename[, objname]) -> retval\n. @brief loads HOGDescriptor parameters and coefficients for the linear SVM classifier from a file\n. @param filename Name of the file to read.\n. @param objname The optional name of the node to read (if empty, the first top-level node will be used)."}, |  | 15232 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_load, 0), "load(filename[, objname]) -> retval\n. @brief loads HOGDescriptor parameters and coefficients for the linear SVM classifier from a file\n. @param filename Name of the file to read.\n. @param objname The optional name of the node to read (if empty, the first top-level node will be used)."},
| 15233 | {"save", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_save, 0), "save(filename[, objname]) -> None\n. @brief saves HOGDescriptor parameters and coefficients for the linear SVM classifier to a file\n. @param filename File name\n. @param objname Object name"}, |  | 15233 | {"save", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_save, 0), "save(filename[, objname]) -> None\n. @brief saves HOGDescriptor parameters and coefficients for the linear SVM classifier to a file\n. @param filename File name\n. @param objname Object name"},
| 15234 | {"setSVMDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_setSVMDetector, 0), "setSVMDetector(svmdetector) -> None\n. @brief Sets coefficients for the linear SVM classifier.\n. @param svmdetector coefficients for the linear SVM classifier."}, |  | 15234 | {"setSVMDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_HOGDescriptor_setSVMDetector, 0), "setSVMDetector(svmdetector) -> None\n. @brief Sets coefficients for the linear SVM classifier.\n. @param svmdetector coefficients for the linear SVM classifier."},
| 15235 |  |  | 15235 |
| 15236 | {NULL, NULL} |  | 15236 | {NULL, NULL}
| 15237 | }; |  | 15237 | };
| 15238 |  |  | 15238 |
| 15239 | // Converter (HOGDescriptor) |  | 15239 | // Converter (HOGDescriptor)
| 15240 |  |  | 15240 |
| 15241 | template<> |  | 15241 | template<>
| 15242 | struct PyOpenCV_Converter< Ptr<cv::HOGDescriptor> > |  | 15242 | struct PyOpenCV_Converter< Ptr<cv::HOGDescriptor> >
| 15243 | { |  | 15243 | {
| 15244 | static PyObject* from(const Ptr<cv::HOGDescriptor>& r) |  | 15244 | static PyObject* from(const Ptr<cv::HOGDescriptor>& r)
| 15245 | { |  | 15245 | {
| 15246 | return pyopencv_HOGDescriptor_Instance(r); |  | 15246 | return pyopencv_HOGDescriptor_Instance(r);
| 15247 | } |  | 15247 | }
| 15248 | static bool to(PyObject* src, Ptr<cv::HOGDescriptor>& dst, const ArgInfo& info) |  | 15248 | static bool to(PyObject* src, Ptr<cv::HOGDescriptor>& dst, const ArgInfo& info)
| 15249 | { |  | 15249 | {
| 15250 | if(!src || src == Py_None) |  | 15250 | if(!src || src == Py_None)
| 15251 | return true; |  | 15251 | return true;
| 15252 | Ptr<cv::HOGDescriptor> * dst_; |  | 15252 | Ptr<cv::HOGDescriptor> * dst_;
| 15253 | if (pyopencv_HOGDescriptor_getp(src, dst_)) |  | 15253 | if (pyopencv_HOGDescriptor_getp(src, dst_))
| 15254 | { |  | 15254 | {
| 15255 | dst = *dst_; |  | 15255 | dst = *dst_;
| 15256 | return true; |  | 15256 | return true;
| 15257 | } |  | 15257 | }
| 15258 |  |  | 15258 |
| 15259 | failmsg("Expected Ptr<cv::HOGDescriptor> for argument '%s'", info.name); |  | 15259 | failmsg("Expected Ptr<cv::HOGDescriptor> for argument '%s'", info.name);
| 15260 | return false; |  | 15260 | return false;
| 15261 | } |  | 15261 | }
| 15262 | }; |  | 15262 | };
| 15263 |  |  | 15263 |
| 15264 | //================================================================================ |  | 15264 | //================================================================================
| 15265 | // HausdorffDistanceExtractor (Generic) |  | 15265 | // HausdorffDistanceExtractor (Generic)
| 15266 | //================================================================================ |  | 15266 | //================================================================================
| 15267 |  |  | 15267 |
| 15268 | // GetSet (HausdorffDistanceExtractor) |  | 15268 | // GetSet (HausdorffDistanceExtractor)
| 15269 |  |  | 15269 |
| 15270 |  |  | 15270 |
| 15271 |  |  | 15271 |
| 15272 | // Methods (HausdorffDistanceExtractor) |  | 15272 | // Methods (HausdorffDistanceExtractor)
| 15273 |  |  | 15273 |
| 15274 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_getDistanceFlag(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15274 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_getDistanceFlag(PyObject* self, PyObject* py_args, PyObject* kw)
| 15275 | { |  | 15275 | {
| 15276 | using namespace cv; |  | 15276 | using namespace cv;
| 15277 |  |  | 15277 |
| 15278 |  |  | 15278 |
| 15279 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0; |  | 15279 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0;
| 15280 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1)) |  | 15280 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1))
| 15281 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)"); |  | 15281 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)");
| 15282 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1); |  | 15282 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1);
| 15283 | int retval; |  | 15283 | int retval;
| 15284 |  |  | 15284 |
| 15285 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15285 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15286 | { |  | 15286 | {
| 15287 | ERRWRAP2(retval = _self_->getDistanceFlag()); |  | 15287 | ERRWRAP2(retval = _self_->getDistanceFlag());
| 15288 | return pyopencv_from(retval); |  | 15288 | return pyopencv_from(retval);
| 15289 | } |  | 15289 | }
| 15290 |  |  | 15290 |
| 15291 | return NULL; |  | 15291 | return NULL;
| 15292 | } |  | 15292 | }
| 15293 |  |  | 15293 |
| 15294 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_getRankProportion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15294 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_getRankProportion(PyObject* self, PyObject* py_args, PyObject* kw)
| 15295 | { |  | 15295 | {
| 15296 | using namespace cv; |  | 15296 | using namespace cv;
| 15297 |  |  | 15297 |
| 15298 |  |  | 15298 |
| 15299 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0; |  | 15299 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0;
| 15300 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1)) |  | 15300 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1))
| 15301 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)"); |  | 15301 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)");
| 15302 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1); |  | 15302 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1);
| 15303 | float retval; |  | 15303 | float retval;
| 15304 |  |  | 15304 |
| 15305 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15305 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15306 | { |  | 15306 | {
| 15307 | ERRWRAP2(retval = _self_->getRankProportion()); |  | 15307 | ERRWRAP2(retval = _self_->getRankProportion());
| 15308 | return pyopencv_from(retval); |  | 15308 | return pyopencv_from(retval);
| 15309 | } |  | 15309 | }
| 15310 |  |  | 15310 |
| 15311 | return NULL; |  | 15311 | return NULL;
| 15312 | } |  | 15312 | }
| 15313 |  |  | 15313 |
| 15314 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_setDistanceFlag(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15314 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_setDistanceFlag(PyObject* self, PyObject* py_args, PyObject* kw)
| 15315 | { |  | 15315 | {
| 15316 | using namespace cv; |  | 15316 | using namespace cv;
| 15317 |  |  | 15317 |
| 15318 |  |  | 15318 |
| 15319 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0; |  | 15319 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0;
| 15320 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1)) |  | 15320 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1))
| 15321 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)"); |  | 15321 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)");
| 15322 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1); |  | 15322 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1);
| 15323 | PyObject* pyobj_distanceFlag = NULL; |  | 15323 | PyObject* pyobj_distanceFlag = NULL;
| 15324 | int distanceFlag=0; |  | 15324 | int distanceFlag=0;
| 15325 |  |  | 15325 |
| 15326 | const char* keywords[] = { "distanceFlag", NULL }; |  | 15326 | const char* keywords[] = { "distanceFlag", NULL };
| 15327 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HausdorffDistanceExtractor.setDistanceFlag", (char**)keywords, &pyobj_distanceFlag) && |  | 15327 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HausdorffDistanceExtractor.setDistanceFlag", (char**)keywords, &pyobj_distanceFlag) &&
| 15328 | pyopencv_to_safe(pyobj_distanceFlag, distanceFlag, ArgInfo("distanceFlag", 0)) ) |  | 15328 | pyopencv_to_safe(pyobj_distanceFlag, distanceFlag, ArgInfo("distanceFlag", 0)) )
| 15329 | { |  | 15329 | {
| 15330 | ERRWRAP2(_self_->setDistanceFlag(distanceFlag)); |  | 15330 | ERRWRAP2(_self_->setDistanceFlag(distanceFlag));
| 15331 | Py_RETURN_NONE; |  | 15331 | Py_RETURN_NONE;
| 15332 | } |  | 15332 | }
| 15333 |  |  | 15333 |
| 15334 | return NULL; |  | 15334 | return NULL;
| 15335 | } |  | 15335 | }
| 15336 |  |  | 15336 |
| 15337 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_setRankProportion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15337 | static PyObject* pyopencv_cv_HausdorffDistanceExtractor_setRankProportion(PyObject* self, PyObject* py_args, PyObject* kw)
| 15338 | { |  | 15338 | {
| 15339 | using namespace cv; |  | 15339 | using namespace cv;
| 15340 |  |  | 15340 |
| 15341 |  |  | 15341 |
| 15342 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0; |  | 15342 | Ptr<cv::HausdorffDistanceExtractor> * self1 = 0;
| 15343 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1)) |  | 15343 | if (!pyopencv_HausdorffDistanceExtractor_getp(self, self1))
| 15344 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)"); |  | 15344 | return failmsgp("Incorrect type of self (must be 'HausdorffDistanceExtractor' or its derivative)");
| 15345 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1); |  | 15345 | Ptr<cv::HausdorffDistanceExtractor> _self_ = *(self1);
| 15346 | PyObject* pyobj_rankProportion = NULL; |  | 15346 | PyObject* pyobj_rankProportion = NULL;
| 15347 | float rankProportion=0.f; |  | 15347 | float rankProportion=0.f;
| 15348 |  |  | 15348 |
| 15349 | const char* keywords[] = { "rankProportion", NULL }; |  | 15349 | const char* keywords[] = { "rankProportion", NULL };
| 15350 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HausdorffDistanceExtractor.setRankProportion", (char**)keywords, &pyobj_rankProportion) && |  | 15350 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HausdorffDistanceExtractor.setRankProportion", (char**)keywords, &pyobj_rankProportion) &&
| 15351 | pyopencv_to_safe(pyobj_rankProportion, rankProportion, ArgInfo("rankProportion", 0)) ) |  | 15351 | pyopencv_to_safe(pyobj_rankProportion, rankProportion, ArgInfo("rankProportion", 0)) )
| 15352 | { |  | 15352 | {
| 15353 | ERRWRAP2(_self_->setRankProportion(rankProportion)); |  | 15353 | ERRWRAP2(_self_->setRankProportion(rankProportion));
| 15354 | Py_RETURN_NONE; |  | 15354 | Py_RETURN_NONE;
| 15355 | } |  | 15355 | }
| 15356 |  |  | 15356 |
| 15357 | return NULL; |  | 15357 | return NULL;
| 15358 | } |  | 15358 | }
| 15359 |  |  | 15359 |
| 15360 |  |  | 15360 |
| 15361 |  |  | 15361 |
| 15362 | // Tables (HausdorffDistanceExtractor) |  | 15362 | // Tables (HausdorffDistanceExtractor)
| 15363 |  |  | 15363 |
| 15364 | static PyGetSetDef pyopencv_HausdorffDistanceExtractor_getseters[] = |  | 15364 | static PyGetSetDef pyopencv_HausdorffDistanceExtractor_getseters[] =
| 15365 | { |  | 15365 | {
| 15366 | {NULL} /* Sentinel */ |  | 15366 | {NULL} /* Sentinel */
| 15367 | }; |  | 15367 | };
| 15368 |  |  | 15368 |
| 15369 | static PyMethodDef pyopencv_HausdorffDistanceExtractor_methods[] = |  | 15369 | static PyMethodDef pyopencv_HausdorffDistanceExtractor_methods[] =
| 15370 | { |  | 15370 | {
| 15371 | {"getDistanceFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_getDistanceFlag, 0), "getDistanceFlag() -> retval\n."}, |  | 15371 | {"getDistanceFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_getDistanceFlag, 0), "getDistanceFlag() -> retval\n."},
| 15372 | {"getRankProportion", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_getRankProportion, 0), "getRankProportion() -> retval\n."}, |  | 15372 | {"getRankProportion", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_getRankProportion, 0), "getRankProportion() -> retval\n."},
| 15373 | {"setDistanceFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_setDistanceFlag, 0), "setDistanceFlag(distanceFlag) -> None\n. @brief Set the norm used to compute the Hausdorff value between two shapes. It can be L1 or L2 norm.\n. \n. @param distanceFlag Flag indicating which norm is used to compute the Hausdorff distance\n. (NORM_L1, NORM_L2)."}, |  | 15373 | {"setDistanceFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_setDistanceFlag, 0), "setDistanceFlag(distanceFlag) -> None\n. @brief Set the norm used to compute the Hausdorff value between two shapes. It can be L1 or L2 norm.\n. \n. @param distanceFlag Flag indicating which norm is used to compute the Hausdorff distance\n. (NORM_L1, NORM_L2)."},
| 15374 | {"setRankProportion", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_setRankProportion, 0), "setRankProportion(rankProportion) -> None\n. @brief This method sets the rank proportion (or fractional value) that establish the Kth ranked value of\n. the partial Hausdorff distance. Experimentally had been shown that 0.6 is a good value to compare\n. shapes.\n. \n. @param rankProportion fractional value (between 0 and 1)."}, |  | 15374 | {"setRankProportion", CV_PY_FN_WITH_KW_(pyopencv_cv_HausdorffDistanceExtractor_setRankProportion, 0), "setRankProportion(rankProportion) -> None\n. @brief This method sets the rank proportion (or fractional value) that establish the Kth ranked value of\n. the partial Hausdorff distance. Experimentally had been shown that 0.6 is a good value to compare\n. shapes.\n. \n. @param rankProportion fractional value (between 0 and 1)."},
| 15375 |  |  | 15375 |
| 15376 | {NULL, NULL} |  | 15376 | {NULL, NULL}
| 15377 | }; |  | 15377 | };
| 15378 |  |  | 15378 |
| 15379 | // Converter (HausdorffDistanceExtractor) |  | 15379 | // Converter (HausdorffDistanceExtractor)
| 15380 |  |  | 15380 |
| 15381 | template<> |  | 15381 | template<>
| 15382 | struct PyOpenCV_Converter< Ptr<cv::HausdorffDistanceExtractor> > |  | 15382 | struct PyOpenCV_Converter< Ptr<cv::HausdorffDistanceExtractor> >
| 15383 | { |  | 15383 | {
| 15384 | static PyObject* from(const Ptr<cv::HausdorffDistanceExtractor>& r) |  | 15384 | static PyObject* from(const Ptr<cv::HausdorffDistanceExtractor>& r)
| 15385 | { |  | 15385 | {
| 15386 | return pyopencv_HausdorffDistanceExtractor_Instance(r); |  | 15386 | return pyopencv_HausdorffDistanceExtractor_Instance(r);
| 15387 | } |  | 15387 | }
| 15388 | static bool to(PyObject* src, Ptr<cv::HausdorffDistanceExtractor>& dst, const ArgInfo& info) |  | 15388 | static bool to(PyObject* src, Ptr<cv::HausdorffDistanceExtractor>& dst, const ArgInfo& info)
| 15389 | { |  | 15389 | {
| 15390 | if(!src || src == Py_None) |  | 15390 | if(!src || src == Py_None)
| 15391 | return true; |  | 15391 | return true;
| 15392 | Ptr<cv::HausdorffDistanceExtractor> * dst_; |  | 15392 | Ptr<cv::HausdorffDistanceExtractor> * dst_;
| 15393 | if (pyopencv_HausdorffDistanceExtractor_getp(src, dst_)) |  | 15393 | if (pyopencv_HausdorffDistanceExtractor_getp(src, dst_))
| 15394 | { |  | 15394 | {
| 15395 | dst = *dst_; |  | 15395 | dst = *dst_;
| 15396 | return true; |  | 15396 | return true;
| 15397 | } |  | 15397 | }
| 15398 |  |  | 15398 |
| 15399 | failmsg("Expected Ptr<cv::HausdorffDistanceExtractor> for argument '%s'", info.name); |  | 15399 | failmsg("Expected Ptr<cv::HausdorffDistanceExtractor> for argument '%s'", info.name);
| 15400 | return false; |  | 15400 | return false;
| 15401 | } |  | 15401 | }
| 15402 | }; |  | 15402 | };
| 15403 |  |  | 15403 |
| 15404 | //================================================================================ |  | 15404 | //================================================================================
| 15405 | // HistogramCostExtractor (Generic) |  | 15405 | // HistogramCostExtractor (Generic)
| 15406 | //================================================================================ |  | 15406 | //================================================================================
| 15407 |  |  | 15407 |
| 15408 | // GetSet (HistogramCostExtractor) |  | 15408 | // GetSet (HistogramCostExtractor)
| 15409 |  |  | 15409 |
| 15410 |  |  | 15410 |
| 15411 |  |  | 15411 |
| 15412 | // Methods (HistogramCostExtractor) |  | 15412 | // Methods (HistogramCostExtractor)
| 15413 |  |  | 15413 |
| 15414 | static PyObject* pyopencv_cv_HistogramCostExtractor_buildCostMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15414 | static PyObject* pyopencv_cv_HistogramCostExtractor_buildCostMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 15415 | { |  | 15415 | {
| 15416 | using namespace cv; |  | 15416 | using namespace cv;
| 15417 |  |  | 15417 |
| 15418 |  |  | 15418 |
| 15419 | Ptr<cv::HistogramCostExtractor> * self1 = 0; |  | 15419 | Ptr<cv::HistogramCostExtractor> * self1 = 0;
| 15420 | if (!pyopencv_HistogramCostExtractor_getp(self, self1)) |  | 15420 | if (!pyopencv_HistogramCostExtractor_getp(self, self1))
| 15421 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)"); |  | 15421 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)");
| 15422 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1); |  | 15422 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1);
| 15423 | pyPrepareArgumentConversionErrorsStorage(2); |  | 15423 | pyPrepareArgumentConversionErrorsStorage(2);
| 15424 |  |  | 15424 |
| 15425 | { |  | 15425 | {
| 15426 | PyObject* pyobj_descriptors1 = NULL; |  | 15426 | PyObject* pyobj_descriptors1 = NULL;
| 15427 | Mat descriptors1; |  | 15427 | Mat descriptors1;
| 15428 | PyObject* pyobj_descriptors2 = NULL; |  | 15428 | PyObject* pyobj_descriptors2 = NULL;
| 15429 | Mat descriptors2; |  | 15429 | Mat descriptors2;
| 15430 | PyObject* pyobj_costMatrix = NULL; |  | 15430 | PyObject* pyobj_costMatrix = NULL;
| 15431 | Mat costMatrix; |  | 15431 | Mat costMatrix;
| 15432 |  |  | 15432 |
| 15433 | const char* keywords[] = { "descriptors1", "descriptors2", "costMatrix", NULL }; |  | 15433 | const char* keywords[] = { "descriptors1", "descriptors2", "costMatrix", NULL };
| 15434 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:HistogramCostExtractor.buildCostMatrix", (char**)keywords, &pyobj_descriptors1, &pyobj_descriptors2, &pyobj_costMatrix) && |  | 15434 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:HistogramCostExtractor.buildCostMatrix", (char**)keywords, &pyobj_descriptors1, &pyobj_descriptors2, &pyobj_costMatrix) &&
| 15435 | pyopencv_to_safe(pyobj_descriptors1, descriptors1, ArgInfo("descriptors1", 0)) && |  | 15435 | pyopencv_to_safe(pyobj_descriptors1, descriptors1, ArgInfo("descriptors1", 0)) &&
| 15436 | pyopencv_to_safe(pyobj_descriptors2, descriptors2, ArgInfo("descriptors2", 0)) && |  | 15436 | pyopencv_to_safe(pyobj_descriptors2, descriptors2, ArgInfo("descriptors2", 0)) &&
| 15437 | pyopencv_to_safe(pyobj_costMatrix, costMatrix, ArgInfo("costMatrix", 1)) ) |  | 15437 | pyopencv_to_safe(pyobj_costMatrix, costMatrix, ArgInfo("costMatrix", 1)) )
| 15438 | { |  | 15438 | {
| 15439 | ERRWRAP2(_self_->buildCostMatrix(descriptors1, descriptors2, costMatrix)); |  | 15439 | ERRWRAP2(_self_->buildCostMatrix(descriptors1, descriptors2, costMatrix));
| 15440 | return pyopencv_from(costMatrix); |  | 15440 | return pyopencv_from(costMatrix);
| 15441 | } |  | 15441 | }
| 15442 |  |  | 15442 |
| 15443 |  |  | 15443 |
| 15444 | pyPopulateArgumentConversionErrors(); |  | 15444 | pyPopulateArgumentConversionErrors();
| 15445 | } |  | 15445 | }
| 15446 |  |  | 15446 |
| 15447 |  |  | 15447 |
| 15448 | { |  | 15448 | {
| 15449 | PyObject* pyobj_descriptors1 = NULL; |  | 15449 | PyObject* pyobj_descriptors1 = NULL;
| 15450 | UMat descriptors1; |  | 15450 | UMat descriptors1;
| 15451 | PyObject* pyobj_descriptors2 = NULL; |  | 15451 | PyObject* pyobj_descriptors2 = NULL;
| 15452 | UMat descriptors2; |  | 15452 | UMat descriptors2;
| 15453 | PyObject* pyobj_costMatrix = NULL; |  | 15453 | PyObject* pyobj_costMatrix = NULL;
| 15454 | UMat costMatrix; |  | 15454 | UMat costMatrix;
| 15455 |  |  | 15455 |
| 15456 | const char* keywords[] = { "descriptors1", "descriptors2", "costMatrix", NULL }; |  | 15456 | const char* keywords[] = { "descriptors1", "descriptors2", "costMatrix", NULL };
| 15457 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:HistogramCostExtractor.buildCostMatrix", (char**)keywords, &pyobj_descriptors1, &pyobj_descriptors2, &pyobj_costMatrix) && |  | 15457 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:HistogramCostExtractor.buildCostMatrix", (char**)keywords, &pyobj_descriptors1, &pyobj_descriptors2, &pyobj_costMatrix) &&
| 15458 | pyopencv_to_safe(pyobj_descriptors1, descriptors1, ArgInfo("descriptors1", 0)) && |  | 15458 | pyopencv_to_safe(pyobj_descriptors1, descriptors1, ArgInfo("descriptors1", 0)) &&
| 15459 | pyopencv_to_safe(pyobj_descriptors2, descriptors2, ArgInfo("descriptors2", 0)) && |  | 15459 | pyopencv_to_safe(pyobj_descriptors2, descriptors2, ArgInfo("descriptors2", 0)) &&
| 15460 | pyopencv_to_safe(pyobj_costMatrix, costMatrix, ArgInfo("costMatrix", 1)) ) |  | 15460 | pyopencv_to_safe(pyobj_costMatrix, costMatrix, ArgInfo("costMatrix", 1)) )
| 15461 | { |  | 15461 | {
| 15462 | ERRWRAP2(_self_->buildCostMatrix(descriptors1, descriptors2, costMatrix)); |  | 15462 | ERRWRAP2(_self_->buildCostMatrix(descriptors1, descriptors2, costMatrix));
| 15463 | return pyopencv_from(costMatrix); |  | 15463 | return pyopencv_from(costMatrix);
| 15464 | } |  | 15464 | }
| 15465 |  |  | 15465 |
| 15466 |  |  | 15466 |
| 15467 | pyPopulateArgumentConversionErrors(); |  | 15467 | pyPopulateArgumentConversionErrors();
| 15468 | } |  | 15468 | }
| 15469 | pyRaiseCVOverloadException("buildCostMatrix"); |  | 15469 | pyRaiseCVOverloadException("buildCostMatrix");
| 15470 |  |  | 15470 |
| 15471 | return NULL; |  | 15471 | return NULL;
| 15472 | } |  | 15472 | }
| 15473 |  |  | 15473 |
| 15474 | static PyObject* pyopencv_cv_HistogramCostExtractor_getDefaultCost(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15474 | static PyObject* pyopencv_cv_HistogramCostExtractor_getDefaultCost(PyObject* self, PyObject* py_args, PyObject* kw)
| 15475 | { |  | 15475 | {
| 15476 | using namespace cv; |  | 15476 | using namespace cv;
| 15477 |  |  | 15477 |
| 15478 |  |  | 15478 |
| 15479 | Ptr<cv::HistogramCostExtractor> * self1 = 0; |  | 15479 | Ptr<cv::HistogramCostExtractor> * self1 = 0;
| 15480 | if (!pyopencv_HistogramCostExtractor_getp(self, self1)) |  | 15480 | if (!pyopencv_HistogramCostExtractor_getp(self, self1))
| 15481 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)"); |  | 15481 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)");
| 15482 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1); |  | 15482 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1);
| 15483 | float retval; |  | 15483 | float retval;
| 15484 |  |  | 15484 |
| 15485 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15485 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15486 | { |  | 15486 | {
| 15487 | ERRWRAP2(retval = _self_->getDefaultCost()); |  | 15487 | ERRWRAP2(retval = _self_->getDefaultCost());
| 15488 | return pyopencv_from(retval); |  | 15488 | return pyopencv_from(retval);
| 15489 | } |  | 15489 | }
| 15490 |  |  | 15490 |
| 15491 | return NULL; |  | 15491 | return NULL;
| 15492 | } |  | 15492 | }
| 15493 |  |  | 15493 |
| 15494 | static PyObject* pyopencv_cv_HistogramCostExtractor_getNDummies(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15494 | static PyObject* pyopencv_cv_HistogramCostExtractor_getNDummies(PyObject* self, PyObject* py_args, PyObject* kw)
| 15495 | { |  | 15495 | {
| 15496 | using namespace cv; |  | 15496 | using namespace cv;
| 15497 |  |  | 15497 |
| 15498 |  |  | 15498 |
| 15499 | Ptr<cv::HistogramCostExtractor> * self1 = 0; |  | 15499 | Ptr<cv::HistogramCostExtractor> * self1 = 0;
| 15500 | if (!pyopencv_HistogramCostExtractor_getp(self, self1)) |  | 15500 | if (!pyopencv_HistogramCostExtractor_getp(self, self1))
| 15501 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)"); |  | 15501 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)");
| 15502 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1); |  | 15502 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1);
| 15503 | int retval; |  | 15503 | int retval;
| 15504 |  |  | 15504 |
| 15505 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15505 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15506 | { |  | 15506 | {
| 15507 | ERRWRAP2(retval = _self_->getNDummies()); |  | 15507 | ERRWRAP2(retval = _self_->getNDummies());
| 15508 | return pyopencv_from(retval); |  | 15508 | return pyopencv_from(retval);
| 15509 | } |  | 15509 | }
| 15510 |  |  | 15510 |
| 15511 | return NULL; |  | 15511 | return NULL;
| 15512 | } |  | 15512 | }
| 15513 |  |  | 15513 |
| 15514 | static PyObject* pyopencv_cv_HistogramCostExtractor_setDefaultCost(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15514 | static PyObject* pyopencv_cv_HistogramCostExtractor_setDefaultCost(PyObject* self, PyObject* py_args, PyObject* kw)
| 15515 | { |  | 15515 | {
| 15516 | using namespace cv; |  | 15516 | using namespace cv;
| 15517 |  |  | 15517 |
| 15518 |  |  | 15518 |
| 15519 | Ptr<cv::HistogramCostExtractor> * self1 = 0; |  | 15519 | Ptr<cv::HistogramCostExtractor> * self1 = 0;
| 15520 | if (!pyopencv_HistogramCostExtractor_getp(self, self1)) |  | 15520 | if (!pyopencv_HistogramCostExtractor_getp(self, self1))
| 15521 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)"); |  | 15521 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)");
| 15522 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1); |  | 15522 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1);
| 15523 | PyObject* pyobj_defaultCost = NULL; |  | 15523 | PyObject* pyobj_defaultCost = NULL;
| 15524 | float defaultCost=0.f; |  | 15524 | float defaultCost=0.f;
| 15525 |  |  | 15525 |
| 15526 | const char* keywords[] = { "defaultCost", NULL }; |  | 15526 | const char* keywords[] = { "defaultCost", NULL };
| 15527 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HistogramCostExtractor.setDefaultCost", (char**)keywords, &pyobj_defaultCost) && |  | 15527 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HistogramCostExtractor.setDefaultCost", (char**)keywords, &pyobj_defaultCost) &&
| 15528 | pyopencv_to_safe(pyobj_defaultCost, defaultCost, ArgInfo("defaultCost", 0)) ) |  | 15528 | pyopencv_to_safe(pyobj_defaultCost, defaultCost, ArgInfo("defaultCost", 0)) )
| 15529 | { |  | 15529 | {
| 15530 | ERRWRAP2(_self_->setDefaultCost(defaultCost)); |  | 15530 | ERRWRAP2(_self_->setDefaultCost(defaultCost));
| 15531 | Py_RETURN_NONE; |  | 15531 | Py_RETURN_NONE;
| 15532 | } |  | 15532 | }
| 15533 |  |  | 15533 |
| 15534 | return NULL; |  | 15534 | return NULL;
| 15535 | } |  | 15535 | }
| 15536 |  |  | 15536 |
| 15537 | static PyObject* pyopencv_cv_HistogramCostExtractor_setNDummies(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15537 | static PyObject* pyopencv_cv_HistogramCostExtractor_setNDummies(PyObject* self, PyObject* py_args, PyObject* kw)
| 15538 | { |  | 15538 | {
| 15539 | using namespace cv; |  | 15539 | using namespace cv;
| 15540 |  |  | 15540 |
| 15541 |  |  | 15541 |
| 15542 | Ptr<cv::HistogramCostExtractor> * self1 = 0; |  | 15542 | Ptr<cv::HistogramCostExtractor> * self1 = 0;
| 15543 | if (!pyopencv_HistogramCostExtractor_getp(self, self1)) |  | 15543 | if (!pyopencv_HistogramCostExtractor_getp(self, self1))
| 15544 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)"); |  | 15544 | return failmsgp("Incorrect type of self (must be 'HistogramCostExtractor' or its derivative)");
| 15545 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1); |  | 15545 | Ptr<cv::HistogramCostExtractor> _self_ = *(self1);
| 15546 | PyObject* pyobj_nDummies = NULL; |  | 15546 | PyObject* pyobj_nDummies = NULL;
| 15547 | int nDummies=0; |  | 15547 | int nDummies=0;
| 15548 |  |  | 15548 |
| 15549 | const char* keywords[] = { "nDummies", NULL }; |  | 15549 | const char* keywords[] = { "nDummies", NULL };
| 15550 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HistogramCostExtractor.setNDummies", (char**)keywords, &pyobj_nDummies) && |  | 15550 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:HistogramCostExtractor.setNDummies", (char**)keywords, &pyobj_nDummies) &&
| 15551 | pyopencv_to_safe(pyobj_nDummies, nDummies, ArgInfo("nDummies", 0)) ) |  | 15551 | pyopencv_to_safe(pyobj_nDummies, nDummies, ArgInfo("nDummies", 0)) )
| 15552 | { |  | 15552 | {
| 15553 | ERRWRAP2(_self_->setNDummies(nDummies)); |  | 15553 | ERRWRAP2(_self_->setNDummies(nDummies));
| 15554 | Py_RETURN_NONE; |  | 15554 | Py_RETURN_NONE;
| 15555 | } |  | 15555 | }
| 15556 |  |  | 15556 |
| 15557 | return NULL; |  | 15557 | return NULL;
| 15558 | } |  | 15558 | }
| 15559 |  |  | 15559 |
| 15560 |  |  | 15560 |
| 15561 |  |  | 15561 |
| 15562 | // Tables (HistogramCostExtractor) |  | 15562 | // Tables (HistogramCostExtractor)
| 15563 |  |  | 15563 |
| 15564 | static PyGetSetDef pyopencv_HistogramCostExtractor_getseters[] = |  | 15564 | static PyGetSetDef pyopencv_HistogramCostExtractor_getseters[] =
| 15565 | { |  | 15565 | {
| 15566 | {NULL} /* Sentinel */ |  | 15566 | {NULL} /* Sentinel */
| 15567 | }; |  | 15567 | };
| 15568 |  |  | 15568 |
| 15569 | static PyMethodDef pyopencv_HistogramCostExtractor_methods[] = |  | 15569 | static PyMethodDef pyopencv_HistogramCostExtractor_methods[] =
| 15570 | { |  | 15570 | {
| 15571 | {"buildCostMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_buildCostMatrix, 0), "buildCostMatrix(descriptors1, descriptors2[, costMatrix]) -> costMatrix\n."}, |  | 15571 | {"buildCostMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_buildCostMatrix, 0), "buildCostMatrix(descriptors1, descriptors2[, costMatrix]) -> costMatrix\n."},
| 15572 | {"getDefaultCost", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_getDefaultCost, 0), "getDefaultCost() -> retval\n."}, |  | 15572 | {"getDefaultCost", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_getDefaultCost, 0), "getDefaultCost() -> retval\n."},
| 15573 | {"getNDummies", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_getNDummies, 0), "getNDummies() -> retval\n."}, |  | 15573 | {"getNDummies", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_getNDummies, 0), "getNDummies() -> retval\n."},
| 15574 | {"setDefaultCost", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_setDefaultCost, 0), "setDefaultCost(defaultCost) -> None\n."}, |  | 15574 | {"setDefaultCost", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_setDefaultCost, 0), "setDefaultCost(defaultCost) -> None\n."},
| 15575 | {"setNDummies", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_setNDummies, 0), "setNDummies(nDummies) -> None\n."}, |  | 15575 | {"setNDummies", CV_PY_FN_WITH_KW_(pyopencv_cv_HistogramCostExtractor_setNDummies, 0), "setNDummies(nDummies) -> None\n."},
| 15576 |  |  | 15576 |
| 15577 | {NULL, NULL} |  | 15577 | {NULL, NULL}
| 15578 | }; |  | 15578 | };
| 15579 |  |  | 15579 |
| 15580 | // Converter (HistogramCostExtractor) |  | 15580 | // Converter (HistogramCostExtractor)
| 15581 |  |  | 15581 |
| 15582 | template<> |  | 15582 | template<>
| 15583 | struct PyOpenCV_Converter< Ptr<cv::HistogramCostExtractor> > |  | 15583 | struct PyOpenCV_Converter< Ptr<cv::HistogramCostExtractor> >
| 15584 | { |  | 15584 | {
| 15585 | static PyObject* from(const Ptr<cv::HistogramCostExtractor>& r) |  | 15585 | static PyObject* from(const Ptr<cv::HistogramCostExtractor>& r)
| 15586 | { |  | 15586 | {
| 15587 | return pyopencv_HistogramCostExtractor_Instance(r); |  | 15587 | return pyopencv_HistogramCostExtractor_Instance(r);
| 15588 | } |  | 15588 | }
| 15589 | static bool to(PyObject* src, Ptr<cv::HistogramCostExtractor>& dst, const ArgInfo& info) |  | 15589 | static bool to(PyObject* src, Ptr<cv::HistogramCostExtractor>& dst, const ArgInfo& info)
| 15590 | { |  | 15590 | {
| 15591 | if(!src || src == Py_None) |  | 15591 | if(!src || src == Py_None)
| 15592 | return true; |  | 15592 | return true;
| 15593 | Ptr<cv::HistogramCostExtractor> * dst_; |  | 15593 | Ptr<cv::HistogramCostExtractor> * dst_;
| 15594 | if (pyopencv_HistogramCostExtractor_getp(src, dst_)) |  | 15594 | if (pyopencv_HistogramCostExtractor_getp(src, dst_))
| 15595 | { |  | 15595 | {
| 15596 | dst = *dst_; |  | 15596 | dst = *dst_;
| 15597 | return true; |  | 15597 | return true;
| 15598 | } |  | 15598 | }
| 15599 |  |  | 15599 |
| 15600 | failmsg("Expected Ptr<cv::HistogramCostExtractor> for argument '%s'", info.name); |  | 15600 | failmsg("Expected Ptr<cv::HistogramCostExtractor> for argument '%s'", info.name);
| 15601 | return false; |  | 15601 | return false;
| 15602 | } |  | 15602 | }
| 15603 | }; |  | 15603 | };
| 15604 |  |  | 15604 |
| 15605 | //================================================================================ |  | 15605 | //================================================================================
| 15606 | // IStreamReader (Generic) |  | 15606 | // IStreamReader (Generic)
| 15607 | //================================================================================ |  | 15607 | //================================================================================
| 15608 |  |  | 15608 |
| 15609 | // GetSet (IStreamReader) |  | 15609 | // GetSet (IStreamReader)
| 15610 |  |  | 15610 |
| 15611 |  |  | 15611 |
| 15612 |  |  | 15612 |
| 15613 | // Methods (IStreamReader) |  | 15613 | // Methods (IStreamReader)
| 15614 |  |  | 15614 |
| 15615 | static PyObject* pyopencv_cv_IStreamReader_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15615 | static PyObject* pyopencv_cv_IStreamReader_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 15616 | { |  | 15616 | {
| 15617 | using namespace cv; |  | 15617 | using namespace cv;
| 15618 |  |  | 15618 |
| 15619 |  |  | 15619 |
| 15620 | Ptr<cv::IStreamReader> * self1 = 0; |  | 15620 | Ptr<cv::IStreamReader> * self1 = 0;
| 15621 | if (!pyopencv_IStreamReader_getp(self, self1)) |  | 15621 | if (!pyopencv_IStreamReader_getp(self, self1))
| 15622 | return failmsgp("Incorrect type of self (must be 'IStreamReader' or its derivative)"); |  | 15622 | return failmsgp("Incorrect type of self (must be 'IStreamReader' or its derivative)");
| 15623 | Ptr<cv::IStreamReader> _self_ = *(self1); |  | 15623 | Ptr<cv::IStreamReader> _self_ = *(self1);
| 15624 | char* buffer=(char*)""; |  | 15624 | char* buffer=(char*)"";
| 15625 | PyObject* pyobj_size = NULL; |  | 15625 | PyObject* pyobj_size = NULL;
| 15626 | long long size; |  | 15626 | long long size;
| 15627 | long long retval; |  | 15627 | long long retval;
| 15628 |  |  | 15628 |
| 15629 | const char* keywords[] = { "buffer", "size", NULL }; |  | 15629 | const char* keywords[] = { "buffer", "size", NULL };
| 15630 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "sO:IStreamReader.read", (char**)keywords, &buffer, &pyobj_size) && |  | 15630 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "sO:IStreamReader.read", (char**)keywords, &buffer, &pyobj_size) &&
| 15631 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) ) |  | 15631 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) )
| 15632 | { |  | 15632 | {
| 15633 | ERRWRAP2(retval = _self_->read(buffer, size)); |  | 15633 | ERRWRAP2(retval = _self_->read(buffer, size));
| 15634 | return pyopencv_from(retval); |  | 15634 | return pyopencv_from(retval);
| 15635 | } |  | 15635 | }
| 15636 |  |  | 15636 |
| 15637 | return NULL; |  | 15637 | return NULL;
| 15638 | } |  | 15638 | }
| 15639 |  |  | 15639 |
| 15640 | static PyObject* pyopencv_cv_IStreamReader_seek(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15640 | static PyObject* pyopencv_cv_IStreamReader_seek(PyObject* self, PyObject* py_args, PyObject* kw)
| 15641 | { |  | 15641 | {
| 15642 | using namespace cv; |  | 15642 | using namespace cv;
| 15643 |  |  | 15643 |
| 15644 |  |  | 15644 |
| 15645 | Ptr<cv::IStreamReader> * self1 = 0; |  | 15645 | Ptr<cv::IStreamReader> * self1 = 0;
| 15646 | if (!pyopencv_IStreamReader_getp(self, self1)) |  | 15646 | if (!pyopencv_IStreamReader_getp(self, self1))
| 15647 | return failmsgp("Incorrect type of self (must be 'IStreamReader' or its derivative)"); |  | 15647 | return failmsgp("Incorrect type of self (must be 'IStreamReader' or its derivative)");
| 15648 | Ptr<cv::IStreamReader> _self_ = *(self1); |  | 15648 | Ptr<cv::IStreamReader> _self_ = *(self1);
| 15649 | PyObject* pyobj_offset = NULL; |  | 15649 | PyObject* pyobj_offset = NULL;
| 15650 | long long offset; |  | 15650 | long long offset;
| 15651 | PyObject* pyobj_origin = NULL; |  | 15651 | PyObject* pyobj_origin = NULL;
| 15652 | int origin=0; |  | 15652 | int origin=0;
| 15653 | long long retval; |  | 15653 | long long retval;
| 15654 |  |  | 15654 |
| 15655 | const char* keywords[] = { "offset", "origin", NULL }; |  | 15655 | const char* keywords[] = { "offset", "origin", NULL };
| 15656 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:IStreamReader.seek", (char**)keywords, &pyobj_offset, &pyobj_origin) && |  | 15656 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:IStreamReader.seek", (char**)keywords, &pyobj_offset, &pyobj_origin) &&
| 15657 | pyopencv_to_safe(pyobj_offset, offset, ArgInfo("offset", 0)) && |  | 15657 | pyopencv_to_safe(pyobj_offset, offset, ArgInfo("offset", 0)) &&
| 15658 | pyopencv_to_safe(pyobj_origin, origin, ArgInfo("origin", 0)) ) |  | 15658 | pyopencv_to_safe(pyobj_origin, origin, ArgInfo("origin", 0)) )
| 15659 | { |  | 15659 | {
| 15660 | ERRWRAP2(retval = _self_->seek(offset, origin)); |  | 15660 | ERRWRAP2(retval = _self_->seek(offset, origin));
| 15661 | return pyopencv_from(retval); |  | 15661 | return pyopencv_from(retval);
| 15662 | } |  | 15662 | }
| 15663 |  |  | 15663 |
| 15664 | return NULL; |  | 15664 | return NULL;
| 15665 | } |  | 15665 | }
| 15666 |  |  | 15666 |
| 15667 |  |  | 15667 |
| 15668 |  |  | 15668 |
| 15669 | // Tables (IStreamReader) |  | 15669 | // Tables (IStreamReader)
| 15670 |  |  | 15670 |
| 15671 | static PyGetSetDef pyopencv_IStreamReader_getseters[] = |  | 15671 | static PyGetSetDef pyopencv_IStreamReader_getseters[] =
| 15672 | { |  | 15672 | {
| 15673 | {NULL} /* Sentinel */ |  | 15673 | {NULL} /* Sentinel */
| 15674 | }; |  | 15674 | };
| 15675 |  |  | 15675 |
| 15676 | static PyMethodDef pyopencv_IStreamReader_methods[] = |  | 15676 | static PyMethodDef pyopencv_IStreamReader_methods[] =
| 15677 | { |  | 15677 | {
| 15678 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_IStreamReader_read, 0), "read(buffer, size) -> retval\n. @brief Read bytes from stream\n. *\n. * @param buffer already allocated buffer of at least @p size bytes\n. * @param size maximum number of bytes to read\n. *\n. * @return actual number of read bytes"}, |  | 15678 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_IStreamReader_read, 0), "read(buffer, size) -> retval\n. @brief Read bytes from stream\n. *\n. * @param buffer already allocated buffer of at least @p size bytes\n. * @param size maximum number of bytes to read\n. *\n. * @return actual number of read bytes"},
| 15679 | {"seek", CV_PY_FN_WITH_KW_(pyopencv_cv_IStreamReader_seek, 0), "seek(offset, origin) -> retval\n. @brief Sets the stream position\n. *\n. * @param offset Seek offset\n. * @param origin SEEK_SET / SEEK_END / SEEK_CUR\n. *\n. * @see fseek"}, |  | 15679 | {"seek", CV_PY_FN_WITH_KW_(pyopencv_cv_IStreamReader_seek, 0), "seek(offset, origin) -> retval\n. @brief Sets the stream position\n. *\n. * @param offset Seek offset\n. * @param origin SEEK_SET / SEEK_END / SEEK_CUR\n. *\n. * @see fseek"},
| 15680 |  |  | 15680 |
| 15681 | {NULL, NULL} |  | 15681 | {NULL, NULL}
| 15682 | }; |  | 15682 | };
| 15683 |  |  | 15683 |
| 15684 | // Converter (IStreamReader) |  | 15684 | // Converter (IStreamReader)
| 15685 |  |  | 15685 |
| 15686 | template<> |  | 15686 | template<>
| 15687 | struct PyOpenCV_Converter< Ptr<cv::IStreamReader> > |  | 15687 | struct PyOpenCV_Converter< Ptr<cv::IStreamReader> >
| 15688 | { |  | 15688 | {
| 15689 | static PyObject* from(const Ptr<cv::IStreamReader>& r) |  | 15689 | static PyObject* from(const Ptr<cv::IStreamReader>& r)
| 15690 | { |  | 15690 | {
| 15691 | return pyopencv_IStreamReader_Instance(r); |  | 15691 | return pyopencv_IStreamReader_Instance(r);
| 15692 | } |  | 15692 | }
| 15693 | static bool to(PyObject* src, Ptr<cv::IStreamReader>& dst, const ArgInfo& info) |  | 15693 | static bool to(PyObject* src, Ptr<cv::IStreamReader>& dst, const ArgInfo& info)
| 15694 | { |  | 15694 | {
| 15695 | if(!src || src == Py_None) |  | 15695 | if(!src || src == Py_None)
| 15696 | return true; |  | 15696 | return true;
| 15697 | Ptr<cv::IStreamReader> * dst_; |  | 15697 | Ptr<cv::IStreamReader> * dst_;
| 15698 | if (pyopencv_IStreamReader_getp(src, dst_)) |  | 15698 | if (pyopencv_IStreamReader_getp(src, dst_))
| 15699 | { |  | 15699 | {
| 15700 | dst = *dst_; |  | 15700 | dst = *dst_;
| 15701 | return true; |  | 15701 | return true;
| 15702 | } |  | 15702 | }
| 15703 |  |  | 15703 |
| 15704 | failmsg("Expected Ptr<cv::IStreamReader> for argument '%s'", info.name); |  | 15704 | failmsg("Expected Ptr<cv::IStreamReader> for argument '%s'", info.name);
| 15705 | return false; |  | 15705 | return false;
| 15706 | } |  | 15706 | }
| 15707 | }; |  | 15707 | };
| 15708 |  |  | 15708 |
| 15709 | //================================================================================ |  | 15709 | //================================================================================
| 15710 | // KAZE (Generic) |  | 15710 | // KAZE (Generic)
| 15711 | //================================================================================ |  | 15711 | //================================================================================
| 15712 |  |  | 15712 |
| 15713 | // GetSet (KAZE) |  | 15713 | // GetSet (KAZE)
| 15714 |  |  | 15714 |
| 15715 |  |  | 15715 |
| 15716 |  |  | 15716 |
| 15717 | // Methods (KAZE) |  | 15717 | // Methods (KAZE)
| 15718 |  |  | 15718 |
| 15719 | static PyObject* pyopencv_cv_KAZE_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15719 | static PyObject* pyopencv_cv_KAZE_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 15720 | { |  | 15720 | {
| 15721 | using namespace cv; |  | 15721 | using namespace cv;
| 15722 |  |  | 15722 |
| 15723 | PyObject* pyobj_extended = NULL; |  | 15723 | PyObject* pyobj_extended = NULL;
| 15724 | bool extended=false; |  | 15724 | bool extended=false;
| 15725 | PyObject* pyobj_upright = NULL; |  | 15725 | PyObject* pyobj_upright = NULL;
| 15726 | bool upright=false; |  | 15726 | bool upright=false;
| 15727 | PyObject* pyobj_threshold = NULL; |  | 15727 | PyObject* pyobj_threshold = NULL;
| 15728 | float threshold=0.001f; |  | 15728 | float threshold=0.001f;
| 15729 | PyObject* pyobj_nOctaves = NULL; |  | 15729 | PyObject* pyobj_nOctaves = NULL;
| 15730 | int nOctaves=4; |  | 15730 | int nOctaves=4;
| 15731 | PyObject* pyobj_nOctaveLayers = NULL; |  | 15731 | PyObject* pyobj_nOctaveLayers = NULL;
| 15732 | int nOctaveLayers=4; |  | 15732 | int nOctaveLayers=4;
| 15733 | PyObject* pyobj_diffusivity = NULL; |  | 15733 | PyObject* pyobj_diffusivity = NULL;
| 15734 | KAZE_DiffusivityType diffusivity=KAZE::DIFF_PM_G2; |  | 15734 | KAZE_DiffusivityType diffusivity=KAZE::DIFF_PM_G2;
| 15735 | Ptr<KAZE> retval; |  | 15735 | Ptr<KAZE> retval;
| 15736 |  |  | 15736 |
| 15737 | const char* keywords[] = { "extended", "upright", "threshold", "nOctaves", "nOctaveLayers", "diffusivity", NULL }; |  | 15737 | const char* keywords[] = { "extended", "upright", "threshold", "nOctaves", "nOctaveLayers", "diffusivity", NULL };
| 15738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOO:KAZE.create", (char**)keywords, &pyobj_extended, &pyobj_upright, &pyobj_threshold, &pyobj_nOctaves, &pyobj_nOctaveLayers, &pyobj_diffusivity) && |  | 15738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOO:KAZE.create", (char**)keywords, &pyobj_extended, &pyobj_upright, &pyobj_threshold, &pyobj_nOctaves, &pyobj_nOctaveLayers, &pyobj_diffusivity) &&
| 15739 | pyopencv_to_safe(pyobj_extended, extended, ArgInfo("extended", 0)) && |  | 15739 | pyopencv_to_safe(pyobj_extended, extended, ArgInfo("extended", 0)) &&
| 15740 | pyopencv_to_safe(pyobj_upright, upright, ArgInfo("upright", 0)) && |  | 15740 | pyopencv_to_safe(pyobj_upright, upright, ArgInfo("upright", 0)) &&
| 15741 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) && |  | 15741 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) &&
| 15742 | pyopencv_to_safe(pyobj_nOctaves, nOctaves, ArgInfo("nOctaves", 0)) && |  | 15742 | pyopencv_to_safe(pyobj_nOctaves, nOctaves, ArgInfo("nOctaves", 0)) &&
| 15743 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) && |  | 15743 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) &&
| 15744 | pyopencv_to_safe(pyobj_diffusivity, diffusivity, ArgInfo("diffusivity", 0)) ) |  | 15744 | pyopencv_to_safe(pyobj_diffusivity, diffusivity, ArgInfo("diffusivity", 0)) )
| 15745 | { |  | 15745 | {
| 15746 | ERRWRAP2(retval = cv::KAZE::create(extended, upright, threshold, nOctaves, nOctaveLayers, diffusivity)); |  | 15746 | ERRWRAP2(retval = cv::KAZE::create(extended, upright, threshold, nOctaves, nOctaveLayers, diffusivity));
| 15747 | return pyopencv_from(retval); |  | 15747 | return pyopencv_from(retval);
| 15748 | } |  | 15748 | }
| 15749 |  |  | 15749 |
| 15750 | return NULL; |  | 15750 | return NULL;
| 15751 | } |  | 15751 | }
| 15752 |  |  | 15752 |
| 15753 | static PyObject* pyopencv_cv_KAZE_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15753 | static PyObject* pyopencv_cv_KAZE_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 15754 | { |  | 15754 | {
| 15755 | using namespace cv; |  | 15755 | using namespace cv;
| 15756 |  |  | 15756 |
| 15757 |  |  | 15757 |
| 15758 | Ptr<cv::KAZE> * self1 = 0; |  | 15758 | Ptr<cv::KAZE> * self1 = 0;
| 15759 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15759 | if (!pyopencv_KAZE_getp(self, self1))
| 15760 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15760 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15761 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15761 | Ptr<cv::KAZE> _self_ = *(self1);
| 15762 | String retval; |  | 15762 | String retval;
| 15763 |  |  | 15763 |
| 15764 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15764 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15765 | { |  | 15765 | {
| 15766 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 15766 | ERRWRAP2(retval = _self_->getDefaultName());
| 15767 | return pyopencv_from(retval); |  | 15767 | return pyopencv_from(retval);
| 15768 | } |  | 15768 | }
| 15769 |  |  | 15769 |
| 15770 | return NULL; |  | 15770 | return NULL;
| 15771 | } |  | 15771 | }
| 15772 |  |  | 15772 |
| 15773 | static PyObject* pyopencv_cv_KAZE_getDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15773 | static PyObject* pyopencv_cv_KAZE_getDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw)
| 15774 | { |  | 15774 | {
| 15775 | using namespace cv; |  | 15775 | using namespace cv;
| 15776 |  |  | 15776 |
| 15777 |  |  | 15777 |
| 15778 | Ptr<cv::KAZE> * self1 = 0; |  | 15778 | Ptr<cv::KAZE> * self1 = 0;
| 15779 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15779 | if (!pyopencv_KAZE_getp(self, self1))
| 15780 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15780 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15781 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15781 | Ptr<cv::KAZE> _self_ = *(self1);
| 15782 | KAZE::DiffusivityType retval; |  | 15782 | KAZE::DiffusivityType retval;
| 15783 |  |  | 15783 |
| 15784 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15784 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15785 | { |  | 15785 | {
| 15786 | ERRWRAP2(retval = _self_->getDiffusivity()); |  | 15786 | ERRWRAP2(retval = _self_->getDiffusivity());
| 15787 | return pyopencv_from(retval); |  | 15787 | return pyopencv_from(retval);
| 15788 | } |  | 15788 | }
| 15789 |  |  | 15789 |
| 15790 | return NULL; |  | 15790 | return NULL;
| 15791 | } |  | 15791 | }
| 15792 |  |  | 15792 |
| 15793 | static PyObject* pyopencv_cv_KAZE_getExtended(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15793 | static PyObject* pyopencv_cv_KAZE_getExtended(PyObject* self, PyObject* py_args, PyObject* kw)
| 15794 | { |  | 15794 | {
| 15795 | using namespace cv; |  | 15795 | using namespace cv;
| 15796 |  |  | 15796 |
| 15797 |  |  | 15797 |
| 15798 | Ptr<cv::KAZE> * self1 = 0; |  | 15798 | Ptr<cv::KAZE> * self1 = 0;
| 15799 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15799 | if (!pyopencv_KAZE_getp(self, self1))
| 15800 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15800 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15801 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15801 | Ptr<cv::KAZE> _self_ = *(self1);
| 15802 | bool retval; |  | 15802 | bool retval;
| 15803 |  |  | 15803 |
| 15804 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15804 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15805 | { |  | 15805 | {
| 15806 | ERRWRAP2(retval = _self_->getExtended()); |  | 15806 | ERRWRAP2(retval = _self_->getExtended());
| 15807 | return pyopencv_from(retval); |  | 15807 | return pyopencv_from(retval);
| 15808 | } |  | 15808 | }
| 15809 |  |  | 15809 |
| 15810 | return NULL; |  | 15810 | return NULL;
| 15811 | } |  | 15811 | }
| 15812 |  |  | 15812 |
| 15813 | static PyObject* pyopencv_cv_KAZE_getNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15813 | static PyObject* pyopencv_cv_KAZE_getNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw)
| 15814 | { |  | 15814 | {
| 15815 | using namespace cv; |  | 15815 | using namespace cv;
| 15816 |  |  | 15816 |
| 15817 |  |  | 15817 |
| 15818 | Ptr<cv::KAZE> * self1 = 0; |  | 15818 | Ptr<cv::KAZE> * self1 = 0;
| 15819 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15819 | if (!pyopencv_KAZE_getp(self, self1))
| 15820 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15820 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15821 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15821 | Ptr<cv::KAZE> _self_ = *(self1);
| 15822 | int retval; |  | 15822 | int retval;
| 15823 |  |  | 15823 |
| 15824 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15824 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15825 | { |  | 15825 | {
| 15826 | ERRWRAP2(retval = _self_->getNOctaveLayers()); |  | 15826 | ERRWRAP2(retval = _self_->getNOctaveLayers());
| 15827 | return pyopencv_from(retval); |  | 15827 | return pyopencv_from(retval);
| 15828 | } |  | 15828 | }
| 15829 |  |  | 15829 |
| 15830 | return NULL; |  | 15830 | return NULL;
| 15831 | } |  | 15831 | }
| 15832 |  |  | 15832 |
| 15833 | static PyObject* pyopencv_cv_KAZE_getNOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15833 | static PyObject* pyopencv_cv_KAZE_getNOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 15834 | { |  | 15834 | {
| 15835 | using namespace cv; |  | 15835 | using namespace cv;
| 15836 |  |  | 15836 |
| 15837 |  |  | 15837 |
| 15838 | Ptr<cv::KAZE> * self1 = 0; |  | 15838 | Ptr<cv::KAZE> * self1 = 0;
| 15839 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15839 | if (!pyopencv_KAZE_getp(self, self1))
| 15840 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15840 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15841 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15841 | Ptr<cv::KAZE> _self_ = *(self1);
| 15842 | int retval; |  | 15842 | int retval;
| 15843 |  |  | 15843 |
| 15844 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15844 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15845 | { |  | 15845 | {
| 15846 | ERRWRAP2(retval = _self_->getNOctaves()); |  | 15846 | ERRWRAP2(retval = _self_->getNOctaves());
| 15847 | return pyopencv_from(retval); |  | 15847 | return pyopencv_from(retval);
| 15848 | } |  | 15848 | }
| 15849 |  |  | 15849 |
| 15850 | return NULL; |  | 15850 | return NULL;
| 15851 | } |  | 15851 | }
| 15852 |  |  | 15852 |
| 15853 | static PyObject* pyopencv_cv_KAZE_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15853 | static PyObject* pyopencv_cv_KAZE_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 15854 | { |  | 15854 | {
| 15855 | using namespace cv; |  | 15855 | using namespace cv;
| 15856 |  |  | 15856 |
| 15857 |  |  | 15857 |
| 15858 | Ptr<cv::KAZE> * self1 = 0; |  | 15858 | Ptr<cv::KAZE> * self1 = 0;
| 15859 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15859 | if (!pyopencv_KAZE_getp(self, self1))
| 15860 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15860 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15861 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15861 | Ptr<cv::KAZE> _self_ = *(self1);
| 15862 | double retval; |  | 15862 | double retval;
| 15863 |  |  | 15863 |
| 15864 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15864 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15865 | { |  | 15865 | {
| 15866 | ERRWRAP2(retval = _self_->getThreshold()); |  | 15866 | ERRWRAP2(retval = _self_->getThreshold());
| 15867 | return pyopencv_from(retval); |  | 15867 | return pyopencv_from(retval);
| 15868 | } |  | 15868 | }
| 15869 |  |  | 15869 |
| 15870 | return NULL; |  | 15870 | return NULL;
| 15871 | } |  | 15871 | }
| 15872 |  |  | 15872 |
| 15873 | static PyObject* pyopencv_cv_KAZE_getUpright(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15873 | static PyObject* pyopencv_cv_KAZE_getUpright(PyObject* self, PyObject* py_args, PyObject* kw)
| 15874 | { |  | 15874 | {
| 15875 | using namespace cv; |  | 15875 | using namespace cv;
| 15876 |  |  | 15876 |
| 15877 |  |  | 15877 |
| 15878 | Ptr<cv::KAZE> * self1 = 0; |  | 15878 | Ptr<cv::KAZE> * self1 = 0;
| 15879 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15879 | if (!pyopencv_KAZE_getp(self, self1))
| 15880 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15880 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15881 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15881 | Ptr<cv::KAZE> _self_ = *(self1);
| 15882 | bool retval; |  | 15882 | bool retval;
| 15883 |  |  | 15883 |
| 15884 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 15884 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 15885 | { |  | 15885 | {
| 15886 | ERRWRAP2(retval = _self_->getUpright()); |  | 15886 | ERRWRAP2(retval = _self_->getUpright());
| 15887 | return pyopencv_from(retval); |  | 15887 | return pyopencv_from(retval);
| 15888 | } |  | 15888 | }
| 15889 |  |  | 15889 |
| 15890 | return NULL; |  | 15890 | return NULL;
| 15891 | } |  | 15891 | }
| 15892 |  |  | 15892 |
| 15893 | static PyObject* pyopencv_cv_KAZE_setDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15893 | static PyObject* pyopencv_cv_KAZE_setDiffusivity(PyObject* self, PyObject* py_args, PyObject* kw)
| 15894 | { |  | 15894 | {
| 15895 | using namespace cv; |  | 15895 | using namespace cv;
| 15896 |  |  | 15896 |
| 15897 |  |  | 15897 |
| 15898 | Ptr<cv::KAZE> * self1 = 0; |  | 15898 | Ptr<cv::KAZE> * self1 = 0;
| 15899 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15899 | if (!pyopencv_KAZE_getp(self, self1))
| 15900 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15900 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15901 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15901 | Ptr<cv::KAZE> _self_ = *(self1);
| 15902 | PyObject* pyobj_diff = NULL; |  | 15902 | PyObject* pyobj_diff = NULL;
| 15903 | KAZE_DiffusivityType diff=static_cast<KAZE_DiffusivityType>(0); |  | 15903 | KAZE_DiffusivityType diff=static_cast<KAZE_DiffusivityType>(0);
| 15904 |  |  | 15904 |
| 15905 | const char* keywords[] = { "diff", NULL }; |  | 15905 | const char* keywords[] = { "diff", NULL };
| 15906 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setDiffusivity", (char**)keywords, &pyobj_diff) && |  | 15906 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setDiffusivity", (char**)keywords, &pyobj_diff) &&
| 15907 | pyopencv_to_safe(pyobj_diff, diff, ArgInfo("diff", 0)) ) |  | 15907 | pyopencv_to_safe(pyobj_diff, diff, ArgInfo("diff", 0)) )
| 15908 | { |  | 15908 | {
| 15909 | ERRWRAP2(_self_->setDiffusivity(diff)); |  | 15909 | ERRWRAP2(_self_->setDiffusivity(diff));
| 15910 | Py_RETURN_NONE; |  | 15910 | Py_RETURN_NONE;
| 15911 | } |  | 15911 | }
| 15912 |  |  | 15912 |
| 15913 | return NULL; |  | 15913 | return NULL;
| 15914 | } |  | 15914 | }
| 15915 |  |  | 15915 |
| 15916 | static PyObject* pyopencv_cv_KAZE_setExtended(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15916 | static PyObject* pyopencv_cv_KAZE_setExtended(PyObject* self, PyObject* py_args, PyObject* kw)
| 15917 | { |  | 15917 | {
| 15918 | using namespace cv; |  | 15918 | using namespace cv;
| 15919 |  |  | 15919 |
| 15920 |  |  | 15920 |
| 15921 | Ptr<cv::KAZE> * self1 = 0; |  | 15921 | Ptr<cv::KAZE> * self1 = 0;
| 15922 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15922 | if (!pyopencv_KAZE_getp(self, self1))
| 15923 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15923 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15924 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15924 | Ptr<cv::KAZE> _self_ = *(self1);
| 15925 | PyObject* pyobj_extended = NULL; |  | 15925 | PyObject* pyobj_extended = NULL;
| 15926 | bool extended=0; |  | 15926 | bool extended=0;
| 15927 |  |  | 15927 |
| 15928 | const char* keywords[] = { "extended", NULL }; |  | 15928 | const char* keywords[] = { "extended", NULL };
| 15929 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setExtended", (char**)keywords, &pyobj_extended) && |  | 15929 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setExtended", (char**)keywords, &pyobj_extended) &&
| 15930 | pyopencv_to_safe(pyobj_extended, extended, ArgInfo("extended", 0)) ) |  | 15930 | pyopencv_to_safe(pyobj_extended, extended, ArgInfo("extended", 0)) )
| 15931 | { |  | 15931 | {
| 15932 | ERRWRAP2(_self_->setExtended(extended)); |  | 15932 | ERRWRAP2(_self_->setExtended(extended));
| 15933 | Py_RETURN_NONE; |  | 15933 | Py_RETURN_NONE;
| 15934 | } |  | 15934 | }
| 15935 |  |  | 15935 |
| 15936 | return NULL; |  | 15936 | return NULL;
| 15937 | } |  | 15937 | }
| 15938 |  |  | 15938 |
| 15939 | static PyObject* pyopencv_cv_KAZE_setNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15939 | static PyObject* pyopencv_cv_KAZE_setNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw)
| 15940 | { |  | 15940 | {
| 15941 | using namespace cv; |  | 15941 | using namespace cv;
| 15942 |  |  | 15942 |
| 15943 |  |  | 15943 |
| 15944 | Ptr<cv::KAZE> * self1 = 0; |  | 15944 | Ptr<cv::KAZE> * self1 = 0;
| 15945 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15945 | if (!pyopencv_KAZE_getp(self, self1))
| 15946 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15946 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15947 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15947 | Ptr<cv::KAZE> _self_ = *(self1);
| 15948 | PyObject* pyobj_octaveLayers = NULL; |  | 15948 | PyObject* pyobj_octaveLayers = NULL;
| 15949 | int octaveLayers=0; |  | 15949 | int octaveLayers=0;
| 15950 |  |  | 15950 |
| 15951 | const char* keywords[] = { "octaveLayers", NULL }; |  | 15951 | const char* keywords[] = { "octaveLayers", NULL };
| 15952 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setNOctaveLayers", (char**)keywords, &pyobj_octaveLayers) && |  | 15952 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setNOctaveLayers", (char**)keywords, &pyobj_octaveLayers) &&
| 15953 | pyopencv_to_safe(pyobj_octaveLayers, octaveLayers, ArgInfo("octaveLayers", 0)) ) |  | 15953 | pyopencv_to_safe(pyobj_octaveLayers, octaveLayers, ArgInfo("octaveLayers", 0)) )
| 15954 | { |  | 15954 | {
| 15955 | ERRWRAP2(_self_->setNOctaveLayers(octaveLayers)); |  | 15955 | ERRWRAP2(_self_->setNOctaveLayers(octaveLayers));
| 15956 | Py_RETURN_NONE; |  | 15956 | Py_RETURN_NONE;
| 15957 | } |  | 15957 | }
| 15958 |  |  | 15958 |
| 15959 | return NULL; |  | 15959 | return NULL;
| 15960 | } |  | 15960 | }
| 15961 |  |  | 15961 |
| 15962 | static PyObject* pyopencv_cv_KAZE_setNOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15962 | static PyObject* pyopencv_cv_KAZE_setNOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 15963 | { |  | 15963 | {
| 15964 | using namespace cv; |  | 15964 | using namespace cv;
| 15965 |  |  | 15965 |
| 15966 |  |  | 15966 |
| 15967 | Ptr<cv::KAZE> * self1 = 0; |  | 15967 | Ptr<cv::KAZE> * self1 = 0;
| 15968 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15968 | if (!pyopencv_KAZE_getp(self, self1))
| 15969 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15969 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15970 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15970 | Ptr<cv::KAZE> _self_ = *(self1);
| 15971 | PyObject* pyobj_octaves = NULL; |  | 15971 | PyObject* pyobj_octaves = NULL;
| 15972 | int octaves=0; |  | 15972 | int octaves=0;
| 15973 |  |  | 15973 |
| 15974 | const char* keywords[] = { "octaves", NULL }; |  | 15974 | const char* keywords[] = { "octaves", NULL };
| 15975 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setNOctaves", (char**)keywords, &pyobj_octaves) && |  | 15975 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setNOctaves", (char**)keywords, &pyobj_octaves) &&
| 15976 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) ) |  | 15976 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) )
| 15977 | { |  | 15977 | {
| 15978 | ERRWRAP2(_self_->setNOctaves(octaves)); |  | 15978 | ERRWRAP2(_self_->setNOctaves(octaves));
| 15979 | Py_RETURN_NONE; |  | 15979 | Py_RETURN_NONE;
| 15980 | } |  | 15980 | }
| 15981 |  |  | 15981 |
| 15982 | return NULL; |  | 15982 | return NULL;
| 15983 | } |  | 15983 | }
| 15984 |  |  | 15984 |
| 15985 | static PyObject* pyopencv_cv_KAZE_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 15985 | static PyObject* pyopencv_cv_KAZE_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 15986 | { |  | 15986 | {
| 15987 | using namespace cv; |  | 15987 | using namespace cv;
| 15988 |  |  | 15988 |
| 15989 |  |  | 15989 |
| 15990 | Ptr<cv::KAZE> * self1 = 0; |  | 15990 | Ptr<cv::KAZE> * self1 = 0;
| 15991 | if (!pyopencv_KAZE_getp(self, self1)) |  | 15991 | if (!pyopencv_KAZE_getp(self, self1))
| 15992 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 15992 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 15993 | Ptr<cv::KAZE> _self_ = *(self1); |  | 15993 | Ptr<cv::KAZE> _self_ = *(self1);
| 15994 | PyObject* pyobj_threshold = NULL; |  | 15994 | PyObject* pyobj_threshold = NULL;
| 15995 | double threshold=0; |  | 15995 | double threshold=0;
| 15996 |  |  | 15996 |
| 15997 | const char* keywords[] = { "threshold", NULL }; |  | 15997 | const char* keywords[] = { "threshold", NULL };
| 15998 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setThreshold", (char**)keywords, &pyobj_threshold) && |  | 15998 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setThreshold", (char**)keywords, &pyobj_threshold) &&
| 15999 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 15999 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 16000 | { |  | 16000 | {
| 16001 | ERRWRAP2(_self_->setThreshold(threshold)); |  | 16001 | ERRWRAP2(_self_->setThreshold(threshold));
| 16002 | Py_RETURN_NONE; |  | 16002 | Py_RETURN_NONE;
| 16003 | } |  | 16003 | }
| 16004 |  |  | 16004 |
| 16005 | return NULL; |  | 16005 | return NULL;
| 16006 | } |  | 16006 | }
| 16007 |  |  | 16007 |
| 16008 | static PyObject* pyopencv_cv_KAZE_setUpright(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16008 | static PyObject* pyopencv_cv_KAZE_setUpright(PyObject* self, PyObject* py_args, PyObject* kw)
| 16009 | { |  | 16009 | {
| 16010 | using namespace cv; |  | 16010 | using namespace cv;
| 16011 |  |  | 16011 |
| 16012 |  |  | 16012 |
| 16013 | Ptr<cv::KAZE> * self1 = 0; |  | 16013 | Ptr<cv::KAZE> * self1 = 0;
| 16014 | if (!pyopencv_KAZE_getp(self, self1)) |  | 16014 | if (!pyopencv_KAZE_getp(self, self1))
| 16015 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)"); |  | 16015 | return failmsgp("Incorrect type of self (must be 'KAZE' or its derivative)");
| 16016 | Ptr<cv::KAZE> _self_ = *(self1); |  | 16016 | Ptr<cv::KAZE> _self_ = *(self1);
| 16017 | PyObject* pyobj_upright = NULL; |  | 16017 | PyObject* pyobj_upright = NULL;
| 16018 | bool upright=0; |  | 16018 | bool upright=0;
| 16019 |  |  | 16019 |
| 16020 | const char* keywords[] = { "upright", NULL }; |  | 16020 | const char* keywords[] = { "upright", NULL };
| 16021 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setUpright", (char**)keywords, &pyobj_upright) && |  | 16021 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KAZE.setUpright", (char**)keywords, &pyobj_upright) &&
| 16022 | pyopencv_to_safe(pyobj_upright, upright, ArgInfo("upright", 0)) ) |  | 16022 | pyopencv_to_safe(pyobj_upright, upright, ArgInfo("upright", 0)) )
| 16023 | { |  | 16023 | {
| 16024 | ERRWRAP2(_self_->setUpright(upright)); |  | 16024 | ERRWRAP2(_self_->setUpright(upright));
| 16025 | Py_RETURN_NONE; |  | 16025 | Py_RETURN_NONE;
| 16026 | } |  | 16026 | }
| 16027 |  |  | 16027 |
| 16028 | return NULL; |  | 16028 | return NULL;
| 16029 | } |  | 16029 | }
| 16030 |  |  | 16030 |
| 16031 |  |  | 16031 |
| 16032 |  |  | 16032 |
| 16033 | // Tables (KAZE) |  | 16033 | // Tables (KAZE)
| 16034 |  |  | 16034 |
| 16035 | static PyGetSetDef pyopencv_KAZE_getseters[] = |  | 16035 | static PyGetSetDef pyopencv_KAZE_getseters[] =
| 16036 | { |  | 16036 | {
| 16037 | {NULL} /* Sentinel */ |  | 16037 | {NULL} /* Sentinel */
| 16038 | }; |  | 16038 | };
| 16039 |  |  | 16039 |
| 16040 | static PyMethodDef pyopencv_KAZE_methods[] = |  | 16040 | static PyMethodDef pyopencv_KAZE_methods[] =
| 16041 | { |  | 16041 | {
| 16042 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_create_static, METH_STATIC), "create([, extended[, upright[, threshold[, nOctaves[, nOctaveLayers[, diffusivity]]]]]]) -> retval\n. @brief The KAZE constructor\n. \n. @param extended Set to enable extraction of extended (128-byte) descriptor.\n. @param upright Set to enable use of upright descriptors (non rotation-invariant).\n. @param threshold Detector response threshold to accept point\n. @param nOctaves Maximum octave evolution of the image\n. @param nOctaveLayers Default number of sublevels per scale level\n. @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or\n. DIFF_CHARBONNIER"}, |  | 16042 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_create_static, METH_STATIC), "create([, extended[, upright[, threshold[, nOctaves[, nOctaveLayers[, diffusivity]]]]]]) -> retval\n. @brief The KAZE constructor\n. \n. @param extended Set to enable extraction of extended (128-byte) descriptor.\n. @param upright Set to enable use of upright descriptors (non rotation-invariant).\n. @param threshold Detector response threshold to accept point\n. @param nOctaves Maximum octave evolution of the image\n. @param nOctaveLayers Default number of sublevels per scale level\n. @param diffusivity Diffusivity type. DIFF_PM_G1, DIFF_PM_G2, DIFF_WEICKERT or\n. DIFF_CHARBONNIER"},
| 16043 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 16043 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 16044 | {"getDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getDiffusivity, 0), "getDiffusivity() -> retval\n."}, |  | 16044 | {"getDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getDiffusivity, 0), "getDiffusivity() -> retval\n."},
| 16045 | {"getExtended", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getExtended, 0), "getExtended() -> retval\n."}, |  | 16045 | {"getExtended", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getExtended, 0), "getExtended() -> retval\n."},
| 16046 | {"getNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getNOctaveLayers, 0), "getNOctaveLayers() -> retval\n."}, |  | 16046 | {"getNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getNOctaveLayers, 0), "getNOctaveLayers() -> retval\n."},
| 16047 | {"getNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getNOctaves, 0), "getNOctaves() -> retval\n."}, |  | 16047 | {"getNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getNOctaves, 0), "getNOctaves() -> retval\n."},
| 16048 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getThreshold, 0), "getThreshold() -> retval\n."}, |  | 16048 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getThreshold, 0), "getThreshold() -> retval\n."},
| 16049 | {"getUpright", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getUpright, 0), "getUpright() -> retval\n."}, |  | 16049 | {"getUpright", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_getUpright, 0), "getUpright() -> retval\n."},
| 16050 | {"setDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setDiffusivity, 0), "setDiffusivity(diff) -> None\n."}, |  | 16050 | {"setDiffusivity", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setDiffusivity, 0), "setDiffusivity(diff) -> None\n."},
| 16051 | {"setExtended", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setExtended, 0), "setExtended(extended) -> None\n."}, |  | 16051 | {"setExtended", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setExtended, 0), "setExtended(extended) -> None\n."},
| 16052 | {"setNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setNOctaveLayers, 0), "setNOctaveLayers(octaveLayers) -> None\n."}, |  | 16052 | {"setNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setNOctaveLayers, 0), "setNOctaveLayers(octaveLayers) -> None\n."},
| 16053 | {"setNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setNOctaves, 0), "setNOctaves(octaves) -> None\n."}, |  | 16053 | {"setNOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setNOctaves, 0), "setNOctaves(octaves) -> None\n."},
| 16054 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setThreshold, 0), "setThreshold(threshold) -> None\n."}, |  | 16054 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setThreshold, 0), "setThreshold(threshold) -> None\n."},
| 16055 | {"setUpright", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setUpright, 0), "setUpright(upright) -> None\n."}, |  | 16055 | {"setUpright", CV_PY_FN_WITH_KW_(pyopencv_cv_KAZE_setUpright, 0), "setUpright(upright) -> None\n."},
| 16056 |  |  | 16056 |
| 16057 | {NULL, NULL} |  | 16057 | {NULL, NULL}
| 16058 | }; |  | 16058 | };
| 16059 |  |  | 16059 |
| 16060 | // Converter (KAZE) |  | 16060 | // Converter (KAZE)
| 16061 |  |  | 16061 |
| 16062 | template<> |  | 16062 | template<>
| 16063 | struct PyOpenCV_Converter< Ptr<cv::KAZE> > |  | 16063 | struct PyOpenCV_Converter< Ptr<cv::KAZE> >
| 16064 | { |  | 16064 | {
| 16065 | static PyObject* from(const Ptr<cv::KAZE>& r) |  | 16065 | static PyObject* from(const Ptr<cv::KAZE>& r)
| 16066 | { |  | 16066 | {
| 16067 | return pyopencv_KAZE_Instance(r); |  | 16067 | return pyopencv_KAZE_Instance(r);
| 16068 | } |  | 16068 | }
| 16069 | static bool to(PyObject* src, Ptr<cv::KAZE>& dst, const ArgInfo& info) |  | 16069 | static bool to(PyObject* src, Ptr<cv::KAZE>& dst, const ArgInfo& info)
| 16070 | { |  | 16070 | {
| 16071 | if(!src || src == Py_None) |  | 16071 | if(!src || src == Py_None)
| 16072 | return true; |  | 16072 | return true;
| 16073 | Ptr<cv::KAZE> * dst_; |  | 16073 | Ptr<cv::KAZE> * dst_;
| 16074 | if (pyopencv_KAZE_getp(src, dst_)) |  | 16074 | if (pyopencv_KAZE_getp(src, dst_))
| 16075 | { |  | 16075 | {
| 16076 | dst = *dst_; |  | 16076 | dst = *dst_;
| 16077 | return true; |  | 16077 | return true;
| 16078 | } |  | 16078 | }
| 16079 |  |  | 16079 |
| 16080 | failmsg("Expected Ptr<cv::KAZE> for argument '%s'", info.name); |  | 16080 | failmsg("Expected Ptr<cv::KAZE> for argument '%s'", info.name);
| 16081 | return false; |  | 16081 | return false;
| 16082 | } |  | 16082 | }
| 16083 | }; |  | 16083 | };
| 16084 |  |  | 16084 |
| 16085 | //================================================================================ |  | 16085 | //================================================================================
| 16086 | // KalmanFilter (Generic) |  | 16086 | // KalmanFilter (Generic)
| 16087 | //================================================================================ |  | 16087 | //================================================================================
| 16088 |  |  | 16088 |
| 16089 | // GetSet (KalmanFilter) |  | 16089 | // GetSet (KalmanFilter)
| 16090 |  |  | 16090 |
| 16091 |  |  | 16091 |
| 16092 | static PyObject* pyopencv_KalmanFilter_get_controlMatrix(pyopencv_KalmanFilter_t* p, void *closure) |  | 16092 | static PyObject* pyopencv_KalmanFilter_get_controlMatrix(pyopencv_KalmanFilter_t* p, void *closure)
| 16093 | { |  | 16093 | {
| 16094 | return pyopencv_from(p->v->controlMatrix); |  | 16094 | return pyopencv_from(p->v->controlMatrix);
| 16095 | } |  | 16095 | }
| 16096 |  |  | 16096 |
| 16097 | static int pyopencv_KalmanFilter_set_controlMatrix(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16097 | static int pyopencv_KalmanFilter_set_controlMatrix(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16098 | { |  | 16098 | {
| 16099 | if (!value) |  | 16099 | if (!value)
| 16100 | { |  | 16100 | {
| 16101 | PyErr_SetString(PyExc_TypeError, "Cannot delete the controlMatrix attribute"); |  | 16101 | PyErr_SetString(PyExc_TypeError, "Cannot delete the controlMatrix attribute");
| 16102 | return -1; |  | 16102 | return -1;
| 16103 | } |  | 16103 | }
| 16104 | return pyopencv_to_safe(value, p->v->controlMatrix, ArgInfo("value", 0)) ? 0 : -1; |  | 16104 | return pyopencv_to_safe(value, p->v->controlMatrix, ArgInfo("value", 0)) ? 0 : -1;
| 16105 | } |  | 16105 | }
| 16106 |  |  | 16106 |
| 16107 | static PyObject* pyopencv_KalmanFilter_get_errorCovPost(pyopencv_KalmanFilter_t* p, void *closure) |  | 16107 | static PyObject* pyopencv_KalmanFilter_get_errorCovPost(pyopencv_KalmanFilter_t* p, void *closure)
| 16108 | { |  | 16108 | {
| 16109 | return pyopencv_from(p->v->errorCovPost); |  | 16109 | return pyopencv_from(p->v->errorCovPost);
| 16110 | } |  | 16110 | }
| 16111 |  |  | 16111 |
| 16112 | static int pyopencv_KalmanFilter_set_errorCovPost(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16112 | static int pyopencv_KalmanFilter_set_errorCovPost(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16113 | { |  | 16113 | {
| 16114 | if (!value) |  | 16114 | if (!value)
| 16115 | { |  | 16115 | {
| 16116 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCovPost attribute"); |  | 16116 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCovPost attribute");
| 16117 | return -1; |  | 16117 | return -1;
| 16118 | } |  | 16118 | }
| 16119 | return pyopencv_to_safe(value, p->v->errorCovPost, ArgInfo("value", 0)) ? 0 : -1; |  | 16119 | return pyopencv_to_safe(value, p->v->errorCovPost, ArgInfo("value", 0)) ? 0 : -1;
| 16120 | } |  | 16120 | }
| 16121 |  |  | 16121 |
| 16122 | static PyObject* pyopencv_KalmanFilter_get_errorCovPre(pyopencv_KalmanFilter_t* p, void *closure) |  | 16122 | static PyObject* pyopencv_KalmanFilter_get_errorCovPre(pyopencv_KalmanFilter_t* p, void *closure)
| 16123 | { |  | 16123 | {
| 16124 | return pyopencv_from(p->v->errorCovPre); |  | 16124 | return pyopencv_from(p->v->errorCovPre);
| 16125 | } |  | 16125 | }
| 16126 |  |  | 16126 |
| 16127 | static int pyopencv_KalmanFilter_set_errorCovPre(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16127 | static int pyopencv_KalmanFilter_set_errorCovPre(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16128 | { |  | 16128 | {
| 16129 | if (!value) |  | 16129 | if (!value)
| 16130 | { |  | 16130 | {
| 16131 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCovPre attribute"); |  | 16131 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCovPre attribute");
| 16132 | return -1; |  | 16132 | return -1;
| 16133 | } |  | 16133 | }
| 16134 | return pyopencv_to_safe(value, p->v->errorCovPre, ArgInfo("value", 0)) ? 0 : -1; |  | 16134 | return pyopencv_to_safe(value, p->v->errorCovPre, ArgInfo("value", 0)) ? 0 : -1;
| 16135 | } |  | 16135 | }
| 16136 |  |  | 16136 |
| 16137 | static PyObject* pyopencv_KalmanFilter_get_gain(pyopencv_KalmanFilter_t* p, void *closure) |  | 16137 | static PyObject* pyopencv_KalmanFilter_get_gain(pyopencv_KalmanFilter_t* p, void *closure)
| 16138 | { |  | 16138 | {
| 16139 | return pyopencv_from(p->v->gain); |  | 16139 | return pyopencv_from(p->v->gain);
| 16140 | } |  | 16140 | }
| 16141 |  |  | 16141 |
| 16142 | static int pyopencv_KalmanFilter_set_gain(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16142 | static int pyopencv_KalmanFilter_set_gain(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16143 | { |  | 16143 | {
| 16144 | if (!value) |  | 16144 | if (!value)
| 16145 | { |  | 16145 | {
| 16146 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gain attribute"); |  | 16146 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gain attribute");
| 16147 | return -1; |  | 16147 | return -1;
| 16148 | } |  | 16148 | }
| 16149 | return pyopencv_to_safe(value, p->v->gain, ArgInfo("value", 0)) ? 0 : -1; |  | 16149 | return pyopencv_to_safe(value, p->v->gain, ArgInfo("value", 0)) ? 0 : -1;
| 16150 | } |  | 16150 | }
| 16151 |  |  | 16151 |
| 16152 | static PyObject* pyopencv_KalmanFilter_get_measurementMatrix(pyopencv_KalmanFilter_t* p, void *closure) |  | 16152 | static PyObject* pyopencv_KalmanFilter_get_measurementMatrix(pyopencv_KalmanFilter_t* p, void *closure)
| 16153 | { |  | 16153 | {
| 16154 | return pyopencv_from(p->v->measurementMatrix); |  | 16154 | return pyopencv_from(p->v->measurementMatrix);
| 16155 | } |  | 16155 | }
| 16156 |  |  | 16156 |
| 16157 | static int pyopencv_KalmanFilter_set_measurementMatrix(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16157 | static int pyopencv_KalmanFilter_set_measurementMatrix(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16158 | { |  | 16158 | {
| 16159 | if (!value) |  | 16159 | if (!value)
| 16160 | { |  | 16160 | {
| 16161 | PyErr_SetString(PyExc_TypeError, "Cannot delete the measurementMatrix attribute"); |  | 16161 | PyErr_SetString(PyExc_TypeError, "Cannot delete the measurementMatrix attribute");
| 16162 | return -1; |  | 16162 | return -1;
| 16163 | } |  | 16163 | }
| 16164 | return pyopencv_to_safe(value, p->v->measurementMatrix, ArgInfo("value", 0)) ? 0 : -1; |  | 16164 | return pyopencv_to_safe(value, p->v->measurementMatrix, ArgInfo("value", 0)) ? 0 : -1;
| 16165 | } |  | 16165 | }
| 16166 |  |  | 16166 |
| 16167 | static PyObject* pyopencv_KalmanFilter_get_measurementNoiseCov(pyopencv_KalmanFilter_t* p, void *closure) |  | 16167 | static PyObject* pyopencv_KalmanFilter_get_measurementNoiseCov(pyopencv_KalmanFilter_t* p, void *closure)
| 16168 | { |  | 16168 | {
| 16169 | return pyopencv_from(p->v->measurementNoiseCov); |  | 16169 | return pyopencv_from(p->v->measurementNoiseCov);
| 16170 | } |  | 16170 | }
| 16171 |  |  | 16171 |
| 16172 | static int pyopencv_KalmanFilter_set_measurementNoiseCov(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16172 | static int pyopencv_KalmanFilter_set_measurementNoiseCov(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16173 | { |  | 16173 | {
| 16174 | if (!value) |  | 16174 | if (!value)
| 16175 | { |  | 16175 | {
| 16176 | PyErr_SetString(PyExc_TypeError, "Cannot delete the measurementNoiseCov attribute"); |  | 16176 | PyErr_SetString(PyExc_TypeError, "Cannot delete the measurementNoiseCov attribute");
| 16177 | return -1; |  | 16177 | return -1;
| 16178 | } |  | 16178 | }
| 16179 | return pyopencv_to_safe(value, p->v->measurementNoiseCov, ArgInfo("value", 0)) ? 0 : -1; |  | 16179 | return pyopencv_to_safe(value, p->v->measurementNoiseCov, ArgInfo("value", 0)) ? 0 : -1;
| 16180 | } |  | 16180 | }
| 16181 |  |  | 16181 |
| 16182 | static PyObject* pyopencv_KalmanFilter_get_processNoiseCov(pyopencv_KalmanFilter_t* p, void *closure) |  | 16182 | static PyObject* pyopencv_KalmanFilter_get_processNoiseCov(pyopencv_KalmanFilter_t* p, void *closure)
| 16183 | { |  | 16183 | {
| 16184 | return pyopencv_from(p->v->processNoiseCov); |  | 16184 | return pyopencv_from(p->v->processNoiseCov);
| 16185 | } |  | 16185 | }
| 16186 |  |  | 16186 |
| 16187 | static int pyopencv_KalmanFilter_set_processNoiseCov(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16187 | static int pyopencv_KalmanFilter_set_processNoiseCov(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16188 | { |  | 16188 | {
| 16189 | if (!value) |  | 16189 | if (!value)
| 16190 | { |  | 16190 | {
| 16191 | PyErr_SetString(PyExc_TypeError, "Cannot delete the processNoiseCov attribute"); |  | 16191 | PyErr_SetString(PyExc_TypeError, "Cannot delete the processNoiseCov attribute");
| 16192 | return -1; |  | 16192 | return -1;
| 16193 | } |  | 16193 | }
| 16194 | return pyopencv_to_safe(value, p->v->processNoiseCov, ArgInfo("value", 0)) ? 0 : -1; |  | 16194 | return pyopencv_to_safe(value, p->v->processNoiseCov, ArgInfo("value", 0)) ? 0 : -1;
| 16195 | } |  | 16195 | }
| 16196 |  |  | 16196 |
| 16197 | static PyObject* pyopencv_KalmanFilter_get_statePost(pyopencv_KalmanFilter_t* p, void *closure) |  | 16197 | static PyObject* pyopencv_KalmanFilter_get_statePost(pyopencv_KalmanFilter_t* p, void *closure)
| 16198 | { |  | 16198 | {
| 16199 | return pyopencv_from(p->v->statePost); |  | 16199 | return pyopencv_from(p->v->statePost);
| 16200 | } |  | 16200 | }
| 16201 |  |  | 16201 |
| 16202 | static int pyopencv_KalmanFilter_set_statePost(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16202 | static int pyopencv_KalmanFilter_set_statePost(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16203 | { |  | 16203 | {
| 16204 | if (!value) |  | 16204 | if (!value)
| 16205 | { |  | 16205 | {
| 16206 | PyErr_SetString(PyExc_TypeError, "Cannot delete the statePost attribute"); |  | 16206 | PyErr_SetString(PyExc_TypeError, "Cannot delete the statePost attribute");
| 16207 | return -1; |  | 16207 | return -1;
| 16208 | } |  | 16208 | }
| 16209 | return pyopencv_to_safe(value, p->v->statePost, ArgInfo("value", 0)) ? 0 : -1; |  | 16209 | return pyopencv_to_safe(value, p->v->statePost, ArgInfo("value", 0)) ? 0 : -1;
| 16210 | } |  | 16210 | }
| 16211 |  |  | 16211 |
| 16212 | static PyObject* pyopencv_KalmanFilter_get_statePre(pyopencv_KalmanFilter_t* p, void *closure) |  | 16212 | static PyObject* pyopencv_KalmanFilter_get_statePre(pyopencv_KalmanFilter_t* p, void *closure)
| 16213 | { |  | 16213 | {
| 16214 | return pyopencv_from(p->v->statePre); |  | 16214 | return pyopencv_from(p->v->statePre);
| 16215 | } |  | 16215 | }
| 16216 |  |  | 16216 |
| 16217 | static int pyopencv_KalmanFilter_set_statePre(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16217 | static int pyopencv_KalmanFilter_set_statePre(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16218 | { |  | 16218 | {
| 16219 | if (!value) |  | 16219 | if (!value)
| 16220 | { |  | 16220 | {
| 16221 | PyErr_SetString(PyExc_TypeError, "Cannot delete the statePre attribute"); |  | 16221 | PyErr_SetString(PyExc_TypeError, "Cannot delete the statePre attribute");
| 16222 | return -1; |  | 16222 | return -1;
| 16223 | } |  | 16223 | }
| 16224 | return pyopencv_to_safe(value, p->v->statePre, ArgInfo("value", 0)) ? 0 : -1; |  | 16224 | return pyopencv_to_safe(value, p->v->statePre, ArgInfo("value", 0)) ? 0 : -1;
| 16225 | } |  | 16225 | }
| 16226 |  |  | 16226 |
| 16227 | static PyObject* pyopencv_KalmanFilter_get_transitionMatrix(pyopencv_KalmanFilter_t* p, void *closure) |  | 16227 | static PyObject* pyopencv_KalmanFilter_get_transitionMatrix(pyopencv_KalmanFilter_t* p, void *closure)
| 16228 | { |  | 16228 | {
| 16229 | return pyopencv_from(p->v->transitionMatrix); |  | 16229 | return pyopencv_from(p->v->transitionMatrix);
| 16230 | } |  | 16230 | }
| 16231 |  |  | 16231 |
| 16232 | static int pyopencv_KalmanFilter_set_transitionMatrix(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure) |  | 16232 | static int pyopencv_KalmanFilter_set_transitionMatrix(pyopencv_KalmanFilter_t* p, PyObject *value, void *closure)
| 16233 | { |  | 16233 | {
| 16234 | if (!value) |  | 16234 | if (!value)
| 16235 | { |  | 16235 | {
| 16236 | PyErr_SetString(PyExc_TypeError, "Cannot delete the transitionMatrix attribute"); |  | 16236 | PyErr_SetString(PyExc_TypeError, "Cannot delete the transitionMatrix attribute");
| 16237 | return -1; |  | 16237 | return -1;
| 16238 | } |  | 16238 | }
| 16239 | return pyopencv_to_safe(value, p->v->transitionMatrix, ArgInfo("value", 0)) ? 0 : -1; |  | 16239 | return pyopencv_to_safe(value, p->v->transitionMatrix, ArgInfo("value", 0)) ? 0 : -1;
| 16240 | } |  | 16240 | }
| 16241 |  |  | 16241 |
| 16242 |  |  | 16242 |
| 16243 | // Methods (KalmanFilter) |  | 16243 | // Methods (KalmanFilter)
| 16244 |  |  | 16244 |
| 16245 | static int pyopencv_cv_KalmanFilter_KalmanFilter(pyopencv_KalmanFilter_t* self, PyObject* py_args, PyObject* kw) |  | 16245 | static int pyopencv_cv_KalmanFilter_KalmanFilter(pyopencv_KalmanFilter_t* self, PyObject* py_args, PyObject* kw)
| 16246 | { |  | 16246 | {
| 16247 | using namespace cv; |  | 16247 | using namespace cv;
| 16248 |  |  | 16248 |
| 16249 | pyPrepareArgumentConversionErrorsStorage(2); |  | 16249 | pyPrepareArgumentConversionErrorsStorage(2);
| 16250 |  |  | 16250 |
| 16251 | { |  | 16251 | {
| 16252 |  |  | 16252 |
| 16253 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 16253 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 16254 | { |  | 16254 | {
| 16255 | new (&(self->v)) Ptr<cv::KalmanFilter>(); // init Ptr with placement new |  | 16255 | new (&(self->v)) Ptr<cv::KalmanFilter>(); // init Ptr with placement new
| 16256 | if(self) ERRWRAP2(self->v.reset(new cv::KalmanFilter())); |  | 16256 | if(self) ERRWRAP2(self->v.reset(new cv::KalmanFilter()));
| 16257 | return 0; |  | 16257 | return 0;
| 16258 | } |  | 16258 | }
| 16259 |  |  | 16259 |
| 16260 |  |  | 16260 |
| 16261 | pyPopulateArgumentConversionErrors(); |  | 16261 | pyPopulateArgumentConversionErrors();
| 16262 | } |  | 16262 | }
| 16263 |  |  | 16263 |
| 16264 |  |  | 16264 |
| 16265 | { |  | 16265 | {
| 16266 | PyObject* pyobj_dynamParams = NULL; |  | 16266 | PyObject* pyobj_dynamParams = NULL;
| 16267 | int dynamParams=0; |  | 16267 | int dynamParams=0;
| 16268 | PyObject* pyobj_measureParams = NULL; |  | 16268 | PyObject* pyobj_measureParams = NULL;
| 16269 | int measureParams=0; |  | 16269 | int measureParams=0;
| 16270 | PyObject* pyobj_controlParams = NULL; |  | 16270 | PyObject* pyobj_controlParams = NULL;
| 16271 | int controlParams=0; |  | 16271 | int controlParams=0;
| 16272 | PyObject* pyobj_type = NULL; |  | 16272 | PyObject* pyobj_type = NULL;
| 16273 | int type=CV_32F; |  | 16273 | int type=CV_32F;
| 16274 |  |  | 16274 |
| 16275 | const char* keywords[] = { "dynamParams", "measureParams", "controlParams", "type", NULL }; |  | 16275 | const char* keywords[] = { "dynamParams", "measureParams", "controlParams", "type", NULL };
| 16276 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:KalmanFilter", (char**)keywords, &pyobj_dynamParams, &pyobj_measureParams, &pyobj_controlParams, &pyobj_type) && |  | 16276 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:KalmanFilter", (char**)keywords, &pyobj_dynamParams, &pyobj_measureParams, &pyobj_controlParams, &pyobj_type) &&
| 16277 | pyopencv_to_safe(pyobj_dynamParams, dynamParams, ArgInfo("dynamParams", 0)) && |  | 16277 | pyopencv_to_safe(pyobj_dynamParams, dynamParams, ArgInfo("dynamParams", 0)) &&
| 16278 | pyopencv_to_safe(pyobj_measureParams, measureParams, ArgInfo("measureParams", 0)) && |  | 16278 | pyopencv_to_safe(pyobj_measureParams, measureParams, ArgInfo("measureParams", 0)) &&
| 16279 | pyopencv_to_safe(pyobj_controlParams, controlParams, ArgInfo("controlParams", 0)) && |  | 16279 | pyopencv_to_safe(pyobj_controlParams, controlParams, ArgInfo("controlParams", 0)) &&
| 16280 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 16280 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 16281 | { |  | 16281 | {
| 16282 | new (&(self->v)) Ptr<cv::KalmanFilter>(); // init Ptr with placement new |  | 16282 | new (&(self->v)) Ptr<cv::KalmanFilter>(); // init Ptr with placement new
| 16283 | if(self) ERRWRAP2(self->v.reset(new cv::KalmanFilter(dynamParams, measureParams, controlParams, type))); |  | 16283 | if(self) ERRWRAP2(self->v.reset(new cv::KalmanFilter(dynamParams, measureParams, controlParams, type)));
| 16284 | return 0; |  | 16284 | return 0;
| 16285 | } |  | 16285 | }
| 16286 |  |  | 16286 |
| 16287 |  |  | 16287 |
| 16288 | pyPopulateArgumentConversionErrors(); |  | 16288 | pyPopulateArgumentConversionErrors();
| 16289 | } |  | 16289 | }
| 16290 | pyRaiseCVOverloadException("KalmanFilter"); |  | 16290 | pyRaiseCVOverloadException("KalmanFilter");
| 16291 |  |  | 16291 |
| 16292 | return -1; |  | 16292 | return -1;
| 16293 | } |  | 16293 | }
| 16294 |  |  | 16294 |
| 16295 | static PyObject* pyopencv_cv_KalmanFilter_correct(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16295 | static PyObject* pyopencv_cv_KalmanFilter_correct(PyObject* self, PyObject* py_args, PyObject* kw)
| 16296 | { |  | 16296 | {
| 16297 | using namespace cv; |  | 16297 | using namespace cv;
| 16298 |  |  | 16298 |
| 16299 |  |  | 16299 |
| 16300 | Ptr<cv::KalmanFilter> * self1 = 0; |  | 16300 | Ptr<cv::KalmanFilter> * self1 = 0;
| 16301 | if (!pyopencv_KalmanFilter_getp(self, self1)) |  | 16301 | if (!pyopencv_KalmanFilter_getp(self, self1))
| 16302 | return failmsgp("Incorrect type of self (must be 'KalmanFilter' or its derivative)"); |  | 16302 | return failmsgp("Incorrect type of self (must be 'KalmanFilter' or its derivative)");
| 16303 | Ptr<cv::KalmanFilter> _self_ = *(self1); |  | 16303 | Ptr<cv::KalmanFilter> _self_ = *(self1);
| 16304 | PyObject* pyobj_measurement = NULL; |  | 16304 | PyObject* pyobj_measurement = NULL;
| 16305 | Mat measurement; |  | 16305 | Mat measurement;
| 16306 | Mat retval; |  | 16306 | Mat retval;
| 16307 |  |  | 16307 |
| 16308 | const char* keywords[] = { "measurement", NULL }; |  | 16308 | const char* keywords[] = { "measurement", NULL };
| 16309 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KalmanFilter.correct", (char**)keywords, &pyobj_measurement) && |  | 16309 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KalmanFilter.correct", (char**)keywords, &pyobj_measurement) &&
| 16310 | pyopencv_to_safe(pyobj_measurement, measurement, ArgInfo("measurement", 0)) ) |  | 16310 | pyopencv_to_safe(pyobj_measurement, measurement, ArgInfo("measurement", 0)) )
| 16311 | { |  | 16311 | {
| 16312 | ERRWRAP2(retval = _self_->correct(measurement)); |  | 16312 | ERRWRAP2(retval = _self_->correct(measurement));
| 16313 | return pyopencv_from(retval); |  | 16313 | return pyopencv_from(retval);
| 16314 | } |  | 16314 | }
| 16315 |  |  | 16315 |
| 16316 | return NULL; |  | 16316 | return NULL;
| 16317 | } |  | 16317 | }
| 16318 |  |  | 16318 |
| 16319 | static PyObject* pyopencv_cv_KalmanFilter_predict(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16319 | static PyObject* pyopencv_cv_KalmanFilter_predict(PyObject* self, PyObject* py_args, PyObject* kw)
| 16320 | { |  | 16320 | {
| 16321 | using namespace cv; |  | 16321 | using namespace cv;
| 16322 |  |  | 16322 |
| 16323 |  |  | 16323 |
| 16324 | Ptr<cv::KalmanFilter> * self1 = 0; |  | 16324 | Ptr<cv::KalmanFilter> * self1 = 0;
| 16325 | if (!pyopencv_KalmanFilter_getp(self, self1)) |  | 16325 | if (!pyopencv_KalmanFilter_getp(self, self1))
| 16326 | return failmsgp("Incorrect type of self (must be 'KalmanFilter' or its derivative)"); |  | 16326 | return failmsgp("Incorrect type of self (must be 'KalmanFilter' or its derivative)");
| 16327 | Ptr<cv::KalmanFilter> _self_ = *(self1); |  | 16327 | Ptr<cv::KalmanFilter> _self_ = *(self1);
| 16328 | PyObject* pyobj_control = NULL; |  | 16328 | PyObject* pyobj_control = NULL;
| 16329 | Mat control; |  | 16329 | Mat control;
| 16330 | Mat retval; |  | 16330 | Mat retval;
| 16331 |  |  | 16331 |
| 16332 | const char* keywords[] = { "control", NULL }; |  | 16332 | const char* keywords[] = { "control", NULL };
| 16333 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:KalmanFilter.predict", (char**)keywords, &pyobj_control) && |  | 16333 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:KalmanFilter.predict", (char**)keywords, &pyobj_control) &&
| 16334 | pyopencv_to_safe(pyobj_control, control, ArgInfo("control", 0)) ) |  | 16334 | pyopencv_to_safe(pyobj_control, control, ArgInfo("control", 0)) )
| 16335 | { |  | 16335 | {
| 16336 | ERRWRAP2(retval = _self_->predict(control)); |  | 16336 | ERRWRAP2(retval = _self_->predict(control));
| 16337 | return pyopencv_from(retval); |  | 16337 | return pyopencv_from(retval);
| 16338 | } |  | 16338 | }
| 16339 |  |  | 16339 |
| 16340 | return NULL; |  | 16340 | return NULL;
| 16341 | } |  | 16341 | }
| 16342 |  |  | 16342 |
| 16343 |  |  | 16343 |
| 16344 |  |  | 16344 |
| 16345 | // Tables (KalmanFilter) |  | 16345 | // Tables (KalmanFilter)
| 16346 |  |  | 16346 |
| 16347 | static PyGetSetDef pyopencv_KalmanFilter_getseters[] = |  | 16347 | static PyGetSetDef pyopencv_KalmanFilter_getseters[] =
| 16348 | { |  | 16348 | {
| 16349 | {(char*)"controlMatrix", (getter)pyopencv_KalmanFilter_get_controlMatrix, (setter)pyopencv_KalmanFilter_set_controlMatrix, (char*)"controlMatrix", NULL}, |  | 16349 | {(char*)"controlMatrix", (getter)pyopencv_KalmanFilter_get_controlMatrix, (setter)pyopencv_KalmanFilter_set_controlMatrix, (char*)"controlMatrix", NULL},
| 16350 | {(char*)"errorCovPost", (getter)pyopencv_KalmanFilter_get_errorCovPost, (setter)pyopencv_KalmanFilter_set_errorCovPost, (char*)"errorCovPost", NULL}, |  | 16350 | {(char*)"errorCovPost", (getter)pyopencv_KalmanFilter_get_errorCovPost, (setter)pyopencv_KalmanFilter_set_errorCovPost, (char*)"errorCovPost", NULL},
| 16351 | {(char*)"errorCovPre", (getter)pyopencv_KalmanFilter_get_errorCovPre, (setter)pyopencv_KalmanFilter_set_errorCovPre, (char*)"errorCovPre", NULL}, |  | 16351 | {(char*)"errorCovPre", (getter)pyopencv_KalmanFilter_get_errorCovPre, (setter)pyopencv_KalmanFilter_set_errorCovPre, (char*)"errorCovPre", NULL},
| 16352 | {(char*)"gain", (getter)pyopencv_KalmanFilter_get_gain, (setter)pyopencv_KalmanFilter_set_gain, (char*)"gain", NULL}, |  | 16352 | {(char*)"gain", (getter)pyopencv_KalmanFilter_get_gain, (setter)pyopencv_KalmanFilter_set_gain, (char*)"gain", NULL},
| 16353 | {(char*)"measurementMatrix", (getter)pyopencv_KalmanFilter_get_measurementMatrix, (setter)pyopencv_KalmanFilter_set_measurementMatrix, (char*)"measurementMatrix", NULL}, |  | 16353 | {(char*)"measurementMatrix", (getter)pyopencv_KalmanFilter_get_measurementMatrix, (setter)pyopencv_KalmanFilter_set_measurementMatrix, (char*)"measurementMatrix", NULL},
| 16354 | {(char*)"measurementNoiseCov", (getter)pyopencv_KalmanFilter_get_measurementNoiseCov, (setter)pyopencv_KalmanFilter_set_measurementNoiseCov, (char*)"measurementNoiseCov", NULL}, |  | 16354 | {(char*)"measurementNoiseCov", (getter)pyopencv_KalmanFilter_get_measurementNoiseCov, (setter)pyopencv_KalmanFilter_set_measurementNoiseCov, (char*)"measurementNoiseCov", NULL},
| 16355 | {(char*)"processNoiseCov", (getter)pyopencv_KalmanFilter_get_processNoiseCov, (setter)pyopencv_KalmanFilter_set_processNoiseCov, (char*)"processNoiseCov", NULL}, |  | 16355 | {(char*)"processNoiseCov", (getter)pyopencv_KalmanFilter_get_processNoiseCov, (setter)pyopencv_KalmanFilter_set_processNoiseCov, (char*)"processNoiseCov", NULL},
| 16356 | {(char*)"statePost", (getter)pyopencv_KalmanFilter_get_statePost, (setter)pyopencv_KalmanFilter_set_statePost, (char*)"statePost", NULL}, |  | 16356 | {(char*)"statePost", (getter)pyopencv_KalmanFilter_get_statePost, (setter)pyopencv_KalmanFilter_set_statePost, (char*)"statePost", NULL},
| 16357 | {(char*)"statePre", (getter)pyopencv_KalmanFilter_get_statePre, (setter)pyopencv_KalmanFilter_set_statePre, (char*)"statePre", NULL}, |  | 16357 | {(char*)"statePre", (getter)pyopencv_KalmanFilter_get_statePre, (setter)pyopencv_KalmanFilter_set_statePre, (char*)"statePre", NULL},
| 16358 | {(char*)"transitionMatrix", (getter)pyopencv_KalmanFilter_get_transitionMatrix, (setter)pyopencv_KalmanFilter_set_transitionMatrix, (char*)"transitionMatrix", NULL}, |  | 16358 | {(char*)"transitionMatrix", (getter)pyopencv_KalmanFilter_get_transitionMatrix, (setter)pyopencv_KalmanFilter_set_transitionMatrix, (char*)"transitionMatrix", NULL},
| 16359 | {NULL} /* Sentinel */ |  | 16359 | {NULL} /* Sentinel */
| 16360 | }; |  | 16360 | };
| 16361 |  |  | 16361 |
| 16362 | static PyMethodDef pyopencv_KalmanFilter_methods[] = |  | 16362 | static PyMethodDef pyopencv_KalmanFilter_methods[] =
| 16363 | { |  | 16363 | {
| 16364 | {"correct", CV_PY_FN_WITH_KW_(pyopencv_cv_KalmanFilter_correct, 0), "correct(measurement) -> retval\n. @brief Updates the predicted state from the measurement.\n. \n. @param measurement The measured system parameters"}, |  | 16364 | {"correct", CV_PY_FN_WITH_KW_(pyopencv_cv_KalmanFilter_correct, 0), "correct(measurement) -> retval\n. @brief Updates the predicted state from the measurement.\n. \n. @param measurement The measured system parameters"},
| 16365 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_KalmanFilter_predict, 0), "predict([, control]) -> retval\n. @brief Computes a predicted state.\n. \n. @param control The optional input control"}, |  | 16365 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_KalmanFilter_predict, 0), "predict([, control]) -> retval\n. @brief Computes a predicted state.\n. \n. @param control The optional input control"},
| 16366 |  |  | 16366 |
| 16367 | {NULL, NULL} |  | 16367 | {NULL, NULL}
| 16368 | }; |  | 16368 | };
| 16369 |  |  | 16369 |
| 16370 | // Converter (KalmanFilter) |  | 16370 | // Converter (KalmanFilter)
| 16371 |  |  | 16371 |
| 16372 | template<> |  | 16372 | template<>
| 16373 | struct PyOpenCV_Converter< Ptr<cv::KalmanFilter> > |  | 16373 | struct PyOpenCV_Converter< Ptr<cv::KalmanFilter> >
| 16374 | { |  | 16374 | {
| 16375 | static PyObject* from(const Ptr<cv::KalmanFilter>& r) |  | 16375 | static PyObject* from(const Ptr<cv::KalmanFilter>& r)
| 16376 | { |  | 16376 | {
| 16377 | return pyopencv_KalmanFilter_Instance(r); |  | 16377 | return pyopencv_KalmanFilter_Instance(r);
| 16378 | } |  | 16378 | }
| 16379 | static bool to(PyObject* src, Ptr<cv::KalmanFilter>& dst, const ArgInfo& info) |  | 16379 | static bool to(PyObject* src, Ptr<cv::KalmanFilter>& dst, const ArgInfo& info)
| 16380 | { |  | 16380 | {
| 16381 | if(!src || src == Py_None) |  | 16381 | if(!src || src == Py_None)
| 16382 | return true; |  | 16382 | return true;
| 16383 | Ptr<cv::KalmanFilter> * dst_; |  | 16383 | Ptr<cv::KalmanFilter> * dst_;
| 16384 | if (pyopencv_KalmanFilter_getp(src, dst_)) |  | 16384 | if (pyopencv_KalmanFilter_getp(src, dst_))
| 16385 | { |  | 16385 | {
| 16386 | dst = *dst_; |  | 16386 | dst = *dst_;
| 16387 | return true; |  | 16387 | return true;
| 16388 | } |  | 16388 | }
| 16389 |  |  | 16389 |
| 16390 | failmsg("Expected Ptr<cv::KalmanFilter> for argument '%s'", info.name); |  | 16390 | failmsg("Expected Ptr<cv::KalmanFilter> for argument '%s'", info.name);
| 16391 | return false; |  | 16391 | return false;
| 16392 | } |  | 16392 | }
| 16393 | }; |  | 16393 | };
| 16394 |  |  | 16394 |
| 16395 | //================================================================================ |  | 16395 | //================================================================================
| 16396 | // KeyPoint (Generic) |  | 16396 | // KeyPoint (Generic)
| 16397 | //================================================================================ |  | 16397 | //================================================================================
| 16398 |  |  | 16398 |
| 16399 | // GetSet (KeyPoint) |  | 16399 | // GetSet (KeyPoint)
| 16400 |  |  | 16400 |
| 16401 |  |  | 16401 |
| 16402 | static PyObject* pyopencv_KeyPoint_get_angle(pyopencv_KeyPoint_t* p, void *closure) |  | 16402 | static PyObject* pyopencv_KeyPoint_get_angle(pyopencv_KeyPoint_t* p, void *closure)
| 16403 | { |  | 16403 | {
| 16404 | return pyopencv_from(p->v.angle); |  | 16404 | return pyopencv_from(p->v.angle);
| 16405 | } |  | 16405 | }
| 16406 |  |  | 16406 |
| 16407 | static int pyopencv_KeyPoint_set_angle(pyopencv_KeyPoint_t* p, PyObject *value, void *closure) |  | 16407 | static int pyopencv_KeyPoint_set_angle(pyopencv_KeyPoint_t* p, PyObject *value, void *closure)
| 16408 | { |  | 16408 | {
| 16409 | if (!value) |  | 16409 | if (!value)
| 16410 | { |  | 16410 | {
| 16411 | PyErr_SetString(PyExc_TypeError, "Cannot delete the angle attribute"); |  | 16411 | PyErr_SetString(PyExc_TypeError, "Cannot delete the angle attribute");
| 16412 | return -1; |  | 16412 | return -1;
| 16413 | } |  | 16413 | }
| 16414 | return pyopencv_to_safe(value, p->v.angle, ArgInfo("value", 0)) ? 0 : -1; |  | 16414 | return pyopencv_to_safe(value, p->v.angle, ArgInfo("value", 0)) ? 0 : -1;
| 16415 | } |  | 16415 | }
| 16416 |  |  | 16416 |
| 16417 | static PyObject* pyopencv_KeyPoint_get_class_id(pyopencv_KeyPoint_t* p, void *closure) |  | 16417 | static PyObject* pyopencv_KeyPoint_get_class_id(pyopencv_KeyPoint_t* p, void *closure)
| 16418 | { |  | 16418 | {
| 16419 | return pyopencv_from(p->v.class_id); |  | 16419 | return pyopencv_from(p->v.class_id);
| 16420 | } |  | 16420 | }
| 16421 |  |  | 16421 |
| 16422 | static int pyopencv_KeyPoint_set_class_id(pyopencv_KeyPoint_t* p, PyObject *value, void *closure) |  | 16422 | static int pyopencv_KeyPoint_set_class_id(pyopencv_KeyPoint_t* p, PyObject *value, void *closure)
| 16423 | { |  | 16423 | {
| 16424 | if (!value) |  | 16424 | if (!value)
| 16425 | { |  | 16425 | {
| 16426 | PyErr_SetString(PyExc_TypeError, "Cannot delete the class_id attribute"); |  | 16426 | PyErr_SetString(PyExc_TypeError, "Cannot delete the class_id attribute");
| 16427 | return -1; |  | 16427 | return -1;
| 16428 | } |  | 16428 | }
| 16429 | return pyopencv_to_safe(value, p->v.class_id, ArgInfo("value", 0)) ? 0 : -1; |  | 16429 | return pyopencv_to_safe(value, p->v.class_id, ArgInfo("value", 0)) ? 0 : -1;
| 16430 | } |  | 16430 | }
| 16431 |  |  | 16431 |
| 16432 | static PyObject* pyopencv_KeyPoint_get_octave(pyopencv_KeyPoint_t* p, void *closure) |  | 16432 | static PyObject* pyopencv_KeyPoint_get_octave(pyopencv_KeyPoint_t* p, void *closure)
| 16433 | { |  | 16433 | {
| 16434 | return pyopencv_from(p->v.octave); |  | 16434 | return pyopencv_from(p->v.octave);
| 16435 | } |  | 16435 | }
| 16436 |  |  | 16436 |
| 16437 | static int pyopencv_KeyPoint_set_octave(pyopencv_KeyPoint_t* p, PyObject *value, void *closure) |  | 16437 | static int pyopencv_KeyPoint_set_octave(pyopencv_KeyPoint_t* p, PyObject *value, void *closure)
| 16438 | { |  | 16438 | {
| 16439 | if (!value) |  | 16439 | if (!value)
| 16440 | { |  | 16440 | {
| 16441 | PyErr_SetString(PyExc_TypeError, "Cannot delete the octave attribute"); |  | 16441 | PyErr_SetString(PyExc_TypeError, "Cannot delete the octave attribute");
| 16442 | return -1; |  | 16442 | return -1;
| 16443 | } |  | 16443 | }
| 16444 | return pyopencv_to_safe(value, p->v.octave, ArgInfo("value", 0)) ? 0 : -1; |  | 16444 | return pyopencv_to_safe(value, p->v.octave, ArgInfo("value", 0)) ? 0 : -1;
| 16445 | } |  | 16445 | }
| 16446 |  |  | 16446 |
| 16447 | static PyObject* pyopencv_KeyPoint_get_pt(pyopencv_KeyPoint_t* p, void *closure) |  | 16447 | static PyObject* pyopencv_KeyPoint_get_pt(pyopencv_KeyPoint_t* p, void *closure)
| 16448 | { |  | 16448 | {
| 16449 | return pyopencv_from(p->v.pt); |  | 16449 | return pyopencv_from(p->v.pt);
| 16450 | } |  | 16450 | }
| 16451 |  |  | 16451 |
| 16452 | static int pyopencv_KeyPoint_set_pt(pyopencv_KeyPoint_t* p, PyObject *value, void *closure) |  | 16452 | static int pyopencv_KeyPoint_set_pt(pyopencv_KeyPoint_t* p, PyObject *value, void *closure)
| 16453 | { |  | 16453 | {
| 16454 | if (!value) |  | 16454 | if (!value)
| 16455 | { |  | 16455 | {
| 16456 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt attribute"); |  | 16456 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt attribute");
| 16457 | return -1; |  | 16457 | return -1;
| 16458 | } |  | 16458 | }
| 16459 | return pyopencv_to_safe(value, p->v.pt, ArgInfo("value", 0)) ? 0 : -1; |  | 16459 | return pyopencv_to_safe(value, p->v.pt, ArgInfo("value", 0)) ? 0 : -1;
| 16460 | } |  | 16460 | }
| 16461 |  |  | 16461 |
| 16462 | static PyObject* pyopencv_KeyPoint_get_response(pyopencv_KeyPoint_t* p, void *closure) |  | 16462 | static PyObject* pyopencv_KeyPoint_get_response(pyopencv_KeyPoint_t* p, void *closure)
| 16463 | { |  | 16463 | {
| 16464 | return pyopencv_from(p->v.response); |  | 16464 | return pyopencv_from(p->v.response);
| 16465 | } |  | 16465 | }
| 16466 |  |  | 16466 |
| 16467 | static int pyopencv_KeyPoint_set_response(pyopencv_KeyPoint_t* p, PyObject *value, void *closure) |  | 16467 | static int pyopencv_KeyPoint_set_response(pyopencv_KeyPoint_t* p, PyObject *value, void *closure)
| 16468 | { |  | 16468 | {
| 16469 | if (!value) |  | 16469 | if (!value)
| 16470 | { |  | 16470 | {
| 16471 | PyErr_SetString(PyExc_TypeError, "Cannot delete the response attribute"); |  | 16471 | PyErr_SetString(PyExc_TypeError, "Cannot delete the response attribute");
| 16472 | return -1; |  | 16472 | return -1;
| 16473 | } |  | 16473 | }
| 16474 | return pyopencv_to_safe(value, p->v.response, ArgInfo("value", 0)) ? 0 : -1; |  | 16474 | return pyopencv_to_safe(value, p->v.response, ArgInfo("value", 0)) ? 0 : -1;
| 16475 | } |  | 16475 | }
| 16476 |  |  | 16476 |
| 16477 | static PyObject* pyopencv_KeyPoint_get_size(pyopencv_KeyPoint_t* p, void *closure) |  | 16477 | static PyObject* pyopencv_KeyPoint_get_size(pyopencv_KeyPoint_t* p, void *closure)
| 16478 | { |  | 16478 | {
| 16479 | return pyopencv_from(p->v.size); |  | 16479 | return pyopencv_from(p->v.size);
| 16480 | } |  | 16480 | }
| 16481 |  |  | 16481 |
| 16482 | static int pyopencv_KeyPoint_set_size(pyopencv_KeyPoint_t* p, PyObject *value, void *closure) |  | 16482 | static int pyopencv_KeyPoint_set_size(pyopencv_KeyPoint_t* p, PyObject *value, void *closure)
| 16483 | { |  | 16483 | {
| 16484 | if (!value) |  | 16484 | if (!value)
| 16485 | { |  | 16485 | {
| 16486 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute"); |  | 16486 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute");
| 16487 | return -1; |  | 16487 | return -1;
| 16488 | } |  | 16488 | }
| 16489 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1; |  | 16489 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1;
| 16490 | } |  | 16490 | }
| 16491 |  |  | 16491 |
| 16492 |  |  | 16492 |
| 16493 | // Methods (KeyPoint) |  | 16493 | // Methods (KeyPoint)
| 16494 |  |  | 16494 |
| 16495 | static int pyopencv_cv_KeyPoint_KeyPoint(pyopencv_KeyPoint_t* self, PyObject* py_args, PyObject* kw) |  | 16495 | static int pyopencv_cv_KeyPoint_KeyPoint(pyopencv_KeyPoint_t* self, PyObject* py_args, PyObject* kw)
| 16496 | { |  | 16496 | {
| 16497 | using namespace cv; |  | 16497 | using namespace cv;
| 16498 |  |  | 16498 |
| 16499 | pyPrepareArgumentConversionErrorsStorage(2); |  | 16499 | pyPrepareArgumentConversionErrorsStorage(2);
| 16500 |  |  | 16500 |
| 16501 | { |  | 16501 | {
| 16502 |  |  | 16502 |
| 16503 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 16503 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 16504 | { |  | 16504 | {
| 16505 | if(self) ERRWRAP2(new (&(self->v)) cv::KeyPoint()); |  | 16505 | if(self) ERRWRAP2(new (&(self->v)) cv::KeyPoint());
| 16506 | return 0; |  | 16506 | return 0;
| 16507 | } |  | 16507 | }
| 16508 |  |  | 16508 |
| 16509 |  |  | 16509 |
| 16510 | pyPopulateArgumentConversionErrors(); |  | 16510 | pyPopulateArgumentConversionErrors();
| 16511 | } |  | 16511 | }
| 16512 |  |  | 16512 |
| 16513 |  |  | 16513 |
| 16514 | { |  | 16514 | {
| 16515 | PyObject* pyobj_x = NULL; |  | 16515 | PyObject* pyobj_x = NULL;
| 16516 | float x=0.f; |  | 16516 | float x=0.f;
| 16517 | PyObject* pyobj_y = NULL; |  | 16517 | PyObject* pyobj_y = NULL;
| 16518 | float y=0.f; |  | 16518 | float y=0.f;
| 16519 | PyObject* pyobj_size = NULL; |  | 16519 | PyObject* pyobj_size = NULL;
| 16520 | float size=0.f; |  | 16520 | float size=0.f;
| 16521 | PyObject* pyobj_angle = NULL; |  | 16521 | PyObject* pyobj_angle = NULL;
| 16522 | float angle=-1; |  | 16522 | float angle=-1;
| 16523 | PyObject* pyobj_response = NULL; |  | 16523 | PyObject* pyobj_response = NULL;
| 16524 | float response=0; |  | 16524 | float response=0;
| 16525 | PyObject* pyobj_octave = NULL; |  | 16525 | PyObject* pyobj_octave = NULL;
| 16526 | int octave=0; |  | 16526 | int octave=0;
| 16527 | PyObject* pyobj_class_id = NULL; |  | 16527 | PyObject* pyobj_class_id = NULL;
| 16528 | int class_id=-1; |  | 16528 | int class_id=-1;
| 16529 |  |  | 16529 |
| 16530 | const char* keywords[] = { "x", "y", "size", "angle", "response", "octave", "class_id", NULL }; |  | 16530 | const char* keywords[] = { "x", "y", "size", "angle", "response", "octave", "class_id", NULL };
| 16531 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOO:KeyPoint", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_size, &pyobj_angle, &pyobj_response, &pyobj_octave, &pyobj_class_id) && |  | 16531 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOO:KeyPoint", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_size, &pyobj_angle, &pyobj_response, &pyobj_octave, &pyobj_class_id) &&
| 16532 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) && |  | 16532 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) &&
| 16533 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) && |  | 16533 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) &&
| 16534 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 16534 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 16535 | pyopencv_to_safe(pyobj_angle, angle, ArgInfo("angle", 0)) && |  | 16535 | pyopencv_to_safe(pyobj_angle, angle, ArgInfo("angle", 0)) &&
| 16536 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) && |  | 16536 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) &&
| 16537 | pyopencv_to_safe(pyobj_octave, octave, ArgInfo("octave", 0)) && |  | 16537 | pyopencv_to_safe(pyobj_octave, octave, ArgInfo("octave", 0)) &&
| 16538 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) ) |  | 16538 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) )
| 16539 | { |  | 16539 | {
| 16540 | if(self) ERRWRAP2(new (&(self->v)) cv::KeyPoint(x, y, size, angle, response, octave, class_id)); |  | 16540 | if(self) ERRWRAP2(new (&(self->v)) cv::KeyPoint(x, y, size, angle, response, octave, class_id));
| 16541 | return 0; |  | 16541 | return 0;
| 16542 | } |  | 16542 | }
| 16543 |  |  | 16543 |
| 16544 |  |  | 16544 |
| 16545 | pyPopulateArgumentConversionErrors(); |  | 16545 | pyPopulateArgumentConversionErrors();
| 16546 | } |  | 16546 | }
| 16547 | pyRaiseCVOverloadException("KeyPoint"); |  | 16547 | pyRaiseCVOverloadException("KeyPoint");
| 16548 |  |  | 16548 |
| 16549 | return -1; |  | 16549 | return -1;
| 16550 | } |  | 16550 | }
| 16551 |  |  | 16551 |
| 16552 | static PyObject* pyopencv_cv_KeyPoint_convert_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16552 | static PyObject* pyopencv_cv_KeyPoint_convert_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 16553 | { |  | 16553 | {
| 16554 | using namespace cv; |  | 16554 | using namespace cv;
| 16555 |  |  | 16555 |
| 16556 | pyPrepareArgumentConversionErrorsStorage(2); |  | 16556 | pyPrepareArgumentConversionErrorsStorage(2);
| 16557 |  |  | 16557 |
| 16558 | { |  | 16558 | {
| 16559 | PyObject* pyobj_keypoints = NULL; |  | 16559 | PyObject* pyobj_keypoints = NULL;
| 16560 | vector_KeyPoint keypoints; |  | 16560 | vector_KeyPoint keypoints;
| 16561 | vector_Point2f points2f; |  | 16561 | vector_Point2f points2f;
| 16562 | PyObject* pyobj_keypointIndexes = NULL; |  | 16562 | PyObject* pyobj_keypointIndexes = NULL;
| 16563 | vector_int keypointIndexes=std::vector<int>(); |  | 16563 | vector_int keypointIndexes=std::vector<int>();
| 16564 |  |  | 16564 |
| 16565 | const char* keywords[] = { "keypoints", "keypointIndexes", NULL }; |  | 16565 | const char* keywords[] = { "keypoints", "keypointIndexes", NULL };
| 16566 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:KeyPoint.convert", (char**)keywords, &pyobj_keypoints, &pyobj_keypointIndexes) && |  | 16566 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:KeyPoint.convert", (char**)keywords, &pyobj_keypoints, &pyobj_keypointIndexes) &&
| 16567 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 0)) && |  | 16567 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 0)) &&
| 16568 | pyopencv_to_safe(pyobj_keypointIndexes, keypointIndexes, ArgInfo("keypointIndexes", 0)) ) |  | 16568 | pyopencv_to_safe(pyobj_keypointIndexes, keypointIndexes, ArgInfo("keypointIndexes", 0)) )
| 16569 | { |  | 16569 | {
| 16570 | ERRWRAP2(cv::KeyPoint::convert(keypoints, points2f, keypointIndexes)); |  | 16570 | ERRWRAP2(cv::KeyPoint::convert(keypoints, points2f, keypointIndexes));
| 16571 | return pyopencv_from(points2f); |  | 16571 | return pyopencv_from(points2f);
| 16572 | } |  | 16572 | }
| 16573 |  |  | 16573 |
| 16574 |  |  | 16574 |
| 16575 | pyPopulateArgumentConversionErrors(); |  | 16575 | pyPopulateArgumentConversionErrors();
| 16576 | } |  | 16576 | }
| 16577 |  |  | 16577 |
| 16578 |  |  | 16578 |
| 16579 | { |  | 16579 | {
| 16580 | PyObject* pyobj_points2f = NULL; |  | 16580 | PyObject* pyobj_points2f = NULL;
| 16581 | vector_Point2f points2f; |  | 16581 | vector_Point2f points2f;
| 16582 | vector_KeyPoint keypoints; |  | 16582 | vector_KeyPoint keypoints;
| 16583 | PyObject* pyobj_size = NULL; |  | 16583 | PyObject* pyobj_size = NULL;
| 16584 | float size=1; |  | 16584 | float size=1;
| 16585 | PyObject* pyobj_response = NULL; |  | 16585 | PyObject* pyobj_response = NULL;
| 16586 | float response=1; |  | 16586 | float response=1;
| 16587 | PyObject* pyobj_octave = NULL; |  | 16587 | PyObject* pyobj_octave = NULL;
| 16588 | int octave=0; |  | 16588 | int octave=0;
| 16589 | PyObject* pyobj_class_id = NULL; |  | 16589 | PyObject* pyobj_class_id = NULL;
| 16590 | int class_id=-1; |  | 16590 | int class_id=-1;
| 16591 |  |  | 16591 |
| 16592 | const char* keywords[] = { "points2f", "size", "response", "octave", "class_id", NULL }; |  | 16592 | const char* keywords[] = { "points2f", "size", "response", "octave", "class_id", NULL };
| 16593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:KeyPoint.convert", (char**)keywords, &pyobj_points2f, &pyobj_size, &pyobj_response, &pyobj_octave, &pyobj_class_id) && |  | 16593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:KeyPoint.convert", (char**)keywords, &pyobj_points2f, &pyobj_size, &pyobj_response, &pyobj_octave, &pyobj_class_id) &&
| 16594 | pyopencv_to_safe(pyobj_points2f, points2f, ArgInfo("points2f", 0)) && |  | 16594 | pyopencv_to_safe(pyobj_points2f, points2f, ArgInfo("points2f", 0)) &&
| 16595 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 16595 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 16596 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) && |  | 16596 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) &&
| 16597 | pyopencv_to_safe(pyobj_octave, octave, ArgInfo("octave", 0)) && |  | 16597 | pyopencv_to_safe(pyobj_octave, octave, ArgInfo("octave", 0)) &&
| 16598 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) ) |  | 16598 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) )
| 16599 | { |  | 16599 | {
| 16600 | ERRWRAP2(cv::KeyPoint::convert(points2f, keypoints, size, response, octave, class_id)); |  | 16600 | ERRWRAP2(cv::KeyPoint::convert(points2f, keypoints, size, response, octave, class_id));
| 16601 | return pyopencv_from(keypoints); |  | 16601 | return pyopencv_from(keypoints);
| 16602 | } |  | 16602 | }
| 16603 |  |  | 16603 |
| 16604 |  |  | 16604 |
| 16605 | pyPopulateArgumentConversionErrors(); |  | 16605 | pyPopulateArgumentConversionErrors();
| 16606 | } |  | 16606 | }
| 16607 | pyRaiseCVOverloadException("convert"); |  | 16607 | pyRaiseCVOverloadException("convert");
| 16608 |  |  | 16608 |
| 16609 | return NULL; |  | 16609 | return NULL;
| 16610 | } |  | 16610 | }
| 16611 |  |  | 16611 |
| 16612 | static PyObject* pyopencv_cv_KeyPoint_overlap_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16612 | static PyObject* pyopencv_cv_KeyPoint_overlap_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 16613 | { |  | 16613 | {
| 16614 | using namespace cv; |  | 16614 | using namespace cv;
| 16615 |  |  | 16615 |
| 16616 | PyObject* pyobj_kp1 = NULL; |  | 16616 | PyObject* pyobj_kp1 = NULL;
| 16617 | cv::KeyPoint kp1; |  | 16617 | cv::KeyPoint kp1;
| 16618 | PyObject* pyobj_kp2 = NULL; |  | 16618 | PyObject* pyobj_kp2 = NULL;
| 16619 | cv::KeyPoint kp2; |  | 16619 | cv::KeyPoint kp2;
| 16620 | float retval; |  | 16620 | float retval;
| 16621 |  |  | 16621 |
| 16622 | const char* keywords[] = { "kp1", "kp2", NULL }; |  | 16622 | const char* keywords[] = { "kp1", "kp2", NULL };
| 16623 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:KeyPoint.overlap", (char**)keywords, &pyobj_kp1, &pyobj_kp2) && |  | 16623 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:KeyPoint.overlap", (char**)keywords, &pyobj_kp1, &pyobj_kp2) &&
| 16624 | pyopencv_to_safe(pyobj_kp1, kp1, ArgInfo("kp1", 0)) && |  | 16624 | pyopencv_to_safe(pyobj_kp1, kp1, ArgInfo("kp1", 0)) &&
| 16625 | pyopencv_to_safe(pyobj_kp2, kp2, ArgInfo("kp2", 0)) ) |  | 16625 | pyopencv_to_safe(pyobj_kp2, kp2, ArgInfo("kp2", 0)) )
| 16626 | { |  | 16626 | {
| 16627 | ERRWRAP2(retval = cv::KeyPoint::overlap(kp1, kp2)); |  | 16627 | ERRWRAP2(retval = cv::KeyPoint::overlap(kp1, kp2));
| 16628 | return pyopencv_from(retval); |  | 16628 | return pyopencv_from(retval);
| 16629 | } |  | 16629 | }
| 16630 |  |  | 16630 |
| 16631 | return NULL; |  | 16631 | return NULL;
| 16632 | } |  | 16632 | }
| 16633 |  |  | 16633 |
| 16634 |  |  | 16634 |
| 16635 |  |  | 16635 |
| 16636 | // Tables (KeyPoint) |  | 16636 | // Tables (KeyPoint)
| 16637 |  |  | 16637 |
| 16638 | static PyGetSetDef pyopencv_KeyPoint_getseters[] = |  | 16638 | static PyGetSetDef pyopencv_KeyPoint_getseters[] =
| 16639 | { |  | 16639 | {
| 16640 | {(char*)"angle", (getter)pyopencv_KeyPoint_get_angle, (setter)pyopencv_KeyPoint_set_angle, (char*)"angle", NULL}, |  | 16640 | {(char*)"angle", (getter)pyopencv_KeyPoint_get_angle, (setter)pyopencv_KeyPoint_set_angle, (char*)"angle", NULL},
| 16641 | {(char*)"class_id", (getter)pyopencv_KeyPoint_get_class_id, (setter)pyopencv_KeyPoint_set_class_id, (char*)"class_id", NULL}, |  | 16641 | {(char*)"class_id", (getter)pyopencv_KeyPoint_get_class_id, (setter)pyopencv_KeyPoint_set_class_id, (char*)"class_id", NULL},
| 16642 | {(char*)"octave", (getter)pyopencv_KeyPoint_get_octave, (setter)pyopencv_KeyPoint_set_octave, (char*)"octave", NULL}, |  | 16642 | {(char*)"octave", (getter)pyopencv_KeyPoint_get_octave, (setter)pyopencv_KeyPoint_set_octave, (char*)"octave", NULL},
| 16643 | {(char*)"pt", (getter)pyopencv_KeyPoint_get_pt, (setter)pyopencv_KeyPoint_set_pt, (char*)"pt", NULL}, |  | 16643 | {(char*)"pt", (getter)pyopencv_KeyPoint_get_pt, (setter)pyopencv_KeyPoint_set_pt, (char*)"pt", NULL},
| 16644 | {(char*)"response", (getter)pyopencv_KeyPoint_get_response, (setter)pyopencv_KeyPoint_set_response, (char*)"response", NULL}, |  | 16644 | {(char*)"response", (getter)pyopencv_KeyPoint_get_response, (setter)pyopencv_KeyPoint_set_response, (char*)"response", NULL},
| 16645 | {(char*)"size", (getter)pyopencv_KeyPoint_get_size, (setter)pyopencv_KeyPoint_set_size, (char*)"size", NULL}, |  | 16645 | {(char*)"size", (getter)pyopencv_KeyPoint_get_size, (setter)pyopencv_KeyPoint_set_size, (char*)"size", NULL},
| 16646 | {NULL} /* Sentinel */ |  | 16646 | {NULL} /* Sentinel */
| 16647 | }; |  | 16647 | };
| 16648 |  |  | 16648 |
| 16649 | static PyMethodDef pyopencv_KeyPoint_methods[] = |  | 16649 | static PyMethodDef pyopencv_KeyPoint_methods[] =
| 16650 | { |  | 16650 | {
| 16651 | {"convert", CV_PY_FN_WITH_KW_(pyopencv_cv_KeyPoint_convert_static, METH_STATIC), "convert(keypoints[, keypointIndexes]) -> points2f\n. This method converts vector of keypoints to vector of points or the reverse, where each keypoint is\n. assigned the same size and the same orientation.\n. \n. @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB\n. @param points2f Array of (x,y) coordinates of each keypoint\n. @param keypointIndexes Array of indexes of keypoints to be converted to points. (Acts like a mask to\n. convert only specified keypoints)\n\n\n\nconvert(points2f[, size[, response[, octave[, class_id]]]]) -> keypoints\n. @overload\n. @param points2f Array of (x,y) coordinates of each keypoint\n. @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB\n. @param size keypoint diameter\n. @param response keypoint detector response on the keypoint (that is, strength of the keypoint)\n. @param octave pyramid octave in which the keypoint has been detected\n. @param class_id object id"}, |  | 16651 | {"convert", CV_PY_FN_WITH_KW_(pyopencv_cv_KeyPoint_convert_static, METH_STATIC), "convert(keypoints[, keypointIndexes]) -> points2f\n. This method converts vector of keypoints to vector of points or the reverse, where each keypoint is\n. assigned the same size and the same orientation.\n. \n. @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB\n. @param points2f Array of (x,y) coordinates of each keypoint\n. @param keypointIndexes Array of indexes of keypoints to be converted to points. (Acts like a mask to\n. convert only specified keypoints)\n\n\n\nconvert(points2f[, size[, response[, octave[, class_id]]]]) -> keypoints\n. @overload\n. @param points2f Array of (x,y) coordinates of each keypoint\n. @param keypoints Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB\n. @param size keypoint diameter\n. @param response keypoint detector response on the keypoint (that is, strength of the keypoint)\n. @param octave pyramid octave in which the keypoint has been detected\n. @param class_id object id"},
| 16652 | {"overlap", CV_PY_FN_WITH_KW_(pyopencv_cv_KeyPoint_overlap_static, METH_STATIC), "overlap(kp1, kp2) -> retval\n. This method computes overlap for pair of keypoints. Overlap is the ratio between area of keypoint\n. regions' intersection and area of keypoint regions' union (considering keypoint region as circle).\n. If they don't overlap, we get zero. If they coincide at same location with same size, we get 1.\n. @param kp1 First keypoint\n. @param kp2 Second keypoint"}, |  | 16652 | {"overlap", CV_PY_FN_WITH_KW_(pyopencv_cv_KeyPoint_overlap_static, METH_STATIC), "overlap(kp1, kp2) -> retval\n. This method computes overlap for pair of keypoints. Overlap is the ratio between area of keypoint\n. regions' intersection and area of keypoint regions' union (considering keypoint region as circle).\n. If they don't overlap, we get zero. If they coincide at same location with same size, we get 1.\n. @param kp1 First keypoint\n. @param kp2 Second keypoint"},
| 16653 |  |  | 16653 |
| 16654 | {NULL, NULL} |  | 16654 | {NULL, NULL}
| 16655 | }; |  | 16655 | };
| 16656 |  |  | 16656 |
| 16657 | // Converter (KeyPoint) |  | 16657 | // Converter (KeyPoint)
| 16658 |  |  | 16658 |
| 16659 | template<> |  | 16659 | template<>
| 16660 | struct PyOpenCV_Converter< cv::KeyPoint > |  | 16660 | struct PyOpenCV_Converter< cv::KeyPoint >
| 16661 | { |  | 16661 | {
| 16662 | static PyObject* from(const cv::KeyPoint& r) |  | 16662 | static PyObject* from(const cv::KeyPoint& r)
| 16663 | { |  | 16663 | {
| 16664 | return pyopencv_KeyPoint_Instance(r); |  | 16664 | return pyopencv_KeyPoint_Instance(r);
| 16665 | } |  | 16665 | }
| 16666 | static bool to(PyObject* src, cv::KeyPoint& dst, const ArgInfo& info) |  | 16666 | static bool to(PyObject* src, cv::KeyPoint& dst, const ArgInfo& info)
| 16667 | { |  | 16667 | {
| 16668 | if(!src || src == Py_None) |  | 16668 | if(!src || src == Py_None)
| 16669 | return true; |  | 16669 | return true;
| 16670 | cv::KeyPoint * dst_; |  | 16670 | cv::KeyPoint * dst_;
| 16671 | if (pyopencv_KeyPoint_getp(src, dst_)) |  | 16671 | if (pyopencv_KeyPoint_getp(src, dst_))
| 16672 | { |  | 16672 | {
| 16673 | dst = *dst_; |  | 16673 | dst = *dst_;
| 16674 | return true; |  | 16674 | return true;
| 16675 | } |  | 16675 | }
| 16676 |  |  | 16676 |
| 16677 | failmsg("Expected cv::KeyPoint for argument '%s'", info.name); |  | 16677 | failmsg("Expected cv::KeyPoint for argument '%s'", info.name);
| 16678 | return false; |  | 16678 | return false;
| 16679 | } |  | 16679 | }
| 16680 | }; |  | 16680 | };
| 16681 |  |  | 16681 |
| 16682 | //================================================================================ |  | 16682 | //================================================================================
| 16683 | // LineSegmentDetector (Generic) |  | 16683 | // LineSegmentDetector (Generic)
| 16684 | //================================================================================ |  | 16684 | //================================================================================
| 16685 |  |  | 16685 |
| 16686 | // GetSet (LineSegmentDetector) |  | 16686 | // GetSet (LineSegmentDetector)
| 16687 |  |  | 16687 |
| 16688 |  |  | 16688 |
| 16689 |  |  | 16689 |
| 16690 | // Methods (LineSegmentDetector) |  | 16690 | // Methods (LineSegmentDetector)
| 16691 |  |  | 16691 |
| 16692 | static PyObject* pyopencv_cv_LineSegmentDetector_compareSegments(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16692 | static PyObject* pyopencv_cv_LineSegmentDetector_compareSegments(PyObject* self, PyObject* py_args, PyObject* kw)
| 16693 | { |  | 16693 | {
| 16694 | using namespace cv; |  | 16694 | using namespace cv;
| 16695 |  |  | 16695 |
| 16696 |  |  | 16696 |
| 16697 | Ptr<cv::LineSegmentDetector> * self1 = 0; |  | 16697 | Ptr<cv::LineSegmentDetector> * self1 = 0;
| 16698 | if (!pyopencv_LineSegmentDetector_getp(self, self1)) |  | 16698 | if (!pyopencv_LineSegmentDetector_getp(self, self1))
| 16699 | return failmsgp("Incorrect type of self (must be 'LineSegmentDetector' or its derivative)"); |  | 16699 | return failmsgp("Incorrect type of self (must be 'LineSegmentDetector' or its derivative)");
| 16700 | Ptr<cv::LineSegmentDetector> _self_ = *(self1); |  | 16700 | Ptr<cv::LineSegmentDetector> _self_ = *(self1);
| 16701 | pyPrepareArgumentConversionErrorsStorage(2); |  | 16701 | pyPrepareArgumentConversionErrorsStorage(2);
| 16702 |  |  | 16702 |
| 16703 | { |  | 16703 | {
| 16704 | PyObject* pyobj_size = NULL; |  | 16704 | PyObject* pyobj_size = NULL;
| 16705 | Size size; |  | 16705 | Size size;
| 16706 | PyObject* pyobj_lines1 = NULL; |  | 16706 | PyObject* pyobj_lines1 = NULL;
| 16707 | Mat lines1; |  | 16707 | Mat lines1;
| 16708 | PyObject* pyobj_lines2 = NULL; |  | 16708 | PyObject* pyobj_lines2 = NULL;
| 16709 | Mat lines2; |  | 16709 | Mat lines2;
| 16710 | PyObject* pyobj_image = NULL; |  | 16710 | PyObject* pyobj_image = NULL;
| 16711 | Mat image; |  | 16711 | Mat image;
| 16712 | int retval; |  | 16712 | int retval;
| 16713 |  |  | 16713 |
| 16714 | const char* keywords[] = { "size", "lines1", "lines2", "image", NULL }; |  | 16714 | const char* keywords[] = { "size", "lines1", "lines2", "image", NULL };
| 16715 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:LineSegmentDetector.compareSegments", (char**)keywords, &pyobj_size, &pyobj_lines1, &pyobj_lines2, &pyobj_image) && |  | 16715 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:LineSegmentDetector.compareSegments", (char**)keywords, &pyobj_size, &pyobj_lines1, &pyobj_lines2, &pyobj_image) &&
| 16716 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 16716 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 16717 | pyopencv_to_safe(pyobj_lines1, lines1, ArgInfo("lines1", 0)) && |  | 16717 | pyopencv_to_safe(pyobj_lines1, lines1, ArgInfo("lines1", 0)) &&
| 16718 | pyopencv_to_safe(pyobj_lines2, lines2, ArgInfo("lines2", 0)) && |  | 16718 | pyopencv_to_safe(pyobj_lines2, lines2, ArgInfo("lines2", 0)) &&
| 16719 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 16719 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 16720 | { |  | 16720 | {
| 16721 | ERRWRAP2(retval = _self_->compareSegments(size, lines1, lines2, image)); |  | 16721 | ERRWRAP2(retval = _self_->compareSegments(size, lines1, lines2, image));
| 16722 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image)); |  | 16722 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image));
| 16723 | } |  | 16723 | }
| 16724 |  |  | 16724 |
| 16725 |  |  | 16725 |
| 16726 | pyPopulateArgumentConversionErrors(); |  | 16726 | pyPopulateArgumentConversionErrors();
| 16727 | } |  | 16727 | }
| 16728 |  |  | 16728 |
| 16729 |  |  | 16729 |
| 16730 | { |  | 16730 | {
| 16731 | PyObject* pyobj_size = NULL; |  | 16731 | PyObject* pyobj_size = NULL;
| 16732 | Size size; |  | 16732 | Size size;
| 16733 | PyObject* pyobj_lines1 = NULL; |  | 16733 | PyObject* pyobj_lines1 = NULL;
| 16734 | UMat lines1; |  | 16734 | UMat lines1;
| 16735 | PyObject* pyobj_lines2 = NULL; |  | 16735 | PyObject* pyobj_lines2 = NULL;
| 16736 | UMat lines2; |  | 16736 | UMat lines2;
| 16737 | PyObject* pyobj_image = NULL; |  | 16737 | PyObject* pyobj_image = NULL;
| 16738 | UMat image; |  | 16738 | UMat image;
| 16739 | int retval; |  | 16739 | int retval;
| 16740 |  |  | 16740 |
| 16741 | const char* keywords[] = { "size", "lines1", "lines2", "image", NULL }; |  | 16741 | const char* keywords[] = { "size", "lines1", "lines2", "image", NULL };
| 16742 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:LineSegmentDetector.compareSegments", (char**)keywords, &pyobj_size, &pyobj_lines1, &pyobj_lines2, &pyobj_image) && |  | 16742 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:LineSegmentDetector.compareSegments", (char**)keywords, &pyobj_size, &pyobj_lines1, &pyobj_lines2, &pyobj_image) &&
| 16743 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 16743 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 16744 | pyopencv_to_safe(pyobj_lines1, lines1, ArgInfo("lines1", 0)) && |  | 16744 | pyopencv_to_safe(pyobj_lines1, lines1, ArgInfo("lines1", 0)) &&
| 16745 | pyopencv_to_safe(pyobj_lines2, lines2, ArgInfo("lines2", 0)) && |  | 16745 | pyopencv_to_safe(pyobj_lines2, lines2, ArgInfo("lines2", 0)) &&
| 16746 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 16746 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 16747 | { |  | 16747 | {
| 16748 | ERRWRAP2(retval = _self_->compareSegments(size, lines1, lines2, image)); |  | 16748 | ERRWRAP2(retval = _self_->compareSegments(size, lines1, lines2, image));
| 16749 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image)); |  | 16749 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image));
| 16750 | } |  | 16750 | }
| 16751 |  |  | 16751 |
| 16752 |  |  | 16752 |
| 16753 | pyPopulateArgumentConversionErrors(); |  | 16753 | pyPopulateArgumentConversionErrors();
| 16754 | } |  | 16754 | }
| 16755 | pyRaiseCVOverloadException("compareSegments"); |  | 16755 | pyRaiseCVOverloadException("compareSegments");
| 16756 |  |  | 16756 |
| 16757 | return NULL; |  | 16757 | return NULL;
| 16758 | } |  | 16758 | }
| 16759 |  |  | 16759 |
| 16760 | static PyObject* pyopencv_cv_LineSegmentDetector_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16760 | static PyObject* pyopencv_cv_LineSegmentDetector_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 16761 | { |  | 16761 | {
| 16762 | using namespace cv; |  | 16762 | using namespace cv;
| 16763 |  |  | 16763 |
| 16764 |  |  | 16764 |
| 16765 | Ptr<cv::LineSegmentDetector> * self1 = 0; |  | 16765 | Ptr<cv::LineSegmentDetector> * self1 = 0;
| 16766 | if (!pyopencv_LineSegmentDetector_getp(self, self1)) |  | 16766 | if (!pyopencv_LineSegmentDetector_getp(self, self1))
| 16767 | return failmsgp("Incorrect type of self (must be 'LineSegmentDetector' or its derivative)"); |  | 16767 | return failmsgp("Incorrect type of self (must be 'LineSegmentDetector' or its derivative)");
| 16768 | Ptr<cv::LineSegmentDetector> _self_ = *(self1); |  | 16768 | Ptr<cv::LineSegmentDetector> _self_ = *(self1);
| 16769 | pyPrepareArgumentConversionErrorsStorage(2); |  | 16769 | pyPrepareArgumentConversionErrorsStorage(2);
| 16770 |  |  | 16770 |
| 16771 | { |  | 16771 | {
| 16772 | PyObject* pyobj_image = NULL; |  | 16772 | PyObject* pyobj_image = NULL;
| 16773 | Mat image; |  | 16773 | Mat image;
| 16774 | PyObject* pyobj_lines = NULL; |  | 16774 | PyObject* pyobj_lines = NULL;
| 16775 | Mat lines; |  | 16775 | Mat lines;
| 16776 | PyObject* pyobj_width = NULL; |  | 16776 | PyObject* pyobj_width = NULL;
| 16777 | Mat width; |  | 16777 | Mat width;
| 16778 | PyObject* pyobj_prec = NULL; |  | 16778 | PyObject* pyobj_prec = NULL;
| 16779 | Mat prec; |  | 16779 | Mat prec;
| 16780 | PyObject* pyobj_nfa = NULL; |  | 16780 | PyObject* pyobj_nfa = NULL;
| 16781 | Mat nfa; |  | 16781 | Mat nfa;
| 16782 |  |  | 16782 |
| 16783 | const char* keywords[] = { "image", "lines", "width", "prec", "nfa", NULL }; |  | 16783 | const char* keywords[] = { "image", "lines", "width", "prec", "nfa", NULL };
| 16784 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:LineSegmentDetector.detect", (char**)keywords, &pyobj_image, &pyobj_lines, &pyobj_width, &pyobj_prec, &pyobj_nfa) && |  | 16784 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:LineSegmentDetector.detect", (char**)keywords, &pyobj_image, &pyobj_lines, &pyobj_width, &pyobj_prec, &pyobj_nfa) &&
| 16785 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 16785 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 16786 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 1)) && |  | 16786 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 1)) &&
| 16787 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 1)) && |  | 16787 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 1)) &&
| 16788 | pyopencv_to_safe(pyobj_prec, prec, ArgInfo("prec", 1)) && |  | 16788 | pyopencv_to_safe(pyobj_prec, prec, ArgInfo("prec", 1)) &&
| 16789 | pyopencv_to_safe(pyobj_nfa, nfa, ArgInfo("nfa", 1)) ) |  | 16789 | pyopencv_to_safe(pyobj_nfa, nfa, ArgInfo("nfa", 1)) )
| 16790 | { |  | 16790 | {
| 16791 | ERRWRAP2(_self_->detect(image, lines, width, prec, nfa)); |  | 16791 | ERRWRAP2(_self_->detect(image, lines, width, prec, nfa));
| 16792 | return Py_BuildValue("(NNNN)", pyopencv_from(lines), pyopencv_from(width), pyopencv_from(prec), pyopencv_from(nfa)); |  | 16792 | return Py_BuildValue("(NNNN)", pyopencv_from(lines), pyopencv_from(width), pyopencv_from(prec), pyopencv_from(nfa));
| 16793 | } |  | 16793 | }
| 16794 |  |  | 16794 |
| 16795 |  |  | 16795 |
| 16796 | pyPopulateArgumentConversionErrors(); |  | 16796 | pyPopulateArgumentConversionErrors();
| 16797 | } |  | 16797 | }
| 16798 |  |  | 16798 |
| 16799 |  |  | 16799 |
| 16800 | { |  | 16800 | {
| 16801 | PyObject* pyobj_image = NULL; |  | 16801 | PyObject* pyobj_image = NULL;
| 16802 | UMat image; |  | 16802 | UMat image;
| 16803 | PyObject* pyobj_lines = NULL; |  | 16803 | PyObject* pyobj_lines = NULL;
| 16804 | UMat lines; |  | 16804 | UMat lines;
| 16805 | PyObject* pyobj_width = NULL; |  | 16805 | PyObject* pyobj_width = NULL;
| 16806 | UMat width; |  | 16806 | UMat width;
| 16807 | PyObject* pyobj_prec = NULL; |  | 16807 | PyObject* pyobj_prec = NULL;
| 16808 | UMat prec; |  | 16808 | UMat prec;
| 16809 | PyObject* pyobj_nfa = NULL; |  | 16809 | PyObject* pyobj_nfa = NULL;
| 16810 | UMat nfa; |  | 16810 | UMat nfa;
| 16811 |  |  | 16811 |
| 16812 | const char* keywords[] = { "image", "lines", "width", "prec", "nfa", NULL }; |  | 16812 | const char* keywords[] = { "image", "lines", "width", "prec", "nfa", NULL };
| 16813 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:LineSegmentDetector.detect", (char**)keywords, &pyobj_image, &pyobj_lines, &pyobj_width, &pyobj_prec, &pyobj_nfa) && |  | 16813 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:LineSegmentDetector.detect", (char**)keywords, &pyobj_image, &pyobj_lines, &pyobj_width, &pyobj_prec, &pyobj_nfa) &&
| 16814 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 16814 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 16815 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 1)) && |  | 16815 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 1)) &&
| 16816 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 1)) && |  | 16816 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 1)) &&
| 16817 | pyopencv_to_safe(pyobj_prec, prec, ArgInfo("prec", 1)) && |  | 16817 | pyopencv_to_safe(pyobj_prec, prec, ArgInfo("prec", 1)) &&
| 16818 | pyopencv_to_safe(pyobj_nfa, nfa, ArgInfo("nfa", 1)) ) |  | 16818 | pyopencv_to_safe(pyobj_nfa, nfa, ArgInfo("nfa", 1)) )
| 16819 | { |  | 16819 | {
| 16820 | ERRWRAP2(_self_->detect(image, lines, width, prec, nfa)); |  | 16820 | ERRWRAP2(_self_->detect(image, lines, width, prec, nfa));
| 16821 | return Py_BuildValue("(NNNN)", pyopencv_from(lines), pyopencv_from(width), pyopencv_from(prec), pyopencv_from(nfa)); |  | 16821 | return Py_BuildValue("(NNNN)", pyopencv_from(lines), pyopencv_from(width), pyopencv_from(prec), pyopencv_from(nfa));
| 16822 | } |  | 16822 | }
| 16823 |  |  | 16823 |
| 16824 |  |  | 16824 |
| 16825 | pyPopulateArgumentConversionErrors(); |  | 16825 | pyPopulateArgumentConversionErrors();
| 16826 | } |  | 16826 | }
| 16827 | pyRaiseCVOverloadException("detect"); |  | 16827 | pyRaiseCVOverloadException("detect");
| 16828 |  |  | 16828 |
| 16829 | return NULL; |  | 16829 | return NULL;
| 16830 | } |  | 16830 | }
| 16831 |  |  | 16831 |
| 16832 | static PyObject* pyopencv_cv_LineSegmentDetector_drawSegments(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16832 | static PyObject* pyopencv_cv_LineSegmentDetector_drawSegments(PyObject* self, PyObject* py_args, PyObject* kw)
| 16833 | { |  | 16833 | {
| 16834 | using namespace cv; |  | 16834 | using namespace cv;
| 16835 |  |  | 16835 |
| 16836 |  |  | 16836 |
| 16837 | Ptr<cv::LineSegmentDetector> * self1 = 0; |  | 16837 | Ptr<cv::LineSegmentDetector> * self1 = 0;
| 16838 | if (!pyopencv_LineSegmentDetector_getp(self, self1)) |  | 16838 | if (!pyopencv_LineSegmentDetector_getp(self, self1))
| 16839 | return failmsgp("Incorrect type of self (must be 'LineSegmentDetector' or its derivative)"); |  | 16839 | return failmsgp("Incorrect type of self (must be 'LineSegmentDetector' or its derivative)");
| 16840 | Ptr<cv::LineSegmentDetector> _self_ = *(self1); |  | 16840 | Ptr<cv::LineSegmentDetector> _self_ = *(self1);
| 16841 | pyPrepareArgumentConversionErrorsStorage(2); |  | 16841 | pyPrepareArgumentConversionErrorsStorage(2);
| 16842 |  |  | 16842 |
| 16843 | { |  | 16843 | {
| 16844 | PyObject* pyobj_image = NULL; |  | 16844 | PyObject* pyobj_image = NULL;
| 16845 | Mat image; |  | 16845 | Mat image;
| 16846 | PyObject* pyobj_lines = NULL; |  | 16846 | PyObject* pyobj_lines = NULL;
| 16847 | Mat lines; |  | 16847 | Mat lines;
| 16848 |  |  | 16848 |
| 16849 | const char* keywords[] = { "image", "lines", NULL }; |  | 16849 | const char* keywords[] = { "image", "lines", NULL };
| 16850 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:LineSegmentDetector.drawSegments", (char**)keywords, &pyobj_image, &pyobj_lines) && |  | 16850 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:LineSegmentDetector.drawSegments", (char**)keywords, &pyobj_image, &pyobj_lines) &&
| 16851 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 16851 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 16852 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 0)) ) |  | 16852 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 0)) )
| 16853 | { |  | 16853 | {
| 16854 | ERRWRAP2(_self_->drawSegments(image, lines)); |  | 16854 | ERRWRAP2(_self_->drawSegments(image, lines));
| 16855 | return pyopencv_from(image); |  | 16855 | return pyopencv_from(image);
| 16856 | } |  | 16856 | }
| 16857 |  |  | 16857 |
| 16858 |  |  | 16858 |
| 16859 | pyPopulateArgumentConversionErrors(); |  | 16859 | pyPopulateArgumentConversionErrors();
| 16860 | } |  | 16860 | }
| 16861 |  |  | 16861 |
| 16862 |  |  | 16862 |
| 16863 | { |  | 16863 | {
| 16864 | PyObject* pyobj_image = NULL; |  | 16864 | PyObject* pyobj_image = NULL;
| 16865 | UMat image; |  | 16865 | UMat image;
| 16866 | PyObject* pyobj_lines = NULL; |  | 16866 | PyObject* pyobj_lines = NULL;
| 16867 | UMat lines; |  | 16867 | UMat lines;
| 16868 |  |  | 16868 |
| 16869 | const char* keywords[] = { "image", "lines", NULL }; |  | 16869 | const char* keywords[] = { "image", "lines", NULL };
| 16870 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:LineSegmentDetector.drawSegments", (char**)keywords, &pyobj_image, &pyobj_lines) && |  | 16870 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:LineSegmentDetector.drawSegments", (char**)keywords, &pyobj_image, &pyobj_lines) &&
| 16871 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 16871 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 16872 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 0)) ) |  | 16872 | pyopencv_to_safe(pyobj_lines, lines, ArgInfo("lines", 0)) )
| 16873 | { |  | 16873 | {
| 16874 | ERRWRAP2(_self_->drawSegments(image, lines)); |  | 16874 | ERRWRAP2(_self_->drawSegments(image, lines));
| 16875 | return pyopencv_from(image); |  | 16875 | return pyopencv_from(image);
| 16876 | } |  | 16876 | }
| 16877 |  |  | 16877 |
| 16878 |  |  | 16878 |
| 16879 | pyPopulateArgumentConversionErrors(); |  | 16879 | pyPopulateArgumentConversionErrors();
| 16880 | } |  | 16880 | }
| 16881 | pyRaiseCVOverloadException("drawSegments"); |  | 16881 | pyRaiseCVOverloadException("drawSegments");
| 16882 |  |  | 16882 |
| 16883 | return NULL; |  | 16883 | return NULL;
| 16884 | } |  | 16884 | }
| 16885 |  |  | 16885 |
| 16886 |  |  | 16886 |
| 16887 |  |  | 16887 |
| 16888 | // Tables (LineSegmentDetector) |  | 16888 | // Tables (LineSegmentDetector)
| 16889 |  |  | 16889 |
| 16890 | static PyGetSetDef pyopencv_LineSegmentDetector_getseters[] = |  | 16890 | static PyGetSetDef pyopencv_LineSegmentDetector_getseters[] =
| 16891 | { |  | 16891 | {
| 16892 | {NULL} /* Sentinel */ |  | 16892 | {NULL} /* Sentinel */
| 16893 | }; |  | 16893 | };
| 16894 |  |  | 16894 |
| 16895 | static PyMethodDef pyopencv_LineSegmentDetector_methods[] = |  | 16895 | static PyMethodDef pyopencv_LineSegmentDetector_methods[] =
| 16896 | { |  | 16896 | {
| 16897 | {"compareSegments", CV_PY_FN_WITH_KW_(pyopencv_cv_LineSegmentDetector_compareSegments, 0), "compareSegments(size, lines1, lines2[, image]) -> retval, image\n. @brief Draws two groups of lines in blue and red, counting the non overlapping (mismatching) pixels.\n. \n. @param size The size of the image, where lines1 and lines2 were found.\n. @param lines1 The first group of lines that needs to be drawn. It is visualized in blue color.\n. @param lines2 The second group of lines. They visualized in red color.\n. @param image Optional image, where the lines will be drawn. The image should be color(3-channel)\n. in order for lines1 and lines2 to be drawn in the above mentioned colors."}, |  | 16897 | {"compareSegments", CV_PY_FN_WITH_KW_(pyopencv_cv_LineSegmentDetector_compareSegments, 0), "compareSegments(size, lines1, lines2[, image]) -> retval, image\n. @brief Draws two groups of lines in blue and red, counting the non overlapping (mismatching) pixels.\n. \n. @param size The size of the image, where lines1 and lines2 were found.\n. @param lines1 The first group of lines that needs to be drawn. It is visualized in blue color.\n. @param lines2 The second group of lines. They visualized in red color.\n. @param image Optional image, where the lines will be drawn. The image should be color(3-channel)\n. in order for lines1 and lines2 to be drawn in the above mentioned colors."},
| 16898 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_LineSegmentDetector_detect, 0), "detect(image[, lines[, width[, prec[, nfa]]]]) -> lines, width, prec, nfa\n. @brief Finds lines in the input image.\n. \n. This is the output of the default parameters of the algorithm on the above shown image.\n. \n. ![image](pics/building_lsd.png)\n. \n. @param image A grayscale (CV_8UC1) input image. If only a roi needs to be selected, use:\n. `lsd_ptr-\\>detect(image(roi), lines, ...); lines += Scalar(roi.x, roi.y, roi.x, roi.y);`\n. @param lines A vector of Vec4f elements specifying the beginning and ending point of a line. Where\n. Vec4f is (x1, y1, x2, y2), point 1 is the start, point 2 - end. Returned lines are strictly\n. oriented depending on the gradient.\n. @param width Vector of widths of the regions, where the lines are found. E.g. Width of line.\n. @param prec Vector of precisions with which the lines are found.\n. @param nfa Vector containing number of false alarms in the line region, with precision of 10%. The\n. bigger the value, logarithmically better the detection.\n. - -1 corresponds to 10 mean false alarms\n. - 0 corresponds to 1 mean false alarm\n. - 1 corresponds to 0.1 mean false alarms\n. This vector will be calculated only when the objects type is #LSD_REFINE_ADV."}, |  | 16898 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_LineSegmentDetector_detect, 0), "detect(image[, lines[, width[, prec[, nfa]]]]) -> lines, width, prec, nfa\n. @brief Finds lines in the input image.\n. \n. This is the output of the default parameters of the algorithm on the above shown image.\n. \n. ![image](pics/building_lsd.png)\n. \n. @param image A grayscale (CV_8UC1) input image. If only a roi needs to be selected, use:\n. `lsd_ptr-\\>detect(image(roi), lines, ...); lines += Scalar(roi.x, roi.y, roi.x, roi.y);`\n. @param lines A vector of Vec4f elements specifying the beginning and ending point of a line. Where\n. Vec4f is (x1, y1, x2, y2), point 1 is the start, point 2 - end. Returned lines are strictly\n. oriented depending on the gradient.\n. @param width Vector of widths of the regions, where the lines are found. E.g. Width of line.\n. @param prec Vector of precisions with which the lines are found.\n. @param nfa Vector containing number of false alarms in the line region, with precision of 10%. The\n. bigger the value, logarithmically better the detection.\n. - -1 corresponds to 10 mean false alarms\n. - 0 corresponds to 1 mean false alarm\n. - 1 corresponds to 0.1 mean false alarms\n. This vector will be calculated only when the objects type is #LSD_REFINE_ADV."},
| 16899 | {"drawSegments", CV_PY_FN_WITH_KW_(pyopencv_cv_LineSegmentDetector_drawSegments, 0), "drawSegments(image, lines) -> image\n. @brief Draws the line segments on a given image.\n. @param image The image, where the lines will be drawn. Should be bigger or equal to the image,\n. where the lines were found.\n. @param lines A vector of the lines that needed to be drawn."}, |  | 16899 | {"drawSegments", CV_PY_FN_WITH_KW_(pyopencv_cv_LineSegmentDetector_drawSegments, 0), "drawSegments(image, lines) -> image\n. @brief Draws the line segments on a given image.\n. @param image The image, where the lines will be drawn. Should be bigger or equal to the image,\n. where the lines were found.\n. @param lines A vector of the lines that needed to be drawn."},
| 16900 |  |  | 16900 |
| 16901 | {NULL, NULL} |  | 16901 | {NULL, NULL}
| 16902 | }; |  | 16902 | };
| 16903 |  |  | 16903 |
| 16904 | // Converter (LineSegmentDetector) |  | 16904 | // Converter (LineSegmentDetector)
| 16905 |  |  | 16905 |
| 16906 | template<> |  | 16906 | template<>
| 16907 | struct PyOpenCV_Converter< Ptr<cv::LineSegmentDetector> > |  | 16907 | struct PyOpenCV_Converter< Ptr<cv::LineSegmentDetector> >
| 16908 | { |  | 16908 | {
| 16909 | static PyObject* from(const Ptr<cv::LineSegmentDetector>& r) |  | 16909 | static PyObject* from(const Ptr<cv::LineSegmentDetector>& r)
| 16910 | { |  | 16910 | {
| 16911 | return pyopencv_LineSegmentDetector_Instance(r); |  | 16911 | return pyopencv_LineSegmentDetector_Instance(r);
| 16912 | } |  | 16912 | }
| 16913 | static bool to(PyObject* src, Ptr<cv::LineSegmentDetector>& dst, const ArgInfo& info) |  | 16913 | static bool to(PyObject* src, Ptr<cv::LineSegmentDetector>& dst, const ArgInfo& info)
| 16914 | { |  | 16914 | {
| 16915 | if(!src || src == Py_None) |  | 16915 | if(!src || src == Py_None)
| 16916 | return true; |  | 16916 | return true;
| 16917 | Ptr<cv::LineSegmentDetector> * dst_; |  | 16917 | Ptr<cv::LineSegmentDetector> * dst_;
| 16918 | if (pyopencv_LineSegmentDetector_getp(src, dst_)) |  | 16918 | if (pyopencv_LineSegmentDetector_getp(src, dst_))
| 16919 | { |  | 16919 | {
| 16920 | dst = *dst_; |  | 16920 | dst = *dst_;
| 16921 | return true; |  | 16921 | return true;
| 16922 | } |  | 16922 | }
| 16923 |  |  | 16923 |
| 16924 | failmsg("Expected Ptr<cv::LineSegmentDetector> for argument '%s'", info.name); |  | 16924 | failmsg("Expected Ptr<cv::LineSegmentDetector> for argument '%s'", info.name);
| 16925 | return false; |  | 16925 | return false;
| 16926 | } |  | 16926 | }
| 16927 | }; |  | 16927 | };
| 16928 |  |  | 16928 |
| 16929 | //================================================================================ |  | 16929 | //================================================================================
| 16930 | // MSER (Generic) |  | 16930 | // MSER (Generic)
| 16931 | //================================================================================ |  | 16931 | //================================================================================
| 16932 |  |  | 16932 |
| 16933 | // GetSet (MSER) |  | 16933 | // GetSet (MSER)
| 16934 |  |  | 16934 |
| 16935 |  |  | 16935 |
| 16936 |  |  | 16936 |
| 16937 | // Methods (MSER) |  | 16937 | // Methods (MSER)
| 16938 |  |  | 16938 |
| 16939 | static PyObject* pyopencv_cv_MSER_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16939 | static PyObject* pyopencv_cv_MSER_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 16940 | { |  | 16940 | {
| 16941 | using namespace cv; |  | 16941 | using namespace cv;
| 16942 |  |  | 16942 |
| 16943 | PyObject* pyobj_delta = NULL; |  | 16943 | PyObject* pyobj_delta = NULL;
| 16944 | int delta=5; |  | 16944 | int delta=5;
| 16945 | PyObject* pyobj_min_area = NULL; |  | 16945 | PyObject* pyobj_min_area = NULL;
| 16946 | int min_area=60; |  | 16946 | int min_area=60;
| 16947 | PyObject* pyobj_max_area = NULL; |  | 16947 | PyObject* pyobj_max_area = NULL;
| 16948 | int max_area=14400; |  | 16948 | int max_area=14400;
| 16949 | PyObject* pyobj_max_variation = NULL; |  | 16949 | PyObject* pyobj_max_variation = NULL;
| 16950 | double max_variation=0.25; |  | 16950 | double max_variation=0.25;
| 16951 | PyObject* pyobj_min_diversity = NULL; |  | 16951 | PyObject* pyobj_min_diversity = NULL;
| 16952 | double min_diversity=.2; |  | 16952 | double min_diversity=.2;
| 16953 | PyObject* pyobj_max_evolution = NULL; |  | 16953 | PyObject* pyobj_max_evolution = NULL;
| 16954 | int max_evolution=200; |  | 16954 | int max_evolution=200;
| 16955 | PyObject* pyobj_area_threshold = NULL; |  | 16955 | PyObject* pyobj_area_threshold = NULL;
| 16956 | double area_threshold=1.01; |  | 16956 | double area_threshold=1.01;
| 16957 | PyObject* pyobj_min_margin = NULL; |  | 16957 | PyObject* pyobj_min_margin = NULL;
| 16958 | double min_margin=0.003; |  | 16958 | double min_margin=0.003;
| 16959 | PyObject* pyobj_edge_blur_size = NULL; |  | 16959 | PyObject* pyobj_edge_blur_size = NULL;
| 16960 | int edge_blur_size=5; |  | 16960 | int edge_blur_size=5;
| 16961 | Ptr<MSER> retval; |  | 16961 | Ptr<MSER> retval;
| 16962 |  |  | 16962 |
| 16963 | const char* keywords[] = { "delta", "min_area", "max_area", "max_variation", "min_diversity", "max_evolution", "area_threshold", "min_margin", "edge_blur_size", NULL }; |  | 16963 | const char* keywords[] = { "delta", "min_area", "max_area", "max_variation", "min_diversity", "max_evolution", "area_threshold", "min_margin", "edge_blur_size", NULL };
| 16964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOO:MSER.create", (char**)keywords, &pyobj_delta, &pyobj_min_area, &pyobj_max_area, &pyobj_max_variation, &pyobj_min_diversity, &pyobj_max_evolution, &pyobj_area_threshold, &pyobj_min_margin, &pyobj_edge_blur_size) && |  | 16964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOO:MSER.create", (char**)keywords, &pyobj_delta, &pyobj_min_area, &pyobj_max_area, &pyobj_max_variation, &pyobj_min_diversity, &pyobj_max_evolution, &pyobj_area_threshold, &pyobj_min_margin, &pyobj_edge_blur_size) &&
| 16965 | pyopencv_to_safe(pyobj_delta, delta, ArgInfo("delta", 0)) && |  | 16965 | pyopencv_to_safe(pyobj_delta, delta, ArgInfo("delta", 0)) &&
| 16966 | pyopencv_to_safe(pyobj_min_area, min_area, ArgInfo("min_area", 0)) && |  | 16966 | pyopencv_to_safe(pyobj_min_area, min_area, ArgInfo("min_area", 0)) &&
| 16967 | pyopencv_to_safe(pyobj_max_area, max_area, ArgInfo("max_area", 0)) && |  | 16967 | pyopencv_to_safe(pyobj_max_area, max_area, ArgInfo("max_area", 0)) &&
| 16968 | pyopencv_to_safe(pyobj_max_variation, max_variation, ArgInfo("max_variation", 0)) && |  | 16968 | pyopencv_to_safe(pyobj_max_variation, max_variation, ArgInfo("max_variation", 0)) &&
| 16969 | pyopencv_to_safe(pyobj_min_diversity, min_diversity, ArgInfo("min_diversity", 0)) && |  | 16969 | pyopencv_to_safe(pyobj_min_diversity, min_diversity, ArgInfo("min_diversity", 0)) &&
| 16970 | pyopencv_to_safe(pyobj_max_evolution, max_evolution, ArgInfo("max_evolution", 0)) && |  | 16970 | pyopencv_to_safe(pyobj_max_evolution, max_evolution, ArgInfo("max_evolution", 0)) &&
| 16971 | pyopencv_to_safe(pyobj_area_threshold, area_threshold, ArgInfo("area_threshold", 0)) && |  | 16971 | pyopencv_to_safe(pyobj_area_threshold, area_threshold, ArgInfo("area_threshold", 0)) &&
| 16972 | pyopencv_to_safe(pyobj_min_margin, min_margin, ArgInfo("min_margin", 0)) && |  | 16972 | pyopencv_to_safe(pyobj_min_margin, min_margin, ArgInfo("min_margin", 0)) &&
| 16973 | pyopencv_to_safe(pyobj_edge_blur_size, edge_blur_size, ArgInfo("edge_blur_size", 0)) ) |  | 16973 | pyopencv_to_safe(pyobj_edge_blur_size, edge_blur_size, ArgInfo("edge_blur_size", 0)) )
| 16974 | { |  | 16974 | {
| 16975 | ERRWRAP2(retval = cv::MSER::create(delta, min_area, max_area, max_variation, min_diversity, max_evolution, area_threshold, min_margin, edge_blur_size)); |  | 16975 | ERRWRAP2(retval = cv::MSER::create(delta, min_area, max_area, max_variation, min_diversity, max_evolution, area_threshold, min_margin, edge_blur_size));
| 16976 | return pyopencv_from(retval); |  | 16976 | return pyopencv_from(retval);
| 16977 | } |  | 16977 | }
| 16978 |  |  | 16978 |
| 16979 | return NULL; |  | 16979 | return NULL;
| 16980 | } |  | 16980 | }
| 16981 |  |  | 16981 |
| 16982 | static PyObject* pyopencv_cv_MSER_detectRegions(PyObject* self, PyObject* py_args, PyObject* kw) |  | 16982 | static PyObject* pyopencv_cv_MSER_detectRegions(PyObject* self, PyObject* py_args, PyObject* kw)
| 16983 | { |  | 16983 | {
| 16984 | using namespace cv; |  | 16984 | using namespace cv;
| 16985 |  |  | 16985 |
| 16986 |  |  | 16986 |
| 16987 | Ptr<cv::MSER> * self1 = 0; |  | 16987 | Ptr<cv::MSER> * self1 = 0;
| 16988 | if (!pyopencv_MSER_getp(self, self1)) |  | 16988 | if (!pyopencv_MSER_getp(self, self1))
| 16989 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 16989 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 16990 | Ptr<cv::MSER> _self_ = *(self1); |  | 16990 | Ptr<cv::MSER> _self_ = *(self1);
| 16991 | pyPrepareArgumentConversionErrorsStorage(2); |  | 16991 | pyPrepareArgumentConversionErrorsStorage(2);
| 16992 |  |  | 16992 |
| 16993 | { |  | 16993 | {
| 16994 | PyObject* pyobj_image = NULL; |  | 16994 | PyObject* pyobj_image = NULL;
| 16995 | Mat image; |  | 16995 | Mat image;
| 16996 | vector_vector_Point msers; |  | 16996 | vector_vector_Point msers;
| 16997 | vector_Rect bboxes; |  | 16997 | vector_Rect bboxes;
| 16998 |  |  | 16998 |
| 16999 | const char* keywords[] = { "image", NULL }; |  | 16999 | const char* keywords[] = { "image", NULL };
| 17000 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.detectRegions", (char**)keywords, &pyobj_image) && |  | 17000 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.detectRegions", (char**)keywords, &pyobj_image) &&
| 17001 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 17001 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 17002 | { |  | 17002 | {
| 17003 | ERRWRAP2(_self_->detectRegions(image, msers, bboxes)); |  | 17003 | ERRWRAP2(_self_->detectRegions(image, msers, bboxes));
| 17004 | return Py_BuildValue("(NN)", pyopencv_from(msers), pyopencv_from(bboxes)); |  | 17004 | return Py_BuildValue("(NN)", pyopencv_from(msers), pyopencv_from(bboxes));
| 17005 | } |  | 17005 | }
| 17006 |  |  | 17006 |
| 17007 |  |  | 17007 |
| 17008 | pyPopulateArgumentConversionErrors(); |  | 17008 | pyPopulateArgumentConversionErrors();
| 17009 | } |  | 17009 | }
| 17010 |  |  | 17010 |
| 17011 |  |  | 17011 |
| 17012 | { |  | 17012 | {
| 17013 | PyObject* pyobj_image = NULL; |  | 17013 | PyObject* pyobj_image = NULL;
| 17014 | UMat image; |  | 17014 | UMat image;
| 17015 | vector_vector_Point msers; |  | 17015 | vector_vector_Point msers;
| 17016 | vector_Rect bboxes; |  | 17016 | vector_Rect bboxes;
| 17017 |  |  | 17017 |
| 17018 | const char* keywords[] = { "image", NULL }; |  | 17018 | const char* keywords[] = { "image", NULL };
| 17019 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.detectRegions", (char**)keywords, &pyobj_image) && |  | 17019 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.detectRegions", (char**)keywords, &pyobj_image) &&
| 17020 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 17020 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 17021 | { |  | 17021 | {
| 17022 | ERRWRAP2(_self_->detectRegions(image, msers, bboxes)); |  | 17022 | ERRWRAP2(_self_->detectRegions(image, msers, bboxes));
| 17023 | return Py_BuildValue("(NN)", pyopencv_from(msers), pyopencv_from(bboxes)); |  | 17023 | return Py_BuildValue("(NN)", pyopencv_from(msers), pyopencv_from(bboxes));
| 17024 | } |  | 17024 | }
| 17025 |  |  | 17025 |
| 17026 |  |  | 17026 |
| 17027 | pyPopulateArgumentConversionErrors(); |  | 17027 | pyPopulateArgumentConversionErrors();
| 17028 | } |  | 17028 | }
| 17029 | pyRaiseCVOverloadException("detectRegions"); |  | 17029 | pyRaiseCVOverloadException("detectRegions");
| 17030 |  |  | 17030 |
| 17031 | return NULL; |  | 17031 | return NULL;
| 17032 | } |  | 17032 | }
| 17033 |  |  | 17033 |
| 17034 | static PyObject* pyopencv_cv_MSER_getAreaThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17034 | static PyObject* pyopencv_cv_MSER_getAreaThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 17035 | { |  | 17035 | {
| 17036 | using namespace cv; |  | 17036 | using namespace cv;
| 17037 |  |  | 17037 |
| 17038 |  |  | 17038 |
| 17039 | Ptr<cv::MSER> * self1 = 0; |  | 17039 | Ptr<cv::MSER> * self1 = 0;
| 17040 | if (!pyopencv_MSER_getp(self, self1)) |  | 17040 | if (!pyopencv_MSER_getp(self, self1))
| 17041 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17041 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17042 | Ptr<cv::MSER> _self_ = *(self1); |  | 17042 | Ptr<cv::MSER> _self_ = *(self1);
| 17043 | double retval; |  | 17043 | double retval;
| 17044 |  |  | 17044 |
| 17045 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17045 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17046 | { |  | 17046 | {
| 17047 | ERRWRAP2(retval = _self_->getAreaThreshold()); |  | 17047 | ERRWRAP2(retval = _self_->getAreaThreshold());
| 17048 | return pyopencv_from(retval); |  | 17048 | return pyopencv_from(retval);
| 17049 | } |  | 17049 | }
| 17050 |  |  | 17050 |
| 17051 | return NULL; |  | 17051 | return NULL;
| 17052 | } |  | 17052 | }
| 17053 |  |  | 17053 |
| 17054 | static PyObject* pyopencv_cv_MSER_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17054 | static PyObject* pyopencv_cv_MSER_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 17055 | { |  | 17055 | {
| 17056 | using namespace cv; |  | 17056 | using namespace cv;
| 17057 |  |  | 17057 |
| 17058 |  |  | 17058 |
| 17059 | Ptr<cv::MSER> * self1 = 0; |  | 17059 | Ptr<cv::MSER> * self1 = 0;
| 17060 | if (!pyopencv_MSER_getp(self, self1)) |  | 17060 | if (!pyopencv_MSER_getp(self, self1))
| 17061 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17061 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17062 | Ptr<cv::MSER> _self_ = *(self1); |  | 17062 | Ptr<cv::MSER> _self_ = *(self1);
| 17063 | String retval; |  | 17063 | String retval;
| 17064 |  |  | 17064 |
| 17065 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17065 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17066 | { |  | 17066 | {
| 17067 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 17067 | ERRWRAP2(retval = _self_->getDefaultName());
| 17068 | return pyopencv_from(retval); |  | 17068 | return pyopencv_from(retval);
| 17069 | } |  | 17069 | }
| 17070 |  |  | 17070 |
| 17071 | return NULL; |  | 17071 | return NULL;
| 17072 | } |  | 17072 | }
| 17073 |  |  | 17073 |
| 17074 | static PyObject* pyopencv_cv_MSER_getDelta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17074 | static PyObject* pyopencv_cv_MSER_getDelta(PyObject* self, PyObject* py_args, PyObject* kw)
| 17075 | { |  | 17075 | {
| 17076 | using namespace cv; |  | 17076 | using namespace cv;
| 17077 |  |  | 17077 |
| 17078 |  |  | 17078 |
| 17079 | Ptr<cv::MSER> * self1 = 0; |  | 17079 | Ptr<cv::MSER> * self1 = 0;
| 17080 | if (!pyopencv_MSER_getp(self, self1)) |  | 17080 | if (!pyopencv_MSER_getp(self, self1))
| 17081 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17081 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17082 | Ptr<cv::MSER> _self_ = *(self1); |  | 17082 | Ptr<cv::MSER> _self_ = *(self1);
| 17083 | int retval; |  | 17083 | int retval;
| 17084 |  |  | 17084 |
| 17085 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17085 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17086 | { |  | 17086 | {
| 17087 | ERRWRAP2(retval = _self_->getDelta()); |  | 17087 | ERRWRAP2(retval = _self_->getDelta());
| 17088 | return pyopencv_from(retval); |  | 17088 | return pyopencv_from(retval);
| 17089 | } |  | 17089 | }
| 17090 |  |  | 17090 |
| 17091 | return NULL; |  | 17091 | return NULL;
| 17092 | } |  | 17092 | }
| 17093 |  |  | 17093 |
| 17094 | static PyObject* pyopencv_cv_MSER_getEdgeBlurSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17094 | static PyObject* pyopencv_cv_MSER_getEdgeBlurSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 17095 | { |  | 17095 | {
| 17096 | using namespace cv; |  | 17096 | using namespace cv;
| 17097 |  |  | 17097 |
| 17098 |  |  | 17098 |
| 17099 | Ptr<cv::MSER> * self1 = 0; |  | 17099 | Ptr<cv::MSER> * self1 = 0;
| 17100 | if (!pyopencv_MSER_getp(self, self1)) |  | 17100 | if (!pyopencv_MSER_getp(self, self1))
| 17101 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17101 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17102 | Ptr<cv::MSER> _self_ = *(self1); |  | 17102 | Ptr<cv::MSER> _self_ = *(self1);
| 17103 | int retval; |  | 17103 | int retval;
| 17104 |  |  | 17104 |
| 17105 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17105 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17106 | { |  | 17106 | {
| 17107 | ERRWRAP2(retval = _self_->getEdgeBlurSize()); |  | 17107 | ERRWRAP2(retval = _self_->getEdgeBlurSize());
| 17108 | return pyopencv_from(retval); |  | 17108 | return pyopencv_from(retval);
| 17109 | } |  | 17109 | }
| 17110 |  |  | 17110 |
| 17111 | return NULL; |  | 17111 | return NULL;
| 17112 | } |  | 17112 | }
| 17113 |  |  | 17113 |
| 17114 | static PyObject* pyopencv_cv_MSER_getMaxArea(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17114 | static PyObject* pyopencv_cv_MSER_getMaxArea(PyObject* self, PyObject* py_args, PyObject* kw)
| 17115 | { |  | 17115 | {
| 17116 | using namespace cv; |  | 17116 | using namespace cv;
| 17117 |  |  | 17117 |
| 17118 |  |  | 17118 |
| 17119 | Ptr<cv::MSER> * self1 = 0; |  | 17119 | Ptr<cv::MSER> * self1 = 0;
| 17120 | if (!pyopencv_MSER_getp(self, self1)) |  | 17120 | if (!pyopencv_MSER_getp(self, self1))
| 17121 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17121 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17122 | Ptr<cv::MSER> _self_ = *(self1); |  | 17122 | Ptr<cv::MSER> _self_ = *(self1);
| 17123 | int retval; |  | 17123 | int retval;
| 17124 |  |  | 17124 |
| 17125 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17125 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17126 | { |  | 17126 | {
| 17127 | ERRWRAP2(retval = _self_->getMaxArea()); |  | 17127 | ERRWRAP2(retval = _self_->getMaxArea());
| 17128 | return pyopencv_from(retval); |  | 17128 | return pyopencv_from(retval);
| 17129 | } |  | 17129 | }
| 17130 |  |  | 17130 |
| 17131 | return NULL; |  | 17131 | return NULL;
| 17132 | } |  | 17132 | }
| 17133 |  |  | 17133 |
| 17134 | static PyObject* pyopencv_cv_MSER_getMaxEvolution(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17134 | static PyObject* pyopencv_cv_MSER_getMaxEvolution(PyObject* self, PyObject* py_args, PyObject* kw)
| 17135 | { |  | 17135 | {
| 17136 | using namespace cv; |  | 17136 | using namespace cv;
| 17137 |  |  | 17137 |
| 17138 |  |  | 17138 |
| 17139 | Ptr<cv::MSER> * self1 = 0; |  | 17139 | Ptr<cv::MSER> * self1 = 0;
| 17140 | if (!pyopencv_MSER_getp(self, self1)) |  | 17140 | if (!pyopencv_MSER_getp(self, self1))
| 17141 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17141 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17142 | Ptr<cv::MSER> _self_ = *(self1); |  | 17142 | Ptr<cv::MSER> _self_ = *(self1);
| 17143 | int retval; |  | 17143 | int retval;
| 17144 |  |  | 17144 |
| 17145 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17145 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17146 | { |  | 17146 | {
| 17147 | ERRWRAP2(retval = _self_->getMaxEvolution()); |  | 17147 | ERRWRAP2(retval = _self_->getMaxEvolution());
| 17148 | return pyopencv_from(retval); |  | 17148 | return pyopencv_from(retval);
| 17149 | } |  | 17149 | }
| 17150 |  |  | 17150 |
| 17151 | return NULL; |  | 17151 | return NULL;
| 17152 | } |  | 17152 | }
| 17153 |  |  | 17153 |
| 17154 | static PyObject* pyopencv_cv_MSER_getMaxVariation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17154 | static PyObject* pyopencv_cv_MSER_getMaxVariation(PyObject* self, PyObject* py_args, PyObject* kw)
| 17155 | { |  | 17155 | {
| 17156 | using namespace cv; |  | 17156 | using namespace cv;
| 17157 |  |  | 17157 |
| 17158 |  |  | 17158 |
| 17159 | Ptr<cv::MSER> * self1 = 0; |  | 17159 | Ptr<cv::MSER> * self1 = 0;
| 17160 | if (!pyopencv_MSER_getp(self, self1)) |  | 17160 | if (!pyopencv_MSER_getp(self, self1))
| 17161 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17161 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17162 | Ptr<cv::MSER> _self_ = *(self1); |  | 17162 | Ptr<cv::MSER> _self_ = *(self1);
| 17163 | double retval; |  | 17163 | double retval;
| 17164 |  |  | 17164 |
| 17165 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17165 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17166 | { |  | 17166 | {
| 17167 | ERRWRAP2(retval = _self_->getMaxVariation()); |  | 17167 | ERRWRAP2(retval = _self_->getMaxVariation());
| 17168 | return pyopencv_from(retval); |  | 17168 | return pyopencv_from(retval);
| 17169 | } |  | 17169 | }
| 17170 |  |  | 17170 |
| 17171 | return NULL; |  | 17171 | return NULL;
| 17172 | } |  | 17172 | }
| 17173 |  |  | 17173 |
| 17174 | static PyObject* pyopencv_cv_MSER_getMinArea(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17174 | static PyObject* pyopencv_cv_MSER_getMinArea(PyObject* self, PyObject* py_args, PyObject* kw)
| 17175 | { |  | 17175 | {
| 17176 | using namespace cv; |  | 17176 | using namespace cv;
| 17177 |  |  | 17177 |
| 17178 |  |  | 17178 |
| 17179 | Ptr<cv::MSER> * self1 = 0; |  | 17179 | Ptr<cv::MSER> * self1 = 0;
| 17180 | if (!pyopencv_MSER_getp(self, self1)) |  | 17180 | if (!pyopencv_MSER_getp(self, self1))
| 17181 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17181 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17182 | Ptr<cv::MSER> _self_ = *(self1); |  | 17182 | Ptr<cv::MSER> _self_ = *(self1);
| 17183 | int retval; |  | 17183 | int retval;
| 17184 |  |  | 17184 |
| 17185 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17185 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17186 | { |  | 17186 | {
| 17187 | ERRWRAP2(retval = _self_->getMinArea()); |  | 17187 | ERRWRAP2(retval = _self_->getMinArea());
| 17188 | return pyopencv_from(retval); |  | 17188 | return pyopencv_from(retval);
| 17189 | } |  | 17189 | }
| 17190 |  |  | 17190 |
| 17191 | return NULL; |  | 17191 | return NULL;
| 17192 | } |  | 17192 | }
| 17193 |  |  | 17193 |
| 17194 | static PyObject* pyopencv_cv_MSER_getMinDiversity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17194 | static PyObject* pyopencv_cv_MSER_getMinDiversity(PyObject* self, PyObject* py_args, PyObject* kw)
| 17195 | { |  | 17195 | {
| 17196 | using namespace cv; |  | 17196 | using namespace cv;
| 17197 |  |  | 17197 |
| 17198 |  |  | 17198 |
| 17199 | Ptr<cv::MSER> * self1 = 0; |  | 17199 | Ptr<cv::MSER> * self1 = 0;
| 17200 | if (!pyopencv_MSER_getp(self, self1)) |  | 17200 | if (!pyopencv_MSER_getp(self, self1))
| 17201 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17201 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17202 | Ptr<cv::MSER> _self_ = *(self1); |  | 17202 | Ptr<cv::MSER> _self_ = *(self1);
| 17203 | double retval; |  | 17203 | double retval;
| 17204 |  |  | 17204 |
| 17205 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17205 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17206 | { |  | 17206 | {
| 17207 | ERRWRAP2(retval = _self_->getMinDiversity()); |  | 17207 | ERRWRAP2(retval = _self_->getMinDiversity());
| 17208 | return pyopencv_from(retval); |  | 17208 | return pyopencv_from(retval);
| 17209 | } |  | 17209 | }
| 17210 |  |  | 17210 |
| 17211 | return NULL; |  | 17211 | return NULL;
| 17212 | } |  | 17212 | }
| 17213 |  |  | 17213 |
| 17214 | static PyObject* pyopencv_cv_MSER_getMinMargin(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17214 | static PyObject* pyopencv_cv_MSER_getMinMargin(PyObject* self, PyObject* py_args, PyObject* kw)
| 17215 | { |  | 17215 | {
| 17216 | using namespace cv; |  | 17216 | using namespace cv;
| 17217 |  |  | 17217 |
| 17218 |  |  | 17218 |
| 17219 | Ptr<cv::MSER> * self1 = 0; |  | 17219 | Ptr<cv::MSER> * self1 = 0;
| 17220 | if (!pyopencv_MSER_getp(self, self1)) |  | 17220 | if (!pyopencv_MSER_getp(self, self1))
| 17221 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17221 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17222 | Ptr<cv::MSER> _self_ = *(self1); |  | 17222 | Ptr<cv::MSER> _self_ = *(self1);
| 17223 | double retval; |  | 17223 | double retval;
| 17224 |  |  | 17224 |
| 17225 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17225 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17226 | { |  | 17226 | {
| 17227 | ERRWRAP2(retval = _self_->getMinMargin()); |  | 17227 | ERRWRAP2(retval = _self_->getMinMargin());
| 17228 | return pyopencv_from(retval); |  | 17228 | return pyopencv_from(retval);
| 17229 | } |  | 17229 | }
| 17230 |  |  | 17230 |
| 17231 | return NULL; |  | 17231 | return NULL;
| 17232 | } |  | 17232 | }
| 17233 |  |  | 17233 |
| 17234 | static PyObject* pyopencv_cv_MSER_getPass2Only(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17234 | static PyObject* pyopencv_cv_MSER_getPass2Only(PyObject* self, PyObject* py_args, PyObject* kw)
| 17235 | { |  | 17235 | {
| 17236 | using namespace cv; |  | 17236 | using namespace cv;
| 17237 |  |  | 17237 |
| 17238 |  |  | 17238 |
| 17239 | Ptr<cv::MSER> * self1 = 0; |  | 17239 | Ptr<cv::MSER> * self1 = 0;
| 17240 | if (!pyopencv_MSER_getp(self, self1)) |  | 17240 | if (!pyopencv_MSER_getp(self, self1))
| 17241 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17241 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17242 | Ptr<cv::MSER> _self_ = *(self1); |  | 17242 | Ptr<cv::MSER> _self_ = *(self1);
| 17243 | bool retval; |  | 17243 | bool retval;
| 17244 |  |  | 17244 |
| 17245 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17245 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17246 | { |  | 17246 | {
| 17247 | ERRWRAP2(retval = _self_->getPass2Only()); |  | 17247 | ERRWRAP2(retval = _self_->getPass2Only());
| 17248 | return pyopencv_from(retval); |  | 17248 | return pyopencv_from(retval);
| 17249 | } |  | 17249 | }
| 17250 |  |  | 17250 |
| 17251 | return NULL; |  | 17251 | return NULL;
| 17252 | } |  | 17252 | }
| 17253 |  |  | 17253 |
| 17254 | static PyObject* pyopencv_cv_MSER_setAreaThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17254 | static PyObject* pyopencv_cv_MSER_setAreaThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 17255 | { |  | 17255 | {
| 17256 | using namespace cv; |  | 17256 | using namespace cv;
| 17257 |  |  | 17257 |
| 17258 |  |  | 17258 |
| 17259 | Ptr<cv::MSER> * self1 = 0; |  | 17259 | Ptr<cv::MSER> * self1 = 0;
| 17260 | if (!pyopencv_MSER_getp(self, self1)) |  | 17260 | if (!pyopencv_MSER_getp(self, self1))
| 17261 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17261 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17262 | Ptr<cv::MSER> _self_ = *(self1); |  | 17262 | Ptr<cv::MSER> _self_ = *(self1);
| 17263 | PyObject* pyobj_areaThreshold = NULL; |  | 17263 | PyObject* pyobj_areaThreshold = NULL;
| 17264 | double areaThreshold=0; |  | 17264 | double areaThreshold=0;
| 17265 |  |  | 17265 |
| 17266 | const char* keywords[] = { "areaThreshold", NULL }; |  | 17266 | const char* keywords[] = { "areaThreshold", NULL };
| 17267 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setAreaThreshold", (char**)keywords, &pyobj_areaThreshold) && |  | 17267 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setAreaThreshold", (char**)keywords, &pyobj_areaThreshold) &&
| 17268 | pyopencv_to_safe(pyobj_areaThreshold, areaThreshold, ArgInfo("areaThreshold", 0)) ) |  | 17268 | pyopencv_to_safe(pyobj_areaThreshold, areaThreshold, ArgInfo("areaThreshold", 0)) )
| 17269 | { |  | 17269 | {
| 17270 | ERRWRAP2(_self_->setAreaThreshold(areaThreshold)); |  | 17270 | ERRWRAP2(_self_->setAreaThreshold(areaThreshold));
| 17271 | Py_RETURN_NONE; |  | 17271 | Py_RETURN_NONE;
| 17272 | } |  | 17272 | }
| 17273 |  |  | 17273 |
| 17274 | return NULL; |  | 17274 | return NULL;
| 17275 | } |  | 17275 | }
| 17276 |  |  | 17276 |
| 17277 | static PyObject* pyopencv_cv_MSER_setDelta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17277 | static PyObject* pyopencv_cv_MSER_setDelta(PyObject* self, PyObject* py_args, PyObject* kw)
| 17278 | { |  | 17278 | {
| 17279 | using namespace cv; |  | 17279 | using namespace cv;
| 17280 |  |  | 17280 |
| 17281 |  |  | 17281 |
| 17282 | Ptr<cv::MSER> * self1 = 0; |  | 17282 | Ptr<cv::MSER> * self1 = 0;
| 17283 | if (!pyopencv_MSER_getp(self, self1)) |  | 17283 | if (!pyopencv_MSER_getp(self, self1))
| 17284 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17284 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17285 | Ptr<cv::MSER> _self_ = *(self1); |  | 17285 | Ptr<cv::MSER> _self_ = *(self1);
| 17286 | PyObject* pyobj_delta = NULL; |  | 17286 | PyObject* pyobj_delta = NULL;
| 17287 | int delta=0; |  | 17287 | int delta=0;
| 17288 |  |  | 17288 |
| 17289 | const char* keywords[] = { "delta", NULL }; |  | 17289 | const char* keywords[] = { "delta", NULL };
| 17290 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setDelta", (char**)keywords, &pyobj_delta) && |  | 17290 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setDelta", (char**)keywords, &pyobj_delta) &&
| 17291 | pyopencv_to_safe(pyobj_delta, delta, ArgInfo("delta", 0)) ) |  | 17291 | pyopencv_to_safe(pyobj_delta, delta, ArgInfo("delta", 0)) )
| 17292 | { |  | 17292 | {
| 17293 | ERRWRAP2(_self_->setDelta(delta)); |  | 17293 | ERRWRAP2(_self_->setDelta(delta));
| 17294 | Py_RETURN_NONE; |  | 17294 | Py_RETURN_NONE;
| 17295 | } |  | 17295 | }
| 17296 |  |  | 17296 |
| 17297 | return NULL; |  | 17297 | return NULL;
| 17298 | } |  | 17298 | }
| 17299 |  |  | 17299 |
| 17300 | static PyObject* pyopencv_cv_MSER_setEdgeBlurSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17300 | static PyObject* pyopencv_cv_MSER_setEdgeBlurSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 17301 | { |  | 17301 | {
| 17302 | using namespace cv; |  | 17302 | using namespace cv;
| 17303 |  |  | 17303 |
| 17304 |  |  | 17304 |
| 17305 | Ptr<cv::MSER> * self1 = 0; |  | 17305 | Ptr<cv::MSER> * self1 = 0;
| 17306 | if (!pyopencv_MSER_getp(self, self1)) |  | 17306 | if (!pyopencv_MSER_getp(self, self1))
| 17307 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17307 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17308 | Ptr<cv::MSER> _self_ = *(self1); |  | 17308 | Ptr<cv::MSER> _self_ = *(self1);
| 17309 | PyObject* pyobj_edge_blur_size = NULL; |  | 17309 | PyObject* pyobj_edge_blur_size = NULL;
| 17310 | int edge_blur_size=0; |  | 17310 | int edge_blur_size=0;
| 17311 |  |  | 17311 |
| 17312 | const char* keywords[] = { "edge_blur_size", NULL }; |  | 17312 | const char* keywords[] = { "edge_blur_size", NULL };
| 17313 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setEdgeBlurSize", (char**)keywords, &pyobj_edge_blur_size) && |  | 17313 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setEdgeBlurSize", (char**)keywords, &pyobj_edge_blur_size) &&
| 17314 | pyopencv_to_safe(pyobj_edge_blur_size, edge_blur_size, ArgInfo("edge_blur_size", 0)) ) |  | 17314 | pyopencv_to_safe(pyobj_edge_blur_size, edge_blur_size, ArgInfo("edge_blur_size", 0)) )
| 17315 | { |  | 17315 | {
| 17316 | ERRWRAP2(_self_->setEdgeBlurSize(edge_blur_size)); |  | 17316 | ERRWRAP2(_self_->setEdgeBlurSize(edge_blur_size));
| 17317 | Py_RETURN_NONE; |  | 17317 | Py_RETURN_NONE;
| 17318 | } |  | 17318 | }
| 17319 |  |  | 17319 |
| 17320 | return NULL; |  | 17320 | return NULL;
| 17321 | } |  | 17321 | }
| 17322 |  |  | 17322 |
| 17323 | static PyObject* pyopencv_cv_MSER_setMaxArea(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17323 | static PyObject* pyopencv_cv_MSER_setMaxArea(PyObject* self, PyObject* py_args, PyObject* kw)
| 17324 | { |  | 17324 | {
| 17325 | using namespace cv; |  | 17325 | using namespace cv;
| 17326 |  |  | 17326 |
| 17327 |  |  | 17327 |
| 17328 | Ptr<cv::MSER> * self1 = 0; |  | 17328 | Ptr<cv::MSER> * self1 = 0;
| 17329 | if (!pyopencv_MSER_getp(self, self1)) |  | 17329 | if (!pyopencv_MSER_getp(self, self1))
| 17330 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17330 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17331 | Ptr<cv::MSER> _self_ = *(self1); |  | 17331 | Ptr<cv::MSER> _self_ = *(self1);
| 17332 | PyObject* pyobj_maxArea = NULL; |  | 17332 | PyObject* pyobj_maxArea = NULL;
| 17333 | int maxArea=0; |  | 17333 | int maxArea=0;
| 17334 |  |  | 17334 |
| 17335 | const char* keywords[] = { "maxArea", NULL }; |  | 17335 | const char* keywords[] = { "maxArea", NULL };
| 17336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMaxArea", (char**)keywords, &pyobj_maxArea) && |  | 17336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMaxArea", (char**)keywords, &pyobj_maxArea) &&
| 17337 | pyopencv_to_safe(pyobj_maxArea, maxArea, ArgInfo("maxArea", 0)) ) |  | 17337 | pyopencv_to_safe(pyobj_maxArea, maxArea, ArgInfo("maxArea", 0)) )
| 17338 | { |  | 17338 | {
| 17339 | ERRWRAP2(_self_->setMaxArea(maxArea)); |  | 17339 | ERRWRAP2(_self_->setMaxArea(maxArea));
| 17340 | Py_RETURN_NONE; |  | 17340 | Py_RETURN_NONE;
| 17341 | } |  | 17341 | }
| 17342 |  |  | 17342 |
| 17343 | return NULL; |  | 17343 | return NULL;
| 17344 | } |  | 17344 | }
| 17345 |  |  | 17345 |
| 17346 | static PyObject* pyopencv_cv_MSER_setMaxEvolution(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17346 | static PyObject* pyopencv_cv_MSER_setMaxEvolution(PyObject* self, PyObject* py_args, PyObject* kw)
| 17347 | { |  | 17347 | {
| 17348 | using namespace cv; |  | 17348 | using namespace cv;
| 17349 |  |  | 17349 |
| 17350 |  |  | 17350 |
| 17351 | Ptr<cv::MSER> * self1 = 0; |  | 17351 | Ptr<cv::MSER> * self1 = 0;
| 17352 | if (!pyopencv_MSER_getp(self, self1)) |  | 17352 | if (!pyopencv_MSER_getp(self, self1))
| 17353 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17353 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17354 | Ptr<cv::MSER> _self_ = *(self1); |  | 17354 | Ptr<cv::MSER> _self_ = *(self1);
| 17355 | PyObject* pyobj_maxEvolution = NULL; |  | 17355 | PyObject* pyobj_maxEvolution = NULL;
| 17356 | int maxEvolution=0; |  | 17356 | int maxEvolution=0;
| 17357 |  |  | 17357 |
| 17358 | const char* keywords[] = { "maxEvolution", NULL }; |  | 17358 | const char* keywords[] = { "maxEvolution", NULL };
| 17359 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMaxEvolution", (char**)keywords, &pyobj_maxEvolution) && |  | 17359 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMaxEvolution", (char**)keywords, &pyobj_maxEvolution) &&
| 17360 | pyopencv_to_safe(pyobj_maxEvolution, maxEvolution, ArgInfo("maxEvolution", 0)) ) |  | 17360 | pyopencv_to_safe(pyobj_maxEvolution, maxEvolution, ArgInfo("maxEvolution", 0)) )
| 17361 | { |  | 17361 | {
| 17362 | ERRWRAP2(_self_->setMaxEvolution(maxEvolution)); |  | 17362 | ERRWRAP2(_self_->setMaxEvolution(maxEvolution));
| 17363 | Py_RETURN_NONE; |  | 17363 | Py_RETURN_NONE;
| 17364 | } |  | 17364 | }
| 17365 |  |  | 17365 |
| 17366 | return NULL; |  | 17366 | return NULL;
| 17367 | } |  | 17367 | }
| 17368 |  |  | 17368 |
| 17369 | static PyObject* pyopencv_cv_MSER_setMaxVariation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17369 | static PyObject* pyopencv_cv_MSER_setMaxVariation(PyObject* self, PyObject* py_args, PyObject* kw)
| 17370 | { |  | 17370 | {
| 17371 | using namespace cv; |  | 17371 | using namespace cv;
| 17372 |  |  | 17372 |
| 17373 |  |  | 17373 |
| 17374 | Ptr<cv::MSER> * self1 = 0; |  | 17374 | Ptr<cv::MSER> * self1 = 0;
| 17375 | if (!pyopencv_MSER_getp(self, self1)) |  | 17375 | if (!pyopencv_MSER_getp(self, self1))
| 17376 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17376 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17377 | Ptr<cv::MSER> _self_ = *(self1); |  | 17377 | Ptr<cv::MSER> _self_ = *(self1);
| 17378 | PyObject* pyobj_maxVariation = NULL; |  | 17378 | PyObject* pyobj_maxVariation = NULL;
| 17379 | double maxVariation=0; |  | 17379 | double maxVariation=0;
| 17380 |  |  | 17380 |
| 17381 | const char* keywords[] = { "maxVariation", NULL }; |  | 17381 | const char* keywords[] = { "maxVariation", NULL };
| 17382 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMaxVariation", (char**)keywords, &pyobj_maxVariation) && |  | 17382 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMaxVariation", (char**)keywords, &pyobj_maxVariation) &&
| 17383 | pyopencv_to_safe(pyobj_maxVariation, maxVariation, ArgInfo("maxVariation", 0)) ) |  | 17383 | pyopencv_to_safe(pyobj_maxVariation, maxVariation, ArgInfo("maxVariation", 0)) )
| 17384 | { |  | 17384 | {
| 17385 | ERRWRAP2(_self_->setMaxVariation(maxVariation)); |  | 17385 | ERRWRAP2(_self_->setMaxVariation(maxVariation));
| 17386 | Py_RETURN_NONE; |  | 17386 | Py_RETURN_NONE;
| 17387 | } |  | 17387 | }
| 17388 |  |  | 17388 |
| 17389 | return NULL; |  | 17389 | return NULL;
| 17390 | } |  | 17390 | }
| 17391 |  |  | 17391 |
| 17392 | static PyObject* pyopencv_cv_MSER_setMinArea(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17392 | static PyObject* pyopencv_cv_MSER_setMinArea(PyObject* self, PyObject* py_args, PyObject* kw)
| 17393 | { |  | 17393 | {
| 17394 | using namespace cv; |  | 17394 | using namespace cv;
| 17395 |  |  | 17395 |
| 17396 |  |  | 17396 |
| 17397 | Ptr<cv::MSER> * self1 = 0; |  | 17397 | Ptr<cv::MSER> * self1 = 0;
| 17398 | if (!pyopencv_MSER_getp(self, self1)) |  | 17398 | if (!pyopencv_MSER_getp(self, self1))
| 17399 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17399 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17400 | Ptr<cv::MSER> _self_ = *(self1); |  | 17400 | Ptr<cv::MSER> _self_ = *(self1);
| 17401 | PyObject* pyobj_minArea = NULL; |  | 17401 | PyObject* pyobj_minArea = NULL;
| 17402 | int minArea=0; |  | 17402 | int minArea=0;
| 17403 |  |  | 17403 |
| 17404 | const char* keywords[] = { "minArea", NULL }; |  | 17404 | const char* keywords[] = { "minArea", NULL };
| 17405 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMinArea", (char**)keywords, &pyobj_minArea) && |  | 17405 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMinArea", (char**)keywords, &pyobj_minArea) &&
| 17406 | pyopencv_to_safe(pyobj_minArea, minArea, ArgInfo("minArea", 0)) ) |  | 17406 | pyopencv_to_safe(pyobj_minArea, minArea, ArgInfo("minArea", 0)) )
| 17407 | { |  | 17407 | {
| 17408 | ERRWRAP2(_self_->setMinArea(minArea)); |  | 17408 | ERRWRAP2(_self_->setMinArea(minArea));
| 17409 | Py_RETURN_NONE; |  | 17409 | Py_RETURN_NONE;
| 17410 | } |  | 17410 | }
| 17411 |  |  | 17411 |
| 17412 | return NULL; |  | 17412 | return NULL;
| 17413 | } |  | 17413 | }
| 17414 |  |  | 17414 |
| 17415 | static PyObject* pyopencv_cv_MSER_setMinDiversity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17415 | static PyObject* pyopencv_cv_MSER_setMinDiversity(PyObject* self, PyObject* py_args, PyObject* kw)
| 17416 | { |  | 17416 | {
| 17417 | using namespace cv; |  | 17417 | using namespace cv;
| 17418 |  |  | 17418 |
| 17419 |  |  | 17419 |
| 17420 | Ptr<cv::MSER> * self1 = 0; |  | 17420 | Ptr<cv::MSER> * self1 = 0;
| 17421 | if (!pyopencv_MSER_getp(self, self1)) |  | 17421 | if (!pyopencv_MSER_getp(self, self1))
| 17422 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17422 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17423 | Ptr<cv::MSER> _self_ = *(self1); |  | 17423 | Ptr<cv::MSER> _self_ = *(self1);
| 17424 | PyObject* pyobj_minDiversity = NULL; |  | 17424 | PyObject* pyobj_minDiversity = NULL;
| 17425 | double minDiversity=0; |  | 17425 | double minDiversity=0;
| 17426 |  |  | 17426 |
| 17427 | const char* keywords[] = { "minDiversity", NULL }; |  | 17427 | const char* keywords[] = { "minDiversity", NULL };
| 17428 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMinDiversity", (char**)keywords, &pyobj_minDiversity) && |  | 17428 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMinDiversity", (char**)keywords, &pyobj_minDiversity) &&
| 17429 | pyopencv_to_safe(pyobj_minDiversity, minDiversity, ArgInfo("minDiversity", 0)) ) |  | 17429 | pyopencv_to_safe(pyobj_minDiversity, minDiversity, ArgInfo("minDiversity", 0)) )
| 17430 | { |  | 17430 | {
| 17431 | ERRWRAP2(_self_->setMinDiversity(minDiversity)); |  | 17431 | ERRWRAP2(_self_->setMinDiversity(minDiversity));
| 17432 | Py_RETURN_NONE; |  | 17432 | Py_RETURN_NONE;
| 17433 | } |  | 17433 | }
| 17434 |  |  | 17434 |
| 17435 | return NULL; |  | 17435 | return NULL;
| 17436 | } |  | 17436 | }
| 17437 |  |  | 17437 |
| 17438 | static PyObject* pyopencv_cv_MSER_setMinMargin(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17438 | static PyObject* pyopencv_cv_MSER_setMinMargin(PyObject* self, PyObject* py_args, PyObject* kw)
| 17439 | { |  | 17439 | {
| 17440 | using namespace cv; |  | 17440 | using namespace cv;
| 17441 |  |  | 17441 |
| 17442 |  |  | 17442 |
| 17443 | Ptr<cv::MSER> * self1 = 0; |  | 17443 | Ptr<cv::MSER> * self1 = 0;
| 17444 | if (!pyopencv_MSER_getp(self, self1)) |  | 17444 | if (!pyopencv_MSER_getp(self, self1))
| 17445 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17445 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17446 | Ptr<cv::MSER> _self_ = *(self1); |  | 17446 | Ptr<cv::MSER> _self_ = *(self1);
| 17447 | PyObject* pyobj_min_margin = NULL; |  | 17447 | PyObject* pyobj_min_margin = NULL;
| 17448 | double min_margin=0; |  | 17448 | double min_margin=0;
| 17449 |  |  | 17449 |
| 17450 | const char* keywords[] = { "min_margin", NULL }; |  | 17450 | const char* keywords[] = { "min_margin", NULL };
| 17451 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMinMargin", (char**)keywords, &pyobj_min_margin) && |  | 17451 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setMinMargin", (char**)keywords, &pyobj_min_margin) &&
| 17452 | pyopencv_to_safe(pyobj_min_margin, min_margin, ArgInfo("min_margin", 0)) ) |  | 17452 | pyopencv_to_safe(pyobj_min_margin, min_margin, ArgInfo("min_margin", 0)) )
| 17453 | { |  | 17453 | {
| 17454 | ERRWRAP2(_self_->setMinMargin(min_margin)); |  | 17454 | ERRWRAP2(_self_->setMinMargin(min_margin));
| 17455 | Py_RETURN_NONE; |  | 17455 | Py_RETURN_NONE;
| 17456 | } |  | 17456 | }
| 17457 |  |  | 17457 |
| 17458 | return NULL; |  | 17458 | return NULL;
| 17459 | } |  | 17459 | }
| 17460 |  |  | 17460 |
| 17461 | static PyObject* pyopencv_cv_MSER_setPass2Only(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17461 | static PyObject* pyopencv_cv_MSER_setPass2Only(PyObject* self, PyObject* py_args, PyObject* kw)
| 17462 | { |  | 17462 | {
| 17463 | using namespace cv; |  | 17463 | using namespace cv;
| 17464 |  |  | 17464 |
| 17465 |  |  | 17465 |
| 17466 | Ptr<cv::MSER> * self1 = 0; |  | 17466 | Ptr<cv::MSER> * self1 = 0;
| 17467 | if (!pyopencv_MSER_getp(self, self1)) |  | 17467 | if (!pyopencv_MSER_getp(self, self1))
| 17468 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)"); |  | 17468 | return failmsgp("Incorrect type of self (must be 'MSER' or its derivative)");
| 17469 | Ptr<cv::MSER> _self_ = *(self1); |  | 17469 | Ptr<cv::MSER> _self_ = *(self1);
| 17470 | PyObject* pyobj_f = NULL; |  | 17470 | PyObject* pyobj_f = NULL;
| 17471 | bool f=0; |  | 17471 | bool f=0;
| 17472 |  |  | 17472 |
| 17473 | const char* keywords[] = { "f", NULL }; |  | 17473 | const char* keywords[] = { "f", NULL };
| 17474 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setPass2Only", (char**)keywords, &pyobj_f) && |  | 17474 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MSER.setPass2Only", (char**)keywords, &pyobj_f) &&
| 17475 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) ) |  | 17475 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) )
| 17476 | { |  | 17476 | {
| 17477 | ERRWRAP2(_self_->setPass2Only(f)); |  | 17477 | ERRWRAP2(_self_->setPass2Only(f));
| 17478 | Py_RETURN_NONE; |  | 17478 | Py_RETURN_NONE;
| 17479 | } |  | 17479 | }
| 17480 |  |  | 17480 |
| 17481 | return NULL; |  | 17481 | return NULL;
| 17482 | } |  | 17482 | }
| 17483 |  |  | 17483 |
| 17484 |  |  | 17484 |
| 17485 |  |  | 17485 |
| 17486 | // Tables (MSER) |  | 17486 | // Tables (MSER)
| 17487 |  |  | 17487 |
| 17488 | static PyGetSetDef pyopencv_MSER_getseters[] = |  | 17488 | static PyGetSetDef pyopencv_MSER_getseters[] =
| 17489 | { |  | 17489 | {
| 17490 | {NULL} /* Sentinel */ |  | 17490 | {NULL} /* Sentinel */
| 17491 | }; |  | 17491 | };
| 17492 |  |  | 17492 |
| 17493 | static PyMethodDef pyopencv_MSER_methods[] = |  | 17493 | static PyMethodDef pyopencv_MSER_methods[] =
| 17494 | { |  | 17494 | {
| 17495 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_create_static, METH_STATIC), "create([, delta[, min_area[, max_area[, max_variation[, min_diversity[, max_evolution[, area_threshold[, min_margin[, edge_blur_size]]]]]]]]]) -> retval\n. @brief Full constructor for %MSER detector\n. \n. @param delta it compares \\f$(size_{i}-size_{i-delta})/size_{i-delta}\\f$\n. @param min_area prune the area which smaller than minArea\n. @param max_area prune the area which bigger than maxArea\n. @param max_variation prune the area have similar size to its children\n. @param min_diversity for color image, trace back to cut off mser with diversity less than min_diversity\n. @param max_evolution for color image, the evolution steps\n. @param area_threshold for color image, the area threshold to cause re-initialize\n. @param min_margin for color image, ignore too small margin\n. @param edge_blur_size for color image, the aperture size for edge blur"}, |  | 17495 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_create_static, METH_STATIC), "create([, delta[, min_area[, max_area[, max_variation[, min_diversity[, max_evolution[, area_threshold[, min_margin[, edge_blur_size]]]]]]]]]) -> retval\n. @brief Full constructor for %MSER detector\n. \n. @param delta it compares \\f$(size_{i}-size_{i-delta})/size_{i-delta}\\f$\n. @param min_area prune the area which smaller than minArea\n. @param max_area prune the area which bigger than maxArea\n. @param max_variation prune the area have similar size to its children\n. @param min_diversity for color image, trace back to cut off mser with diversity less than min_diversity\n. @param max_evolution for color image, the evolution steps\n. @param area_threshold for color image, the area threshold to cause re-initialize\n. @param min_margin for color image, ignore too small margin\n. @param edge_blur_size for color image, the aperture size for edge blur"},
| 17496 | {"detectRegions", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_detectRegions, 0), "detectRegions(image) -> msers, bboxes\n. @brief Detect %MSER regions\n. \n. @param image input image (8UC1, 8UC3 or 8UC4, must be greater or equal than 3x3)\n. @param msers resulting list of point sets\n. @param bboxes resulting bounding boxes"}, |  | 17496 | {"detectRegions", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_detectRegions, 0), "detectRegions(image) -> msers, bboxes\n. @brief Detect %MSER regions\n. \n. @param image input image (8UC1, 8UC3 or 8UC4, must be greater or equal than 3x3)\n. @param msers resulting list of point sets\n. @param bboxes resulting bounding boxes"},
| 17497 | {"getAreaThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getAreaThreshold, 0), "getAreaThreshold() -> retval\n."}, |  | 17497 | {"getAreaThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getAreaThreshold, 0), "getAreaThreshold() -> retval\n."},
| 17498 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 17498 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 17499 | {"getDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getDelta, 0), "getDelta() -> retval\n."}, |  | 17499 | {"getDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getDelta, 0), "getDelta() -> retval\n."},
| 17500 | {"getEdgeBlurSize", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getEdgeBlurSize, 0), "getEdgeBlurSize() -> retval\n."}, |  | 17500 | {"getEdgeBlurSize", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getEdgeBlurSize, 0), "getEdgeBlurSize() -> retval\n."},
| 17501 | {"getMaxArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMaxArea, 0), "getMaxArea() -> retval\n."}, |  | 17501 | {"getMaxArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMaxArea, 0), "getMaxArea() -> retval\n."},
| 17502 | {"getMaxEvolution", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMaxEvolution, 0), "getMaxEvolution() -> retval\n."}, |  | 17502 | {"getMaxEvolution", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMaxEvolution, 0), "getMaxEvolution() -> retval\n."},
| 17503 | {"getMaxVariation", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMaxVariation, 0), "getMaxVariation() -> retval\n."}, |  | 17503 | {"getMaxVariation", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMaxVariation, 0), "getMaxVariation() -> retval\n."},
| 17504 | {"getMinArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMinArea, 0), "getMinArea() -> retval\n."}, |  | 17504 | {"getMinArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMinArea, 0), "getMinArea() -> retval\n."},
| 17505 | {"getMinDiversity", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMinDiversity, 0), "getMinDiversity() -> retval\n."}, |  | 17505 | {"getMinDiversity", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMinDiversity, 0), "getMinDiversity() -> retval\n."},
| 17506 | {"getMinMargin", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMinMargin, 0), "getMinMargin() -> retval\n."}, |  | 17506 | {"getMinMargin", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getMinMargin, 0), "getMinMargin() -> retval\n."},
| 17507 | {"getPass2Only", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getPass2Only, 0), "getPass2Only() -> retval\n."}, |  | 17507 | {"getPass2Only", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_getPass2Only, 0), "getPass2Only() -> retval\n."},
| 17508 | {"setAreaThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setAreaThreshold, 0), "setAreaThreshold(areaThreshold) -> None\n."}, |  | 17508 | {"setAreaThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setAreaThreshold, 0), "setAreaThreshold(areaThreshold) -> None\n."},
| 17509 | {"setDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setDelta, 0), "setDelta(delta) -> None\n."}, |  | 17509 | {"setDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setDelta, 0), "setDelta(delta) -> None\n."},
| 17510 | {"setEdgeBlurSize", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setEdgeBlurSize, 0), "setEdgeBlurSize(edge_blur_size) -> None\n."}, |  | 17510 | {"setEdgeBlurSize", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setEdgeBlurSize, 0), "setEdgeBlurSize(edge_blur_size) -> None\n."},
| 17511 | {"setMaxArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMaxArea, 0), "setMaxArea(maxArea) -> None\n."}, |  | 17511 | {"setMaxArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMaxArea, 0), "setMaxArea(maxArea) -> None\n."},
| 17512 | {"setMaxEvolution", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMaxEvolution, 0), "setMaxEvolution(maxEvolution) -> None\n."}, |  | 17512 | {"setMaxEvolution", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMaxEvolution, 0), "setMaxEvolution(maxEvolution) -> None\n."},
| 17513 | {"setMaxVariation", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMaxVariation, 0), "setMaxVariation(maxVariation) -> None\n."}, |  | 17513 | {"setMaxVariation", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMaxVariation, 0), "setMaxVariation(maxVariation) -> None\n."},
| 17514 | {"setMinArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMinArea, 0), "setMinArea(minArea) -> None\n."}, |  | 17514 | {"setMinArea", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMinArea, 0), "setMinArea(minArea) -> None\n."},
| 17515 | {"setMinDiversity", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMinDiversity, 0), "setMinDiversity(minDiversity) -> None\n."}, |  | 17515 | {"setMinDiversity", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMinDiversity, 0), "setMinDiversity(minDiversity) -> None\n."},
| 17516 | {"setMinMargin", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMinMargin, 0), "setMinMargin(min_margin) -> None\n."}, |  | 17516 | {"setMinMargin", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setMinMargin, 0), "setMinMargin(min_margin) -> None\n."},
| 17517 | {"setPass2Only", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setPass2Only, 0), "setPass2Only(f) -> None\n."}, |  | 17517 | {"setPass2Only", CV_PY_FN_WITH_KW_(pyopencv_cv_MSER_setPass2Only, 0), "setPass2Only(f) -> None\n."},
| 17518 |  |  | 17518 |
| 17519 | {NULL, NULL} |  | 17519 | {NULL, NULL}
| 17520 | }; |  | 17520 | };
| 17521 |  |  | 17521 |
| 17522 | // Converter (MSER) |  | 17522 | // Converter (MSER)
| 17523 |  |  | 17523 |
| 17524 | template<> |  | 17524 | template<>
| 17525 | struct PyOpenCV_Converter< Ptr<cv::MSER> > |  | 17525 | struct PyOpenCV_Converter< Ptr<cv::MSER> >
| 17526 | { |  | 17526 | {
| 17527 | static PyObject* from(const Ptr<cv::MSER>& r) |  | 17527 | static PyObject* from(const Ptr<cv::MSER>& r)
| 17528 | { |  | 17528 | {
| 17529 | return pyopencv_MSER_Instance(r); |  | 17529 | return pyopencv_MSER_Instance(r);
| 17530 | } |  | 17530 | }
| 17531 | static bool to(PyObject* src, Ptr<cv::MSER>& dst, const ArgInfo& info) |  | 17531 | static bool to(PyObject* src, Ptr<cv::MSER>& dst, const ArgInfo& info)
| 17532 | { |  | 17532 | {
| 17533 | if(!src || src == Py_None) |  | 17533 | if(!src || src == Py_None)
| 17534 | return true; |  | 17534 | return true;
| 17535 | Ptr<cv::MSER> * dst_; |  | 17535 | Ptr<cv::MSER> * dst_;
| 17536 | if (pyopencv_MSER_getp(src, dst_)) |  | 17536 | if (pyopencv_MSER_getp(src, dst_))
| 17537 | { |  | 17537 | {
| 17538 | dst = *dst_; |  | 17538 | dst = *dst_;
| 17539 | return true; |  | 17539 | return true;
| 17540 | } |  | 17540 | }
| 17541 |  |  | 17541 |
| 17542 | failmsg("Expected Ptr<cv::MSER> for argument '%s'", info.name); |  | 17542 | failmsg("Expected Ptr<cv::MSER> for argument '%s'", info.name);
| 17543 | return false; |  | 17543 | return false;
| 17544 | } |  | 17544 | }
| 17545 | }; |  | 17545 | };
| 17546 |  |  | 17546 |
| 17547 | //================================================================================ |  | 17547 | //================================================================================
| 17548 | // MergeDebevec (Generic) |  | 17548 | // MergeDebevec (Generic)
| 17549 | //================================================================================ |  | 17549 | //================================================================================
| 17550 |  |  | 17550 |
| 17551 | // GetSet (MergeDebevec) |  | 17551 | // GetSet (MergeDebevec)
| 17552 |  |  | 17552 |
| 17553 |  |  | 17553 |
| 17554 |  |  | 17554 |
| 17555 | // Methods (MergeDebevec) |  | 17555 | // Methods (MergeDebevec)
| 17556 |  |  | 17556 |
| 17557 | static PyObject* pyopencv_cv_MergeDebevec_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17557 | static PyObject* pyopencv_cv_MergeDebevec_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 17558 | { |  | 17558 | {
| 17559 | using namespace cv; |  | 17559 | using namespace cv;
| 17560 |  |  | 17560 |
| 17561 |  |  | 17561 |
| 17562 | Ptr<cv::MergeDebevec> * self1 = 0; |  | 17562 | Ptr<cv::MergeDebevec> * self1 = 0;
| 17563 | if (!pyopencv_MergeDebevec_getp(self, self1)) |  | 17563 | if (!pyopencv_MergeDebevec_getp(self, self1))
| 17564 | return failmsgp("Incorrect type of self (must be 'MergeDebevec' or its derivative)"); |  | 17564 | return failmsgp("Incorrect type of self (must be 'MergeDebevec' or its derivative)");
| 17565 | Ptr<cv::MergeDebevec> _self_ = *(self1); |  | 17565 | Ptr<cv::MergeDebevec> _self_ = *(self1);
| 17566 | pyPrepareArgumentConversionErrorsStorage(4); |  | 17566 | pyPrepareArgumentConversionErrorsStorage(4);
| 17567 |  |  | 17567 |
| 17568 | { |  | 17568 | {
| 17569 | PyObject* pyobj_src = NULL; |  | 17569 | PyObject* pyobj_src = NULL;
| 17570 | vector_Mat src; |  | 17570 | vector_Mat src;
| 17571 | PyObject* pyobj_dst = NULL; |  | 17571 | PyObject* pyobj_dst = NULL;
| 17572 | Mat dst; |  | 17572 | Mat dst;
| 17573 | PyObject* pyobj_times = NULL; |  | 17573 | PyObject* pyobj_times = NULL;
| 17574 | Mat times; |  | 17574 | Mat times;
| 17575 | PyObject* pyobj_response = NULL; |  | 17575 | PyObject* pyobj_response = NULL;
| 17576 | Mat response; |  | 17576 | Mat response;
| 17577 |  |  | 17577 |
| 17578 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 17578 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 17579 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 17579 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 17580 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17580 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17581 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17581 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17582 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 17582 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 17583 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 17583 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 17584 | { |  | 17584 | {
| 17585 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 17585 | ERRWRAP2(_self_->process(src, dst, times, response));
| 17586 | return pyopencv_from(dst); |  | 17586 | return pyopencv_from(dst);
| 17587 | } |  | 17587 | }
| 17588 |  |  | 17588 |
| 17589 |  |  | 17589 |
| 17590 | pyPopulateArgumentConversionErrors(); |  | 17590 | pyPopulateArgumentConversionErrors();
| 17591 | } |  | 17591 | }
| 17592 |  |  | 17592 |
| 17593 |  |  | 17593 |
| 17594 | { |  | 17594 | {
| 17595 | PyObject* pyobj_src = NULL; |  | 17595 | PyObject* pyobj_src = NULL;
| 17596 | vector_Mat src; |  | 17596 | vector_Mat src;
| 17597 | PyObject* pyobj_dst = NULL; |  | 17597 | PyObject* pyobj_dst = NULL;
| 17598 | Mat dst; |  | 17598 | Mat dst;
| 17599 | PyObject* pyobj_times = NULL; |  | 17599 | PyObject* pyobj_times = NULL;
| 17600 | Mat times; |  | 17600 | Mat times;
| 17601 |  |  | 17601 |
| 17602 | const char* keywords[] = { "src", "times", "dst", NULL }; |  | 17602 | const char* keywords[] = { "src", "times", "dst", NULL };
| 17603 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) && |  | 17603 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) &&
| 17604 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17604 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17605 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17605 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17606 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) ) |  | 17606 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) )
| 17607 | { |  | 17607 | {
| 17608 | ERRWRAP2(_self_->process(src, dst, times)); |  | 17608 | ERRWRAP2(_self_->process(src, dst, times));
| 17609 | return pyopencv_from(dst); |  | 17609 | return pyopencv_from(dst);
| 17610 | } |  | 17610 | }
| 17611 |  |  | 17611 |
| 17612 |  |  | 17612 |
| 17613 | pyPopulateArgumentConversionErrors(); |  | 17613 | pyPopulateArgumentConversionErrors();
| 17614 | } |  | 17614 | }
| 17615 |  |  | 17615 |
| 17616 |  |  | 17616 |
| 17617 | { |  | 17617 | {
| 17618 | PyObject* pyobj_src = NULL; |  | 17618 | PyObject* pyobj_src = NULL;
| 17619 | vector_UMat src; |  | 17619 | vector_UMat src;
| 17620 | PyObject* pyobj_dst = NULL; |  | 17620 | PyObject* pyobj_dst = NULL;
| 17621 | UMat dst; |  | 17621 | UMat dst;
| 17622 | PyObject* pyobj_times = NULL; |  | 17622 | PyObject* pyobj_times = NULL;
| 17623 | UMat times; |  | 17623 | UMat times;
| 17624 | PyObject* pyobj_response = NULL; |  | 17624 | PyObject* pyobj_response = NULL;
| 17625 | UMat response; |  | 17625 | UMat response;
| 17626 |  |  | 17626 |
| 17627 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 17627 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 17628 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 17628 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 17629 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17629 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17630 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17630 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17631 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 17631 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 17632 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 17632 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 17633 | { |  | 17633 | {
| 17634 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 17634 | ERRWRAP2(_self_->process(src, dst, times, response));
| 17635 | return pyopencv_from(dst); |  | 17635 | return pyopencv_from(dst);
| 17636 | } |  | 17636 | }
| 17637 |  |  | 17637 |
| 17638 |  |  | 17638 |
| 17639 | pyPopulateArgumentConversionErrors(); |  | 17639 | pyPopulateArgumentConversionErrors();
| 17640 | } |  | 17640 | }
| 17641 |  |  | 17641 |
| 17642 |  |  | 17642 |
| 17643 | { |  | 17643 | {
| 17644 | PyObject* pyobj_src = NULL; |  | 17644 | PyObject* pyobj_src = NULL;
| 17645 | vector_UMat src; |  | 17645 | vector_UMat src;
| 17646 | PyObject* pyobj_dst = NULL; |  | 17646 | PyObject* pyobj_dst = NULL;
| 17647 | UMat dst; |  | 17647 | UMat dst;
| 17648 | PyObject* pyobj_times = NULL; |  | 17648 | PyObject* pyobj_times = NULL;
| 17649 | UMat times; |  | 17649 | UMat times;
| 17650 |  |  | 17650 |
| 17651 | const char* keywords[] = { "src", "times", "dst", NULL }; |  | 17651 | const char* keywords[] = { "src", "times", "dst", NULL };
| 17652 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) && |  | 17652 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeDebevec.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) &&
| 17653 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17653 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17654 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17654 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17655 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) ) |  | 17655 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) )
| 17656 | { |  | 17656 | {
| 17657 | ERRWRAP2(_self_->process(src, dst, times)); |  | 17657 | ERRWRAP2(_self_->process(src, dst, times));
| 17658 | return pyopencv_from(dst); |  | 17658 | return pyopencv_from(dst);
| 17659 | } |  | 17659 | }
| 17660 |  |  | 17660 |
| 17661 |  |  | 17661 |
| 17662 | pyPopulateArgumentConversionErrors(); |  | 17662 | pyPopulateArgumentConversionErrors();
| 17663 | } |  | 17663 | }
| 17664 | pyRaiseCVOverloadException("process"); |  | 17664 | pyRaiseCVOverloadException("process");
| 17665 |  |  | 17665 |
| 17666 | return NULL; |  | 17666 | return NULL;
| 17667 | } |  | 17667 | }
| 17668 |  |  | 17668 |
| 17669 |  |  | 17669 |
| 17670 |  |  | 17670 |
| 17671 | // Tables (MergeDebevec) |  | 17671 | // Tables (MergeDebevec)
| 17672 |  |  | 17672 |
| 17673 | static PyGetSetDef pyopencv_MergeDebevec_getseters[] = |  | 17673 | static PyGetSetDef pyopencv_MergeDebevec_getseters[] =
| 17674 | { |  | 17674 | {
| 17675 | {NULL} /* Sentinel */ |  | 17675 | {NULL} /* Sentinel */
| 17676 | }; |  | 17676 | };
| 17677 |  |  | 17677 |
| 17678 | static PyMethodDef pyopencv_MergeDebevec_methods[] = |  | 17678 | static PyMethodDef pyopencv_MergeDebevec_methods[] =
| 17679 | { |  | 17679 | {
| 17680 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeDebevec_process, 0), "process(src, times, response[, dst]) -> dst\n. \n\n\n\nprocess(src, times[, dst]) -> dst\n."}, |  | 17680 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeDebevec_process, 0), "process(src, times, response[, dst]) -> dst\n. \n\n\n\nprocess(src, times[, dst]) -> dst\n."},
| 17681 |  |  | 17681 |
| 17682 | {NULL, NULL} |  | 17682 | {NULL, NULL}
| 17683 | }; |  | 17683 | };
| 17684 |  |  | 17684 |
| 17685 | // Converter (MergeDebevec) |  | 17685 | // Converter (MergeDebevec)
| 17686 |  |  | 17686 |
| 17687 | template<> |  | 17687 | template<>
| 17688 | struct PyOpenCV_Converter< Ptr<cv::MergeDebevec> > |  | 17688 | struct PyOpenCV_Converter< Ptr<cv::MergeDebevec> >
| 17689 | { |  | 17689 | {
| 17690 | static PyObject* from(const Ptr<cv::MergeDebevec>& r) |  | 17690 | static PyObject* from(const Ptr<cv::MergeDebevec>& r)
| 17691 | { |  | 17691 | {
| 17692 | return pyopencv_MergeDebevec_Instance(r); |  | 17692 | return pyopencv_MergeDebevec_Instance(r);
| 17693 | } |  | 17693 | }
| 17694 | static bool to(PyObject* src, Ptr<cv::MergeDebevec>& dst, const ArgInfo& info) |  | 17694 | static bool to(PyObject* src, Ptr<cv::MergeDebevec>& dst, const ArgInfo& info)
| 17695 | { |  | 17695 | {
| 17696 | if(!src || src == Py_None) |  | 17696 | if(!src || src == Py_None)
| 17697 | return true; |  | 17697 | return true;
| 17698 | Ptr<cv::MergeDebevec> * dst_; |  | 17698 | Ptr<cv::MergeDebevec> * dst_;
| 17699 | if (pyopencv_MergeDebevec_getp(src, dst_)) |  | 17699 | if (pyopencv_MergeDebevec_getp(src, dst_))
| 17700 | { |  | 17700 | {
| 17701 | dst = *dst_; |  | 17701 | dst = *dst_;
| 17702 | return true; |  | 17702 | return true;
| 17703 | } |  | 17703 | }
| 17704 |  |  | 17704 |
| 17705 | failmsg("Expected Ptr<cv::MergeDebevec> for argument '%s'", info.name); |  | 17705 | failmsg("Expected Ptr<cv::MergeDebevec> for argument '%s'", info.name);
| 17706 | return false; |  | 17706 | return false;
| 17707 | } |  | 17707 | }
| 17708 | }; |  | 17708 | };
| 17709 |  |  | 17709 |
| 17710 | //================================================================================ |  | 17710 | //================================================================================
| 17711 | // MergeExposures (Generic) |  | 17711 | // MergeExposures (Generic)
| 17712 | //================================================================================ |  | 17712 | //================================================================================
| 17713 |  |  | 17713 |
| 17714 | // GetSet (MergeExposures) |  | 17714 | // GetSet (MergeExposures)
| 17715 |  |  | 17715 |
| 17716 |  |  | 17716 |
| 17717 |  |  | 17717 |
| 17718 | // Methods (MergeExposures) |  | 17718 | // Methods (MergeExposures)
| 17719 |  |  | 17719 |
| 17720 | static PyObject* pyopencv_cv_MergeExposures_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17720 | static PyObject* pyopencv_cv_MergeExposures_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 17721 | { |  | 17721 | {
| 17722 | using namespace cv; |  | 17722 | using namespace cv;
| 17723 |  |  | 17723 |
| 17724 |  |  | 17724 |
| 17725 | Ptr<cv::MergeExposures> * self1 = 0; |  | 17725 | Ptr<cv::MergeExposures> * self1 = 0;
| 17726 | if (!pyopencv_MergeExposures_getp(self, self1)) |  | 17726 | if (!pyopencv_MergeExposures_getp(self, self1))
| 17727 | return failmsgp("Incorrect type of self (must be 'MergeExposures' or its derivative)"); |  | 17727 | return failmsgp("Incorrect type of self (must be 'MergeExposures' or its derivative)");
| 17728 | Ptr<cv::MergeExposures> _self_ = *(self1); |  | 17728 | Ptr<cv::MergeExposures> _self_ = *(self1);
| 17729 | pyPrepareArgumentConversionErrorsStorage(2); |  | 17729 | pyPrepareArgumentConversionErrorsStorage(2);
| 17730 |  |  | 17730 |
| 17731 | { |  | 17731 | {
| 17732 | PyObject* pyobj_src = NULL; |  | 17732 | PyObject* pyobj_src = NULL;
| 17733 | vector_Mat src; |  | 17733 | vector_Mat src;
| 17734 | PyObject* pyobj_dst = NULL; |  | 17734 | PyObject* pyobj_dst = NULL;
| 17735 | Mat dst; |  | 17735 | Mat dst;
| 17736 | PyObject* pyobj_times = NULL; |  | 17736 | PyObject* pyobj_times = NULL;
| 17737 | Mat times; |  | 17737 | Mat times;
| 17738 | PyObject* pyobj_response = NULL; |  | 17738 | PyObject* pyobj_response = NULL;
| 17739 | Mat response; |  | 17739 | Mat response;
| 17740 |  |  | 17740 |
| 17741 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 17741 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 17742 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeExposures.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 17742 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeExposures.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 17743 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17743 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17744 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17744 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17745 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 17745 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 17746 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 17746 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 17747 | { |  | 17747 | {
| 17748 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 17748 | ERRWRAP2(_self_->process(src, dst, times, response));
| 17749 | return pyopencv_from(dst); |  | 17749 | return pyopencv_from(dst);
| 17750 | } |  | 17750 | }
| 17751 |  |  | 17751 |
| 17752 |  |  | 17752 |
| 17753 | pyPopulateArgumentConversionErrors(); |  | 17753 | pyPopulateArgumentConversionErrors();
| 17754 | } |  | 17754 | }
| 17755 |  |  | 17755 |
| 17756 |  |  | 17756 |
| 17757 | { |  | 17757 | {
| 17758 | PyObject* pyobj_src = NULL; |  | 17758 | PyObject* pyobj_src = NULL;
| 17759 | vector_UMat src; |  | 17759 | vector_UMat src;
| 17760 | PyObject* pyobj_dst = NULL; |  | 17760 | PyObject* pyobj_dst = NULL;
| 17761 | UMat dst; |  | 17761 | UMat dst;
| 17762 | PyObject* pyobj_times = NULL; |  | 17762 | PyObject* pyobj_times = NULL;
| 17763 | UMat times; |  | 17763 | UMat times;
| 17764 | PyObject* pyobj_response = NULL; |  | 17764 | PyObject* pyobj_response = NULL;
| 17765 | UMat response; |  | 17765 | UMat response;
| 17766 |  |  | 17766 |
| 17767 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 17767 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 17768 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeExposures.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 17768 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeExposures.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 17769 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17769 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17770 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17770 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17771 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 17771 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 17772 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 17772 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 17773 | { |  | 17773 | {
| 17774 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 17774 | ERRWRAP2(_self_->process(src, dst, times, response));
| 17775 | return pyopencv_from(dst); |  | 17775 | return pyopencv_from(dst);
| 17776 | } |  | 17776 | }
| 17777 |  |  | 17777 |
| 17778 |  |  | 17778 |
| 17779 | pyPopulateArgumentConversionErrors(); |  | 17779 | pyPopulateArgumentConversionErrors();
| 17780 | } |  | 17780 | }
| 17781 | pyRaiseCVOverloadException("process"); |  | 17781 | pyRaiseCVOverloadException("process");
| 17782 |  |  | 17782 |
| 17783 | return NULL; |  | 17783 | return NULL;
| 17784 | } |  | 17784 | }
| 17785 |  |  | 17785 |
| 17786 |  |  | 17786 |
| 17787 |  |  | 17787 |
| 17788 | // Tables (MergeExposures) |  | 17788 | // Tables (MergeExposures)
| 17789 |  |  | 17789 |
| 17790 | static PyGetSetDef pyopencv_MergeExposures_getseters[] = |  | 17790 | static PyGetSetDef pyopencv_MergeExposures_getseters[] =
| 17791 | { |  | 17791 | {
| 17792 | {NULL} /* Sentinel */ |  | 17792 | {NULL} /* Sentinel */
| 17793 | }; |  | 17793 | };
| 17794 |  |  | 17794 |
| 17795 | static PyMethodDef pyopencv_MergeExposures_methods[] = |  | 17795 | static PyMethodDef pyopencv_MergeExposures_methods[] =
| 17796 | { |  | 17796 | {
| 17797 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeExposures_process, 0), "process(src, times, response[, dst]) -> dst\n. @brief Merges images.\n. \n. @param src vector of input images\n. @param dst result image\n. @param times vector of exposure time values for each image\n. @param response 256x1 matrix with inverse camera response function for each pixel value, it should\n. have the same number of channels as images."}, |  | 17797 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeExposures_process, 0), "process(src, times, response[, dst]) -> dst\n. @brief Merges images.\n. \n. @param src vector of input images\n. @param dst result image\n. @param times vector of exposure time values for each image\n. @param response 256x1 matrix with inverse camera response function for each pixel value, it should\n. have the same number of channels as images."},
| 17798 |  |  | 17798 |
| 17799 | {NULL, NULL} |  | 17799 | {NULL, NULL}
| 17800 | }; |  | 17800 | };
| 17801 |  |  | 17801 |
| 17802 | // Converter (MergeExposures) |  | 17802 | // Converter (MergeExposures)
| 17803 |  |  | 17803 |
| 17804 | template<> |  | 17804 | template<>
| 17805 | struct PyOpenCV_Converter< Ptr<cv::MergeExposures> > |  | 17805 | struct PyOpenCV_Converter< Ptr<cv::MergeExposures> >
| 17806 | { |  | 17806 | {
| 17807 | static PyObject* from(const Ptr<cv::MergeExposures>& r) |  | 17807 | static PyObject* from(const Ptr<cv::MergeExposures>& r)
| 17808 | { |  | 17808 | {
| 17809 | return pyopencv_MergeExposures_Instance(r); |  | 17809 | return pyopencv_MergeExposures_Instance(r);
| 17810 | } |  | 17810 | }
| 17811 | static bool to(PyObject* src, Ptr<cv::MergeExposures>& dst, const ArgInfo& info) |  | 17811 | static bool to(PyObject* src, Ptr<cv::MergeExposures>& dst, const ArgInfo& info)
| 17812 | { |  | 17812 | {
| 17813 | if(!src || src == Py_None) |  | 17813 | if(!src || src == Py_None)
| 17814 | return true; |  | 17814 | return true;
| 17815 | Ptr<cv::MergeExposures> * dst_; |  | 17815 | Ptr<cv::MergeExposures> * dst_;
| 17816 | if (pyopencv_MergeExposures_getp(src, dst_)) |  | 17816 | if (pyopencv_MergeExposures_getp(src, dst_))
| 17817 | { |  | 17817 | {
| 17818 | dst = *dst_; |  | 17818 | dst = *dst_;
| 17819 | return true; |  | 17819 | return true;
| 17820 | } |  | 17820 | }
| 17821 |  |  | 17821 |
| 17822 | failmsg("Expected Ptr<cv::MergeExposures> for argument '%s'", info.name); |  | 17822 | failmsg("Expected Ptr<cv::MergeExposures> for argument '%s'", info.name);
| 17823 | return false; |  | 17823 | return false;
| 17824 | } |  | 17824 | }
| 17825 | }; |  | 17825 | };
| 17826 |  |  | 17826 |
| 17827 | //================================================================================ |  | 17827 | //================================================================================
| 17828 | // MergeMertens (Generic) |  | 17828 | // MergeMertens (Generic)
| 17829 | //================================================================================ |  | 17829 | //================================================================================
| 17830 |  |  | 17830 |
| 17831 | // GetSet (MergeMertens) |  | 17831 | // GetSet (MergeMertens)
| 17832 |  |  | 17832 |
| 17833 |  |  | 17833 |
| 17834 |  |  | 17834 |
| 17835 | // Methods (MergeMertens) |  | 17835 | // Methods (MergeMertens)
| 17836 |  |  | 17836 |
| 17837 | static PyObject* pyopencv_cv_MergeMertens_getContrastWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17837 | static PyObject* pyopencv_cv_MergeMertens_getContrastWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 17838 | { |  | 17838 | {
| 17839 | using namespace cv; |  | 17839 | using namespace cv;
| 17840 |  |  | 17840 |
| 17841 |  |  | 17841 |
| 17842 | Ptr<cv::MergeMertens> * self1 = 0; |  | 17842 | Ptr<cv::MergeMertens> * self1 = 0;
| 17843 | if (!pyopencv_MergeMertens_getp(self, self1)) |  | 17843 | if (!pyopencv_MergeMertens_getp(self, self1))
| 17844 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)"); |  | 17844 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)");
| 17845 | Ptr<cv::MergeMertens> _self_ = *(self1); |  | 17845 | Ptr<cv::MergeMertens> _self_ = *(self1);
| 17846 | float retval; |  | 17846 | float retval;
| 17847 |  |  | 17847 |
| 17848 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17848 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17849 | { |  | 17849 | {
| 17850 | ERRWRAP2(retval = _self_->getContrastWeight()); |  | 17850 | ERRWRAP2(retval = _self_->getContrastWeight());
| 17851 | return pyopencv_from(retval); |  | 17851 | return pyopencv_from(retval);
| 17852 | } |  | 17852 | }
| 17853 |  |  | 17853 |
| 17854 | return NULL; |  | 17854 | return NULL;
| 17855 | } |  | 17855 | }
| 17856 |  |  | 17856 |
| 17857 | static PyObject* pyopencv_cv_MergeMertens_getExposureWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17857 | static PyObject* pyopencv_cv_MergeMertens_getExposureWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 17858 | { |  | 17858 | {
| 17859 | using namespace cv; |  | 17859 | using namespace cv;
| 17860 |  |  | 17860 |
| 17861 |  |  | 17861 |
| 17862 | Ptr<cv::MergeMertens> * self1 = 0; |  | 17862 | Ptr<cv::MergeMertens> * self1 = 0;
| 17863 | if (!pyopencv_MergeMertens_getp(self, self1)) |  | 17863 | if (!pyopencv_MergeMertens_getp(self, self1))
| 17864 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)"); |  | 17864 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)");
| 17865 | Ptr<cv::MergeMertens> _self_ = *(self1); |  | 17865 | Ptr<cv::MergeMertens> _self_ = *(self1);
| 17866 | float retval; |  | 17866 | float retval;
| 17867 |  |  | 17867 |
| 17868 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17868 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17869 | { |  | 17869 | {
| 17870 | ERRWRAP2(retval = _self_->getExposureWeight()); |  | 17870 | ERRWRAP2(retval = _self_->getExposureWeight());
| 17871 | return pyopencv_from(retval); |  | 17871 | return pyopencv_from(retval);
| 17872 | } |  | 17872 | }
| 17873 |  |  | 17873 |
| 17874 | return NULL; |  | 17874 | return NULL;
| 17875 | } |  | 17875 | }
| 17876 |  |  | 17876 |
| 17877 | static PyObject* pyopencv_cv_MergeMertens_getSaturationWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17877 | static PyObject* pyopencv_cv_MergeMertens_getSaturationWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 17878 | { |  | 17878 | {
| 17879 | using namespace cv; |  | 17879 | using namespace cv;
| 17880 |  |  | 17880 |
| 17881 |  |  | 17881 |
| 17882 | Ptr<cv::MergeMertens> * self1 = 0; |  | 17882 | Ptr<cv::MergeMertens> * self1 = 0;
| 17883 | if (!pyopencv_MergeMertens_getp(self, self1)) |  | 17883 | if (!pyopencv_MergeMertens_getp(self, self1))
| 17884 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)"); |  | 17884 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)");
| 17885 | Ptr<cv::MergeMertens> _self_ = *(self1); |  | 17885 | Ptr<cv::MergeMertens> _self_ = *(self1);
| 17886 | float retval; |  | 17886 | float retval;
| 17887 |  |  | 17887 |
| 17888 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 17888 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 17889 | { |  | 17889 | {
| 17890 | ERRWRAP2(retval = _self_->getSaturationWeight()); |  | 17890 | ERRWRAP2(retval = _self_->getSaturationWeight());
| 17891 | return pyopencv_from(retval); |  | 17891 | return pyopencv_from(retval);
| 17892 | } |  | 17892 | }
| 17893 |  |  | 17893 |
| 17894 | return NULL; |  | 17894 | return NULL;
| 17895 | } |  | 17895 | }
| 17896 |  |  | 17896 |
| 17897 | static PyObject* pyopencv_cv_MergeMertens_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 17897 | static PyObject* pyopencv_cv_MergeMertens_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 17898 | { |  | 17898 | {
| 17899 | using namespace cv; |  | 17899 | using namespace cv;
| 17900 |  |  | 17900 |
| 17901 |  |  | 17901 |
| 17902 | Ptr<cv::MergeMertens> * self1 = 0; |  | 17902 | Ptr<cv::MergeMertens> * self1 = 0;
| 17903 | if (!pyopencv_MergeMertens_getp(self, self1)) |  | 17903 | if (!pyopencv_MergeMertens_getp(self, self1))
| 17904 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)"); |  | 17904 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)");
| 17905 | Ptr<cv::MergeMertens> _self_ = *(self1); |  | 17905 | Ptr<cv::MergeMertens> _self_ = *(self1);
| 17906 | pyPrepareArgumentConversionErrorsStorage(4); |  | 17906 | pyPrepareArgumentConversionErrorsStorage(4);
| 17907 |  |  | 17907 |
| 17908 | { |  | 17908 | {
| 17909 | PyObject* pyobj_src = NULL; |  | 17909 | PyObject* pyobj_src = NULL;
| 17910 | vector_Mat src; |  | 17910 | vector_Mat src;
| 17911 | PyObject* pyobj_dst = NULL; |  | 17911 | PyObject* pyobj_dst = NULL;
| 17912 | Mat dst; |  | 17912 | Mat dst;
| 17913 | PyObject* pyobj_times = NULL; |  | 17913 | PyObject* pyobj_times = NULL;
| 17914 | Mat times; |  | 17914 | Mat times;
| 17915 | PyObject* pyobj_response = NULL; |  | 17915 | PyObject* pyobj_response = NULL;
| 17916 | Mat response; |  | 17916 | Mat response;
| 17917 |  |  | 17917 |
| 17918 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 17918 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 17919 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 17919 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 17920 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17920 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17921 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17921 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17922 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 17922 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 17923 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 17923 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 17924 | { |  | 17924 | {
| 17925 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 17925 | ERRWRAP2(_self_->process(src, dst, times, response));
| 17926 | return pyopencv_from(dst); |  | 17926 | return pyopencv_from(dst);
| 17927 | } |  | 17927 | }
| 17928 |  |  | 17928 |
| 17929 |  |  | 17929 |
| 17930 | pyPopulateArgumentConversionErrors(); |  | 17930 | pyPopulateArgumentConversionErrors();
| 17931 | } |  | 17931 | }
| 17932 |  |  | 17932 |
| 17933 |  |  | 17933 |
| 17934 | { |  | 17934 | {
| 17935 | PyObject* pyobj_src = NULL; |  | 17935 | PyObject* pyobj_src = NULL;
| 17936 | vector_Mat src; |  | 17936 | vector_Mat src;
| 17937 | PyObject* pyobj_dst = NULL; |  | 17937 | PyObject* pyobj_dst = NULL;
| 17938 | Mat dst; |  | 17938 | Mat dst;
| 17939 |  |  | 17939 |
| 17940 | const char* keywords[] = { "src", "dst", NULL }; |  | 17940 | const char* keywords[] = { "src", "dst", NULL };
| 17941 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 17941 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 17942 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17942 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17943 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 17943 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 17944 | { |  | 17944 | {
| 17945 | ERRWRAP2(_self_->process(src, dst)); |  | 17945 | ERRWRAP2(_self_->process(src, dst));
| 17946 | return pyopencv_from(dst); |  | 17946 | return pyopencv_from(dst);
| 17947 | } |  | 17947 | }
| 17948 |  |  | 17948 |
| 17949 |  |  | 17949 |
| 17950 | pyPopulateArgumentConversionErrors(); |  | 17950 | pyPopulateArgumentConversionErrors();
| 17951 | } |  | 17951 | }
| 17952 |  |  | 17952 |
| 17953 |  |  | 17953 |
| 17954 | { |  | 17954 | {
| 17955 | PyObject* pyobj_src = NULL; |  | 17955 | PyObject* pyobj_src = NULL;
| 17956 | vector_UMat src; |  | 17956 | vector_UMat src;
| 17957 | PyObject* pyobj_dst = NULL; |  | 17957 | PyObject* pyobj_dst = NULL;
| 17958 | UMat dst; |  | 17958 | UMat dst;
| 17959 | PyObject* pyobj_times = NULL; |  | 17959 | PyObject* pyobj_times = NULL;
| 17960 | UMat times; |  | 17960 | UMat times;
| 17961 | PyObject* pyobj_response = NULL; |  | 17961 | PyObject* pyobj_response = NULL;
| 17962 | UMat response; |  | 17962 | UMat response;
| 17963 |  |  | 17963 |
| 17964 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 17964 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 17965 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 17965 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 17966 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17966 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17967 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 17967 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 17968 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 17968 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 17969 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 17969 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 17970 | { |  | 17970 | {
| 17971 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 17971 | ERRWRAP2(_self_->process(src, dst, times, response));
| 17972 | return pyopencv_from(dst); |  | 17972 | return pyopencv_from(dst);
| 17973 | } |  | 17973 | }
| 17974 |  |  | 17974 |
| 17975 |  |  | 17975 |
| 17976 | pyPopulateArgumentConversionErrors(); |  | 17976 | pyPopulateArgumentConversionErrors();
| 17977 | } |  | 17977 | }
| 17978 |  |  | 17978 |
| 17979 |  |  | 17979 |
| 17980 | { |  | 17980 | {
| 17981 | PyObject* pyobj_src = NULL; |  | 17981 | PyObject* pyobj_src = NULL;
| 17982 | vector_UMat src; |  | 17982 | vector_UMat src;
| 17983 | PyObject* pyobj_dst = NULL; |  | 17983 | PyObject* pyobj_dst = NULL;
| 17984 | UMat dst; |  | 17984 | UMat dst;
| 17985 |  |  | 17985 |
| 17986 | const char* keywords[] = { "src", "dst", NULL }; |  | 17986 | const char* keywords[] = { "src", "dst", NULL };
| 17987 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 17987 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:MergeMertens.process", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 17988 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 17988 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 17989 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 17989 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 17990 | { |  | 17990 | {
| 17991 | ERRWRAP2(_self_->process(src, dst)); |  | 17991 | ERRWRAP2(_self_->process(src, dst));
| 17992 | return pyopencv_from(dst); |  | 17992 | return pyopencv_from(dst);
| 17993 | } |  | 17993 | }
| 17994 |  |  | 17994 |
| 17995 |  |  | 17995 |
| 17996 | pyPopulateArgumentConversionErrors(); |  | 17996 | pyPopulateArgumentConversionErrors();
| 17997 | } |  | 17997 | }
| 17998 | pyRaiseCVOverloadException("process"); |  | 17998 | pyRaiseCVOverloadException("process");
| 17999 |  |  | 17999 |
| 18000 | return NULL; |  | 18000 | return NULL;
| 18001 | } |  | 18001 | }
| 18002 |  |  | 18002 |
| 18003 | static PyObject* pyopencv_cv_MergeMertens_setContrastWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18003 | static PyObject* pyopencv_cv_MergeMertens_setContrastWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 18004 | { |  | 18004 | {
| 18005 | using namespace cv; |  | 18005 | using namespace cv;
| 18006 |  |  | 18006 |
| 18007 |  |  | 18007 |
| 18008 | Ptr<cv::MergeMertens> * self1 = 0; |  | 18008 | Ptr<cv::MergeMertens> * self1 = 0;
| 18009 | if (!pyopencv_MergeMertens_getp(self, self1)) |  | 18009 | if (!pyopencv_MergeMertens_getp(self, self1))
| 18010 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)"); |  | 18010 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)");
| 18011 | Ptr<cv::MergeMertens> _self_ = *(self1); |  | 18011 | Ptr<cv::MergeMertens> _self_ = *(self1);
| 18012 | PyObject* pyobj_contrast_weiht = NULL; |  | 18012 | PyObject* pyobj_contrast_weiht = NULL;
| 18013 | float contrast_weiht=0.f; |  | 18013 | float contrast_weiht=0.f;
| 18014 |  |  | 18014 |
| 18015 | const char* keywords[] = { "contrast_weiht", NULL }; |  | 18015 | const char* keywords[] = { "contrast_weiht", NULL };
| 18016 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MergeMertens.setContrastWeight", (char**)keywords, &pyobj_contrast_weiht) && |  | 18016 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MergeMertens.setContrastWeight", (char**)keywords, &pyobj_contrast_weiht) &&
| 18017 | pyopencv_to_safe(pyobj_contrast_weiht, contrast_weiht, ArgInfo("contrast_weiht", 0)) ) |  | 18017 | pyopencv_to_safe(pyobj_contrast_weiht, contrast_weiht, ArgInfo("contrast_weiht", 0)) )
| 18018 | { |  | 18018 | {
| 18019 | ERRWRAP2(_self_->setContrastWeight(contrast_weiht)); |  | 18019 | ERRWRAP2(_self_->setContrastWeight(contrast_weiht));
| 18020 | Py_RETURN_NONE; |  | 18020 | Py_RETURN_NONE;
| 18021 | } |  | 18021 | }
| 18022 |  |  | 18022 |
| 18023 | return NULL; |  | 18023 | return NULL;
| 18024 | } |  | 18024 | }
| 18025 |  |  | 18025 |
| 18026 | static PyObject* pyopencv_cv_MergeMertens_setExposureWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18026 | static PyObject* pyopencv_cv_MergeMertens_setExposureWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 18027 | { |  | 18027 | {
| 18028 | using namespace cv; |  | 18028 | using namespace cv;
| 18029 |  |  | 18029 |
| 18030 |  |  | 18030 |
| 18031 | Ptr<cv::MergeMertens> * self1 = 0; |  | 18031 | Ptr<cv::MergeMertens> * self1 = 0;
| 18032 | if (!pyopencv_MergeMertens_getp(self, self1)) |  | 18032 | if (!pyopencv_MergeMertens_getp(self, self1))
| 18033 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)"); |  | 18033 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)");
| 18034 | Ptr<cv::MergeMertens> _self_ = *(self1); |  | 18034 | Ptr<cv::MergeMertens> _self_ = *(self1);
| 18035 | PyObject* pyobj_exposure_weight = NULL; |  | 18035 | PyObject* pyobj_exposure_weight = NULL;
| 18036 | float exposure_weight=0.f; |  | 18036 | float exposure_weight=0.f;
| 18037 |  |  | 18037 |
| 18038 | const char* keywords[] = { "exposure_weight", NULL }; |  | 18038 | const char* keywords[] = { "exposure_weight", NULL };
| 18039 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MergeMertens.setExposureWeight", (char**)keywords, &pyobj_exposure_weight) && |  | 18039 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MergeMertens.setExposureWeight", (char**)keywords, &pyobj_exposure_weight) &&
| 18040 | pyopencv_to_safe(pyobj_exposure_weight, exposure_weight, ArgInfo("exposure_weight", 0)) ) |  | 18040 | pyopencv_to_safe(pyobj_exposure_weight, exposure_weight, ArgInfo("exposure_weight", 0)) )
| 18041 | { |  | 18041 | {
| 18042 | ERRWRAP2(_self_->setExposureWeight(exposure_weight)); |  | 18042 | ERRWRAP2(_self_->setExposureWeight(exposure_weight));
| 18043 | Py_RETURN_NONE; |  | 18043 | Py_RETURN_NONE;
| 18044 | } |  | 18044 | }
| 18045 |  |  | 18045 |
| 18046 | return NULL; |  | 18046 | return NULL;
| 18047 | } |  | 18047 | }
| 18048 |  |  | 18048 |
| 18049 | static PyObject* pyopencv_cv_MergeMertens_setSaturationWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18049 | static PyObject* pyopencv_cv_MergeMertens_setSaturationWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 18050 | { |  | 18050 | {
| 18051 | using namespace cv; |  | 18051 | using namespace cv;
| 18052 |  |  | 18052 |
| 18053 |  |  | 18053 |
| 18054 | Ptr<cv::MergeMertens> * self1 = 0; |  | 18054 | Ptr<cv::MergeMertens> * self1 = 0;
| 18055 | if (!pyopencv_MergeMertens_getp(self, self1)) |  | 18055 | if (!pyopencv_MergeMertens_getp(self, self1))
| 18056 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)"); |  | 18056 | return failmsgp("Incorrect type of self (must be 'MergeMertens' or its derivative)");
| 18057 | Ptr<cv::MergeMertens> _self_ = *(self1); |  | 18057 | Ptr<cv::MergeMertens> _self_ = *(self1);
| 18058 | PyObject* pyobj_saturation_weight = NULL; |  | 18058 | PyObject* pyobj_saturation_weight = NULL;
| 18059 | float saturation_weight=0.f; |  | 18059 | float saturation_weight=0.f;
| 18060 |  |  | 18060 |
| 18061 | const char* keywords[] = { "saturation_weight", NULL }; |  | 18061 | const char* keywords[] = { "saturation_weight", NULL };
| 18062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MergeMertens.setSaturationWeight", (char**)keywords, &pyobj_saturation_weight) && |  | 18062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MergeMertens.setSaturationWeight", (char**)keywords, &pyobj_saturation_weight) &&
| 18063 | pyopencv_to_safe(pyobj_saturation_weight, saturation_weight, ArgInfo("saturation_weight", 0)) ) |  | 18063 | pyopencv_to_safe(pyobj_saturation_weight, saturation_weight, ArgInfo("saturation_weight", 0)) )
| 18064 | { |  | 18064 | {
| 18065 | ERRWRAP2(_self_->setSaturationWeight(saturation_weight)); |  | 18065 | ERRWRAP2(_self_->setSaturationWeight(saturation_weight));
| 18066 | Py_RETURN_NONE; |  | 18066 | Py_RETURN_NONE;
| 18067 | } |  | 18067 | }
| 18068 |  |  | 18068 |
| 18069 | return NULL; |  | 18069 | return NULL;
| 18070 | } |  | 18070 | }
| 18071 |  |  | 18071 |
| 18072 |  |  | 18072 |
| 18073 |  |  | 18073 |
| 18074 | // Tables (MergeMertens) |  | 18074 | // Tables (MergeMertens)
| 18075 |  |  | 18075 |
| 18076 | static PyGetSetDef pyopencv_MergeMertens_getseters[] = |  | 18076 | static PyGetSetDef pyopencv_MergeMertens_getseters[] =
| 18077 | { |  | 18077 | {
| 18078 | {NULL} /* Sentinel */ |  | 18078 | {NULL} /* Sentinel */
| 18079 | }; |  | 18079 | };
| 18080 |  |  | 18080 |
| 18081 | static PyMethodDef pyopencv_MergeMertens_methods[] = |  | 18081 | static PyMethodDef pyopencv_MergeMertens_methods[] =
| 18082 | { |  | 18082 | {
| 18083 | {"getContrastWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_getContrastWeight, 0), "getContrastWeight() -> retval\n."}, |  | 18083 | {"getContrastWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_getContrastWeight, 0), "getContrastWeight() -> retval\n."},
| 18084 | {"getExposureWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_getExposureWeight, 0), "getExposureWeight() -> retval\n."}, |  | 18084 | {"getExposureWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_getExposureWeight, 0), "getExposureWeight() -> retval\n."},
| 18085 | {"getSaturationWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_getSaturationWeight, 0), "getSaturationWeight() -> retval\n."}, |  | 18085 | {"getSaturationWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_getSaturationWeight, 0), "getSaturationWeight() -> retval\n."},
| 18086 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_process, 0), "process(src, times, response[, dst]) -> dst\n. \n\n\n\nprocess(src[, dst]) -> dst\n. @brief Short version of process, that doesn't take extra arguments.\n. \n. @param src vector of input images\n. @param dst result image"}, |  | 18086 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_process, 0), "process(src, times, response[, dst]) -> dst\n. \n\n\n\nprocess(src[, dst]) -> dst\n. @brief Short version of process, that doesn't take extra arguments.\n. \n. @param src vector of input images\n. @param dst result image"},
| 18087 | {"setContrastWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_setContrastWeight, 0), "setContrastWeight(contrast_weiht) -> None\n."}, |  | 18087 | {"setContrastWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_setContrastWeight, 0), "setContrastWeight(contrast_weiht) -> None\n."},
| 18088 | {"setExposureWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_setExposureWeight, 0), "setExposureWeight(exposure_weight) -> None\n."}, |  | 18088 | {"setExposureWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_setExposureWeight, 0), "setExposureWeight(exposure_weight) -> None\n."},
| 18089 | {"setSaturationWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_setSaturationWeight, 0), "setSaturationWeight(saturation_weight) -> None\n."}, |  | 18089 | {"setSaturationWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeMertens_setSaturationWeight, 0), "setSaturationWeight(saturation_weight) -> None\n."},
| 18090 |  |  | 18090 |
| 18091 | {NULL, NULL} |  | 18091 | {NULL, NULL}
| 18092 | }; |  | 18092 | };
| 18093 |  |  | 18093 |
| 18094 | // Converter (MergeMertens) |  | 18094 | // Converter (MergeMertens)
| 18095 |  |  | 18095 |
| 18096 | template<> |  | 18096 | template<>
| 18097 | struct PyOpenCV_Converter< Ptr<cv::MergeMertens> > |  | 18097 | struct PyOpenCV_Converter< Ptr<cv::MergeMertens> >
| 18098 | { |  | 18098 | {
| 18099 | static PyObject* from(const Ptr<cv::MergeMertens>& r) |  | 18099 | static PyObject* from(const Ptr<cv::MergeMertens>& r)
| 18100 | { |  | 18100 | {
| 18101 | return pyopencv_MergeMertens_Instance(r); |  | 18101 | return pyopencv_MergeMertens_Instance(r);
| 18102 | } |  | 18102 | }
| 18103 | static bool to(PyObject* src, Ptr<cv::MergeMertens>& dst, const ArgInfo& info) |  | 18103 | static bool to(PyObject* src, Ptr<cv::MergeMertens>& dst, const ArgInfo& info)
| 18104 | { |  | 18104 | {
| 18105 | if(!src || src == Py_None) |  | 18105 | if(!src || src == Py_None)
| 18106 | return true; |  | 18106 | return true;
| 18107 | Ptr<cv::MergeMertens> * dst_; |  | 18107 | Ptr<cv::MergeMertens> * dst_;
| 18108 | if (pyopencv_MergeMertens_getp(src, dst_)) |  | 18108 | if (pyopencv_MergeMertens_getp(src, dst_))
| 18109 | { |  | 18109 | {
| 18110 | dst = *dst_; |  | 18110 | dst = *dst_;
| 18111 | return true; |  | 18111 | return true;
| 18112 | } |  | 18112 | }
| 18113 |  |  | 18113 |
| 18114 | failmsg("Expected Ptr<cv::MergeMertens> for argument '%s'", info.name); |  | 18114 | failmsg("Expected Ptr<cv::MergeMertens> for argument '%s'", info.name);
| 18115 | return false; |  | 18115 | return false;
| 18116 | } |  | 18116 | }
| 18117 | }; |  | 18117 | };
| 18118 |  |  | 18118 |
| 18119 | //================================================================================ |  | 18119 | //================================================================================
| 18120 | // MergeRobertson (Generic) |  | 18120 | // MergeRobertson (Generic)
| 18121 | //================================================================================ |  | 18121 | //================================================================================
| 18122 |  |  | 18122 |
| 18123 | // GetSet (MergeRobertson) |  | 18123 | // GetSet (MergeRobertson)
| 18124 |  |  | 18124 |
| 18125 |  |  | 18125 |
| 18126 |  |  | 18126 |
| 18127 | // Methods (MergeRobertson) |  | 18127 | // Methods (MergeRobertson)
| 18128 |  |  | 18128 |
| 18129 | static PyObject* pyopencv_cv_MergeRobertson_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18129 | static PyObject* pyopencv_cv_MergeRobertson_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 18130 | { |  | 18130 | {
| 18131 | using namespace cv; |  | 18131 | using namespace cv;
| 18132 |  |  | 18132 |
| 18133 |  |  | 18133 |
| 18134 | Ptr<cv::MergeRobertson> * self1 = 0; |  | 18134 | Ptr<cv::MergeRobertson> * self1 = 0;
| 18135 | if (!pyopencv_MergeRobertson_getp(self, self1)) |  | 18135 | if (!pyopencv_MergeRobertson_getp(self, self1))
| 18136 | return failmsgp("Incorrect type of self (must be 'MergeRobertson' or its derivative)"); |  | 18136 | return failmsgp("Incorrect type of self (must be 'MergeRobertson' or its derivative)");
| 18137 | Ptr<cv::MergeRobertson> _self_ = *(self1); |  | 18137 | Ptr<cv::MergeRobertson> _self_ = *(self1);
| 18138 | pyPrepareArgumentConversionErrorsStorage(4); |  | 18138 | pyPrepareArgumentConversionErrorsStorage(4);
| 18139 |  |  | 18139 |
| 18140 | { |  | 18140 | {
| 18141 | PyObject* pyobj_src = NULL; |  | 18141 | PyObject* pyobj_src = NULL;
| 18142 | vector_Mat src; |  | 18142 | vector_Mat src;
| 18143 | PyObject* pyobj_dst = NULL; |  | 18143 | PyObject* pyobj_dst = NULL;
| 18144 | Mat dst; |  | 18144 | Mat dst;
| 18145 | PyObject* pyobj_times = NULL; |  | 18145 | PyObject* pyobj_times = NULL;
| 18146 | Mat times; |  | 18146 | Mat times;
| 18147 | PyObject* pyobj_response = NULL; |  | 18147 | PyObject* pyobj_response = NULL;
| 18148 | Mat response; |  | 18148 | Mat response;
| 18149 |  |  | 18149 |
| 18150 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 18150 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 18151 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 18151 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 18152 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 18152 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 18153 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 18153 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 18154 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 18154 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 18155 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 18155 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 18156 | { |  | 18156 | {
| 18157 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 18157 | ERRWRAP2(_self_->process(src, dst, times, response));
| 18158 | return pyopencv_from(dst); |  | 18158 | return pyopencv_from(dst);
| 18159 | } |  | 18159 | }
| 18160 |  |  | 18160 |
| 18161 |  |  | 18161 |
| 18162 | pyPopulateArgumentConversionErrors(); |  | 18162 | pyPopulateArgumentConversionErrors();
| 18163 | } |  | 18163 | }
| 18164 |  |  | 18164 |
| 18165 |  |  | 18165 |
| 18166 | { |  | 18166 | {
| 18167 | PyObject* pyobj_src = NULL; |  | 18167 | PyObject* pyobj_src = NULL;
| 18168 | vector_Mat src; |  | 18168 | vector_Mat src;
| 18169 | PyObject* pyobj_dst = NULL; |  | 18169 | PyObject* pyobj_dst = NULL;
| 18170 | Mat dst; |  | 18170 | Mat dst;
| 18171 | PyObject* pyobj_times = NULL; |  | 18171 | PyObject* pyobj_times = NULL;
| 18172 | Mat times; |  | 18172 | Mat times;
| 18173 |  |  | 18173 |
| 18174 | const char* keywords[] = { "src", "times", "dst", NULL }; |  | 18174 | const char* keywords[] = { "src", "times", "dst", NULL };
| 18175 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) && |  | 18175 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) &&
| 18176 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 18176 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 18177 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 18177 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 18178 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) ) |  | 18178 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) )
| 18179 | { |  | 18179 | {
| 18180 | ERRWRAP2(_self_->process(src, dst, times)); |  | 18180 | ERRWRAP2(_self_->process(src, dst, times));
| 18181 | return pyopencv_from(dst); |  | 18181 | return pyopencv_from(dst);
| 18182 | } |  | 18182 | }
| 18183 |  |  | 18183 |
| 18184 |  |  | 18184 |
| 18185 | pyPopulateArgumentConversionErrors(); |  | 18185 | pyPopulateArgumentConversionErrors();
| 18186 | } |  | 18186 | }
| 18187 |  |  | 18187 |
| 18188 |  |  | 18188 |
| 18189 | { |  | 18189 | {
| 18190 | PyObject* pyobj_src = NULL; |  | 18190 | PyObject* pyobj_src = NULL;
| 18191 | vector_UMat src; |  | 18191 | vector_UMat src;
| 18192 | PyObject* pyobj_dst = NULL; |  | 18192 | PyObject* pyobj_dst = NULL;
| 18193 | UMat dst; |  | 18193 | UMat dst;
| 18194 | PyObject* pyobj_times = NULL; |  | 18194 | PyObject* pyobj_times = NULL;
| 18195 | UMat times; |  | 18195 | UMat times;
| 18196 | PyObject* pyobj_response = NULL; |  | 18196 | PyObject* pyobj_response = NULL;
| 18197 | UMat response; |  | 18197 | UMat response;
| 18198 |  |  | 18198 |
| 18199 | const char* keywords[] = { "src", "times", "response", "dst", NULL }; |  | 18199 | const char* keywords[] = { "src", "times", "response", "dst", NULL };
| 18200 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) && |  | 18200 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_response, &pyobj_dst) &&
| 18201 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 18201 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 18202 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 18202 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 18203 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) && |  | 18203 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) &&
| 18204 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) ) |  | 18204 | pyopencv_to_safe(pyobj_response, response, ArgInfo("response", 0)) )
| 18205 | { |  | 18205 | {
| 18206 | ERRWRAP2(_self_->process(src, dst, times, response)); |  | 18206 | ERRWRAP2(_self_->process(src, dst, times, response));
| 18207 | return pyopencv_from(dst); |  | 18207 | return pyopencv_from(dst);
| 18208 | } |  | 18208 | }
| 18209 |  |  | 18209 |
| 18210 |  |  | 18210 |
| 18211 | pyPopulateArgumentConversionErrors(); |  | 18211 | pyPopulateArgumentConversionErrors();
| 18212 | } |  | 18212 | }
| 18213 |  |  | 18213 |
| 18214 |  |  | 18214 |
| 18215 | { |  | 18215 | {
| 18216 | PyObject* pyobj_src = NULL; |  | 18216 | PyObject* pyobj_src = NULL;
| 18217 | vector_UMat src; |  | 18217 | vector_UMat src;
| 18218 | PyObject* pyobj_dst = NULL; |  | 18218 | PyObject* pyobj_dst = NULL;
| 18219 | UMat dst; |  | 18219 | UMat dst;
| 18220 | PyObject* pyobj_times = NULL; |  | 18220 | PyObject* pyobj_times = NULL;
| 18221 | UMat times; |  | 18221 | UMat times;
| 18222 |  |  | 18222 |
| 18223 | const char* keywords[] = { "src", "times", "dst", NULL }; |  | 18223 | const char* keywords[] = { "src", "times", "dst", NULL };
| 18224 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) && |  | 18224 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:MergeRobertson.process", (char**)keywords, &pyobj_src, &pyobj_times, &pyobj_dst) &&
| 18225 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 18225 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 18226 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 18226 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 18227 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) ) |  | 18227 | pyopencv_to_safe(pyobj_times, times, ArgInfo("times", 0)) )
| 18228 | { |  | 18228 | {
| 18229 | ERRWRAP2(_self_->process(src, dst, times)); |  | 18229 | ERRWRAP2(_self_->process(src, dst, times));
| 18230 | return pyopencv_from(dst); |  | 18230 | return pyopencv_from(dst);
| 18231 | } |  | 18231 | }
| 18232 |  |  | 18232 |
| 18233 |  |  | 18233 |
| 18234 | pyPopulateArgumentConversionErrors(); |  | 18234 | pyPopulateArgumentConversionErrors();
| 18235 | } |  | 18235 | }
| 18236 | pyRaiseCVOverloadException("process"); |  | 18236 | pyRaiseCVOverloadException("process");
| 18237 |  |  | 18237 |
| 18238 | return NULL; |  | 18238 | return NULL;
| 18239 | } |  | 18239 | }
| 18240 |  |  | 18240 |
| 18241 |  |  | 18241 |
| 18242 |  |  | 18242 |
| 18243 | // Tables (MergeRobertson) |  | 18243 | // Tables (MergeRobertson)
| 18244 |  |  | 18244 |
| 18245 | static PyGetSetDef pyopencv_MergeRobertson_getseters[] = |  | 18245 | static PyGetSetDef pyopencv_MergeRobertson_getseters[] =
| 18246 | { |  | 18246 | {
| 18247 | {NULL} /* Sentinel */ |  | 18247 | {NULL} /* Sentinel */
| 18248 | }; |  | 18248 | };
| 18249 |  |  | 18249 |
| 18250 | static PyMethodDef pyopencv_MergeRobertson_methods[] = |  | 18250 | static PyMethodDef pyopencv_MergeRobertson_methods[] =
| 18251 | { |  | 18251 | {
| 18252 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeRobertson_process, 0), "process(src, times, response[, dst]) -> dst\n. \n\n\n\nprocess(src, times[, dst]) -> dst\n."}, |  | 18252 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_MergeRobertson_process, 0), "process(src, times, response[, dst]) -> dst\n. \n\n\n\nprocess(src, times[, dst]) -> dst\n."},
| 18253 |  |  | 18253 |
| 18254 | {NULL, NULL} |  | 18254 | {NULL, NULL}
| 18255 | }; |  | 18255 | };
| 18256 |  |  | 18256 |
| 18257 | // Converter (MergeRobertson) |  | 18257 | // Converter (MergeRobertson)
| 18258 |  |  | 18258 |
| 18259 | template<> |  | 18259 | template<>
| 18260 | struct PyOpenCV_Converter< Ptr<cv::MergeRobertson> > |  | 18260 | struct PyOpenCV_Converter< Ptr<cv::MergeRobertson> >
| 18261 | { |  | 18261 | {
| 18262 | static PyObject* from(const Ptr<cv::MergeRobertson>& r) |  | 18262 | static PyObject* from(const Ptr<cv::MergeRobertson>& r)
| 18263 | { |  | 18263 | {
| 18264 | return pyopencv_MergeRobertson_Instance(r); |  | 18264 | return pyopencv_MergeRobertson_Instance(r);
| 18265 | } |  | 18265 | }
| 18266 | static bool to(PyObject* src, Ptr<cv::MergeRobertson>& dst, const ArgInfo& info) |  | 18266 | static bool to(PyObject* src, Ptr<cv::MergeRobertson>& dst, const ArgInfo& info)
| 18267 | { |  | 18267 | {
| 18268 | if(!src || src == Py_None) |  | 18268 | if(!src || src == Py_None)
| 18269 | return true; |  | 18269 | return true;
| 18270 | Ptr<cv::MergeRobertson> * dst_; |  | 18270 | Ptr<cv::MergeRobertson> * dst_;
| 18271 | if (pyopencv_MergeRobertson_getp(src, dst_)) |  | 18271 | if (pyopencv_MergeRobertson_getp(src, dst_))
| 18272 | { |  | 18272 | {
| 18273 | dst = *dst_; |  | 18273 | dst = *dst_;
| 18274 | return true; |  | 18274 | return true;
| 18275 | } |  | 18275 | }
| 18276 |  |  | 18276 |
| 18277 | failmsg("Expected Ptr<cv::MergeRobertson> for argument '%s'", info.name); |  | 18277 | failmsg("Expected Ptr<cv::MergeRobertson> for argument '%s'", info.name);
| 18278 | return false; |  | 18278 | return false;
| 18279 | } |  | 18279 | }
| 18280 | }; |  | 18280 | };
| 18281 |  |  | 18281 |
| 18282 | //================================================================================ |  | 18282 | //================================================================================
| 18283 | // Moments (Map) |  | 18283 | // Moments (Map)
| 18284 | //================================================================================ |  | 18284 | //================================================================================
| 18285 | static bool pyopencv_to(PyObject* src, cv::Moments& dst, const ArgInfo& info) |  | 18285 | static bool pyopencv_to(PyObject* src, cv::Moments& dst, const ArgInfo& info)
| 18286 | { |  | 18286 | {
| 18287 | PyObject* tmp; |  | 18287 | PyObject* tmp;
| 18288 | bool ok; |  | 18288 | bool ok;
| 18289 |  |  | 18289 |
| 18290 | if( PyMapping_HasKeyString(src, (char*)"m00") ) |  | 18290 | if( PyMapping_HasKeyString(src, (char*)"m00") )
| 18291 | { |  | 18291 | {
| 18292 | tmp = PyMapping_GetItemString(src, (char*)"m00"); |  | 18292 | tmp = PyMapping_GetItemString(src, (char*)"m00");
| 18293 | ok = tmp && pyopencv_to_safe(tmp, dst.m00, ArgInfo("m00", 0)); |  | 18293 | ok = tmp && pyopencv_to_safe(tmp, dst.m00, ArgInfo("m00", 0));
| 18294 | Py_DECREF(tmp); |  | 18294 | Py_DECREF(tmp);
| 18295 | if(!ok) return false; |  | 18295 | if(!ok) return false;
| 18296 | } |  | 18296 | }
| 18297 | if( PyMapping_HasKeyString(src, (char*)"m10") ) |  | 18297 | if( PyMapping_HasKeyString(src, (char*)"m10") )
| 18298 | { |  | 18298 | {
| 18299 | tmp = PyMapping_GetItemString(src, (char*)"m10"); |  | 18299 | tmp = PyMapping_GetItemString(src, (char*)"m10");
| 18300 | ok = tmp && pyopencv_to_safe(tmp, dst.m10, ArgInfo("m10", 0)); |  | 18300 | ok = tmp && pyopencv_to_safe(tmp, dst.m10, ArgInfo("m10", 0));
| 18301 | Py_DECREF(tmp); |  | 18301 | Py_DECREF(tmp);
| 18302 | if(!ok) return false; |  | 18302 | if(!ok) return false;
| 18303 | } |  | 18303 | }
| 18304 | if( PyMapping_HasKeyString(src, (char*)"m01") ) |  | 18304 | if( PyMapping_HasKeyString(src, (char*)"m01") )
| 18305 | { |  | 18305 | {
| 18306 | tmp = PyMapping_GetItemString(src, (char*)"m01"); |  | 18306 | tmp = PyMapping_GetItemString(src, (char*)"m01");
| 18307 | ok = tmp && pyopencv_to_safe(tmp, dst.m01, ArgInfo("m01", 0)); |  | 18307 | ok = tmp && pyopencv_to_safe(tmp, dst.m01, ArgInfo("m01", 0));
| 18308 | Py_DECREF(tmp); |  | 18308 | Py_DECREF(tmp);
| 18309 | if(!ok) return false; |  | 18309 | if(!ok) return false;
| 18310 | } |  | 18310 | }
| 18311 | if( PyMapping_HasKeyString(src, (char*)"m20") ) |  | 18311 | if( PyMapping_HasKeyString(src, (char*)"m20") )
| 18312 | { |  | 18312 | {
| 18313 | tmp = PyMapping_GetItemString(src, (char*)"m20"); |  | 18313 | tmp = PyMapping_GetItemString(src, (char*)"m20");
| 18314 | ok = tmp && pyopencv_to_safe(tmp, dst.m20, ArgInfo("m20", 0)); |  | 18314 | ok = tmp && pyopencv_to_safe(tmp, dst.m20, ArgInfo("m20", 0));
| 18315 | Py_DECREF(tmp); |  | 18315 | Py_DECREF(tmp);
| 18316 | if(!ok) return false; |  | 18316 | if(!ok) return false;
| 18317 | } |  | 18317 | }
| 18318 | if( PyMapping_HasKeyString(src, (char*)"m11") ) |  | 18318 | if( PyMapping_HasKeyString(src, (char*)"m11") )
| 18319 | { |  | 18319 | {
| 18320 | tmp = PyMapping_GetItemString(src, (char*)"m11"); |  | 18320 | tmp = PyMapping_GetItemString(src, (char*)"m11");
| 18321 | ok = tmp && pyopencv_to_safe(tmp, dst.m11, ArgInfo("m11", 0)); |  | 18321 | ok = tmp && pyopencv_to_safe(tmp, dst.m11, ArgInfo("m11", 0));
| 18322 | Py_DECREF(tmp); |  | 18322 | Py_DECREF(tmp);
| 18323 | if(!ok) return false; |  | 18323 | if(!ok) return false;
| 18324 | } |  | 18324 | }
| 18325 | if( PyMapping_HasKeyString(src, (char*)"m02") ) |  | 18325 | if( PyMapping_HasKeyString(src, (char*)"m02") )
| 18326 | { |  | 18326 | {
| 18327 | tmp = PyMapping_GetItemString(src, (char*)"m02"); |  | 18327 | tmp = PyMapping_GetItemString(src, (char*)"m02");
| 18328 | ok = tmp && pyopencv_to_safe(tmp, dst.m02, ArgInfo("m02", 0)); |  | 18328 | ok = tmp && pyopencv_to_safe(tmp, dst.m02, ArgInfo("m02", 0));
| 18329 | Py_DECREF(tmp); |  | 18329 | Py_DECREF(tmp);
| 18330 | if(!ok) return false; |  | 18330 | if(!ok) return false;
| 18331 | } |  | 18331 | }
| 18332 | if( PyMapping_HasKeyString(src, (char*)"m30") ) |  | 18332 | if( PyMapping_HasKeyString(src, (char*)"m30") )
| 18333 | { |  | 18333 | {
| 18334 | tmp = PyMapping_GetItemString(src, (char*)"m30"); |  | 18334 | tmp = PyMapping_GetItemString(src, (char*)"m30");
| 18335 | ok = tmp && pyopencv_to_safe(tmp, dst.m30, ArgInfo("m30", 0)); |  | 18335 | ok = tmp && pyopencv_to_safe(tmp, dst.m30, ArgInfo("m30", 0));
| 18336 | Py_DECREF(tmp); |  | 18336 | Py_DECREF(tmp);
| 18337 | if(!ok) return false; |  | 18337 | if(!ok) return false;
| 18338 | } |  | 18338 | }
| 18339 | if( PyMapping_HasKeyString(src, (char*)"m21") ) |  | 18339 | if( PyMapping_HasKeyString(src, (char*)"m21") )
| 18340 | { |  | 18340 | {
| 18341 | tmp = PyMapping_GetItemString(src, (char*)"m21"); |  | 18341 | tmp = PyMapping_GetItemString(src, (char*)"m21");
| 18342 | ok = tmp && pyopencv_to_safe(tmp, dst.m21, ArgInfo("m21", 0)); |  | 18342 | ok = tmp && pyopencv_to_safe(tmp, dst.m21, ArgInfo("m21", 0));
| 18343 | Py_DECREF(tmp); |  | 18343 | Py_DECREF(tmp);
| 18344 | if(!ok) return false; |  | 18344 | if(!ok) return false;
| 18345 | } |  | 18345 | }
| 18346 | if( PyMapping_HasKeyString(src, (char*)"m12") ) |  | 18346 | if( PyMapping_HasKeyString(src, (char*)"m12") )
| 18347 | { |  | 18347 | {
| 18348 | tmp = PyMapping_GetItemString(src, (char*)"m12"); |  | 18348 | tmp = PyMapping_GetItemString(src, (char*)"m12");
| 18349 | ok = tmp && pyopencv_to_safe(tmp, dst.m12, ArgInfo("m12", 0)); |  | 18349 | ok = tmp && pyopencv_to_safe(tmp, dst.m12, ArgInfo("m12", 0));
| 18350 | Py_DECREF(tmp); |  | 18350 | Py_DECREF(tmp);
| 18351 | if(!ok) return false; |  | 18351 | if(!ok) return false;
| 18352 | } |  | 18352 | }
| 18353 | if( PyMapping_HasKeyString(src, (char*)"m03") ) |  | 18353 | if( PyMapping_HasKeyString(src, (char*)"m03") )
| 18354 | { |  | 18354 | {
| 18355 | tmp = PyMapping_GetItemString(src, (char*)"m03"); |  | 18355 | tmp = PyMapping_GetItemString(src, (char*)"m03");
| 18356 | ok = tmp && pyopencv_to_safe(tmp, dst.m03, ArgInfo("m03", 0)); |  | 18356 | ok = tmp && pyopencv_to_safe(tmp, dst.m03, ArgInfo("m03", 0));
| 18357 | Py_DECREF(tmp); |  | 18357 | Py_DECREF(tmp);
| 18358 | if(!ok) return false; |  | 18358 | if(!ok) return false;
| 18359 | } |  | 18359 | }
| 18360 | if( PyMapping_HasKeyString(src, (char*)"mu20") ) |  | 18360 | if( PyMapping_HasKeyString(src, (char*)"mu20") )
| 18361 | { |  | 18361 | {
| 18362 | tmp = PyMapping_GetItemString(src, (char*)"mu20"); |  | 18362 | tmp = PyMapping_GetItemString(src, (char*)"mu20");
| 18363 | ok = tmp && pyopencv_to_safe(tmp, dst.mu20, ArgInfo("mu20", 0)); |  | 18363 | ok = tmp && pyopencv_to_safe(tmp, dst.mu20, ArgInfo("mu20", 0));
| 18364 | Py_DECREF(tmp); |  | 18364 | Py_DECREF(tmp);
| 18365 | if(!ok) return false; |  | 18365 | if(!ok) return false;
| 18366 | } |  | 18366 | }
| 18367 | if( PyMapping_HasKeyString(src, (char*)"mu11") ) |  | 18367 | if( PyMapping_HasKeyString(src, (char*)"mu11") )
| 18368 | { |  | 18368 | {
| 18369 | tmp = PyMapping_GetItemString(src, (char*)"mu11"); |  | 18369 | tmp = PyMapping_GetItemString(src, (char*)"mu11");
| 18370 | ok = tmp && pyopencv_to_safe(tmp, dst.mu11, ArgInfo("mu11", 0)); |  | 18370 | ok = tmp && pyopencv_to_safe(tmp, dst.mu11, ArgInfo("mu11", 0));
| 18371 | Py_DECREF(tmp); |  | 18371 | Py_DECREF(tmp);
| 18372 | if(!ok) return false; |  | 18372 | if(!ok) return false;
| 18373 | } |  | 18373 | }
| 18374 | if( PyMapping_HasKeyString(src, (char*)"mu02") ) |  | 18374 | if( PyMapping_HasKeyString(src, (char*)"mu02") )
| 18375 | { |  | 18375 | {
| 18376 | tmp = PyMapping_GetItemString(src, (char*)"mu02"); |  | 18376 | tmp = PyMapping_GetItemString(src, (char*)"mu02");
| 18377 | ok = tmp && pyopencv_to_safe(tmp, dst.mu02, ArgInfo("mu02", 0)); |  | 18377 | ok = tmp && pyopencv_to_safe(tmp, dst.mu02, ArgInfo("mu02", 0));
| 18378 | Py_DECREF(tmp); |  | 18378 | Py_DECREF(tmp);
| 18379 | if(!ok) return false; |  | 18379 | if(!ok) return false;
| 18380 | } |  | 18380 | }
| 18381 | if( PyMapping_HasKeyString(src, (char*)"mu30") ) |  | 18381 | if( PyMapping_HasKeyString(src, (char*)"mu30") )
| 18382 | { |  | 18382 | {
| 18383 | tmp = PyMapping_GetItemString(src, (char*)"mu30"); |  | 18383 | tmp = PyMapping_GetItemString(src, (char*)"mu30");
| 18384 | ok = tmp && pyopencv_to_safe(tmp, dst.mu30, ArgInfo("mu30", 0)); |  | 18384 | ok = tmp && pyopencv_to_safe(tmp, dst.mu30, ArgInfo("mu30", 0));
| 18385 | Py_DECREF(tmp); |  | 18385 | Py_DECREF(tmp);
| 18386 | if(!ok) return false; |  | 18386 | if(!ok) return false;
| 18387 | } |  | 18387 | }
| 18388 | if( PyMapping_HasKeyString(src, (char*)"mu21") ) |  | 18388 | if( PyMapping_HasKeyString(src, (char*)"mu21") )
| 18389 | { |  | 18389 | {
| 18390 | tmp = PyMapping_GetItemString(src, (char*)"mu21"); |  | 18390 | tmp = PyMapping_GetItemString(src, (char*)"mu21");
| 18391 | ok = tmp && pyopencv_to_safe(tmp, dst.mu21, ArgInfo("mu21", 0)); |  | 18391 | ok = tmp && pyopencv_to_safe(tmp, dst.mu21, ArgInfo("mu21", 0));
| 18392 | Py_DECREF(tmp); |  | 18392 | Py_DECREF(tmp);
| 18393 | if(!ok) return false; |  | 18393 | if(!ok) return false;
| 18394 | } |  | 18394 | }
| 18395 | if( PyMapping_HasKeyString(src, (char*)"mu12") ) |  | 18395 | if( PyMapping_HasKeyString(src, (char*)"mu12") )
| 18396 | { |  | 18396 | {
| 18397 | tmp = PyMapping_GetItemString(src, (char*)"mu12"); |  | 18397 | tmp = PyMapping_GetItemString(src, (char*)"mu12");
| 18398 | ok = tmp && pyopencv_to_safe(tmp, dst.mu12, ArgInfo("mu12", 0)); |  | 18398 | ok = tmp && pyopencv_to_safe(tmp, dst.mu12, ArgInfo("mu12", 0));
| 18399 | Py_DECREF(tmp); |  | 18399 | Py_DECREF(tmp);
| 18400 | if(!ok) return false; |  | 18400 | if(!ok) return false;
| 18401 | } |  | 18401 | }
| 18402 | if( PyMapping_HasKeyString(src, (char*)"mu03") ) |  | 18402 | if( PyMapping_HasKeyString(src, (char*)"mu03") )
| 18403 | { |  | 18403 | {
| 18404 | tmp = PyMapping_GetItemString(src, (char*)"mu03"); |  | 18404 | tmp = PyMapping_GetItemString(src, (char*)"mu03");
| 18405 | ok = tmp && pyopencv_to_safe(tmp, dst.mu03, ArgInfo("mu03", 0)); |  | 18405 | ok = tmp && pyopencv_to_safe(tmp, dst.mu03, ArgInfo("mu03", 0));
| 18406 | Py_DECREF(tmp); |  | 18406 | Py_DECREF(tmp);
| 18407 | if(!ok) return false; |  | 18407 | if(!ok) return false;
| 18408 | } |  | 18408 | }
| 18409 | if( PyMapping_HasKeyString(src, (char*)"nu20") ) |  | 18409 | if( PyMapping_HasKeyString(src, (char*)"nu20") )
| 18410 | { |  | 18410 | {
| 18411 | tmp = PyMapping_GetItemString(src, (char*)"nu20"); |  | 18411 | tmp = PyMapping_GetItemString(src, (char*)"nu20");
| 18412 | ok = tmp && pyopencv_to_safe(tmp, dst.nu20, ArgInfo("nu20", 0)); |  | 18412 | ok = tmp && pyopencv_to_safe(tmp, dst.nu20, ArgInfo("nu20", 0));
| 18413 | Py_DECREF(tmp); |  | 18413 | Py_DECREF(tmp);
| 18414 | if(!ok) return false; |  | 18414 | if(!ok) return false;
| 18415 | } |  | 18415 | }
| 18416 | if( PyMapping_HasKeyString(src, (char*)"nu11") ) |  | 18416 | if( PyMapping_HasKeyString(src, (char*)"nu11") )
| 18417 | { |  | 18417 | {
| 18418 | tmp = PyMapping_GetItemString(src, (char*)"nu11"); |  | 18418 | tmp = PyMapping_GetItemString(src, (char*)"nu11");
| 18419 | ok = tmp && pyopencv_to_safe(tmp, dst.nu11, ArgInfo("nu11", 0)); |  | 18419 | ok = tmp && pyopencv_to_safe(tmp, dst.nu11, ArgInfo("nu11", 0));
| 18420 | Py_DECREF(tmp); |  | 18420 | Py_DECREF(tmp);
| 18421 | if(!ok) return false; |  | 18421 | if(!ok) return false;
| 18422 | } |  | 18422 | }
| 18423 | if( PyMapping_HasKeyString(src, (char*)"nu02") ) |  | 18423 | if( PyMapping_HasKeyString(src, (char*)"nu02") )
| 18424 | { |  | 18424 | {
| 18425 | tmp = PyMapping_GetItemString(src, (char*)"nu02"); |  | 18425 | tmp = PyMapping_GetItemString(src, (char*)"nu02");
| 18426 | ok = tmp && pyopencv_to_safe(tmp, dst.nu02, ArgInfo("nu02", 0)); |  | 18426 | ok = tmp && pyopencv_to_safe(tmp, dst.nu02, ArgInfo("nu02", 0));
| 18427 | Py_DECREF(tmp); |  | 18427 | Py_DECREF(tmp);
| 18428 | if(!ok) return false; |  | 18428 | if(!ok) return false;
| 18429 | } |  | 18429 | }
| 18430 | if( PyMapping_HasKeyString(src, (char*)"nu30") ) |  | 18430 | if( PyMapping_HasKeyString(src, (char*)"nu30") )
| 18431 | { |  | 18431 | {
| 18432 | tmp = PyMapping_GetItemString(src, (char*)"nu30"); |  | 18432 | tmp = PyMapping_GetItemString(src, (char*)"nu30");
| 18433 | ok = tmp && pyopencv_to_safe(tmp, dst.nu30, ArgInfo("nu30", 0)); |  | 18433 | ok = tmp && pyopencv_to_safe(tmp, dst.nu30, ArgInfo("nu30", 0));
| 18434 | Py_DECREF(tmp); |  | 18434 | Py_DECREF(tmp);
| 18435 | if(!ok) return false; |  | 18435 | if(!ok) return false;
| 18436 | } |  | 18436 | }
| 18437 | if( PyMapping_HasKeyString(src, (char*)"nu21") ) |  | 18437 | if( PyMapping_HasKeyString(src, (char*)"nu21") )
| 18438 | { |  | 18438 | {
| 18439 | tmp = PyMapping_GetItemString(src, (char*)"nu21"); |  | 18439 | tmp = PyMapping_GetItemString(src, (char*)"nu21");
| 18440 | ok = tmp && pyopencv_to_safe(tmp, dst.nu21, ArgInfo("nu21", 0)); |  | 18440 | ok = tmp && pyopencv_to_safe(tmp, dst.nu21, ArgInfo("nu21", 0));
| 18441 | Py_DECREF(tmp); |  | 18441 | Py_DECREF(tmp);
| 18442 | if(!ok) return false; |  | 18442 | if(!ok) return false;
| 18443 | } |  | 18443 | }
| 18444 | if( PyMapping_HasKeyString(src, (char*)"nu12") ) |  | 18444 | if( PyMapping_HasKeyString(src, (char*)"nu12") )
| 18445 | { |  | 18445 | {
| 18446 | tmp = PyMapping_GetItemString(src, (char*)"nu12"); |  | 18446 | tmp = PyMapping_GetItemString(src, (char*)"nu12");
| 18447 | ok = tmp && pyopencv_to_safe(tmp, dst.nu12, ArgInfo("nu12", 0)); |  | 18447 | ok = tmp && pyopencv_to_safe(tmp, dst.nu12, ArgInfo("nu12", 0));
| 18448 | Py_DECREF(tmp); |  | 18448 | Py_DECREF(tmp);
| 18449 | if(!ok) return false; |  | 18449 | if(!ok) return false;
| 18450 | } |  | 18450 | }
| 18451 | if( PyMapping_HasKeyString(src, (char*)"nu03") ) |  | 18451 | if( PyMapping_HasKeyString(src, (char*)"nu03") )
| 18452 | { |  | 18452 | {
| 18453 | tmp = PyMapping_GetItemString(src, (char*)"nu03"); |  | 18453 | tmp = PyMapping_GetItemString(src, (char*)"nu03");
| 18454 | ok = tmp && pyopencv_to_safe(tmp, dst.nu03, ArgInfo("nu03", 0)); |  | 18454 | ok = tmp && pyopencv_to_safe(tmp, dst.nu03, ArgInfo("nu03", 0));
| 18455 | Py_DECREF(tmp); |  | 18455 | Py_DECREF(tmp);
| 18456 | if(!ok) return false; |  | 18456 | if(!ok) return false;
| 18457 | } |  | 18457 | }
| 18458 | return true; |  | 18458 | return true;
| 18459 | } |  | 18459 | }
| 18460 |  |  | 18460 |
| 18461 | template<> bool pyopencv_to(PyObject* src, cv::Moments& dst, const ArgInfo& info); |  | 18461 | template<> bool pyopencv_to(PyObject* src, cv::Moments& dst, const ArgInfo& info);
| 18462 |  |  | 18462 |
| 18463 | //================================================================================ |  | 18463 | //================================================================================
| 18464 | // NormHistogramCostExtractor (Generic) |  | 18464 | // NormHistogramCostExtractor (Generic)
| 18465 | //================================================================================ |  | 18465 | //================================================================================
| 18466 |  |  | 18466 |
| 18467 | // GetSet (NormHistogramCostExtractor) |  | 18467 | // GetSet (NormHistogramCostExtractor)
| 18468 |  |  | 18468 |
| 18469 |  |  | 18469 |
| 18470 |  |  | 18470 |
| 18471 | // Methods (NormHistogramCostExtractor) |  | 18471 | // Methods (NormHistogramCostExtractor)
| 18472 |  |  | 18472 |
| 18473 | static PyObject* pyopencv_cv_NormHistogramCostExtractor_getNormFlag(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18473 | static PyObject* pyopencv_cv_NormHistogramCostExtractor_getNormFlag(PyObject* self, PyObject* py_args, PyObject* kw)
| 18474 | { |  | 18474 | {
| 18475 | using namespace cv; |  | 18475 | using namespace cv;
| 18476 |  |  | 18476 |
| 18477 |  |  | 18477 |
| 18478 | Ptr<cv::NormHistogramCostExtractor> * self1 = 0; |  | 18478 | Ptr<cv::NormHistogramCostExtractor> * self1 = 0;
| 18479 | if (!pyopencv_NormHistogramCostExtractor_getp(self, self1)) |  | 18479 | if (!pyopencv_NormHistogramCostExtractor_getp(self, self1))
| 18480 | return failmsgp("Incorrect type of self (must be 'NormHistogramCostExtractor' or its derivative)"); |  | 18480 | return failmsgp("Incorrect type of self (must be 'NormHistogramCostExtractor' or its derivative)");
| 18481 | Ptr<cv::NormHistogramCostExtractor> _self_ = *(self1); |  | 18481 | Ptr<cv::NormHistogramCostExtractor> _self_ = *(self1);
| 18482 | int retval; |  | 18482 | int retval;
| 18483 |  |  | 18483 |
| 18484 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18484 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18485 | { |  | 18485 | {
| 18486 | ERRWRAP2(retval = _self_->getNormFlag()); |  | 18486 | ERRWRAP2(retval = _self_->getNormFlag());
| 18487 | return pyopencv_from(retval); |  | 18487 | return pyopencv_from(retval);
| 18488 | } |  | 18488 | }
| 18489 |  |  | 18489 |
| 18490 | return NULL; |  | 18490 | return NULL;
| 18491 | } |  | 18491 | }
| 18492 |  |  | 18492 |
| 18493 | static PyObject* pyopencv_cv_NormHistogramCostExtractor_setNormFlag(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18493 | static PyObject* pyopencv_cv_NormHistogramCostExtractor_setNormFlag(PyObject* self, PyObject* py_args, PyObject* kw)
| 18494 | { |  | 18494 | {
| 18495 | using namespace cv; |  | 18495 | using namespace cv;
| 18496 |  |  | 18496 |
| 18497 |  |  | 18497 |
| 18498 | Ptr<cv::NormHistogramCostExtractor> * self1 = 0; |  | 18498 | Ptr<cv::NormHistogramCostExtractor> * self1 = 0;
| 18499 | if (!pyopencv_NormHistogramCostExtractor_getp(self, self1)) |  | 18499 | if (!pyopencv_NormHistogramCostExtractor_getp(self, self1))
| 18500 | return failmsgp("Incorrect type of self (must be 'NormHistogramCostExtractor' or its derivative)"); |  | 18500 | return failmsgp("Incorrect type of self (must be 'NormHistogramCostExtractor' or its derivative)");
| 18501 | Ptr<cv::NormHistogramCostExtractor> _self_ = *(self1); |  | 18501 | Ptr<cv::NormHistogramCostExtractor> _self_ = *(self1);
| 18502 | PyObject* pyobj_flag = NULL; |  | 18502 | PyObject* pyobj_flag = NULL;
| 18503 | int flag=0; |  | 18503 | int flag=0;
| 18504 |  |  | 18504 |
| 18505 | const char* keywords[] = { "flag", NULL }; |  | 18505 | const char* keywords[] = { "flag", NULL };
| 18506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:NormHistogramCostExtractor.setNormFlag", (char**)keywords, &pyobj_flag) && |  | 18506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:NormHistogramCostExtractor.setNormFlag", (char**)keywords, &pyobj_flag) &&
| 18507 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) ) |  | 18507 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) )
| 18508 | { |  | 18508 | {
| 18509 | ERRWRAP2(_self_->setNormFlag(flag)); |  | 18509 | ERRWRAP2(_self_->setNormFlag(flag));
| 18510 | Py_RETURN_NONE; |  | 18510 | Py_RETURN_NONE;
| 18511 | } |  | 18511 | }
| 18512 |  |  | 18512 |
| 18513 | return NULL; |  | 18513 | return NULL;
| 18514 | } |  | 18514 | }
| 18515 |  |  | 18515 |
| 18516 |  |  | 18516 |
| 18517 |  |  | 18517 |
| 18518 | // Tables (NormHistogramCostExtractor) |  | 18518 | // Tables (NormHistogramCostExtractor)
| 18519 |  |  | 18519 |
| 18520 | static PyGetSetDef pyopencv_NormHistogramCostExtractor_getseters[] = |  | 18520 | static PyGetSetDef pyopencv_NormHistogramCostExtractor_getseters[] =
| 18521 | { |  | 18521 | {
| 18522 | {NULL} /* Sentinel */ |  | 18522 | {NULL} /* Sentinel */
| 18523 | }; |  | 18523 | };
| 18524 |  |  | 18524 |
| 18525 | static PyMethodDef pyopencv_NormHistogramCostExtractor_methods[] = |  | 18525 | static PyMethodDef pyopencv_NormHistogramCostExtractor_methods[] =
| 18526 | { |  | 18526 | {
| 18527 | {"getNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_NormHistogramCostExtractor_getNormFlag, 0), "getNormFlag() -> retval\n."}, |  | 18527 | {"getNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_NormHistogramCostExtractor_getNormFlag, 0), "getNormFlag() -> retval\n."},
| 18528 | {"setNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_NormHistogramCostExtractor_setNormFlag, 0), "setNormFlag(flag) -> None\n."}, |  | 18528 | {"setNormFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_NormHistogramCostExtractor_setNormFlag, 0), "setNormFlag(flag) -> None\n."},
| 18529 |  |  | 18529 |
| 18530 | {NULL, NULL} |  | 18530 | {NULL, NULL}
| 18531 | }; |  | 18531 | };
| 18532 |  |  | 18532 |
| 18533 | // Converter (NormHistogramCostExtractor) |  | 18533 | // Converter (NormHistogramCostExtractor)
| 18534 |  |  | 18534 |
| 18535 | template<> |  | 18535 | template<>
| 18536 | struct PyOpenCV_Converter< Ptr<cv::NormHistogramCostExtractor> > |  | 18536 | struct PyOpenCV_Converter< Ptr<cv::NormHistogramCostExtractor> >
| 18537 | { |  | 18537 | {
| 18538 | static PyObject* from(const Ptr<cv::NormHistogramCostExtractor>& r) |  | 18538 | static PyObject* from(const Ptr<cv::NormHistogramCostExtractor>& r)
| 18539 | { |  | 18539 | {
| 18540 | return pyopencv_NormHistogramCostExtractor_Instance(r); |  | 18540 | return pyopencv_NormHistogramCostExtractor_Instance(r);
| 18541 | } |  | 18541 | }
| 18542 | static bool to(PyObject* src, Ptr<cv::NormHistogramCostExtractor>& dst, const ArgInfo& info) |  | 18542 | static bool to(PyObject* src, Ptr<cv::NormHistogramCostExtractor>& dst, const ArgInfo& info)
| 18543 | { |  | 18543 | {
| 18544 | if(!src || src == Py_None) |  | 18544 | if(!src || src == Py_None)
| 18545 | return true; |  | 18545 | return true;
| 18546 | Ptr<cv::NormHistogramCostExtractor> * dst_; |  | 18546 | Ptr<cv::NormHistogramCostExtractor> * dst_;
| 18547 | if (pyopencv_NormHistogramCostExtractor_getp(src, dst_)) |  | 18547 | if (pyopencv_NormHistogramCostExtractor_getp(src, dst_))
| 18548 | { |  | 18548 | {
| 18549 | dst = *dst_; |  | 18549 | dst = *dst_;
| 18550 | return true; |  | 18550 | return true;
| 18551 | } |  | 18551 | }
| 18552 |  |  | 18552 |
| 18553 | failmsg("Expected Ptr<cv::NormHistogramCostExtractor> for argument '%s'", info.name); |  | 18553 | failmsg("Expected Ptr<cv::NormHistogramCostExtractor> for argument '%s'", info.name);
| 18554 | return false; |  | 18554 | return false;
| 18555 | } |  | 18555 | }
| 18556 | }; |  | 18556 | };
| 18557 |  |  | 18557 |
| 18558 | //================================================================================ |  | 18558 | //================================================================================
| 18559 | // ORB (Generic) |  | 18559 | // ORB (Generic)
| 18560 | //================================================================================ |  | 18560 | //================================================================================
| 18561 |  |  | 18561 |
| 18562 | // GetSet (ORB) |  | 18562 | // GetSet (ORB)
| 18563 |  |  | 18563 |
| 18564 |  |  | 18564 |
| 18565 |  |  | 18565 |
| 18566 | // Methods (ORB) |  | 18566 | // Methods (ORB)
| 18567 |  |  | 18567 |
| 18568 | static PyObject* pyopencv_cv_ORB_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18568 | static PyObject* pyopencv_cv_ORB_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 18569 | { |  | 18569 | {
| 18570 | using namespace cv; |  | 18570 | using namespace cv;
| 18571 |  |  | 18571 |
| 18572 | PyObject* pyobj_nfeatures = NULL; |  | 18572 | PyObject* pyobj_nfeatures = NULL;
| 18573 | int nfeatures=500; |  | 18573 | int nfeatures=500;
| 18574 | PyObject* pyobj_scaleFactor = NULL; |  | 18574 | PyObject* pyobj_scaleFactor = NULL;
| 18575 | float scaleFactor=1.2f; |  | 18575 | float scaleFactor=1.2f;
| 18576 | PyObject* pyobj_nlevels = NULL; |  | 18576 | PyObject* pyobj_nlevels = NULL;
| 18577 | int nlevels=8; |  | 18577 | int nlevels=8;
| 18578 | PyObject* pyobj_edgeThreshold = NULL; |  | 18578 | PyObject* pyobj_edgeThreshold = NULL;
| 18579 | int edgeThreshold=31; |  | 18579 | int edgeThreshold=31;
| 18580 | PyObject* pyobj_firstLevel = NULL; |  | 18580 | PyObject* pyobj_firstLevel = NULL;
| 18581 | int firstLevel=0; |  | 18581 | int firstLevel=0;
| 18582 | PyObject* pyobj_WTA_K = NULL; |  | 18582 | PyObject* pyobj_WTA_K = NULL;
| 18583 | int WTA_K=2; |  | 18583 | int WTA_K=2;
| 18584 | PyObject* pyobj_scoreType = NULL; |  | 18584 | PyObject* pyobj_scoreType = NULL;
| 18585 | ORB_ScoreType scoreType=ORB::HARRIS_SCORE; |  | 18585 | ORB_ScoreType scoreType=ORB::HARRIS_SCORE;
| 18586 | PyObject* pyobj_patchSize = NULL; |  | 18586 | PyObject* pyobj_patchSize = NULL;
| 18587 | int patchSize=31; |  | 18587 | int patchSize=31;
| 18588 | PyObject* pyobj_fastThreshold = NULL; |  | 18588 | PyObject* pyobj_fastThreshold = NULL;
| 18589 | int fastThreshold=20; |  | 18589 | int fastThreshold=20;
| 18590 | Ptr<ORB> retval; |  | 18590 | Ptr<ORB> retval;
| 18591 |  |  | 18591 |
| 18592 | const char* keywords[] = { "nfeatures", "scaleFactor", "nlevels", "edgeThreshold", "firstLevel", "WTA_K", "scoreType", "patchSize", "fastThreshold", NULL }; |  | 18592 | const char* keywords[] = { "nfeatures", "scaleFactor", "nlevels", "edgeThreshold", "firstLevel", "WTA_K", "scoreType", "patchSize", "fastThreshold", NULL };
| 18593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOO:ORB.create", (char**)keywords, &pyobj_nfeatures, &pyobj_scaleFactor, &pyobj_nlevels, &pyobj_edgeThreshold, &pyobj_firstLevel, &pyobj_WTA_K, &pyobj_scoreType, &pyobj_patchSize, &pyobj_fastThreshold) && |  | 18593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOO:ORB.create", (char**)keywords, &pyobj_nfeatures, &pyobj_scaleFactor, &pyobj_nlevels, &pyobj_edgeThreshold, &pyobj_firstLevel, &pyobj_WTA_K, &pyobj_scoreType, &pyobj_patchSize, &pyobj_fastThreshold) &&
| 18594 | pyopencv_to_safe(pyobj_nfeatures, nfeatures, ArgInfo("nfeatures", 0)) && |  | 18594 | pyopencv_to_safe(pyobj_nfeatures, nfeatures, ArgInfo("nfeatures", 0)) &&
| 18595 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) && |  | 18595 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) &&
| 18596 | pyopencv_to_safe(pyobj_nlevels, nlevels, ArgInfo("nlevels", 0)) && |  | 18596 | pyopencv_to_safe(pyobj_nlevels, nlevels, ArgInfo("nlevels", 0)) &&
| 18597 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) && |  | 18597 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) &&
| 18598 | pyopencv_to_safe(pyobj_firstLevel, firstLevel, ArgInfo("firstLevel", 0)) && |  | 18598 | pyopencv_to_safe(pyobj_firstLevel, firstLevel, ArgInfo("firstLevel", 0)) &&
| 18599 | pyopencv_to_safe(pyobj_WTA_K, WTA_K, ArgInfo("WTA_K", 0)) && |  | 18599 | pyopencv_to_safe(pyobj_WTA_K, WTA_K, ArgInfo("WTA_K", 0)) &&
| 18600 | pyopencv_to_safe(pyobj_scoreType, scoreType, ArgInfo("scoreType", 0)) && |  | 18600 | pyopencv_to_safe(pyobj_scoreType, scoreType, ArgInfo("scoreType", 0)) &&
| 18601 | pyopencv_to_safe(pyobj_patchSize, patchSize, ArgInfo("patchSize", 0)) && |  | 18601 | pyopencv_to_safe(pyobj_patchSize, patchSize, ArgInfo("patchSize", 0)) &&
| 18602 | pyopencv_to_safe(pyobj_fastThreshold, fastThreshold, ArgInfo("fastThreshold", 0)) ) |  | 18602 | pyopencv_to_safe(pyobj_fastThreshold, fastThreshold, ArgInfo("fastThreshold", 0)) )
| 18603 | { |  | 18603 | {
| 18604 | ERRWRAP2(retval = cv::ORB::create(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold)); |  | 18604 | ERRWRAP2(retval = cv::ORB::create(nfeatures, scaleFactor, nlevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize, fastThreshold));
| 18605 | return pyopencv_from(retval); |  | 18605 | return pyopencv_from(retval);
| 18606 | } |  | 18606 | }
| 18607 |  |  | 18607 |
| 18608 | return NULL; |  | 18608 | return NULL;
| 18609 | } |  | 18609 | }
| 18610 |  |  | 18610 |
| 18611 | static PyObject* pyopencv_cv_ORB_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18611 | static PyObject* pyopencv_cv_ORB_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 18612 | { |  | 18612 | {
| 18613 | using namespace cv; |  | 18613 | using namespace cv;
| 18614 |  |  | 18614 |
| 18615 |  |  | 18615 |
| 18616 | Ptr<cv::ORB> * self1 = 0; |  | 18616 | Ptr<cv::ORB> * self1 = 0;
| 18617 | if (!pyopencv_ORB_getp(self, self1)) |  | 18617 | if (!pyopencv_ORB_getp(self, self1))
| 18618 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18618 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18619 | Ptr<cv::ORB> _self_ = *(self1); |  | 18619 | Ptr<cv::ORB> _self_ = *(self1);
| 18620 | String retval; |  | 18620 | String retval;
| 18621 |  |  | 18621 |
| 18622 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18622 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18623 | { |  | 18623 | {
| 18624 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 18624 | ERRWRAP2(retval = _self_->getDefaultName());
| 18625 | return pyopencv_from(retval); |  | 18625 | return pyopencv_from(retval);
| 18626 | } |  | 18626 | }
| 18627 |  |  | 18627 |
| 18628 | return NULL; |  | 18628 | return NULL;
| 18629 | } |  | 18629 | }
| 18630 |  |  | 18630 |
| 18631 | static PyObject* pyopencv_cv_ORB_getEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18631 | static PyObject* pyopencv_cv_ORB_getEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 18632 | { |  | 18632 | {
| 18633 | using namespace cv; |  | 18633 | using namespace cv;
| 18634 |  |  | 18634 |
| 18635 |  |  | 18635 |
| 18636 | Ptr<cv::ORB> * self1 = 0; |  | 18636 | Ptr<cv::ORB> * self1 = 0;
| 18637 | if (!pyopencv_ORB_getp(self, self1)) |  | 18637 | if (!pyopencv_ORB_getp(self, self1))
| 18638 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18638 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18639 | Ptr<cv::ORB> _self_ = *(self1); |  | 18639 | Ptr<cv::ORB> _self_ = *(self1);
| 18640 | int retval; |  | 18640 | int retval;
| 18641 |  |  | 18641 |
| 18642 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18642 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18643 | { |  | 18643 | {
| 18644 | ERRWRAP2(retval = _self_->getEdgeThreshold()); |  | 18644 | ERRWRAP2(retval = _self_->getEdgeThreshold());
| 18645 | return pyopencv_from(retval); |  | 18645 | return pyopencv_from(retval);
| 18646 | } |  | 18646 | }
| 18647 |  |  | 18647 |
| 18648 | return NULL; |  | 18648 | return NULL;
| 18649 | } |  | 18649 | }
| 18650 |  |  | 18650 |
| 18651 | static PyObject* pyopencv_cv_ORB_getFastThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18651 | static PyObject* pyopencv_cv_ORB_getFastThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 18652 | { |  | 18652 | {
| 18653 | using namespace cv; |  | 18653 | using namespace cv;
| 18654 |  |  | 18654 |
| 18655 |  |  | 18655 |
| 18656 | Ptr<cv::ORB> * self1 = 0; |  | 18656 | Ptr<cv::ORB> * self1 = 0;
| 18657 | if (!pyopencv_ORB_getp(self, self1)) |  | 18657 | if (!pyopencv_ORB_getp(self, self1))
| 18658 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18658 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18659 | Ptr<cv::ORB> _self_ = *(self1); |  | 18659 | Ptr<cv::ORB> _self_ = *(self1);
| 18660 | int retval; |  | 18660 | int retval;
| 18661 |  |  | 18661 |
| 18662 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18662 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18663 | { |  | 18663 | {
| 18664 | ERRWRAP2(retval = _self_->getFastThreshold()); |  | 18664 | ERRWRAP2(retval = _self_->getFastThreshold());
| 18665 | return pyopencv_from(retval); |  | 18665 | return pyopencv_from(retval);
| 18666 | } |  | 18666 | }
| 18667 |  |  | 18667 |
| 18668 | return NULL; |  | 18668 | return NULL;
| 18669 | } |  | 18669 | }
| 18670 |  |  | 18670 |
| 18671 | static PyObject* pyopencv_cv_ORB_getFirstLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18671 | static PyObject* pyopencv_cv_ORB_getFirstLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 18672 | { |  | 18672 | {
| 18673 | using namespace cv; |  | 18673 | using namespace cv;
| 18674 |  |  | 18674 |
| 18675 |  |  | 18675 |
| 18676 | Ptr<cv::ORB> * self1 = 0; |  | 18676 | Ptr<cv::ORB> * self1 = 0;
| 18677 | if (!pyopencv_ORB_getp(self, self1)) |  | 18677 | if (!pyopencv_ORB_getp(self, self1))
| 18678 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18678 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18679 | Ptr<cv::ORB> _self_ = *(self1); |  | 18679 | Ptr<cv::ORB> _self_ = *(self1);
| 18680 | int retval; |  | 18680 | int retval;
| 18681 |  |  | 18681 |
| 18682 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18682 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18683 | { |  | 18683 | {
| 18684 | ERRWRAP2(retval = _self_->getFirstLevel()); |  | 18684 | ERRWRAP2(retval = _self_->getFirstLevel());
| 18685 | return pyopencv_from(retval); |  | 18685 | return pyopencv_from(retval);
| 18686 | } |  | 18686 | }
| 18687 |  |  | 18687 |
| 18688 | return NULL; |  | 18688 | return NULL;
| 18689 | } |  | 18689 | }
| 18690 |  |  | 18690 |
| 18691 | static PyObject* pyopencv_cv_ORB_getMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18691 | static PyObject* pyopencv_cv_ORB_getMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 18692 | { |  | 18692 | {
| 18693 | using namespace cv; |  | 18693 | using namespace cv;
| 18694 |  |  | 18694 |
| 18695 |  |  | 18695 |
| 18696 | Ptr<cv::ORB> * self1 = 0; |  | 18696 | Ptr<cv::ORB> * self1 = 0;
| 18697 | if (!pyopencv_ORB_getp(self, self1)) |  | 18697 | if (!pyopencv_ORB_getp(self, self1))
| 18698 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18698 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18699 | Ptr<cv::ORB> _self_ = *(self1); |  | 18699 | Ptr<cv::ORB> _self_ = *(self1);
| 18700 | int retval; |  | 18700 | int retval;
| 18701 |  |  | 18701 |
| 18702 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18702 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18703 | { |  | 18703 | {
| 18704 | ERRWRAP2(retval = _self_->getMaxFeatures()); |  | 18704 | ERRWRAP2(retval = _self_->getMaxFeatures());
| 18705 | return pyopencv_from(retval); |  | 18705 | return pyopencv_from(retval);
| 18706 | } |  | 18706 | }
| 18707 |  |  | 18707 |
| 18708 | return NULL; |  | 18708 | return NULL;
| 18709 | } |  | 18709 | }
| 18710 |  |  | 18710 |
| 18711 | static PyObject* pyopencv_cv_ORB_getNLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18711 | static PyObject* pyopencv_cv_ORB_getNLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 18712 | { |  | 18712 | {
| 18713 | using namespace cv; |  | 18713 | using namespace cv;
| 18714 |  |  | 18714 |
| 18715 |  |  | 18715 |
| 18716 | Ptr<cv::ORB> * self1 = 0; |  | 18716 | Ptr<cv::ORB> * self1 = 0;
| 18717 | if (!pyopencv_ORB_getp(self, self1)) |  | 18717 | if (!pyopencv_ORB_getp(self, self1))
| 18718 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18718 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18719 | Ptr<cv::ORB> _self_ = *(self1); |  | 18719 | Ptr<cv::ORB> _self_ = *(self1);
| 18720 | int retval; |  | 18720 | int retval;
| 18721 |  |  | 18721 |
| 18722 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18722 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18723 | { |  | 18723 | {
| 18724 | ERRWRAP2(retval = _self_->getNLevels()); |  | 18724 | ERRWRAP2(retval = _self_->getNLevels());
| 18725 | return pyopencv_from(retval); |  | 18725 | return pyopencv_from(retval);
| 18726 | } |  | 18726 | }
| 18727 |  |  | 18727 |
| 18728 | return NULL; |  | 18728 | return NULL;
| 18729 | } |  | 18729 | }
| 18730 |  |  | 18730 |
| 18731 | static PyObject* pyopencv_cv_ORB_getPatchSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18731 | static PyObject* pyopencv_cv_ORB_getPatchSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 18732 | { |  | 18732 | {
| 18733 | using namespace cv; |  | 18733 | using namespace cv;
| 18734 |  |  | 18734 |
| 18735 |  |  | 18735 |
| 18736 | Ptr<cv::ORB> * self1 = 0; |  | 18736 | Ptr<cv::ORB> * self1 = 0;
| 18737 | if (!pyopencv_ORB_getp(self, self1)) |  | 18737 | if (!pyopencv_ORB_getp(self, self1))
| 18738 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18738 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18739 | Ptr<cv::ORB> _self_ = *(self1); |  | 18739 | Ptr<cv::ORB> _self_ = *(self1);
| 18740 | int retval; |  | 18740 | int retval;
| 18741 |  |  | 18741 |
| 18742 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18742 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18743 | { |  | 18743 | {
| 18744 | ERRWRAP2(retval = _self_->getPatchSize()); |  | 18744 | ERRWRAP2(retval = _self_->getPatchSize());
| 18745 | return pyopencv_from(retval); |  | 18745 | return pyopencv_from(retval);
| 18746 | } |  | 18746 | }
| 18747 |  |  | 18747 |
| 18748 | return NULL; |  | 18748 | return NULL;
| 18749 | } |  | 18749 | }
| 18750 |  |  | 18750 |
| 18751 | static PyObject* pyopencv_cv_ORB_getScaleFactor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18751 | static PyObject* pyopencv_cv_ORB_getScaleFactor(PyObject* self, PyObject* py_args, PyObject* kw)
| 18752 | { |  | 18752 | {
| 18753 | using namespace cv; |  | 18753 | using namespace cv;
| 18754 |  |  | 18754 |
| 18755 |  |  | 18755 |
| 18756 | Ptr<cv::ORB> * self1 = 0; |  | 18756 | Ptr<cv::ORB> * self1 = 0;
| 18757 | if (!pyopencv_ORB_getp(self, self1)) |  | 18757 | if (!pyopencv_ORB_getp(self, self1))
| 18758 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18758 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18759 | Ptr<cv::ORB> _self_ = *(self1); |  | 18759 | Ptr<cv::ORB> _self_ = *(self1);
| 18760 | double retval; |  | 18760 | double retval;
| 18761 |  |  | 18761 |
| 18762 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18762 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18763 | { |  | 18763 | {
| 18764 | ERRWRAP2(retval = _self_->getScaleFactor()); |  | 18764 | ERRWRAP2(retval = _self_->getScaleFactor());
| 18765 | return pyopencv_from(retval); |  | 18765 | return pyopencv_from(retval);
| 18766 | } |  | 18766 | }
| 18767 |  |  | 18767 |
| 18768 | return NULL; |  | 18768 | return NULL;
| 18769 | } |  | 18769 | }
| 18770 |  |  | 18770 |
| 18771 | static PyObject* pyopencv_cv_ORB_getScoreType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18771 | static PyObject* pyopencv_cv_ORB_getScoreType(PyObject* self, PyObject* py_args, PyObject* kw)
| 18772 | { |  | 18772 | {
| 18773 | using namespace cv; |  | 18773 | using namespace cv;
| 18774 |  |  | 18774 |
| 18775 |  |  | 18775 |
| 18776 | Ptr<cv::ORB> * self1 = 0; |  | 18776 | Ptr<cv::ORB> * self1 = 0;
| 18777 | if (!pyopencv_ORB_getp(self, self1)) |  | 18777 | if (!pyopencv_ORB_getp(self, self1))
| 18778 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18778 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18779 | Ptr<cv::ORB> _self_ = *(self1); |  | 18779 | Ptr<cv::ORB> _self_ = *(self1);
| 18780 | ORB::ScoreType retval; |  | 18780 | ORB::ScoreType retval;
| 18781 |  |  | 18781 |
| 18782 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18782 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18783 | { |  | 18783 | {
| 18784 | ERRWRAP2(retval = _self_->getScoreType()); |  | 18784 | ERRWRAP2(retval = _self_->getScoreType());
| 18785 | return pyopencv_from(retval); |  | 18785 | return pyopencv_from(retval);
| 18786 | } |  | 18786 | }
| 18787 |  |  | 18787 |
| 18788 | return NULL; |  | 18788 | return NULL;
| 18789 | } |  | 18789 | }
| 18790 |  |  | 18790 |
| 18791 | static PyObject* pyopencv_cv_ORB_getWTA_K(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18791 | static PyObject* pyopencv_cv_ORB_getWTA_K(PyObject* self, PyObject* py_args, PyObject* kw)
| 18792 | { |  | 18792 | {
| 18793 | using namespace cv; |  | 18793 | using namespace cv;
| 18794 |  |  | 18794 |
| 18795 |  |  | 18795 |
| 18796 | Ptr<cv::ORB> * self1 = 0; |  | 18796 | Ptr<cv::ORB> * self1 = 0;
| 18797 | if (!pyopencv_ORB_getp(self, self1)) |  | 18797 | if (!pyopencv_ORB_getp(self, self1))
| 18798 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18798 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18799 | Ptr<cv::ORB> _self_ = *(self1); |  | 18799 | Ptr<cv::ORB> _self_ = *(self1);
| 18800 | int retval; |  | 18800 | int retval;
| 18801 |  |  | 18801 |
| 18802 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 18802 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 18803 | { |  | 18803 | {
| 18804 | ERRWRAP2(retval = _self_->getWTA_K()); |  | 18804 | ERRWRAP2(retval = _self_->getWTA_K());
| 18805 | return pyopencv_from(retval); |  | 18805 | return pyopencv_from(retval);
| 18806 | } |  | 18806 | }
| 18807 |  |  | 18807 |
| 18808 | return NULL; |  | 18808 | return NULL;
| 18809 | } |  | 18809 | }
| 18810 |  |  | 18810 |
| 18811 | static PyObject* pyopencv_cv_ORB_setEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18811 | static PyObject* pyopencv_cv_ORB_setEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 18812 | { |  | 18812 | {
| 18813 | using namespace cv; |  | 18813 | using namespace cv;
| 18814 |  |  | 18814 |
| 18815 |  |  | 18815 |
| 18816 | Ptr<cv::ORB> * self1 = 0; |  | 18816 | Ptr<cv::ORB> * self1 = 0;
| 18817 | if (!pyopencv_ORB_getp(self, self1)) |  | 18817 | if (!pyopencv_ORB_getp(self, self1))
| 18818 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18818 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18819 | Ptr<cv::ORB> _self_ = *(self1); |  | 18819 | Ptr<cv::ORB> _self_ = *(self1);
| 18820 | PyObject* pyobj_edgeThreshold = NULL; |  | 18820 | PyObject* pyobj_edgeThreshold = NULL;
| 18821 | int edgeThreshold=0; |  | 18821 | int edgeThreshold=0;
| 18822 |  |  | 18822 |
| 18823 | const char* keywords[] = { "edgeThreshold", NULL }; |  | 18823 | const char* keywords[] = { "edgeThreshold", NULL };
| 18824 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setEdgeThreshold", (char**)keywords, &pyobj_edgeThreshold) && |  | 18824 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setEdgeThreshold", (char**)keywords, &pyobj_edgeThreshold) &&
| 18825 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) ) |  | 18825 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) )
| 18826 | { |  | 18826 | {
| 18827 | ERRWRAP2(_self_->setEdgeThreshold(edgeThreshold)); |  | 18827 | ERRWRAP2(_self_->setEdgeThreshold(edgeThreshold));
| 18828 | Py_RETURN_NONE; |  | 18828 | Py_RETURN_NONE;
| 18829 | } |  | 18829 | }
| 18830 |  |  | 18830 |
| 18831 | return NULL; |  | 18831 | return NULL;
| 18832 | } |  | 18832 | }
| 18833 |  |  | 18833 |
| 18834 | static PyObject* pyopencv_cv_ORB_setFastThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18834 | static PyObject* pyopencv_cv_ORB_setFastThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 18835 | { |  | 18835 | {
| 18836 | using namespace cv; |  | 18836 | using namespace cv;
| 18837 |  |  | 18837 |
| 18838 |  |  | 18838 |
| 18839 | Ptr<cv::ORB> * self1 = 0; |  | 18839 | Ptr<cv::ORB> * self1 = 0;
| 18840 | if (!pyopencv_ORB_getp(self, self1)) |  | 18840 | if (!pyopencv_ORB_getp(self, self1))
| 18841 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18841 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18842 | Ptr<cv::ORB> _self_ = *(self1); |  | 18842 | Ptr<cv::ORB> _self_ = *(self1);
| 18843 | PyObject* pyobj_fastThreshold = NULL; |  | 18843 | PyObject* pyobj_fastThreshold = NULL;
| 18844 | int fastThreshold=0; |  | 18844 | int fastThreshold=0;
| 18845 |  |  | 18845 |
| 18846 | const char* keywords[] = { "fastThreshold", NULL }; |  | 18846 | const char* keywords[] = { "fastThreshold", NULL };
| 18847 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setFastThreshold", (char**)keywords, &pyobj_fastThreshold) && |  | 18847 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setFastThreshold", (char**)keywords, &pyobj_fastThreshold) &&
| 18848 | pyopencv_to_safe(pyobj_fastThreshold, fastThreshold, ArgInfo("fastThreshold", 0)) ) |  | 18848 | pyopencv_to_safe(pyobj_fastThreshold, fastThreshold, ArgInfo("fastThreshold", 0)) )
| 18849 | { |  | 18849 | {
| 18850 | ERRWRAP2(_self_->setFastThreshold(fastThreshold)); |  | 18850 | ERRWRAP2(_self_->setFastThreshold(fastThreshold));
| 18851 | Py_RETURN_NONE; |  | 18851 | Py_RETURN_NONE;
| 18852 | } |  | 18852 | }
| 18853 |  |  | 18853 |
| 18854 | return NULL; |  | 18854 | return NULL;
| 18855 | } |  | 18855 | }
| 18856 |  |  | 18856 |
| 18857 | static PyObject* pyopencv_cv_ORB_setFirstLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18857 | static PyObject* pyopencv_cv_ORB_setFirstLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 18858 | { |  | 18858 | {
| 18859 | using namespace cv; |  | 18859 | using namespace cv;
| 18860 |  |  | 18860 |
| 18861 |  |  | 18861 |
| 18862 | Ptr<cv::ORB> * self1 = 0; |  | 18862 | Ptr<cv::ORB> * self1 = 0;
| 18863 | if (!pyopencv_ORB_getp(self, self1)) |  | 18863 | if (!pyopencv_ORB_getp(self, self1))
| 18864 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18864 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18865 | Ptr<cv::ORB> _self_ = *(self1); |  | 18865 | Ptr<cv::ORB> _self_ = *(self1);
| 18866 | PyObject* pyobj_firstLevel = NULL; |  | 18866 | PyObject* pyobj_firstLevel = NULL;
| 18867 | int firstLevel=0; |  | 18867 | int firstLevel=0;
| 18868 |  |  | 18868 |
| 18869 | const char* keywords[] = { "firstLevel", NULL }; |  | 18869 | const char* keywords[] = { "firstLevel", NULL };
| 18870 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setFirstLevel", (char**)keywords, &pyobj_firstLevel) && |  | 18870 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setFirstLevel", (char**)keywords, &pyobj_firstLevel) &&
| 18871 | pyopencv_to_safe(pyobj_firstLevel, firstLevel, ArgInfo("firstLevel", 0)) ) |  | 18871 | pyopencv_to_safe(pyobj_firstLevel, firstLevel, ArgInfo("firstLevel", 0)) )
| 18872 | { |  | 18872 | {
| 18873 | ERRWRAP2(_self_->setFirstLevel(firstLevel)); |  | 18873 | ERRWRAP2(_self_->setFirstLevel(firstLevel));
| 18874 | Py_RETURN_NONE; |  | 18874 | Py_RETURN_NONE;
| 18875 | } |  | 18875 | }
| 18876 |  |  | 18876 |
| 18877 | return NULL; |  | 18877 | return NULL;
| 18878 | } |  | 18878 | }
| 18879 |  |  | 18879 |
| 18880 | static PyObject* pyopencv_cv_ORB_setMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18880 | static PyObject* pyopencv_cv_ORB_setMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 18881 | { |  | 18881 | {
| 18882 | using namespace cv; |  | 18882 | using namespace cv;
| 18883 |  |  | 18883 |
| 18884 |  |  | 18884 |
| 18885 | Ptr<cv::ORB> * self1 = 0; |  | 18885 | Ptr<cv::ORB> * self1 = 0;
| 18886 | if (!pyopencv_ORB_getp(self, self1)) |  | 18886 | if (!pyopencv_ORB_getp(self, self1))
| 18887 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18887 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18888 | Ptr<cv::ORB> _self_ = *(self1); |  | 18888 | Ptr<cv::ORB> _self_ = *(self1);
| 18889 | PyObject* pyobj_maxFeatures = NULL; |  | 18889 | PyObject* pyobj_maxFeatures = NULL;
| 18890 | int maxFeatures=0; |  | 18890 | int maxFeatures=0;
| 18891 |  |  | 18891 |
| 18892 | const char* keywords[] = { "maxFeatures", NULL }; |  | 18892 | const char* keywords[] = { "maxFeatures", NULL };
| 18893 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setMaxFeatures", (char**)keywords, &pyobj_maxFeatures) && |  | 18893 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setMaxFeatures", (char**)keywords, &pyobj_maxFeatures) &&
| 18894 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) ) |  | 18894 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) )
| 18895 | { |  | 18895 | {
| 18896 | ERRWRAP2(_self_->setMaxFeatures(maxFeatures)); |  | 18896 | ERRWRAP2(_self_->setMaxFeatures(maxFeatures));
| 18897 | Py_RETURN_NONE; |  | 18897 | Py_RETURN_NONE;
| 18898 | } |  | 18898 | }
| 18899 |  |  | 18899 |
| 18900 | return NULL; |  | 18900 | return NULL;
| 18901 | } |  | 18901 | }
| 18902 |  |  | 18902 |
| 18903 | static PyObject* pyopencv_cv_ORB_setNLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18903 | static PyObject* pyopencv_cv_ORB_setNLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 18904 | { |  | 18904 | {
| 18905 | using namespace cv; |  | 18905 | using namespace cv;
| 18906 |  |  | 18906 |
| 18907 |  |  | 18907 |
| 18908 | Ptr<cv::ORB> * self1 = 0; |  | 18908 | Ptr<cv::ORB> * self1 = 0;
| 18909 | if (!pyopencv_ORB_getp(self, self1)) |  | 18909 | if (!pyopencv_ORB_getp(self, self1))
| 18910 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18910 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18911 | Ptr<cv::ORB> _self_ = *(self1); |  | 18911 | Ptr<cv::ORB> _self_ = *(self1);
| 18912 | PyObject* pyobj_nlevels = NULL; |  | 18912 | PyObject* pyobj_nlevels = NULL;
| 18913 | int nlevels=0; |  | 18913 | int nlevels=0;
| 18914 |  |  | 18914 |
| 18915 | const char* keywords[] = { "nlevels", NULL }; |  | 18915 | const char* keywords[] = { "nlevels", NULL };
| 18916 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setNLevels", (char**)keywords, &pyobj_nlevels) && |  | 18916 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setNLevels", (char**)keywords, &pyobj_nlevels) &&
| 18917 | pyopencv_to_safe(pyobj_nlevels, nlevels, ArgInfo("nlevels", 0)) ) |  | 18917 | pyopencv_to_safe(pyobj_nlevels, nlevels, ArgInfo("nlevels", 0)) )
| 18918 | { |  | 18918 | {
| 18919 | ERRWRAP2(_self_->setNLevels(nlevels)); |  | 18919 | ERRWRAP2(_self_->setNLevels(nlevels));
| 18920 | Py_RETURN_NONE; |  | 18920 | Py_RETURN_NONE;
| 18921 | } |  | 18921 | }
| 18922 |  |  | 18922 |
| 18923 | return NULL; |  | 18923 | return NULL;
| 18924 | } |  | 18924 | }
| 18925 |  |  | 18925 |
| 18926 | static PyObject* pyopencv_cv_ORB_setPatchSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18926 | static PyObject* pyopencv_cv_ORB_setPatchSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 18927 | { |  | 18927 | {
| 18928 | using namespace cv; |  | 18928 | using namespace cv;
| 18929 |  |  | 18929 |
| 18930 |  |  | 18930 |
| 18931 | Ptr<cv::ORB> * self1 = 0; |  | 18931 | Ptr<cv::ORB> * self1 = 0;
| 18932 | if (!pyopencv_ORB_getp(self, self1)) |  | 18932 | if (!pyopencv_ORB_getp(self, self1))
| 18933 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18933 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18934 | Ptr<cv::ORB> _self_ = *(self1); |  | 18934 | Ptr<cv::ORB> _self_ = *(self1);
| 18935 | PyObject* pyobj_patchSize = NULL; |  | 18935 | PyObject* pyobj_patchSize = NULL;
| 18936 | int patchSize=0; |  | 18936 | int patchSize=0;
| 18937 |  |  | 18937 |
| 18938 | const char* keywords[] = { "patchSize", NULL }; |  | 18938 | const char* keywords[] = { "patchSize", NULL };
| 18939 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setPatchSize", (char**)keywords, &pyobj_patchSize) && |  | 18939 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setPatchSize", (char**)keywords, &pyobj_patchSize) &&
| 18940 | pyopencv_to_safe(pyobj_patchSize, patchSize, ArgInfo("patchSize", 0)) ) |  | 18940 | pyopencv_to_safe(pyobj_patchSize, patchSize, ArgInfo("patchSize", 0)) )
| 18941 | { |  | 18941 | {
| 18942 | ERRWRAP2(_self_->setPatchSize(patchSize)); |  | 18942 | ERRWRAP2(_self_->setPatchSize(patchSize));
| 18943 | Py_RETURN_NONE; |  | 18943 | Py_RETURN_NONE;
| 18944 | } |  | 18944 | }
| 18945 |  |  | 18945 |
| 18946 | return NULL; |  | 18946 | return NULL;
| 18947 | } |  | 18947 | }
| 18948 |  |  | 18948 |
| 18949 | static PyObject* pyopencv_cv_ORB_setScaleFactor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18949 | static PyObject* pyopencv_cv_ORB_setScaleFactor(PyObject* self, PyObject* py_args, PyObject* kw)
| 18950 | { |  | 18950 | {
| 18951 | using namespace cv; |  | 18951 | using namespace cv;
| 18952 |  |  | 18952 |
| 18953 |  |  | 18953 |
| 18954 | Ptr<cv::ORB> * self1 = 0; |  | 18954 | Ptr<cv::ORB> * self1 = 0;
| 18955 | if (!pyopencv_ORB_getp(self, self1)) |  | 18955 | if (!pyopencv_ORB_getp(self, self1))
| 18956 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18956 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18957 | Ptr<cv::ORB> _self_ = *(self1); |  | 18957 | Ptr<cv::ORB> _self_ = *(self1);
| 18958 | PyObject* pyobj_scaleFactor = NULL; |  | 18958 | PyObject* pyobj_scaleFactor = NULL;
| 18959 | double scaleFactor=0; |  | 18959 | double scaleFactor=0;
| 18960 |  |  | 18960 |
| 18961 | const char* keywords[] = { "scaleFactor", NULL }; |  | 18961 | const char* keywords[] = { "scaleFactor", NULL };
| 18962 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setScaleFactor", (char**)keywords, &pyobj_scaleFactor) && |  | 18962 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setScaleFactor", (char**)keywords, &pyobj_scaleFactor) &&
| 18963 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) ) |  | 18963 | pyopencv_to_safe(pyobj_scaleFactor, scaleFactor, ArgInfo("scaleFactor", 0)) )
| 18964 | { |  | 18964 | {
| 18965 | ERRWRAP2(_self_->setScaleFactor(scaleFactor)); |  | 18965 | ERRWRAP2(_self_->setScaleFactor(scaleFactor));
| 18966 | Py_RETURN_NONE; |  | 18966 | Py_RETURN_NONE;
| 18967 | } |  | 18967 | }
| 18968 |  |  | 18968 |
| 18969 | return NULL; |  | 18969 | return NULL;
| 18970 | } |  | 18970 | }
| 18971 |  |  | 18971 |
| 18972 | static PyObject* pyopencv_cv_ORB_setScoreType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18972 | static PyObject* pyopencv_cv_ORB_setScoreType(PyObject* self, PyObject* py_args, PyObject* kw)
| 18973 | { |  | 18973 | {
| 18974 | using namespace cv; |  | 18974 | using namespace cv;
| 18975 |  |  | 18975 |
| 18976 |  |  | 18976 |
| 18977 | Ptr<cv::ORB> * self1 = 0; |  | 18977 | Ptr<cv::ORB> * self1 = 0;
| 18978 | if (!pyopencv_ORB_getp(self, self1)) |  | 18978 | if (!pyopencv_ORB_getp(self, self1))
| 18979 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 18979 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 18980 | Ptr<cv::ORB> _self_ = *(self1); |  | 18980 | Ptr<cv::ORB> _self_ = *(self1);
| 18981 | PyObject* pyobj_scoreType = NULL; |  | 18981 | PyObject* pyobj_scoreType = NULL;
| 18982 | ORB_ScoreType scoreType=static_cast<ORB_ScoreType>(0); |  | 18982 | ORB_ScoreType scoreType=static_cast<ORB_ScoreType>(0);
| 18983 |  |  | 18983 |
| 18984 | const char* keywords[] = { "scoreType", NULL }; |  | 18984 | const char* keywords[] = { "scoreType", NULL };
| 18985 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setScoreType", (char**)keywords, &pyobj_scoreType) && |  | 18985 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setScoreType", (char**)keywords, &pyobj_scoreType) &&
| 18986 | pyopencv_to_safe(pyobj_scoreType, scoreType, ArgInfo("scoreType", 0)) ) |  | 18986 | pyopencv_to_safe(pyobj_scoreType, scoreType, ArgInfo("scoreType", 0)) )
| 18987 | { |  | 18987 | {
| 18988 | ERRWRAP2(_self_->setScoreType(scoreType)); |  | 18988 | ERRWRAP2(_self_->setScoreType(scoreType));
| 18989 | Py_RETURN_NONE; |  | 18989 | Py_RETURN_NONE;
| 18990 | } |  | 18990 | }
| 18991 |  |  | 18991 |
| 18992 | return NULL; |  | 18992 | return NULL;
| 18993 | } |  | 18993 | }
| 18994 |  |  | 18994 |
| 18995 | static PyObject* pyopencv_cv_ORB_setWTA_K(PyObject* self, PyObject* py_args, PyObject* kw) |  | 18995 | static PyObject* pyopencv_cv_ORB_setWTA_K(PyObject* self, PyObject* py_args, PyObject* kw)
| 18996 | { |  | 18996 | {
| 18997 | using namespace cv; |  | 18997 | using namespace cv;
| 18998 |  |  | 18998 |
| 18999 |  |  | 18999 |
| 19000 | Ptr<cv::ORB> * self1 = 0; |  | 19000 | Ptr<cv::ORB> * self1 = 0;
| 19001 | if (!pyopencv_ORB_getp(self, self1)) |  | 19001 | if (!pyopencv_ORB_getp(self, self1))
| 19002 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)"); |  | 19002 | return failmsgp("Incorrect type of self (must be 'ORB' or its derivative)");
| 19003 | Ptr<cv::ORB> _self_ = *(self1); |  | 19003 | Ptr<cv::ORB> _self_ = *(self1);
| 19004 | PyObject* pyobj_wta_k = NULL; |  | 19004 | PyObject* pyobj_wta_k = NULL;
| 19005 | int wta_k=0; |  | 19005 | int wta_k=0;
| 19006 |  |  | 19006 |
| 19007 | const char* keywords[] = { "wta_k", NULL }; |  | 19007 | const char* keywords[] = { "wta_k", NULL };
| 19008 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setWTA_K", (char**)keywords, &pyobj_wta_k) && |  | 19008 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ORB.setWTA_K", (char**)keywords, &pyobj_wta_k) &&
| 19009 | pyopencv_to_safe(pyobj_wta_k, wta_k, ArgInfo("wta_k", 0)) ) |  | 19009 | pyopencv_to_safe(pyobj_wta_k, wta_k, ArgInfo("wta_k", 0)) )
| 19010 | { |  | 19010 | {
| 19011 | ERRWRAP2(_self_->setWTA_K(wta_k)); |  | 19011 | ERRWRAP2(_self_->setWTA_K(wta_k));
| 19012 | Py_RETURN_NONE; |  | 19012 | Py_RETURN_NONE;
| 19013 | } |  | 19013 | }
| 19014 |  |  | 19014 |
| 19015 | return NULL; |  | 19015 | return NULL;
| 19016 | } |  | 19016 | }
| 19017 |  |  | 19017 |
| 19018 |  |  | 19018 |
| 19019 |  |  | 19019 |
| 19020 | // Tables (ORB) |  | 19020 | // Tables (ORB)
| 19021 |  |  | 19021 |
| 19022 | static PyGetSetDef pyopencv_ORB_getseters[] = |  | 19022 | static PyGetSetDef pyopencv_ORB_getseters[] =
| 19023 | { |  | 19023 | {
| 19024 | {NULL} /* Sentinel */ |  | 19024 | {NULL} /* Sentinel */
| 19025 | }; |  | 19025 | };
| 19026 |  |  | 19026 |
| 19027 | static PyMethodDef pyopencv_ORB_methods[] = |  | 19027 | static PyMethodDef pyopencv_ORB_methods[] =
| 19028 | { |  | 19028 | {
| 19029 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_create_static, METH_STATIC), "create([, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize[, fastThreshold]]]]]]]]]) -> retval\n. @brief The ORB constructor\n. \n. @param nfeatures The maximum number of features to retain.\n. @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical\n. pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor\n. will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor\n. will mean that to cover certain scale range you will need more pyramid levels and so the speed\n. will suffer.\n. @param nlevels The number of pyramid levels. The smallest level will have linear size equal to\n. input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).\n. @param edgeThreshold This is size of the border where the features are not detected. It should\n. roughly match the patchSize parameter.\n. @param firstLevel The level of pyramid to put source image to. Previous layers are filled\n. with upscaled source image.\n. @param WTA_K The number of points that produce each element of the oriented BRIEF descriptor. The\n. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,\n. so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3\n. random points (of course, those point coordinates are random, but they are generated from the\n. pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel\n. rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such\n. output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,\n. denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each\n. bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).\n. @param scoreType The default HARRIS_SCORE means that Harris algorithm is used to rank features\n. (the score is written to KeyPoint::score and is used to retain best nfeatures features);\n. FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,\n. but it is a little faster to compute.\n. @param patchSize size of the patch used by the oriented BRIEF descriptor. Of course, on smaller\n. pyramid layers the perceived image area covered by a feature will be larger.\n. @param fastThreshold the fast threshold"}, |  | 19029 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_create_static, METH_STATIC), "create([, nfeatures[, scaleFactor[, nlevels[, edgeThreshold[, firstLevel[, WTA_K[, scoreType[, patchSize[, fastThreshold]]]]]]]]]) -> retval\n. @brief The ORB constructor\n. \n. @param nfeatures The maximum number of features to retain.\n. @param scaleFactor Pyramid decimation ratio, greater than 1. scaleFactor==2 means the classical\n. pyramid, where each next level has 4x less pixels than the previous, but such a big scale factor\n. will degrade feature matching scores dramatically. On the other hand, too close to 1 scale factor\n. will mean that to cover certain scale range you will need more pyramid levels and so the speed\n. will suffer.\n. @param nlevels The number of pyramid levels. The smallest level will have linear size equal to\n. input_image_linear_size/pow(scaleFactor, nlevels - firstLevel).\n. @param edgeThreshold This is size of the border where the features are not detected. It should\n. roughly match the patchSize parameter.\n. @param firstLevel The level of pyramid to put source image to. Previous layers are filled\n. with upscaled source image.\n. @param WTA_K The number of points that produce each element of the oriented BRIEF descriptor. The\n. default value 2 means the BRIEF where we take a random point pair and compare their brightnesses,\n. so we get 0/1 response. Other possible values are 3 and 4. For example, 3 means that we take 3\n. random points (of course, those point coordinates are random, but they are generated from the\n. pre-defined seed, so each element of BRIEF descriptor is computed deterministically from the pixel\n. rectangle), find point of maximum brightness and output index of the winner (0, 1 or 2). Such\n. output will occupy 2 bits, and therefore it will need a special variant of Hamming distance,\n. denoted as NORM_HAMMING2 (2 bits per bin). When WTA_K=4, we take 4 random points to compute each\n. bin (that will also occupy 2 bits with possible values 0, 1, 2 or 3).\n. @param scoreType The default HARRIS_SCORE means that Harris algorithm is used to rank features\n. (the score is written to KeyPoint::score and is used to retain best nfeatures features);\n. FAST_SCORE is alternative value of the parameter that produces slightly less stable keypoints,\n. but it is a little faster to compute.\n. @param patchSize size of the patch used by the oriented BRIEF descriptor. Of course, on smaller\n. pyramid layers the perceived image area covered by a feature will be larger.\n. @param fastThreshold the fast threshold"},
| 19030 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 19030 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 19031 | {"getEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getEdgeThreshold, 0), "getEdgeThreshold() -> retval\n."}, |  | 19031 | {"getEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getEdgeThreshold, 0), "getEdgeThreshold() -> retval\n."},
| 19032 | {"getFastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getFastThreshold, 0), "getFastThreshold() -> retval\n."}, |  | 19032 | {"getFastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getFastThreshold, 0), "getFastThreshold() -> retval\n."},
| 19033 | {"getFirstLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getFirstLevel, 0), "getFirstLevel() -> retval\n."}, |  | 19033 | {"getFirstLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getFirstLevel, 0), "getFirstLevel() -> retval\n."},
| 19034 | {"getMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getMaxFeatures, 0), "getMaxFeatures() -> retval\n."}, |  | 19034 | {"getMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getMaxFeatures, 0), "getMaxFeatures() -> retval\n."},
| 19035 | {"getNLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getNLevels, 0), "getNLevels() -> retval\n."}, |  | 19035 | {"getNLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getNLevels, 0), "getNLevels() -> retval\n."},
| 19036 | {"getPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getPatchSize, 0), "getPatchSize() -> retval\n."}, |  | 19036 | {"getPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getPatchSize, 0), "getPatchSize() -> retval\n."},
| 19037 | {"getScaleFactor", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getScaleFactor, 0), "getScaleFactor() -> retval\n."}, |  | 19037 | {"getScaleFactor", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getScaleFactor, 0), "getScaleFactor() -> retval\n."},
| 19038 | {"getScoreType", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getScoreType, 0), "getScoreType() -> retval\n."}, |  | 19038 | {"getScoreType", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getScoreType, 0), "getScoreType() -> retval\n."},
| 19039 | {"getWTA_K", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getWTA_K, 0), "getWTA_K() -> retval\n."}, |  | 19039 | {"getWTA_K", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_getWTA_K, 0), "getWTA_K() -> retval\n."},
| 19040 | {"setEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setEdgeThreshold, 0), "setEdgeThreshold(edgeThreshold) -> None\n."}, |  | 19040 | {"setEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setEdgeThreshold, 0), "setEdgeThreshold(edgeThreshold) -> None\n."},
| 19041 | {"setFastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setFastThreshold, 0), "setFastThreshold(fastThreshold) -> None\n."}, |  | 19041 | {"setFastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setFastThreshold, 0), "setFastThreshold(fastThreshold) -> None\n."},
| 19042 | {"setFirstLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setFirstLevel, 0), "setFirstLevel(firstLevel) -> None\n."}, |  | 19042 | {"setFirstLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setFirstLevel, 0), "setFirstLevel(firstLevel) -> None\n."},
| 19043 | {"setMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setMaxFeatures, 0), "setMaxFeatures(maxFeatures) -> None\n."}, |  | 19043 | {"setMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setMaxFeatures, 0), "setMaxFeatures(maxFeatures) -> None\n."},
| 19044 | {"setNLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setNLevels, 0), "setNLevels(nlevels) -> None\n."}, |  | 19044 | {"setNLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setNLevels, 0), "setNLevels(nlevels) -> None\n."},
| 19045 | {"setPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setPatchSize, 0), "setPatchSize(patchSize) -> None\n."}, |  | 19045 | {"setPatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setPatchSize, 0), "setPatchSize(patchSize) -> None\n."},
| 19046 | {"setScaleFactor", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setScaleFactor, 0), "setScaleFactor(scaleFactor) -> None\n."}, |  | 19046 | {"setScaleFactor", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setScaleFactor, 0), "setScaleFactor(scaleFactor) -> None\n."},
| 19047 | {"setScoreType", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setScoreType, 0), "setScoreType(scoreType) -> None\n."}, |  | 19047 | {"setScoreType", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setScoreType, 0), "setScoreType(scoreType) -> None\n."},
| 19048 | {"setWTA_K", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setWTA_K, 0), "setWTA_K(wta_k) -> None\n."}, |  | 19048 | {"setWTA_K", CV_PY_FN_WITH_KW_(pyopencv_cv_ORB_setWTA_K, 0), "setWTA_K(wta_k) -> None\n."},
| 19049 |  |  | 19049 |
| 19050 | {NULL, NULL} |  | 19050 | {NULL, NULL}
| 19051 | }; |  | 19051 | };
| 19052 |  |  | 19052 |
| 19053 | // Converter (ORB) |  | 19053 | // Converter (ORB)
| 19054 |  |  | 19054 |
| 19055 | template<> |  | 19055 | template<>
| 19056 | struct PyOpenCV_Converter< Ptr<cv::ORB> > |  | 19056 | struct PyOpenCV_Converter< Ptr<cv::ORB> >
| 19057 | { |  | 19057 | {
| 19058 | static PyObject* from(const Ptr<cv::ORB>& r) |  | 19058 | static PyObject* from(const Ptr<cv::ORB>& r)
| 19059 | { |  | 19059 | {
| 19060 | return pyopencv_ORB_Instance(r); |  | 19060 | return pyopencv_ORB_Instance(r);
| 19061 | } |  | 19061 | }
| 19062 | static bool to(PyObject* src, Ptr<cv::ORB>& dst, const ArgInfo& info) |  | 19062 | static bool to(PyObject* src, Ptr<cv::ORB>& dst, const ArgInfo& info)
| 19063 | { |  | 19063 | {
| 19064 | if(!src || src == Py_None) |  | 19064 | if(!src || src == Py_None)
| 19065 | return true; |  | 19065 | return true;
| 19066 | Ptr<cv::ORB> * dst_; |  | 19066 | Ptr<cv::ORB> * dst_;
| 19067 | if (pyopencv_ORB_getp(src, dst_)) |  | 19067 | if (pyopencv_ORB_getp(src, dst_))
| 19068 | { |  | 19068 | {
| 19069 | dst = *dst_; |  | 19069 | dst = *dst_;
| 19070 | return true; |  | 19070 | return true;
| 19071 | } |  | 19071 | }
| 19072 |  |  | 19072 |
| 19073 | failmsg("Expected Ptr<cv::ORB> for argument '%s'", info.name); |  | 19073 | failmsg("Expected Ptr<cv::ORB> for argument '%s'", info.name);
| 19074 | return false; |  | 19074 | return false;
| 19075 | } |  | 19075 | }
| 19076 | }; |  | 19076 | };
| 19077 |  |  | 19077 |
| 19078 | //================================================================================ |  | 19078 | //================================================================================
| 19079 | // PyRotationWarper (Generic) |  | 19079 | // PyRotationWarper (Generic)
| 19080 | //================================================================================ |  | 19080 | //================================================================================
| 19081 |  |  | 19081 |
| 19082 | // GetSet (PyRotationWarper) |  | 19082 | // GetSet (PyRotationWarper)
| 19083 |  |  | 19083 |
| 19084 |  |  | 19084 |
| 19085 |  |  | 19085 |
| 19086 | // Methods (PyRotationWarper) |  | 19086 | // Methods (PyRotationWarper)
| 19087 |  |  | 19087 |
| 19088 | static int pyopencv_cv_PyRotationWarper_PyRotationWarper(pyopencv_PyRotationWarper_t* self, PyObject* py_args, PyObject* kw) |  | 19088 | static int pyopencv_cv_PyRotationWarper_PyRotationWarper(pyopencv_PyRotationWarper_t* self, PyObject* py_args, PyObject* kw)
| 19089 | { |  | 19089 | {
| 19090 | using namespace cv; |  | 19090 | using namespace cv;
| 19091 |  |  | 19091 |
| 19092 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19092 | pyPrepareArgumentConversionErrorsStorage(2);
| 19093 |  |  | 19093 |
| 19094 | { |  | 19094 | {
| 19095 | PyObject* pyobj_type = NULL; |  | 19095 | PyObject* pyobj_type = NULL;
| 19096 | String type; |  | 19096 | String type;
| 19097 | PyObject* pyobj_scale = NULL; |  | 19097 | PyObject* pyobj_scale = NULL;
| 19098 | float scale=0.f; |  | 19098 | float scale=0.f;
| 19099 |  |  | 19099 |
| 19100 | const char* keywords[] = { "type", "scale", NULL }; |  | 19100 | const char* keywords[] = { "type", "scale", NULL };
| 19101 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:PyRotationWarper", (char**)keywords, &pyobj_type, &pyobj_scale) && |  | 19101 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:PyRotationWarper", (char**)keywords, &pyobj_type, &pyobj_scale) &&
| 19102 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 19102 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 19103 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) ) |  | 19103 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) )
| 19104 | { |  | 19104 | {
| 19105 | new (&(self->v)) Ptr<cv::PyRotationWarper>(); // init Ptr with placement new |  | 19105 | new (&(self->v)) Ptr<cv::PyRotationWarper>(); // init Ptr with placement new
| 19106 | if(self) ERRWRAP2(self->v.reset(new cv::PyRotationWarper(type, scale))); |  | 19106 | if(self) ERRWRAP2(self->v.reset(new cv::PyRotationWarper(type, scale)));
| 19107 | return 0; |  | 19107 | return 0;
| 19108 | } |  | 19108 | }
| 19109 |  |  | 19109 |
| 19110 |  |  | 19110 |
| 19111 | pyPopulateArgumentConversionErrors(); |  | 19111 | pyPopulateArgumentConversionErrors();
| 19112 | } |  | 19112 | }
| 19113 |  |  | 19113 |
| 19114 |  |  | 19114 |
| 19115 | { |  | 19115 | {
| 19116 |  |  | 19116 |
| 19117 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 19117 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 19118 | { |  | 19118 | {
| 19119 | new (&(self->v)) Ptr<cv::PyRotationWarper>(); // init Ptr with placement new |  | 19119 | new (&(self->v)) Ptr<cv::PyRotationWarper>(); // init Ptr with placement new
| 19120 | if(self) ERRWRAP2(self->v.reset(new cv::PyRotationWarper())); |  | 19120 | if(self) ERRWRAP2(self->v.reset(new cv::PyRotationWarper()));
| 19121 | return 0; |  | 19121 | return 0;
| 19122 | } |  | 19122 | }
| 19123 |  |  | 19123 |
| 19124 |  |  | 19124 |
| 19125 | pyPopulateArgumentConversionErrors(); |  | 19125 | pyPopulateArgumentConversionErrors();
| 19126 | } |  | 19126 | }
| 19127 | pyRaiseCVOverloadException("PyRotationWarper"); |  | 19127 | pyRaiseCVOverloadException("PyRotationWarper");
| 19128 |  |  | 19128 |
| 19129 | return -1; |  | 19129 | return -1;
| 19130 | } |  | 19130 | }
| 19131 |  |  | 19131 |
| 19132 | static PyObject* pyopencv_cv_PyRotationWarper_buildMaps(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19132 | static PyObject* pyopencv_cv_PyRotationWarper_buildMaps(PyObject* self, PyObject* py_args, PyObject* kw)
| 19133 | { |  | 19133 | {
| 19134 | using namespace cv; |  | 19134 | using namespace cv;
| 19135 |  |  | 19135 |
| 19136 |  |  | 19136 |
| 19137 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19137 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19138 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19138 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19139 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19139 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19140 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19140 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
| 19141 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19141 | pyPrepareArgumentConversionErrorsStorage(2);
| 19142 |  |  | 19142 |
| 19143 | { |  | 19143 | {
| 19144 | PyObject* pyobj_src_size = NULL; |  | 19144 | PyObject* pyobj_src_size = NULL;
| 19145 | Size src_size; |  | 19145 | Size src_size;
| 19146 | PyObject* pyobj_K = NULL; |  | 19146 | PyObject* pyobj_K = NULL;
| 19147 | Mat K; |  | 19147 | Mat K;
| 19148 | PyObject* pyobj_R = NULL; |  | 19148 | PyObject* pyobj_R = NULL;
| 19149 | Mat R; |  | 19149 | Mat R;
| 19150 | PyObject* pyobj_xmap = NULL; |  | 19150 | PyObject* pyobj_xmap = NULL;
| 19151 | Mat xmap; |  | 19151 | Mat xmap;
| 19152 | PyObject* pyobj_ymap = NULL; |  | 19152 | PyObject* pyobj_ymap = NULL;
| 19153 | Mat ymap; |  | 19153 | Mat ymap;
| 19154 | Rect retval; |  | 19154 | Rect retval;
| 19155 |  |  | 19155 |
| 19156 | const char* keywords[] = { "src_size", "K", "R", "xmap", "ymap", NULL }; |  | 19156 | const char* keywords[] = { "src_size", "K", "R", "xmap", "ymap", NULL };
| 19157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:PyRotationWarper.buildMaps", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R, &pyobj_xmap, &pyobj_ymap) && |  | 19157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:PyRotationWarper.buildMaps", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R, &pyobj_xmap, &pyobj_ymap) &&
| 19158 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) && |  | 19158 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) &&
| 19159 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19159 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19160 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 19160 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 19161 | pyopencv_to_safe(pyobj_xmap, xmap, ArgInfo("xmap", 1)) && |  | 19161 | pyopencv_to_safe(pyobj_xmap, xmap, ArgInfo("xmap", 1)) &&
| 19162 | pyopencv_to_safe(pyobj_ymap, ymap, ArgInfo("ymap", 1)) ) |  | 19162 | pyopencv_to_safe(pyobj_ymap, ymap, ArgInfo("ymap", 1)) )
| 19163 | { |  | 19163 | {
| 19164 | ERRWRAP2(retval = _self_->buildMaps(src_size, K, R, xmap, ymap)); |  | 19164 | ERRWRAP2(retval = _self_->buildMaps(src_size, K, R, xmap, ymap));
| 19165 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(xmap), pyopencv_from(ymap)); |  | 19165 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(xmap), pyopencv_from(ymap));
| 19166 | } |  | 19166 | }
| 19167 |  |  | 19167 |
| 19168 |  |  | 19168 |
| 19169 | pyPopulateArgumentConversionErrors(); |  | 19169 | pyPopulateArgumentConversionErrors();
| 19170 | } |  | 19170 | }
| 19171 |  |  | 19171 |
| 19172 |  |  | 19172 |
| 19173 | { |  | 19173 | {
| 19174 | PyObject* pyobj_src_size = NULL; |  | 19174 | PyObject* pyobj_src_size = NULL;
| 19175 | Size src_size; |  | 19175 | Size src_size;
| 19176 | PyObject* pyobj_K = NULL; |  | 19176 | PyObject* pyobj_K = NULL;
| 19177 | UMat K; |  | 19177 | UMat K;
| 19178 | PyObject* pyobj_R = NULL; |  | 19178 | PyObject* pyobj_R = NULL;
| 19179 | UMat R; |  | 19179 | UMat R;
| 19180 | PyObject* pyobj_xmap = NULL; |  | 19180 | PyObject* pyobj_xmap = NULL;
| 19181 | UMat xmap; |  | 19181 | UMat xmap;
| 19182 | PyObject* pyobj_ymap = NULL; |  | 19182 | PyObject* pyobj_ymap = NULL;
| 19183 | UMat ymap; |  | 19183 | UMat ymap;
| 19184 | Rect retval; |  | 19184 | Rect retval;
| 19185 |  |  | 19185 |
| 19186 | const char* keywords[] = { "src_size", "K", "R", "xmap", "ymap", NULL }; |  | 19186 | const char* keywords[] = { "src_size", "K", "R", "xmap", "ymap", NULL };
| 19187 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:PyRotationWarper.buildMaps", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R, &pyobj_xmap, &pyobj_ymap) && |  | 19187 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:PyRotationWarper.buildMaps", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R, &pyobj_xmap, &pyobj_ymap) &&
| 19188 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) && |  | 19188 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) &&
| 19189 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19189 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19190 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 19190 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 19191 | pyopencv_to_safe(pyobj_xmap, xmap, ArgInfo("xmap", 1)) && |  | 19191 | pyopencv_to_safe(pyobj_xmap, xmap, ArgInfo("xmap", 1)) &&
| 19192 | pyopencv_to_safe(pyobj_ymap, ymap, ArgInfo("ymap", 1)) ) |  | 19192 | pyopencv_to_safe(pyobj_ymap, ymap, ArgInfo("ymap", 1)) )
| 19193 | { |  | 19193 | {
| 19194 | ERRWRAP2(retval = _self_->buildMaps(src_size, K, R, xmap, ymap)); |  | 19194 | ERRWRAP2(retval = _self_->buildMaps(src_size, K, R, xmap, ymap));
| 19195 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(xmap), pyopencv_from(ymap)); |  | 19195 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(xmap), pyopencv_from(ymap));
| 19196 | } |  | 19196 | }
| 19197 |  |  | 19197 |
| 19198 |  |  | 19198 |
| 19199 | pyPopulateArgumentConversionErrors(); |  | 19199 | pyPopulateArgumentConversionErrors();
| 19200 | } |  | 19200 | }
| 19201 | pyRaiseCVOverloadException("buildMaps"); |  | 19201 | pyRaiseCVOverloadException("buildMaps");
| 19202 |  |  | 19202 |
| 19203 | return NULL; |  | 19203 | return NULL;
| 19204 | } |  | 19204 | }
| 19205 |  |  | 19205 |
| 19206 | static PyObject* pyopencv_cv_PyRotationWarper_getScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19206 | static PyObject* pyopencv_cv_PyRotationWarper_getScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 19207 | { |  | 19207 | {
| 19208 | using namespace cv; |  | 19208 | using namespace cv;
| 19209 |  |  | 19209 |
| 19210 |  |  | 19210 |
| 19211 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19211 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19212 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19212 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19213 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19213 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19214 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19214 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
| 19215 | float retval; |  | 19215 | float retval;
| 19216 |  |  | 19216 |
| 19217 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 19217 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 19218 | { |  | 19218 | {
| 19219 | ERRWRAP2(retval = _self_->getScale()); |  | 19219 | ERRWRAP2(retval = _self_->getScale());
| 19220 | return pyopencv_from(retval); |  | 19220 | return pyopencv_from(retval);
| 19221 | } |  | 19221 | }
| 19222 |  |  | 19222 |
| 19223 | return NULL; |  | 19223 | return NULL;
| 19224 | } |  | 19224 | }
| 19225 |  |  | 19225 |
| 19226 | static PyObject* pyopencv_cv_PyRotationWarper_setScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19226 | static PyObject* pyopencv_cv_PyRotationWarper_setScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 19227 | { |  | 19227 | {
| 19228 | using namespace cv; |  | 19228 | using namespace cv;
| 19229 |  |  | 19229 |
| 19230 |  |  | 19230 |
| 19231 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19231 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19232 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19232 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19233 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19233 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19234 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19234 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
| 19235 | PyObject* pyobj_arg1 = NULL; |  | 19235 | PyObject* pyobj_arg1 = NULL;
| 19236 | float arg1=0.f; |  | 19236 | float arg1=0.f;
| 19237 |  |  | 19237 |
| 19238 | const char* keywords[] = { "arg1", NULL }; |  | 19238 | const char* keywords[] = { "arg1", NULL };
| 19239 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:PyRotationWarper.setScale", (char**)keywords, &pyobj_arg1) && |  | 19239 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:PyRotationWarper.setScale", (char**)keywords, &pyobj_arg1) &&
| 19240 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) ) |  | 19240 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) )
| 19241 | { |  | 19241 | {
| 19242 | ERRWRAP2(_self_->setScale(arg1)); |  | 19242 | ERRWRAP2(_self_->setScale(arg1));
| 19243 | Py_RETURN_NONE; |  | 19243 | Py_RETURN_NONE;
| 19244 | } |  | 19244 | }
| 19245 |  |  | 19245 |
| 19246 | return NULL; |  | 19246 | return NULL;
| 19247 | } |  | 19247 | }
| 19248 |  |  | 19248 |
| 19249 | static PyObject* pyopencv_cv_PyRotationWarper_warp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19249 | static PyObject* pyopencv_cv_PyRotationWarper_warp(PyObject* self, PyObject* py_args, PyObject* kw)
| 19250 | { |  | 19250 | {
| 19251 | using namespace cv; |  | 19251 | using namespace cv;
| 19252 |  |  | 19252 |
| 19253 |  |  | 19253 |
| 19254 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19254 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19255 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19255 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19256 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19256 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19257 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19257 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
| 19258 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19258 | pyPrepareArgumentConversionErrorsStorage(2);
| 19259 |  |  | 19259 |
| 19260 | { |  | 19260 | {
| 19261 | PyObject* pyobj_src = NULL; |  | 19261 | PyObject* pyobj_src = NULL;
| 19262 | Mat src; |  | 19262 | Mat src;
| 19263 | PyObject* pyobj_K = NULL; |  | 19263 | PyObject* pyobj_K = NULL;
| 19264 | Mat K; |  | 19264 | Mat K;
| 19265 | PyObject* pyobj_R = NULL; |  | 19265 | PyObject* pyobj_R = NULL;
| 19266 | Mat R; |  | 19266 | Mat R;
| 19267 | PyObject* pyobj_interp_mode = NULL; |  | 19267 | PyObject* pyobj_interp_mode = NULL;
| 19268 | int interp_mode=0; |  | 19268 | int interp_mode=0;
| 19269 | PyObject* pyobj_border_mode = NULL; |  | 19269 | PyObject* pyobj_border_mode = NULL;
| 19270 | int border_mode=0; |  | 19270 | int border_mode=0;
| 19271 | PyObject* pyobj_dst = NULL; |  | 19271 | PyObject* pyobj_dst = NULL;
| 19272 | Mat dst; |  | 19272 | Mat dst;
| 19273 | Point retval; |  | 19273 | Point retval;
| 19274 |  |  | 19274 |
| 19275 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst", NULL }; |  | 19275 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst", NULL };
| 19276 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:PyRotationWarper.warp", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst) && |  | 19276 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:PyRotationWarper.warp", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst) &&
| 19277 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 19277 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 19278 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19278 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19279 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 19279 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 19280 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) && |  | 19280 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) &&
| 19281 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) && |  | 19281 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) &&
| 19282 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 19282 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 19283 | { |  | 19283 | {
| 19284 | ERRWRAP2(retval = _self_->warp(src, K, R, interp_mode, border_mode, dst)); |  | 19284 | ERRWRAP2(retval = _self_->warp(src, K, R, interp_mode, border_mode, dst));
| 19285 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst)); |  | 19285 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst));
| 19286 | } |  | 19286 | }
| 19287 |  |  | 19287 |
| 19288 |  |  | 19288 |
| 19289 | pyPopulateArgumentConversionErrors(); |  | 19289 | pyPopulateArgumentConversionErrors();
| 19290 | } |  | 19290 | }
| 19291 |  |  | 19291 |
| 19292 |  |  | 19292 |
| 19293 | { |  | 19293 | {
| 19294 | PyObject* pyobj_src = NULL; |  | 19294 | PyObject* pyobj_src = NULL;
| 19295 | UMat src; |  | 19295 | UMat src;
| 19296 | PyObject* pyobj_K = NULL; |  | 19296 | PyObject* pyobj_K = NULL;
| 19297 | UMat K; |  | 19297 | UMat K;
| 19298 | PyObject* pyobj_R = NULL; |  | 19298 | PyObject* pyobj_R = NULL;
| 19299 | UMat R; |  | 19299 | UMat R;
| 19300 | PyObject* pyobj_interp_mode = NULL; |  | 19300 | PyObject* pyobj_interp_mode = NULL;
| 19301 | int interp_mode=0; |  | 19301 | int interp_mode=0;
| 19302 | PyObject* pyobj_border_mode = NULL; |  | 19302 | PyObject* pyobj_border_mode = NULL;
| 19303 | int border_mode=0; |  | 19303 | int border_mode=0;
| 19304 | PyObject* pyobj_dst = NULL; |  | 19304 | PyObject* pyobj_dst = NULL;
| 19305 | UMat dst; |  | 19305 | UMat dst;
| 19306 | Point retval; |  | 19306 | Point retval;
| 19307 |  |  | 19307 |
| 19308 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst", NULL }; |  | 19308 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst", NULL };
| 19309 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:PyRotationWarper.warp", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst) && |  | 19309 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:PyRotationWarper.warp", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst) &&
| 19310 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 19310 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 19311 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19311 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19312 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 19312 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 19313 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) && |  | 19313 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) &&
| 19314 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) && |  | 19314 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) &&
| 19315 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 19315 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 19316 | { |  | 19316 | {
| 19317 | ERRWRAP2(retval = _self_->warp(src, K, R, interp_mode, border_mode, dst)); |  | 19317 | ERRWRAP2(retval = _self_->warp(src, K, R, interp_mode, border_mode, dst));
| 19318 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst)); |  | 19318 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dst));
| 19319 | } |  | 19319 | }
| 19320 |  |  | 19320 |
| 19321 |  |  | 19321 |
| 19322 | pyPopulateArgumentConversionErrors(); |  | 19322 | pyPopulateArgumentConversionErrors();
| 19323 | } |  | 19323 | }
| 19324 | pyRaiseCVOverloadException("warp"); |  | 19324 | pyRaiseCVOverloadException("warp");
| 19325 |  |  | 19325 |
| 19326 | return NULL; |  | 19326 | return NULL;
| 19327 | } |  | 19327 | }
| 19328 |  |  | 19328 |
| 19329 | static PyObject* pyopencv_cv_PyRotationWarper_warpBackward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19329 | static PyObject* pyopencv_cv_PyRotationWarper_warpBackward(PyObject* self, PyObject* py_args, PyObject* kw)
| 19330 | { |  | 19330 | {
| 19331 | using namespace cv; |  | 19331 | using namespace cv;
| 19332 |  |  | 19332 |
| 19333 |  |  | 19333 |
| 19334 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19334 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19335 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19335 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19336 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19336 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19337 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19337 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
| 19338 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19338 | pyPrepareArgumentConversionErrorsStorage(2);
| 19339 |  |  | 19339 |
| 19340 | { |  | 19340 | {
| 19341 | PyObject* pyobj_src = NULL; |  | 19341 | PyObject* pyobj_src = NULL;
| 19342 | Mat src; |  | 19342 | Mat src;
| 19343 | PyObject* pyobj_K = NULL; |  | 19343 | PyObject* pyobj_K = NULL;
| 19344 | Mat K; |  | 19344 | Mat K;
| 19345 | PyObject* pyobj_R = NULL; |  | 19345 | PyObject* pyobj_R = NULL;
| 19346 | Mat R; |  | 19346 | Mat R;
| 19347 | PyObject* pyobj_interp_mode = NULL; |  | 19347 | PyObject* pyobj_interp_mode = NULL;
| 19348 | int interp_mode=0; |  | 19348 | int interp_mode=0;
| 19349 | PyObject* pyobj_border_mode = NULL; |  | 19349 | PyObject* pyobj_border_mode = NULL;
| 19350 | int border_mode=0; |  | 19350 | int border_mode=0;
| 19351 | PyObject* pyobj_dst_size = NULL; |  | 19351 | PyObject* pyobj_dst_size = NULL;
| 19352 | Size dst_size; |  | 19352 | Size dst_size;
| 19353 | PyObject* pyobj_dst = NULL; |  | 19353 | PyObject* pyobj_dst = NULL;
| 19354 | Mat dst; |  | 19354 | Mat dst;
| 19355 |  |  | 19355 |
| 19356 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst_size", "dst", NULL }; |  | 19356 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst_size", "dst", NULL };
| 19357 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:PyRotationWarper.warpBackward", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst_size, &pyobj_dst) && |  | 19357 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:PyRotationWarper.warpBackward", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst_size, &pyobj_dst) &&
| 19358 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 19358 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 19359 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19359 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19360 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 19360 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 19361 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) && |  | 19361 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) &&
| 19362 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) && |  | 19362 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) &&
| 19363 | pyopencv_to_safe(pyobj_dst_size, dst_size, ArgInfo("dst_size", 0)) && |  | 19363 | pyopencv_to_safe(pyobj_dst_size, dst_size, ArgInfo("dst_size", 0)) &&
| 19364 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 19364 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 19365 | { |  | 19365 | {
| 19366 | ERRWRAP2(_self_->warpBackward(src, K, R, interp_mode, border_mode, dst_size, dst)); |  | 19366 | ERRWRAP2(_self_->warpBackward(src, K, R, interp_mode, border_mode, dst_size, dst));
| 19367 | return pyopencv_from(dst); |  | 19367 | return pyopencv_from(dst);
| 19368 | } |  | 19368 | }
| 19369 |  |  | 19369 |
| 19370 |  |  | 19370 |
| 19371 | pyPopulateArgumentConversionErrors(); |  | 19371 | pyPopulateArgumentConversionErrors();
| 19372 | } |  | 19372 | }
| 19373 |  |  | 19373 |
| 19374 |  |  | 19374 |
| 19375 | { |  | 19375 | {
| 19376 | PyObject* pyobj_src = NULL; |  | 19376 | PyObject* pyobj_src = NULL;
| 19377 | UMat src; |  | 19377 | UMat src;
| 19378 | PyObject* pyobj_K = NULL; |  | 19378 | PyObject* pyobj_K = NULL;
| 19379 | UMat K; |  | 19379 | UMat K;
| 19380 | PyObject* pyobj_R = NULL; |  | 19380 | PyObject* pyobj_R = NULL;
| 19381 | UMat R; |  | 19381 | UMat R;
| 19382 | PyObject* pyobj_interp_mode = NULL; |  | 19382 | PyObject* pyobj_interp_mode = NULL;
| 19383 | int interp_mode=0; |  | 19383 | int interp_mode=0;
| 19384 | PyObject* pyobj_border_mode = NULL; |  | 19384 | PyObject* pyobj_border_mode = NULL;
| 19385 | int border_mode=0; |  | 19385 | int border_mode=0;
| 19386 | PyObject* pyobj_dst_size = NULL; |  | 19386 | PyObject* pyobj_dst_size = NULL;
| 19387 | Size dst_size; |  | 19387 | Size dst_size;
| 19388 | PyObject* pyobj_dst = NULL; |  | 19388 | PyObject* pyobj_dst = NULL;
| 19389 | UMat dst; |  | 19389 | UMat dst;
| 19390 |  |  | 19390 |
| 19391 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst_size", "dst", NULL }; |  | 19391 | const char* keywords[] = { "src", "K", "R", "interp_mode", "border_mode", "dst_size", "dst", NULL };
| 19392 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:PyRotationWarper.warpBackward", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst_size, &pyobj_dst) && |  | 19392 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:PyRotationWarper.warpBackward", (char**)keywords, &pyobj_src, &pyobj_K, &pyobj_R, &pyobj_interp_mode, &pyobj_border_mode, &pyobj_dst_size, &pyobj_dst) &&
| 19393 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 19393 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 19394 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19394 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19395 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 19395 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 19396 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) && |  | 19396 | pyopencv_to_safe(pyobj_interp_mode, interp_mode, ArgInfo("interp_mode", 0)) &&
| 19397 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) && |  | 19397 | pyopencv_to_safe(pyobj_border_mode, border_mode, ArgInfo("border_mode", 0)) &&
| 19398 | pyopencv_to_safe(pyobj_dst_size, dst_size, ArgInfo("dst_size", 0)) && |  | 19398 | pyopencv_to_safe(pyobj_dst_size, dst_size, ArgInfo("dst_size", 0)) &&
| 19399 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 19399 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 19400 | { |  | 19400 | {
| 19401 | ERRWRAP2(_self_->warpBackward(src, K, R, interp_mode, border_mode, dst_size, dst)); |  | 19401 | ERRWRAP2(_self_->warpBackward(src, K, R, interp_mode, border_mode, dst_size, dst));
| 19402 | return pyopencv_from(dst); |  | 19402 | return pyopencv_from(dst);
| 19403 | } |  | 19403 | }
| 19404 |  |  | 19404 |
| 19405 |  |  | 19405 |
| 19406 | pyPopulateArgumentConversionErrors(); |  | 19406 | pyPopulateArgumentConversionErrors();
| 19407 | } |  | 19407 | }
| 19408 | pyRaiseCVOverloadException("warpBackward"); |  | 19408 | pyRaiseCVOverloadException("warpBackward");
| 19409 |  |  | 19409 |
| 19410 | return NULL; |  | 19410 | return NULL;
| 19411 | } |  | 19411 | }
| 19412 |  |  | 19412 |
| 19413 | static PyObject* pyopencv_cv_PyRotationWarper_warpPoint(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19413 | static PyObject* pyopencv_cv_PyRotationWarper_warpPoint(PyObject* self, PyObject* py_args, PyObject* kw)
| 19414 | { |  | 19414 | {
| 19415 | using namespace cv; |  | 19415 | using namespace cv;
| 19416 |  |  | 19416 |
| 19417 |  |  | 19417 |
| 19418 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19418 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19419 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19419 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19420 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19420 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19421 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19421 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
| 19422 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19422 | pyPrepareArgumentConversionErrorsStorage(2);
| 19423 |  |  | 19423 |
| 19424 | { |  | 19424 | {
| 19425 | PyObject* pyobj_pt = NULL; |  | 19425 | PyObject* pyobj_pt = NULL;
| 19426 | Point2f pt; |  | 19426 | Point2f pt;
| 19427 | PyObject* pyobj_K = NULL; |  | 19427 | PyObject* pyobj_K = NULL;
| 19428 | Mat K; |  | 19428 | Mat K;
| 19429 | PyObject* pyobj_R = NULL; |  | 19429 | PyObject* pyobj_R = NULL;
| 19430 | Mat R; |  | 19430 | Mat R;
| 19431 | Point2f retval; |  | 19431 | Point2f retval;
| 19432 |  |  | 19432 |
| 19433 | const char* keywords[] = { "pt", "K", "R", NULL }; |  | 19433 | const char* keywords[] = { "pt", "K", "R", NULL };
| 19434 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPoint", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) && |  | 19434 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPoint", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) &&
| 19435 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) && |  | 19435 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) &&
| 19436 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19436 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19437 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  | 19437 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) )
| 19438 | { |  | 19438 | {
| 19439 | ERRWRAP2(retval = _self_->warpPoint(pt, K, R)); |  | 19439 | ERRWRAP2(retval = _self_->warpPoint(pt, K, R));
| 19440 | return pyopencv_from(retval); |  | 19440 | return pyopencv_from(retval);
| 19441 | } |  | 19441 | }
| 19442 |  |  | 19442 |
| 19443 |  |  | 19443 |
| 19444 | pyPopulateArgumentConversionErrors(); |  | 19444 | pyPopulateArgumentConversionErrors();
| 19445 | } |  | 19445 | }
| 19446 |  |  | 19446 |
| 19447 |  |  | 19447 |
| 19448 | { |  | 19448 | {
| 19449 | PyObject* pyobj_pt = NULL; |  | 19449 | PyObject* pyobj_pt = NULL;
| 19450 | Point2f pt; |  | 19450 | Point2f pt;
| 19451 | PyObject* pyobj_K = NULL; |  | 19451 | PyObject* pyobj_K = NULL;
| 19452 | UMat K; |  | 19452 | UMat K;
| 19453 | PyObject* pyobj_R = NULL; |  | 19453 | PyObject* pyobj_R = NULL;
| 19454 | UMat R; |  | 19454 | UMat R;
| 19455 | Point2f retval; |  | 19455 | Point2f retval;
| 19456 |  |  | 19456 |
| 19457 | const char* keywords[] = { "pt", "K", "R", NULL }; |  | 19457 | const char* keywords[] = { "pt", "K", "R", NULL };
| 19458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPoint", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) && |  | 19458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPoint", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) &&
| 19459 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) && |  | 19459 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) &&
| 19460 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19460 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19461 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  | 19461 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) )
| 19462 | { |  | 19462 | {
| 19463 | ERRWRAP2(retval = _self_->warpPoint(pt, K, R)); |  | 19463 | ERRWRAP2(retval = _self_->warpPoint(pt, K, R));
| 19464 | return pyopencv_from(retval); |  | 19464 | return pyopencv_from(retval);
| 19465 | } |  | 19465 | }
| 19466 |  |  | 19466 |
| 19467 |  |  | 19467 |
| 19468 | pyPopulateArgumentConversionErrors(); |  | 19468 | pyPopulateArgumentConversionErrors();
| 19469 | } |  | 19469 | }
| 19470 | pyRaiseCVOverloadException("warpPoint"); |  | 19470 | pyRaiseCVOverloadException("warpPoint");
| 19471 |  |  | 19471 |
| 19472 | return NULL; |  | 19472 | return NULL;
| 19473 | } |  | 19473 | }
| 19474 |  |  | 19474 |
| 19475 | static PyObject* pyopencv_cv_PyRotationWarper_warpPointBackward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19475 | static PyObject* pyopencv_cv_PyRotationWarper_warpPointBackward(PyObject* self, PyObject* py_args, PyObject* kw)
| 19476 | { |  | 19476 | {
| 19477 | using namespace cv; |  | 19477 | using namespace cv;
| 19478 |  |  | 19478 |
| 19479 |  |  | 19479 |
| 19480 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19480 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19481 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19481 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19482 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19482 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19483 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19483 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
n | 19484 | pyPrepareArgumentConversionErrorsStorage(4); | n | 19484 | pyPrepareArgumentConversionErrorsStorage(2);
| 19485 |  |  | 19485 |
| 19486 | { |  | 19486 | {
| 19487 | PyObject* pyobj_pt = NULL; |  | 19487 | PyObject* pyobj_pt = NULL;
| 19488 | Point2f pt; |  | 19488 | Point2f pt;
| 19489 | PyObject* pyobj_K = NULL; |  | 19489 | PyObject* pyobj_K = NULL;
| 19490 | Mat K; |  | 19490 | Mat K;
| 19491 | PyObject* pyobj_R = NULL; |  | 19491 | PyObject* pyobj_R = NULL;
| 19492 | Mat R; |  | 19492 | Mat R;
t | 19493 | Point2f retval; | t |  |
| 19494 |  |  |  |
| 19495 | const char* keywords[] = { "pt", "K", "R", NULL }; |  |  |
| 19496 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPointBackward", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) && |  |  |
| 19497 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) && |  |  |
| 19498 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  |  |
| 19499 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  |  |
| 19500 | { |  |  |
| 19501 | ERRWRAP2(retval = _self_->warpPointBackward(pt, K, R)); |  |  |
| 19502 | return pyopencv_from(retval); |  |  |
| 19503 | } |  |  |
| 19504 |  |  |  |
| 19505 |  |  |  |
| 19506 | pyPopulateArgumentConversionErrors(); |  |  |
| 19507 | } |  |  |
| 19508 |  |  |  |
| 19509 |  |  |  |
| 19510 | { |  |  |
| 19511 | PyObject* pyobj_pt = NULL; |  |  |
| 19512 | Point2f pt; |  |  |
| 19513 | PyObject* pyobj_K = NULL; |  |  |
| 19514 | Mat K; |  |  |
| 19515 | PyObject* pyobj_R = NULL; |  |  |
| 19516 | Mat R; |  |  |
| 19517 | Point2f retval; |  |  |
| 19518 |  |  |  |
| 19519 | const char* keywords[] = { "pt", "K", "R", NULL }; |  |  |
| 19520 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPointBackward", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) && |  |  |
| 19521 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) && |  |  |
| 19522 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  |  |
| 19523 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  |  |
| 19524 | { |  |  |
| 19525 | ERRWRAP2(retval = _self_->warpPointBackward(pt, K, R)); |  |  |
| 19526 | return pyopencv_from(retval); |  |  |
| 19527 | } |  |  |
| 19528 |  |  |  |
| 19529 |  |  |  |
| 19530 | pyPopulateArgumentConversionErrors(); |  |  |
| 19531 | } |  |  |
| 19532 |  |  |  |
| 19533 |  |  |  |
| 19534 | { |  |  |
| 19535 | PyObject* pyobj_pt = NULL; |  |  |
| 19536 | Point2f pt; |  |  |
| 19537 | PyObject* pyobj_K = NULL; |  |  |
| 19538 | UMat K; |  |  |
| 19539 | PyObject* pyobj_R = NULL; |  |  |
| 19540 | UMat R; |  |  |
| 19541 | Point2f retval; |  | 19493 | Point2f retval;
| 19542 |  |  | 19494 |
| 19543 | const char* keywords[] = { "pt", "K", "R", NULL }; |  | 19495 | const char* keywords[] = { "pt", "K", "R", NULL };
| 19544 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPointBackward", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) && |  | 19496 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPointBackward", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) &&
| 19545 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) && |  | 19497 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) &&
| 19546 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19498 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19547 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  | 19499 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) )
| 19548 | { |  | 19500 | {
| 19549 | ERRWRAP2(retval = _self_->warpPointBackward(pt, K, R)); |  | 19501 | ERRWRAP2(retval = _self_->warpPointBackward(pt, K, R));
| 19550 | return pyopencv_from(retval); |  | 19502 | return pyopencv_from(retval);
| 19551 | } |  | 19503 | }
| 19552 |  |  | 19504 |
| 19553 |  |  | 19505 |
| 19554 | pyPopulateArgumentConversionErrors(); |  | 19506 | pyPopulateArgumentConversionErrors();
| 19555 | } |  | 19507 | }
| 19556 |  |  | 19508 |
| 19557 |  |  | 19509 |
| 19558 | { |  | 19510 | {
| 19559 | PyObject* pyobj_pt = NULL; |  | 19511 | PyObject* pyobj_pt = NULL;
| 19560 | Point2f pt; |  | 19512 | Point2f pt;
| 19561 | PyObject* pyobj_K = NULL; |  | 19513 | PyObject* pyobj_K = NULL;
| 19562 | UMat K; |  | 19514 | UMat K;
| 19563 | PyObject* pyobj_R = NULL; |  | 19515 | PyObject* pyobj_R = NULL;
| 19564 | UMat R; |  | 19516 | UMat R;
| 19565 | Point2f retval; |  | 19517 | Point2f retval;
| 19566 |  |  | 19518 |
| 19567 | const char* keywords[] = { "pt", "K", "R", NULL }; |  | 19519 | const char* keywords[] = { "pt", "K", "R", NULL };
| 19568 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPointBackward", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) && |  | 19520 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpPointBackward", (char**)keywords, &pyobj_pt, &pyobj_K, &pyobj_R) &&
| 19569 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) && |  | 19521 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) &&
| 19570 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19522 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19571 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  | 19523 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) )
| 19572 | { |  | 19524 | {
| 19573 | ERRWRAP2(retval = _self_->warpPointBackward(pt, K, R)); |  | 19525 | ERRWRAP2(retval = _self_->warpPointBackward(pt, K, R));
| 19574 | return pyopencv_from(retval); |  | 19526 | return pyopencv_from(retval);
| 19575 | } |  | 19527 | }
| 19576 |  |  | 19528 |
| 19577 |  |  | 19529 |
| 19578 | pyPopulateArgumentConversionErrors(); |  | 19530 | pyPopulateArgumentConversionErrors();
| 19579 | } |  | 19531 | }
| 19580 | pyRaiseCVOverloadException("warpPointBackward"); |  | 19532 | pyRaiseCVOverloadException("warpPointBackward");
| 19581 |  |  | 19533 |
| 19582 | return NULL; |  | 19534 | return NULL;
| 19583 | } |  | 19535 | }
| 19584 |  |  | 19536 |
| 19585 | static PyObject* pyopencv_cv_PyRotationWarper_warpRoi(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19537 | static PyObject* pyopencv_cv_PyRotationWarper_warpRoi(PyObject* self, PyObject* py_args, PyObject* kw)
| 19586 | { |  | 19538 | {
| 19587 | using namespace cv; |  | 19539 | using namespace cv;
| 19588 |  |  | 19540 |
| 19589 |  |  | 19541 |
| 19590 | Ptr<cv::PyRotationWarper> * self1 = 0; |  | 19542 | Ptr<cv::PyRotationWarper> * self1 = 0;
| 19591 | if (!pyopencv_PyRotationWarper_getp(self, self1)) |  | 19543 | if (!pyopencv_PyRotationWarper_getp(self, self1))
| 19592 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)"); |  | 19544 | return failmsgp("Incorrect type of self (must be 'PyRotationWarper' or its derivative)");
| 19593 | Ptr<cv::PyRotationWarper> _self_ = *(self1); |  | 19545 | Ptr<cv::PyRotationWarper> _self_ = *(self1);
| 19594 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19546 | pyPrepareArgumentConversionErrorsStorage(2);
| 19595 |  |  | 19547 |
| 19596 | { |  | 19548 | {
| 19597 | PyObject* pyobj_src_size = NULL; |  | 19549 | PyObject* pyobj_src_size = NULL;
| 19598 | Size src_size; |  | 19550 | Size src_size;
| 19599 | PyObject* pyobj_K = NULL; |  | 19551 | PyObject* pyobj_K = NULL;
| 19600 | Mat K; |  | 19552 | Mat K;
| 19601 | PyObject* pyobj_R = NULL; |  | 19553 | PyObject* pyobj_R = NULL;
| 19602 | Mat R; |  | 19554 | Mat R;
| 19603 | Rect retval; |  | 19555 | Rect retval;
| 19604 |  |  | 19556 |
| 19605 | const char* keywords[] = { "src_size", "K", "R", NULL }; |  | 19557 | const char* keywords[] = { "src_size", "K", "R", NULL };
| 19606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpRoi", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R) && |  | 19558 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpRoi", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R) &&
| 19607 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) && |  | 19559 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) &&
| 19608 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19560 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19609 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  | 19561 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) )
| 19610 | { |  | 19562 | {
| 19611 | ERRWRAP2(retval = _self_->warpRoi(src_size, K, R)); |  | 19563 | ERRWRAP2(retval = _self_->warpRoi(src_size, K, R));
| 19612 | return pyopencv_from(retval); |  | 19564 | return pyopencv_from(retval);
| 19613 | } |  | 19565 | }
| 19614 |  |  | 19566 |
| 19615 |  |  | 19567 |
| 19616 | pyPopulateArgumentConversionErrors(); |  | 19568 | pyPopulateArgumentConversionErrors();
| 19617 | } |  | 19569 | }
| 19618 |  |  | 19570 |
| 19619 |  |  | 19571 |
| 19620 | { |  | 19572 | {
| 19621 | PyObject* pyobj_src_size = NULL; |  | 19573 | PyObject* pyobj_src_size = NULL;
| 19622 | Size src_size; |  | 19574 | Size src_size;
| 19623 | PyObject* pyobj_K = NULL; |  | 19575 | PyObject* pyobj_K = NULL;
| 19624 | UMat K; |  | 19576 | UMat K;
| 19625 | PyObject* pyobj_R = NULL; |  | 19577 | PyObject* pyobj_R = NULL;
| 19626 | UMat R; |  | 19578 | UMat R;
| 19627 | Rect retval; |  | 19579 | Rect retval;
| 19628 |  |  | 19580 |
| 19629 | const char* keywords[] = { "src_size", "K", "R", NULL }; |  | 19581 | const char* keywords[] = { "src_size", "K", "R", NULL };
| 19630 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpRoi", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R) && |  | 19582 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyRotationWarper.warpRoi", (char**)keywords, &pyobj_src_size, &pyobj_K, &pyobj_R) &&
| 19631 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) && |  | 19583 | pyopencv_to_safe(pyobj_src_size, src_size, ArgInfo("src_size", 0)) &&
| 19632 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 19584 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 19633 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) ) |  | 19585 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) )
| 19634 | { |  | 19586 | {
| 19635 | ERRWRAP2(retval = _self_->warpRoi(src_size, K, R)); |  | 19587 | ERRWRAP2(retval = _self_->warpRoi(src_size, K, R));
| 19636 | return pyopencv_from(retval); |  | 19588 | return pyopencv_from(retval);
| 19637 | } |  | 19589 | }
| 19638 |  |  | 19590 |
| 19639 |  |  | 19591 |
| 19640 | pyPopulateArgumentConversionErrors(); |  | 19592 | pyPopulateArgumentConversionErrors();
| 19641 | } |  | 19593 | }
| 19642 | pyRaiseCVOverloadException("warpRoi"); |  | 19594 | pyRaiseCVOverloadException("warpRoi");
| 19643 |  |  | 19595 |
| 19644 | return NULL; |  | 19596 | return NULL;
| 19645 | } |  | 19597 | }
| 19646 |  |  | 19598 |
| 19647 |  |  | 19599 |
| 19648 |  |  | 19600 |
| 19649 | // Tables (PyRotationWarper) |  | 19601 | // Tables (PyRotationWarper)
| 19650 |  |  | 19602 |
| 19651 | static PyGetSetDef pyopencv_PyRotationWarper_getseters[] = |  | 19603 | static PyGetSetDef pyopencv_PyRotationWarper_getseters[] =
| 19652 | { |  | 19604 | {
| 19653 | {NULL} /* Sentinel */ |  | 19605 | {NULL} /* Sentinel */
| 19654 | }; |  | 19606 | };
| 19655 |  |  | 19607 |
| 19656 | static PyMethodDef pyopencv_PyRotationWarper_methods[] = |  | 19608 | static PyMethodDef pyopencv_PyRotationWarper_methods[] =
| 19657 | { |  | 19609 | {
| 19658 | {"buildMaps", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_buildMaps, 0), "buildMaps(src_size, K, R[, xmap[, ymap]]) -> retval, xmap, ymap\n. @brief Builds the projection maps according to the given camera data.\n. \n. @param src_size Source image size\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @param xmap Projection map for the x axis\n. @param ymap Projection map for the y axis\n. @return Projected image minimum bounding box"}, |  | 19610 | {"buildMaps", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_buildMaps, 0), "buildMaps(src_size, K, R[, xmap[, ymap]]) -> retval, xmap, ymap\n. @brief Builds the projection maps according to the given camera data.\n. \n. @param src_size Source image size\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @param xmap Projection map for the x axis\n. @param ymap Projection map for the y axis\n. @return Projected image minimum bounding box"},
| 19659 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_getScale, 0), "getScale() -> retval\n."}, |  | 19611 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_getScale, 0), "getScale() -> retval\n."},
| 19660 | {"setScale", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_setScale, 0), "setScale(arg1) -> None\n."}, |  | 19612 | {"setScale", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_setScale, 0), "setScale(arg1) -> None\n."},
| 19661 | {"warp", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warp, 0), "warp(src, K, R, interp_mode, border_mode[, dst]) -> retval, dst\n. @brief Projects the image.\n. \n. @param src Source image\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @param interp_mode Interpolation mode\n. @param border_mode Border extrapolation mode\n. @param dst Projected image\n. @return Project image top-left corner"}, |  | 19613 | {"warp", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warp, 0), "warp(src, K, R, interp_mode, border_mode[, dst]) -> retval, dst\n. @brief Projects the image.\n. \n. @param src Source image\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @param interp_mode Interpolation mode\n. @param border_mode Border extrapolation mode\n. @param dst Projected image\n. @return Project image top-left corner"},
| 19662 | {"warpBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpBackward, 0), "warpBackward(src, K, R, interp_mode, border_mode, dst_size[, dst]) -> dst\n. @brief Projects the image backward.\n. \n. @param src Projected image\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @param interp_mode Interpolation mode\n. @param border_mode Border extrapolation mode\n. @param dst_size Backward-projected image size\n. @param dst Backward-projected image"}, |  | 19614 | {"warpBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpBackward, 0), "warpBackward(src, K, R, interp_mode, border_mode, dst_size[, dst]) -> dst\n. @brief Projects the image backward.\n. \n. @param src Projected image\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @param interp_mode Interpolation mode\n. @param border_mode Border extrapolation mode\n. @param dst_size Backward-projected image size\n. @param dst Backward-projected image"},
| 19663 | {"warpPoint", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpPoint, 0), "warpPoint(pt, K, R) -> retval\n. @brief Projects the image point.\n. \n. @param pt Source point\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @return Projected point"}, |  | 19615 | {"warpPoint", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpPoint, 0), "warpPoint(pt, K, R) -> retval\n. @brief Projects the image point.\n. \n. @param pt Source point\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @return Projected point"},
| 19664 | {"warpPointBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpPointBackward, 0), "warpPointBackward(pt, K, R) -> retval\n. @brief Projects the image point backward.\n. \n. @param pt Projected point\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @return Backward-projected point"}, |  | 19616 | {"warpPointBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpPointBackward, 0), "warpPointBackward(pt, K, R) -> retval\n. @brief Projects the image point backward.\n. \n. @param pt Projected point\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @return Backward-projected point"},
| 19665 | {"warpRoi", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpRoi, 0), "warpRoi(src_size, K, R) -> retval\n. @param src_size Source image bounding box\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @return Projected image minimum bounding box"}, |  | 19617 | {"warpRoi", CV_PY_FN_WITH_KW_(pyopencv_cv_PyRotationWarper_warpRoi, 0), "warpRoi(src_size, K, R) -> retval\n. @param src_size Source image bounding box\n. @param K Camera intrinsic parameters\n. @param R Camera rotation matrix\n. @return Projected image minimum bounding box"},
| 19666 |  |  | 19618 |
| 19667 | {NULL, NULL} |  | 19619 | {NULL, NULL}
| 19668 | }; |  | 19620 | };
| 19669 |  |  | 19621 |
| 19670 | // Converter (PyRotationWarper) |  | 19622 | // Converter (PyRotationWarper)
| 19671 |  |  | 19623 |
| 19672 | template<> |  | 19624 | template<>
| 19673 | struct PyOpenCV_Converter< Ptr<cv::PyRotationWarper> > |  | 19625 | struct PyOpenCV_Converter< Ptr<cv::PyRotationWarper> >
| 19674 | { |  | 19626 | {
| 19675 | static PyObject* from(const Ptr<cv::PyRotationWarper>& r) |  | 19627 | static PyObject* from(const Ptr<cv::PyRotationWarper>& r)
| 19676 | { |  | 19628 | {
| 19677 | return pyopencv_PyRotationWarper_Instance(r); |  | 19629 | return pyopencv_PyRotationWarper_Instance(r);
| 19678 | } |  | 19630 | }
| 19679 | static bool to(PyObject* src, Ptr<cv::PyRotationWarper>& dst, const ArgInfo& info) |  | 19631 | static bool to(PyObject* src, Ptr<cv::PyRotationWarper>& dst, const ArgInfo& info)
| 19680 | { |  | 19632 | {
| 19681 | if(!src || src == Py_None) |  | 19633 | if(!src || src == Py_None)
| 19682 | return true; |  | 19634 | return true;
| 19683 | Ptr<cv::PyRotationWarper> * dst_; |  | 19635 | Ptr<cv::PyRotationWarper> * dst_;
| 19684 | if (pyopencv_PyRotationWarper_getp(src, dst_)) |  | 19636 | if (pyopencv_PyRotationWarper_getp(src, dst_))
| 19685 | { |  | 19637 | {
| 19686 | dst = *dst_; |  | 19638 | dst = *dst_;
| 19687 | return true; |  | 19639 | return true;
| 19688 | } |  | 19640 | }
| 19689 |  |  | 19641 |
| 19690 | failmsg("Expected Ptr<cv::PyRotationWarper> for argument '%s'", info.name); |  | 19642 | failmsg("Expected Ptr<cv::PyRotationWarper> for argument '%s'", info.name);
| 19691 | return false; |  | 19643 | return false;
| 19692 | } |  | 19644 | }
| 19693 | }; |  | 19645 | };
| 19694 |  |  | 19646 |
| 19695 | //================================================================================ |  | 19647 | //================================================================================
| 19696 | // QRCodeDetector (Generic) |  | 19648 | // QRCodeDetector (Generic)
| 19697 | //================================================================================ |  | 19649 | //================================================================================
| 19698 |  |  | 19650 |
| 19699 | // GetSet (QRCodeDetector) |  | 19651 | // GetSet (QRCodeDetector)
| 19700 |  |  | 19652 |
| 19701 |  |  | 19653 |
| 19702 |  |  | 19654 |
| 19703 | // Methods (QRCodeDetector) |  | 19655 | // Methods (QRCodeDetector)
| 19704 |  |  | 19656 |
| 19705 | static int pyopencv_cv_QRCodeDetector_QRCodeDetector(pyopencv_QRCodeDetector_t* self, PyObject* py_args, PyObject* kw) |  | 19657 | static int pyopencv_cv_QRCodeDetector_QRCodeDetector(pyopencv_QRCodeDetector_t* self, PyObject* py_args, PyObject* kw)
| 19706 | { |  | 19658 | {
| 19707 | using namespace cv; |  | 19659 | using namespace cv;
| 19708 |  |  | 19660 |
| 19709 |  |  | 19661 |
| 19710 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 19662 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 19711 | { |  | 19663 | {
| 19712 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetector()); |  | 19664 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetector());
| 19713 | return 0; |  | 19665 | return 0;
| 19714 | } |  | 19666 | }
| 19715 |  |  | 19667 |
| 19716 | return -1; |  | 19668 | return -1;
| 19717 | } |  | 19669 | }
| 19718 |  |  | 19670 |
| 19719 | static PyObject* pyopencv_cv_QRCodeDetector_decodeCurved(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19671 | static PyObject* pyopencv_cv_QRCodeDetector_decodeCurved(PyObject* self, PyObject* py_args, PyObject* kw)
| 19720 | { |  | 19672 | {
| 19721 | using namespace cv; |  | 19673 | using namespace cv;
| 19722 |  |  | 19674 |
| 19723 |  |  | 19675 |
| 19724 | cv::QRCodeDetector * self1 = 0; |  | 19676 | cv::QRCodeDetector * self1 = 0;
| 19725 | if (!pyopencv_QRCodeDetector_getp(self, self1)) |  | 19677 | if (!pyopencv_QRCodeDetector_getp(self, self1))
| 19726 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)"); |  | 19678 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)");
| 19727 | cv::QRCodeDetector* _self_ = (self1); |  | 19679 | cv::QRCodeDetector* _self_ = (self1);
| 19728 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19680 | pyPrepareArgumentConversionErrorsStorage(2);
| 19729 |  |  | 19681 |
| 19730 | { |  | 19682 | {
| 19731 | PyObject* pyobj_img = NULL; |  | 19683 | PyObject* pyobj_img = NULL;
| 19732 | Mat img; |  | 19684 | Mat img;
| 19733 | PyObject* pyobj_points = NULL; |  | 19685 | PyObject* pyobj_points = NULL;
| 19734 | Mat points; |  | 19686 | Mat points;
| 19735 | PyObject* pyobj_straight_qrcode = NULL; |  | 19687 | PyObject* pyobj_straight_qrcode = NULL;
| 19736 | Mat straight_qrcode; |  | 19688 | Mat straight_qrcode;
| 19737 | cv::String retval; |  | 19689 | cv::String retval;
| 19738 |  |  | 19690 |
| 19739 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL }; |  | 19691 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL };
| 19740 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:QRCodeDetector.decodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) && |  | 19692 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:QRCodeDetector.decodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) &&
| 19741 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 19693 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 19742 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 19694 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 19743 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) ) |  | 19695 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) )
| 19744 | { |  | 19696 | {
| 19745 | ERRWRAP2(retval = _self_->decodeCurved(img, points, straight_qrcode)); |  | 19697 | ERRWRAP2(retval = _self_->decodeCurved(img, points, straight_qrcode));
| 19746 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_qrcode)); |  | 19698 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_qrcode));
| 19747 | } |  | 19699 | }
| 19748 |  |  | 19700 |
| 19749 |  |  | 19701 |
| 19750 | pyPopulateArgumentConversionErrors(); |  | 19702 | pyPopulateArgumentConversionErrors();
| 19751 | } |  | 19703 | }
| 19752 |  |  | 19704 |
| 19753 |  |  | 19705 |
| 19754 | { |  | 19706 | {
| 19755 | PyObject* pyobj_img = NULL; |  | 19707 | PyObject* pyobj_img = NULL;
| 19756 | UMat img; |  | 19708 | UMat img;
| 19757 | PyObject* pyobj_points = NULL; |  | 19709 | PyObject* pyobj_points = NULL;
| 19758 | UMat points; |  | 19710 | UMat points;
| 19759 | PyObject* pyobj_straight_qrcode = NULL; |  | 19711 | PyObject* pyobj_straight_qrcode = NULL;
| 19760 | UMat straight_qrcode; |  | 19712 | UMat straight_qrcode;
| 19761 | cv::String retval; |  | 19713 | cv::String retval;
| 19762 |  |  | 19714 |
| 19763 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL }; |  | 19715 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL };
| 19764 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:QRCodeDetector.decodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) && |  | 19716 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:QRCodeDetector.decodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) &&
| 19765 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 19717 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 19766 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 19718 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 19767 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) ) |  | 19719 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) )
| 19768 | { |  | 19720 | {
| 19769 | ERRWRAP2(retval = _self_->decodeCurved(img, points, straight_qrcode)); |  | 19721 | ERRWRAP2(retval = _self_->decodeCurved(img, points, straight_qrcode));
| 19770 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_qrcode)); |  | 19722 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(straight_qrcode));
| 19771 | } |  | 19723 | }
| 19772 |  |  | 19724 |
| 19773 |  |  | 19725 |
| 19774 | pyPopulateArgumentConversionErrors(); |  | 19726 | pyPopulateArgumentConversionErrors();
| 19775 | } |  | 19727 | }
| 19776 | pyRaiseCVOverloadException("decodeCurved"); |  | 19728 | pyRaiseCVOverloadException("decodeCurved");
| 19777 |  |  | 19729 |
| 19778 | return NULL; |  | 19730 | return NULL;
| 19779 | } |  | 19731 | }
| 19780 |  |  | 19732 |
| 19781 | static PyObject* pyopencv_cv_QRCodeDetector_detectAndDecodeCurved(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19733 | static PyObject* pyopencv_cv_QRCodeDetector_detectAndDecodeCurved(PyObject* self, PyObject* py_args, PyObject* kw)
| 19782 | { |  | 19734 | {
| 19783 | using namespace cv; |  | 19735 | using namespace cv;
| 19784 |  |  | 19736 |
| 19785 |  |  | 19737 |
| 19786 | cv::QRCodeDetector * self1 = 0; |  | 19738 | cv::QRCodeDetector * self1 = 0;
| 19787 | if (!pyopencv_QRCodeDetector_getp(self, self1)) |  | 19739 | if (!pyopencv_QRCodeDetector_getp(self, self1))
| 19788 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)"); |  | 19740 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)");
| 19789 | cv::QRCodeDetector* _self_ = (self1); |  | 19741 | cv::QRCodeDetector* _self_ = (self1);
| 19790 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19742 | pyPrepareArgumentConversionErrorsStorage(2);
| 19791 |  |  | 19743 |
| 19792 | { |  | 19744 | {
| 19793 | PyObject* pyobj_img = NULL; |  | 19745 | PyObject* pyobj_img = NULL;
| 19794 | Mat img; |  | 19746 | Mat img;
| 19795 | PyObject* pyobj_points = NULL; |  | 19747 | PyObject* pyobj_points = NULL;
| 19796 | Mat points; |  | 19748 | Mat points;
| 19797 | PyObject* pyobj_straight_qrcode = NULL; |  | 19749 | PyObject* pyobj_straight_qrcode = NULL;
| 19798 | Mat straight_qrcode; |  | 19750 | Mat straight_qrcode;
| 19799 | std::string retval; |  | 19751 | std::string retval;
| 19800 |  |  | 19752 |
| 19801 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL }; |  | 19753 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL };
| 19802 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:QRCodeDetector.detectAndDecodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) && |  | 19754 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:QRCodeDetector.detectAndDecodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) &&
| 19803 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 19755 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 19804 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 19756 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 19805 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) ) |  | 19757 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) )
| 19806 | { |  | 19758 | {
| 19807 | ERRWRAP2(retval = _self_->detectAndDecodeCurved(img, points, straight_qrcode)); |  | 19759 | ERRWRAP2(retval = _self_->detectAndDecodeCurved(img, points, straight_qrcode));
| 19808 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_qrcode)); |  | 19760 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_qrcode));
| 19809 | } |  | 19761 | }
| 19810 |  |  | 19762 |
| 19811 |  |  | 19763 |
| 19812 | pyPopulateArgumentConversionErrors(); |  | 19764 | pyPopulateArgumentConversionErrors();
| 19813 | } |  | 19765 | }
| 19814 |  |  | 19766 |
| 19815 |  |  | 19767 |
| 19816 | { |  | 19768 | {
| 19817 | PyObject* pyobj_img = NULL; |  | 19769 | PyObject* pyobj_img = NULL;
| 19818 | UMat img; |  | 19770 | UMat img;
| 19819 | PyObject* pyobj_points = NULL; |  | 19771 | PyObject* pyobj_points = NULL;
| 19820 | UMat points; |  | 19772 | UMat points;
| 19821 | PyObject* pyobj_straight_qrcode = NULL; |  | 19773 | PyObject* pyobj_straight_qrcode = NULL;
| 19822 | UMat straight_qrcode; |  | 19774 | UMat straight_qrcode;
| 19823 | std::string retval; |  | 19775 | std::string retval;
| 19824 |  |  | 19776 |
| 19825 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL }; |  | 19777 | const char* keywords[] = { "img", "points", "straight_qrcode", NULL };
| 19826 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:QRCodeDetector.detectAndDecodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) && |  | 19778 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:QRCodeDetector.detectAndDecodeCurved", (char**)keywords, &pyobj_img, &pyobj_points, &pyobj_straight_qrcode) &&
| 19827 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 19779 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 19828 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 19780 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 19829 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) ) |  | 19781 | pyopencv_to_safe(pyobj_straight_qrcode, straight_qrcode, ArgInfo("straight_qrcode", 1)) )
| 19830 | { |  | 19782 | {
| 19831 | ERRWRAP2(retval = _self_->detectAndDecodeCurved(img, points, straight_qrcode)); |  | 19783 | ERRWRAP2(retval = _self_->detectAndDecodeCurved(img, points, straight_qrcode));
| 19832 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_qrcode)); |  | 19784 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(points), pyopencv_from(straight_qrcode));
| 19833 | } |  | 19785 | }
| 19834 |  |  | 19786 |
| 19835 |  |  | 19787 |
| 19836 | pyPopulateArgumentConversionErrors(); |  | 19788 | pyPopulateArgumentConversionErrors();
| 19837 | } |  | 19789 | }
| 19838 | pyRaiseCVOverloadException("detectAndDecodeCurved"); |  | 19790 | pyRaiseCVOverloadException("detectAndDecodeCurved");
| 19839 |  |  | 19791 |
| 19840 | return NULL; |  | 19792 | return NULL;
| 19841 | } |  | 19793 | }
| 19842 |  |  | 19794 |
| 19843 | static PyObject* pyopencv_cv_QRCodeDetector_setEpsX(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19795 | static PyObject* pyopencv_cv_QRCodeDetector_setEpsX(PyObject* self, PyObject* py_args, PyObject* kw)
| 19844 | { |  | 19796 | {
| 19845 | using namespace cv; |  | 19797 | using namespace cv;
| 19846 |  |  | 19798 |
| 19847 |  |  | 19799 |
| 19848 | cv::QRCodeDetector * self1 = 0; |  | 19800 | cv::QRCodeDetector * self1 = 0;
| 19849 | if (!pyopencv_QRCodeDetector_getp(self, self1)) |  | 19801 | if (!pyopencv_QRCodeDetector_getp(self, self1))
| 19850 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)"); |  | 19802 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)");
| 19851 | cv::QRCodeDetector* _self_ = (self1); |  | 19803 | cv::QRCodeDetector* _self_ = (self1);
| 19852 | PyObject* pyobj_epsX = NULL; |  | 19804 | PyObject* pyobj_epsX = NULL;
| 19853 | double epsX=0; |  | 19805 | double epsX=0;
| 19854 | QRCodeDetector retval; |  | 19806 | QRCodeDetector retval;
| 19855 |  |  | 19807 |
| 19856 | const char* keywords[] = { "epsX", NULL }; |  | 19808 | const char* keywords[] = { "epsX", NULL };
| 19857 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetector.setEpsX", (char**)keywords, &pyobj_epsX) && |  | 19809 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetector.setEpsX", (char**)keywords, &pyobj_epsX) &&
| 19858 | pyopencv_to_safe(pyobj_epsX, epsX, ArgInfo("epsX", 0)) ) |  | 19810 | pyopencv_to_safe(pyobj_epsX, epsX, ArgInfo("epsX", 0)) )
| 19859 | { |  | 19811 | {
| 19860 | ERRWRAP2(retval = _self_->setEpsX(epsX)); |  | 19812 | ERRWRAP2(retval = _self_->setEpsX(epsX));
| 19861 | return pyopencv_from(retval); |  | 19813 | return pyopencv_from(retval);
| 19862 | } |  | 19814 | }
| 19863 |  |  | 19815 |
| 19864 | return NULL; |  | 19816 | return NULL;
| 19865 | } |  | 19817 | }
| 19866 |  |  | 19818 |
| 19867 | static PyObject* pyopencv_cv_QRCodeDetector_setEpsY(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19819 | static PyObject* pyopencv_cv_QRCodeDetector_setEpsY(PyObject* self, PyObject* py_args, PyObject* kw)
| 19868 | { |  | 19820 | {
| 19869 | using namespace cv; |  | 19821 | using namespace cv;
| 19870 |  |  | 19822 |
| 19871 |  |  | 19823 |
| 19872 | cv::QRCodeDetector * self1 = 0; |  | 19824 | cv::QRCodeDetector * self1 = 0;
| 19873 | if (!pyopencv_QRCodeDetector_getp(self, self1)) |  | 19825 | if (!pyopencv_QRCodeDetector_getp(self, self1))
| 19874 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)"); |  | 19826 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)");
| 19875 | cv::QRCodeDetector* _self_ = (self1); |  | 19827 | cv::QRCodeDetector* _self_ = (self1);
| 19876 | PyObject* pyobj_epsY = NULL; |  | 19828 | PyObject* pyobj_epsY = NULL;
| 19877 | double epsY=0; |  | 19829 | double epsY=0;
| 19878 | QRCodeDetector retval; |  | 19830 | QRCodeDetector retval;
| 19879 |  |  | 19831 |
| 19880 | const char* keywords[] = { "epsY", NULL }; |  | 19832 | const char* keywords[] = { "epsY", NULL };
| 19881 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetector.setEpsY", (char**)keywords, &pyobj_epsY) && |  | 19833 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetector.setEpsY", (char**)keywords, &pyobj_epsY) &&
| 19882 | pyopencv_to_safe(pyobj_epsY, epsY, ArgInfo("epsY", 0)) ) |  | 19834 | pyopencv_to_safe(pyobj_epsY, epsY, ArgInfo("epsY", 0)) )
| 19883 | { |  | 19835 | {
| 19884 | ERRWRAP2(retval = _self_->setEpsY(epsY)); |  | 19836 | ERRWRAP2(retval = _self_->setEpsY(epsY));
| 19885 | return pyopencv_from(retval); |  | 19837 | return pyopencv_from(retval);
| 19886 | } |  | 19838 | }
| 19887 |  |  | 19839 |
| 19888 | return NULL; |  | 19840 | return NULL;
| 19889 | } |  | 19841 | }
| 19890 |  |  | 19842 |
| 19891 | static PyObject* pyopencv_cv_QRCodeDetector_setUseAlignmentMarkers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19843 | static PyObject* pyopencv_cv_QRCodeDetector_setUseAlignmentMarkers(PyObject* self, PyObject* py_args, PyObject* kw)
| 19892 | { |  | 19844 | {
| 19893 | using namespace cv; |  | 19845 | using namespace cv;
| 19894 |  |  | 19846 |
| 19895 |  |  | 19847 |
| 19896 | cv::QRCodeDetector * self1 = 0; |  | 19848 | cv::QRCodeDetector * self1 = 0;
| 19897 | if (!pyopencv_QRCodeDetector_getp(self, self1)) |  | 19849 | if (!pyopencv_QRCodeDetector_getp(self, self1))
| 19898 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)"); |  | 19850 | return failmsgp("Incorrect type of self (must be 'QRCodeDetector' or its derivative)");
| 19899 | cv::QRCodeDetector* _self_ = (self1); |  | 19851 | cv::QRCodeDetector* _self_ = (self1);
| 19900 | PyObject* pyobj_useAlignmentMarkers = NULL; |  | 19852 | PyObject* pyobj_useAlignmentMarkers = NULL;
| 19901 | bool useAlignmentMarkers=0; |  | 19853 | bool useAlignmentMarkers=0;
| 19902 | QRCodeDetector retval; |  | 19854 | QRCodeDetector retval;
| 19903 |  |  | 19855 |
| 19904 | const char* keywords[] = { "useAlignmentMarkers", NULL }; |  | 19856 | const char* keywords[] = { "useAlignmentMarkers", NULL };
| 19905 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetector.setUseAlignmentMarkers", (char**)keywords, &pyobj_useAlignmentMarkers) && |  | 19857 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetector.setUseAlignmentMarkers", (char**)keywords, &pyobj_useAlignmentMarkers) &&
| 19906 | pyopencv_to_safe(pyobj_useAlignmentMarkers, useAlignmentMarkers, ArgInfo("useAlignmentMarkers", 0)) ) |  | 19858 | pyopencv_to_safe(pyobj_useAlignmentMarkers, useAlignmentMarkers, ArgInfo("useAlignmentMarkers", 0)) )
| 19907 | { |  | 19859 | {
| 19908 | ERRWRAP2(retval = _self_->setUseAlignmentMarkers(useAlignmentMarkers)); |  | 19860 | ERRWRAP2(retval = _self_->setUseAlignmentMarkers(useAlignmentMarkers));
| 19909 | return pyopencv_from(retval); |  | 19861 | return pyopencv_from(retval);
| 19910 | } |  | 19862 | }
| 19911 |  |  | 19863 |
| 19912 | return NULL; |  | 19864 | return NULL;
| 19913 | } |  | 19865 | }
| 19914 |  |  | 19866 |
| 19915 |  |  | 19867 |
| 19916 |  |  | 19868 |
| 19917 | // Tables (QRCodeDetector) |  | 19869 | // Tables (QRCodeDetector)
| 19918 |  |  | 19870 |
| 19919 | static PyGetSetDef pyopencv_QRCodeDetector_getseters[] = |  | 19871 | static PyGetSetDef pyopencv_QRCodeDetector_getseters[] =
| 19920 | { |  | 19872 | {
| 19921 | {NULL} /* Sentinel */ |  | 19873 | {NULL} /* Sentinel */
| 19922 | }; |  | 19874 | };
| 19923 |  |  | 19875 |
| 19924 | static PyMethodDef pyopencv_QRCodeDetector_methods[] = |  | 19876 | static PyMethodDef pyopencv_QRCodeDetector_methods[] =
| 19925 | { |  | 19877 | {
| 19926 | {"decodeCurved", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_decodeCurved, 0), "decodeCurved(img, points[, straight_qrcode]) -> retval, straight_qrcode\n. @brief Decodes QR code on a curved surface in image once it's found by the detect() method.\n. \n. Returns UTF8-encoded output string or empty string if the code cannot be decoded.\n. @param img grayscale or color (BGR) image containing QR code.\n. @param points Quadrangle vertices found by detect() method (or some other algorithm).\n. @param straight_qrcode The optional output image containing rectified and binarized QR code"}, |  | 19878 | {"decodeCurved", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_decodeCurved, 0), "decodeCurved(img, points[, straight_qrcode]) -> retval, straight_qrcode\n. @brief Decodes QR code on a curved surface in image once it's found by the detect() method.\n. \n. Returns UTF8-encoded output string or empty string if the code cannot be decoded.\n. @param img grayscale or color (BGR) image containing QR code.\n. @param points Quadrangle vertices found by detect() method (or some other algorithm).\n. @param straight_qrcode The optional output image containing rectified and binarized QR code"},
| 19927 | {"detectAndDecodeCurved", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_detectAndDecodeCurved, 0), "detectAndDecodeCurved(img[, points[, straight_qrcode]]) -> retval, points, straight_qrcode\n. @brief Both detects and decodes QR code on a curved surface\n. \n. @param img grayscale or color (BGR) image containing QR code.\n. @param points optional output array of vertices of the found QR code quadrangle. Will be empty if not found.\n. @param straight_qrcode The optional output image containing rectified and binarized QR code"}, |  | 19879 | {"detectAndDecodeCurved", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_detectAndDecodeCurved, 0), "detectAndDecodeCurved(img[, points[, straight_qrcode]]) -> retval, points, straight_qrcode\n. @brief Both detects and decodes QR code on a curved surface\n. \n. @param img grayscale or color (BGR) image containing QR code.\n. @param points optional output array of vertices of the found QR code quadrangle. Will be empty if not found.\n. @param straight_qrcode The optional output image containing rectified and binarized QR code"},
| 19928 | {"setEpsX", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_setEpsX, 0), "setEpsX(epsX) -> retval\n. @brief sets the epsilon used during the horizontal scan of QR code stop marker detection.\n. @param epsX Epsilon neighborhood, which allows you to determine the horizontal pattern\n. of the scheme 1:1:3:1:1 according to QR code standard."}, |  | 19880 | {"setEpsX", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_setEpsX, 0), "setEpsX(epsX) -> retval\n. @brief sets the epsilon used during the horizontal scan of QR code stop marker detection.\n. @param epsX Epsilon neighborhood, which allows you to determine the horizontal pattern\n. of the scheme 1:1:3:1:1 according to QR code standard."},
| 19929 | {"setEpsY", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_setEpsY, 0), "setEpsY(epsY) -> retval\n. @brief sets the epsilon used during the vertical scan of QR code stop marker detection.\n. @param epsY Epsilon neighborhood, which allows you to determine the vertical pattern\n. of the scheme 1:1:3:1:1 according to QR code standard."}, |  | 19881 | {"setEpsY", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_setEpsY, 0), "setEpsY(epsY) -> retval\n. @brief sets the epsilon used during the vertical scan of QR code stop marker detection.\n. @param epsY Epsilon neighborhood, which allows you to determine the vertical pattern\n. of the scheme 1:1:3:1:1 according to QR code standard."},
| 19930 | {"setUseAlignmentMarkers", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_setUseAlignmentMarkers, 0), "setUseAlignmentMarkers(useAlignmentMarkers) -> retval\n. @brief use markers to improve the position of the corners of the QR code\n. *\n. * alignmentMarkers using by default"}, |  | 19882 | {"setUseAlignmentMarkers", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetector_setUseAlignmentMarkers, 0), "setUseAlignmentMarkers(useAlignmentMarkers) -> retval\n. @brief use markers to improve the position of the corners of the QR code\n. *\n. * alignmentMarkers using by default"},
| 19931 |  |  | 19883 |
| 19932 | {NULL, NULL} |  | 19884 | {NULL, NULL}
| 19933 | }; |  | 19885 | };
| 19934 |  |  | 19886 |
| 19935 | // Converter (QRCodeDetector) |  | 19887 | // Converter (QRCodeDetector)
| 19936 |  |  | 19888 |
| 19937 | template<> |  | 19889 | template<>
| 19938 | struct PyOpenCV_Converter< cv::QRCodeDetector > |  | 19890 | struct PyOpenCV_Converter< cv::QRCodeDetector >
| 19939 | { |  | 19891 | {
| 19940 | static PyObject* from(const cv::QRCodeDetector& r) |  | 19892 | static PyObject* from(const cv::QRCodeDetector& r)
| 19941 | { |  | 19893 | {
| 19942 | return pyopencv_QRCodeDetector_Instance(r); |  | 19894 | return pyopencv_QRCodeDetector_Instance(r);
| 19943 | } |  | 19895 | }
| 19944 | static bool to(PyObject* src, cv::QRCodeDetector& dst, const ArgInfo& info) |  | 19896 | static bool to(PyObject* src, cv::QRCodeDetector& dst, const ArgInfo& info)
| 19945 | { |  | 19897 | {
| 19946 | if(!src || src == Py_None) |  | 19898 | if(!src || src == Py_None)
| 19947 | return true; |  | 19899 | return true;
| 19948 | cv::QRCodeDetector * dst_; |  | 19900 | cv::QRCodeDetector * dst_;
| 19949 | if (pyopencv_QRCodeDetector_getp(src, dst_)) |  | 19901 | if (pyopencv_QRCodeDetector_getp(src, dst_))
| 19950 | { |  | 19902 | {
| 19951 | dst = *dst_; |  | 19903 | dst = *dst_;
| 19952 | return true; |  | 19904 | return true;
| 19953 | } |  | 19905 | }
| 19954 |  |  | 19906 |
| 19955 | failmsg("Expected cv::QRCodeDetector for argument '%s'", info.name); |  | 19907 | failmsg("Expected cv::QRCodeDetector for argument '%s'", info.name);
| 19956 | return false; |  | 19908 | return false;
| 19957 | } |  | 19909 | }
| 19958 | }; |  | 19910 | };
| 19959 |  |  | 19911 |
| 19960 | //================================================================================ |  | 19912 | //================================================================================
| 19961 | // QRCodeDetectorAruco (Generic) |  | 19913 | // QRCodeDetectorAruco (Generic)
| 19962 | //================================================================================ |  | 19914 | //================================================================================
| 19963 |  |  | 19915 |
| 19964 | // GetSet (QRCodeDetectorAruco) |  | 19916 | // GetSet (QRCodeDetectorAruco)
| 19965 |  |  | 19917 |
| 19966 |  |  | 19918 |
| 19967 |  |  | 19919 |
| 19968 | // Methods (QRCodeDetectorAruco) |  | 19920 | // Methods (QRCodeDetectorAruco)
| 19969 |  |  | 19921 |
| 19970 | static int pyopencv_cv_QRCodeDetectorAruco_QRCodeDetectorAruco(pyopencv_QRCodeDetectorAruco_t* self, PyObject* py_args, PyObject* kw) |  | 19922 | static int pyopencv_cv_QRCodeDetectorAruco_QRCodeDetectorAruco(pyopencv_QRCodeDetectorAruco_t* self, PyObject* py_args, PyObject* kw)
| 19971 | { |  | 19923 | {
| 19972 | using namespace cv; |  | 19924 | using namespace cv;
| 19973 |  |  | 19925 |
| 19974 | pyPrepareArgumentConversionErrorsStorage(2); |  | 19926 | pyPrepareArgumentConversionErrorsStorage(2);
| 19975 |  |  | 19927 |
| 19976 | { |  | 19928 | {
| 19977 |  |  | 19929 |
| 19978 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 19930 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 19979 | { |  | 19931 | {
| 19980 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetectorAruco()); |  | 19932 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetectorAruco());
| 19981 | return 0; |  | 19933 | return 0;
| 19982 | } |  | 19934 | }
| 19983 |  |  | 19935 |
| 19984 |  |  | 19936 |
| 19985 | pyPopulateArgumentConversionErrors(); |  | 19937 | pyPopulateArgumentConversionErrors();
| 19986 | } |  | 19938 | }
| 19987 |  |  | 19939 |
| 19988 |  |  | 19940 |
| 19989 | { |  | 19941 | {
| 19990 | PyObject* pyobj_params = NULL; |  | 19942 | PyObject* pyobj_params = NULL;
| 19991 | cv::QRCodeDetectorAruco::Params params; |  | 19943 | cv::QRCodeDetectorAruco::Params params;
| 19992 |  |  | 19944 |
| 19993 | const char* keywords[] = { "params", NULL }; |  | 19945 | const char* keywords[] = { "params", NULL };
| 19994 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetectorAruco", (char**)keywords, &pyobj_params) && |  | 19946 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetectorAruco", (char**)keywords, &pyobj_params) &&
| 19995 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 19947 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 19996 | { |  | 19948 | {
| 19997 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetectorAruco(params)); |  | 19949 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetectorAruco(params));
| 19998 | return 0; |  | 19950 | return 0;
| 19999 | } |  | 19951 | }
| 20000 |  |  | 19952 |
| 20001 |  |  | 19953 |
| 20002 | pyPopulateArgumentConversionErrors(); |  | 19954 | pyPopulateArgumentConversionErrors();
| 20003 | } |  | 19955 | }
| 20004 | pyRaiseCVOverloadException("QRCodeDetectorAruco"); |  | 19956 | pyRaiseCVOverloadException("QRCodeDetectorAruco");
| 20005 |  |  | 19957 |
| 20006 | return -1; |  | 19958 | return -1;
| 20007 | } |  | 19959 | }
| 20008 |  |  | 19960 |
| 20009 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_getArucoParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19961 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_getArucoParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 20010 | { |  | 19962 | {
| 20011 | using namespace cv; |  | 19963 | using namespace cv;
| 20012 |  |  | 19964 |
| 20013 |  |  | 19965 |
| 20014 | cv::QRCodeDetectorAruco * self1 = 0; |  | 19966 | cv::QRCodeDetectorAruco * self1 = 0;
| 20015 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1)) |  | 19967 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1))
| 20016 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)"); |  | 19968 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)");
| 20017 | cv::QRCodeDetectorAruco* _self_ = (self1); |  | 19969 | cv::QRCodeDetectorAruco* _self_ = (self1);
| 20018 | aruco::DetectorParameters retval; |  | 19970 | aruco::DetectorParameters retval;
| 20019 |  |  | 19971 |
| 20020 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 19972 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20021 | { |  | 19973 | {
| 20022 | ERRWRAP2(retval = _self_->getArucoParameters()); |  | 19974 | ERRWRAP2(retval = _self_->getArucoParameters());
| 20023 | return pyopencv_from(retval); |  | 19975 | return pyopencv_from(retval);
| 20024 | } |  | 19976 | }
| 20025 |  |  | 19977 |
| 20026 | return NULL; |  | 19978 | return NULL;
| 20027 | } |  | 19979 | }
| 20028 |  |  | 19980 |
| 20029 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_getDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 19981 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_getDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 20030 | { |  | 19982 | {
| 20031 | using namespace cv; |  | 19983 | using namespace cv;
| 20032 |  |  | 19984 |
| 20033 |  |  | 19985 |
| 20034 | cv::QRCodeDetectorAruco * self1 = 0; |  | 19986 | cv::QRCodeDetectorAruco * self1 = 0;
| 20035 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1)) |  | 19987 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1))
| 20036 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)"); |  | 19988 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)");
| 20037 | cv::QRCodeDetectorAruco* _self_ = (self1); |  | 19989 | cv::QRCodeDetectorAruco* _self_ = (self1);
| 20038 | QRCodeDetectorAruco::Params retval; |  | 19990 | QRCodeDetectorAruco::Params retval;
| 20039 |  |  | 19991 |
| 20040 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 19992 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20041 | { |  | 19993 | {
| 20042 | ERRWRAP2(retval = _self_->getDetectorParameters()); |  | 19994 | ERRWRAP2(retval = _self_->getDetectorParameters());
| 20043 | return pyopencv_from(retval); |  | 19995 | return pyopencv_from(retval);
| 20044 | } |  | 19996 | }
| 20045 |  |  | 19997 |
| 20046 | return NULL; |  | 19998 | return NULL;
| 20047 | } |  | 19999 | }
| 20048 |  |  | 20000 |
| 20049 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_setArucoParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20001 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_setArucoParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 20050 | { |  | 20002 | {
| 20051 | using namespace cv; |  | 20003 | using namespace cv;
| 20052 |  |  | 20004 |
| 20053 |  |  | 20005 |
| 20054 | cv::QRCodeDetectorAruco * self1 = 0; |  | 20006 | cv::QRCodeDetectorAruco * self1 = 0;
| 20055 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1)) |  | 20007 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1))
| 20056 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)"); |  | 20008 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)");
| 20057 | cv::QRCodeDetectorAruco* _self_ = (self1); |  | 20009 | cv::QRCodeDetectorAruco* _self_ = (self1);
| 20058 | PyObject* pyobj_params = NULL; |  | 20010 | PyObject* pyobj_params = NULL;
| 20059 | cv::aruco::DetectorParameters params; |  | 20011 | cv::aruco::DetectorParameters params;
| 20060 |  |  | 20012 |
| 20061 | const char* keywords[] = { "params", NULL }; |  | 20013 | const char* keywords[] = { "params", NULL };
| 20062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetectorAruco.setArucoParameters", (char**)keywords, &pyobj_params) && |  | 20014 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetectorAruco.setArucoParameters", (char**)keywords, &pyobj_params) &&
| 20063 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 20015 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 20064 | { |  | 20016 | {
| 20065 | ERRWRAP2(_self_->setArucoParameters(params)); |  | 20017 | ERRWRAP2(_self_->setArucoParameters(params));
| 20066 | Py_RETURN_NONE; |  | 20018 | Py_RETURN_NONE;
| 20067 | } |  | 20019 | }
| 20068 |  |  | 20020 |
| 20069 | return NULL; |  | 20021 | return NULL;
| 20070 | } |  | 20022 | }
| 20071 |  |  | 20023 |
| 20072 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_setDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20024 | static PyObject* pyopencv_cv_QRCodeDetectorAruco_setDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 20073 | { |  | 20025 | {
| 20074 | using namespace cv; |  | 20026 | using namespace cv;
| 20075 |  |  | 20027 |
| 20076 |  |  | 20028 |
| 20077 | cv::QRCodeDetectorAruco * self1 = 0; |  | 20029 | cv::QRCodeDetectorAruco * self1 = 0;
| 20078 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1)) |  | 20030 | if (!pyopencv_QRCodeDetectorAruco_getp(self, self1))
| 20079 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)"); |  | 20031 | return failmsgp("Incorrect type of self (must be 'QRCodeDetectorAruco' or its derivative)");
| 20080 | cv::QRCodeDetectorAruco* _self_ = (self1); |  | 20032 | cv::QRCodeDetectorAruco* _self_ = (self1);
| 20081 | PyObject* pyobj_params = NULL; |  | 20033 | PyObject* pyobj_params = NULL;
| 20082 | cv::QRCodeDetectorAruco::Params params; |  | 20034 | cv::QRCodeDetectorAruco::Params params;
| 20083 | QRCodeDetectorAruco retval; |  | 20035 | QRCodeDetectorAruco retval;
| 20084 |  |  | 20036 |
| 20085 | const char* keywords[] = { "params", NULL }; |  | 20037 | const char* keywords[] = { "params", NULL };
| 20086 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetectorAruco.setDetectorParameters", (char**)keywords, &pyobj_params) && |  | 20038 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:QRCodeDetectorAruco.setDetectorParameters", (char**)keywords, &pyobj_params) &&
| 20087 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 20039 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 20088 | { |  | 20040 | {
| 20089 | ERRWRAP2(retval = _self_->setDetectorParameters(params)); |  | 20041 | ERRWRAP2(retval = _self_->setDetectorParameters(params));
| 20090 | return pyopencv_from(retval); |  | 20042 | return pyopencv_from(retval);
| 20091 | } |  | 20043 | }
| 20092 |  |  | 20044 |
| 20093 | return NULL; |  | 20045 | return NULL;
| 20094 | } |  | 20046 | }
| 20095 |  |  | 20047 |
| 20096 |  |  | 20048 |
| 20097 |  |  | 20049 |
| 20098 | // Tables (QRCodeDetectorAruco) |  | 20050 | // Tables (QRCodeDetectorAruco)
| 20099 |  |  | 20051 |
| 20100 | static PyGetSetDef pyopencv_QRCodeDetectorAruco_getseters[] = |  | 20052 | static PyGetSetDef pyopencv_QRCodeDetectorAruco_getseters[] =
| 20101 | { |  | 20053 | {
| 20102 | {NULL} /* Sentinel */ |  | 20054 | {NULL} /* Sentinel */
| 20103 | }; |  | 20055 | };
| 20104 |  |  | 20056 |
| 20105 | static PyMethodDef pyopencv_QRCodeDetectorAruco_methods[] = |  | 20057 | static PyMethodDef pyopencv_QRCodeDetectorAruco_methods[] =
| 20106 | { |  | 20058 | {
| 20107 | {"getArucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_getArucoParameters, 0), "getArucoParameters() -> retval\n. @brief Aruco detector parameters are used to search for the finder patterns."}, |  | 20059 | {"getArucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_getArucoParameters, 0), "getArucoParameters() -> retval\n. @brief Aruco detector parameters are used to search for the finder patterns."},
| 20108 | {"getDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_getDetectorParameters, 0), "getDetectorParameters() -> retval\n. @brief Detector parameters getter. See cv::QRCodeDetectorAruco::Params"}, |  | 20060 | {"getDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_getDetectorParameters, 0), "getDetectorParameters() -> retval\n. @brief Detector parameters getter. See cv::QRCodeDetectorAruco::Params"},
| 20109 | {"setArucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_setArucoParameters, 0), "setArucoParameters(params) -> None\n. @brief Aruco detector parameters are used to search for the finder patterns."}, |  | 20061 | {"setArucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_setArucoParameters, 0), "setArucoParameters(params) -> None\n. @brief Aruco detector parameters are used to search for the finder patterns."},
| 20110 | {"setDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_setDetectorParameters, 0), "setDetectorParameters(params) -> retval\n. @brief Detector parameters setter. See cv::QRCodeDetectorAruco::Params"}, |  | 20062 | {"setDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeDetectorAruco_setDetectorParameters, 0), "setDetectorParameters(params) -> retval\n. @brief Detector parameters setter. See cv::QRCodeDetectorAruco::Params"},
| 20111 |  |  | 20063 |
| 20112 | {NULL, NULL} |  | 20064 | {NULL, NULL}
| 20113 | }; |  | 20065 | };
| 20114 |  |  | 20066 |
| 20115 | // Converter (QRCodeDetectorAruco) |  | 20067 | // Converter (QRCodeDetectorAruco)
| 20116 |  |  | 20068 |
| 20117 | template<> |  | 20069 | template<>
| 20118 | struct PyOpenCV_Converter< cv::QRCodeDetectorAruco > |  | 20070 | struct PyOpenCV_Converter< cv::QRCodeDetectorAruco >
| 20119 | { |  | 20071 | {
| 20120 | static PyObject* from(const cv::QRCodeDetectorAruco& r) |  | 20072 | static PyObject* from(const cv::QRCodeDetectorAruco& r)
| 20121 | { |  | 20073 | {
| 20122 | return pyopencv_QRCodeDetectorAruco_Instance(r); |  | 20074 | return pyopencv_QRCodeDetectorAruco_Instance(r);
| 20123 | } |  | 20075 | }
| 20124 | static bool to(PyObject* src, cv::QRCodeDetectorAruco& dst, const ArgInfo& info) |  | 20076 | static bool to(PyObject* src, cv::QRCodeDetectorAruco& dst, const ArgInfo& info)
| 20125 | { |  | 20077 | {
| 20126 | if(!src || src == Py_None) |  | 20078 | if(!src || src == Py_None)
| 20127 | return true; |  | 20079 | return true;
| 20128 | cv::QRCodeDetectorAruco * dst_; |  | 20080 | cv::QRCodeDetectorAruco * dst_;
| 20129 | if (pyopencv_QRCodeDetectorAruco_getp(src, dst_)) |  | 20081 | if (pyopencv_QRCodeDetectorAruco_getp(src, dst_))
| 20130 | { |  | 20082 | {
| 20131 | dst = *dst_; |  | 20083 | dst = *dst_;
| 20132 | return true; |  | 20084 | return true;
| 20133 | } |  | 20085 | }
| 20134 |  |  | 20086 |
| 20135 | failmsg("Expected cv::QRCodeDetectorAruco for argument '%s'", info.name); |  | 20087 | failmsg("Expected cv::QRCodeDetectorAruco for argument '%s'", info.name);
| 20136 | return false; |  | 20088 | return false;
| 20137 | } |  | 20089 | }
| 20138 | }; |  | 20090 | };
| 20139 |  |  | 20091 |
| 20140 | //================================================================================ |  | 20092 | //================================================================================
| 20141 | // QRCodeDetectorAruco_Params (Generic) |  | 20093 | // QRCodeDetectorAruco_Params (Generic)
| 20142 | //================================================================================ |  | 20094 | //================================================================================
| 20143 |  |  | 20095 |
| 20144 | // GetSet (QRCodeDetectorAruco_Params) |  | 20096 | // GetSet (QRCodeDetectorAruco_Params)
| 20145 |  |  | 20097 |
| 20146 |  |  | 20098 |
| 20147 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxColorsMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure) |  | 20099 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxColorsMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure)
| 20148 | { |  | 20100 | {
| 20149 | return pyopencv_from(p->v.maxColorsMismatch); |  | 20101 | return pyopencv_from(p->v.maxColorsMismatch);
| 20150 | } |  | 20102 | }
| 20151 |  |  | 20103 |
| 20152 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxColorsMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure) |  | 20104 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxColorsMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure)
| 20153 | { |  | 20105 | {
| 20154 | if (!value) |  | 20106 | if (!value)
| 20155 | { |  | 20107 | {
| 20156 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxColorsMismatch attribute"); |  | 20108 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxColorsMismatch attribute");
| 20157 | return -1; |  | 20109 | return -1;
| 20158 | } |  | 20110 | }
| 20159 | return pyopencv_to_safe(value, p->v.maxColorsMismatch, ArgInfo("value", 0)) ? 0 : -1; |  | 20111 | return pyopencv_to_safe(value, p->v.maxColorsMismatch, ArgInfo("value", 0)) ? 0 : -1;
| 20160 | } |  | 20112 | }
| 20161 |  |  | 20113 |
| 20162 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxModuleSizeMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure) |  | 20114 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxModuleSizeMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure)
| 20163 | { |  | 20115 | {
| 20164 | return pyopencv_from(p->v.maxModuleSizeMismatch); |  | 20116 | return pyopencv_from(p->v.maxModuleSizeMismatch);
| 20165 | } |  | 20117 | }
| 20166 |  |  | 20118 |
| 20167 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxModuleSizeMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure) |  | 20119 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxModuleSizeMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure)
| 20168 | { |  | 20120 | {
| 20169 | if (!value) |  | 20121 | if (!value)
| 20170 | { |  | 20122 | {
| 20171 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxModuleSizeMismatch attribute"); |  | 20123 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxModuleSizeMismatch attribute");
| 20172 | return -1; |  | 20124 | return -1;
| 20173 | } |  | 20125 | }
| 20174 | return pyopencv_to_safe(value, p->v.maxModuleSizeMismatch, ArgInfo("value", 0)) ? 0 : -1; |  | 20126 | return pyopencv_to_safe(value, p->v.maxModuleSizeMismatch, ArgInfo("value", 0)) ? 0 : -1;
| 20175 | } |  | 20127 | }
| 20176 |  |  | 20128 |
| 20177 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxPenalties(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure) |  | 20129 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxPenalties(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure)
| 20178 | { |  | 20130 | {
| 20179 | return pyopencv_from(p->v.maxPenalties); |  | 20131 | return pyopencv_from(p->v.maxPenalties);
| 20180 | } |  | 20132 | }
| 20181 |  |  | 20133 |
| 20182 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxPenalties(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure) |  | 20134 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxPenalties(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure)
| 20183 | { |  | 20135 | {
| 20184 | if (!value) |  | 20136 | if (!value)
| 20185 | { |  | 20137 | {
| 20186 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxPenalties attribute"); |  | 20138 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxPenalties attribute");
| 20187 | return -1; |  | 20139 | return -1;
| 20188 | } |  | 20140 | }
| 20189 | return pyopencv_to_safe(value, p->v.maxPenalties, ArgInfo("value", 0)) ? 0 : -1; |  | 20141 | return pyopencv_to_safe(value, p->v.maxPenalties, ArgInfo("value", 0)) ? 0 : -1;
| 20190 | } |  | 20142 | }
| 20191 |  |  | 20143 |
| 20192 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxRotation(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure) |  | 20144 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxRotation(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure)
| 20193 | { |  | 20145 | {
| 20194 | return pyopencv_from(p->v.maxRotation); |  | 20146 | return pyopencv_from(p->v.maxRotation);
| 20195 | } |  | 20147 | }
| 20196 |  |  | 20148 |
| 20197 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxRotation(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure) |  | 20149 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxRotation(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure)
| 20198 | { |  | 20150 | {
| 20199 | if (!value) |  | 20151 | if (!value)
| 20200 | { |  | 20152 | {
| 20201 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxRotation attribute"); |  | 20153 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxRotation attribute");
| 20202 | return -1; |  | 20154 | return -1;
| 20203 | } |  | 20155 | }
| 20204 | return pyopencv_to_safe(value, p->v.maxRotation, ArgInfo("value", 0)) ? 0 : -1; |  | 20156 | return pyopencv_to_safe(value, p->v.maxRotation, ArgInfo("value", 0)) ? 0 : -1;
| 20205 | } |  | 20157 | }
| 20206 |  |  | 20158 |
| 20207 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxTimingPatternMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure) |  | 20159 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_maxTimingPatternMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure)
| 20208 | { |  | 20160 | {
| 20209 | return pyopencv_from(p->v.maxTimingPatternMismatch); |  | 20161 | return pyopencv_from(p->v.maxTimingPatternMismatch);
| 20210 | } |  | 20162 | }
| 20211 |  |  | 20163 |
| 20212 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxTimingPatternMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure) |  | 20164 | static int pyopencv_QRCodeDetectorAruco_Params_set_maxTimingPatternMismatch(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure)
| 20213 | { |  | 20165 | {
| 20214 | if (!value) |  | 20166 | if (!value)
| 20215 | { |  | 20167 | {
| 20216 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxTimingPatternMismatch attribute"); |  | 20168 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxTimingPatternMismatch attribute");
| 20217 | return -1; |  | 20169 | return -1;
| 20218 | } |  | 20170 | }
| 20219 | return pyopencv_to_safe(value, p->v.maxTimingPatternMismatch, ArgInfo("value", 0)) ? 0 : -1; |  | 20171 | return pyopencv_to_safe(value, p->v.maxTimingPatternMismatch, ArgInfo("value", 0)) ? 0 : -1;
| 20220 | } |  | 20172 | }
| 20221 |  |  | 20173 |
| 20222 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_minModuleSizeInPyramid(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure) |  | 20174 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_minModuleSizeInPyramid(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure)
| 20223 | { |  | 20175 | {
| 20224 | return pyopencv_from(p->v.minModuleSizeInPyramid); |  | 20176 | return pyopencv_from(p->v.minModuleSizeInPyramid);
| 20225 | } |  | 20177 | }
| 20226 |  |  | 20178 |
| 20227 | static int pyopencv_QRCodeDetectorAruco_Params_set_minModuleSizeInPyramid(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure) |  | 20179 | static int pyopencv_QRCodeDetectorAruco_Params_set_minModuleSizeInPyramid(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure)
| 20228 | { |  | 20180 | {
| 20229 | if (!value) |  | 20181 | if (!value)
| 20230 | { |  | 20182 | {
| 20231 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minModuleSizeInPyramid attribute"); |  | 20183 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minModuleSizeInPyramid attribute");
| 20232 | return -1; |  | 20184 | return -1;
| 20233 | } |  | 20185 | }
| 20234 | return pyopencv_to_safe(value, p->v.minModuleSizeInPyramid, ArgInfo("value", 0)) ? 0 : -1; |  | 20186 | return pyopencv_to_safe(value, p->v.minModuleSizeInPyramid, ArgInfo("value", 0)) ? 0 : -1;
| 20235 | } |  | 20187 | }
| 20236 |  |  | 20188 |
| 20237 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_scaleTimingPatternScore(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure) |  | 20189 | static PyObject* pyopencv_QRCodeDetectorAruco_Params_get_scaleTimingPatternScore(pyopencv_QRCodeDetectorAruco_Params_t* p, void *closure)
| 20238 | { |  | 20190 | {
| 20239 | return pyopencv_from(p->v.scaleTimingPatternScore); |  | 20191 | return pyopencv_from(p->v.scaleTimingPatternScore);
| 20240 | } |  | 20192 | }
| 20241 |  |  | 20193 |
| 20242 | static int pyopencv_QRCodeDetectorAruco_Params_set_scaleTimingPatternScore(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure) |  | 20194 | static int pyopencv_QRCodeDetectorAruco_Params_set_scaleTimingPatternScore(pyopencv_QRCodeDetectorAruco_Params_t* p, PyObject *value, void *closure)
| 20243 | { |  | 20195 | {
| 20244 | if (!value) |  | 20196 | if (!value)
| 20245 | { |  | 20197 | {
| 20246 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scaleTimingPatternScore attribute"); |  | 20198 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scaleTimingPatternScore attribute");
| 20247 | return -1; |  | 20199 | return -1;
| 20248 | } |  | 20200 | }
| 20249 | return pyopencv_to_safe(value, p->v.scaleTimingPatternScore, ArgInfo("value", 0)) ? 0 : -1; |  | 20201 | return pyopencv_to_safe(value, p->v.scaleTimingPatternScore, ArgInfo("value", 0)) ? 0 : -1;
| 20250 | } |  | 20202 | }
| 20251 |  |  | 20203 |
| 20252 |  |  | 20204 |
| 20253 | // Methods (QRCodeDetectorAruco_Params) |  | 20205 | // Methods (QRCodeDetectorAruco_Params)
| 20254 |  |  | 20206 |
| 20255 | static int pyopencv_cv_QRCodeDetectorAruco_Params_QRCodeDetectorAruco_Params(pyopencv_QRCodeDetectorAruco_Params_t* self, PyObject* py_args, PyObject* kw) |  | 20207 | static int pyopencv_cv_QRCodeDetectorAruco_Params_QRCodeDetectorAruco_Params(pyopencv_QRCodeDetectorAruco_Params_t* self, PyObject* py_args, PyObject* kw)
| 20256 | { |  | 20208 | {
| 20257 | using namespace cv; |  | 20209 | using namespace cv;
| 20258 |  |  | 20210 |
| 20259 |  |  | 20211 |
| 20260 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20212 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20261 | { |  | 20213 | {
| 20262 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetectorAruco::Params()); |  | 20214 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeDetectorAruco::Params());
| 20263 | return 0; |  | 20215 | return 0;
| 20264 | } |  | 20216 | }
| 20265 |  |  | 20217 |
| 20266 | return -1; |  | 20218 | return -1;
| 20267 | } |  | 20219 | }
| 20268 |  |  | 20220 |
| 20269 |  |  | 20221 |
| 20270 |  |  | 20222 |
| 20271 | // Tables (QRCodeDetectorAruco_Params) |  | 20223 | // Tables (QRCodeDetectorAruco_Params)
| 20272 |  |  | 20224 |
| 20273 | static PyGetSetDef pyopencv_QRCodeDetectorAruco_Params_getseters[] = |  | 20225 | static PyGetSetDef pyopencv_QRCodeDetectorAruco_Params_getseters[] =
| 20274 | { |  | 20226 | {
| 20275 | {(char*)"maxColorsMismatch", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxColorsMismatch, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxColorsMismatch, (char*)"maxColorsMismatch", NULL}, |  | 20227 | {(char*)"maxColorsMismatch", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxColorsMismatch, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxColorsMismatch, (char*)"maxColorsMismatch", NULL},
| 20276 | {(char*)"maxModuleSizeMismatch", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxModuleSizeMismatch, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxModuleSizeMismatch, (char*)"maxModuleSizeMismatch", NULL}, |  | 20228 | {(char*)"maxModuleSizeMismatch", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxModuleSizeMismatch, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxModuleSizeMismatch, (char*)"maxModuleSizeMismatch", NULL},
| 20277 | {(char*)"maxPenalties", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxPenalties, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxPenalties, (char*)"maxPenalties", NULL}, |  | 20229 | {(char*)"maxPenalties", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxPenalties, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxPenalties, (char*)"maxPenalties", NULL},
| 20278 | {(char*)"maxRotation", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxRotation, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxRotation, (char*)"maxRotation", NULL}, |  | 20230 | {(char*)"maxRotation", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxRotation, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxRotation, (char*)"maxRotation", NULL},
| 20279 | {(char*)"maxTimingPatternMismatch", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxTimingPatternMismatch, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxTimingPatternMismatch, (char*)"maxTimingPatternMismatch", NULL}, |  | 20231 | {(char*)"maxTimingPatternMismatch", (getter)pyopencv_QRCodeDetectorAruco_Params_get_maxTimingPatternMismatch, (setter)pyopencv_QRCodeDetectorAruco_Params_set_maxTimingPatternMismatch, (char*)"maxTimingPatternMismatch", NULL},
| 20280 | {(char*)"minModuleSizeInPyramid", (getter)pyopencv_QRCodeDetectorAruco_Params_get_minModuleSizeInPyramid, (setter)pyopencv_QRCodeDetectorAruco_Params_set_minModuleSizeInPyramid, (char*)"minModuleSizeInPyramid", NULL}, |  | 20232 | {(char*)"minModuleSizeInPyramid", (getter)pyopencv_QRCodeDetectorAruco_Params_get_minModuleSizeInPyramid, (setter)pyopencv_QRCodeDetectorAruco_Params_set_minModuleSizeInPyramid, (char*)"minModuleSizeInPyramid", NULL},
| 20281 | {(char*)"scaleTimingPatternScore", (getter)pyopencv_QRCodeDetectorAruco_Params_get_scaleTimingPatternScore, (setter)pyopencv_QRCodeDetectorAruco_Params_set_scaleTimingPatternScore, (char*)"scaleTimingPatternScore", NULL}, |  | 20233 | {(char*)"scaleTimingPatternScore", (getter)pyopencv_QRCodeDetectorAruco_Params_get_scaleTimingPatternScore, (setter)pyopencv_QRCodeDetectorAruco_Params_set_scaleTimingPatternScore, (char*)"scaleTimingPatternScore", NULL},
| 20282 | {NULL} /* Sentinel */ |  | 20234 | {NULL} /* Sentinel */
| 20283 | }; |  | 20235 | };
| 20284 |  |  | 20236 |
| 20285 | static PyMethodDef pyopencv_QRCodeDetectorAruco_Params_methods[] = |  | 20237 | static PyMethodDef pyopencv_QRCodeDetectorAruco_Params_methods[] =
| 20286 | { |  | 20238 | {
| 20287 |  |  | 20239 |
| 20288 | {NULL, NULL} |  | 20240 | {NULL, NULL}
| 20289 | }; |  | 20241 | };
| 20290 |  |  | 20242 |
| 20291 | // Converter (QRCodeDetectorAruco_Params) |  | 20243 | // Converter (QRCodeDetectorAruco_Params)
| 20292 |  |  | 20244 |
| 20293 | template<> |  | 20245 | template<>
| 20294 | struct PyOpenCV_Converter< cv::QRCodeDetectorAruco::Params > |  | 20246 | struct PyOpenCV_Converter< cv::QRCodeDetectorAruco::Params >
| 20295 | { |  | 20247 | {
| 20296 | static PyObject* from(const cv::QRCodeDetectorAruco::Params& r) |  | 20248 | static PyObject* from(const cv::QRCodeDetectorAruco::Params& r)
| 20297 | { |  | 20249 | {
| 20298 | return pyopencv_QRCodeDetectorAruco_Params_Instance(r); |  | 20250 | return pyopencv_QRCodeDetectorAruco_Params_Instance(r);
| 20299 | } |  | 20251 | }
| 20300 | static bool to(PyObject* src, cv::QRCodeDetectorAruco::Params& dst, const ArgInfo& info) |  | 20252 | static bool to(PyObject* src, cv::QRCodeDetectorAruco::Params& dst, const ArgInfo& info)
| 20301 | { |  | 20253 | {
| 20302 | if(!src || src == Py_None) |  | 20254 | if(!src || src == Py_None)
| 20303 | return true; |  | 20255 | return true;
| 20304 | cv::QRCodeDetectorAruco::Params * dst_; |  | 20256 | cv::QRCodeDetectorAruco::Params * dst_;
| 20305 | if (pyopencv_QRCodeDetectorAruco_Params_getp(src, dst_)) |  | 20257 | if (pyopencv_QRCodeDetectorAruco_Params_getp(src, dst_))
| 20306 | { |  | 20258 | {
| 20307 | dst = *dst_; |  | 20259 | dst = *dst_;
| 20308 | return true; |  | 20260 | return true;
| 20309 | } |  | 20261 | }
| 20310 |  |  | 20262 |
| 20311 | failmsg("Expected cv::QRCodeDetectorAruco::Params for argument '%s'", info.name); |  | 20263 | failmsg("Expected cv::QRCodeDetectorAruco::Params for argument '%s'", info.name);
| 20312 | return false; |  | 20264 | return false;
| 20313 | } |  | 20265 | }
| 20314 | }; |  | 20266 | };
| 20315 |  |  | 20267 |
| 20316 | //================================================================================ |  | 20268 | //================================================================================
| 20317 | // QRCodeEncoder (Generic) |  | 20269 | // QRCodeEncoder (Generic)
| 20318 | //================================================================================ |  | 20270 | //================================================================================
| 20319 |  |  | 20271 |
| 20320 | // GetSet (QRCodeEncoder) |  | 20272 | // GetSet (QRCodeEncoder)
| 20321 |  |  | 20273 |
| 20322 |  |  | 20274 |
| 20323 |  |  | 20275 |
| 20324 | // Methods (QRCodeEncoder) |  | 20276 | // Methods (QRCodeEncoder)
| 20325 |  |  | 20277 |
| 20326 | static PyObject* pyopencv_cv_QRCodeEncoder_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20278 | static PyObject* pyopencv_cv_QRCodeEncoder_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 20327 | { |  | 20279 | {
| 20328 | using namespace cv; |  | 20280 | using namespace cv;
| 20329 |  |  | 20281 |
| 20330 | PyObject* pyobj_parameters = NULL; |  | 20282 | PyObject* pyobj_parameters = NULL;
| 20331 | cv::QRCodeEncoder::Params parameters=QRCodeEncoder::Params(); |  | 20283 | cv::QRCodeEncoder::Params parameters=QRCodeEncoder::Params();
| 20332 | Ptr<QRCodeEncoder> retval; |  | 20284 | Ptr<QRCodeEncoder> retval;
| 20333 |  |  | 20285 |
| 20334 | const char* keywords[] = { "parameters", NULL }; |  | 20286 | const char* keywords[] = { "parameters", NULL };
| 20335 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:QRCodeEncoder.create", (char**)keywords, &pyobj_parameters) && |  | 20287 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:QRCodeEncoder.create", (char**)keywords, &pyobj_parameters) &&
| 20336 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 20288 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 20337 | { |  | 20289 | {
| 20338 | ERRWRAP2(retval = cv::QRCodeEncoder::create(parameters)); |  | 20290 | ERRWRAP2(retval = cv::QRCodeEncoder::create(parameters));
| 20339 | return pyopencv_from(retval); |  | 20291 | return pyopencv_from(retval);
| 20340 | } |  | 20292 | }
| 20341 |  |  | 20293 |
| 20342 | return NULL; |  | 20294 | return NULL;
| 20343 | } |  | 20295 | }
| 20344 |  |  | 20296 |
| 20345 | static PyObject* pyopencv_cv_QRCodeEncoder_encode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20297 | static PyObject* pyopencv_cv_QRCodeEncoder_encode(PyObject* self, PyObject* py_args, PyObject* kw)
| 20346 | { |  | 20298 | {
| 20347 | using namespace cv; |  | 20299 | using namespace cv;
| 20348 |  |  | 20300 |
| 20349 |  |  | 20301 |
| 20350 | Ptr<cv::QRCodeEncoder> * self1 = 0; |  | 20302 | Ptr<cv::QRCodeEncoder> * self1 = 0;
| 20351 | if (!pyopencv_QRCodeEncoder_getp(self, self1)) |  | 20303 | if (!pyopencv_QRCodeEncoder_getp(self, self1))
| 20352 | return failmsgp("Incorrect type of self (must be 'QRCodeEncoder' or its derivative)"); |  | 20304 | return failmsgp("Incorrect type of self (must be 'QRCodeEncoder' or its derivative)");
| 20353 | Ptr<cv::QRCodeEncoder> _self_ = *(self1); |  | 20305 | Ptr<cv::QRCodeEncoder> _self_ = *(self1);
| 20354 | pyPrepareArgumentConversionErrorsStorage(2); |  | 20306 | pyPrepareArgumentConversionErrorsStorage(2);
| 20355 |  |  | 20307 |
| 20356 | { |  | 20308 | {
| 20357 | PyObject* pyobj_encoded_info = NULL; |  | 20309 | PyObject* pyobj_encoded_info = NULL;
| 20358 | String encoded_info; |  | 20310 | String encoded_info;
| 20359 | PyObject* pyobj_qrcode = NULL; |  | 20311 | PyObject* pyobj_qrcode = NULL;
| 20360 | Mat qrcode; |  | 20312 | Mat qrcode;
| 20361 |  |  | 20313 |
| 20362 | const char* keywords[] = { "encoded_info", "qrcode", NULL }; |  | 20314 | const char* keywords[] = { "encoded_info", "qrcode", NULL };
| 20363 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encode", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcode) && |  | 20315 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encode", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcode) &&
| 20364 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) && |  | 20316 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) &&
| 20365 | pyopencv_to_safe(pyobj_qrcode, qrcode, ArgInfo("qrcode", 1)) ) |  | 20317 | pyopencv_to_safe(pyobj_qrcode, qrcode, ArgInfo("qrcode", 1)) )
| 20366 | { |  | 20318 | {
| 20367 | ERRWRAP2(_self_->encode(encoded_info, qrcode)); |  | 20319 | ERRWRAP2(_self_->encode(encoded_info, qrcode));
| 20368 | return pyopencv_from(qrcode); |  | 20320 | return pyopencv_from(qrcode);
| 20369 | } |  | 20321 | }
| 20370 |  |  | 20322 |
| 20371 |  |  | 20323 |
| 20372 | pyPopulateArgumentConversionErrors(); |  | 20324 | pyPopulateArgumentConversionErrors();
| 20373 | } |  | 20325 | }
| 20374 |  |  | 20326 |
| 20375 |  |  | 20327 |
| 20376 | { |  | 20328 | {
| 20377 | PyObject* pyobj_encoded_info = NULL; |  | 20329 | PyObject* pyobj_encoded_info = NULL;
| 20378 | String encoded_info; |  | 20330 | String encoded_info;
| 20379 | PyObject* pyobj_qrcode = NULL; |  | 20331 | PyObject* pyobj_qrcode = NULL;
| 20380 | UMat qrcode; |  | 20332 | UMat qrcode;
| 20381 |  |  | 20333 |
| 20382 | const char* keywords[] = { "encoded_info", "qrcode", NULL }; |  | 20334 | const char* keywords[] = { "encoded_info", "qrcode", NULL };
| 20383 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encode", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcode) && |  | 20335 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encode", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcode) &&
| 20384 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) && |  | 20336 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) &&
| 20385 | pyopencv_to_safe(pyobj_qrcode, qrcode, ArgInfo("qrcode", 1)) ) |  | 20337 | pyopencv_to_safe(pyobj_qrcode, qrcode, ArgInfo("qrcode", 1)) )
| 20386 | { |  | 20338 | {
| 20387 | ERRWRAP2(_self_->encode(encoded_info, qrcode)); |  | 20339 | ERRWRAP2(_self_->encode(encoded_info, qrcode));
| 20388 | return pyopencv_from(qrcode); |  | 20340 | return pyopencv_from(qrcode);
| 20389 | } |  | 20341 | }
| 20390 |  |  | 20342 |
| 20391 |  |  | 20343 |
| 20392 | pyPopulateArgumentConversionErrors(); |  | 20344 | pyPopulateArgumentConversionErrors();
| 20393 | } |  | 20345 | }
| 20394 | pyRaiseCVOverloadException("encode"); |  | 20346 | pyRaiseCVOverloadException("encode");
| 20395 |  |  | 20347 |
| 20396 | return NULL; |  | 20348 | return NULL;
| 20397 | } |  | 20349 | }
| 20398 |  |  | 20350 |
| 20399 | static PyObject* pyopencv_cv_QRCodeEncoder_encodeStructuredAppend(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20351 | static PyObject* pyopencv_cv_QRCodeEncoder_encodeStructuredAppend(PyObject* self, PyObject* py_args, PyObject* kw)
| 20400 | { |  | 20352 | {
| 20401 | using namespace cv; |  | 20353 | using namespace cv;
| 20402 |  |  | 20354 |
| 20403 |  |  | 20355 |
| 20404 | Ptr<cv::QRCodeEncoder> * self1 = 0; |  | 20356 | Ptr<cv::QRCodeEncoder> * self1 = 0;
| 20405 | if (!pyopencv_QRCodeEncoder_getp(self, self1)) |  | 20357 | if (!pyopencv_QRCodeEncoder_getp(self, self1))
| 20406 | return failmsgp("Incorrect type of self (must be 'QRCodeEncoder' or its derivative)"); |  | 20358 | return failmsgp("Incorrect type of self (must be 'QRCodeEncoder' or its derivative)");
| 20407 | Ptr<cv::QRCodeEncoder> _self_ = *(self1); |  | 20359 | Ptr<cv::QRCodeEncoder> _self_ = *(self1);
| 20408 | pyPrepareArgumentConversionErrorsStorage(2); |  | 20360 | pyPrepareArgumentConversionErrorsStorage(2);
| 20409 |  |  | 20361 |
| 20410 | { |  | 20362 | {
| 20411 | PyObject* pyobj_encoded_info = NULL; |  | 20363 | PyObject* pyobj_encoded_info = NULL;
| 20412 | String encoded_info; |  | 20364 | String encoded_info;
| 20413 | PyObject* pyobj_qrcodes = NULL; |  | 20365 | PyObject* pyobj_qrcodes = NULL;
| 20414 | vector_Mat qrcodes; |  | 20366 | vector_Mat qrcodes;
| 20415 |  |  | 20367 |
| 20416 | const char* keywords[] = { "encoded_info", "qrcodes", NULL }; |  | 20368 | const char* keywords[] = { "encoded_info", "qrcodes", NULL };
| 20417 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encodeStructuredAppend", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcodes) && |  | 20369 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encodeStructuredAppend", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcodes) &&
| 20418 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) && |  | 20370 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) &&
| 20419 | pyopencv_to_safe(pyobj_qrcodes, qrcodes, ArgInfo("qrcodes", 1)) ) |  | 20371 | pyopencv_to_safe(pyobj_qrcodes, qrcodes, ArgInfo("qrcodes", 1)) )
| 20420 | { |  | 20372 | {
| 20421 | ERRWRAP2(_self_->encodeStructuredAppend(encoded_info, qrcodes)); |  | 20373 | ERRWRAP2(_self_->encodeStructuredAppend(encoded_info, qrcodes));
| 20422 | return pyopencv_from(qrcodes); |  | 20374 | return pyopencv_from(qrcodes);
| 20423 | } |  | 20375 | }
| 20424 |  |  | 20376 |
| 20425 |  |  | 20377 |
| 20426 | pyPopulateArgumentConversionErrors(); |  | 20378 | pyPopulateArgumentConversionErrors();
| 20427 | } |  | 20379 | }
| 20428 |  |  | 20380 |
| 20429 |  |  | 20381 |
| 20430 | { |  | 20382 | {
| 20431 | PyObject* pyobj_encoded_info = NULL; |  | 20383 | PyObject* pyobj_encoded_info = NULL;
| 20432 | String encoded_info; |  | 20384 | String encoded_info;
| 20433 | PyObject* pyobj_qrcodes = NULL; |  | 20385 | PyObject* pyobj_qrcodes = NULL;
| 20434 | vector_UMat qrcodes; |  | 20386 | vector_UMat qrcodes;
| 20435 |  |  | 20387 |
| 20436 | const char* keywords[] = { "encoded_info", "qrcodes", NULL }; |  | 20388 | const char* keywords[] = { "encoded_info", "qrcodes", NULL };
| 20437 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encodeStructuredAppend", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcodes) && |  | 20389 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:QRCodeEncoder.encodeStructuredAppend", (char**)keywords, &pyobj_encoded_info, &pyobj_qrcodes) &&
| 20438 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) && |  | 20390 | pyopencv_to_safe(pyobj_encoded_info, encoded_info, ArgInfo("encoded_info", 0)) &&
| 20439 | pyopencv_to_safe(pyobj_qrcodes, qrcodes, ArgInfo("qrcodes", 1)) ) |  | 20391 | pyopencv_to_safe(pyobj_qrcodes, qrcodes, ArgInfo("qrcodes", 1)) )
| 20440 | { |  | 20392 | {
| 20441 | ERRWRAP2(_self_->encodeStructuredAppend(encoded_info, qrcodes)); |  | 20393 | ERRWRAP2(_self_->encodeStructuredAppend(encoded_info, qrcodes));
| 20442 | return pyopencv_from(qrcodes); |  | 20394 | return pyopencv_from(qrcodes);
| 20443 | } |  | 20395 | }
| 20444 |  |  | 20396 |
| 20445 |  |  | 20397 |
| 20446 | pyPopulateArgumentConversionErrors(); |  | 20398 | pyPopulateArgumentConversionErrors();
| 20447 | } |  | 20399 | }
| 20448 | pyRaiseCVOverloadException("encodeStructuredAppend"); |  | 20400 | pyRaiseCVOverloadException("encodeStructuredAppend");
| 20449 |  |  | 20401 |
| 20450 | return NULL; |  | 20402 | return NULL;
| 20451 | } |  | 20403 | }
| 20452 |  |  | 20404 |
| 20453 |  |  | 20405 |
| 20454 |  |  | 20406 |
| 20455 | // Tables (QRCodeEncoder) |  | 20407 | // Tables (QRCodeEncoder)
| 20456 |  |  | 20408 |
| 20457 | static PyGetSetDef pyopencv_QRCodeEncoder_getseters[] = |  | 20409 | static PyGetSetDef pyopencv_QRCodeEncoder_getseters[] =
| 20458 | { |  | 20410 | {
| 20459 | {NULL} /* Sentinel */ |  | 20411 | {NULL} /* Sentinel */
| 20460 | }; |  | 20412 | };
| 20461 |  |  | 20413 |
| 20462 | static PyMethodDef pyopencv_QRCodeEncoder_methods[] = |  | 20414 | static PyMethodDef pyopencv_QRCodeEncoder_methods[] =
| 20463 | { |  | 20415 | {
| 20464 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeEncoder_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters QR code encoder parameters QRCodeEncoder::Params"}, |  | 20416 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeEncoder_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters QR code encoder parameters QRCodeEncoder::Params"},
| 20465 | {"encode", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeEncoder_encode, 0), "encode(encoded_info[, qrcode]) -> qrcode\n. @brief Generates QR code from input string.\n. @param encoded_info Input string to encode.\n. @param qrcode Generated QR code."}, |  | 20417 | {"encode", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeEncoder_encode, 0), "encode(encoded_info[, qrcode]) -> qrcode\n. @brief Generates QR code from input string.\n. @param encoded_info Input string to encode.\n. @param qrcode Generated QR code."},
| 20466 | {"encodeStructuredAppend", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeEncoder_encodeStructuredAppend, 0), "encodeStructuredAppend(encoded_info[, qrcodes]) -> qrcodes\n. @brief Generates QR code from input string in Structured Append mode. The encoded message is splitting over a number of QR codes.\n. @param encoded_info Input string to encode.\n. @param qrcodes Vector of generated QR codes."}, |  | 20418 | {"encodeStructuredAppend", CV_PY_FN_WITH_KW_(pyopencv_cv_QRCodeEncoder_encodeStructuredAppend, 0), "encodeStructuredAppend(encoded_info[, qrcodes]) -> qrcodes\n. @brief Generates QR code from input string in Structured Append mode. The encoded message is splitting over a number of QR codes.\n. @param encoded_info Input string to encode.\n. @param qrcodes Vector of generated QR codes."},
| 20467 |  |  | 20419 |
| 20468 | {NULL, NULL} |  | 20420 | {NULL, NULL}
| 20469 | }; |  | 20421 | };
| 20470 |  |  | 20422 |
| 20471 | // Converter (QRCodeEncoder) |  | 20423 | // Converter (QRCodeEncoder)
| 20472 |  |  | 20424 |
| 20473 | template<> |  | 20425 | template<>
| 20474 | struct PyOpenCV_Converter< Ptr<cv::QRCodeEncoder> > |  | 20426 | struct PyOpenCV_Converter< Ptr<cv::QRCodeEncoder> >
| 20475 | { |  | 20427 | {
| 20476 | static PyObject* from(const Ptr<cv::QRCodeEncoder>& r) |  | 20428 | static PyObject* from(const Ptr<cv::QRCodeEncoder>& r)
| 20477 | { |  | 20429 | {
| 20478 | return pyopencv_QRCodeEncoder_Instance(r); |  | 20430 | return pyopencv_QRCodeEncoder_Instance(r);
| 20479 | } |  | 20431 | }
| 20480 | static bool to(PyObject* src, Ptr<cv::QRCodeEncoder>& dst, const ArgInfo& info) |  | 20432 | static bool to(PyObject* src, Ptr<cv::QRCodeEncoder>& dst, const ArgInfo& info)
| 20481 | { |  | 20433 | {
| 20482 | if(!src || src == Py_None) |  | 20434 | if(!src || src == Py_None)
| 20483 | return true; |  | 20435 | return true;
| 20484 | Ptr<cv::QRCodeEncoder> * dst_; |  | 20436 | Ptr<cv::QRCodeEncoder> * dst_;
| 20485 | if (pyopencv_QRCodeEncoder_getp(src, dst_)) |  | 20437 | if (pyopencv_QRCodeEncoder_getp(src, dst_))
| 20486 | { |  | 20438 | {
| 20487 | dst = *dst_; |  | 20439 | dst = *dst_;
| 20488 | return true; |  | 20440 | return true;
| 20489 | } |  | 20441 | }
| 20490 |  |  | 20442 |
| 20491 | failmsg("Expected Ptr<cv::QRCodeEncoder> for argument '%s'", info.name); |  | 20443 | failmsg("Expected Ptr<cv::QRCodeEncoder> for argument '%s'", info.name);
| 20492 | return false; |  | 20444 | return false;
| 20493 | } |  | 20445 | }
| 20494 | }; |  | 20446 | };
| 20495 |  |  | 20447 |
| 20496 | //================================================================================ |  | 20448 | //================================================================================
| 20497 | // QRCodeEncoder_Params (Generic) |  | 20449 | // QRCodeEncoder_Params (Generic)
| 20498 | //================================================================================ |  | 20450 | //================================================================================
| 20499 |  |  | 20451 |
| 20500 | // GetSet (QRCodeEncoder_Params) |  | 20452 | // GetSet (QRCodeEncoder_Params)
| 20501 |  |  | 20453 |
| 20502 |  |  | 20454 |
| 20503 | static PyObject* pyopencv_QRCodeEncoder_Params_get_correction_level(pyopencv_QRCodeEncoder_Params_t* p, void *closure) |  | 20455 | static PyObject* pyopencv_QRCodeEncoder_Params_get_correction_level(pyopencv_QRCodeEncoder_Params_t* p, void *closure)
| 20504 | { |  | 20456 | {
| 20505 | return pyopencv_from(p->v.correction_level); |  | 20457 | return pyopencv_from(p->v.correction_level);
| 20506 | } |  | 20458 | }
| 20507 |  |  | 20459 |
| 20508 | static int pyopencv_QRCodeEncoder_Params_set_correction_level(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure) |  | 20460 | static int pyopencv_QRCodeEncoder_Params_set_correction_level(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure)
| 20509 | { |  | 20461 | {
| 20510 | if (!value) |  | 20462 | if (!value)
| 20511 | { |  | 20463 | {
| 20512 | PyErr_SetString(PyExc_TypeError, "Cannot delete the correction_level attribute"); |  | 20464 | PyErr_SetString(PyExc_TypeError, "Cannot delete the correction_level attribute");
| 20513 | return -1; |  | 20465 | return -1;
| 20514 | } |  | 20466 | }
| 20515 | return pyopencv_to_safe(value, p->v.correction_level, ArgInfo("value", 0)) ? 0 : -1; |  | 20467 | return pyopencv_to_safe(value, p->v.correction_level, ArgInfo("value", 0)) ? 0 : -1;
| 20516 | } |  | 20468 | }
| 20517 |  |  | 20469 |
| 20518 | static PyObject* pyopencv_QRCodeEncoder_Params_get_mode(pyopencv_QRCodeEncoder_Params_t* p, void *closure) |  | 20470 | static PyObject* pyopencv_QRCodeEncoder_Params_get_mode(pyopencv_QRCodeEncoder_Params_t* p, void *closure)
| 20519 | { |  | 20471 | {
| 20520 | return pyopencv_from(p->v.mode); |  | 20472 | return pyopencv_from(p->v.mode);
| 20521 | } |  | 20473 | }
| 20522 |  |  | 20474 |
| 20523 | static int pyopencv_QRCodeEncoder_Params_set_mode(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure) |  | 20475 | static int pyopencv_QRCodeEncoder_Params_set_mode(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure)
| 20524 | { |  | 20476 | {
| 20525 | if (!value) |  | 20477 | if (!value)
| 20526 | { |  | 20478 | {
| 20527 | PyErr_SetString(PyExc_TypeError, "Cannot delete the mode attribute"); |  | 20479 | PyErr_SetString(PyExc_TypeError, "Cannot delete the mode attribute");
| 20528 | return -1; |  | 20480 | return -1;
| 20529 | } |  | 20481 | }
| 20530 | return pyopencv_to_safe(value, p->v.mode, ArgInfo("value", 0)) ? 0 : -1; |  | 20482 | return pyopencv_to_safe(value, p->v.mode, ArgInfo("value", 0)) ? 0 : -1;
| 20531 | } |  | 20483 | }
| 20532 |  |  | 20484 |
| 20533 | static PyObject* pyopencv_QRCodeEncoder_Params_get_structure_number(pyopencv_QRCodeEncoder_Params_t* p, void *closure) |  | 20485 | static PyObject* pyopencv_QRCodeEncoder_Params_get_structure_number(pyopencv_QRCodeEncoder_Params_t* p, void *closure)
| 20534 | { |  | 20486 | {
| 20535 | return pyopencv_from(p->v.structure_number); |  | 20487 | return pyopencv_from(p->v.structure_number);
| 20536 | } |  | 20488 | }
| 20537 |  |  | 20489 |
| 20538 | static int pyopencv_QRCodeEncoder_Params_set_structure_number(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure) |  | 20490 | static int pyopencv_QRCodeEncoder_Params_set_structure_number(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure)
| 20539 | { |  | 20491 | {
| 20540 | if (!value) |  | 20492 | if (!value)
| 20541 | { |  | 20493 | {
| 20542 | PyErr_SetString(PyExc_TypeError, "Cannot delete the structure_number attribute"); |  | 20494 | PyErr_SetString(PyExc_TypeError, "Cannot delete the structure_number attribute");
| 20543 | return -1; |  | 20495 | return -1;
| 20544 | } |  | 20496 | }
| 20545 | return pyopencv_to_safe(value, p->v.structure_number, ArgInfo("value", 0)) ? 0 : -1; |  | 20497 | return pyopencv_to_safe(value, p->v.structure_number, ArgInfo("value", 0)) ? 0 : -1;
| 20546 | } |  | 20498 | }
| 20547 |  |  | 20499 |
| 20548 | static PyObject* pyopencv_QRCodeEncoder_Params_get_version(pyopencv_QRCodeEncoder_Params_t* p, void *closure) |  | 20500 | static PyObject* pyopencv_QRCodeEncoder_Params_get_version(pyopencv_QRCodeEncoder_Params_t* p, void *closure)
| 20549 | { |  | 20501 | {
| 20550 | return pyopencv_from(p->v.version); |  | 20502 | return pyopencv_from(p->v.version);
| 20551 | } |  | 20503 | }
| 20552 |  |  | 20504 |
| 20553 | static int pyopencv_QRCodeEncoder_Params_set_version(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure) |  | 20505 | static int pyopencv_QRCodeEncoder_Params_set_version(pyopencv_QRCodeEncoder_Params_t* p, PyObject *value, void *closure)
| 20554 | { |  | 20506 | {
| 20555 | if (!value) |  | 20507 | if (!value)
| 20556 | { |  | 20508 | {
| 20557 | PyErr_SetString(PyExc_TypeError, "Cannot delete the version attribute"); |  | 20509 | PyErr_SetString(PyExc_TypeError, "Cannot delete the version attribute");
| 20558 | return -1; |  | 20510 | return -1;
| 20559 | } |  | 20511 | }
| 20560 | return pyopencv_to_safe(value, p->v.version, ArgInfo("value", 0)) ? 0 : -1; |  | 20512 | return pyopencv_to_safe(value, p->v.version, ArgInfo("value", 0)) ? 0 : -1;
| 20561 | } |  | 20513 | }
| 20562 |  |  | 20514 |
| 20563 |  |  | 20515 |
| 20564 | // Methods (QRCodeEncoder_Params) |  | 20516 | // Methods (QRCodeEncoder_Params)
| 20565 |  |  | 20517 |
| 20566 | static int pyopencv_cv_QRCodeEncoder_Params_QRCodeEncoder_Params(pyopencv_QRCodeEncoder_Params_t* self, PyObject* py_args, PyObject* kw) |  | 20518 | static int pyopencv_cv_QRCodeEncoder_Params_QRCodeEncoder_Params(pyopencv_QRCodeEncoder_Params_t* self, PyObject* py_args, PyObject* kw)
| 20567 | { |  | 20519 | {
| 20568 | using namespace cv; |  | 20520 | using namespace cv;
| 20569 |  |  | 20521 |
| 20570 |  |  | 20522 |
| 20571 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20523 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20572 | { |  | 20524 | {
| 20573 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeEncoder::Params()); |  | 20525 | if(self) ERRWRAP2(new (&(self->v)) cv::QRCodeEncoder::Params());
| 20574 | return 0; |  | 20526 | return 0;
| 20575 | } |  | 20527 | }
| 20576 |  |  | 20528 |
| 20577 | return -1; |  | 20529 | return -1;
| 20578 | } |  | 20530 | }
| 20579 |  |  | 20531 |
| 20580 |  |  | 20532 |
| 20581 |  |  | 20533 |
| 20582 | // Tables (QRCodeEncoder_Params) |  | 20534 | // Tables (QRCodeEncoder_Params)
| 20583 |  |  | 20535 |
| 20584 | static PyGetSetDef pyopencv_QRCodeEncoder_Params_getseters[] = |  | 20536 | static PyGetSetDef pyopencv_QRCodeEncoder_Params_getseters[] =
| 20585 | { |  | 20537 | {
| 20586 | {(char*)"correction_level", (getter)pyopencv_QRCodeEncoder_Params_get_correction_level, (setter)pyopencv_QRCodeEncoder_Params_set_correction_level, (char*)"correction_level", NULL}, |  | 20538 | {(char*)"correction_level", (getter)pyopencv_QRCodeEncoder_Params_get_correction_level, (setter)pyopencv_QRCodeEncoder_Params_set_correction_level, (char*)"correction_level", NULL},
| 20587 | {(char*)"mode", (getter)pyopencv_QRCodeEncoder_Params_get_mode, (setter)pyopencv_QRCodeEncoder_Params_set_mode, (char*)"mode", NULL}, |  | 20539 | {(char*)"mode", (getter)pyopencv_QRCodeEncoder_Params_get_mode, (setter)pyopencv_QRCodeEncoder_Params_set_mode, (char*)"mode", NULL},
| 20588 | {(char*)"structure_number", (getter)pyopencv_QRCodeEncoder_Params_get_structure_number, (setter)pyopencv_QRCodeEncoder_Params_set_structure_number, (char*)"structure_number", NULL}, |  | 20540 | {(char*)"structure_number", (getter)pyopencv_QRCodeEncoder_Params_get_structure_number, (setter)pyopencv_QRCodeEncoder_Params_set_structure_number, (char*)"structure_number", NULL},
| 20589 | {(char*)"version", (getter)pyopencv_QRCodeEncoder_Params_get_version, (setter)pyopencv_QRCodeEncoder_Params_set_version, (char*)"version", NULL}, |  | 20541 | {(char*)"version", (getter)pyopencv_QRCodeEncoder_Params_get_version, (setter)pyopencv_QRCodeEncoder_Params_set_version, (char*)"version", NULL},
| 20590 | {NULL} /* Sentinel */ |  | 20542 | {NULL} /* Sentinel */
| 20591 | }; |  | 20543 | };
| 20592 |  |  | 20544 |
| 20593 | static PyMethodDef pyopencv_QRCodeEncoder_Params_methods[] = |  | 20545 | static PyMethodDef pyopencv_QRCodeEncoder_Params_methods[] =
| 20594 | { |  | 20546 | {
| 20595 |  |  | 20547 |
| 20596 | {NULL, NULL} |  | 20548 | {NULL, NULL}
| 20597 | }; |  | 20549 | };
| 20598 |  |  | 20550 |
| 20599 | // Converter (QRCodeEncoder_Params) |  | 20551 | // Converter (QRCodeEncoder_Params)
| 20600 |  |  | 20552 |
| 20601 | template<> |  | 20553 | template<>
| 20602 | struct PyOpenCV_Converter< cv::QRCodeEncoder::Params > |  | 20554 | struct PyOpenCV_Converter< cv::QRCodeEncoder::Params >
| 20603 | { |  | 20555 | {
| 20604 | static PyObject* from(const cv::QRCodeEncoder::Params& r) |  | 20556 | static PyObject* from(const cv::QRCodeEncoder::Params& r)
| 20605 | { |  | 20557 | {
| 20606 | return pyopencv_QRCodeEncoder_Params_Instance(r); |  | 20558 | return pyopencv_QRCodeEncoder_Params_Instance(r);
| 20607 | } |  | 20559 | }
| 20608 | static bool to(PyObject* src, cv::QRCodeEncoder::Params& dst, const ArgInfo& info) |  | 20560 | static bool to(PyObject* src, cv::QRCodeEncoder::Params& dst, const ArgInfo& info)
| 20609 | { |  | 20561 | {
| 20610 | if(!src || src == Py_None) |  | 20562 | if(!src || src == Py_None)
| 20611 | return true; |  | 20563 | return true;
| 20612 | cv::QRCodeEncoder::Params * dst_; |  | 20564 | cv::QRCodeEncoder::Params * dst_;
| 20613 | if (pyopencv_QRCodeEncoder_Params_getp(src, dst_)) |  | 20565 | if (pyopencv_QRCodeEncoder_Params_getp(src, dst_))
| 20614 | { |  | 20566 | {
| 20615 | dst = *dst_; |  | 20567 | dst = *dst_;
| 20616 | return true; |  | 20568 | return true;
| 20617 | } |  | 20569 | }
| 20618 |  |  | 20570 |
| 20619 | failmsg("Expected cv::QRCodeEncoder::Params for argument '%s'", info.name); |  | 20571 | failmsg("Expected cv::QRCodeEncoder::Params for argument '%s'", info.name);
| 20620 | return false; |  | 20572 | return false;
| 20621 | } |  | 20573 | }
| 20622 | }; |  | 20574 | };
| 20623 |  |  | 20575 |
| 20624 | //================================================================================ |  | 20576 | //================================================================================
| 20625 | // RotatedRect (Generic) |  | 20577 | // RotatedRect (Generic)
| 20626 | //================================================================================ |  | 20578 | //================================================================================
| 20627 |  |  | 20579 |
| 20628 | // GetSet (RotatedRect) |  | 20580 | // GetSet (RotatedRect)
| 20629 |  |  | 20581 |
| 20630 |  |  | 20582 |
| 20631 | static PyObject* pyopencv_RotatedRect_get_angle(pyopencv_RotatedRect_t* p, void *closure) |  | 20583 | static PyObject* pyopencv_RotatedRect_get_angle(pyopencv_RotatedRect_t* p, void *closure)
| 20632 | { |  | 20584 | {
| 20633 | return pyopencv_from(p->v.angle); |  | 20585 | return pyopencv_from(p->v.angle);
| 20634 | } |  | 20586 | }
| 20635 |  |  | 20587 |
| 20636 | static int pyopencv_RotatedRect_set_angle(pyopencv_RotatedRect_t* p, PyObject *value, void *closure) |  | 20588 | static int pyopencv_RotatedRect_set_angle(pyopencv_RotatedRect_t* p, PyObject *value, void *closure)
| 20637 | { |  | 20589 | {
| 20638 | if (!value) |  | 20590 | if (!value)
| 20639 | { |  | 20591 | {
| 20640 | PyErr_SetString(PyExc_TypeError, "Cannot delete the angle attribute"); |  | 20592 | PyErr_SetString(PyExc_TypeError, "Cannot delete the angle attribute");
| 20641 | return -1; |  | 20593 | return -1;
| 20642 | } |  | 20594 | }
| 20643 | return pyopencv_to_safe(value, p->v.angle, ArgInfo("value", 0)) ? 0 : -1; |  | 20595 | return pyopencv_to_safe(value, p->v.angle, ArgInfo("value", 0)) ? 0 : -1;
| 20644 | } |  | 20596 | }
| 20645 |  |  | 20597 |
| 20646 | static PyObject* pyopencv_RotatedRect_get_center(pyopencv_RotatedRect_t* p, void *closure) |  | 20598 | static PyObject* pyopencv_RotatedRect_get_center(pyopencv_RotatedRect_t* p, void *closure)
| 20647 | { |  | 20599 | {
| 20648 | return pyopencv_from(p->v.center); |  | 20600 | return pyopencv_from(p->v.center);
| 20649 | } |  | 20601 | }
| 20650 |  |  | 20602 |
| 20651 | static int pyopencv_RotatedRect_set_center(pyopencv_RotatedRect_t* p, PyObject *value, void *closure) |  | 20603 | static int pyopencv_RotatedRect_set_center(pyopencv_RotatedRect_t* p, PyObject *value, void *closure)
| 20652 | { |  | 20604 | {
| 20653 | if (!value) |  | 20605 | if (!value)
| 20654 | { |  | 20606 | {
| 20655 | PyErr_SetString(PyExc_TypeError, "Cannot delete the center attribute"); |  | 20607 | PyErr_SetString(PyExc_TypeError, "Cannot delete the center attribute");
| 20656 | return -1; |  | 20608 | return -1;
| 20657 | } |  | 20609 | }
| 20658 | return pyopencv_to_safe(value, p->v.center, ArgInfo("value", 0)) ? 0 : -1; |  | 20610 | return pyopencv_to_safe(value, p->v.center, ArgInfo("value", 0)) ? 0 : -1;
| 20659 | } |  | 20611 | }
| 20660 |  |  | 20612 |
| 20661 | static PyObject* pyopencv_RotatedRect_get_size(pyopencv_RotatedRect_t* p, void *closure) |  | 20613 | static PyObject* pyopencv_RotatedRect_get_size(pyopencv_RotatedRect_t* p, void *closure)
| 20662 | { |  | 20614 | {
| 20663 | return pyopencv_from(p->v.size); |  | 20615 | return pyopencv_from(p->v.size);
| 20664 | } |  | 20616 | }
| 20665 |  |  | 20617 |
| 20666 | static int pyopencv_RotatedRect_set_size(pyopencv_RotatedRect_t* p, PyObject *value, void *closure) |  | 20618 | static int pyopencv_RotatedRect_set_size(pyopencv_RotatedRect_t* p, PyObject *value, void *closure)
| 20667 | { |  | 20619 | {
| 20668 | if (!value) |  | 20620 | if (!value)
| 20669 | { |  | 20621 | {
| 20670 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute"); |  | 20622 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute");
| 20671 | return -1; |  | 20623 | return -1;
| 20672 | } |  | 20624 | }
| 20673 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1; |  | 20625 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1;
| 20674 | } |  | 20626 | }
| 20675 |  |  | 20627 |
| 20676 |  |  | 20628 |
| 20677 | // Methods (RotatedRect) |  | 20629 | // Methods (RotatedRect)
| 20678 |  |  | 20630 |
| 20679 | static int pyopencv_cv_RotatedRect_RotatedRect(pyopencv_RotatedRect_t* self, PyObject* py_args, PyObject* kw) |  | 20631 | static int pyopencv_cv_RotatedRect_RotatedRect(pyopencv_RotatedRect_t* self, PyObject* py_args, PyObject* kw)
| 20680 | { |  | 20632 | {
| 20681 | using namespace cv; |  | 20633 | using namespace cv;
| 20682 |  |  | 20634 |
| 20683 | pyPrepareArgumentConversionErrorsStorage(3); |  | 20635 | pyPrepareArgumentConversionErrorsStorage(3);
| 20684 |  |  | 20636 |
| 20685 | { |  | 20637 | {
| 20686 |  |  | 20638 |
| 20687 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20639 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20688 | { |  | 20640 | {
| 20689 | if(self) ERRWRAP2(new (&(self->v)) cv::RotatedRect()); |  | 20641 | if(self) ERRWRAP2(new (&(self->v)) cv::RotatedRect());
| 20690 | return 0; |  | 20642 | return 0;
| 20691 | } |  | 20643 | }
| 20692 |  |  | 20644 |
| 20693 |  |  | 20645 |
| 20694 | pyPopulateArgumentConversionErrors(); |  | 20646 | pyPopulateArgumentConversionErrors();
| 20695 | } |  | 20647 | }
| 20696 |  |  | 20648 |
| 20697 |  |  | 20649 |
| 20698 | { |  | 20650 | {
| 20699 | PyObject* pyobj_center = NULL; |  | 20651 | PyObject* pyobj_center = NULL;
| 20700 | Point2f center; |  | 20652 | Point2f center;
| 20701 | PyObject* pyobj_size = NULL; |  | 20653 | PyObject* pyobj_size = NULL;
| 20702 | Size2f size; |  | 20654 | Size2f size;
| 20703 | PyObject* pyobj_angle = NULL; |  | 20655 | PyObject* pyobj_angle = NULL;
| 20704 | float angle=0.f; |  | 20656 | float angle=0.f;
| 20705 |  |  | 20657 |
| 20706 | const char* keywords[] = { "center", "size", "angle", NULL }; |  | 20658 | const char* keywords[] = { "center", "size", "angle", NULL };
| 20707 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:RotatedRect", (char**)keywords, &pyobj_center, &pyobj_size, &pyobj_angle) && |  | 20659 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:RotatedRect", (char**)keywords, &pyobj_center, &pyobj_size, &pyobj_angle) &&
| 20708 | pyopencv_to_safe(pyobj_center, center, ArgInfo("center", 0)) && |  | 20660 | pyopencv_to_safe(pyobj_center, center, ArgInfo("center", 0)) &&
| 20709 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 20661 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 20710 | pyopencv_to_safe(pyobj_angle, angle, ArgInfo("angle", 0)) ) |  | 20662 | pyopencv_to_safe(pyobj_angle, angle, ArgInfo("angle", 0)) )
| 20711 | { |  | 20663 | {
| 20712 | if(self) ERRWRAP2(new (&(self->v)) cv::RotatedRect(center, size, angle)); |  | 20664 | if(self) ERRWRAP2(new (&(self->v)) cv::RotatedRect(center, size, angle));
| 20713 | return 0; |  | 20665 | return 0;
| 20714 | } |  | 20666 | }
| 20715 |  |  | 20667 |
| 20716 |  |  | 20668 |
| 20717 | pyPopulateArgumentConversionErrors(); |  | 20669 | pyPopulateArgumentConversionErrors();
| 20718 | } |  | 20670 | }
| 20719 |  |  | 20671 |
| 20720 |  |  | 20672 |
| 20721 | { |  | 20673 | {
| 20722 | PyObject* pyobj_point1 = NULL; |  | 20674 | PyObject* pyobj_point1 = NULL;
| 20723 | Point2f point1; |  | 20675 | Point2f point1;
| 20724 | PyObject* pyobj_point2 = NULL; |  | 20676 | PyObject* pyobj_point2 = NULL;
| 20725 | Point2f point2; |  | 20677 | Point2f point2;
| 20726 | PyObject* pyobj_point3 = NULL; |  | 20678 | PyObject* pyobj_point3 = NULL;
| 20727 | Point2f point3; |  | 20679 | Point2f point3;
| 20728 |  |  | 20680 |
| 20729 | const char* keywords[] = { "point1", "point2", "point3", NULL }; |  | 20681 | const char* keywords[] = { "point1", "point2", "point3", NULL };
| 20730 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:RotatedRect", (char**)keywords, &pyobj_point1, &pyobj_point2, &pyobj_point3) && |  | 20682 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:RotatedRect", (char**)keywords, &pyobj_point1, &pyobj_point2, &pyobj_point3) &&
| 20731 | pyopencv_to_safe(pyobj_point1, point1, ArgInfo("point1", 0)) && |  | 20683 | pyopencv_to_safe(pyobj_point1, point1, ArgInfo("point1", 0)) &&
| 20732 | pyopencv_to_safe(pyobj_point2, point2, ArgInfo("point2", 0)) && |  | 20684 | pyopencv_to_safe(pyobj_point2, point2, ArgInfo("point2", 0)) &&
| 20733 | pyopencv_to_safe(pyobj_point3, point3, ArgInfo("point3", 0)) ) |  | 20685 | pyopencv_to_safe(pyobj_point3, point3, ArgInfo("point3", 0)) )
| 20734 | { |  | 20686 | {
| 20735 | if(self) ERRWRAP2(new (&(self->v)) cv::RotatedRect(point1, point2, point3)); |  | 20687 | if(self) ERRWRAP2(new (&(self->v)) cv::RotatedRect(point1, point2, point3));
| 20736 | return 0; |  | 20688 | return 0;
| 20737 | } |  | 20689 | }
| 20738 |  |  | 20690 |
| 20739 |  |  | 20691 |
| 20740 | pyPopulateArgumentConversionErrors(); |  | 20692 | pyPopulateArgumentConversionErrors();
| 20741 | } |  | 20693 | }
| 20742 | pyRaiseCVOverloadException("RotatedRect"); |  | 20694 | pyRaiseCVOverloadException("RotatedRect");
| 20743 |  |  | 20695 |
| 20744 | return -1; |  | 20696 | return -1;
| 20745 | } |  | 20697 | }
| 20746 |  |  | 20698 |
| 20747 | static PyObject* pyopencv_cv_RotatedRect_boundingRect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20699 | static PyObject* pyopencv_cv_RotatedRect_boundingRect(PyObject* self, PyObject* py_args, PyObject* kw)
| 20748 | { |  | 20700 | {
| 20749 | using namespace cv; |  | 20701 | using namespace cv;
| 20750 |  |  | 20702 |
| 20751 |  |  | 20703 |
| 20752 | cv::RotatedRect * self1 = 0; |  | 20704 | cv::RotatedRect * self1 = 0;
| 20753 | if (!pyopencv_RotatedRect_getp(self, self1)) |  | 20705 | if (!pyopencv_RotatedRect_getp(self, self1))
| 20754 | return failmsgp("Incorrect type of self (must be 'RotatedRect' or its derivative)"); |  | 20706 | return failmsgp("Incorrect type of self (must be 'RotatedRect' or its derivative)");
| 20755 | cv::RotatedRect* _self_ = (self1); |  | 20707 | cv::RotatedRect* _self_ = (self1);
| 20756 | Rect retval; |  | 20708 | Rect retval;
| 20757 |  |  | 20709 |
| 20758 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20710 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20759 | { |  | 20711 | {
| 20760 | ERRWRAP2(retval = _self_->boundingRect()); |  | 20712 | ERRWRAP2(retval = _self_->boundingRect());
| 20761 | return pyopencv_from(retval); |  | 20713 | return pyopencv_from(retval);
| 20762 | } |  | 20714 | }
| 20763 |  |  | 20715 |
| 20764 | return NULL; |  | 20716 | return NULL;
| 20765 | } |  | 20717 | }
| 20766 |  |  | 20718 |
| 20767 | static PyObject* pyopencv_cv_RotatedRect_boundingRect2f(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20719 | static PyObject* pyopencv_cv_RotatedRect_boundingRect2f(PyObject* self, PyObject* py_args, PyObject* kw)
| 20768 | { |  | 20720 | {
| 20769 | using namespace cv; |  | 20721 | using namespace cv;
| 20770 |  |  | 20722 |
| 20771 |  |  | 20723 |
| 20772 | cv::RotatedRect * self1 = 0; |  | 20724 | cv::RotatedRect * self1 = 0;
| 20773 | if (!pyopencv_RotatedRect_getp(self, self1)) |  | 20725 | if (!pyopencv_RotatedRect_getp(self, self1))
| 20774 | return failmsgp("Incorrect type of self (must be 'RotatedRect' or its derivative)"); |  | 20726 | return failmsgp("Incorrect type of self (must be 'RotatedRect' or its derivative)");
| 20775 | cv::RotatedRect* _self_ = (self1); |  | 20727 | cv::RotatedRect* _self_ = (self1);
| 20776 | Rect2f retval; |  | 20728 | Rect2f retval;
| 20777 |  |  | 20729 |
| 20778 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20730 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20779 | { |  | 20731 | {
| 20780 | ERRWRAP2(retval = _self_->boundingRect2f()); |  | 20732 | ERRWRAP2(retval = _self_->boundingRect2f());
| 20781 | return pyopencv_from(retval); |  | 20733 | return pyopencv_from(retval);
| 20782 | } |  | 20734 | }
| 20783 |  |  | 20735 |
| 20784 | return NULL; |  | 20736 | return NULL;
| 20785 | } |  | 20737 | }
| 20786 |  |  | 20738 |
| 20787 | static PyObject* pyopencv_cv_RotatedRect_points(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20739 | static PyObject* pyopencv_cv_RotatedRect_points(PyObject* self, PyObject* py_args, PyObject* kw)
| 20788 | { |  | 20740 | {
| 20789 | using namespace cv; |  | 20741 | using namespace cv;
| 20790 |  |  | 20742 |
| 20791 |  |  | 20743 |
| 20792 | cv::RotatedRect * self1 = 0; |  | 20744 | cv::RotatedRect * self1 = 0;
| 20793 | if (!pyopencv_RotatedRect_getp(self, self1)) |  | 20745 | if (!pyopencv_RotatedRect_getp(self, self1))
| 20794 | return failmsgp("Incorrect type of self (must be 'RotatedRect' or its derivative)"); |  | 20746 | return failmsgp("Incorrect type of self (must be 'RotatedRect' or its derivative)");
| 20795 | cv::RotatedRect* _self_ = (self1); |  | 20747 | cv::RotatedRect* _self_ = (self1);
| 20796 | vector_Point2f pts; |  | 20748 | vector_Point2f pts;
| 20797 |  |  | 20749 |
| 20798 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20750 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20799 | { |  | 20751 | {
| 20800 | ERRWRAP2(_self_->points(pts)); |  | 20752 | ERRWRAP2(_self_->points(pts));
| 20801 | return pyopencv_from(pts); |  | 20753 | return pyopencv_from(pts);
| 20802 | } |  | 20754 | }
| 20803 |  |  | 20755 |
| 20804 | return NULL; |  | 20756 | return NULL;
| 20805 | } |  | 20757 | }
| 20806 |  |  | 20758 |
| 20807 |  |  | 20759 |
| 20808 |  |  | 20760 |
| 20809 | // Tables (RotatedRect) |  | 20761 | // Tables (RotatedRect)
| 20810 |  |  | 20762 |
| 20811 | static PyGetSetDef pyopencv_RotatedRect_getseters[] = |  | 20763 | static PyGetSetDef pyopencv_RotatedRect_getseters[] =
| 20812 | { |  | 20764 | {
| 20813 | {(char*)"angle", (getter)pyopencv_RotatedRect_get_angle, (setter)pyopencv_RotatedRect_set_angle, (char*)"angle", NULL}, |  | 20765 | {(char*)"angle", (getter)pyopencv_RotatedRect_get_angle, (setter)pyopencv_RotatedRect_set_angle, (char*)"angle", NULL},
| 20814 | {(char*)"center", (getter)pyopencv_RotatedRect_get_center, (setter)pyopencv_RotatedRect_set_center, (char*)"center", NULL}, |  | 20766 | {(char*)"center", (getter)pyopencv_RotatedRect_get_center, (setter)pyopencv_RotatedRect_set_center, (char*)"center", NULL},
| 20815 | {(char*)"size", (getter)pyopencv_RotatedRect_get_size, (setter)pyopencv_RotatedRect_set_size, (char*)"size", NULL}, |  | 20767 | {(char*)"size", (getter)pyopencv_RotatedRect_get_size, (setter)pyopencv_RotatedRect_set_size, (char*)"size", NULL},
| 20816 | {NULL} /* Sentinel */ |  | 20768 | {NULL} /* Sentinel */
| 20817 | }; |  | 20769 | };
| 20818 |  |  | 20770 |
| 20819 | static PyMethodDef pyopencv_RotatedRect_methods[] = |  | 20771 | static PyMethodDef pyopencv_RotatedRect_methods[] =
| 20820 | { |  | 20772 | {
| 20821 | {"boundingRect", CV_PY_FN_WITH_KW_(pyopencv_cv_RotatedRect_boundingRect, 0), "boundingRect() -> retval\n."}, |  | 20773 | {"boundingRect", CV_PY_FN_WITH_KW_(pyopencv_cv_RotatedRect_boundingRect, 0), "boundingRect() -> retval\n."},
| 20822 | {"boundingRect2f", CV_PY_FN_WITH_KW_(pyopencv_cv_RotatedRect_boundingRect2f, 0), "boundingRect2f() -> retval\n."}, |  | 20774 | {"boundingRect2f", CV_PY_FN_WITH_KW_(pyopencv_cv_RotatedRect_boundingRect2f, 0), "boundingRect2f() -> retval\n."},
| 20823 | {"points", CV_PY_FN_WITH_KW_(pyopencv_cv_RotatedRect_points, 0), "points() -> pts\n. returns 4 vertices of the rotated rectangle\n. @param pts The points array for storing rectangle vertices. The order is _bottomLeft_, _topLeft_, topRight, bottomRight.\n. @note _Bottom_, _Top_, _Left_ and _Right_ sides refer to the original rectangle (angle is 0),\n. so after 180 degree rotation _bottomLeft_ point will be located at the top right corner of the\n. rectangle."}, |  | 20775 | {"points", CV_PY_FN_WITH_KW_(pyopencv_cv_RotatedRect_points, 0), "points() -> pts\n. returns 4 vertices of the rotated rectangle\n. @param pts The points array for storing rectangle vertices. The order is _bottomLeft_, _topLeft_, topRight, bottomRight.\n. @note _Bottom_, _Top_, _Left_ and _Right_ sides refer to the original rectangle (angle is 0),\n. so after 180 degree rotation _bottomLeft_ point will be located at the top right corner of the\n. rectangle."},
| 20824 |  |  | 20776 |
| 20825 | {NULL, NULL} |  | 20777 | {NULL, NULL}
| 20826 | }; |  | 20778 | };
| 20827 |  |  | 20779 |
| 20828 | // Converter (RotatedRect) |  | 20780 | // Converter (RotatedRect)
| 20829 |  |  | 20781 |
| 20830 | template<> |  | 20782 | template<>
| 20831 | struct PyOpenCV_Converter< cv::RotatedRect > |  | 20783 | struct PyOpenCV_Converter< cv::RotatedRect >
| 20832 | { |  | 20784 | {
| 20833 | static PyObject* from(const cv::RotatedRect& r) |  | 20785 | static PyObject* from(const cv::RotatedRect& r)
| 20834 | { |  | 20786 | {
| 20835 | return pyopencv_RotatedRect_Instance(r); |  | 20787 | return pyopencv_RotatedRect_Instance(r);
| 20836 | } |  | 20788 | }
| 20837 | static bool to(PyObject* src, cv::RotatedRect& dst, const ArgInfo& info) |  | 20789 | static bool to(PyObject* src, cv::RotatedRect& dst, const ArgInfo& info)
| 20838 | { |  | 20790 | {
| 20839 | if(!src || src == Py_None) |  | 20791 | if(!src || src == Py_None)
| 20840 | return true; |  | 20792 | return true;
| 20841 | cv::RotatedRect * dst_; |  | 20793 | cv::RotatedRect * dst_;
| 20842 | if (pyopencv_RotatedRect_getp(src, dst_)) |  | 20794 | if (pyopencv_RotatedRect_getp(src, dst_))
| 20843 | { |  | 20795 | {
| 20844 | dst = *dst_; |  | 20796 | dst = *dst_;
| 20845 | return true; |  | 20797 | return true;
| 20846 | } |  | 20798 | }
| 20847 |  |  | 20799 |
| 20848 | failmsg("Expected cv::RotatedRect for argument '%s'", info.name); |  | 20800 | failmsg("Expected cv::RotatedRect for argument '%s'", info.name);
| 20849 | return false; |  | 20801 | return false;
| 20850 | } |  | 20802 | }
| 20851 | }; |  | 20803 | };
| 20852 |  |  | 20804 |
| 20853 | //================================================================================ |  | 20805 | //================================================================================
| 20854 | // SIFT (Generic) |  | 20806 | // SIFT (Generic)
| 20855 | //================================================================================ |  | 20807 | //================================================================================
| 20856 |  |  | 20808 |
| 20857 | // GetSet (SIFT) |  | 20809 | // GetSet (SIFT)
| 20858 |  |  | 20810 |
| 20859 |  |  | 20811 |
| 20860 |  |  | 20812 |
| 20861 | // Methods (SIFT) |  | 20813 | // Methods (SIFT)
| 20862 |  |  | 20814 |
| 20863 | static PyObject* pyopencv_cv_SIFT_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20815 | static PyObject* pyopencv_cv_SIFT_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 20864 | { |  | 20816 | {
| 20865 | using namespace cv; |  | 20817 | using namespace cv;
| 20866 |  |  | 20818 |
| 20867 | pyPrepareArgumentConversionErrorsStorage(2); |  | 20819 | pyPrepareArgumentConversionErrorsStorage(2);
| 20868 |  |  | 20820 |
| 20869 | { |  | 20821 | {
| 20870 | PyObject* pyobj_nfeatures = NULL; |  | 20822 | PyObject* pyobj_nfeatures = NULL;
| 20871 | int nfeatures=0; |  | 20823 | int nfeatures=0;
| 20872 | PyObject* pyobj_nOctaveLayers = NULL; |  | 20824 | PyObject* pyobj_nOctaveLayers = NULL;
| 20873 | int nOctaveLayers=3; |  | 20825 | int nOctaveLayers=3;
| 20874 | PyObject* pyobj_contrastThreshold = NULL; |  | 20826 | PyObject* pyobj_contrastThreshold = NULL;
| 20875 | double contrastThreshold=0.04; |  | 20827 | double contrastThreshold=0.04;
| 20876 | PyObject* pyobj_edgeThreshold = NULL; |  | 20828 | PyObject* pyobj_edgeThreshold = NULL;
| 20877 | double edgeThreshold=10; |  | 20829 | double edgeThreshold=10;
| 20878 | PyObject* pyobj_sigma = NULL; |  | 20830 | PyObject* pyobj_sigma = NULL;
| 20879 | double sigma=1.6; |  | 20831 | double sigma=1.6;
| 20880 | PyObject* pyobj_enable_precise_upscale = NULL; |  | 20832 | PyObject* pyobj_enable_precise_upscale = NULL;
| 20881 | bool enable_precise_upscale=false; |  | 20833 | bool enable_precise_upscale=false;
| 20882 | Ptr<SIFT> retval; |  | 20834 | Ptr<SIFT> retval;
| 20883 |  |  | 20835 |
| 20884 | const char* keywords[] = { "nfeatures", "nOctaveLayers", "contrastThreshold", "edgeThreshold", "sigma", "enable_precise_upscale", NULL }; |  | 20836 | const char* keywords[] = { "nfeatures", "nOctaveLayers", "contrastThreshold", "edgeThreshold", "sigma", "enable_precise_upscale", NULL };
| 20885 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOO:SIFT.create", (char**)keywords, &pyobj_nfeatures, &pyobj_nOctaveLayers, &pyobj_contrastThreshold, &pyobj_edgeThreshold, &pyobj_sigma, &pyobj_enable_precise_upscale) && |  | 20837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOO:SIFT.create", (char**)keywords, &pyobj_nfeatures, &pyobj_nOctaveLayers, &pyobj_contrastThreshold, &pyobj_edgeThreshold, &pyobj_sigma, &pyobj_enable_precise_upscale) &&
| 20886 | pyopencv_to_safe(pyobj_nfeatures, nfeatures, ArgInfo("nfeatures", 0)) && |  | 20838 | pyopencv_to_safe(pyobj_nfeatures, nfeatures, ArgInfo("nfeatures", 0)) &&
| 20887 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) && |  | 20839 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) &&
| 20888 | pyopencv_to_safe(pyobj_contrastThreshold, contrastThreshold, ArgInfo("contrastThreshold", 0)) && |  | 20840 | pyopencv_to_safe(pyobj_contrastThreshold, contrastThreshold, ArgInfo("contrastThreshold", 0)) &&
| 20889 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) && |  | 20841 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) &&
| 20890 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) && |  | 20842 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) &&
| 20891 | pyopencv_to_safe(pyobj_enable_precise_upscale, enable_precise_upscale, ArgInfo("enable_precise_upscale", 0)) ) |  | 20843 | pyopencv_to_safe(pyobj_enable_precise_upscale, enable_precise_upscale, ArgInfo("enable_precise_upscale", 0)) )
| 20892 | { |  | 20844 | {
| 20893 | ERRWRAP2(retval = cv::SIFT::create(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, enable_precise_upscale)); |  | 20845 | ERRWRAP2(retval = cv::SIFT::create(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, enable_precise_upscale));
| 20894 | return pyopencv_from(retval); |  | 20846 | return pyopencv_from(retval);
| 20895 | } |  | 20847 | }
| 20896 |  |  | 20848 |
| 20897 |  |  | 20849 |
| 20898 | pyPopulateArgumentConversionErrors(); |  | 20850 | pyPopulateArgumentConversionErrors();
| 20899 | } |  | 20851 | }
| 20900 |  |  | 20852 |
| 20901 |  |  | 20853 |
| 20902 | { |  | 20854 | {
| 20903 | PyObject* pyobj_nfeatures = NULL; |  | 20855 | PyObject* pyobj_nfeatures = NULL;
| 20904 | int nfeatures=0; |  | 20856 | int nfeatures=0;
| 20905 | PyObject* pyobj_nOctaveLayers = NULL; |  | 20857 | PyObject* pyobj_nOctaveLayers = NULL;
| 20906 | int nOctaveLayers=0; |  | 20858 | int nOctaveLayers=0;
| 20907 | PyObject* pyobj_contrastThreshold = NULL; |  | 20859 | PyObject* pyobj_contrastThreshold = NULL;
| 20908 | double contrastThreshold=0; |  | 20860 | double contrastThreshold=0;
| 20909 | PyObject* pyobj_edgeThreshold = NULL; |  | 20861 | PyObject* pyobj_edgeThreshold = NULL;
| 20910 | double edgeThreshold=0; |  | 20862 | double edgeThreshold=0;
| 20911 | PyObject* pyobj_sigma = NULL; |  | 20863 | PyObject* pyobj_sigma = NULL;
| 20912 | double sigma=0; |  | 20864 | double sigma=0;
| 20913 | PyObject* pyobj_descriptorType = NULL; |  | 20865 | PyObject* pyobj_descriptorType = NULL;
| 20914 | int descriptorType=0; |  | 20866 | int descriptorType=0;
| 20915 | PyObject* pyobj_enable_precise_upscale = NULL; |  | 20867 | PyObject* pyobj_enable_precise_upscale = NULL;
| 20916 | bool enable_precise_upscale=false; |  | 20868 | bool enable_precise_upscale=false;
| 20917 | Ptr<SIFT> retval; |  | 20869 | Ptr<SIFT> retval;
| 20918 |  |  | 20870 |
| 20919 | const char* keywords[] = { "nfeatures", "nOctaveLayers", "contrastThreshold", "edgeThreshold", "sigma", "descriptorType", "enable_precise_upscale", NULL }; |  | 20871 | const char* keywords[] = { "nfeatures", "nOctaveLayers", "contrastThreshold", "edgeThreshold", "sigma", "descriptorType", "enable_precise_upscale", NULL };
| 20920 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:SIFT.create", (char**)keywords, &pyobj_nfeatures, &pyobj_nOctaveLayers, &pyobj_contrastThreshold, &pyobj_edgeThreshold, &pyobj_sigma, &pyobj_descriptorType, &pyobj_enable_precise_upscale) && |  | 20872 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:SIFT.create", (char**)keywords, &pyobj_nfeatures, &pyobj_nOctaveLayers, &pyobj_contrastThreshold, &pyobj_edgeThreshold, &pyobj_sigma, &pyobj_descriptorType, &pyobj_enable_precise_upscale) &&
| 20921 | pyopencv_to_safe(pyobj_nfeatures, nfeatures, ArgInfo("nfeatures", 0)) && |  | 20873 | pyopencv_to_safe(pyobj_nfeatures, nfeatures, ArgInfo("nfeatures", 0)) &&
| 20922 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) && |  | 20874 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) &&
| 20923 | pyopencv_to_safe(pyobj_contrastThreshold, contrastThreshold, ArgInfo("contrastThreshold", 0)) && |  | 20875 | pyopencv_to_safe(pyobj_contrastThreshold, contrastThreshold, ArgInfo("contrastThreshold", 0)) &&
| 20924 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) && |  | 20876 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) &&
| 20925 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) && |  | 20877 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) &&
| 20926 | pyopencv_to_safe(pyobj_descriptorType, descriptorType, ArgInfo("descriptorType", 0)) && |  | 20878 | pyopencv_to_safe(pyobj_descriptorType, descriptorType, ArgInfo("descriptorType", 0)) &&
| 20927 | pyopencv_to_safe(pyobj_enable_precise_upscale, enable_precise_upscale, ArgInfo("enable_precise_upscale", 0)) ) |  | 20879 | pyopencv_to_safe(pyobj_enable_precise_upscale, enable_precise_upscale, ArgInfo("enable_precise_upscale", 0)) )
| 20928 | { |  | 20880 | {
| 20929 | ERRWRAP2(retval = cv::SIFT::create(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, descriptorType, enable_precise_upscale)); |  | 20881 | ERRWRAP2(retval = cv::SIFT::create(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, descriptorType, enable_precise_upscale));
| 20930 | return pyopencv_from(retval); |  | 20882 | return pyopencv_from(retval);
| 20931 | } |  | 20883 | }
| 20932 |  |  | 20884 |
| 20933 |  |  | 20885 |
| 20934 | pyPopulateArgumentConversionErrors(); |  | 20886 | pyPopulateArgumentConversionErrors();
| 20935 | } |  | 20887 | }
| 20936 | pyRaiseCVOverloadException("create"); |  | 20888 | pyRaiseCVOverloadException("create");
| 20937 |  |  | 20889 |
| 20938 | return NULL; |  | 20890 | return NULL;
| 20939 | } |  | 20891 | }
| 20940 |  |  | 20892 |
| 20941 | static PyObject* pyopencv_cv_SIFT_getContrastThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20893 | static PyObject* pyopencv_cv_SIFT_getContrastThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 20942 | { |  | 20894 | {
| 20943 | using namespace cv; |  | 20895 | using namespace cv;
| 20944 |  |  | 20896 |
| 20945 |  |  | 20897 |
| 20946 | Ptr<cv::SIFT> * self1 = 0; |  | 20898 | Ptr<cv::SIFT> * self1 = 0;
| 20947 | if (!pyopencv_SIFT_getp(self, self1)) |  | 20899 | if (!pyopencv_SIFT_getp(self, self1))
| 20948 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 20900 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 20949 | Ptr<cv::SIFT> _self_ = *(self1); |  | 20901 | Ptr<cv::SIFT> _self_ = *(self1);
| 20950 | double retval; |  | 20902 | double retval;
| 20951 |  |  | 20903 |
| 20952 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20904 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20953 | { |  | 20905 | {
| 20954 | ERRWRAP2(retval = _self_->getContrastThreshold()); |  | 20906 | ERRWRAP2(retval = _self_->getContrastThreshold());
| 20955 | return pyopencv_from(retval); |  | 20907 | return pyopencv_from(retval);
| 20956 | } |  | 20908 | }
| 20957 |  |  | 20909 |
| 20958 | return NULL; |  | 20910 | return NULL;
| 20959 | } |  | 20911 | }
| 20960 |  |  | 20912 |
| 20961 | static PyObject* pyopencv_cv_SIFT_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20913 | static PyObject* pyopencv_cv_SIFT_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 20962 | { |  | 20914 | {
| 20963 | using namespace cv; |  | 20915 | using namespace cv;
| 20964 |  |  | 20916 |
| 20965 |  |  | 20917 |
| 20966 | Ptr<cv::SIFT> * self1 = 0; |  | 20918 | Ptr<cv::SIFT> * self1 = 0;
| 20967 | if (!pyopencv_SIFT_getp(self, self1)) |  | 20919 | if (!pyopencv_SIFT_getp(self, self1))
| 20968 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 20920 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 20969 | Ptr<cv::SIFT> _self_ = *(self1); |  | 20921 | Ptr<cv::SIFT> _self_ = *(self1);
| 20970 | String retval; |  | 20922 | String retval;
| 20971 |  |  | 20923 |
| 20972 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20924 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20973 | { |  | 20925 | {
| 20974 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 20926 | ERRWRAP2(retval = _self_->getDefaultName());
| 20975 | return pyopencv_from(retval); |  | 20927 | return pyopencv_from(retval);
| 20976 | } |  | 20928 | }
| 20977 |  |  | 20929 |
| 20978 | return NULL; |  | 20930 | return NULL;
| 20979 | } |  | 20931 | }
| 20980 |  |  | 20932 |
| 20981 | static PyObject* pyopencv_cv_SIFT_getEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20933 | static PyObject* pyopencv_cv_SIFT_getEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 20982 | { |  | 20934 | {
| 20983 | using namespace cv; |  | 20935 | using namespace cv;
| 20984 |  |  | 20936 |
| 20985 |  |  | 20937 |
| 20986 | Ptr<cv::SIFT> * self1 = 0; |  | 20938 | Ptr<cv::SIFT> * self1 = 0;
| 20987 | if (!pyopencv_SIFT_getp(self, self1)) |  | 20939 | if (!pyopencv_SIFT_getp(self, self1))
| 20988 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 20940 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 20989 | Ptr<cv::SIFT> _self_ = *(self1); |  | 20941 | Ptr<cv::SIFT> _self_ = *(self1);
| 20990 | double retval; |  | 20942 | double retval;
| 20991 |  |  | 20943 |
| 20992 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20944 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 20993 | { |  | 20945 | {
| 20994 | ERRWRAP2(retval = _self_->getEdgeThreshold()); |  | 20946 | ERRWRAP2(retval = _self_->getEdgeThreshold());
| 20995 | return pyopencv_from(retval); |  | 20947 | return pyopencv_from(retval);
| 20996 | } |  | 20948 | }
| 20997 |  |  | 20949 |
| 20998 | return NULL; |  | 20950 | return NULL;
| 20999 | } |  | 20951 | }
| 21000 |  |  | 20952 |
| 21001 | static PyObject* pyopencv_cv_SIFT_getNFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20953 | static PyObject* pyopencv_cv_SIFT_getNFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 21002 | { |  | 20954 | {
| 21003 | using namespace cv; |  | 20955 | using namespace cv;
| 21004 |  |  | 20956 |
| 21005 |  |  | 20957 |
| 21006 | Ptr<cv::SIFT> * self1 = 0; |  | 20958 | Ptr<cv::SIFT> * self1 = 0;
| 21007 | if (!pyopencv_SIFT_getp(self, self1)) |  | 20959 | if (!pyopencv_SIFT_getp(self, self1))
| 21008 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 20960 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21009 | Ptr<cv::SIFT> _self_ = *(self1); |  | 20961 | Ptr<cv::SIFT> _self_ = *(self1);
| 21010 | int retval; |  | 20962 | int retval;
| 21011 |  |  | 20963 |
| 21012 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20964 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21013 | { |  | 20965 | {
| 21014 | ERRWRAP2(retval = _self_->getNFeatures()); |  | 20966 | ERRWRAP2(retval = _self_->getNFeatures());
| 21015 | return pyopencv_from(retval); |  | 20967 | return pyopencv_from(retval);
| 21016 | } |  | 20968 | }
| 21017 |  |  | 20969 |
| 21018 | return NULL; |  | 20970 | return NULL;
| 21019 | } |  | 20971 | }
| 21020 |  |  | 20972 |
| 21021 | static PyObject* pyopencv_cv_SIFT_getNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20973 | static PyObject* pyopencv_cv_SIFT_getNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw)
| 21022 | { |  | 20974 | {
| 21023 | using namespace cv; |  | 20975 | using namespace cv;
| 21024 |  |  | 20976 |
| 21025 |  |  | 20977 |
| 21026 | Ptr<cv::SIFT> * self1 = 0; |  | 20978 | Ptr<cv::SIFT> * self1 = 0;
| 21027 | if (!pyopencv_SIFT_getp(self, self1)) |  | 20979 | if (!pyopencv_SIFT_getp(self, self1))
| 21028 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 20980 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21029 | Ptr<cv::SIFT> _self_ = *(self1); |  | 20981 | Ptr<cv::SIFT> _self_ = *(self1);
| 21030 | int retval; |  | 20982 | int retval;
| 21031 |  |  | 20983 |
| 21032 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 20984 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21033 | { |  | 20985 | {
| 21034 | ERRWRAP2(retval = _self_->getNOctaveLayers()); |  | 20986 | ERRWRAP2(retval = _self_->getNOctaveLayers());
| 21035 | return pyopencv_from(retval); |  | 20987 | return pyopencv_from(retval);
| 21036 | } |  | 20988 | }
| 21037 |  |  | 20989 |
| 21038 | return NULL; |  | 20990 | return NULL;
| 21039 | } |  | 20991 | }
| 21040 |  |  | 20992 |
| 21041 | static PyObject* pyopencv_cv_SIFT_getSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 20993 | static PyObject* pyopencv_cv_SIFT_getSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 21042 | { |  | 20994 | {
| 21043 | using namespace cv; |  | 20995 | using namespace cv;
| 21044 |  |  | 20996 |
| 21045 |  |  | 20997 |
| 21046 | Ptr<cv::SIFT> * self1 = 0; |  | 20998 | Ptr<cv::SIFT> * self1 = 0;
| 21047 | if (!pyopencv_SIFT_getp(self, self1)) |  | 20999 | if (!pyopencv_SIFT_getp(self, self1))
| 21048 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 21000 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21049 | Ptr<cv::SIFT> _self_ = *(self1); |  | 21001 | Ptr<cv::SIFT> _self_ = *(self1);
| 21050 | double retval; |  | 21002 | double retval;
| 21051 |  |  | 21003 |
| 21052 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21004 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21053 | { |  | 21005 | {
| 21054 | ERRWRAP2(retval = _self_->getSigma()); |  | 21006 | ERRWRAP2(retval = _self_->getSigma());
| 21055 | return pyopencv_from(retval); |  | 21007 | return pyopencv_from(retval);
| 21056 | } |  | 21008 | }
| 21057 |  |  | 21009 |
| 21058 | return NULL; |  | 21010 | return NULL;
| 21059 | } |  | 21011 | }
| 21060 |  |  | 21012 |
| 21061 | static PyObject* pyopencv_cv_SIFT_setContrastThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21013 | static PyObject* pyopencv_cv_SIFT_setContrastThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 21062 | { |  | 21014 | {
| 21063 | using namespace cv; |  | 21015 | using namespace cv;
| 21064 |  |  | 21016 |
| 21065 |  |  | 21017 |
| 21066 | Ptr<cv::SIFT> * self1 = 0; |  | 21018 | Ptr<cv::SIFT> * self1 = 0;
| 21067 | if (!pyopencv_SIFT_getp(self, self1)) |  | 21019 | if (!pyopencv_SIFT_getp(self, self1))
| 21068 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 21020 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21069 | Ptr<cv::SIFT> _self_ = *(self1); |  | 21021 | Ptr<cv::SIFT> _self_ = *(self1);
| 21070 | PyObject* pyobj_contrastThreshold = NULL; |  | 21022 | PyObject* pyobj_contrastThreshold = NULL;
| 21071 | double contrastThreshold=0; |  | 21023 | double contrastThreshold=0;
| 21072 |  |  | 21024 |
| 21073 | const char* keywords[] = { "contrastThreshold", NULL }; |  | 21025 | const char* keywords[] = { "contrastThreshold", NULL };
| 21074 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setContrastThreshold", (char**)keywords, &pyobj_contrastThreshold) && |  | 21026 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setContrastThreshold", (char**)keywords, &pyobj_contrastThreshold) &&
| 21075 | pyopencv_to_safe(pyobj_contrastThreshold, contrastThreshold, ArgInfo("contrastThreshold", 0)) ) |  | 21027 | pyopencv_to_safe(pyobj_contrastThreshold, contrastThreshold, ArgInfo("contrastThreshold", 0)) )
| 21076 | { |  | 21028 | {
| 21077 | ERRWRAP2(_self_->setContrastThreshold(contrastThreshold)); |  | 21029 | ERRWRAP2(_self_->setContrastThreshold(contrastThreshold));
| 21078 | Py_RETURN_NONE; |  | 21030 | Py_RETURN_NONE;
| 21079 | } |  | 21031 | }
| 21080 |  |  | 21032 |
| 21081 | return NULL; |  | 21033 | return NULL;
| 21082 | } |  | 21034 | }
| 21083 |  |  | 21035 |
| 21084 | static PyObject* pyopencv_cv_SIFT_setEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21036 | static PyObject* pyopencv_cv_SIFT_setEdgeThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 21085 | { |  | 21037 | {
| 21086 | using namespace cv; |  | 21038 | using namespace cv;
| 21087 |  |  | 21039 |
| 21088 |  |  | 21040 |
| 21089 | Ptr<cv::SIFT> * self1 = 0; |  | 21041 | Ptr<cv::SIFT> * self1 = 0;
| 21090 | if (!pyopencv_SIFT_getp(self, self1)) |  | 21042 | if (!pyopencv_SIFT_getp(self, self1))
| 21091 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 21043 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21092 | Ptr<cv::SIFT> _self_ = *(self1); |  | 21044 | Ptr<cv::SIFT> _self_ = *(self1);
| 21093 | PyObject* pyobj_edgeThreshold = NULL; |  | 21045 | PyObject* pyobj_edgeThreshold = NULL;
| 21094 | double edgeThreshold=0; |  | 21046 | double edgeThreshold=0;
| 21095 |  |  | 21047 |
| 21096 | const char* keywords[] = { "edgeThreshold", NULL }; |  | 21048 | const char* keywords[] = { "edgeThreshold", NULL };
| 21097 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setEdgeThreshold", (char**)keywords, &pyobj_edgeThreshold) && |  | 21049 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setEdgeThreshold", (char**)keywords, &pyobj_edgeThreshold) &&
| 21098 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) ) |  | 21050 | pyopencv_to_safe(pyobj_edgeThreshold, edgeThreshold, ArgInfo("edgeThreshold", 0)) )
| 21099 | { |  | 21051 | {
| 21100 | ERRWRAP2(_self_->setEdgeThreshold(edgeThreshold)); |  | 21052 | ERRWRAP2(_self_->setEdgeThreshold(edgeThreshold));
| 21101 | Py_RETURN_NONE; |  | 21053 | Py_RETURN_NONE;
| 21102 | } |  | 21054 | }
| 21103 |  |  | 21055 |
| 21104 | return NULL; |  | 21056 | return NULL;
| 21105 | } |  | 21057 | }
| 21106 |  |  | 21058 |
| 21107 | static PyObject* pyopencv_cv_SIFT_setNFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21059 | static PyObject* pyopencv_cv_SIFT_setNFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 21108 | { |  | 21060 | {
| 21109 | using namespace cv; |  | 21061 | using namespace cv;
| 21110 |  |  | 21062 |
| 21111 |  |  | 21063 |
| 21112 | Ptr<cv::SIFT> * self1 = 0; |  | 21064 | Ptr<cv::SIFT> * self1 = 0;
| 21113 | if (!pyopencv_SIFT_getp(self, self1)) |  | 21065 | if (!pyopencv_SIFT_getp(self, self1))
| 21114 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 21066 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21115 | Ptr<cv::SIFT> _self_ = *(self1); |  | 21067 | Ptr<cv::SIFT> _self_ = *(self1);
| 21116 | PyObject* pyobj_maxFeatures = NULL; |  | 21068 | PyObject* pyobj_maxFeatures = NULL;
| 21117 | int maxFeatures=0; |  | 21069 | int maxFeatures=0;
| 21118 |  |  | 21070 |
| 21119 | const char* keywords[] = { "maxFeatures", NULL }; |  | 21071 | const char* keywords[] = { "maxFeatures", NULL };
| 21120 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setNFeatures", (char**)keywords, &pyobj_maxFeatures) && |  | 21072 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setNFeatures", (char**)keywords, &pyobj_maxFeatures) &&
| 21121 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) ) |  | 21073 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) )
| 21122 | { |  | 21074 | {
| 21123 | ERRWRAP2(_self_->setNFeatures(maxFeatures)); |  | 21075 | ERRWRAP2(_self_->setNFeatures(maxFeatures));
| 21124 | Py_RETURN_NONE; |  | 21076 | Py_RETURN_NONE;
| 21125 | } |  | 21077 | }
| 21126 |  |  | 21078 |
| 21127 | return NULL; |  | 21079 | return NULL;
| 21128 | } |  | 21080 | }
| 21129 |  |  | 21081 |
| 21130 | static PyObject* pyopencv_cv_SIFT_setNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21082 | static PyObject* pyopencv_cv_SIFT_setNOctaveLayers(PyObject* self, PyObject* py_args, PyObject* kw)
| 21131 | { |  | 21083 | {
| 21132 | using namespace cv; |  | 21084 | using namespace cv;
| 21133 |  |  | 21085 |
| 21134 |  |  | 21086 |
| 21135 | Ptr<cv::SIFT> * self1 = 0; |  | 21087 | Ptr<cv::SIFT> * self1 = 0;
| 21136 | if (!pyopencv_SIFT_getp(self, self1)) |  | 21088 | if (!pyopencv_SIFT_getp(self, self1))
| 21137 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 21089 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21138 | Ptr<cv::SIFT> _self_ = *(self1); |  | 21090 | Ptr<cv::SIFT> _self_ = *(self1);
| 21139 | PyObject* pyobj_nOctaveLayers = NULL; |  | 21091 | PyObject* pyobj_nOctaveLayers = NULL;
| 21140 | int nOctaveLayers=0; |  | 21092 | int nOctaveLayers=0;
| 21141 |  |  | 21093 |
| 21142 | const char* keywords[] = { "nOctaveLayers", NULL }; |  | 21094 | const char* keywords[] = { "nOctaveLayers", NULL };
| 21143 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setNOctaveLayers", (char**)keywords, &pyobj_nOctaveLayers) && |  | 21095 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setNOctaveLayers", (char**)keywords, &pyobj_nOctaveLayers) &&
| 21144 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) ) |  | 21096 | pyopencv_to_safe(pyobj_nOctaveLayers, nOctaveLayers, ArgInfo("nOctaveLayers", 0)) )
| 21145 | { |  | 21097 | {
| 21146 | ERRWRAP2(_self_->setNOctaveLayers(nOctaveLayers)); |  | 21098 | ERRWRAP2(_self_->setNOctaveLayers(nOctaveLayers));
| 21147 | Py_RETURN_NONE; |  | 21099 | Py_RETURN_NONE;
| 21148 | } |  | 21100 | }
| 21149 |  |  | 21101 |
| 21150 | return NULL; |  | 21102 | return NULL;
| 21151 | } |  | 21103 | }
| 21152 |  |  | 21104 |
| 21153 | static PyObject* pyopencv_cv_SIFT_setSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21105 | static PyObject* pyopencv_cv_SIFT_setSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 21154 | { |  | 21106 | {
| 21155 | using namespace cv; |  | 21107 | using namespace cv;
| 21156 |  |  | 21108 |
| 21157 |  |  | 21109 |
| 21158 | Ptr<cv::SIFT> * self1 = 0; |  | 21110 | Ptr<cv::SIFT> * self1 = 0;
| 21159 | if (!pyopencv_SIFT_getp(self, self1)) |  | 21111 | if (!pyopencv_SIFT_getp(self, self1))
| 21160 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)"); |  | 21112 | return failmsgp("Incorrect type of self (must be 'SIFT' or its derivative)");
| 21161 | Ptr<cv::SIFT> _self_ = *(self1); |  | 21113 | Ptr<cv::SIFT> _self_ = *(self1);
| 21162 | PyObject* pyobj_sigma = NULL; |  | 21114 | PyObject* pyobj_sigma = NULL;
| 21163 | double sigma=0; |  | 21115 | double sigma=0;
| 21164 |  |  | 21116 |
| 21165 | const char* keywords[] = { "sigma", NULL }; |  | 21117 | const char* keywords[] = { "sigma", NULL };
| 21166 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setSigma", (char**)keywords, &pyobj_sigma) && |  | 21118 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SIFT.setSigma", (char**)keywords, &pyobj_sigma) &&
| 21167 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) ) |  | 21119 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) )
| 21168 | { |  | 21120 | {
| 21169 | ERRWRAP2(_self_->setSigma(sigma)); |  | 21121 | ERRWRAP2(_self_->setSigma(sigma));
| 21170 | Py_RETURN_NONE; |  | 21122 | Py_RETURN_NONE;
| 21171 | } |  | 21123 | }
| 21172 |  |  | 21124 |
| 21173 | return NULL; |  | 21125 | return NULL;
| 21174 | } |  | 21126 | }
| 21175 |  |  | 21127 |
| 21176 |  |  | 21128 |
| 21177 |  |  | 21129 |
| 21178 | // Tables (SIFT) |  | 21130 | // Tables (SIFT)
| 21179 |  |  | 21131 |
| 21180 | static PyGetSetDef pyopencv_SIFT_getseters[] = |  | 21132 | static PyGetSetDef pyopencv_SIFT_getseters[] =
| 21181 | { |  | 21133 | {
| 21182 | {NULL} /* Sentinel */ |  | 21134 | {NULL} /* Sentinel */
| 21183 | }; |  | 21135 | };
| 21184 |  |  | 21136 |
| 21185 | static PyMethodDef pyopencv_SIFT_methods[] = |  | 21137 | static PyMethodDef pyopencv_SIFT_methods[] =
| 21186 | { |  | 21138 | {
| 21187 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_create_static, METH_STATIC), "create([, nfeatures[, nOctaveLayers[, contrastThreshold[, edgeThreshold[, sigma[, enable_precise_upscale]]]]]]) -> retval\n. @param nfeatures The number of best features to retain. The features are ranked by their scores\n. (measured in SIFT algorithm as the local contrast)\n. \n. @param nOctaveLayers The number of layers in each octave. 3 is the value used in D. Lowe paper. The\n. number of octaves is computed automatically from the image resolution.\n. \n. @param contrastThreshold The contrast threshold used to filter out weak features in semi-uniform\n. (low-contrast) regions. The larger the threshold, the less features are produced by the detector.\n. \n. @note The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When\n. nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set\n. this argument to 0.09.\n. \n. @param edgeThreshold The threshold used to filter out edge-like features. Note that the its meaning\n. is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are\n. filtered out (more features are retained).\n. \n. @param sigma The sigma of the Gaussian applied to the input image at the octave \\#0. If your image\n. is captured with a weak camera with soft lenses, you might want to reduce the number.\n. \n. @param enable_precise_upscale Whether to enable precise upscaling in the scale pyramid, which maps\n. index \\f$\\texttt{x}\\f$ to \\f$\\texttt{2x}\\f$. This prevents localization bias. The option\n. is disabled by default.\n\n\n\ncreate(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, descriptorType[, enable_precise_upscale]) -> retval\n. @brief Create SIFT with specified descriptorType.\n. @param nfeatures The number of best features to retain. The features are ranked by their scores\n. (measured in SIFT algorithm as the local contrast)\n. \n. @param nOctaveLayers The number of layers in each octave. 3 is the value used in D. Lowe paper. The\n. number of octaves is computed automatically from the image resolution.\n. \n. @param contrastThreshold The contrast threshold used to filter out weak features in semi-uniform\n. (low-contrast) regions. The larger the threshold, the less features are produced by the detector.\n. \n. @note The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When\n. nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set\n. this argument to 0.09.\n. \n. @param edgeThreshold The threshold used to filter out edge-like features. Note that the its meaning\n. is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are\n. filtered out (more features are retained).\n. \n. @param sigma The sigma of the Gaussian applied to the input image at the octave \\#0. If your image\n. is captured with a weak camera with soft lenses, you might want to reduce the number.\n. \n. @param descriptorType The type of descriptors. Only CV_32F and CV_8U are supported.\n. \n. @param enable_precise_upscale Whether to enable precise upscaling in the scale pyramid, which maps\n. index \\f$\\texttt{x}\\f$ to \\f$\\texttt{2x}\\f$. This prevents localization bias. The option\n. is disabled by default."}, |  | 21139 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_create_static, METH_STATIC), "create([, nfeatures[, nOctaveLayers[, contrastThreshold[, edgeThreshold[, sigma[, enable_precise_upscale]]]]]]) -> retval\n. @param nfeatures The number of best features to retain. The features are ranked by their scores\n. (measured in SIFT algorithm as the local contrast)\n. \n. @param nOctaveLayers The number of layers in each octave. 3 is the value used in D. Lowe paper. The\n. number of octaves is computed automatically from the image resolution.\n. \n. @param contrastThreshold The contrast threshold used to filter out weak features in semi-uniform\n. (low-contrast) regions. The larger the threshold, the less features are produced by the detector.\n. \n. @note The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When\n. nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set\n. this argument to 0.09.\n. \n. @param edgeThreshold The threshold used to filter out edge-like features. Note that the its meaning\n. is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are\n. filtered out (more features are retained).\n. \n. @param sigma The sigma of the Gaussian applied to the input image at the octave \\#0. If your image\n. is captured with a weak camera with soft lenses, you might want to reduce the number.\n. \n. @param enable_precise_upscale Whether to enable precise upscaling in the scale pyramid, which maps\n. index \\f$\\texttt{x}\\f$ to \\f$\\texttt{2x}\\f$. This prevents localization bias. The option\n. is disabled by default.\n\n\n\ncreate(nfeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma, descriptorType[, enable_precise_upscale]) -> retval\n. @brief Create SIFT with specified descriptorType.\n. @param nfeatures The number of best features to retain. The features are ranked by their scores\n. (measured in SIFT algorithm as the local contrast)\n. \n. @param nOctaveLayers The number of layers in each octave. 3 is the value used in D. Lowe paper. The\n. number of octaves is computed automatically from the image resolution.\n. \n. @param contrastThreshold The contrast threshold used to filter out weak features in semi-uniform\n. (low-contrast) regions. The larger the threshold, the less features are produced by the detector.\n. \n. @note The contrast threshold will be divided by nOctaveLayers when the filtering is applied. When\n. nOctaveLayers is set to default and if you want to use the value used in D. Lowe paper, 0.03, set\n. this argument to 0.09.\n. \n. @param edgeThreshold The threshold used to filter out edge-like features. Note that the its meaning\n. is different from the contrastThreshold, i.e. the larger the edgeThreshold, the less features are\n. filtered out (more features are retained).\n. \n. @param sigma The sigma of the Gaussian applied to the input image at the octave \\#0. If your image\n. is captured with a weak camera with soft lenses, you might want to reduce the number.\n. \n. @param descriptorType The type of descriptors. Only CV_32F and CV_8U are supported.\n. \n. @param enable_precise_upscale Whether to enable precise upscaling in the scale pyramid, which maps\n. index \\f$\\texttt{x}\\f$ to \\f$\\texttt{2x}\\f$. This prevents localization bias. The option\n. is disabled by default."},
| 21188 | {"getContrastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getContrastThreshold, 0), "getContrastThreshold() -> retval\n."}, |  | 21140 | {"getContrastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getContrastThreshold, 0), "getContrastThreshold() -> retval\n."},
| 21189 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 21141 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 21190 | {"getEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getEdgeThreshold, 0), "getEdgeThreshold() -> retval\n."}, |  | 21142 | {"getEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getEdgeThreshold, 0), "getEdgeThreshold() -> retval\n."},
| 21191 | {"getNFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getNFeatures, 0), "getNFeatures() -> retval\n."}, |  | 21143 | {"getNFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getNFeatures, 0), "getNFeatures() -> retval\n."},
| 21192 | {"getNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getNOctaveLayers, 0), "getNOctaveLayers() -> retval\n."}, |  | 21144 | {"getNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getNOctaveLayers, 0), "getNOctaveLayers() -> retval\n."},
| 21193 | {"getSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getSigma, 0), "getSigma() -> retval\n."}, |  | 21145 | {"getSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_getSigma, 0), "getSigma() -> retval\n."},
| 21194 | {"setContrastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setContrastThreshold, 0), "setContrastThreshold(contrastThreshold) -> None\n."}, |  | 21146 | {"setContrastThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setContrastThreshold, 0), "setContrastThreshold(contrastThreshold) -> None\n."},
| 21195 | {"setEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setEdgeThreshold, 0), "setEdgeThreshold(edgeThreshold) -> None\n."}, |  | 21147 | {"setEdgeThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setEdgeThreshold, 0), "setEdgeThreshold(edgeThreshold) -> None\n."},
| 21196 | {"setNFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setNFeatures, 0), "setNFeatures(maxFeatures) -> None\n."}, |  | 21148 | {"setNFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setNFeatures, 0), "setNFeatures(maxFeatures) -> None\n."},
| 21197 | {"setNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setNOctaveLayers, 0), "setNOctaveLayers(nOctaveLayers) -> None\n."}, |  | 21149 | {"setNOctaveLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setNOctaveLayers, 0), "setNOctaveLayers(nOctaveLayers) -> None\n."},
| 21198 | {"setSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setSigma, 0), "setSigma(sigma) -> None\n."}, |  | 21150 | {"setSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_SIFT_setSigma, 0), "setSigma(sigma) -> None\n."},
| 21199 |  |  | 21151 |
| 21200 | {NULL, NULL} |  | 21152 | {NULL, NULL}
| 21201 | }; |  | 21153 | };
| 21202 |  |  | 21154 |
| 21203 | // Converter (SIFT) |  | 21155 | // Converter (SIFT)
| 21204 |  |  | 21156 |
| 21205 | template<> |  | 21157 | template<>
| 21206 | struct PyOpenCV_Converter< Ptr<cv::SIFT> > |  | 21158 | struct PyOpenCV_Converter< Ptr<cv::SIFT> >
| 21207 | { |  | 21159 | {
| 21208 | static PyObject* from(const Ptr<cv::SIFT>& r) |  | 21160 | static PyObject* from(const Ptr<cv::SIFT>& r)
| 21209 | { |  | 21161 | {
| 21210 | return pyopencv_SIFT_Instance(r); |  | 21162 | return pyopencv_SIFT_Instance(r);
| 21211 | } |  | 21163 | }
| 21212 | static bool to(PyObject* src, Ptr<cv::SIFT>& dst, const ArgInfo& info) |  | 21164 | static bool to(PyObject* src, Ptr<cv::SIFT>& dst, const ArgInfo& info)
| 21213 | { |  | 21165 | {
| 21214 | if(!src || src == Py_None) |  | 21166 | if(!src || src == Py_None)
| 21215 | return true; |  | 21167 | return true;
| 21216 | Ptr<cv::SIFT> * dst_; |  | 21168 | Ptr<cv::SIFT> * dst_;
| 21217 | if (pyopencv_SIFT_getp(src, dst_)) |  | 21169 | if (pyopencv_SIFT_getp(src, dst_))
| 21218 | { |  | 21170 | {
| 21219 | dst = *dst_; |  | 21171 | dst = *dst_;
| 21220 | return true; |  | 21172 | return true;
| 21221 | } |  | 21173 | }
| 21222 |  |  | 21174 |
| 21223 | failmsg("Expected Ptr<cv::SIFT> for argument '%s'", info.name); |  | 21175 | failmsg("Expected Ptr<cv::SIFT> for argument '%s'", info.name);
| 21224 | return false; |  | 21176 | return false;
| 21225 | } |  | 21177 | }
| 21226 | }; |  | 21178 | };
| 21227 |  |  | 21179 |
| 21228 | //================================================================================ |  | 21180 | //================================================================================
| 21229 | // ShapeContextDistanceExtractor (Generic) |  | 21181 | // ShapeContextDistanceExtractor (Generic)
| 21230 | //================================================================================ |  | 21182 | //================================================================================
| 21231 |  |  | 21183 |
| 21232 | // GetSet (ShapeContextDistanceExtractor) |  | 21184 | // GetSet (ShapeContextDistanceExtractor)
| 21233 |  |  | 21185 |
| 21234 |  |  | 21186 |
| 21235 |  |  | 21187 |
| 21236 | // Methods (ShapeContextDistanceExtractor) |  | 21188 | // Methods (ShapeContextDistanceExtractor)
| 21237 |  |  | 21189 |
| 21238 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getAngularBins(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21190 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getAngularBins(PyObject* self, PyObject* py_args, PyObject* kw)
| 21239 | { |  | 21191 | {
| 21240 | using namespace cv; |  | 21192 | using namespace cv;
| 21241 |  |  | 21193 |
| 21242 |  |  | 21194 |
| 21243 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21195 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21244 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21196 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21245 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21197 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21246 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21198 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21247 | int retval; |  | 21199 | int retval;
| 21248 |  |  | 21200 |
| 21249 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21201 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21250 | { |  | 21202 | {
| 21251 | ERRWRAP2(retval = _self_->getAngularBins()); |  | 21203 | ERRWRAP2(retval = _self_->getAngularBins());
| 21252 | return pyopencv_from(retval); |  | 21204 | return pyopencv_from(retval);
| 21253 | } |  | 21205 | }
| 21254 |  |  | 21206 |
| 21255 | return NULL; |  | 21207 | return NULL;
| 21256 | } |  | 21208 | }
| 21257 |  |  | 21209 |
| 21258 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getBendingEnergyWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21210 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getBendingEnergyWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 21259 | { |  | 21211 | {
| 21260 | using namespace cv; |  | 21212 | using namespace cv;
| 21261 |  |  | 21213 |
| 21262 |  |  | 21214 |
| 21263 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21215 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21264 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21216 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21265 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21217 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21266 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21218 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21267 | float retval; |  | 21219 | float retval;
| 21268 |  |  | 21220 |
| 21269 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21221 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21270 | { |  | 21222 | {
| 21271 | ERRWRAP2(retval = _self_->getBendingEnergyWeight()); |  | 21223 | ERRWRAP2(retval = _self_->getBendingEnergyWeight());
| 21272 | return pyopencv_from(retval); |  | 21224 | return pyopencv_from(retval);
| 21273 | } |  | 21225 | }
| 21274 |  |  | 21226 |
| 21275 | return NULL; |  | 21227 | return NULL;
| 21276 | } |  | 21228 | }
| 21277 |  |  | 21229 |
| 21278 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getCostExtractor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21230 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getCostExtractor(PyObject* self, PyObject* py_args, PyObject* kw)
| 21279 | { |  | 21231 | {
| 21280 | using namespace cv; |  | 21232 | using namespace cv;
| 21281 |  |  | 21233 |
| 21282 |  |  | 21234 |
| 21283 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21235 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21284 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21236 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21285 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21237 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21286 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21238 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21287 | Ptr<HistogramCostExtractor> retval; |  | 21239 | Ptr<HistogramCostExtractor> retval;
| 21288 |  |  | 21240 |
| 21289 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21241 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21290 | { |  | 21242 | {
| 21291 | ERRWRAP2(retval = _self_->getCostExtractor()); |  | 21243 | ERRWRAP2(retval = _self_->getCostExtractor());
| 21292 | return pyopencv_from(retval); |  | 21244 | return pyopencv_from(retval);
| 21293 | } |  | 21245 | }
| 21294 |  |  | 21246 |
| 21295 | return NULL; |  | 21247 | return NULL;
| 21296 | } |  | 21248 | }
| 21297 |  |  | 21249 |
| 21298 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getImageAppearanceWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21250 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getImageAppearanceWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 21299 | { |  | 21251 | {
| 21300 | using namespace cv; |  | 21252 | using namespace cv;
| 21301 |  |  | 21253 |
| 21302 |  |  | 21254 |
| 21303 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21255 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21304 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21256 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21305 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21257 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21306 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21258 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21307 | float retval; |  | 21259 | float retval;
| 21308 |  |  | 21260 |
| 21309 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21261 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21310 | { |  | 21262 | {
| 21311 | ERRWRAP2(retval = _self_->getImageAppearanceWeight()); |  | 21263 | ERRWRAP2(retval = _self_->getImageAppearanceWeight());
| 21312 | return pyopencv_from(retval); |  | 21264 | return pyopencv_from(retval);
| 21313 | } |  | 21265 | }
| 21314 |  |  | 21266 |
| 21315 | return NULL; |  | 21267 | return NULL;
| 21316 | } |  | 21268 | }
| 21317 |  |  | 21269 |
| 21318 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getImages(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21270 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getImages(PyObject* self, PyObject* py_args, PyObject* kw)
| 21319 | { |  | 21271 | {
| 21320 | using namespace cv; |  | 21272 | using namespace cv;
| 21321 |  |  | 21273 |
| 21322 |  |  | 21274 |
| 21323 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21275 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21324 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21276 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21325 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21277 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21326 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21278 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21327 | pyPrepareArgumentConversionErrorsStorage(2); |  | 21279 | pyPrepareArgumentConversionErrorsStorage(2);
| 21328 |  |  | 21280 |
| 21329 | { |  | 21281 | {
| 21330 | PyObject* pyobj_image1 = NULL; |  | 21282 | PyObject* pyobj_image1 = NULL;
| 21331 | Mat image1; |  | 21283 | Mat image1;
| 21332 | PyObject* pyobj_image2 = NULL; |  | 21284 | PyObject* pyobj_image2 = NULL;
| 21333 | Mat image2; |  | 21285 | Mat image2;
| 21334 |  |  | 21286 |
| 21335 | const char* keywords[] = { "image1", "image2", NULL }; |  | 21287 | const char* keywords[] = { "image1", "image2", NULL };
| 21336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:ShapeContextDistanceExtractor.getImages", (char**)keywords, &pyobj_image1, &pyobj_image2) && |  | 21288 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:ShapeContextDistanceExtractor.getImages", (char**)keywords, &pyobj_image1, &pyobj_image2) &&
| 21337 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 1)) && |  | 21289 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 1)) &&
| 21338 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 1)) ) |  | 21290 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 1)) )
| 21339 | { |  | 21291 | {
| 21340 | ERRWRAP2(_self_->getImages(image1, image2)); |  | 21292 | ERRWRAP2(_self_->getImages(image1, image2));
| 21341 | return Py_BuildValue("(NN)", pyopencv_from(image1), pyopencv_from(image2)); |  | 21293 | return Py_BuildValue("(NN)", pyopencv_from(image1), pyopencv_from(image2));
| 21342 | } |  | 21294 | }
| 21343 |  |  | 21295 |
| 21344 |  |  | 21296 |
| 21345 | pyPopulateArgumentConversionErrors(); |  | 21297 | pyPopulateArgumentConversionErrors();
| 21346 | } |  | 21298 | }
| 21347 |  |  | 21299 |
| 21348 |  |  | 21300 |
| 21349 | { |  | 21301 | {
| 21350 | PyObject* pyobj_image1 = NULL; |  | 21302 | PyObject* pyobj_image1 = NULL;
| 21351 | UMat image1; |  | 21303 | UMat image1;
| 21352 | PyObject* pyobj_image2 = NULL; |  | 21304 | PyObject* pyobj_image2 = NULL;
| 21353 | UMat image2; |  | 21305 | UMat image2;
| 21354 |  |  | 21306 |
| 21355 | const char* keywords[] = { "image1", "image2", NULL }; |  | 21307 | const char* keywords[] = { "image1", "image2", NULL };
| 21356 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:ShapeContextDistanceExtractor.getImages", (char**)keywords, &pyobj_image1, &pyobj_image2) && |  | 21308 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:ShapeContextDistanceExtractor.getImages", (char**)keywords, &pyobj_image1, &pyobj_image2) &&
| 21357 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 1)) && |  | 21309 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 1)) &&
| 21358 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 1)) ) |  | 21310 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 1)) )
| 21359 | { |  | 21311 | {
| 21360 | ERRWRAP2(_self_->getImages(image1, image2)); |  | 21312 | ERRWRAP2(_self_->getImages(image1, image2));
| 21361 | return Py_BuildValue("(NN)", pyopencv_from(image1), pyopencv_from(image2)); |  | 21313 | return Py_BuildValue("(NN)", pyopencv_from(image1), pyopencv_from(image2));
| 21362 | } |  | 21314 | }
| 21363 |  |  | 21315 |
| 21364 |  |  | 21316 |
| 21365 | pyPopulateArgumentConversionErrors(); |  | 21317 | pyPopulateArgumentConversionErrors();
| 21366 | } |  | 21318 | }
| 21367 | pyRaiseCVOverloadException("getImages"); |  | 21319 | pyRaiseCVOverloadException("getImages");
| 21368 |  |  | 21320 |
| 21369 | return NULL; |  | 21321 | return NULL;
| 21370 | } |  | 21322 | }
| 21371 |  |  | 21323 |
| 21372 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getInnerRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21324 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getInnerRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 21373 | { |  | 21325 | {
| 21374 | using namespace cv; |  | 21326 | using namespace cv;
| 21375 |  |  | 21327 |
| 21376 |  |  | 21328 |
| 21377 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21329 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21378 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21330 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21379 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21331 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21380 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21332 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21381 | float retval; |  | 21333 | float retval;
| 21382 |  |  | 21334 |
| 21383 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21335 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21384 | { |  | 21336 | {
| 21385 | ERRWRAP2(retval = _self_->getInnerRadius()); |  | 21337 | ERRWRAP2(retval = _self_->getInnerRadius());
| 21386 | return pyopencv_from(retval); |  | 21338 | return pyopencv_from(retval);
| 21387 | } |  | 21339 | }
| 21388 |  |  | 21340 |
| 21389 | return NULL; |  | 21341 | return NULL;
| 21390 | } |  | 21342 | }
| 21391 |  |  | 21343 |
| 21392 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21344 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 21393 | { |  | 21345 | {
| 21394 | using namespace cv; |  | 21346 | using namespace cv;
| 21395 |  |  | 21347 |
| 21396 |  |  | 21348 |
| 21397 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21349 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21398 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21350 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21399 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21351 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21400 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21352 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21401 | int retval; |  | 21353 | int retval;
| 21402 |  |  | 21354 |
| 21403 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21355 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21404 | { |  | 21356 | {
| 21405 | ERRWRAP2(retval = _self_->getIterations()); |  | 21357 | ERRWRAP2(retval = _self_->getIterations());
| 21406 | return pyopencv_from(retval); |  | 21358 | return pyopencv_from(retval);
| 21407 | } |  | 21359 | }
| 21408 |  |  | 21360 |
| 21409 | return NULL; |  | 21361 | return NULL;
| 21410 | } |  | 21362 | }
| 21411 |  |  | 21363 |
| 21412 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getOuterRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21364 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getOuterRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 21413 | { |  | 21365 | {
| 21414 | using namespace cv; |  | 21366 | using namespace cv;
| 21415 |  |  | 21367 |
| 21416 |  |  | 21368 |
| 21417 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21369 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21418 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21370 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21419 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21371 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21420 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21372 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21421 | float retval; |  | 21373 | float retval;
| 21422 |  |  | 21374 |
| 21423 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21375 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21424 | { |  | 21376 | {
| 21425 | ERRWRAP2(retval = _self_->getOuterRadius()); |  | 21377 | ERRWRAP2(retval = _self_->getOuterRadius());
| 21426 | return pyopencv_from(retval); |  | 21378 | return pyopencv_from(retval);
| 21427 | } |  | 21379 | }
| 21428 |  |  | 21380 |
| 21429 | return NULL; |  | 21381 | return NULL;
| 21430 | } |  | 21382 | }
| 21431 |  |  | 21383 |
| 21432 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getRadialBins(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21384 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getRadialBins(PyObject* self, PyObject* py_args, PyObject* kw)
| 21433 | { |  | 21385 | {
| 21434 | using namespace cv; |  | 21386 | using namespace cv;
| 21435 |  |  | 21387 |
| 21436 |  |  | 21388 |
| 21437 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21389 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21438 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21390 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21439 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21391 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21440 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21392 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21441 | int retval; |  | 21393 | int retval;
| 21442 |  |  | 21394 |
| 21443 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21395 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21444 | { |  | 21396 | {
| 21445 | ERRWRAP2(retval = _self_->getRadialBins()); |  | 21397 | ERRWRAP2(retval = _self_->getRadialBins());
| 21446 | return pyopencv_from(retval); |  | 21398 | return pyopencv_from(retval);
| 21447 | } |  | 21399 | }
| 21448 |  |  | 21400 |
| 21449 | return NULL; |  | 21401 | return NULL;
| 21450 | } |  | 21402 | }
| 21451 |  |  | 21403 |
| 21452 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getRotationInvariant(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21404 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getRotationInvariant(PyObject* self, PyObject* py_args, PyObject* kw)
| 21453 | { |  | 21405 | {
| 21454 | using namespace cv; |  | 21406 | using namespace cv;
| 21455 |  |  | 21407 |
| 21456 |  |  | 21408 |
| 21457 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21409 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21458 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21410 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21459 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21411 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21460 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21412 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21461 | bool retval; |  | 21413 | bool retval;
| 21462 |  |  | 21414 |
| 21463 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21415 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21464 | { |  | 21416 | {
| 21465 | ERRWRAP2(retval = _self_->getRotationInvariant()); |  | 21417 | ERRWRAP2(retval = _self_->getRotationInvariant());
| 21466 | return pyopencv_from(retval); |  | 21418 | return pyopencv_from(retval);
| 21467 | } |  | 21419 | }
| 21468 |  |  | 21420 |
| 21469 | return NULL; |  | 21421 | return NULL;
| 21470 | } |  | 21422 | }
| 21471 |  |  | 21423 |
| 21472 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getShapeContextWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21424 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getShapeContextWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 21473 | { |  | 21425 | {
| 21474 | using namespace cv; |  | 21426 | using namespace cv;
| 21475 |  |  | 21427 |
| 21476 |  |  | 21428 |
| 21477 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21429 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21478 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21430 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21479 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21431 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21480 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21432 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21481 | float retval; |  | 21433 | float retval;
| 21482 |  |  | 21434 |
| 21483 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21435 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21484 | { |  | 21436 | {
| 21485 | ERRWRAP2(retval = _self_->getShapeContextWeight()); |  | 21437 | ERRWRAP2(retval = _self_->getShapeContextWeight());
| 21486 | return pyopencv_from(retval); |  | 21438 | return pyopencv_from(retval);
| 21487 | } |  | 21439 | }
| 21488 |  |  | 21440 |
| 21489 | return NULL; |  | 21441 | return NULL;
| 21490 | } |  | 21442 | }
| 21491 |  |  | 21443 |
| 21492 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getStdDev(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21444 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getStdDev(PyObject* self, PyObject* py_args, PyObject* kw)
| 21493 | { |  | 21445 | {
| 21494 | using namespace cv; |  | 21446 | using namespace cv;
| 21495 |  |  | 21447 |
| 21496 |  |  | 21448 |
| 21497 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21449 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21498 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21450 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21499 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21451 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21500 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21452 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21501 | float retval; |  | 21453 | float retval;
| 21502 |  |  | 21454 |
| 21503 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21455 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21504 | { |  | 21456 | {
| 21505 | ERRWRAP2(retval = _self_->getStdDev()); |  | 21457 | ERRWRAP2(retval = _self_->getStdDev());
| 21506 | return pyopencv_from(retval); |  | 21458 | return pyopencv_from(retval);
| 21507 | } |  | 21459 | }
| 21508 |  |  | 21460 |
| 21509 | return NULL; |  | 21461 | return NULL;
| 21510 | } |  | 21462 | }
| 21511 |  |  | 21463 |
| 21512 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getTransformAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21464 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_getTransformAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw)
| 21513 | { |  | 21465 | {
| 21514 | using namespace cv; |  | 21466 | using namespace cv;
| 21515 |  |  | 21467 |
| 21516 |  |  | 21468 |
| 21517 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21469 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21518 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21470 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21519 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21471 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21520 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21472 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21521 | Ptr<ShapeTransformer> retval; |  | 21473 | Ptr<ShapeTransformer> retval;
| 21522 |  |  | 21474 |
| 21523 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 21475 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 21524 | { |  | 21476 | {
| 21525 | ERRWRAP2(retval = _self_->getTransformAlgorithm()); |  | 21477 | ERRWRAP2(retval = _self_->getTransformAlgorithm());
| 21526 | return pyopencv_from(retval); |  | 21478 | return pyopencv_from(retval);
| 21527 | } |  | 21479 | }
| 21528 |  |  | 21480 |
| 21529 | return NULL; |  | 21481 | return NULL;
| 21530 | } |  | 21482 | }
| 21531 |  |  | 21483 |
| 21532 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setAngularBins(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21484 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setAngularBins(PyObject* self, PyObject* py_args, PyObject* kw)
| 21533 | { |  | 21485 | {
| 21534 | using namespace cv; |  | 21486 | using namespace cv;
| 21535 |  |  | 21487 |
| 21536 |  |  | 21488 |
| 21537 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21489 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21538 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21490 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21539 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21491 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21540 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21492 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21541 | PyObject* pyobj_nAngularBins = NULL; |  | 21493 | PyObject* pyobj_nAngularBins = NULL;
| 21542 | int nAngularBins=0; |  | 21494 | int nAngularBins=0;
| 21543 |  |  | 21495 |
| 21544 | const char* keywords[] = { "nAngularBins", NULL }; |  | 21496 | const char* keywords[] = { "nAngularBins", NULL };
| 21545 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setAngularBins", (char**)keywords, &pyobj_nAngularBins) && |  | 21497 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setAngularBins", (char**)keywords, &pyobj_nAngularBins) &&
| 21546 | pyopencv_to_safe(pyobj_nAngularBins, nAngularBins, ArgInfo("nAngularBins", 0)) ) |  | 21498 | pyopencv_to_safe(pyobj_nAngularBins, nAngularBins, ArgInfo("nAngularBins", 0)) )
| 21547 | { |  | 21499 | {
| 21548 | ERRWRAP2(_self_->setAngularBins(nAngularBins)); |  | 21500 | ERRWRAP2(_self_->setAngularBins(nAngularBins));
| 21549 | Py_RETURN_NONE; |  | 21501 | Py_RETURN_NONE;
| 21550 | } |  | 21502 | }
| 21551 |  |  | 21503 |
| 21552 | return NULL; |  | 21504 | return NULL;
| 21553 | } |  | 21505 | }
| 21554 |  |  | 21506 |
| 21555 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setBendingEnergyWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21507 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setBendingEnergyWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 21556 | { |  | 21508 | {
| 21557 | using namespace cv; |  | 21509 | using namespace cv;
| 21558 |  |  | 21510 |
| 21559 |  |  | 21511 |
| 21560 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21512 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21561 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21513 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21562 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21514 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21563 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21515 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21564 | PyObject* pyobj_bendingEnergyWeight = NULL; |  | 21516 | PyObject* pyobj_bendingEnergyWeight = NULL;
| 21565 | float bendingEnergyWeight=0.f; |  | 21517 | float bendingEnergyWeight=0.f;
| 21566 |  |  | 21518 |
| 21567 | const char* keywords[] = { "bendingEnergyWeight", NULL }; |  | 21519 | const char* keywords[] = { "bendingEnergyWeight", NULL };
| 21568 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setBendingEnergyWeight", (char**)keywords, &pyobj_bendingEnergyWeight) && |  | 21520 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setBendingEnergyWeight", (char**)keywords, &pyobj_bendingEnergyWeight) &&
| 21569 | pyopencv_to_safe(pyobj_bendingEnergyWeight, bendingEnergyWeight, ArgInfo("bendingEnergyWeight", 0)) ) |  | 21521 | pyopencv_to_safe(pyobj_bendingEnergyWeight, bendingEnergyWeight, ArgInfo("bendingEnergyWeight", 0)) )
| 21570 | { |  | 21522 | {
| 21571 | ERRWRAP2(_self_->setBendingEnergyWeight(bendingEnergyWeight)); |  | 21523 | ERRWRAP2(_self_->setBendingEnergyWeight(bendingEnergyWeight));
| 21572 | Py_RETURN_NONE; |  | 21524 | Py_RETURN_NONE;
| 21573 | } |  | 21525 | }
| 21574 |  |  | 21526 |
| 21575 | return NULL; |  | 21527 | return NULL;
| 21576 | } |  | 21528 | }
| 21577 |  |  | 21529 |
| 21578 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setCostExtractor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21530 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setCostExtractor(PyObject* self, PyObject* py_args, PyObject* kw)
| 21579 | { |  | 21531 | {
| 21580 | using namespace cv; |  | 21532 | using namespace cv;
| 21581 |  |  | 21533 |
| 21582 |  |  | 21534 |
| 21583 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21535 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21584 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21536 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21585 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21537 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21586 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21538 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21587 | PyObject* pyobj_comparer = NULL; |  | 21539 | PyObject* pyobj_comparer = NULL;
| 21588 | Ptr<HistogramCostExtractor> comparer; |  | 21540 | Ptr<HistogramCostExtractor> comparer;
| 21589 |  |  | 21541 |
| 21590 | const char* keywords[] = { "comparer", NULL }; |  | 21542 | const char* keywords[] = { "comparer", NULL };
| 21591 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setCostExtractor", (char**)keywords, &pyobj_comparer) && |  | 21543 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setCostExtractor", (char**)keywords, &pyobj_comparer) &&
| 21592 | pyopencv_to_safe(pyobj_comparer, comparer, ArgInfo("comparer", 0)) ) |  | 21544 | pyopencv_to_safe(pyobj_comparer, comparer, ArgInfo("comparer", 0)) )
| 21593 | { |  | 21545 | {
| 21594 | ERRWRAP2(_self_->setCostExtractor(comparer)); |  | 21546 | ERRWRAP2(_self_->setCostExtractor(comparer));
| 21595 | Py_RETURN_NONE; |  | 21547 | Py_RETURN_NONE;
| 21596 | } |  | 21548 | }
| 21597 |  |  | 21549 |
| 21598 | return NULL; |  | 21550 | return NULL;
| 21599 | } |  | 21551 | }
| 21600 |  |  | 21552 |
| 21601 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setImageAppearanceWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21553 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setImageAppearanceWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 21602 | { |  | 21554 | {
| 21603 | using namespace cv; |  | 21555 | using namespace cv;
| 21604 |  |  | 21556 |
| 21605 |  |  | 21557 |
| 21606 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21558 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21607 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21559 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21608 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21560 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21609 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21561 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21610 | PyObject* pyobj_imageAppearanceWeight = NULL; |  | 21562 | PyObject* pyobj_imageAppearanceWeight = NULL;
| 21611 | float imageAppearanceWeight=0.f; |  | 21563 | float imageAppearanceWeight=0.f;
| 21612 |  |  | 21564 |
| 21613 | const char* keywords[] = { "imageAppearanceWeight", NULL }; |  | 21565 | const char* keywords[] = { "imageAppearanceWeight", NULL };
| 21614 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setImageAppearanceWeight", (char**)keywords, &pyobj_imageAppearanceWeight) && |  | 21566 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setImageAppearanceWeight", (char**)keywords, &pyobj_imageAppearanceWeight) &&
| 21615 | pyopencv_to_safe(pyobj_imageAppearanceWeight, imageAppearanceWeight, ArgInfo("imageAppearanceWeight", 0)) ) |  | 21567 | pyopencv_to_safe(pyobj_imageAppearanceWeight, imageAppearanceWeight, ArgInfo("imageAppearanceWeight", 0)) )
| 21616 | { |  | 21568 | {
| 21617 | ERRWRAP2(_self_->setImageAppearanceWeight(imageAppearanceWeight)); |  | 21569 | ERRWRAP2(_self_->setImageAppearanceWeight(imageAppearanceWeight));
| 21618 | Py_RETURN_NONE; |  | 21570 | Py_RETURN_NONE;
| 21619 | } |  | 21571 | }
| 21620 |  |  | 21572 |
| 21621 | return NULL; |  | 21573 | return NULL;
| 21622 | } |  | 21574 | }
| 21623 |  |  | 21575 |
| 21624 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setImages(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21576 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setImages(PyObject* self, PyObject* py_args, PyObject* kw)
| 21625 | { |  | 21577 | {
| 21626 | using namespace cv; |  | 21578 | using namespace cv;
| 21627 |  |  | 21579 |
| 21628 |  |  | 21580 |
| 21629 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21581 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21630 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21582 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21631 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21583 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21632 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21584 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21633 | pyPrepareArgumentConversionErrorsStorage(2); |  | 21585 | pyPrepareArgumentConversionErrorsStorage(2);
| 21634 |  |  | 21586 |
| 21635 | { |  | 21587 | {
| 21636 | PyObject* pyobj_image1 = NULL; |  | 21588 | PyObject* pyobj_image1 = NULL;
| 21637 | Mat image1; |  | 21589 | Mat image1;
| 21638 | PyObject* pyobj_image2 = NULL; |  | 21590 | PyObject* pyobj_image2 = NULL;
| 21639 | Mat image2; |  | 21591 | Mat image2;
| 21640 |  |  | 21592 |
| 21641 | const char* keywords[] = { "image1", "image2", NULL }; |  | 21593 | const char* keywords[] = { "image1", "image2", NULL };
| 21642 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeContextDistanceExtractor.setImages", (char**)keywords, &pyobj_image1, &pyobj_image2) && |  | 21594 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeContextDistanceExtractor.setImages", (char**)keywords, &pyobj_image1, &pyobj_image2) &&
| 21643 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 0)) && |  | 21595 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 0)) &&
| 21644 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 0)) ) |  | 21596 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 0)) )
| 21645 | { |  | 21597 | {
| 21646 | ERRWRAP2(_self_->setImages(image1, image2)); |  | 21598 | ERRWRAP2(_self_->setImages(image1, image2));
| 21647 | Py_RETURN_NONE; |  | 21599 | Py_RETURN_NONE;
| 21648 | } |  | 21600 | }
| 21649 |  |  | 21601 |
| 21650 |  |  | 21602 |
| 21651 | pyPopulateArgumentConversionErrors(); |  | 21603 | pyPopulateArgumentConversionErrors();
| 21652 | } |  | 21604 | }
| 21653 |  |  | 21605 |
| 21654 |  |  | 21606 |
| 21655 | { |  | 21607 | {
| 21656 | PyObject* pyobj_image1 = NULL; |  | 21608 | PyObject* pyobj_image1 = NULL;
| 21657 | UMat image1; |  | 21609 | UMat image1;
| 21658 | PyObject* pyobj_image2 = NULL; |  | 21610 | PyObject* pyobj_image2 = NULL;
| 21659 | UMat image2; |  | 21611 | UMat image2;
| 21660 |  |  | 21612 |
| 21661 | const char* keywords[] = { "image1", "image2", NULL }; |  | 21613 | const char* keywords[] = { "image1", "image2", NULL };
| 21662 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeContextDistanceExtractor.setImages", (char**)keywords, &pyobj_image1, &pyobj_image2) && |  | 21614 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeContextDistanceExtractor.setImages", (char**)keywords, &pyobj_image1, &pyobj_image2) &&
| 21663 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 0)) && |  | 21615 | pyopencv_to_safe(pyobj_image1, image1, ArgInfo("image1", 0)) &&
| 21664 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 0)) ) |  | 21616 | pyopencv_to_safe(pyobj_image2, image2, ArgInfo("image2", 0)) )
| 21665 | { |  | 21617 | {
| 21666 | ERRWRAP2(_self_->setImages(image1, image2)); |  | 21618 | ERRWRAP2(_self_->setImages(image1, image2));
| 21667 | Py_RETURN_NONE; |  | 21619 | Py_RETURN_NONE;
| 21668 | } |  | 21620 | }
| 21669 |  |  | 21621 |
| 21670 |  |  | 21622 |
| 21671 | pyPopulateArgumentConversionErrors(); |  | 21623 | pyPopulateArgumentConversionErrors();
| 21672 | } |  | 21624 | }
| 21673 | pyRaiseCVOverloadException("setImages"); |  | 21625 | pyRaiseCVOverloadException("setImages");
| 21674 |  |  | 21626 |
| 21675 | return NULL; |  | 21627 | return NULL;
| 21676 | } |  | 21628 | }
| 21677 |  |  | 21629 |
| 21678 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setInnerRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21630 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setInnerRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 21679 | { |  | 21631 | {
| 21680 | using namespace cv; |  | 21632 | using namespace cv;
| 21681 |  |  | 21633 |
| 21682 |  |  | 21634 |
| 21683 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21635 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21684 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21636 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21685 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21637 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21686 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21638 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21687 | PyObject* pyobj_innerRadius = NULL; |  | 21639 | PyObject* pyobj_innerRadius = NULL;
| 21688 | float innerRadius=0.f; |  | 21640 | float innerRadius=0.f;
| 21689 |  |  | 21641 |
| 21690 | const char* keywords[] = { "innerRadius", NULL }; |  | 21642 | const char* keywords[] = { "innerRadius", NULL };
| 21691 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setInnerRadius", (char**)keywords, &pyobj_innerRadius) && |  | 21643 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setInnerRadius", (char**)keywords, &pyobj_innerRadius) &&
| 21692 | pyopencv_to_safe(pyobj_innerRadius, innerRadius, ArgInfo("innerRadius", 0)) ) |  | 21644 | pyopencv_to_safe(pyobj_innerRadius, innerRadius, ArgInfo("innerRadius", 0)) )
| 21693 | { |  | 21645 | {
| 21694 | ERRWRAP2(_self_->setInnerRadius(innerRadius)); |  | 21646 | ERRWRAP2(_self_->setInnerRadius(innerRadius));
| 21695 | Py_RETURN_NONE; |  | 21647 | Py_RETURN_NONE;
| 21696 | } |  | 21648 | }
| 21697 |  |  | 21649 |
| 21698 | return NULL; |  | 21650 | return NULL;
| 21699 | } |  | 21651 | }
| 21700 |  |  | 21652 |
| 21701 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21653 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 21702 | { |  | 21654 | {
| 21703 | using namespace cv; |  | 21655 | using namespace cv;
| 21704 |  |  | 21656 |
| 21705 |  |  | 21657 |
| 21706 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21658 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21707 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21659 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21708 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21660 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21709 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21661 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21710 | PyObject* pyobj_iterations = NULL; |  | 21662 | PyObject* pyobj_iterations = NULL;
| 21711 | int iterations=0; |  | 21663 | int iterations=0;
| 21712 |  |  | 21664 |
| 21713 | const char* keywords[] = { "iterations", NULL }; |  | 21665 | const char* keywords[] = { "iterations", NULL };
| 21714 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setIterations", (char**)keywords, &pyobj_iterations) && |  | 21666 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setIterations", (char**)keywords, &pyobj_iterations) &&
| 21715 | pyopencv_to_safe(pyobj_iterations, iterations, ArgInfo("iterations", 0)) ) |  | 21667 | pyopencv_to_safe(pyobj_iterations, iterations, ArgInfo("iterations", 0)) )
| 21716 | { |  | 21668 | {
| 21717 | ERRWRAP2(_self_->setIterations(iterations)); |  | 21669 | ERRWRAP2(_self_->setIterations(iterations));
| 21718 | Py_RETURN_NONE; |  | 21670 | Py_RETURN_NONE;
| 21719 | } |  | 21671 | }
| 21720 |  |  | 21672 |
| 21721 | return NULL; |  | 21673 | return NULL;
| 21722 | } |  | 21674 | }
| 21723 |  |  | 21675 |
| 21724 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setOuterRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21676 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setOuterRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 21725 | { |  | 21677 | {
| 21726 | using namespace cv; |  | 21678 | using namespace cv;
| 21727 |  |  | 21679 |
| 21728 |  |  | 21680 |
| 21729 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21681 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21730 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21682 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21731 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21683 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21732 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21684 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21733 | PyObject* pyobj_outerRadius = NULL; |  | 21685 | PyObject* pyobj_outerRadius = NULL;
| 21734 | float outerRadius=0.f; |  | 21686 | float outerRadius=0.f;
| 21735 |  |  | 21687 |
| 21736 | const char* keywords[] = { "outerRadius", NULL }; |  | 21688 | const char* keywords[] = { "outerRadius", NULL };
| 21737 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setOuterRadius", (char**)keywords, &pyobj_outerRadius) && |  | 21689 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setOuterRadius", (char**)keywords, &pyobj_outerRadius) &&
| 21738 | pyopencv_to_safe(pyobj_outerRadius, outerRadius, ArgInfo("outerRadius", 0)) ) |  | 21690 | pyopencv_to_safe(pyobj_outerRadius, outerRadius, ArgInfo("outerRadius", 0)) )
| 21739 | { |  | 21691 | {
| 21740 | ERRWRAP2(_self_->setOuterRadius(outerRadius)); |  | 21692 | ERRWRAP2(_self_->setOuterRadius(outerRadius));
| 21741 | Py_RETURN_NONE; |  | 21693 | Py_RETURN_NONE;
| 21742 | } |  | 21694 | }
| 21743 |  |  | 21695 |
| 21744 | return NULL; |  | 21696 | return NULL;
| 21745 | } |  | 21697 | }
| 21746 |  |  | 21698 |
| 21747 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setRadialBins(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21699 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setRadialBins(PyObject* self, PyObject* py_args, PyObject* kw)
| 21748 | { |  | 21700 | {
| 21749 | using namespace cv; |  | 21701 | using namespace cv;
| 21750 |  |  | 21702 |
| 21751 |  |  | 21703 |
| 21752 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21704 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21753 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21705 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21754 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21706 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21755 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21707 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21756 | PyObject* pyobj_nRadialBins = NULL; |  | 21708 | PyObject* pyobj_nRadialBins = NULL;
| 21757 | int nRadialBins=0; |  | 21709 | int nRadialBins=0;
| 21758 |  |  | 21710 |
| 21759 | const char* keywords[] = { "nRadialBins", NULL }; |  | 21711 | const char* keywords[] = { "nRadialBins", NULL };
| 21760 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setRadialBins", (char**)keywords, &pyobj_nRadialBins) && |  | 21712 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setRadialBins", (char**)keywords, &pyobj_nRadialBins) &&
| 21761 | pyopencv_to_safe(pyobj_nRadialBins, nRadialBins, ArgInfo("nRadialBins", 0)) ) |  | 21713 | pyopencv_to_safe(pyobj_nRadialBins, nRadialBins, ArgInfo("nRadialBins", 0)) )
| 21762 | { |  | 21714 | {
| 21763 | ERRWRAP2(_self_->setRadialBins(nRadialBins)); |  | 21715 | ERRWRAP2(_self_->setRadialBins(nRadialBins));
| 21764 | Py_RETURN_NONE; |  | 21716 | Py_RETURN_NONE;
| 21765 | } |  | 21717 | }
| 21766 |  |  | 21718 |
| 21767 | return NULL; |  | 21719 | return NULL;
| 21768 | } |  | 21720 | }
| 21769 |  |  | 21721 |
| 21770 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setRotationInvariant(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21722 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setRotationInvariant(PyObject* self, PyObject* py_args, PyObject* kw)
| 21771 | { |  | 21723 | {
| 21772 | using namespace cv; |  | 21724 | using namespace cv;
| 21773 |  |  | 21725 |
| 21774 |  |  | 21726 |
| 21775 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21727 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21776 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21728 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21777 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21729 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21778 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21730 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21779 | PyObject* pyobj_rotationInvariant = NULL; |  | 21731 | PyObject* pyobj_rotationInvariant = NULL;
| 21780 | bool rotationInvariant=0; |  | 21732 | bool rotationInvariant=0;
| 21781 |  |  | 21733 |
| 21782 | const char* keywords[] = { "rotationInvariant", NULL }; |  | 21734 | const char* keywords[] = { "rotationInvariant", NULL };
| 21783 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setRotationInvariant", (char**)keywords, &pyobj_rotationInvariant) && |  | 21735 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setRotationInvariant", (char**)keywords, &pyobj_rotationInvariant) &&
| 21784 | pyopencv_to_safe(pyobj_rotationInvariant, rotationInvariant, ArgInfo("rotationInvariant", 0)) ) |  | 21736 | pyopencv_to_safe(pyobj_rotationInvariant, rotationInvariant, ArgInfo("rotationInvariant", 0)) )
| 21785 | { |  | 21737 | {
| 21786 | ERRWRAP2(_self_->setRotationInvariant(rotationInvariant)); |  | 21738 | ERRWRAP2(_self_->setRotationInvariant(rotationInvariant));
| 21787 | Py_RETURN_NONE; |  | 21739 | Py_RETURN_NONE;
| 21788 | } |  | 21740 | }
| 21789 |  |  | 21741 |
| 21790 | return NULL; |  | 21742 | return NULL;
| 21791 | } |  | 21743 | }
| 21792 |  |  | 21744 |
| 21793 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setShapeContextWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21745 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setShapeContextWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 21794 | { |  | 21746 | {
| 21795 | using namespace cv; |  | 21747 | using namespace cv;
| 21796 |  |  | 21748 |
| 21797 |  |  | 21749 |
| 21798 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21750 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21799 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21751 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21800 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21752 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21801 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21753 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21802 | PyObject* pyobj_shapeContextWeight = NULL; |  | 21754 | PyObject* pyobj_shapeContextWeight = NULL;
| 21803 | float shapeContextWeight=0.f; |  | 21755 | float shapeContextWeight=0.f;
| 21804 |  |  | 21756 |
| 21805 | const char* keywords[] = { "shapeContextWeight", NULL }; |  | 21757 | const char* keywords[] = { "shapeContextWeight", NULL };
| 21806 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setShapeContextWeight", (char**)keywords, &pyobj_shapeContextWeight) && |  | 21758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setShapeContextWeight", (char**)keywords, &pyobj_shapeContextWeight) &&
| 21807 | pyopencv_to_safe(pyobj_shapeContextWeight, shapeContextWeight, ArgInfo("shapeContextWeight", 0)) ) |  | 21759 | pyopencv_to_safe(pyobj_shapeContextWeight, shapeContextWeight, ArgInfo("shapeContextWeight", 0)) )
| 21808 | { |  | 21760 | {
| 21809 | ERRWRAP2(_self_->setShapeContextWeight(shapeContextWeight)); |  | 21761 | ERRWRAP2(_self_->setShapeContextWeight(shapeContextWeight));
| 21810 | Py_RETURN_NONE; |  | 21762 | Py_RETURN_NONE;
| 21811 | } |  | 21763 | }
| 21812 |  |  | 21764 |
| 21813 | return NULL; |  | 21765 | return NULL;
| 21814 | } |  | 21766 | }
| 21815 |  |  | 21767 |
| 21816 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setStdDev(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21768 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setStdDev(PyObject* self, PyObject* py_args, PyObject* kw)
| 21817 | { |  | 21769 | {
| 21818 | using namespace cv; |  | 21770 | using namespace cv;
| 21819 |  |  | 21771 |
| 21820 |  |  | 21772 |
| 21821 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21773 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21822 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21774 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21823 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21775 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21824 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21776 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21825 | PyObject* pyobj_sigma = NULL; |  | 21777 | PyObject* pyobj_sigma = NULL;
| 21826 | float sigma=0.f; |  | 21778 | float sigma=0.f;
| 21827 |  |  | 21779 |
| 21828 | const char* keywords[] = { "sigma", NULL }; |  | 21780 | const char* keywords[] = { "sigma", NULL };
| 21829 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setStdDev", (char**)keywords, &pyobj_sigma) && |  | 21781 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setStdDev", (char**)keywords, &pyobj_sigma) &&
| 21830 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) ) |  | 21782 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) )
| 21831 | { |  | 21783 | {
| 21832 | ERRWRAP2(_self_->setStdDev(sigma)); |  | 21784 | ERRWRAP2(_self_->setStdDev(sigma));
| 21833 | Py_RETURN_NONE; |  | 21785 | Py_RETURN_NONE;
| 21834 | } |  | 21786 | }
| 21835 |  |  | 21787 |
| 21836 | return NULL; |  | 21788 | return NULL;
| 21837 | } |  | 21789 | }
| 21838 |  |  | 21790 |
| 21839 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setTransformAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21791 | static PyObject* pyopencv_cv_ShapeContextDistanceExtractor_setTransformAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw)
| 21840 | { |  | 21792 | {
| 21841 | using namespace cv; |  | 21793 | using namespace cv;
| 21842 |  |  | 21794 |
| 21843 |  |  | 21795 |
| 21844 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0; |  | 21796 | Ptr<cv::ShapeContextDistanceExtractor> * self1 = 0;
| 21845 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1)) |  | 21797 | if (!pyopencv_ShapeContextDistanceExtractor_getp(self, self1))
| 21846 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)"); |  | 21798 | return failmsgp("Incorrect type of self (must be 'ShapeContextDistanceExtractor' or its derivative)");
| 21847 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1); |  | 21799 | Ptr<cv::ShapeContextDistanceExtractor> _self_ = *(self1);
| 21848 | PyObject* pyobj_transformer = NULL; |  | 21800 | PyObject* pyobj_transformer = NULL;
| 21849 | Ptr<ShapeTransformer> transformer; |  | 21801 | Ptr<ShapeTransformer> transformer;
| 21850 |  |  | 21802 |
| 21851 | const char* keywords[] = { "transformer", NULL }; |  | 21803 | const char* keywords[] = { "transformer", NULL };
| 21852 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setTransformAlgorithm", (char**)keywords, &pyobj_transformer) && |  | 21804 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ShapeContextDistanceExtractor.setTransformAlgorithm", (char**)keywords, &pyobj_transformer) &&
| 21853 | pyopencv_to_safe(pyobj_transformer, transformer, ArgInfo("transformer", 0)) ) |  | 21805 | pyopencv_to_safe(pyobj_transformer, transformer, ArgInfo("transformer", 0)) )
| 21854 | { |  | 21806 | {
| 21855 | ERRWRAP2(_self_->setTransformAlgorithm(transformer)); |  | 21807 | ERRWRAP2(_self_->setTransformAlgorithm(transformer));
| 21856 | Py_RETURN_NONE; |  | 21808 | Py_RETURN_NONE;
| 21857 | } |  | 21809 | }
| 21858 |  |  | 21810 |
| 21859 | return NULL; |  | 21811 | return NULL;
| 21860 | } |  | 21812 | }
| 21861 |  |  | 21813 |
| 21862 |  |  | 21814 |
| 21863 |  |  | 21815 |
| 21864 | // Tables (ShapeContextDistanceExtractor) |  | 21816 | // Tables (ShapeContextDistanceExtractor)
| 21865 |  |  | 21817 |
| 21866 | static PyGetSetDef pyopencv_ShapeContextDistanceExtractor_getseters[] = |  | 21818 | static PyGetSetDef pyopencv_ShapeContextDistanceExtractor_getseters[] =
| 21867 | { |  | 21819 | {
| 21868 | {NULL} /* Sentinel */ |  | 21820 | {NULL} /* Sentinel */
| 21869 | }; |  | 21821 | };
| 21870 |  |  | 21822 |
| 21871 | static PyMethodDef pyopencv_ShapeContextDistanceExtractor_methods[] = |  | 21823 | static PyMethodDef pyopencv_ShapeContextDistanceExtractor_methods[] =
| 21872 | { |  | 21824 | {
| 21873 | {"getAngularBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getAngularBins, 0), "getAngularBins() -> retval\n."}, |  | 21825 | {"getAngularBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getAngularBins, 0), "getAngularBins() -> retval\n."},
| 21874 | {"getBendingEnergyWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getBendingEnergyWeight, 0), "getBendingEnergyWeight() -> retval\n."}, |  | 21826 | {"getBendingEnergyWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getBendingEnergyWeight, 0), "getBendingEnergyWeight() -> retval\n."},
| 21875 | {"getCostExtractor", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getCostExtractor, 0), "getCostExtractor() -> retval\n."}, |  | 21827 | {"getCostExtractor", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getCostExtractor, 0), "getCostExtractor() -> retval\n."},
| 21876 | {"getImageAppearanceWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getImageAppearanceWeight, 0), "getImageAppearanceWeight() -> retval\n."}, |  | 21828 | {"getImageAppearanceWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getImageAppearanceWeight, 0), "getImageAppearanceWeight() -> retval\n."},
| 21877 | {"getImages", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getImages, 0), "getImages([, image1[, image2]]) -> image1, image2\n."}, |  | 21829 | {"getImages", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getImages, 0), "getImages([, image1[, image2]]) -> image1, image2\n."},
| 21878 | {"getInnerRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getInnerRadius, 0), "getInnerRadius() -> retval\n."}, |  | 21830 | {"getInnerRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getInnerRadius, 0), "getInnerRadius() -> retval\n."},
| 21879 | {"getIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getIterations, 0), "getIterations() -> retval\n."}, |  | 21831 | {"getIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getIterations, 0), "getIterations() -> retval\n."},
| 21880 | {"getOuterRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getOuterRadius, 0), "getOuterRadius() -> retval\n."}, |  | 21832 | {"getOuterRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getOuterRadius, 0), "getOuterRadius() -> retval\n."},
| 21881 | {"getRadialBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getRadialBins, 0), "getRadialBins() -> retval\n."}, |  | 21833 | {"getRadialBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getRadialBins, 0), "getRadialBins() -> retval\n."},
| 21882 | {"getRotationInvariant", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getRotationInvariant, 0), "getRotationInvariant() -> retval\n."}, |  | 21834 | {"getRotationInvariant", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getRotationInvariant, 0), "getRotationInvariant() -> retval\n."},
| 21883 | {"getShapeContextWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getShapeContextWeight, 0), "getShapeContextWeight() -> retval\n."}, |  | 21835 | {"getShapeContextWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getShapeContextWeight, 0), "getShapeContextWeight() -> retval\n."},
| 21884 | {"getStdDev", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getStdDev, 0), "getStdDev() -> retval\n."}, |  | 21836 | {"getStdDev", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getStdDev, 0), "getStdDev() -> retval\n."},
| 21885 | {"getTransformAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getTransformAlgorithm, 0), "getTransformAlgorithm() -> retval\n."}, |  | 21837 | {"getTransformAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_getTransformAlgorithm, 0), "getTransformAlgorithm() -> retval\n."},
| 21886 | {"setAngularBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setAngularBins, 0), "setAngularBins(nAngularBins) -> None\n. @brief Establish the number of angular bins for the Shape Context Descriptor used in the shape matching\n. pipeline.\n. \n. @param nAngularBins The number of angular bins in the shape context descriptor."}, |  | 21838 | {"setAngularBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setAngularBins, 0), "setAngularBins(nAngularBins) -> None\n. @brief Establish the number of angular bins for the Shape Context Descriptor used in the shape matching\n. pipeline.\n. \n. @param nAngularBins The number of angular bins in the shape context descriptor."},
| 21887 | {"setBendingEnergyWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setBendingEnergyWeight, 0), "setBendingEnergyWeight(bendingEnergyWeight) -> None\n. @brief Set the weight of the Bending Energy in the final value of the shape distance. The bending energy\n. definition depends on what transformation is being used to align the shapes. The final value of the\n. shape distance is a user-defined linear combination of the shape context distance, an image\n. appearance distance, and a bending energy.\n. \n. @param bendingEnergyWeight The weight of the Bending Energy in the final distance value."}, |  | 21839 | {"setBendingEnergyWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setBendingEnergyWeight, 0), "setBendingEnergyWeight(bendingEnergyWeight) -> None\n. @brief Set the weight of the Bending Energy in the final value of the shape distance. The bending energy\n. definition depends on what transformation is being used to align the shapes. The final value of the\n. shape distance is a user-defined linear combination of the shape context distance, an image\n. appearance distance, and a bending energy.\n. \n. @param bendingEnergyWeight The weight of the Bending Energy in the final distance value."},
| 21888 | {"setCostExtractor", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setCostExtractor, 0), "setCostExtractor(comparer) -> None\n. @brief Set the algorithm used for building the shape context descriptor cost matrix.\n. \n. @param comparer Smart pointer to a HistogramCostExtractor, an algorithm that defines the cost\n. matrix between descriptors."}, |  | 21840 | {"setCostExtractor", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setCostExtractor, 0), "setCostExtractor(comparer) -> None\n. @brief Set the algorithm used for building the shape context descriptor cost matrix.\n. \n. @param comparer Smart pointer to a HistogramCostExtractor, an algorithm that defines the cost\n. matrix between descriptors."},
| 21889 | {"setImageAppearanceWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setImageAppearanceWeight, 0), "setImageAppearanceWeight(imageAppearanceWeight) -> None\n. @brief Set the weight of the Image Appearance cost in the final value of the shape distance. The image\n. appearance cost is defined as the sum of squared brightness differences in Gaussian windows around\n. corresponding image points. The final value of the shape distance is a user-defined linear\n. combination of the shape context distance, an image appearance distance, and a bending energy. If\n. this value is set to a number different from 0, is mandatory to set the images that correspond to\n. each shape.\n. \n. @param imageAppearanceWeight The weight of the appearance cost in the final distance value."}, |  | 21841 | {"setImageAppearanceWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setImageAppearanceWeight, 0), "setImageAppearanceWeight(imageAppearanceWeight) -> None\n. @brief Set the weight of the Image Appearance cost in the final value of the shape distance. The image\n. appearance cost is defined as the sum of squared brightness differences in Gaussian windows around\n. corresponding image points. The final value of the shape distance is a user-defined linear\n. combination of the shape context distance, an image appearance distance, and a bending energy. If\n. this value is set to a number different from 0, is mandatory to set the images that correspond to\n. each shape.\n. \n. @param imageAppearanceWeight The weight of the appearance cost in the final distance value."},
| 21890 | {"setImages", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setImages, 0), "setImages(image1, image2) -> None\n. @brief Set the images that correspond to each shape. This images are used in the calculation of the Image\n. Appearance cost.\n. \n. @param image1 Image corresponding to the shape defined by contours1.\n. @param image2 Image corresponding to the shape defined by contours2."}, |  | 21842 | {"setImages", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setImages, 0), "setImages(image1, image2) -> None\n. @brief Set the images that correspond to each shape. This images are used in the calculation of the Image\n. Appearance cost.\n. \n. @param image1 Image corresponding to the shape defined by contours1.\n. @param image2 Image corresponding to the shape defined by contours2."},
| 21891 | {"setInnerRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setInnerRadius, 0), "setInnerRadius(innerRadius) -> None\n. @brief Set the inner radius of the shape context descriptor.\n. \n. @param innerRadius The value of the inner radius."}, |  | 21843 | {"setInnerRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setInnerRadius, 0), "setInnerRadius(innerRadius) -> None\n. @brief Set the inner radius of the shape context descriptor.\n. \n. @param innerRadius The value of the inner radius."},
| 21892 | {"setIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setIterations, 0), "setIterations(iterations) -> None\n."}, |  | 21844 | {"setIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setIterations, 0), "setIterations(iterations) -> None\n."},
| 21893 | {"setOuterRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setOuterRadius, 0), "setOuterRadius(outerRadius) -> None\n. @brief Set the outer radius of the shape context descriptor.\n. \n. @param outerRadius The value of the outer radius."}, |  | 21845 | {"setOuterRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setOuterRadius, 0), "setOuterRadius(outerRadius) -> None\n. @brief Set the outer radius of the shape context descriptor.\n. \n. @param outerRadius The value of the outer radius."},
| 21894 | {"setRadialBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setRadialBins, 0), "setRadialBins(nRadialBins) -> None\n. @brief Establish the number of radial bins for the Shape Context Descriptor used in the shape matching\n. pipeline.\n. \n. @param nRadialBins The number of radial bins in the shape context descriptor."}, |  | 21846 | {"setRadialBins", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setRadialBins, 0), "setRadialBins(nRadialBins) -> None\n. @brief Establish the number of radial bins for the Shape Context Descriptor used in the shape matching\n. pipeline.\n. \n. @param nRadialBins The number of radial bins in the shape context descriptor."},
| 21895 | {"setRotationInvariant", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setRotationInvariant, 0), "setRotationInvariant(rotationInvariant) -> None\n."}, |  | 21847 | {"setRotationInvariant", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setRotationInvariant, 0), "setRotationInvariant(rotationInvariant) -> None\n."},
| 21896 | {"setShapeContextWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setShapeContextWeight, 0), "setShapeContextWeight(shapeContextWeight) -> None\n. @brief Set the weight of the shape context distance in the final value of the shape distance. The shape\n. context distance between two shapes is defined as the symmetric sum of shape context matching costs\n. over best matching points. The final value of the shape distance is a user-defined linear\n. combination of the shape context distance, an image appearance distance, and a bending energy.\n. \n. @param shapeContextWeight The weight of the shape context distance in the final distance value."}, |  | 21848 | {"setShapeContextWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setShapeContextWeight, 0), "setShapeContextWeight(shapeContextWeight) -> None\n. @brief Set the weight of the shape context distance in the final value of the shape distance. The shape\n. context distance between two shapes is defined as the symmetric sum of shape context matching costs\n. over best matching points. The final value of the shape distance is a user-defined linear\n. combination of the shape context distance, an image appearance distance, and a bending energy.\n. \n. @param shapeContextWeight The weight of the shape context distance in the final distance value."},
| 21897 | {"setStdDev", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setStdDev, 0), "setStdDev(sigma) -> None\n. @brief Set the value of the standard deviation for the Gaussian window for the image appearance cost.\n. \n. @param sigma Standard Deviation."}, |  | 21849 | {"setStdDev", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setStdDev, 0), "setStdDev(sigma) -> None\n. @brief Set the value of the standard deviation for the Gaussian window for the image appearance cost.\n. \n. @param sigma Standard Deviation."},
| 21898 | {"setTransformAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setTransformAlgorithm, 0), "setTransformAlgorithm(transformer) -> None\n. @brief Set the algorithm used for aligning the shapes.\n. \n. @param transformer Smart pointer to a ShapeTransformer, an algorithm that defines the aligning\n. transformation."}, |  | 21850 | {"setTransformAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeContextDistanceExtractor_setTransformAlgorithm, 0), "setTransformAlgorithm(transformer) -> None\n. @brief Set the algorithm used for aligning the shapes.\n. \n. @param transformer Smart pointer to a ShapeTransformer, an algorithm that defines the aligning\n. transformation."},
| 21899 |  |  | 21851 |
| 21900 | {NULL, NULL} |  | 21852 | {NULL, NULL}
| 21901 | }; |  | 21853 | };
| 21902 |  |  | 21854 |
| 21903 | // Converter (ShapeContextDistanceExtractor) |  | 21855 | // Converter (ShapeContextDistanceExtractor)
| 21904 |  |  | 21856 |
| 21905 | template<> |  | 21857 | template<>
| 21906 | struct PyOpenCV_Converter< Ptr<cv::ShapeContextDistanceExtractor> > |  | 21858 | struct PyOpenCV_Converter< Ptr<cv::ShapeContextDistanceExtractor> >
| 21907 | { |  | 21859 | {
| 21908 | static PyObject* from(const Ptr<cv::ShapeContextDistanceExtractor>& r) |  | 21860 | static PyObject* from(const Ptr<cv::ShapeContextDistanceExtractor>& r)
| 21909 | { |  | 21861 | {
| 21910 | return pyopencv_ShapeContextDistanceExtractor_Instance(r); |  | 21862 | return pyopencv_ShapeContextDistanceExtractor_Instance(r);
| 21911 | } |  | 21863 | }
| 21912 | static bool to(PyObject* src, Ptr<cv::ShapeContextDistanceExtractor>& dst, const ArgInfo& info) |  | 21864 | static bool to(PyObject* src, Ptr<cv::ShapeContextDistanceExtractor>& dst, const ArgInfo& info)
| 21913 | { |  | 21865 | {
| 21914 | if(!src || src == Py_None) |  | 21866 | if(!src || src == Py_None)
| 21915 | return true; |  | 21867 | return true;
| 21916 | Ptr<cv::ShapeContextDistanceExtractor> * dst_; |  | 21868 | Ptr<cv::ShapeContextDistanceExtractor> * dst_;
| 21917 | if (pyopencv_ShapeContextDistanceExtractor_getp(src, dst_)) |  | 21869 | if (pyopencv_ShapeContextDistanceExtractor_getp(src, dst_))
| 21918 | { |  | 21870 | {
| 21919 | dst = *dst_; |  | 21871 | dst = *dst_;
| 21920 | return true; |  | 21872 | return true;
| 21921 | } |  | 21873 | }
| 21922 |  |  | 21874 |
| 21923 | failmsg("Expected Ptr<cv::ShapeContextDistanceExtractor> for argument '%s'", info.name); |  | 21875 | failmsg("Expected Ptr<cv::ShapeContextDistanceExtractor> for argument '%s'", info.name);
| 21924 | return false; |  | 21876 | return false;
| 21925 | } |  | 21877 | }
| 21926 | }; |  | 21878 | };
| 21927 |  |  | 21879 |
| 21928 | //================================================================================ |  | 21880 | //================================================================================
| 21929 | // ShapeDistanceExtractor (Generic) |  | 21881 | // ShapeDistanceExtractor (Generic)
| 21930 | //================================================================================ |  | 21882 | //================================================================================
| 21931 |  |  | 21883 |
| 21932 | // GetSet (ShapeDistanceExtractor) |  | 21884 | // GetSet (ShapeDistanceExtractor)
| 21933 |  |  | 21885 |
| 21934 |  |  | 21886 |
| 21935 |  |  | 21887 |
| 21936 | // Methods (ShapeDistanceExtractor) |  | 21888 | // Methods (ShapeDistanceExtractor)
| 21937 |  |  | 21889 |
| 21938 | static PyObject* pyopencv_cv_ShapeDistanceExtractor_computeDistance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21890 | static PyObject* pyopencv_cv_ShapeDistanceExtractor_computeDistance(PyObject* self, PyObject* py_args, PyObject* kw)
| 21939 | { |  | 21891 | {
| 21940 | using namespace cv; |  | 21892 | using namespace cv;
| 21941 |  |  | 21893 |
| 21942 |  |  | 21894 |
| 21943 | Ptr<cv::ShapeDistanceExtractor> * self1 = 0; |  | 21895 | Ptr<cv::ShapeDistanceExtractor> * self1 = 0;
| 21944 | if (!pyopencv_ShapeDistanceExtractor_getp(self, self1)) |  | 21896 | if (!pyopencv_ShapeDistanceExtractor_getp(self, self1))
| 21945 | return failmsgp("Incorrect type of self (must be 'ShapeDistanceExtractor' or its derivative)"); |  | 21897 | return failmsgp("Incorrect type of self (must be 'ShapeDistanceExtractor' or its derivative)");
| 21946 | Ptr<cv::ShapeDistanceExtractor> _self_ = *(self1); |  | 21898 | Ptr<cv::ShapeDistanceExtractor> _self_ = *(self1);
| 21947 | pyPrepareArgumentConversionErrorsStorage(2); |  | 21899 | pyPrepareArgumentConversionErrorsStorage(2);
| 21948 |  |  | 21900 |
| 21949 | { |  | 21901 | {
| 21950 | PyObject* pyobj_contour1 = NULL; |  | 21902 | PyObject* pyobj_contour1 = NULL;
| 21951 | Mat contour1; |  | 21903 | Mat contour1;
| 21952 | PyObject* pyobj_contour2 = NULL; |  | 21904 | PyObject* pyobj_contour2 = NULL;
| 21953 | Mat contour2; |  | 21905 | Mat contour2;
| 21954 | float retval; |  | 21906 | float retval;
| 21955 |  |  | 21907 |
| 21956 | const char* keywords[] = { "contour1", "contour2", NULL }; |  | 21908 | const char* keywords[] = { "contour1", "contour2", NULL };
| 21957 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeDistanceExtractor.computeDistance", (char**)keywords, &pyobj_contour1, &pyobj_contour2) && |  | 21909 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeDistanceExtractor.computeDistance", (char**)keywords, &pyobj_contour1, &pyobj_contour2) &&
| 21958 | pyopencv_to_safe(pyobj_contour1, contour1, ArgInfo("contour1", 0)) && |  | 21910 | pyopencv_to_safe(pyobj_contour1, contour1, ArgInfo("contour1", 0)) &&
| 21959 | pyopencv_to_safe(pyobj_contour2, contour2, ArgInfo("contour2", 0)) ) |  | 21911 | pyopencv_to_safe(pyobj_contour2, contour2, ArgInfo("contour2", 0)) )
| 21960 | { |  | 21912 | {
| 21961 | ERRWRAP2(retval = _self_->computeDistance(contour1, contour2)); |  | 21913 | ERRWRAP2(retval = _self_->computeDistance(contour1, contour2));
| 21962 | return pyopencv_from(retval); |  | 21914 | return pyopencv_from(retval);
| 21963 | } |  | 21915 | }
| 21964 |  |  | 21916 |
| 21965 |  |  | 21917 |
| 21966 | pyPopulateArgumentConversionErrors(); |  | 21918 | pyPopulateArgumentConversionErrors();
| 21967 | } |  | 21919 | }
| 21968 |  |  | 21920 |
| 21969 |  |  | 21921 |
| 21970 | { |  | 21922 | {
| 21971 | PyObject* pyobj_contour1 = NULL; |  | 21923 | PyObject* pyobj_contour1 = NULL;
| 21972 | UMat contour1; |  | 21924 | UMat contour1;
| 21973 | PyObject* pyobj_contour2 = NULL; |  | 21925 | PyObject* pyobj_contour2 = NULL;
| 21974 | UMat contour2; |  | 21926 | UMat contour2;
| 21975 | float retval; |  | 21927 | float retval;
| 21976 |  |  | 21928 |
| 21977 | const char* keywords[] = { "contour1", "contour2", NULL }; |  | 21929 | const char* keywords[] = { "contour1", "contour2", NULL };
| 21978 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeDistanceExtractor.computeDistance", (char**)keywords, &pyobj_contour1, &pyobj_contour2) && |  | 21930 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ShapeDistanceExtractor.computeDistance", (char**)keywords, &pyobj_contour1, &pyobj_contour2) &&
| 21979 | pyopencv_to_safe(pyobj_contour1, contour1, ArgInfo("contour1", 0)) && |  | 21931 | pyopencv_to_safe(pyobj_contour1, contour1, ArgInfo("contour1", 0)) &&
| 21980 | pyopencv_to_safe(pyobj_contour2, contour2, ArgInfo("contour2", 0)) ) |  | 21932 | pyopencv_to_safe(pyobj_contour2, contour2, ArgInfo("contour2", 0)) )
| 21981 | { |  | 21933 | {
| 21982 | ERRWRAP2(retval = _self_->computeDistance(contour1, contour2)); |  | 21934 | ERRWRAP2(retval = _self_->computeDistance(contour1, contour2));
| 21983 | return pyopencv_from(retval); |  | 21935 | return pyopencv_from(retval);
| 21984 | } |  | 21936 | }
| 21985 |  |  | 21937 |
| 21986 |  |  | 21938 |
| 21987 | pyPopulateArgumentConversionErrors(); |  | 21939 | pyPopulateArgumentConversionErrors();
| 21988 | } |  | 21940 | }
| 21989 | pyRaiseCVOverloadException("computeDistance"); |  | 21941 | pyRaiseCVOverloadException("computeDistance");
| 21990 |  |  | 21942 |
| 21991 | return NULL; |  | 21943 | return NULL;
| 21992 | } |  | 21944 | }
| 21993 |  |  | 21945 |
| 21994 |  |  | 21946 |
| 21995 |  |  | 21947 |
| 21996 | // Tables (ShapeDistanceExtractor) |  | 21948 | // Tables (ShapeDistanceExtractor)
| 21997 |  |  | 21949 |
| 21998 | static PyGetSetDef pyopencv_ShapeDistanceExtractor_getseters[] = |  | 21950 | static PyGetSetDef pyopencv_ShapeDistanceExtractor_getseters[] =
| 21999 | { |  | 21951 | {
| 22000 | {NULL} /* Sentinel */ |  | 21952 | {NULL} /* Sentinel */
| 22001 | }; |  | 21953 | };
| 22002 |  |  | 21954 |
| 22003 | static PyMethodDef pyopencv_ShapeDistanceExtractor_methods[] = |  | 21955 | static PyMethodDef pyopencv_ShapeDistanceExtractor_methods[] =
| 22004 | { |  | 21956 | {
| 22005 | {"computeDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeDistanceExtractor_computeDistance, 0), "computeDistance(contour1, contour2) -> retval\n. @brief Compute the shape distance between two shapes defined by its contours.\n. \n. @param contour1 Contour defining first shape.\n. @param contour2 Contour defining second shape."}, |  | 21957 | {"computeDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeDistanceExtractor_computeDistance, 0), "computeDistance(contour1, contour2) -> retval\n. @brief Compute the shape distance between two shapes defined by its contours.\n. \n. @param contour1 Contour defining first shape.\n. @param contour2 Contour defining second shape."},
| 22006 |  |  | 21958 |
| 22007 | {NULL, NULL} |  | 21959 | {NULL, NULL}
| 22008 | }; |  | 21960 | };
| 22009 |  |  | 21961 |
| 22010 | // Converter (ShapeDistanceExtractor) |  | 21962 | // Converter (ShapeDistanceExtractor)
| 22011 |  |  | 21963 |
| 22012 | template<> |  | 21964 | template<>
| 22013 | struct PyOpenCV_Converter< Ptr<cv::ShapeDistanceExtractor> > |  | 21965 | struct PyOpenCV_Converter< Ptr<cv::ShapeDistanceExtractor> >
| 22014 | { |  | 21966 | {
| 22015 | static PyObject* from(const Ptr<cv::ShapeDistanceExtractor>& r) |  | 21967 | static PyObject* from(const Ptr<cv::ShapeDistanceExtractor>& r)
| 22016 | { |  | 21968 | {
| 22017 | return pyopencv_ShapeDistanceExtractor_Instance(r); |  | 21969 | return pyopencv_ShapeDistanceExtractor_Instance(r);
| 22018 | } |  | 21970 | }
| 22019 | static bool to(PyObject* src, Ptr<cv::ShapeDistanceExtractor>& dst, const ArgInfo& info) |  | 21971 | static bool to(PyObject* src, Ptr<cv::ShapeDistanceExtractor>& dst, const ArgInfo& info)
| 22020 | { |  | 21972 | {
| 22021 | if(!src || src == Py_None) |  | 21973 | if(!src || src == Py_None)
| 22022 | return true; |  | 21974 | return true;
| 22023 | Ptr<cv::ShapeDistanceExtractor> * dst_; |  | 21975 | Ptr<cv::ShapeDistanceExtractor> * dst_;
| 22024 | if (pyopencv_ShapeDistanceExtractor_getp(src, dst_)) |  | 21976 | if (pyopencv_ShapeDistanceExtractor_getp(src, dst_))
| 22025 | { |  | 21977 | {
| 22026 | dst = *dst_; |  | 21978 | dst = *dst_;
| 22027 | return true; |  | 21979 | return true;
| 22028 | } |  | 21980 | }
| 22029 |  |  | 21981 |
| 22030 | failmsg("Expected Ptr<cv::ShapeDistanceExtractor> for argument '%s'", info.name); |  | 21982 | failmsg("Expected Ptr<cv::ShapeDistanceExtractor> for argument '%s'", info.name);
| 22031 | return false; |  | 21983 | return false;
| 22032 | } |  | 21984 | }
| 22033 | }; |  | 21985 | };
| 22034 |  |  | 21986 |
| 22035 | //================================================================================ |  | 21987 | //================================================================================
| 22036 | // ShapeTransformer (Generic) |  | 21988 | // ShapeTransformer (Generic)
| 22037 | //================================================================================ |  | 21989 | //================================================================================
| 22038 |  |  | 21990 |
| 22039 | // GetSet (ShapeTransformer) |  | 21991 | // GetSet (ShapeTransformer)
| 22040 |  |  | 21992 |
| 22041 |  |  | 21993 |
| 22042 |  |  | 21994 |
| 22043 | // Methods (ShapeTransformer) |  | 21995 | // Methods (ShapeTransformer)
| 22044 |  |  | 21996 |
| 22045 | static PyObject* pyopencv_cv_ShapeTransformer_applyTransformation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 21997 | static PyObject* pyopencv_cv_ShapeTransformer_applyTransformation(PyObject* self, PyObject* py_args, PyObject* kw)
| 22046 | { |  | 21998 | {
| 22047 | using namespace cv; |  | 21999 | using namespace cv;
| 22048 |  |  | 22000 |
| 22049 |  |  | 22001 |
| 22050 | Ptr<cv::ShapeTransformer> * self1 = 0; |  | 22002 | Ptr<cv::ShapeTransformer> * self1 = 0;
| 22051 | if (!pyopencv_ShapeTransformer_getp(self, self1)) |  | 22003 | if (!pyopencv_ShapeTransformer_getp(self, self1))
| 22052 | return failmsgp("Incorrect type of self (must be 'ShapeTransformer' or its derivative)"); |  | 22004 | return failmsgp("Incorrect type of self (must be 'ShapeTransformer' or its derivative)");
| 22053 | Ptr<cv::ShapeTransformer> _self_ = *(self1); |  | 22005 | Ptr<cv::ShapeTransformer> _self_ = *(self1);
| 22054 | pyPrepareArgumentConversionErrorsStorage(2); |  | 22006 | pyPrepareArgumentConversionErrorsStorage(2);
| 22055 |  |  | 22007 |
| 22056 | { |  | 22008 | {
| 22057 | PyObject* pyobj_input = NULL; |  | 22009 | PyObject* pyobj_input = NULL;
| 22058 | Mat input; |  | 22010 | Mat input;
| 22059 | PyObject* pyobj_output = NULL; |  | 22011 | PyObject* pyobj_output = NULL;
| 22060 | Mat output; |  | 22012 | Mat output;
| 22061 | float retval; |  | 22013 | float retval;
| 22062 |  |  | 22014 |
| 22063 | const char* keywords[] = { "input", "output", NULL }; |  | 22015 | const char* keywords[] = { "input", "output", NULL };
| 22064 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ShapeTransformer.applyTransformation", (char**)keywords, &pyobj_input, &pyobj_output) && |  | 22016 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ShapeTransformer.applyTransformation", (char**)keywords, &pyobj_input, &pyobj_output) &&
| 22065 | pyopencv_to_safe(pyobj_input, input, ArgInfo("input", 0)) && |  | 22017 | pyopencv_to_safe(pyobj_input, input, ArgInfo("input", 0)) &&
| 22066 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) ) |  | 22018 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) )
| 22067 | { |  | 22019 | {
| 22068 | ERRWRAP2(retval = _self_->applyTransformation(input, output)); |  | 22020 | ERRWRAP2(retval = _self_->applyTransformation(input, output));
| 22069 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(output)); |  | 22021 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(output));
| 22070 | } |  | 22022 | }
| 22071 |  |  | 22023 |
| 22072 |  |  | 22024 |
| 22073 | pyPopulateArgumentConversionErrors(); |  | 22025 | pyPopulateArgumentConversionErrors();
| 22074 | } |  | 22026 | }
| 22075 |  |  | 22027 |
| 22076 |  |  | 22028 |
| 22077 | { |  | 22029 | {
| 22078 | PyObject* pyobj_input = NULL; |  | 22030 | PyObject* pyobj_input = NULL;
| 22079 | UMat input; |  | 22031 | UMat input;
| 22080 | PyObject* pyobj_output = NULL; |  | 22032 | PyObject* pyobj_output = NULL;
| 22081 | UMat output; |  | 22033 | UMat output;
| 22082 | float retval; |  | 22034 | float retval;
| 22083 |  |  | 22035 |
| 22084 | const char* keywords[] = { "input", "output", NULL }; |  | 22036 | const char* keywords[] = { "input", "output", NULL };
| 22085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ShapeTransformer.applyTransformation", (char**)keywords, &pyobj_input, &pyobj_output) && |  | 22037 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ShapeTransformer.applyTransformation", (char**)keywords, &pyobj_input, &pyobj_output) &&
| 22086 | pyopencv_to_safe(pyobj_input, input, ArgInfo("input", 0)) && |  | 22038 | pyopencv_to_safe(pyobj_input, input, ArgInfo("input", 0)) &&
| 22087 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) ) |  | 22039 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) )
| 22088 | { |  | 22040 | {
| 22089 | ERRWRAP2(retval = _self_->applyTransformation(input, output)); |  | 22041 | ERRWRAP2(retval = _self_->applyTransformation(input, output));
| 22090 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(output)); |  | 22042 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(output));
| 22091 | } |  | 22043 | }
| 22092 |  |  | 22044 |
| 22093 |  |  | 22045 |
| 22094 | pyPopulateArgumentConversionErrors(); |  | 22046 | pyPopulateArgumentConversionErrors();
| 22095 | } |  | 22047 | }
| 22096 | pyRaiseCVOverloadException("applyTransformation"); |  | 22048 | pyRaiseCVOverloadException("applyTransformation");
| 22097 |  |  | 22049 |
| 22098 | return NULL; |  | 22050 | return NULL;
| 22099 | } |  | 22051 | }
| 22100 |  |  | 22052 |
| 22101 | static PyObject* pyopencv_cv_ShapeTransformer_estimateTransformation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22053 | static PyObject* pyopencv_cv_ShapeTransformer_estimateTransformation(PyObject* self, PyObject* py_args, PyObject* kw)
| 22102 | { |  | 22054 | {
| 22103 | using namespace cv; |  | 22055 | using namespace cv;
| 22104 |  |  | 22056 |
| 22105 |  |  | 22057 |
| 22106 | Ptr<cv::ShapeTransformer> * self1 = 0; |  | 22058 | Ptr<cv::ShapeTransformer> * self1 = 0;
| 22107 | if (!pyopencv_ShapeTransformer_getp(self, self1)) |  | 22059 | if (!pyopencv_ShapeTransformer_getp(self, self1))
| 22108 | return failmsgp("Incorrect type of self (must be 'ShapeTransformer' or its derivative)"); |  | 22060 | return failmsgp("Incorrect type of self (must be 'ShapeTransformer' or its derivative)");
| 22109 | Ptr<cv::ShapeTransformer> _self_ = *(self1); |  | 22061 | Ptr<cv::ShapeTransformer> _self_ = *(self1);
| 22110 | pyPrepareArgumentConversionErrorsStorage(2); |  | 22062 | pyPrepareArgumentConversionErrorsStorage(2);
| 22111 |  |  | 22063 |
| 22112 | { |  | 22064 | {
| 22113 | PyObject* pyobj_transformingShape = NULL; |  | 22065 | PyObject* pyobj_transformingShape = NULL;
| 22114 | Mat transformingShape; |  | 22066 | Mat transformingShape;
| 22115 | PyObject* pyobj_targetShape = NULL; |  | 22067 | PyObject* pyobj_targetShape = NULL;
| 22116 | Mat targetShape; |  | 22068 | Mat targetShape;
| 22117 | PyObject* pyobj_matches = NULL; |  | 22069 | PyObject* pyobj_matches = NULL;
| 22118 | vector_DMatch matches; |  | 22070 | vector_DMatch matches;
| 22119 |  |  | 22071 |
| 22120 | const char* keywords[] = { "transformingShape", "targetShape", "matches", NULL }; |  | 22072 | const char* keywords[] = { "transformingShape", "targetShape", "matches", NULL };
| 22121 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ShapeTransformer.estimateTransformation", (char**)keywords, &pyobj_transformingShape, &pyobj_targetShape, &pyobj_matches) && |  | 22073 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ShapeTransformer.estimateTransformation", (char**)keywords, &pyobj_transformingShape, &pyobj_targetShape, &pyobj_matches) &&
| 22122 | pyopencv_to_safe(pyobj_transformingShape, transformingShape, ArgInfo("transformingShape", 0)) && |  | 22074 | pyopencv_to_safe(pyobj_transformingShape, transformingShape, ArgInfo("transformingShape", 0)) &&
| 22123 | pyopencv_to_safe(pyobj_targetShape, targetShape, ArgInfo("targetShape", 0)) && |  | 22075 | pyopencv_to_safe(pyobj_targetShape, targetShape, ArgInfo("targetShape", 0)) &&
| 22124 | pyopencv_to_safe(pyobj_matches, matches, ArgInfo("matches", 0)) ) |  | 22076 | pyopencv_to_safe(pyobj_matches, matches, ArgInfo("matches", 0)) )
| 22125 | { |  | 22077 | {
| 22126 | ERRWRAP2(_self_->estimateTransformation(transformingShape, targetShape, matches)); |  | 22078 | ERRWRAP2(_self_->estimateTransformation(transformingShape, targetShape, matches));
| 22127 | Py_RETURN_NONE; |  | 22079 | Py_RETURN_NONE;
| 22128 | } |  | 22080 | }
| 22129 |  |  | 22081 |
| 22130 |  |  | 22082 |
| 22131 | pyPopulateArgumentConversionErrors(); |  | 22083 | pyPopulateArgumentConversionErrors();
| 22132 | } |  | 22084 | }
| 22133 |  |  | 22085 |
| 22134 |  |  | 22086 |
| 22135 | { |  | 22087 | {
| 22136 | PyObject* pyobj_transformingShape = NULL; |  | 22088 | PyObject* pyobj_transformingShape = NULL;
| 22137 | UMat transformingShape; |  | 22089 | UMat transformingShape;
| 22138 | PyObject* pyobj_targetShape = NULL; |  | 22090 | PyObject* pyobj_targetShape = NULL;
| 22139 | UMat targetShape; |  | 22091 | UMat targetShape;
| 22140 | PyObject* pyobj_matches = NULL; |  | 22092 | PyObject* pyobj_matches = NULL;
| 22141 | vector_DMatch matches; |  | 22093 | vector_DMatch matches;
| 22142 |  |  | 22094 |
| 22143 | const char* keywords[] = { "transformingShape", "targetShape", "matches", NULL }; |  | 22095 | const char* keywords[] = { "transformingShape", "targetShape", "matches", NULL };
| 22144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ShapeTransformer.estimateTransformation", (char**)keywords, &pyobj_transformingShape, &pyobj_targetShape, &pyobj_matches) && |  | 22096 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ShapeTransformer.estimateTransformation", (char**)keywords, &pyobj_transformingShape, &pyobj_targetShape, &pyobj_matches) &&
| 22145 | pyopencv_to_safe(pyobj_transformingShape, transformingShape, ArgInfo("transformingShape", 0)) && |  | 22097 | pyopencv_to_safe(pyobj_transformingShape, transformingShape, ArgInfo("transformingShape", 0)) &&
| 22146 | pyopencv_to_safe(pyobj_targetShape, targetShape, ArgInfo("targetShape", 0)) && |  | 22098 | pyopencv_to_safe(pyobj_targetShape, targetShape, ArgInfo("targetShape", 0)) &&
| 22147 | pyopencv_to_safe(pyobj_matches, matches, ArgInfo("matches", 0)) ) |  | 22099 | pyopencv_to_safe(pyobj_matches, matches, ArgInfo("matches", 0)) )
| 22148 | { |  | 22100 | {
| 22149 | ERRWRAP2(_self_->estimateTransformation(transformingShape, targetShape, matches)); |  | 22101 | ERRWRAP2(_self_->estimateTransformation(transformingShape, targetShape, matches));
| 22150 | Py_RETURN_NONE; |  | 22102 | Py_RETURN_NONE;
| 22151 | } |  | 22103 | }
| 22152 |  |  | 22104 |
| 22153 |  |  | 22105 |
| 22154 | pyPopulateArgumentConversionErrors(); |  | 22106 | pyPopulateArgumentConversionErrors();
| 22155 | } |  | 22107 | }
| 22156 | pyRaiseCVOverloadException("estimateTransformation"); |  | 22108 | pyRaiseCVOverloadException("estimateTransformation");
| 22157 |  |  | 22109 |
| 22158 | return NULL; |  | 22110 | return NULL;
| 22159 | } |  | 22111 | }
| 22160 |  |  | 22112 |
| 22161 | static PyObject* pyopencv_cv_ShapeTransformer_warpImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22113 | static PyObject* pyopencv_cv_ShapeTransformer_warpImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 22162 | { |  | 22114 | {
| 22163 | using namespace cv; |  | 22115 | using namespace cv;
| 22164 |  |  | 22116 |
| 22165 |  |  | 22117 |
| 22166 | Ptr<cv::ShapeTransformer> * self1 = 0; |  | 22118 | Ptr<cv::ShapeTransformer> * self1 = 0;
| 22167 | if (!pyopencv_ShapeTransformer_getp(self, self1)) |  | 22119 | if (!pyopencv_ShapeTransformer_getp(self, self1))
| 22168 | return failmsgp("Incorrect type of self (must be 'ShapeTransformer' or its derivative)"); |  | 22120 | return failmsgp("Incorrect type of self (must be 'ShapeTransformer' or its derivative)");
| 22169 | Ptr<cv::ShapeTransformer> _self_ = *(self1); |  | 22121 | Ptr<cv::ShapeTransformer> _self_ = *(self1);
| 22170 | pyPrepareArgumentConversionErrorsStorage(2); |  | 22122 | pyPrepareArgumentConversionErrorsStorage(2);
| 22171 |  |  | 22123 |
| 22172 | { |  | 22124 | {
| 22173 | PyObject* pyobj_transformingImage = NULL; |  | 22125 | PyObject* pyobj_transformingImage = NULL;
| 22174 | Mat transformingImage; |  | 22126 | Mat transformingImage;
| 22175 | PyObject* pyobj_output = NULL; |  | 22127 | PyObject* pyobj_output = NULL;
| 22176 | Mat output; |  | 22128 | Mat output;
| 22177 | PyObject* pyobj_flags = NULL; |  | 22129 | PyObject* pyobj_flags = NULL;
| 22178 | int flags=INTER_LINEAR; |  | 22130 | int flags=INTER_LINEAR;
| 22179 | PyObject* pyobj_borderMode = NULL; |  | 22131 | PyObject* pyobj_borderMode = NULL;
| 22180 | int borderMode=BORDER_CONSTANT; |  | 22132 | int borderMode=BORDER_CONSTANT;
| 22181 | PyObject* pyobj_borderValue = NULL; |  | 22133 | PyObject* pyobj_borderValue = NULL;
| 22182 | Scalar borderValue; |  | 22134 | Scalar borderValue;
| 22183 |  |  | 22135 |
| 22184 | const char* keywords[] = { "transformingImage", "output", "flags", "borderMode", "borderValue", NULL }; |  | 22136 | const char* keywords[] = { "transformingImage", "output", "flags", "borderMode", "borderValue", NULL };
| 22185 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:ShapeTransformer.warpImage", (char**)keywords, &pyobj_transformingImage, &pyobj_output, &pyobj_flags, &pyobj_borderMode, &pyobj_borderValue) && |  | 22137 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:ShapeTransformer.warpImage", (char**)keywords, &pyobj_transformingImage, &pyobj_output, &pyobj_flags, &pyobj_borderMode, &pyobj_borderValue) &&
| 22186 | pyopencv_to_safe(pyobj_transformingImage, transformingImage, ArgInfo("transformingImage", 0)) && |  | 22138 | pyopencv_to_safe(pyobj_transformingImage, transformingImage, ArgInfo("transformingImage", 0)) &&
| 22187 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) && |  | 22139 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) &&
| 22188 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 22140 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 22189 | pyopencv_to_safe(pyobj_borderMode, borderMode, ArgInfo("borderMode", 0)) && |  | 22141 | pyopencv_to_safe(pyobj_borderMode, borderMode, ArgInfo("borderMode", 0)) &&
| 22190 | pyopencv_to_safe(pyobj_borderValue, borderValue, ArgInfo("borderValue", 0)) ) |  | 22142 | pyopencv_to_safe(pyobj_borderValue, borderValue, ArgInfo("borderValue", 0)) )
| 22191 | { |  | 22143 | {
| 22192 | ERRWRAP2(_self_->warpImage(transformingImage, output, flags, borderMode, borderValue)); |  | 22144 | ERRWRAP2(_self_->warpImage(transformingImage, output, flags, borderMode, borderValue));
| 22193 | return pyopencv_from(output); |  | 22145 | return pyopencv_from(output);
| 22194 | } |  | 22146 | }
| 22195 |  |  | 22147 |
| 22196 |  |  | 22148 |
| 22197 | pyPopulateArgumentConversionErrors(); |  | 22149 | pyPopulateArgumentConversionErrors();
| 22198 | } |  | 22150 | }
| 22199 |  |  | 22151 |
| 22200 |  |  | 22152 |
| 22201 | { |  | 22153 | {
| 22202 | PyObject* pyobj_transformingImage = NULL; |  | 22154 | PyObject* pyobj_transformingImage = NULL;
| 22203 | UMat transformingImage; |  | 22155 | UMat transformingImage;
| 22204 | PyObject* pyobj_output = NULL; |  | 22156 | PyObject* pyobj_output = NULL;
| 22205 | UMat output; |  | 22157 | UMat output;
| 22206 | PyObject* pyobj_flags = NULL; |  | 22158 | PyObject* pyobj_flags = NULL;
| 22207 | int flags=INTER_LINEAR; |  | 22159 | int flags=INTER_LINEAR;
| 22208 | PyObject* pyobj_borderMode = NULL; |  | 22160 | PyObject* pyobj_borderMode = NULL;
| 22209 | int borderMode=BORDER_CONSTANT; |  | 22161 | int borderMode=BORDER_CONSTANT;
| 22210 | PyObject* pyobj_borderValue = NULL; |  | 22162 | PyObject* pyobj_borderValue = NULL;
| 22211 | Scalar borderValue; |  | 22163 | Scalar borderValue;
| 22212 |  |  | 22164 |
| 22213 | const char* keywords[] = { "transformingImage", "output", "flags", "borderMode", "borderValue", NULL }; |  | 22165 | const char* keywords[] = { "transformingImage", "output", "flags", "borderMode", "borderValue", NULL };
| 22214 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:ShapeTransformer.warpImage", (char**)keywords, &pyobj_transformingImage, &pyobj_output, &pyobj_flags, &pyobj_borderMode, &pyobj_borderValue) && |  | 22166 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:ShapeTransformer.warpImage", (char**)keywords, &pyobj_transformingImage, &pyobj_output, &pyobj_flags, &pyobj_borderMode, &pyobj_borderValue) &&
| 22215 | pyopencv_to_safe(pyobj_transformingImage, transformingImage, ArgInfo("transformingImage", 0)) && |  | 22167 | pyopencv_to_safe(pyobj_transformingImage, transformingImage, ArgInfo("transformingImage", 0)) &&
| 22216 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) && |  | 22168 | pyopencv_to_safe(pyobj_output, output, ArgInfo("output", 1)) &&
| 22217 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 22169 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 22218 | pyopencv_to_safe(pyobj_borderMode, borderMode, ArgInfo("borderMode", 0)) && |  | 22170 | pyopencv_to_safe(pyobj_borderMode, borderMode, ArgInfo("borderMode", 0)) &&
| 22219 | pyopencv_to_safe(pyobj_borderValue, borderValue, ArgInfo("borderValue", 0)) ) |  | 22171 | pyopencv_to_safe(pyobj_borderValue, borderValue, ArgInfo("borderValue", 0)) )
| 22220 | { |  | 22172 | {
| 22221 | ERRWRAP2(_self_->warpImage(transformingImage, output, flags, borderMode, borderValue)); |  | 22173 | ERRWRAP2(_self_->warpImage(transformingImage, output, flags, borderMode, borderValue));
| 22222 | return pyopencv_from(output); |  | 22174 | return pyopencv_from(output);
| 22223 | } |  | 22175 | }
| 22224 |  |  | 22176 |
| 22225 |  |  | 22177 |
| 22226 | pyPopulateArgumentConversionErrors(); |  | 22178 | pyPopulateArgumentConversionErrors();
| 22227 | } |  | 22179 | }
| 22228 | pyRaiseCVOverloadException("warpImage"); |  | 22180 | pyRaiseCVOverloadException("warpImage");
| 22229 |  |  | 22181 |
| 22230 | return NULL; |  | 22182 | return NULL;
| 22231 | } |  | 22183 | }
| 22232 |  |  | 22184 |
| 22233 |  |  | 22185 |
| 22234 |  |  | 22186 |
| 22235 | // Tables (ShapeTransformer) |  | 22187 | // Tables (ShapeTransformer)
| 22236 |  |  | 22188 |
| 22237 | static PyGetSetDef pyopencv_ShapeTransformer_getseters[] = |  | 22189 | static PyGetSetDef pyopencv_ShapeTransformer_getseters[] =
| 22238 | { |  | 22190 | {
| 22239 | {NULL} /* Sentinel */ |  | 22191 | {NULL} /* Sentinel */
| 22240 | }; |  | 22192 | };
| 22241 |  |  | 22193 |
| 22242 | static PyMethodDef pyopencv_ShapeTransformer_methods[] = |  | 22194 | static PyMethodDef pyopencv_ShapeTransformer_methods[] =
| 22243 | { |  | 22195 | {
| 22244 | {"applyTransformation", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeTransformer_applyTransformation, 0), "applyTransformation(input[, output]) -> retval, output\n. @brief Apply a transformation, given a pre-estimated transformation parameters.\n. \n. @param input Contour (set of points) to apply the transformation.\n. @param output Output contour."}, |  | 22196 | {"applyTransformation", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeTransformer_applyTransformation, 0), "applyTransformation(input[, output]) -> retval, output\n. @brief Apply a transformation, given a pre-estimated transformation parameters.\n. \n. @param input Contour (set of points) to apply the transformation.\n. @param output Output contour."},
| 22245 | {"estimateTransformation", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeTransformer_estimateTransformation, 0), "estimateTransformation(transformingShape, targetShape, matches) -> None\n. @brief Estimate the transformation parameters of the current transformer algorithm, based on point matches.\n. \n. @param transformingShape Contour defining first shape.\n. @param targetShape Contour defining second shape (Target).\n. @param matches Standard vector of Matches between points."}, |  | 22197 | {"estimateTransformation", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeTransformer_estimateTransformation, 0), "estimateTransformation(transformingShape, targetShape, matches) -> None\n. @brief Estimate the transformation parameters of the current transformer algorithm, based on point matches.\n. \n. @param transformingShape Contour defining first shape.\n. @param targetShape Contour defining second shape (Target).\n. @param matches Standard vector of Matches between points."},
| 22246 | {"warpImage", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeTransformer_warpImage, 0), "warpImage(transformingImage[, output[, flags[, borderMode[, borderValue]]]]) -> output\n. @brief Apply a transformation, given a pre-estimated transformation parameters, to an Image.\n. \n. @param transformingImage Input image.\n. @param output Output image.\n. @param flags Image interpolation method.\n. @param borderMode border style.\n. @param borderValue border value."}, |  | 22198 | {"warpImage", CV_PY_FN_WITH_KW_(pyopencv_cv_ShapeTransformer_warpImage, 0), "warpImage(transformingImage[, output[, flags[, borderMode[, borderValue]]]]) -> output\n. @brief Apply a transformation, given a pre-estimated transformation parameters, to an Image.\n. \n. @param transformingImage Input image.\n. @param output Output image.\n. @param flags Image interpolation method.\n. @param borderMode border style.\n. @param borderValue border value."},
| 22247 |  |  | 22199 |
| 22248 | {NULL, NULL} |  | 22200 | {NULL, NULL}
| 22249 | }; |  | 22201 | };
| 22250 |  |  | 22202 |
| 22251 | // Converter (ShapeTransformer) |  | 22203 | // Converter (ShapeTransformer)
| 22252 |  |  | 22204 |
| 22253 | template<> |  | 22205 | template<>
| 22254 | struct PyOpenCV_Converter< Ptr<cv::ShapeTransformer> > |  | 22206 | struct PyOpenCV_Converter< Ptr<cv::ShapeTransformer> >
| 22255 | { |  | 22207 | {
| 22256 | static PyObject* from(const Ptr<cv::ShapeTransformer>& r) |  | 22208 | static PyObject* from(const Ptr<cv::ShapeTransformer>& r)
| 22257 | { |  | 22209 | {
| 22258 | return pyopencv_ShapeTransformer_Instance(r); |  | 22210 | return pyopencv_ShapeTransformer_Instance(r);
| 22259 | } |  | 22211 | }
| 22260 | static bool to(PyObject* src, Ptr<cv::ShapeTransformer>& dst, const ArgInfo& info) |  | 22212 | static bool to(PyObject* src, Ptr<cv::ShapeTransformer>& dst, const ArgInfo& info)
| 22261 | { |  | 22213 | {
| 22262 | if(!src || src == Py_None) |  | 22214 | if(!src || src == Py_None)
| 22263 | return true; |  | 22215 | return true;
| 22264 | Ptr<cv::ShapeTransformer> * dst_; |  | 22216 | Ptr<cv::ShapeTransformer> * dst_;
| 22265 | if (pyopencv_ShapeTransformer_getp(src, dst_)) |  | 22217 | if (pyopencv_ShapeTransformer_getp(src, dst_))
| 22266 | { |  | 22218 | {
| 22267 | dst = *dst_; |  | 22219 | dst = *dst_;
| 22268 | return true; |  | 22220 | return true;
| 22269 | } |  | 22221 | }
| 22270 |  |  | 22222 |
| 22271 | failmsg("Expected Ptr<cv::ShapeTransformer> for argument '%s'", info.name); |  | 22223 | failmsg("Expected Ptr<cv::ShapeTransformer> for argument '%s'", info.name);
| 22272 | return false; |  | 22224 | return false;
| 22273 | } |  | 22225 | }
| 22274 | }; |  | 22226 | };
| 22275 |  |  | 22227 |
| 22276 | //================================================================================ |  | 22228 | //================================================================================
| 22277 | // SimpleBlobDetector (Generic) |  | 22229 | // SimpleBlobDetector (Generic)
| 22278 | //================================================================================ |  | 22230 | //================================================================================
| 22279 |  |  | 22231 |
| 22280 | // GetSet (SimpleBlobDetector) |  | 22232 | // GetSet (SimpleBlobDetector)
| 22281 |  |  | 22233 |
| 22282 |  |  | 22234 |
| 22283 |  |  | 22235 |
| 22284 | // Methods (SimpleBlobDetector) |  | 22236 | // Methods (SimpleBlobDetector)
| 22285 |  |  | 22237 |
| 22286 | static PyObject* pyopencv_cv_SimpleBlobDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22238 | static PyObject* pyopencv_cv_SimpleBlobDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 22287 | { |  | 22239 | {
| 22288 | using namespace cv; |  | 22240 | using namespace cv;
| 22289 |  |  | 22241 |
| 22290 | PyObject* pyobj_parameters = NULL; |  | 22242 | PyObject* pyobj_parameters = NULL;
| 22291 | cv::SimpleBlobDetector::Params parameters=SimpleBlobDetector::Params(); |  | 22243 | cv::SimpleBlobDetector::Params parameters=SimpleBlobDetector::Params();
| 22292 | Ptr<SimpleBlobDetector> retval; |  | 22244 | Ptr<SimpleBlobDetector> retval;
| 22293 |  |  | 22245 |
| 22294 | const char* keywords[] = { "parameters", NULL }; |  | 22246 | const char* keywords[] = { "parameters", NULL };
| 22295 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:SimpleBlobDetector.create", (char**)keywords, &pyobj_parameters) && |  | 22247 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:SimpleBlobDetector.create", (char**)keywords, &pyobj_parameters) &&
| 22296 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 22248 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 22297 | { |  | 22249 | {
| 22298 | ERRWRAP2(retval = cv::SimpleBlobDetector::create(parameters)); |  | 22250 | ERRWRAP2(retval = cv::SimpleBlobDetector::create(parameters));
| 22299 | return pyopencv_from(retval); |  | 22251 | return pyopencv_from(retval);
| 22300 | } |  | 22252 | }
| 22301 |  |  | 22253 |
| 22302 | return NULL; |  | 22254 | return NULL;
| 22303 | } |  | 22255 | }
| 22304 |  |  | 22256 |
| 22305 | static PyObject* pyopencv_cv_SimpleBlobDetector_getBlobContours(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22257 | static PyObject* pyopencv_cv_SimpleBlobDetector_getBlobContours(PyObject* self, PyObject* py_args, PyObject* kw)
| 22306 | { |  | 22258 | {
| 22307 | using namespace cv; |  | 22259 | using namespace cv;
| 22308 |  |  | 22260 |
| 22309 |  |  | 22261 |
| 22310 | Ptr<cv::SimpleBlobDetector> * self1 = 0; |  | 22262 | Ptr<cv::SimpleBlobDetector> * self1 = 0;
| 22311 | if (!pyopencv_SimpleBlobDetector_getp(self, self1)) |  | 22263 | if (!pyopencv_SimpleBlobDetector_getp(self, self1))
| 22312 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)"); |  | 22264 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)");
| 22313 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1); |  | 22265 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1);
| 22314 | std::vector<std::vector<cv::Point> > retval; |  | 22266 | std::vector<std::vector<cv::Point> > retval;
| 22315 |  |  | 22267 |
| 22316 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 22268 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 22317 | { |  | 22269 | {
| 22318 | ERRWRAP2(retval = _self_->getBlobContours()); |  | 22270 | ERRWRAP2(retval = _self_->getBlobContours());
| 22319 | return pyopencv_from(retval); |  | 22271 | return pyopencv_from(retval);
| 22320 | } |  | 22272 | }
| 22321 |  |  | 22273 |
| 22322 | return NULL; |  | 22274 | return NULL;
| 22323 | } |  | 22275 | }
| 22324 |  |  | 22276 |
| 22325 | static PyObject* pyopencv_cv_SimpleBlobDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22277 | static PyObject* pyopencv_cv_SimpleBlobDetector_getDefaultName(PyObject* self, PyObject* py_args, PyObject* kw)
| 22326 | { |  | 22278 | {
| 22327 | using namespace cv; |  | 22279 | using namespace cv;
| 22328 |  |  | 22280 |
| 22329 |  |  | 22281 |
| 22330 | Ptr<cv::SimpleBlobDetector> * self1 = 0; |  | 22282 | Ptr<cv::SimpleBlobDetector> * self1 = 0;
| 22331 | if (!pyopencv_SimpleBlobDetector_getp(self, self1)) |  | 22283 | if (!pyopencv_SimpleBlobDetector_getp(self, self1))
| 22332 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)"); |  | 22284 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)");
| 22333 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1); |  | 22285 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1);
| 22334 | String retval; |  | 22286 | String retval;
| 22335 |  |  | 22287 |
| 22336 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 22288 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 22337 | { |  | 22289 | {
| 22338 | ERRWRAP2(retval = _self_->getDefaultName()); |  | 22290 | ERRWRAP2(retval = _self_->getDefaultName());
| 22339 | return pyopencv_from(retval); |  | 22291 | return pyopencv_from(retval);
| 22340 | } |  | 22292 | }
| 22341 |  |  | 22293 |
| 22342 | return NULL; |  | 22294 | return NULL;
| 22343 | } |  | 22295 | }
| 22344 |  |  | 22296 |
| 22345 | static PyObject* pyopencv_cv_SimpleBlobDetector_getParams(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22297 | static PyObject* pyopencv_cv_SimpleBlobDetector_getParams(PyObject* self, PyObject* py_args, PyObject* kw)
| 22346 | { |  | 22298 | {
| 22347 | using namespace cv; |  | 22299 | using namespace cv;
| 22348 |  |  | 22300 |
| 22349 |  |  | 22301 |
| 22350 | Ptr<cv::SimpleBlobDetector> * self1 = 0; |  | 22302 | Ptr<cv::SimpleBlobDetector> * self1 = 0;
| 22351 | if (!pyopencv_SimpleBlobDetector_getp(self, self1)) |  | 22303 | if (!pyopencv_SimpleBlobDetector_getp(self, self1))
| 22352 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)"); |  | 22304 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)");
| 22353 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1); |  | 22305 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1);
| 22354 | SimpleBlobDetector::Params retval; |  | 22306 | SimpleBlobDetector::Params retval;
| 22355 |  |  | 22307 |
| 22356 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 22308 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 22357 | { |  | 22309 | {
| 22358 | ERRWRAP2(retval = _self_->getParams()); |  | 22310 | ERRWRAP2(retval = _self_->getParams());
| 22359 | return pyopencv_from(retval); |  | 22311 | return pyopencv_from(retval);
| 22360 | } |  | 22312 | }
| 22361 |  |  | 22313 |
| 22362 | return NULL; |  | 22314 | return NULL;
| 22363 | } |  | 22315 | }
| 22364 |  |  | 22316 |
| 22365 | static PyObject* pyopencv_cv_SimpleBlobDetector_setParams(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22317 | static PyObject* pyopencv_cv_SimpleBlobDetector_setParams(PyObject* self, PyObject* py_args, PyObject* kw)
| 22366 | { |  | 22318 | {
| 22367 | using namespace cv; |  | 22319 | using namespace cv;
| 22368 |  |  | 22320 |
| 22369 |  |  | 22321 |
| 22370 | Ptr<cv::SimpleBlobDetector> * self1 = 0; |  | 22322 | Ptr<cv::SimpleBlobDetector> * self1 = 0;
| 22371 | if (!pyopencv_SimpleBlobDetector_getp(self, self1)) |  | 22323 | if (!pyopencv_SimpleBlobDetector_getp(self, self1))
| 22372 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)"); |  | 22324 | return failmsgp("Incorrect type of self (must be 'SimpleBlobDetector' or its derivative)");
| 22373 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1); |  | 22325 | Ptr<cv::SimpleBlobDetector> _self_ = *(self1);
| 22374 | PyObject* pyobj_params = NULL; |  | 22326 | PyObject* pyobj_params = NULL;
| 22375 | cv::SimpleBlobDetector::Params params; |  | 22327 | cv::SimpleBlobDetector::Params params;
| 22376 |  |  | 22328 |
| 22377 | const char* keywords[] = { "params", NULL }; |  | 22329 | const char* keywords[] = { "params", NULL };
| 22378 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SimpleBlobDetector.setParams", (char**)keywords, &pyobj_params) && |  | 22330 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SimpleBlobDetector.setParams", (char**)keywords, &pyobj_params) &&
| 22379 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 22331 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 22380 | { |  | 22332 | {
| 22381 | ERRWRAP2(_self_->setParams(params)); |  | 22333 | ERRWRAP2(_self_->setParams(params));
| 22382 | Py_RETURN_NONE; |  | 22334 | Py_RETURN_NONE;
| 22383 | } |  | 22335 | }
| 22384 |  |  | 22336 |
| 22385 | return NULL; |  | 22337 | return NULL;
| 22386 | } |  | 22338 | }
| 22387 |  |  | 22339 |
| 22388 |  |  | 22340 |
| 22389 |  |  | 22341 |
| 22390 | // Tables (SimpleBlobDetector) |  | 22342 | // Tables (SimpleBlobDetector)
| 22391 |  |  | 22343 |
| 22392 | static PyGetSetDef pyopencv_SimpleBlobDetector_getseters[] = |  | 22344 | static PyGetSetDef pyopencv_SimpleBlobDetector_getseters[] =
| 22393 | { |  | 22345 | {
| 22394 | {NULL} /* Sentinel */ |  | 22346 | {NULL} /* Sentinel */
| 22395 | }; |  | 22347 | };
| 22396 |  |  | 22348 |
| 22397 | static PyMethodDef pyopencv_SimpleBlobDetector_methods[] = |  | 22349 | static PyMethodDef pyopencv_SimpleBlobDetector_methods[] =
| 22398 | { |  | 22350 | {
| 22399 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_create_static, METH_STATIC), "create([, parameters]) -> retval\n."}, |  | 22351 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_create_static, METH_STATIC), "create([, parameters]) -> retval\n."},
| 22400 | {"getBlobContours", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_getBlobContours, 0), "getBlobContours() -> retval\n."}, |  | 22352 | {"getBlobContours", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_getBlobContours, 0), "getBlobContours() -> retval\n."},
| 22401 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_getDefaultName, 0), "getDefaultName() -> retval\n."}, |  | 22353 | {"getDefaultName", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_getDefaultName, 0), "getDefaultName() -> retval\n."},
| 22402 | {"getParams", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_getParams, 0), "getParams() -> retval\n."}, |  | 22354 | {"getParams", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_getParams, 0), "getParams() -> retval\n."},
| 22403 | {"setParams", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_setParams, 0), "setParams(params) -> None\n."}, |  | 22355 | {"setParams", CV_PY_FN_WITH_KW_(pyopencv_cv_SimpleBlobDetector_setParams, 0), "setParams(params) -> None\n."},
| 22404 |  |  | 22356 |
| 22405 | {NULL, NULL} |  | 22357 | {NULL, NULL}
| 22406 | }; |  | 22358 | };
| 22407 |  |  | 22359 |
| 22408 | // Converter (SimpleBlobDetector) |  | 22360 | // Converter (SimpleBlobDetector)
| 22409 |  |  | 22361 |
| 22410 | template<> |  | 22362 | template<>
| 22411 | struct PyOpenCV_Converter< Ptr<cv::SimpleBlobDetector> > |  | 22363 | struct PyOpenCV_Converter< Ptr<cv::SimpleBlobDetector> >
| 22412 | { |  | 22364 | {
| 22413 | static PyObject* from(const Ptr<cv::SimpleBlobDetector>& r) |  | 22365 | static PyObject* from(const Ptr<cv::SimpleBlobDetector>& r)
| 22414 | { |  | 22366 | {
| 22415 | return pyopencv_SimpleBlobDetector_Instance(r); |  | 22367 | return pyopencv_SimpleBlobDetector_Instance(r);
| 22416 | } |  | 22368 | }
| 22417 | static bool to(PyObject* src, Ptr<cv::SimpleBlobDetector>& dst, const ArgInfo& info) |  | 22369 | static bool to(PyObject* src, Ptr<cv::SimpleBlobDetector>& dst, const ArgInfo& info)
| 22418 | { |  | 22370 | {
| 22419 | if(!src || src == Py_None) |  | 22371 | if(!src || src == Py_None)
| 22420 | return true; |  | 22372 | return true;
| 22421 | Ptr<cv::SimpleBlobDetector> * dst_; |  | 22373 | Ptr<cv::SimpleBlobDetector> * dst_;
| 22422 | if (pyopencv_SimpleBlobDetector_getp(src, dst_)) |  | 22374 | if (pyopencv_SimpleBlobDetector_getp(src, dst_))
| 22423 | { |  | 22375 | {
| 22424 | dst = *dst_; |  | 22376 | dst = *dst_;
| 22425 | return true; |  | 22377 | return true;
| 22426 | } |  | 22378 | }
| 22427 |  |  | 22379 |
| 22428 | failmsg("Expected Ptr<cv::SimpleBlobDetector> for argument '%s'", info.name); |  | 22380 | failmsg("Expected Ptr<cv::SimpleBlobDetector> for argument '%s'", info.name);
| 22429 | return false; |  | 22381 | return false;
| 22430 | } |  | 22382 | }
| 22431 | }; |  | 22383 | };
| 22432 |  |  | 22384 |
| 22433 | //================================================================================ |  | 22385 | //================================================================================
| 22434 | // SimpleBlobDetector_Params (Generic) |  | 22386 | // SimpleBlobDetector_Params (Generic)
| 22435 | //================================================================================ |  | 22387 | //================================================================================
| 22436 |  |  | 22388 |
| 22437 | // GetSet (SimpleBlobDetector_Params) |  | 22389 | // GetSet (SimpleBlobDetector_Params)
| 22438 |  |  | 22390 |
| 22439 |  |  | 22391 |
| 22440 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_blobColor(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22392 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_blobColor(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22441 | { |  | 22393 | {
| 22442 | return pyopencv_from(p->v.blobColor); |  | 22394 | return pyopencv_from(p->v.blobColor);
| 22443 | } |  | 22395 | }
| 22444 |  |  | 22396 |
| 22445 | static int pyopencv_SimpleBlobDetector_Params_set_blobColor(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22397 | static int pyopencv_SimpleBlobDetector_Params_set_blobColor(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22446 | { |  | 22398 | {
| 22447 | if (!value) |  | 22399 | if (!value)
| 22448 | { |  | 22400 | {
| 22449 | PyErr_SetString(PyExc_TypeError, "Cannot delete the blobColor attribute"); |  | 22401 | PyErr_SetString(PyExc_TypeError, "Cannot delete the blobColor attribute");
| 22450 | return -1; |  | 22402 | return -1;
| 22451 | } |  | 22403 | }
| 22452 | return pyopencv_to_safe(value, p->v.blobColor, ArgInfo("value", 0)) ? 0 : -1; |  | 22404 | return pyopencv_to_safe(value, p->v.blobColor, ArgInfo("value", 0)) ? 0 : -1;
| 22453 | } |  | 22405 | }
| 22454 |  |  | 22406 |
| 22455 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_collectContours(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22407 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_collectContours(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22456 | { |  | 22408 | {
| 22457 | return pyopencv_from(p->v.collectContours); |  | 22409 | return pyopencv_from(p->v.collectContours);
| 22458 | } |  | 22410 | }
| 22459 |  |  | 22411 |
| 22460 | static int pyopencv_SimpleBlobDetector_Params_set_collectContours(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22412 | static int pyopencv_SimpleBlobDetector_Params_set_collectContours(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22461 | { |  | 22413 | {
| 22462 | if (!value) |  | 22414 | if (!value)
| 22463 | { |  | 22415 | {
| 22464 | PyErr_SetString(PyExc_TypeError, "Cannot delete the collectContours attribute"); |  | 22416 | PyErr_SetString(PyExc_TypeError, "Cannot delete the collectContours attribute");
| 22465 | return -1; |  | 22417 | return -1;
| 22466 | } |  | 22418 | }
| 22467 | return pyopencv_to_safe(value, p->v.collectContours, ArgInfo("value", 0)) ? 0 : -1; |  | 22419 | return pyopencv_to_safe(value, p->v.collectContours, ArgInfo("value", 0)) ? 0 : -1;
| 22468 | } |  | 22420 | }
| 22469 |  |  | 22421 |
| 22470 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByArea(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22422 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByArea(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22471 | { |  | 22423 | {
| 22472 | return pyopencv_from(p->v.filterByArea); |  | 22424 | return pyopencv_from(p->v.filterByArea);
| 22473 | } |  | 22425 | }
| 22474 |  |  | 22426 |
| 22475 | static int pyopencv_SimpleBlobDetector_Params_set_filterByArea(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22427 | static int pyopencv_SimpleBlobDetector_Params_set_filterByArea(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22476 | { |  | 22428 | {
| 22477 | if (!value) |  | 22429 | if (!value)
| 22478 | { |  | 22430 | {
| 22479 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByArea attribute"); |  | 22431 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByArea attribute");
| 22480 | return -1; |  | 22432 | return -1;
| 22481 | } |  | 22433 | }
| 22482 | return pyopencv_to_safe(value, p->v.filterByArea, ArgInfo("value", 0)) ? 0 : -1; |  | 22434 | return pyopencv_to_safe(value, p->v.filterByArea, ArgInfo("value", 0)) ? 0 : -1;
| 22483 | } |  | 22435 | }
| 22484 |  |  | 22436 |
| 22485 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByCircularity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22437 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByCircularity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22486 | { |  | 22438 | {
| 22487 | return pyopencv_from(p->v.filterByCircularity); |  | 22439 | return pyopencv_from(p->v.filterByCircularity);
| 22488 | } |  | 22440 | }
| 22489 |  |  | 22441 |
| 22490 | static int pyopencv_SimpleBlobDetector_Params_set_filterByCircularity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22442 | static int pyopencv_SimpleBlobDetector_Params_set_filterByCircularity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22491 | { |  | 22443 | {
| 22492 | if (!value) |  | 22444 | if (!value)
| 22493 | { |  | 22445 | {
| 22494 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByCircularity attribute"); |  | 22446 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByCircularity attribute");
| 22495 | return -1; |  | 22447 | return -1;
| 22496 | } |  | 22448 | }
| 22497 | return pyopencv_to_safe(value, p->v.filterByCircularity, ArgInfo("value", 0)) ? 0 : -1; |  | 22449 | return pyopencv_to_safe(value, p->v.filterByCircularity, ArgInfo("value", 0)) ? 0 : -1;
| 22498 | } |  | 22450 | }
| 22499 |  |  | 22451 |
| 22500 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByColor(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22452 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByColor(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22501 | { |  | 22453 | {
| 22502 | return pyopencv_from(p->v.filterByColor); |  | 22454 | return pyopencv_from(p->v.filterByColor);
| 22503 | } |  | 22455 | }
| 22504 |  |  | 22456 |
| 22505 | static int pyopencv_SimpleBlobDetector_Params_set_filterByColor(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22457 | static int pyopencv_SimpleBlobDetector_Params_set_filterByColor(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22506 | { |  | 22458 | {
| 22507 | if (!value) |  | 22459 | if (!value)
| 22508 | { |  | 22460 | {
| 22509 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByColor attribute"); |  | 22461 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByColor attribute");
| 22510 | return -1; |  | 22462 | return -1;
| 22511 | } |  | 22463 | }
| 22512 | return pyopencv_to_safe(value, p->v.filterByColor, ArgInfo("value", 0)) ? 0 : -1; |  | 22464 | return pyopencv_to_safe(value, p->v.filterByColor, ArgInfo("value", 0)) ? 0 : -1;
| 22513 | } |  | 22465 | }
| 22514 |  |  | 22466 |
| 22515 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByConvexity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22467 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByConvexity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22516 | { |  | 22468 | {
| 22517 | return pyopencv_from(p->v.filterByConvexity); |  | 22469 | return pyopencv_from(p->v.filterByConvexity);
| 22518 | } |  | 22470 | }
| 22519 |  |  | 22471 |
| 22520 | static int pyopencv_SimpleBlobDetector_Params_set_filterByConvexity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22472 | static int pyopencv_SimpleBlobDetector_Params_set_filterByConvexity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22521 | { |  | 22473 | {
| 22522 | if (!value) |  | 22474 | if (!value)
| 22523 | { |  | 22475 | {
| 22524 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByConvexity attribute"); |  | 22476 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByConvexity attribute");
| 22525 | return -1; |  | 22477 | return -1;
| 22526 | } |  | 22478 | }
| 22527 | return pyopencv_to_safe(value, p->v.filterByConvexity, ArgInfo("value", 0)) ? 0 : -1; |  | 22479 | return pyopencv_to_safe(value, p->v.filterByConvexity, ArgInfo("value", 0)) ? 0 : -1;
| 22528 | } |  | 22480 | }
| 22529 |  |  | 22481 |
| 22530 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByInertia(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22482 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_filterByInertia(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22531 | { |  | 22483 | {
| 22532 | return pyopencv_from(p->v.filterByInertia); |  | 22484 | return pyopencv_from(p->v.filterByInertia);
| 22533 | } |  | 22485 | }
| 22534 |  |  | 22486 |
| 22535 | static int pyopencv_SimpleBlobDetector_Params_set_filterByInertia(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22487 | static int pyopencv_SimpleBlobDetector_Params_set_filterByInertia(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22536 | { |  | 22488 | {
| 22537 | if (!value) |  | 22489 | if (!value)
| 22538 | { |  | 22490 | {
| 22539 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByInertia attribute"); |  | 22491 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filterByInertia attribute");
| 22540 | return -1; |  | 22492 | return -1;
| 22541 | } |  | 22493 | }
| 22542 | return pyopencv_to_safe(value, p->v.filterByInertia, ArgInfo("value", 0)) ? 0 : -1; |  | 22494 | return pyopencv_to_safe(value, p->v.filterByInertia, ArgInfo("value", 0)) ? 0 : -1;
| 22543 | } |  | 22495 | }
| 22544 |  |  | 22496 |
| 22545 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxArea(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22497 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxArea(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22546 | { |  | 22498 | {
| 22547 | return pyopencv_from(p->v.maxArea); |  | 22499 | return pyopencv_from(p->v.maxArea);
| 22548 | } |  | 22500 | }
| 22549 |  |  | 22501 |
| 22550 | static int pyopencv_SimpleBlobDetector_Params_set_maxArea(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22502 | static int pyopencv_SimpleBlobDetector_Params_set_maxArea(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22551 | { |  | 22503 | {
| 22552 | if (!value) |  | 22504 | if (!value)
| 22553 | { |  | 22505 | {
| 22554 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxArea attribute"); |  | 22506 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxArea attribute");
| 22555 | return -1; |  | 22507 | return -1;
| 22556 | } |  | 22508 | }
| 22557 | return pyopencv_to_safe(value, p->v.maxArea, ArgInfo("value", 0)) ? 0 : -1; |  | 22509 | return pyopencv_to_safe(value, p->v.maxArea, ArgInfo("value", 0)) ? 0 : -1;
| 22558 | } |  | 22510 | }
| 22559 |  |  | 22511 |
| 22560 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxCircularity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22512 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxCircularity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22561 | { |  | 22513 | {
| 22562 | return pyopencv_from(p->v.maxCircularity); |  | 22514 | return pyopencv_from(p->v.maxCircularity);
| 22563 | } |  | 22515 | }
| 22564 |  |  | 22516 |
| 22565 | static int pyopencv_SimpleBlobDetector_Params_set_maxCircularity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22517 | static int pyopencv_SimpleBlobDetector_Params_set_maxCircularity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22566 | { |  | 22518 | {
| 22567 | if (!value) |  | 22519 | if (!value)
| 22568 | { |  | 22520 | {
| 22569 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxCircularity attribute"); |  | 22521 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxCircularity attribute");
| 22570 | return -1; |  | 22522 | return -1;
| 22571 | } |  | 22523 | }
| 22572 | return pyopencv_to_safe(value, p->v.maxCircularity, ArgInfo("value", 0)) ? 0 : -1; |  | 22524 | return pyopencv_to_safe(value, p->v.maxCircularity, ArgInfo("value", 0)) ? 0 : -1;
| 22573 | } |  | 22525 | }
| 22574 |  |  | 22526 |
| 22575 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxConvexity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22527 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxConvexity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22576 | { |  | 22528 | {
| 22577 | return pyopencv_from(p->v.maxConvexity); |  | 22529 | return pyopencv_from(p->v.maxConvexity);
| 22578 | } |  | 22530 | }
| 22579 |  |  | 22531 |
| 22580 | static int pyopencv_SimpleBlobDetector_Params_set_maxConvexity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22532 | static int pyopencv_SimpleBlobDetector_Params_set_maxConvexity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22581 | { |  | 22533 | {
| 22582 | if (!value) |  | 22534 | if (!value)
| 22583 | { |  | 22535 | {
| 22584 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxConvexity attribute"); |  | 22536 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxConvexity attribute");
| 22585 | return -1; |  | 22537 | return -1;
| 22586 | } |  | 22538 | }
| 22587 | return pyopencv_to_safe(value, p->v.maxConvexity, ArgInfo("value", 0)) ? 0 : -1; |  | 22539 | return pyopencv_to_safe(value, p->v.maxConvexity, ArgInfo("value", 0)) ? 0 : -1;
| 22588 | } |  | 22540 | }
| 22589 |  |  | 22541 |
| 22590 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22542 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22591 | { |  | 22543 | {
| 22592 | return pyopencv_from(p->v.maxInertiaRatio); |  | 22544 | return pyopencv_from(p->v.maxInertiaRatio);
| 22593 | } |  | 22545 | }
| 22594 |  |  | 22546 |
| 22595 | static int pyopencv_SimpleBlobDetector_Params_set_maxInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22547 | static int pyopencv_SimpleBlobDetector_Params_set_maxInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22596 | { |  | 22548 | {
| 22597 | if (!value) |  | 22549 | if (!value)
| 22598 | { |  | 22550 | {
| 22599 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxInertiaRatio attribute"); |  | 22551 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxInertiaRatio attribute");
| 22600 | return -1; |  | 22552 | return -1;
| 22601 | } |  | 22553 | }
| 22602 | return pyopencv_to_safe(value, p->v.maxInertiaRatio, ArgInfo("value", 0)) ? 0 : -1; |  | 22554 | return pyopencv_to_safe(value, p->v.maxInertiaRatio, ArgInfo("value", 0)) ? 0 : -1;
| 22603 | } |  | 22555 | }
| 22604 |  |  | 22556 |
| 22605 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxThreshold(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22557 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_maxThreshold(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22606 | { |  | 22558 | {
| 22607 | return pyopencv_from(p->v.maxThreshold); |  | 22559 | return pyopencv_from(p->v.maxThreshold);
| 22608 | } |  | 22560 | }
| 22609 |  |  | 22561 |
| 22610 | static int pyopencv_SimpleBlobDetector_Params_set_maxThreshold(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22562 | static int pyopencv_SimpleBlobDetector_Params_set_maxThreshold(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22611 | { |  | 22563 | {
| 22612 | if (!value) |  | 22564 | if (!value)
| 22613 | { |  | 22565 | {
| 22614 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxThreshold attribute"); |  | 22566 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxThreshold attribute");
| 22615 | return -1; |  | 22567 | return -1;
| 22616 | } |  | 22568 | }
| 22617 | return pyopencv_to_safe(value, p->v.maxThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 22569 | return pyopencv_to_safe(value, p->v.maxThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 22618 | } |  | 22570 | }
| 22619 |  |  | 22571 |
| 22620 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minArea(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22572 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minArea(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22621 | { |  | 22573 | {
| 22622 | return pyopencv_from(p->v.minArea); |  | 22574 | return pyopencv_from(p->v.minArea);
| 22623 | } |  | 22575 | }
| 22624 |  |  | 22576 |
| 22625 | static int pyopencv_SimpleBlobDetector_Params_set_minArea(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22577 | static int pyopencv_SimpleBlobDetector_Params_set_minArea(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22626 | { |  | 22578 | {
| 22627 | if (!value) |  | 22579 | if (!value)
| 22628 | { |  | 22580 | {
| 22629 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minArea attribute"); |  | 22581 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minArea attribute");
| 22630 | return -1; |  | 22582 | return -1;
| 22631 | } |  | 22583 | }
| 22632 | return pyopencv_to_safe(value, p->v.minArea, ArgInfo("value", 0)) ? 0 : -1; |  | 22584 | return pyopencv_to_safe(value, p->v.minArea, ArgInfo("value", 0)) ? 0 : -1;
| 22633 | } |  | 22585 | }
| 22634 |  |  | 22586 |
| 22635 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minCircularity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22587 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minCircularity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22636 | { |  | 22588 | {
| 22637 | return pyopencv_from(p->v.minCircularity); |  | 22589 | return pyopencv_from(p->v.minCircularity);
| 22638 | } |  | 22590 | }
| 22639 |  |  | 22591 |
| 22640 | static int pyopencv_SimpleBlobDetector_Params_set_minCircularity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22592 | static int pyopencv_SimpleBlobDetector_Params_set_minCircularity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22641 | { |  | 22593 | {
| 22642 | if (!value) |  | 22594 | if (!value)
| 22643 | { |  | 22595 | {
| 22644 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minCircularity attribute"); |  | 22596 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minCircularity attribute");
| 22645 | return -1; |  | 22597 | return -1;
| 22646 | } |  | 22598 | }
| 22647 | return pyopencv_to_safe(value, p->v.minCircularity, ArgInfo("value", 0)) ? 0 : -1; |  | 22599 | return pyopencv_to_safe(value, p->v.minCircularity, ArgInfo("value", 0)) ? 0 : -1;
| 22648 | } |  | 22600 | }
| 22649 |  |  | 22601 |
| 22650 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minConvexity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22602 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minConvexity(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22651 | { |  | 22603 | {
| 22652 | return pyopencv_from(p->v.minConvexity); |  | 22604 | return pyopencv_from(p->v.minConvexity);
| 22653 | } |  | 22605 | }
| 22654 |  |  | 22606 |
| 22655 | static int pyopencv_SimpleBlobDetector_Params_set_minConvexity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22607 | static int pyopencv_SimpleBlobDetector_Params_set_minConvexity(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22656 | { |  | 22608 | {
| 22657 | if (!value) |  | 22609 | if (!value)
| 22658 | { |  | 22610 | {
| 22659 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minConvexity attribute"); |  | 22611 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minConvexity attribute");
| 22660 | return -1; |  | 22612 | return -1;
| 22661 | } |  | 22613 | }
| 22662 | return pyopencv_to_safe(value, p->v.minConvexity, ArgInfo("value", 0)) ? 0 : -1; |  | 22614 | return pyopencv_to_safe(value, p->v.minConvexity, ArgInfo("value", 0)) ? 0 : -1;
| 22663 | } |  | 22615 | }
| 22664 |  |  | 22616 |
| 22665 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minDistBetweenBlobs(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22617 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minDistBetweenBlobs(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22666 | { |  | 22618 | {
| 22667 | return pyopencv_from(p->v.minDistBetweenBlobs); |  | 22619 | return pyopencv_from(p->v.minDistBetweenBlobs);
| 22668 | } |  | 22620 | }
| 22669 |  |  | 22621 |
| 22670 | static int pyopencv_SimpleBlobDetector_Params_set_minDistBetweenBlobs(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22622 | static int pyopencv_SimpleBlobDetector_Params_set_minDistBetweenBlobs(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22671 | { |  | 22623 | {
| 22672 | if (!value) |  | 22624 | if (!value)
| 22673 | { |  | 22625 | {
| 22674 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDistBetweenBlobs attribute"); |  | 22626 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDistBetweenBlobs attribute");
| 22675 | return -1; |  | 22627 | return -1;
| 22676 | } |  | 22628 | }
| 22677 | return pyopencv_to_safe(value, p->v.minDistBetweenBlobs, ArgInfo("value", 0)) ? 0 : -1; |  | 22629 | return pyopencv_to_safe(value, p->v.minDistBetweenBlobs, ArgInfo("value", 0)) ? 0 : -1;
| 22678 | } |  | 22630 | }
| 22679 |  |  | 22631 |
| 22680 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22632 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22681 | { |  | 22633 | {
| 22682 | return pyopencv_from(p->v.minInertiaRatio); |  | 22634 | return pyopencv_from(p->v.minInertiaRatio);
| 22683 | } |  | 22635 | }
| 22684 |  |  | 22636 |
| 22685 | static int pyopencv_SimpleBlobDetector_Params_set_minInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22637 | static int pyopencv_SimpleBlobDetector_Params_set_minInertiaRatio(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22686 | { |  | 22638 | {
| 22687 | if (!value) |  | 22639 | if (!value)
| 22688 | { |  | 22640 | {
| 22689 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minInertiaRatio attribute"); |  | 22641 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minInertiaRatio attribute");
| 22690 | return -1; |  | 22642 | return -1;
| 22691 | } |  | 22643 | }
| 22692 | return pyopencv_to_safe(value, p->v.minInertiaRatio, ArgInfo("value", 0)) ? 0 : -1; |  | 22644 | return pyopencv_to_safe(value, p->v.minInertiaRatio, ArgInfo("value", 0)) ? 0 : -1;
| 22693 | } |  | 22645 | }
| 22694 |  |  | 22646 |
| 22695 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minRepeatability(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22647 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minRepeatability(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22696 | { |  | 22648 | {
| 22697 | return pyopencv_from(p->v.minRepeatability); |  | 22649 | return pyopencv_from(p->v.minRepeatability);
| 22698 | } |  | 22650 | }
| 22699 |  |  | 22651 |
| 22700 | static int pyopencv_SimpleBlobDetector_Params_set_minRepeatability(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22652 | static int pyopencv_SimpleBlobDetector_Params_set_minRepeatability(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22701 | { |  | 22653 | {
| 22702 | if (!value) |  | 22654 | if (!value)
| 22703 | { |  | 22655 | {
| 22704 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minRepeatability attribute"); |  | 22656 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minRepeatability attribute");
| 22705 | return -1; |  | 22657 | return -1;
| 22706 | } |  | 22658 | }
| 22707 | return pyopencv_to_safe(value, p->v.minRepeatability, ArgInfo("value", 0)) ? 0 : -1; |  | 22659 | return pyopencv_to_safe(value, p->v.minRepeatability, ArgInfo("value", 0)) ? 0 : -1;
| 22708 | } |  | 22660 | }
| 22709 |  |  | 22661 |
| 22710 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minThreshold(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22662 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_minThreshold(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22711 | { |  | 22663 | {
| 22712 | return pyopencv_from(p->v.minThreshold); |  | 22664 | return pyopencv_from(p->v.minThreshold);
| 22713 | } |  | 22665 | }
| 22714 |  |  | 22666 |
| 22715 | static int pyopencv_SimpleBlobDetector_Params_set_minThreshold(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22667 | static int pyopencv_SimpleBlobDetector_Params_set_minThreshold(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22716 | { |  | 22668 | {
| 22717 | if (!value) |  | 22669 | if (!value)
| 22718 | { |  | 22670 | {
| 22719 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minThreshold attribute"); |  | 22671 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minThreshold attribute");
| 22720 | return -1; |  | 22672 | return -1;
| 22721 | } |  | 22673 | }
| 22722 | return pyopencv_to_safe(value, p->v.minThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 22674 | return pyopencv_to_safe(value, p->v.minThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 22723 | } |  | 22675 | }
| 22724 |  |  | 22676 |
| 22725 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_thresholdStep(pyopencv_SimpleBlobDetector_Params_t* p, void *closure) |  | 22677 | static PyObject* pyopencv_SimpleBlobDetector_Params_get_thresholdStep(pyopencv_SimpleBlobDetector_Params_t* p, void *closure)
| 22726 | { |  | 22678 | {
| 22727 | return pyopencv_from(p->v.thresholdStep); |  | 22679 | return pyopencv_from(p->v.thresholdStep);
| 22728 | } |  | 22680 | }
| 22729 |  |  | 22681 |
| 22730 | static int pyopencv_SimpleBlobDetector_Params_set_thresholdStep(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure) |  | 22682 | static int pyopencv_SimpleBlobDetector_Params_set_thresholdStep(pyopencv_SimpleBlobDetector_Params_t* p, PyObject *value, void *closure)
| 22731 | { |  | 22683 | {
| 22732 | if (!value) |  | 22684 | if (!value)
| 22733 | { |  | 22685 | {
| 22734 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thresholdStep attribute"); |  | 22686 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thresholdStep attribute");
| 22735 | return -1; |  | 22687 | return -1;
| 22736 | } |  | 22688 | }
| 22737 | return pyopencv_to_safe(value, p->v.thresholdStep, ArgInfo("value", 0)) ? 0 : -1; |  | 22689 | return pyopencv_to_safe(value, p->v.thresholdStep, ArgInfo("value", 0)) ? 0 : -1;
| 22738 | } |  | 22690 | }
| 22739 |  |  | 22691 |
| 22740 |  |  | 22692 |
| 22741 | // Methods (SimpleBlobDetector_Params) |  | 22693 | // Methods (SimpleBlobDetector_Params)
| 22742 |  |  | 22694 |
| 22743 | static int pyopencv_cv_SimpleBlobDetector_Params_SimpleBlobDetector_Params(pyopencv_SimpleBlobDetector_Params_t* self, PyObject* py_args, PyObject* kw) |  | 22695 | static int pyopencv_cv_SimpleBlobDetector_Params_SimpleBlobDetector_Params(pyopencv_SimpleBlobDetector_Params_t* self, PyObject* py_args, PyObject* kw)
| 22744 | { |  | 22696 | {
| 22745 | using namespace cv; |  | 22697 | using namespace cv;
| 22746 |  |  | 22698 |
| 22747 |  |  | 22699 |
| 22748 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 22700 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 22749 | { |  | 22701 | {
| 22750 | if(self) ERRWRAP2(new (&(self->v)) cv::SimpleBlobDetector::Params()); |  | 22702 | if(self) ERRWRAP2(new (&(self->v)) cv::SimpleBlobDetector::Params());
| 22751 | return 0; |  | 22703 | return 0;
| 22752 | } |  | 22704 | }
| 22753 |  |  | 22705 |
| 22754 | return -1; |  | 22706 | return -1;
| 22755 | } |  | 22707 | }
| 22756 |  |  | 22708 |
| 22757 |  |  | 22709 |
| 22758 |  |  | 22710 |
| 22759 | // Tables (SimpleBlobDetector_Params) |  | 22711 | // Tables (SimpleBlobDetector_Params)
| 22760 |  |  | 22712 |
| 22761 | static PyGetSetDef pyopencv_SimpleBlobDetector_Params_getseters[] = |  | 22713 | static PyGetSetDef pyopencv_SimpleBlobDetector_Params_getseters[] =
| 22762 | { |  | 22714 | {
| 22763 | {(char*)"blobColor", (getter)pyopencv_SimpleBlobDetector_Params_get_blobColor, (setter)pyopencv_SimpleBlobDetector_Params_set_blobColor, (char*)"blobColor", NULL}, |  | 22715 | {(char*)"blobColor", (getter)pyopencv_SimpleBlobDetector_Params_get_blobColor, (setter)pyopencv_SimpleBlobDetector_Params_set_blobColor, (char*)"blobColor", NULL},
| 22764 | {(char*)"collectContours", (getter)pyopencv_SimpleBlobDetector_Params_get_collectContours, (setter)pyopencv_SimpleBlobDetector_Params_set_collectContours, (char*)"collectContours", NULL}, |  | 22716 | {(char*)"collectContours", (getter)pyopencv_SimpleBlobDetector_Params_get_collectContours, (setter)pyopencv_SimpleBlobDetector_Params_set_collectContours, (char*)"collectContours", NULL},
| 22765 | {(char*)"filterByArea", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByArea, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByArea, (char*)"filterByArea", NULL}, |  | 22717 | {(char*)"filterByArea", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByArea, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByArea, (char*)"filterByArea", NULL},
| 22766 | {(char*)"filterByCircularity", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByCircularity, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByCircularity, (char*)"filterByCircularity", NULL}, |  | 22718 | {(char*)"filterByCircularity", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByCircularity, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByCircularity, (char*)"filterByCircularity", NULL},
| 22767 | {(char*)"filterByColor", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByColor, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByColor, (char*)"filterByColor", NULL}, |  | 22719 | {(char*)"filterByColor", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByColor, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByColor, (char*)"filterByColor", NULL},
| 22768 | {(char*)"filterByConvexity", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByConvexity, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByConvexity, (char*)"filterByConvexity", NULL}, |  | 22720 | {(char*)"filterByConvexity", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByConvexity, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByConvexity, (char*)"filterByConvexity", NULL},
| 22769 | {(char*)"filterByInertia", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByInertia, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByInertia, (char*)"filterByInertia", NULL}, |  | 22721 | {(char*)"filterByInertia", (getter)pyopencv_SimpleBlobDetector_Params_get_filterByInertia, (setter)pyopencv_SimpleBlobDetector_Params_set_filterByInertia, (char*)"filterByInertia", NULL},
| 22770 | {(char*)"maxArea", (getter)pyopencv_SimpleBlobDetector_Params_get_maxArea, (setter)pyopencv_SimpleBlobDetector_Params_set_maxArea, (char*)"maxArea", NULL}, |  | 22722 | {(char*)"maxArea", (getter)pyopencv_SimpleBlobDetector_Params_get_maxArea, (setter)pyopencv_SimpleBlobDetector_Params_set_maxArea, (char*)"maxArea", NULL},
| 22771 | {(char*)"maxCircularity", (getter)pyopencv_SimpleBlobDetector_Params_get_maxCircularity, (setter)pyopencv_SimpleBlobDetector_Params_set_maxCircularity, (char*)"maxCircularity", NULL}, |  | 22723 | {(char*)"maxCircularity", (getter)pyopencv_SimpleBlobDetector_Params_get_maxCircularity, (setter)pyopencv_SimpleBlobDetector_Params_set_maxCircularity, (char*)"maxCircularity", NULL},
| 22772 | {(char*)"maxConvexity", (getter)pyopencv_SimpleBlobDetector_Params_get_maxConvexity, (setter)pyopencv_SimpleBlobDetector_Params_set_maxConvexity, (char*)"maxConvexity", NULL}, |  | 22724 | {(char*)"maxConvexity", (getter)pyopencv_SimpleBlobDetector_Params_get_maxConvexity, (setter)pyopencv_SimpleBlobDetector_Params_set_maxConvexity, (char*)"maxConvexity", NULL},
| 22773 | {(char*)"maxInertiaRatio", (getter)pyopencv_SimpleBlobDetector_Params_get_maxInertiaRatio, (setter)pyopencv_SimpleBlobDetector_Params_set_maxInertiaRatio, (char*)"maxInertiaRatio", NULL}, |  | 22725 | {(char*)"maxInertiaRatio", (getter)pyopencv_SimpleBlobDetector_Params_get_maxInertiaRatio, (setter)pyopencv_SimpleBlobDetector_Params_set_maxInertiaRatio, (char*)"maxInertiaRatio", NULL},
| 22774 | {(char*)"maxThreshold", (getter)pyopencv_SimpleBlobDetector_Params_get_maxThreshold, (setter)pyopencv_SimpleBlobDetector_Params_set_maxThreshold, (char*)"maxThreshold", NULL}, |  | 22726 | {(char*)"maxThreshold", (getter)pyopencv_SimpleBlobDetector_Params_get_maxThreshold, (setter)pyopencv_SimpleBlobDetector_Params_set_maxThreshold, (char*)"maxThreshold", NULL},
| 22775 | {(char*)"minArea", (getter)pyopencv_SimpleBlobDetector_Params_get_minArea, (setter)pyopencv_SimpleBlobDetector_Params_set_minArea, (char*)"minArea", NULL}, |  | 22727 | {(char*)"minArea", (getter)pyopencv_SimpleBlobDetector_Params_get_minArea, (setter)pyopencv_SimpleBlobDetector_Params_set_minArea, (char*)"minArea", NULL},
| 22776 | {(char*)"minCircularity", (getter)pyopencv_SimpleBlobDetector_Params_get_minCircularity, (setter)pyopencv_SimpleBlobDetector_Params_set_minCircularity, (char*)"minCircularity", NULL}, |  | 22728 | {(char*)"minCircularity", (getter)pyopencv_SimpleBlobDetector_Params_get_minCircularity, (setter)pyopencv_SimpleBlobDetector_Params_set_minCircularity, (char*)"minCircularity", NULL},
| 22777 | {(char*)"minConvexity", (getter)pyopencv_SimpleBlobDetector_Params_get_minConvexity, (setter)pyopencv_SimpleBlobDetector_Params_set_minConvexity, (char*)"minConvexity", NULL}, |  | 22729 | {(char*)"minConvexity", (getter)pyopencv_SimpleBlobDetector_Params_get_minConvexity, (setter)pyopencv_SimpleBlobDetector_Params_set_minConvexity, (char*)"minConvexity", NULL},
| 22778 | {(char*)"minDistBetweenBlobs", (getter)pyopencv_SimpleBlobDetector_Params_get_minDistBetweenBlobs, (setter)pyopencv_SimpleBlobDetector_Params_set_minDistBetweenBlobs, (char*)"minDistBetweenBlobs", NULL}, |  | 22730 | {(char*)"minDistBetweenBlobs", (getter)pyopencv_SimpleBlobDetector_Params_get_minDistBetweenBlobs, (setter)pyopencv_SimpleBlobDetector_Params_set_minDistBetweenBlobs, (char*)"minDistBetweenBlobs", NULL},
| 22779 | {(char*)"minInertiaRatio", (getter)pyopencv_SimpleBlobDetector_Params_get_minInertiaRatio, (setter)pyopencv_SimpleBlobDetector_Params_set_minInertiaRatio, (char*)"minInertiaRatio", NULL}, |  | 22731 | {(char*)"minInertiaRatio", (getter)pyopencv_SimpleBlobDetector_Params_get_minInertiaRatio, (setter)pyopencv_SimpleBlobDetector_Params_set_minInertiaRatio, (char*)"minInertiaRatio", NULL},
| 22780 | {(char*)"minRepeatability", (getter)pyopencv_SimpleBlobDetector_Params_get_minRepeatability, (setter)pyopencv_SimpleBlobDetector_Params_set_minRepeatability, (char*)"minRepeatability", NULL}, |  | 22732 | {(char*)"minRepeatability", (getter)pyopencv_SimpleBlobDetector_Params_get_minRepeatability, (setter)pyopencv_SimpleBlobDetector_Params_set_minRepeatability, (char*)"minRepeatability", NULL},
| 22781 | {(char*)"minThreshold", (getter)pyopencv_SimpleBlobDetector_Params_get_minThreshold, (setter)pyopencv_SimpleBlobDetector_Params_set_minThreshold, (char*)"minThreshold", NULL}, |  | 22733 | {(char*)"minThreshold", (getter)pyopencv_SimpleBlobDetector_Params_get_minThreshold, (setter)pyopencv_SimpleBlobDetector_Params_set_minThreshold, (char*)"minThreshold", NULL},
| 22782 | {(char*)"thresholdStep", (getter)pyopencv_SimpleBlobDetector_Params_get_thresholdStep, (setter)pyopencv_SimpleBlobDetector_Params_set_thresholdStep, (char*)"thresholdStep", NULL}, |  | 22734 | {(char*)"thresholdStep", (getter)pyopencv_SimpleBlobDetector_Params_get_thresholdStep, (setter)pyopencv_SimpleBlobDetector_Params_set_thresholdStep, (char*)"thresholdStep", NULL},
| 22783 | {NULL} /* Sentinel */ |  | 22735 | {NULL} /* Sentinel */
| 22784 | }; |  | 22736 | };
| 22785 |  |  | 22737 |
| 22786 | static PyMethodDef pyopencv_SimpleBlobDetector_Params_methods[] = |  | 22738 | static PyMethodDef pyopencv_SimpleBlobDetector_Params_methods[] =
| 22787 | { |  | 22739 | {
| 22788 |  |  | 22740 |
| 22789 | {NULL, NULL} |  | 22741 | {NULL, NULL}
| 22790 | }; |  | 22742 | };
| 22791 |  |  | 22743 |
| 22792 | // Converter (SimpleBlobDetector_Params) |  | 22744 | // Converter (SimpleBlobDetector_Params)
| 22793 |  |  | 22745 |
| 22794 | template<> |  | 22746 | template<>
| 22795 | struct PyOpenCV_Converter< cv::SimpleBlobDetector::Params > |  | 22747 | struct PyOpenCV_Converter< cv::SimpleBlobDetector::Params >
| 22796 | { |  | 22748 | {
| 22797 | static PyObject* from(const cv::SimpleBlobDetector::Params& r) |  | 22749 | static PyObject* from(const cv::SimpleBlobDetector::Params& r)
| 22798 | { |  | 22750 | {
| 22799 | return pyopencv_SimpleBlobDetector_Params_Instance(r); |  | 22751 | return pyopencv_SimpleBlobDetector_Params_Instance(r);
| 22800 | } |  | 22752 | }
| 22801 | static bool to(PyObject* src, cv::SimpleBlobDetector::Params& dst, const ArgInfo& info) |  | 22753 | static bool to(PyObject* src, cv::SimpleBlobDetector::Params& dst, const ArgInfo& info)
| 22802 | { |  | 22754 | {
| 22803 | if(!src || src == Py_None) |  | 22755 | if(!src || src == Py_None)
| 22804 | return true; |  | 22756 | return true;
| 22805 | cv::SimpleBlobDetector::Params * dst_; |  | 22757 | cv::SimpleBlobDetector::Params * dst_;
| 22806 | if (pyopencv_SimpleBlobDetector_Params_getp(src, dst_)) |  | 22758 | if (pyopencv_SimpleBlobDetector_Params_getp(src, dst_))
| 22807 | { |  | 22759 | {
| 22808 | dst = *dst_; |  | 22760 | dst = *dst_;
| 22809 | return true; |  | 22761 | return true;
| 22810 | } |  | 22762 | }
| 22811 |  |  | 22763 |
| 22812 | failmsg("Expected cv::SimpleBlobDetector::Params for argument '%s'", info.name); |  | 22764 | failmsg("Expected cv::SimpleBlobDetector::Params for argument '%s'", info.name);
| 22813 | return false; |  | 22765 | return false;
| 22814 | } |  | 22766 | }
| 22815 | }; |  | 22767 | };
| 22816 |  |  | 22768 |
| 22817 | //================================================================================ |  | 22769 | //================================================================================
| 22818 | // SparseOpticalFlow (Generic) |  | 22770 | // SparseOpticalFlow (Generic)
| 22819 | //================================================================================ |  | 22771 | //================================================================================
| 22820 |  |  | 22772 |
| 22821 | // GetSet (SparseOpticalFlow) |  | 22773 | // GetSet (SparseOpticalFlow)
| 22822 |  |  | 22774 |
| 22823 |  |  | 22775 |
| 22824 |  |  | 22776 |
| 22825 | // Methods (SparseOpticalFlow) |  | 22777 | // Methods (SparseOpticalFlow)
| 22826 |  |  | 22778 |
| 22827 | static PyObject* pyopencv_cv_SparseOpticalFlow_calc(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22779 | static PyObject* pyopencv_cv_SparseOpticalFlow_calc(PyObject* self, PyObject* py_args, PyObject* kw)
| 22828 | { |  | 22780 | {
| 22829 | using namespace cv; |  | 22781 | using namespace cv;
| 22830 |  |  | 22782 |
| 22831 |  |  | 22783 |
| 22832 | Ptr<cv::SparseOpticalFlow> * self1 = 0; |  | 22784 | Ptr<cv::SparseOpticalFlow> * self1 = 0;
| 22833 | if (!pyopencv_SparseOpticalFlow_getp(self, self1)) |  | 22785 | if (!pyopencv_SparseOpticalFlow_getp(self, self1))
| 22834 | return failmsgp("Incorrect type of self (must be 'SparseOpticalFlow' or its derivative)"); |  | 22786 | return failmsgp("Incorrect type of self (must be 'SparseOpticalFlow' or its derivative)");
| 22835 | Ptr<cv::SparseOpticalFlow> _self_ = *(self1); |  | 22787 | Ptr<cv::SparseOpticalFlow> _self_ = *(self1);
| 22836 | pyPrepareArgumentConversionErrorsStorage(2); |  | 22788 | pyPrepareArgumentConversionErrorsStorage(2);
| 22837 |  |  | 22789 |
| 22838 | { |  | 22790 | {
| 22839 | PyObject* pyobj_prevImg = NULL; |  | 22791 | PyObject* pyobj_prevImg = NULL;
| 22840 | Mat prevImg; |  | 22792 | Mat prevImg;
| 22841 | PyObject* pyobj_nextImg = NULL; |  | 22793 | PyObject* pyobj_nextImg = NULL;
| 22842 | Mat nextImg; |  | 22794 | Mat nextImg;
| 22843 | PyObject* pyobj_prevPts = NULL; |  | 22795 | PyObject* pyobj_prevPts = NULL;
| 22844 | Mat prevPts; |  | 22796 | Mat prevPts;
| 22845 | PyObject* pyobj_nextPts = NULL; |  | 22797 | PyObject* pyobj_nextPts = NULL;
| 22846 | Mat nextPts; |  | 22798 | Mat nextPts;
| 22847 | PyObject* pyobj_status = NULL; |  | 22799 | PyObject* pyobj_status = NULL;
| 22848 | Mat status; |  | 22800 | Mat status;
| 22849 | PyObject* pyobj_err = NULL; |  | 22801 | PyObject* pyobj_err = NULL;
| 22850 | Mat err; |  | 22802 | Mat err;
| 22851 |  |  | 22803 |
| 22852 | const char* keywords[] = { "prevImg", "nextImg", "prevPts", "nextPts", "status", "err", NULL }; |  | 22804 | const char* keywords[] = { "prevImg", "nextImg", "prevPts", "nextPts", "status", "err", NULL };
| 22853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:SparseOpticalFlow.calc", (char**)keywords, &pyobj_prevImg, &pyobj_nextImg, &pyobj_prevPts, &pyobj_nextPts, &pyobj_status, &pyobj_err) && |  | 22805 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:SparseOpticalFlow.calc", (char**)keywords, &pyobj_prevImg, &pyobj_nextImg, &pyobj_prevPts, &pyobj_nextPts, &pyobj_status, &pyobj_err) &&
| 22854 | pyopencv_to_safe(pyobj_prevImg, prevImg, ArgInfo("prevImg", 0)) && |  | 22806 | pyopencv_to_safe(pyobj_prevImg, prevImg, ArgInfo("prevImg", 0)) &&
| 22855 | pyopencv_to_safe(pyobj_nextImg, nextImg, ArgInfo("nextImg", 0)) && |  | 22807 | pyopencv_to_safe(pyobj_nextImg, nextImg, ArgInfo("nextImg", 0)) &&
| 22856 | pyopencv_to_safe(pyobj_prevPts, prevPts, ArgInfo("prevPts", 0)) && |  | 22808 | pyopencv_to_safe(pyobj_prevPts, prevPts, ArgInfo("prevPts", 0)) &&
| 22857 | pyopencv_to_safe(pyobj_nextPts, nextPts, ArgInfo("nextPts", 1)) && |  | 22809 | pyopencv_to_safe(pyobj_nextPts, nextPts, ArgInfo("nextPts", 1)) &&
| 22858 | pyopencv_to_safe(pyobj_status, status, ArgInfo("status", 1)) && |  | 22810 | pyopencv_to_safe(pyobj_status, status, ArgInfo("status", 1)) &&
| 22859 | pyopencv_to_safe(pyobj_err, err, ArgInfo("err", 1)) ) |  | 22811 | pyopencv_to_safe(pyobj_err, err, ArgInfo("err", 1)) )
| 22860 | { |  | 22812 | {
| 22861 | ERRWRAP2(_self_->calc(prevImg, nextImg, prevPts, nextPts, status, err)); |  | 22813 | ERRWRAP2(_self_->calc(prevImg, nextImg, prevPts, nextPts, status, err));
| 22862 | return Py_BuildValue("(NNN)", pyopencv_from(nextPts), pyopencv_from(status), pyopencv_from(err)); |  | 22814 | return Py_BuildValue("(NNN)", pyopencv_from(nextPts), pyopencv_from(status), pyopencv_from(err));
| 22863 | } |  | 22815 | }
| 22864 |  |  | 22816 |
| 22865 |  |  | 22817 |
| 22866 | pyPopulateArgumentConversionErrors(); |  | 22818 | pyPopulateArgumentConversionErrors();
| 22867 | } |  | 22819 | }
| 22868 |  |  | 22820 |
| 22869 |  |  | 22821 |
| 22870 | { |  | 22822 | {
| 22871 | PyObject* pyobj_prevImg = NULL; |  | 22823 | PyObject* pyobj_prevImg = NULL;
| 22872 | UMat prevImg; |  | 22824 | UMat prevImg;
| 22873 | PyObject* pyobj_nextImg = NULL; |  | 22825 | PyObject* pyobj_nextImg = NULL;
| 22874 | UMat nextImg; |  | 22826 | UMat nextImg;
| 22875 | PyObject* pyobj_prevPts = NULL; |  | 22827 | PyObject* pyobj_prevPts = NULL;
| 22876 | UMat prevPts; |  | 22828 | UMat prevPts;
| 22877 | PyObject* pyobj_nextPts = NULL; |  | 22829 | PyObject* pyobj_nextPts = NULL;
| 22878 | UMat nextPts; |  | 22830 | UMat nextPts;
| 22879 | PyObject* pyobj_status = NULL; |  | 22831 | PyObject* pyobj_status = NULL;
| 22880 | UMat status; |  | 22832 | UMat status;
| 22881 | PyObject* pyobj_err = NULL; |  | 22833 | PyObject* pyobj_err = NULL;
| 22882 | UMat err; |  | 22834 | UMat err;
| 22883 |  |  | 22835 |
| 22884 | const char* keywords[] = { "prevImg", "nextImg", "prevPts", "nextPts", "status", "err", NULL }; |  | 22836 | const char* keywords[] = { "prevImg", "nextImg", "prevPts", "nextPts", "status", "err", NULL };
| 22885 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:SparseOpticalFlow.calc", (char**)keywords, &pyobj_prevImg, &pyobj_nextImg, &pyobj_prevPts, &pyobj_nextPts, &pyobj_status, &pyobj_err) && |  | 22837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:SparseOpticalFlow.calc", (char**)keywords, &pyobj_prevImg, &pyobj_nextImg, &pyobj_prevPts, &pyobj_nextPts, &pyobj_status, &pyobj_err) &&
| 22886 | pyopencv_to_safe(pyobj_prevImg, prevImg, ArgInfo("prevImg", 0)) && |  | 22838 | pyopencv_to_safe(pyobj_prevImg, prevImg, ArgInfo("prevImg", 0)) &&
| 22887 | pyopencv_to_safe(pyobj_nextImg, nextImg, ArgInfo("nextImg", 0)) && |  | 22839 | pyopencv_to_safe(pyobj_nextImg, nextImg, ArgInfo("nextImg", 0)) &&
| 22888 | pyopencv_to_safe(pyobj_prevPts, prevPts, ArgInfo("prevPts", 0)) && |  | 22840 | pyopencv_to_safe(pyobj_prevPts, prevPts, ArgInfo("prevPts", 0)) &&
| 22889 | pyopencv_to_safe(pyobj_nextPts, nextPts, ArgInfo("nextPts", 1)) && |  | 22841 | pyopencv_to_safe(pyobj_nextPts, nextPts, ArgInfo("nextPts", 1)) &&
| 22890 | pyopencv_to_safe(pyobj_status, status, ArgInfo("status", 1)) && |  | 22842 | pyopencv_to_safe(pyobj_status, status, ArgInfo("status", 1)) &&
| 22891 | pyopencv_to_safe(pyobj_err, err, ArgInfo("err", 1)) ) |  | 22843 | pyopencv_to_safe(pyobj_err, err, ArgInfo("err", 1)) )
| 22892 | { |  | 22844 | {
| 22893 | ERRWRAP2(_self_->calc(prevImg, nextImg, prevPts, nextPts, status, err)); |  | 22845 | ERRWRAP2(_self_->calc(prevImg, nextImg, prevPts, nextPts, status, err));
| 22894 | return Py_BuildValue("(NNN)", pyopencv_from(nextPts), pyopencv_from(status), pyopencv_from(err)); |  | 22846 | return Py_BuildValue("(NNN)", pyopencv_from(nextPts), pyopencv_from(status), pyopencv_from(err));
| 22895 | } |  | 22847 | }
| 22896 |  |  | 22848 |
| 22897 |  |  | 22849 |
| 22898 | pyPopulateArgumentConversionErrors(); |  | 22850 | pyPopulateArgumentConversionErrors();
| 22899 | } |  | 22851 | }
| 22900 | pyRaiseCVOverloadException("calc"); |  | 22852 | pyRaiseCVOverloadException("calc");
| 22901 |  |  | 22853 |
| 22902 | return NULL; |  | 22854 | return NULL;
| 22903 | } |  | 22855 | }
| 22904 |  |  | 22856 |
| 22905 |  |  | 22857 |
| 22906 |  |  | 22858 |
| 22907 | // Tables (SparseOpticalFlow) |  | 22859 | // Tables (SparseOpticalFlow)
| 22908 |  |  | 22860 |
| 22909 | static PyGetSetDef pyopencv_SparseOpticalFlow_getseters[] = |  | 22861 | static PyGetSetDef pyopencv_SparseOpticalFlow_getseters[] =
| 22910 | { |  | 22862 | {
| 22911 | {NULL} /* Sentinel */ |  | 22863 | {NULL} /* Sentinel */
| 22912 | }; |  | 22864 | };
| 22913 |  |  | 22865 |
| 22914 | static PyMethodDef pyopencv_SparseOpticalFlow_methods[] = |  | 22866 | static PyMethodDef pyopencv_SparseOpticalFlow_methods[] =
| 22915 | { |  | 22867 | {
| 22916 | {"calc", CV_PY_FN_WITH_KW_(pyopencv_cv_SparseOpticalFlow_calc, 0), "calc(prevImg, nextImg, prevPts, nextPts[, status[, err]]) -> nextPts, status, err\n. @brief Calculates a sparse optical flow.\n. \n. @param prevImg First input image.\n. @param nextImg Second input image of the same size and the same type as prevImg.\n. @param prevPts Vector of 2D points for which the flow needs to be found.\n. @param nextPts Output vector of 2D points containing the calculated new positions of input features in the second image.\n. @param status Output status vector. Each element of the vector is set to 1 if the\n. flow for the corresponding features has been found. Otherwise, it is set to 0.\n. @param err Optional output vector that contains error response for each point (inverse confidence)."}, |  | 22868 | {"calc", CV_PY_FN_WITH_KW_(pyopencv_cv_SparseOpticalFlow_calc, 0), "calc(prevImg, nextImg, prevPts, nextPts[, status[, err]]) -> nextPts, status, err\n. @brief Calculates a sparse optical flow.\n. \n. @param prevImg First input image.\n. @param nextImg Second input image of the same size and the same type as prevImg.\n. @param prevPts Vector of 2D points for which the flow needs to be found.\n. @param nextPts Output vector of 2D points containing the calculated new positions of input features in the second image.\n. @param status Output status vector. Each element of the vector is set to 1 if the\n. flow for the corresponding features has been found. Otherwise, it is set to 0.\n. @param err Optional output vector that contains error response for each point (inverse confidence)."},
| 22917 |  |  | 22869 |
| 22918 | {NULL, NULL} |  | 22870 | {NULL, NULL}
| 22919 | }; |  | 22871 | };
| 22920 |  |  | 22872 |
| 22921 | // Converter (SparseOpticalFlow) |  | 22873 | // Converter (SparseOpticalFlow)
| 22922 |  |  | 22874 |
| 22923 | template<> |  | 22875 | template<>
| 22924 | struct PyOpenCV_Converter< Ptr<cv::SparseOpticalFlow> > |  | 22876 | struct PyOpenCV_Converter< Ptr<cv::SparseOpticalFlow> >
| 22925 | { |  | 22877 | {
| 22926 | static PyObject* from(const Ptr<cv::SparseOpticalFlow>& r) |  | 22878 | static PyObject* from(const Ptr<cv::SparseOpticalFlow>& r)
| 22927 | { |  | 22879 | {
| 22928 | return pyopencv_SparseOpticalFlow_Instance(r); |  | 22880 | return pyopencv_SparseOpticalFlow_Instance(r);
| 22929 | } |  | 22881 | }
| 22930 | static bool to(PyObject* src, Ptr<cv::SparseOpticalFlow>& dst, const ArgInfo& info) |  | 22882 | static bool to(PyObject* src, Ptr<cv::SparseOpticalFlow>& dst, const ArgInfo& info)
| 22931 | { |  | 22883 | {
| 22932 | if(!src || src == Py_None) |  | 22884 | if(!src || src == Py_None)
| 22933 | return true; |  | 22885 | return true;
| 22934 | Ptr<cv::SparseOpticalFlow> * dst_; |  | 22886 | Ptr<cv::SparseOpticalFlow> * dst_;
| 22935 | if (pyopencv_SparseOpticalFlow_getp(src, dst_)) |  | 22887 | if (pyopencv_SparseOpticalFlow_getp(src, dst_))
| 22936 | { |  | 22888 | {
| 22937 | dst = *dst_; |  | 22889 | dst = *dst_;
| 22938 | return true; |  | 22890 | return true;
| 22939 | } |  | 22891 | }
| 22940 |  |  | 22892 |
| 22941 | failmsg("Expected Ptr<cv::SparseOpticalFlow> for argument '%s'", info.name); |  | 22893 | failmsg("Expected Ptr<cv::SparseOpticalFlow> for argument '%s'", info.name);
| 22942 | return false; |  | 22894 | return false;
| 22943 | } |  | 22895 | }
| 22944 | }; |  | 22896 | };
| 22945 |  |  | 22897 |
| 22946 | //================================================================================ |  | 22898 | //================================================================================
| 22947 | // SparsePyrLKOpticalFlow (Generic) |  | 22899 | // SparsePyrLKOpticalFlow (Generic)
| 22948 | //================================================================================ |  | 22900 | //================================================================================
| 22949 |  |  | 22901 |
| 22950 | // GetSet (SparsePyrLKOpticalFlow) |  | 22902 | // GetSet (SparsePyrLKOpticalFlow)
| 22951 |  |  | 22903 |
| 22952 |  |  | 22904 |
| 22953 |  |  | 22905 |
| 22954 | // Methods (SparsePyrLKOpticalFlow) |  | 22906 | // Methods (SparsePyrLKOpticalFlow)
| 22955 |  |  | 22907 |
| 22956 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22908 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 22957 | { |  | 22909 | {
| 22958 | using namespace cv; |  | 22910 | using namespace cv;
| 22959 |  |  | 22911 |
| 22960 | PyObject* pyobj_winSize = NULL; |  | 22912 | PyObject* pyobj_winSize = NULL;
| 22961 | Size winSize=Size(21, 21); |  | 22913 | Size winSize=Size(21, 21);
| 22962 | PyObject* pyobj_maxLevel = NULL; |  | 22914 | PyObject* pyobj_maxLevel = NULL;
| 22963 | int maxLevel=3; |  | 22915 | int maxLevel=3;
| 22964 | PyObject* pyobj_crit = NULL; |  | 22916 | PyObject* pyobj_crit = NULL;
| 22965 | TermCriteria crit=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01); |  | 22917 | TermCriteria crit=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01);
| 22966 | PyObject* pyobj_flags = NULL; |  | 22918 | PyObject* pyobj_flags = NULL;
| 22967 | int flags=0; |  | 22919 | int flags=0;
| 22968 | PyObject* pyobj_minEigThreshold = NULL; |  | 22920 | PyObject* pyobj_minEigThreshold = NULL;
| 22969 | double minEigThreshold=1e-4; |  | 22921 | double minEigThreshold=1e-4;
| 22970 | Ptr<SparsePyrLKOpticalFlow> retval; |  | 22922 | Ptr<SparsePyrLKOpticalFlow> retval;
| 22971 |  |  | 22923 |
| 22972 | const char* keywords[] = { "winSize", "maxLevel", "crit", "flags", "minEigThreshold", NULL }; |  | 22924 | const char* keywords[] = { "winSize", "maxLevel", "crit", "flags", "minEigThreshold", NULL };
| 22973 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:SparsePyrLKOpticalFlow.create", (char**)keywords, &pyobj_winSize, &pyobj_maxLevel, &pyobj_crit, &pyobj_flags, &pyobj_minEigThreshold) && |  | 22925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:SparsePyrLKOpticalFlow.create", (char**)keywords, &pyobj_winSize, &pyobj_maxLevel, &pyobj_crit, &pyobj_flags, &pyobj_minEigThreshold) &&
| 22974 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) && |  | 22926 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) &&
| 22975 | pyopencv_to_safe(pyobj_maxLevel, maxLevel, ArgInfo("maxLevel", 0)) && |  | 22927 | pyopencv_to_safe(pyobj_maxLevel, maxLevel, ArgInfo("maxLevel", 0)) &&
| 22976 | pyopencv_to_safe(pyobj_crit, crit, ArgInfo("crit", 0)) && |  | 22928 | pyopencv_to_safe(pyobj_crit, crit, ArgInfo("crit", 0)) &&
| 22977 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) && |  | 22929 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) &&
| 22978 | pyopencv_to_safe(pyobj_minEigThreshold, minEigThreshold, ArgInfo("minEigThreshold", 0)) ) |  | 22930 | pyopencv_to_safe(pyobj_minEigThreshold, minEigThreshold, ArgInfo("minEigThreshold", 0)) )
| 22979 | { |  | 22931 | {
| 22980 | ERRWRAP2(retval = cv::SparsePyrLKOpticalFlow::create(winSize, maxLevel, crit, flags, minEigThreshold)); |  | 22932 | ERRWRAP2(retval = cv::SparsePyrLKOpticalFlow::create(winSize, maxLevel, crit, flags, minEigThreshold));
| 22981 | return pyopencv_from(retval); |  | 22933 | return pyopencv_from(retval);
| 22982 | } |  | 22934 | }
| 22983 |  |  | 22935 |
| 22984 | return NULL; |  | 22936 | return NULL;
| 22985 | } |  | 22937 | }
| 22986 |  |  | 22938 |
| 22987 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getFlags(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22939 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getFlags(PyObject* self, PyObject* py_args, PyObject* kw)
| 22988 | { |  | 22940 | {
| 22989 | using namespace cv; |  | 22941 | using namespace cv;
| 22990 |  |  | 22942 |
| 22991 |  |  | 22943 |
| 22992 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 22944 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 22993 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 22945 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 22994 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 22946 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 22995 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 22947 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 22996 | int retval; |  | 22948 | int retval;
| 22997 |  |  | 22949 |
| 22998 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 22950 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 22999 | { |  | 22951 | {
| 23000 | ERRWRAP2(retval = _self_->getFlags()); |  | 22952 | ERRWRAP2(retval = _self_->getFlags());
| 23001 | return pyopencv_from(retval); |  | 22953 | return pyopencv_from(retval);
| 23002 | } |  | 22954 | }
| 23003 |  |  | 22955 |
| 23004 | return NULL; |  | 22956 | return NULL;
| 23005 | } |  | 22957 | }
| 23006 |  |  | 22958 |
| 23007 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22959 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 23008 | { |  | 22960 | {
| 23009 | using namespace cv; |  | 22961 | using namespace cv;
| 23010 |  |  | 22962 |
| 23011 |  |  | 22963 |
| 23012 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 22964 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23013 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 22965 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23014 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 22966 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23015 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 22967 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23016 | int retval; |  | 22968 | int retval;
| 23017 |  |  | 22969 |
| 23018 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 22970 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23019 | { |  | 22971 | {
| 23020 | ERRWRAP2(retval = _self_->getMaxLevel()); |  | 22972 | ERRWRAP2(retval = _self_->getMaxLevel());
| 23021 | return pyopencv_from(retval); |  | 22973 | return pyopencv_from(retval);
| 23022 | } |  | 22974 | }
| 23023 |  |  | 22975 |
| 23024 | return NULL; |  | 22976 | return NULL;
| 23025 | } |  | 22977 | }
| 23026 |  |  | 22978 |
| 23027 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getMinEigThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22979 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getMinEigThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 23028 | { |  | 22980 | {
| 23029 | using namespace cv; |  | 22981 | using namespace cv;
| 23030 |  |  | 22982 |
| 23031 |  |  | 22983 |
| 23032 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 22984 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23033 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 22985 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23034 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 22986 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23035 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 22987 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23036 | double retval; |  | 22988 | double retval;
| 23037 |  |  | 22989 |
| 23038 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 22990 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23039 | { |  | 22991 | {
| 23040 | ERRWRAP2(retval = _self_->getMinEigThreshold()); |  | 22992 | ERRWRAP2(retval = _self_->getMinEigThreshold());
| 23041 | return pyopencv_from(retval); |  | 22993 | return pyopencv_from(retval);
| 23042 | } |  | 22994 | }
| 23043 |  |  | 22995 |
| 23044 | return NULL; |  | 22996 | return NULL;
| 23045 | } |  | 22997 | }
| 23046 |  |  | 22998 |
| 23047 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 22999 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 23048 | { |  | 23000 | {
| 23049 | using namespace cv; |  | 23001 | using namespace cv;
| 23050 |  |  | 23002 |
| 23051 |  |  | 23003 |
| 23052 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 23004 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23053 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 23005 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23054 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 23006 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23055 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 23007 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23056 | TermCriteria retval; |  | 23008 | TermCriteria retval;
| 23057 |  |  | 23009 |
| 23058 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23010 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23059 | { |  | 23011 | {
| 23060 | ERRWRAP2(retval = _self_->getTermCriteria()); |  | 23012 | ERRWRAP2(retval = _self_->getTermCriteria());
| 23061 | return pyopencv_from(retval); |  | 23013 | return pyopencv_from(retval);
| 23062 | } |  | 23014 | }
| 23063 |  |  | 23015 |
| 23064 | return NULL; |  | 23016 | return NULL;
| 23065 | } |  | 23017 | }
| 23066 |  |  | 23018 |
| 23067 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23019 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_getWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23068 | { |  | 23020 | {
| 23069 | using namespace cv; |  | 23021 | using namespace cv;
| 23070 |  |  | 23022 |
| 23071 |  |  | 23023 |
| 23072 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 23024 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23073 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 23025 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23074 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 23026 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23075 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 23027 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23076 | Size retval; |  | 23028 | Size retval;
| 23077 |  |  | 23029 |
| 23078 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23030 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23079 | { |  | 23031 | {
| 23080 | ERRWRAP2(retval = _self_->getWinSize()); |  | 23032 | ERRWRAP2(retval = _self_->getWinSize());
| 23081 | return pyopencv_from(retval); |  | 23033 | return pyopencv_from(retval);
| 23082 | } |  | 23034 | }
| 23083 |  |  | 23035 |
| 23084 | return NULL; |  | 23036 | return NULL;
| 23085 | } |  | 23037 | }
| 23086 |  |  | 23038 |
| 23087 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setFlags(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23039 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setFlags(PyObject* self, PyObject* py_args, PyObject* kw)
| 23088 | { |  | 23040 | {
| 23089 | using namespace cv; |  | 23041 | using namespace cv;
| 23090 |  |  | 23042 |
| 23091 |  |  | 23043 |
| 23092 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 23044 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23093 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 23045 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23094 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 23046 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23095 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 23047 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23096 | PyObject* pyobj_flags = NULL; |  | 23048 | PyObject* pyobj_flags = NULL;
| 23097 | int flags=0; |  | 23049 | int flags=0;
| 23098 |  |  | 23050 |
| 23099 | const char* keywords[] = { "flags", NULL }; |  | 23051 | const char* keywords[] = { "flags", NULL };
| 23100 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setFlags", (char**)keywords, &pyobj_flags) && |  | 23052 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setFlags", (char**)keywords, &pyobj_flags) &&
| 23101 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 23053 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 23102 | { |  | 23054 | {
| 23103 | ERRWRAP2(_self_->setFlags(flags)); |  | 23055 | ERRWRAP2(_self_->setFlags(flags));
| 23104 | Py_RETURN_NONE; |  | 23056 | Py_RETURN_NONE;
| 23105 | } |  | 23057 | }
| 23106 |  |  | 23058 |
| 23107 | return NULL; |  | 23059 | return NULL;
| 23108 | } |  | 23060 | }
| 23109 |  |  | 23061 |
| 23110 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23062 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 23111 | { |  | 23063 | {
| 23112 | using namespace cv; |  | 23064 | using namespace cv;
| 23113 |  |  | 23065 |
| 23114 |  |  | 23066 |
| 23115 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 23067 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23116 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 23068 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23117 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 23069 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23118 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 23070 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23119 | PyObject* pyobj_maxLevel = NULL; |  | 23071 | PyObject* pyobj_maxLevel = NULL;
| 23120 | int maxLevel=0; |  | 23072 | int maxLevel=0;
| 23121 |  |  | 23073 |
| 23122 | const char* keywords[] = { "maxLevel", NULL }; |  | 23074 | const char* keywords[] = { "maxLevel", NULL };
| 23123 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setMaxLevel", (char**)keywords, &pyobj_maxLevel) && |  | 23075 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setMaxLevel", (char**)keywords, &pyobj_maxLevel) &&
| 23124 | pyopencv_to_safe(pyobj_maxLevel, maxLevel, ArgInfo("maxLevel", 0)) ) |  | 23076 | pyopencv_to_safe(pyobj_maxLevel, maxLevel, ArgInfo("maxLevel", 0)) )
| 23125 | { |  | 23077 | {
| 23126 | ERRWRAP2(_self_->setMaxLevel(maxLevel)); |  | 23078 | ERRWRAP2(_self_->setMaxLevel(maxLevel));
| 23127 | Py_RETURN_NONE; |  | 23079 | Py_RETURN_NONE;
| 23128 | } |  | 23080 | }
| 23129 |  |  | 23081 |
| 23130 | return NULL; |  | 23082 | return NULL;
| 23131 | } |  | 23083 | }
| 23132 |  |  | 23084 |
| 23133 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setMinEigThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23085 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setMinEigThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 23134 | { |  | 23086 | {
| 23135 | using namespace cv; |  | 23087 | using namespace cv;
| 23136 |  |  | 23088 |
| 23137 |  |  | 23089 |
| 23138 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 23090 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23139 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 23091 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23140 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 23092 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23141 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 23093 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23142 | PyObject* pyobj_minEigThreshold = NULL; |  | 23094 | PyObject* pyobj_minEigThreshold = NULL;
| 23143 | double minEigThreshold=0; |  | 23095 | double minEigThreshold=0;
| 23144 |  |  | 23096 |
| 23145 | const char* keywords[] = { "minEigThreshold", NULL }; |  | 23097 | const char* keywords[] = { "minEigThreshold", NULL };
| 23146 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setMinEigThreshold", (char**)keywords, &pyobj_minEigThreshold) && |  | 23098 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setMinEigThreshold", (char**)keywords, &pyobj_minEigThreshold) &&
| 23147 | pyopencv_to_safe(pyobj_minEigThreshold, minEigThreshold, ArgInfo("minEigThreshold", 0)) ) |  | 23099 | pyopencv_to_safe(pyobj_minEigThreshold, minEigThreshold, ArgInfo("minEigThreshold", 0)) )
| 23148 | { |  | 23100 | {
| 23149 | ERRWRAP2(_self_->setMinEigThreshold(minEigThreshold)); |  | 23101 | ERRWRAP2(_self_->setMinEigThreshold(minEigThreshold));
| 23150 | Py_RETURN_NONE; |  | 23102 | Py_RETURN_NONE;
| 23151 | } |  | 23103 | }
| 23152 |  |  | 23104 |
| 23153 | return NULL; |  | 23105 | return NULL;
| 23154 | } |  | 23106 | }
| 23155 |  |  | 23107 |
| 23156 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23108 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 23157 | { |  | 23109 | {
| 23158 | using namespace cv; |  | 23110 | using namespace cv;
| 23159 |  |  | 23111 |
| 23160 |  |  | 23112 |
| 23161 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 23113 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23162 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 23114 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23163 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 23115 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23164 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 23116 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23165 | PyObject* pyobj_crit = NULL; |  | 23117 | PyObject* pyobj_crit = NULL;
| 23166 | TermCriteria crit; |  | 23118 | TermCriteria crit;
| 23167 |  |  | 23119 |
| 23168 | const char* keywords[] = { "crit", NULL }; |  | 23120 | const char* keywords[] = { "crit", NULL };
| 23169 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setTermCriteria", (char**)keywords, &pyobj_crit) && |  | 23121 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setTermCriteria", (char**)keywords, &pyobj_crit) &&
| 23170 | pyopencv_to_safe(pyobj_crit, crit, ArgInfo("crit", 0)) ) |  | 23122 | pyopencv_to_safe(pyobj_crit, crit, ArgInfo("crit", 0)) )
| 23171 | { |  | 23123 | {
| 23172 | ERRWRAP2(_self_->setTermCriteria(crit)); |  | 23124 | ERRWRAP2(_self_->setTermCriteria(crit));
| 23173 | Py_RETURN_NONE; |  | 23125 | Py_RETURN_NONE;
| 23174 | } |  | 23126 | }
| 23175 |  |  | 23127 |
| 23176 | return NULL; |  | 23128 | return NULL;
| 23177 | } |  | 23129 | }
| 23178 |  |  | 23130 |
| 23179 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23131 | static PyObject* pyopencv_cv_SparsePyrLKOpticalFlow_setWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23180 | { |  | 23132 | {
| 23181 | using namespace cv; |  | 23133 | using namespace cv;
| 23182 |  |  | 23134 |
| 23183 |  |  | 23135 |
| 23184 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0; |  | 23136 | Ptr<cv::SparsePyrLKOpticalFlow> * self1 = 0;
| 23185 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1)) |  | 23137 | if (!pyopencv_SparsePyrLKOpticalFlow_getp(self, self1))
| 23186 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)"); |  | 23138 | return failmsgp("Incorrect type of self (must be 'SparsePyrLKOpticalFlow' or its derivative)");
| 23187 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1); |  | 23139 | Ptr<cv::SparsePyrLKOpticalFlow> _self_ = *(self1);
| 23188 | PyObject* pyobj_winSize = NULL; |  | 23140 | PyObject* pyobj_winSize = NULL;
| 23189 | Size winSize; |  | 23141 | Size winSize;
| 23190 |  |  | 23142 |
| 23191 | const char* keywords[] = { "winSize", NULL }; |  | 23143 | const char* keywords[] = { "winSize", NULL };
| 23192 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setWinSize", (char**)keywords, &pyobj_winSize) && |  | 23144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SparsePyrLKOpticalFlow.setWinSize", (char**)keywords, &pyobj_winSize) &&
| 23193 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) ) |  | 23145 | pyopencv_to_safe(pyobj_winSize, winSize, ArgInfo("winSize", 0)) )
| 23194 | { |  | 23146 | {
| 23195 | ERRWRAP2(_self_->setWinSize(winSize)); |  | 23147 | ERRWRAP2(_self_->setWinSize(winSize));
| 23196 | Py_RETURN_NONE; |  | 23148 | Py_RETURN_NONE;
| 23197 | } |  | 23149 | }
| 23198 |  |  | 23150 |
| 23199 | return NULL; |  | 23151 | return NULL;
| 23200 | } |  | 23152 | }
| 23201 |  |  | 23153 |
| 23202 |  |  | 23154 |
| 23203 |  |  | 23155 |
| 23204 | // Tables (SparsePyrLKOpticalFlow) |  | 23156 | // Tables (SparsePyrLKOpticalFlow)
| 23205 |  |  | 23157 |
| 23206 | static PyGetSetDef pyopencv_SparsePyrLKOpticalFlow_getseters[] = |  | 23158 | static PyGetSetDef pyopencv_SparsePyrLKOpticalFlow_getseters[] =
| 23207 | { |  | 23159 | {
| 23208 | {NULL} /* Sentinel */ |  | 23160 | {NULL} /* Sentinel */
| 23209 | }; |  | 23161 | };
| 23210 |  |  | 23162 |
| 23211 | static PyMethodDef pyopencv_SparsePyrLKOpticalFlow_methods[] = |  | 23163 | static PyMethodDef pyopencv_SparsePyrLKOpticalFlow_methods[] =
| 23212 | { |  | 23164 | {
| 23213 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_create_static, METH_STATIC), "create([, winSize[, maxLevel[, crit[, flags[, minEigThreshold]]]]]) -> retval\n."}, |  | 23165 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_create_static, METH_STATIC), "create([, winSize[, maxLevel[, crit[, flags[, minEigThreshold]]]]]) -> retval\n."},
| 23214 | {"getFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getFlags, 0), "getFlags() -> retval\n."}, |  | 23166 | {"getFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getFlags, 0), "getFlags() -> retval\n."},
| 23215 | {"getMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getMaxLevel, 0), "getMaxLevel() -> retval\n."}, |  | 23167 | {"getMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getMaxLevel, 0), "getMaxLevel() -> retval\n."},
| 23216 | {"getMinEigThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getMinEigThreshold, 0), "getMinEigThreshold() -> retval\n."}, |  | 23168 | {"getMinEigThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getMinEigThreshold, 0), "getMinEigThreshold() -> retval\n."},
| 23217 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getTermCriteria, 0), "getTermCriteria() -> retval\n."}, |  | 23169 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getTermCriteria, 0), "getTermCriteria() -> retval\n."},
| 23218 | {"getWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getWinSize, 0), "getWinSize() -> retval\n."}, |  | 23170 | {"getWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_getWinSize, 0), "getWinSize() -> retval\n."},
| 23219 | {"setFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setFlags, 0), "setFlags(flags) -> None\n."}, |  | 23171 | {"setFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setFlags, 0), "setFlags(flags) -> None\n."},
| 23220 | {"setMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setMaxLevel, 0), "setMaxLevel(maxLevel) -> None\n."}, |  | 23172 | {"setMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setMaxLevel, 0), "setMaxLevel(maxLevel) -> None\n."},
| 23221 | {"setMinEigThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setMinEigThreshold, 0), "setMinEigThreshold(minEigThreshold) -> None\n."}, |  | 23173 | {"setMinEigThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setMinEigThreshold, 0), "setMinEigThreshold(minEigThreshold) -> None\n."},
| 23222 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setTermCriteria, 0), "setTermCriteria(crit) -> None\n."}, |  | 23174 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setTermCriteria, 0), "setTermCriteria(crit) -> None\n."},
| 23223 | {"setWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setWinSize, 0), "setWinSize(winSize) -> None\n."}, |  | 23175 | {"setWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_SparsePyrLKOpticalFlow_setWinSize, 0), "setWinSize(winSize) -> None\n."},
| 23224 |  |  | 23176 |
| 23225 | {NULL, NULL} |  | 23177 | {NULL, NULL}
| 23226 | }; |  | 23178 | };
| 23227 |  |  | 23179 |
| 23228 | // Converter (SparsePyrLKOpticalFlow) |  | 23180 | // Converter (SparsePyrLKOpticalFlow)
| 23229 |  |  | 23181 |
| 23230 | template<> |  | 23182 | template<>
| 23231 | struct PyOpenCV_Converter< Ptr<cv::SparsePyrLKOpticalFlow> > |  | 23183 | struct PyOpenCV_Converter< Ptr<cv::SparsePyrLKOpticalFlow> >
| 23232 | { |  | 23184 | {
| 23233 | static PyObject* from(const Ptr<cv::SparsePyrLKOpticalFlow>& r) |  | 23185 | static PyObject* from(const Ptr<cv::SparsePyrLKOpticalFlow>& r)
| 23234 | { |  | 23186 | {
| 23235 | return pyopencv_SparsePyrLKOpticalFlow_Instance(r); |  | 23187 | return pyopencv_SparsePyrLKOpticalFlow_Instance(r);
| 23236 | } |  | 23188 | }
| 23237 | static bool to(PyObject* src, Ptr<cv::SparsePyrLKOpticalFlow>& dst, const ArgInfo& info) |  | 23189 | static bool to(PyObject* src, Ptr<cv::SparsePyrLKOpticalFlow>& dst, const ArgInfo& info)
| 23238 | { |  | 23190 | {
| 23239 | if(!src || src == Py_None) |  | 23191 | if(!src || src == Py_None)
| 23240 | return true; |  | 23192 | return true;
| 23241 | Ptr<cv::SparsePyrLKOpticalFlow> * dst_; |  | 23193 | Ptr<cv::SparsePyrLKOpticalFlow> * dst_;
| 23242 | if (pyopencv_SparsePyrLKOpticalFlow_getp(src, dst_)) |  | 23194 | if (pyopencv_SparsePyrLKOpticalFlow_getp(src, dst_))
| 23243 | { |  | 23195 | {
| 23244 | dst = *dst_; |  | 23196 | dst = *dst_;
| 23245 | return true; |  | 23197 | return true;
| 23246 | } |  | 23198 | }
| 23247 |  |  | 23199 |
| 23248 | failmsg("Expected Ptr<cv::SparsePyrLKOpticalFlow> for argument '%s'", info.name); |  | 23200 | failmsg("Expected Ptr<cv::SparsePyrLKOpticalFlow> for argument '%s'", info.name);
| 23249 | return false; |  | 23201 | return false;
| 23250 | } |  | 23202 | }
| 23251 | }; |  | 23203 | };
| 23252 |  |  | 23204 |
| 23253 | //================================================================================ |  | 23205 | //================================================================================
| 23254 | // StereoBM (Generic) |  | 23206 | // StereoBM (Generic)
| 23255 | //================================================================================ |  | 23207 | //================================================================================
| 23256 |  |  | 23208 |
| 23257 | // GetSet (StereoBM) |  | 23209 | // GetSet (StereoBM)
| 23258 |  |  | 23210 |
| 23259 |  |  | 23211 |
| 23260 |  |  | 23212 |
| 23261 | // Methods (StereoBM) |  | 23213 | // Methods (StereoBM)
| 23262 |  |  | 23214 |
| 23263 | static PyObject* pyopencv_cv_StereoBM_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23215 | static PyObject* pyopencv_cv_StereoBM_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 23264 | { |  | 23216 | {
| 23265 | using namespace cv; |  | 23217 | using namespace cv;
| 23266 |  |  | 23218 |
| 23267 | PyObject* pyobj_numDisparities = NULL; |  | 23219 | PyObject* pyobj_numDisparities = NULL;
| 23268 | int numDisparities=0; |  | 23220 | int numDisparities=0;
| 23269 | PyObject* pyobj_blockSize = NULL; |  | 23221 | PyObject* pyobj_blockSize = NULL;
| 23270 | int blockSize=21; |  | 23222 | int blockSize=21;
| 23271 | Ptr<StereoBM> retval; |  | 23223 | Ptr<StereoBM> retval;
| 23272 |  |  | 23224 |
| 23273 | const char* keywords[] = { "numDisparities", "blockSize", NULL }; |  | 23225 | const char* keywords[] = { "numDisparities", "blockSize", NULL };
| 23274 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:StereoBM.create", (char**)keywords, &pyobj_numDisparities, &pyobj_blockSize) && |  | 23226 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:StereoBM.create", (char**)keywords, &pyobj_numDisparities, &pyobj_blockSize) &&
| 23275 | pyopencv_to_safe(pyobj_numDisparities, numDisparities, ArgInfo("numDisparities", 0)) && |  | 23227 | pyopencv_to_safe(pyobj_numDisparities, numDisparities, ArgInfo("numDisparities", 0)) &&
| 23276 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) ) |  | 23228 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) )
| 23277 | { |  | 23229 | {
| 23278 | ERRWRAP2(retval = cv::StereoBM::create(numDisparities, blockSize)); |  | 23230 | ERRWRAP2(retval = cv::StereoBM::create(numDisparities, blockSize));
| 23279 | return pyopencv_from(retval); |  | 23231 | return pyopencv_from(retval);
| 23280 | } |  | 23232 | }
| 23281 |  |  | 23233 |
| 23282 | return NULL; |  | 23234 | return NULL;
| 23283 | } |  | 23235 | }
| 23284 |  |  | 23236 |
| 23285 | static PyObject* pyopencv_cv_StereoBM_getPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23237 | static PyObject* pyopencv_cv_StereoBM_getPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw)
| 23286 | { |  | 23238 | {
| 23287 | using namespace cv; |  | 23239 | using namespace cv;
| 23288 |  |  | 23240 |
| 23289 |  |  | 23241 |
| 23290 | Ptr<cv::StereoBM> * self1 = 0; |  | 23242 | Ptr<cv::StereoBM> * self1 = 0;
| 23291 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23243 | if (!pyopencv_StereoBM_getp(self, self1))
| 23292 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23244 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23293 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23245 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23294 | int retval; |  | 23246 | int retval;
| 23295 |  |  | 23247 |
| 23296 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23248 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23297 | { |  | 23249 | {
| 23298 | ERRWRAP2(retval = _self_->getPreFilterCap()); |  | 23250 | ERRWRAP2(retval = _self_->getPreFilterCap());
| 23299 | return pyopencv_from(retval); |  | 23251 | return pyopencv_from(retval);
| 23300 | } |  | 23252 | }
| 23301 |  |  | 23253 |
| 23302 | return NULL; |  | 23254 | return NULL;
| 23303 | } |  | 23255 | }
| 23304 |  |  | 23256 |
| 23305 | static PyObject* pyopencv_cv_StereoBM_getPreFilterSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23257 | static PyObject* pyopencv_cv_StereoBM_getPreFilterSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23306 | { |  | 23258 | {
| 23307 | using namespace cv; |  | 23259 | using namespace cv;
| 23308 |  |  | 23260 |
| 23309 |  |  | 23261 |
| 23310 | Ptr<cv::StereoBM> * self1 = 0; |  | 23262 | Ptr<cv::StereoBM> * self1 = 0;
| 23311 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23263 | if (!pyopencv_StereoBM_getp(self, self1))
| 23312 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23264 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23313 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23265 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23314 | int retval; |  | 23266 | int retval;
| 23315 |  |  | 23267 |
| 23316 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23268 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23317 | { |  | 23269 | {
| 23318 | ERRWRAP2(retval = _self_->getPreFilterSize()); |  | 23270 | ERRWRAP2(retval = _self_->getPreFilterSize());
| 23319 | return pyopencv_from(retval); |  | 23271 | return pyopencv_from(retval);
| 23320 | } |  | 23272 | }
| 23321 |  |  | 23273 |
| 23322 | return NULL; |  | 23274 | return NULL;
| 23323 | } |  | 23275 | }
| 23324 |  |  | 23276 |
| 23325 | static PyObject* pyopencv_cv_StereoBM_getPreFilterType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23277 | static PyObject* pyopencv_cv_StereoBM_getPreFilterType(PyObject* self, PyObject* py_args, PyObject* kw)
| 23326 | { |  | 23278 | {
| 23327 | using namespace cv; |  | 23279 | using namespace cv;
| 23328 |  |  | 23280 |
| 23329 |  |  | 23281 |
| 23330 | Ptr<cv::StereoBM> * self1 = 0; |  | 23282 | Ptr<cv::StereoBM> * self1 = 0;
| 23331 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23283 | if (!pyopencv_StereoBM_getp(self, self1))
| 23332 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23284 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23333 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23285 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23334 | int retval; |  | 23286 | int retval;
| 23335 |  |  | 23287 |
| 23336 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23288 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23337 | { |  | 23289 | {
| 23338 | ERRWRAP2(retval = _self_->getPreFilterType()); |  | 23290 | ERRWRAP2(retval = _self_->getPreFilterType());
| 23339 | return pyopencv_from(retval); |  | 23291 | return pyopencv_from(retval);
| 23340 | } |  | 23292 | }
| 23341 |  |  | 23293 |
| 23342 | return NULL; |  | 23294 | return NULL;
| 23343 | } |  | 23295 | }
| 23344 |  |  | 23296 |
| 23345 | static PyObject* pyopencv_cv_StereoBM_getROI1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23297 | static PyObject* pyopencv_cv_StereoBM_getROI1(PyObject* self, PyObject* py_args, PyObject* kw)
| 23346 | { |  | 23298 | {
| 23347 | using namespace cv; |  | 23299 | using namespace cv;
| 23348 |  |  | 23300 |
| 23349 |  |  | 23301 |
| 23350 | Ptr<cv::StereoBM> * self1 = 0; |  | 23302 | Ptr<cv::StereoBM> * self1 = 0;
| 23351 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23303 | if (!pyopencv_StereoBM_getp(self, self1))
| 23352 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23304 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23353 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23305 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23354 | Rect retval; |  | 23306 | Rect retval;
| 23355 |  |  | 23307 |
| 23356 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23308 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23357 | { |  | 23309 | {
| 23358 | ERRWRAP2(retval = _self_->getROI1()); |  | 23310 | ERRWRAP2(retval = _self_->getROI1());
| 23359 | return pyopencv_from(retval); |  | 23311 | return pyopencv_from(retval);
| 23360 | } |  | 23312 | }
| 23361 |  |  | 23313 |
| 23362 | return NULL; |  | 23314 | return NULL;
| 23363 | } |  | 23315 | }
| 23364 |  |  | 23316 |
| 23365 | static PyObject* pyopencv_cv_StereoBM_getROI2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23317 | static PyObject* pyopencv_cv_StereoBM_getROI2(PyObject* self, PyObject* py_args, PyObject* kw)
| 23366 | { |  | 23318 | {
| 23367 | using namespace cv; |  | 23319 | using namespace cv;
| 23368 |  |  | 23320 |
| 23369 |  |  | 23321 |
| 23370 | Ptr<cv::StereoBM> * self1 = 0; |  | 23322 | Ptr<cv::StereoBM> * self1 = 0;
| 23371 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23323 | if (!pyopencv_StereoBM_getp(self, self1))
| 23372 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23324 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23373 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23325 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23374 | Rect retval; |  | 23326 | Rect retval;
| 23375 |  |  | 23327 |
| 23376 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23328 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23377 | { |  | 23329 | {
| 23378 | ERRWRAP2(retval = _self_->getROI2()); |  | 23330 | ERRWRAP2(retval = _self_->getROI2());
| 23379 | return pyopencv_from(retval); |  | 23331 | return pyopencv_from(retval);
| 23380 | } |  | 23332 | }
| 23381 |  |  | 23333 |
| 23382 | return NULL; |  | 23334 | return NULL;
| 23383 | } |  | 23335 | }
| 23384 |  |  | 23336 |
| 23385 | static PyObject* pyopencv_cv_StereoBM_getSmallerBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23337 | static PyObject* pyopencv_cv_StereoBM_getSmallerBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23386 | { |  | 23338 | {
| 23387 | using namespace cv; |  | 23339 | using namespace cv;
| 23388 |  |  | 23340 |
| 23389 |  |  | 23341 |
| 23390 | Ptr<cv::StereoBM> * self1 = 0; |  | 23342 | Ptr<cv::StereoBM> * self1 = 0;
| 23391 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23343 | if (!pyopencv_StereoBM_getp(self, self1))
| 23392 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23344 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23393 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23345 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23394 | int retval; |  | 23346 | int retval;
| 23395 |  |  | 23347 |
| 23396 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23348 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23397 | { |  | 23349 | {
| 23398 | ERRWRAP2(retval = _self_->getSmallerBlockSize()); |  | 23350 | ERRWRAP2(retval = _self_->getSmallerBlockSize());
| 23399 | return pyopencv_from(retval); |  | 23351 | return pyopencv_from(retval);
| 23400 | } |  | 23352 | }
| 23401 |  |  | 23353 |
| 23402 | return NULL; |  | 23354 | return NULL;
| 23403 | } |  | 23355 | }
| 23404 |  |  | 23356 |
| 23405 | static PyObject* pyopencv_cv_StereoBM_getTextureThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23357 | static PyObject* pyopencv_cv_StereoBM_getTextureThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 23406 | { |  | 23358 | {
| 23407 | using namespace cv; |  | 23359 | using namespace cv;
| 23408 |  |  | 23360 |
| 23409 |  |  | 23361 |
| 23410 | Ptr<cv::StereoBM> * self1 = 0; |  | 23362 | Ptr<cv::StereoBM> * self1 = 0;
| 23411 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23363 | if (!pyopencv_StereoBM_getp(self, self1))
| 23412 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23364 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23413 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23365 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23414 | int retval; |  | 23366 | int retval;
| 23415 |  |  | 23367 |
| 23416 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23368 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23417 | { |  | 23369 | {
| 23418 | ERRWRAP2(retval = _self_->getTextureThreshold()); |  | 23370 | ERRWRAP2(retval = _self_->getTextureThreshold());
| 23419 | return pyopencv_from(retval); |  | 23371 | return pyopencv_from(retval);
| 23420 | } |  | 23372 | }
| 23421 |  |  | 23373 |
| 23422 | return NULL; |  | 23374 | return NULL;
| 23423 | } |  | 23375 | }
| 23424 |  |  | 23376 |
| 23425 | static PyObject* pyopencv_cv_StereoBM_getUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23377 | static PyObject* pyopencv_cv_StereoBM_getUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 23426 | { |  | 23378 | {
| 23427 | using namespace cv; |  | 23379 | using namespace cv;
| 23428 |  |  | 23380 |
| 23429 |  |  | 23381 |
| 23430 | Ptr<cv::StereoBM> * self1 = 0; |  | 23382 | Ptr<cv::StereoBM> * self1 = 0;
| 23431 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23383 | if (!pyopencv_StereoBM_getp(self, self1))
| 23432 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23384 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23433 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23385 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23434 | int retval; |  | 23386 | int retval;
| 23435 |  |  | 23387 |
| 23436 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23388 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23437 | { |  | 23389 | {
| 23438 | ERRWRAP2(retval = _self_->getUniquenessRatio()); |  | 23390 | ERRWRAP2(retval = _self_->getUniquenessRatio());
| 23439 | return pyopencv_from(retval); |  | 23391 | return pyopencv_from(retval);
| 23440 | } |  | 23392 | }
| 23441 |  |  | 23393 |
| 23442 | return NULL; |  | 23394 | return NULL;
| 23443 | } |  | 23395 | }
| 23444 |  |  | 23396 |
| 23445 | static PyObject* pyopencv_cv_StereoBM_setPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23397 | static PyObject* pyopencv_cv_StereoBM_setPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw)
| 23446 | { |  | 23398 | {
| 23447 | using namespace cv; |  | 23399 | using namespace cv;
| 23448 |  |  | 23400 |
| 23449 |  |  | 23401 |
| 23450 | Ptr<cv::StereoBM> * self1 = 0; |  | 23402 | Ptr<cv::StereoBM> * self1 = 0;
| 23451 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23403 | if (!pyopencv_StereoBM_getp(self, self1))
| 23452 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23404 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23453 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23405 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23454 | PyObject* pyobj_preFilterCap = NULL; |  | 23406 | PyObject* pyobj_preFilterCap = NULL;
| 23455 | int preFilterCap=0; |  | 23407 | int preFilterCap=0;
| 23456 |  |  | 23408 |
| 23457 | const char* keywords[] = { "preFilterCap", NULL }; |  | 23409 | const char* keywords[] = { "preFilterCap", NULL };
| 23458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setPreFilterCap", (char**)keywords, &pyobj_preFilterCap) && |  | 23410 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setPreFilterCap", (char**)keywords, &pyobj_preFilterCap) &&
| 23459 | pyopencv_to_safe(pyobj_preFilterCap, preFilterCap, ArgInfo("preFilterCap", 0)) ) |  | 23411 | pyopencv_to_safe(pyobj_preFilterCap, preFilterCap, ArgInfo("preFilterCap", 0)) )
| 23460 | { |  | 23412 | {
| 23461 | ERRWRAP2(_self_->setPreFilterCap(preFilterCap)); |  | 23413 | ERRWRAP2(_self_->setPreFilterCap(preFilterCap));
| 23462 | Py_RETURN_NONE; |  | 23414 | Py_RETURN_NONE;
| 23463 | } |  | 23415 | }
| 23464 |  |  | 23416 |
| 23465 | return NULL; |  | 23417 | return NULL;
| 23466 | } |  | 23418 | }
| 23467 |  |  | 23419 |
| 23468 | static PyObject* pyopencv_cv_StereoBM_setPreFilterSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23420 | static PyObject* pyopencv_cv_StereoBM_setPreFilterSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23469 | { |  | 23421 | {
| 23470 | using namespace cv; |  | 23422 | using namespace cv;
| 23471 |  |  | 23423 |
| 23472 |  |  | 23424 |
| 23473 | Ptr<cv::StereoBM> * self1 = 0; |  | 23425 | Ptr<cv::StereoBM> * self1 = 0;
| 23474 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23426 | if (!pyopencv_StereoBM_getp(self, self1))
| 23475 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23427 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23476 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23428 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23477 | PyObject* pyobj_preFilterSize = NULL; |  | 23429 | PyObject* pyobj_preFilterSize = NULL;
| 23478 | int preFilterSize=0; |  | 23430 | int preFilterSize=0;
| 23479 |  |  | 23431 |
| 23480 | const char* keywords[] = { "preFilterSize", NULL }; |  | 23432 | const char* keywords[] = { "preFilterSize", NULL };
| 23481 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setPreFilterSize", (char**)keywords, &pyobj_preFilterSize) && |  | 23433 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setPreFilterSize", (char**)keywords, &pyobj_preFilterSize) &&
| 23482 | pyopencv_to_safe(pyobj_preFilterSize, preFilterSize, ArgInfo("preFilterSize", 0)) ) |  | 23434 | pyopencv_to_safe(pyobj_preFilterSize, preFilterSize, ArgInfo("preFilterSize", 0)) )
| 23483 | { |  | 23435 | {
| 23484 | ERRWRAP2(_self_->setPreFilterSize(preFilterSize)); |  | 23436 | ERRWRAP2(_self_->setPreFilterSize(preFilterSize));
| 23485 | Py_RETURN_NONE; |  | 23437 | Py_RETURN_NONE;
| 23486 | } |  | 23438 | }
| 23487 |  |  | 23439 |
| 23488 | return NULL; |  | 23440 | return NULL;
| 23489 | } |  | 23441 | }
| 23490 |  |  | 23442 |
| 23491 | static PyObject* pyopencv_cv_StereoBM_setPreFilterType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23443 | static PyObject* pyopencv_cv_StereoBM_setPreFilterType(PyObject* self, PyObject* py_args, PyObject* kw)
| 23492 | { |  | 23444 | {
| 23493 | using namespace cv; |  | 23445 | using namespace cv;
| 23494 |  |  | 23446 |
| 23495 |  |  | 23447 |
| 23496 | Ptr<cv::StereoBM> * self1 = 0; |  | 23448 | Ptr<cv::StereoBM> * self1 = 0;
| 23497 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23449 | if (!pyopencv_StereoBM_getp(self, self1))
| 23498 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23450 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23499 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23451 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23500 | PyObject* pyobj_preFilterType = NULL; |  | 23452 | PyObject* pyobj_preFilterType = NULL;
| 23501 | int preFilterType=0; |  | 23453 | int preFilterType=0;
| 23502 |  |  | 23454 |
| 23503 | const char* keywords[] = { "preFilterType", NULL }; |  | 23455 | const char* keywords[] = { "preFilterType", NULL };
| 23504 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setPreFilterType", (char**)keywords, &pyobj_preFilterType) && |  | 23456 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setPreFilterType", (char**)keywords, &pyobj_preFilterType) &&
| 23505 | pyopencv_to_safe(pyobj_preFilterType, preFilterType, ArgInfo("preFilterType", 0)) ) |  | 23457 | pyopencv_to_safe(pyobj_preFilterType, preFilterType, ArgInfo("preFilterType", 0)) )
| 23506 | { |  | 23458 | {
| 23507 | ERRWRAP2(_self_->setPreFilterType(preFilterType)); |  | 23459 | ERRWRAP2(_self_->setPreFilterType(preFilterType));
| 23508 | Py_RETURN_NONE; |  | 23460 | Py_RETURN_NONE;
| 23509 | } |  | 23461 | }
| 23510 |  |  | 23462 |
| 23511 | return NULL; |  | 23463 | return NULL;
| 23512 | } |  | 23464 | }
| 23513 |  |  | 23465 |
| 23514 | static PyObject* pyopencv_cv_StereoBM_setROI1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23466 | static PyObject* pyopencv_cv_StereoBM_setROI1(PyObject* self, PyObject* py_args, PyObject* kw)
| 23515 | { |  | 23467 | {
| 23516 | using namespace cv; |  | 23468 | using namespace cv;
| 23517 |  |  | 23469 |
| 23518 |  |  | 23470 |
| 23519 | Ptr<cv::StereoBM> * self1 = 0; |  | 23471 | Ptr<cv::StereoBM> * self1 = 0;
| 23520 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23472 | if (!pyopencv_StereoBM_getp(self, self1))
| 23521 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23473 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23522 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23474 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23523 | PyObject* pyobj_roi1 = NULL; |  | 23475 | PyObject* pyobj_roi1 = NULL;
| 23524 | Rect roi1; |  | 23476 | Rect roi1;
| 23525 |  |  | 23477 |
| 23526 | const char* keywords[] = { "roi1", NULL }; |  | 23478 | const char* keywords[] = { "roi1", NULL };
| 23527 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setROI1", (char**)keywords, &pyobj_roi1) && |  | 23479 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setROI1", (char**)keywords, &pyobj_roi1) &&
| 23528 | pyopencv_to_safe(pyobj_roi1, roi1, ArgInfo("roi1", 0)) ) |  | 23480 | pyopencv_to_safe(pyobj_roi1, roi1, ArgInfo("roi1", 0)) )
| 23529 | { |  | 23481 | {
| 23530 | ERRWRAP2(_self_->setROI1(roi1)); |  | 23482 | ERRWRAP2(_self_->setROI1(roi1));
| 23531 | Py_RETURN_NONE; |  | 23483 | Py_RETURN_NONE;
| 23532 | } |  | 23484 | }
| 23533 |  |  | 23485 |
| 23534 | return NULL; |  | 23486 | return NULL;
| 23535 | } |  | 23487 | }
| 23536 |  |  | 23488 |
| 23537 | static PyObject* pyopencv_cv_StereoBM_setROI2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23489 | static PyObject* pyopencv_cv_StereoBM_setROI2(PyObject* self, PyObject* py_args, PyObject* kw)
| 23538 | { |  | 23490 | {
| 23539 | using namespace cv; |  | 23491 | using namespace cv;
| 23540 |  |  | 23492 |
| 23541 |  |  | 23493 |
| 23542 | Ptr<cv::StereoBM> * self1 = 0; |  | 23494 | Ptr<cv::StereoBM> * self1 = 0;
| 23543 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23495 | if (!pyopencv_StereoBM_getp(self, self1))
| 23544 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23496 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23545 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23497 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23546 | PyObject* pyobj_roi2 = NULL; |  | 23498 | PyObject* pyobj_roi2 = NULL;
| 23547 | Rect roi2; |  | 23499 | Rect roi2;
| 23548 |  |  | 23500 |
| 23549 | const char* keywords[] = { "roi2", NULL }; |  | 23501 | const char* keywords[] = { "roi2", NULL };
| 23550 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setROI2", (char**)keywords, &pyobj_roi2) && |  | 23502 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setROI2", (char**)keywords, &pyobj_roi2) &&
| 23551 | pyopencv_to_safe(pyobj_roi2, roi2, ArgInfo("roi2", 0)) ) |  | 23503 | pyopencv_to_safe(pyobj_roi2, roi2, ArgInfo("roi2", 0)) )
| 23552 | { |  | 23504 | {
| 23553 | ERRWRAP2(_self_->setROI2(roi2)); |  | 23505 | ERRWRAP2(_self_->setROI2(roi2));
| 23554 | Py_RETURN_NONE; |  | 23506 | Py_RETURN_NONE;
| 23555 | } |  | 23507 | }
| 23556 |  |  | 23508 |
| 23557 | return NULL; |  | 23509 | return NULL;
| 23558 | } |  | 23510 | }
| 23559 |  |  | 23511 |
| 23560 | static PyObject* pyopencv_cv_StereoBM_setSmallerBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23512 | static PyObject* pyopencv_cv_StereoBM_setSmallerBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23561 | { |  | 23513 | {
| 23562 | using namespace cv; |  | 23514 | using namespace cv;
| 23563 |  |  | 23515 |
| 23564 |  |  | 23516 |
| 23565 | Ptr<cv::StereoBM> * self1 = 0; |  | 23517 | Ptr<cv::StereoBM> * self1 = 0;
| 23566 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23518 | if (!pyopencv_StereoBM_getp(self, self1))
| 23567 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23519 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23568 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23520 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23569 | PyObject* pyobj_blockSize = NULL; |  | 23521 | PyObject* pyobj_blockSize = NULL;
| 23570 | int blockSize=0; |  | 23522 | int blockSize=0;
| 23571 |  |  | 23523 |
| 23572 | const char* keywords[] = { "blockSize", NULL }; |  | 23524 | const char* keywords[] = { "blockSize", NULL };
| 23573 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setSmallerBlockSize", (char**)keywords, &pyobj_blockSize) && |  | 23525 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setSmallerBlockSize", (char**)keywords, &pyobj_blockSize) &&
| 23574 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) ) |  | 23526 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) )
| 23575 | { |  | 23527 | {
| 23576 | ERRWRAP2(_self_->setSmallerBlockSize(blockSize)); |  | 23528 | ERRWRAP2(_self_->setSmallerBlockSize(blockSize));
| 23577 | Py_RETURN_NONE; |  | 23529 | Py_RETURN_NONE;
| 23578 | } |  | 23530 | }
| 23579 |  |  | 23531 |
| 23580 | return NULL; |  | 23532 | return NULL;
| 23581 | } |  | 23533 | }
| 23582 |  |  | 23534 |
| 23583 | static PyObject* pyopencv_cv_StereoBM_setTextureThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23535 | static PyObject* pyopencv_cv_StereoBM_setTextureThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 23584 | { |  | 23536 | {
| 23585 | using namespace cv; |  | 23537 | using namespace cv;
| 23586 |  |  | 23538 |
| 23587 |  |  | 23539 |
| 23588 | Ptr<cv::StereoBM> * self1 = 0; |  | 23540 | Ptr<cv::StereoBM> * self1 = 0;
| 23589 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23541 | if (!pyopencv_StereoBM_getp(self, self1))
| 23590 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23542 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23591 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23543 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23592 | PyObject* pyobj_textureThreshold = NULL; |  | 23544 | PyObject* pyobj_textureThreshold = NULL;
| 23593 | int textureThreshold=0; |  | 23545 | int textureThreshold=0;
| 23594 |  |  | 23546 |
| 23595 | const char* keywords[] = { "textureThreshold", NULL }; |  | 23547 | const char* keywords[] = { "textureThreshold", NULL };
| 23596 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setTextureThreshold", (char**)keywords, &pyobj_textureThreshold) && |  | 23548 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setTextureThreshold", (char**)keywords, &pyobj_textureThreshold) &&
| 23597 | pyopencv_to_safe(pyobj_textureThreshold, textureThreshold, ArgInfo("textureThreshold", 0)) ) |  | 23549 | pyopencv_to_safe(pyobj_textureThreshold, textureThreshold, ArgInfo("textureThreshold", 0)) )
| 23598 | { |  | 23550 | {
| 23599 | ERRWRAP2(_self_->setTextureThreshold(textureThreshold)); |  | 23551 | ERRWRAP2(_self_->setTextureThreshold(textureThreshold));
| 23600 | Py_RETURN_NONE; |  | 23552 | Py_RETURN_NONE;
| 23601 | } |  | 23553 | }
| 23602 |  |  | 23554 |
| 23603 | return NULL; |  | 23555 | return NULL;
| 23604 | } |  | 23556 | }
| 23605 |  |  | 23557 |
| 23606 | static PyObject* pyopencv_cv_StereoBM_setUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23558 | static PyObject* pyopencv_cv_StereoBM_setUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 23607 | { |  | 23559 | {
| 23608 | using namespace cv; |  | 23560 | using namespace cv;
| 23609 |  |  | 23561 |
| 23610 |  |  | 23562 |
| 23611 | Ptr<cv::StereoBM> * self1 = 0; |  | 23563 | Ptr<cv::StereoBM> * self1 = 0;
| 23612 | if (!pyopencv_StereoBM_getp(self, self1)) |  | 23564 | if (!pyopencv_StereoBM_getp(self, self1))
| 23613 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)"); |  | 23565 | return failmsgp("Incorrect type of self (must be 'StereoBM' or its derivative)");
| 23614 | Ptr<cv::StereoBM> _self_ = *(self1); |  | 23566 | Ptr<cv::StereoBM> _self_ = *(self1);
| 23615 | PyObject* pyobj_uniquenessRatio = NULL; |  | 23567 | PyObject* pyobj_uniquenessRatio = NULL;
| 23616 | int uniquenessRatio=0; |  | 23568 | int uniquenessRatio=0;
| 23617 |  |  | 23569 |
| 23618 | const char* keywords[] = { "uniquenessRatio", NULL }; |  | 23570 | const char* keywords[] = { "uniquenessRatio", NULL };
| 23619 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setUniquenessRatio", (char**)keywords, &pyobj_uniquenessRatio) && |  | 23571 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoBM.setUniquenessRatio", (char**)keywords, &pyobj_uniquenessRatio) &&
| 23620 | pyopencv_to_safe(pyobj_uniquenessRatio, uniquenessRatio, ArgInfo("uniquenessRatio", 0)) ) |  | 23572 | pyopencv_to_safe(pyobj_uniquenessRatio, uniquenessRatio, ArgInfo("uniquenessRatio", 0)) )
| 23621 | { |  | 23573 | {
| 23622 | ERRWRAP2(_self_->setUniquenessRatio(uniquenessRatio)); |  | 23574 | ERRWRAP2(_self_->setUniquenessRatio(uniquenessRatio));
| 23623 | Py_RETURN_NONE; |  | 23575 | Py_RETURN_NONE;
| 23624 | } |  | 23576 | }
| 23625 |  |  | 23577 |
| 23626 | return NULL; |  | 23578 | return NULL;
| 23627 | } |  | 23579 | }
| 23628 |  |  | 23580 |
| 23629 |  |  | 23581 |
| 23630 |  |  | 23582 |
| 23631 | // Tables (StereoBM) |  | 23583 | // Tables (StereoBM)
| 23632 |  |  | 23584 |
| 23633 | static PyGetSetDef pyopencv_StereoBM_getseters[] = |  | 23585 | static PyGetSetDef pyopencv_StereoBM_getseters[] =
| 23634 | { |  | 23586 | {
| 23635 | {NULL} /* Sentinel */ |  | 23587 | {NULL} /* Sentinel */
| 23636 | }; |  | 23588 | };
| 23637 |  |  | 23589 |
| 23638 | static PyMethodDef pyopencv_StereoBM_methods[] = |  | 23590 | static PyMethodDef pyopencv_StereoBM_methods[] =
| 23639 | { |  | 23591 | {
| 23640 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_create_static, METH_STATIC), "create([, numDisparities[, blockSize]]) -> retval\n. * @brief Creates StereoBM object\n. * @param numDisparities The disparity search range. For each pixel, the algorithm will find the best disparity from 0 (default minimum disparity) to numDisparities. The search range can be shifted by changing the minimum disparity.\n. * @param blockSize The linear size of the blocks compared by the algorithm. The size should be odd (as the block is centered at the current pixel). Larger block size implies smoother, though less accurate disparity map. Smaller block size gives more detailed disparity map, but there is a higher chance for the algorithm to find a wrong correspondence.\n. * @return A pointer to the created StereoBM object.\n. * @details The function creates a StereoBM object. You can then call StereoBM::compute() to compute disparity for a specific stereo pair."}, |  | 23592 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_create_static, METH_STATIC), "create([, numDisparities[, blockSize]]) -> retval\n. * @brief Creates StereoBM object\n. * @param numDisparities The disparity search range. For each pixel, the algorithm will find the best disparity from 0 (default minimum disparity) to numDisparities. The search range can be shifted by changing the minimum disparity.\n. * @param blockSize The linear size of the blocks compared by the algorithm. The size should be odd (as the block is centered at the current pixel). Larger block size implies smoother, though less accurate disparity map. Smaller block size gives more detailed disparity map, but there is a higher chance for the algorithm to find a wrong correspondence.\n. * @return A pointer to the created StereoBM object.\n. * @details The function creates a StereoBM object. You can then call StereoBM::compute() to compute disparity for a specific stereo pair."},
| 23641 | {"getPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getPreFilterCap, 0), "getPreFilterCap() -> retval\n. * @brief Gets the current truncation value for prefiltered pixels.\n. * @return The current pre-filter cap value."}, |  | 23593 | {"getPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getPreFilterCap, 0), "getPreFilterCap() -> retval\n. * @brief Gets the current truncation value for prefiltered pixels.\n. * @return The current pre-filter cap value."},
| 23642 | {"getPreFilterSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getPreFilterSize, 0), "getPreFilterSize() -> retval\n. * @brief Gets the current size of the pre-filter kernel.\n. * @return The current pre-filter size."}, |  | 23594 | {"getPreFilterSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getPreFilterSize, 0), "getPreFilterSize() -> retval\n. * @brief Gets the current size of the pre-filter kernel.\n. * @return The current pre-filter size."},
| 23643 | {"getPreFilterType", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getPreFilterType, 0), "getPreFilterType() -> retval\n. * @brief Gets the type of pre-filtering currently used in the algorithm.\n. * @return The current pre-filter type: 0 for PREFILTER_NORMALIZED_RESPONSE or 1 for PREFILTER_XSOBEL."}, |  | 23595 | {"getPreFilterType", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getPreFilterType, 0), "getPreFilterType() -> retval\n. * @brief Gets the type of pre-filtering currently used in the algorithm.\n. * @return The current pre-filter type: 0 for PREFILTER_NORMALIZED_RESPONSE or 1 for PREFILTER_XSOBEL."},
| 23644 | {"getROI1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getROI1, 0), "getROI1() -> retval\n. * @brief Gets the current Region of Interest (ROI) for the left image.\n. * @return The current ROI for the left image."}, |  | 23596 | {"getROI1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getROI1, 0), "getROI1() -> retval\n. * @brief Gets the current Region of Interest (ROI) for the left image.\n. * @return The current ROI for the left image."},
| 23645 | {"getROI2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getROI2, 0), "getROI2() -> retval\n. * @brief Gets the current Region of Interest (ROI) for the right image.\n. * @return The current ROI for the right image."}, |  | 23597 | {"getROI2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getROI2, 0), "getROI2() -> retval\n. * @brief Gets the current Region of Interest (ROI) for the right image.\n. * @return The current ROI for the right image."},
| 23646 | {"getSmallerBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getSmallerBlockSize, 0), "getSmallerBlockSize() -> retval\n. * @brief Gets the current size of the smaller block used for texture check.\n. * @return The current smaller block size."}, |  | 23598 | {"getSmallerBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getSmallerBlockSize, 0), "getSmallerBlockSize() -> retval\n. * @brief Gets the current size of the smaller block used for texture check.\n. * @return The current smaller block size."},
| 23647 | {"getTextureThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getTextureThreshold, 0), "getTextureThreshold() -> retval\n. * @brief Gets the current texture threshold value.\n. * @return The current texture threshold."}, |  | 23599 | {"getTextureThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getTextureThreshold, 0), "getTextureThreshold() -> retval\n. * @brief Gets the current texture threshold value.\n. * @return The current texture threshold."},
| 23648 | {"getUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getUniquenessRatio, 0), "getUniquenessRatio() -> retval\n. * @brief Gets the current uniqueness ratio value.\n. * @return The current uniqueness ratio."}, |  | 23600 | {"getUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_getUniquenessRatio, 0), "getUniquenessRatio() -> retval\n. * @brief Gets the current uniqueness ratio value.\n. * @return The current uniqueness ratio."},
| 23649 | {"setPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setPreFilterCap, 0), "setPreFilterCap(preFilterCap) -> None\n. * @brief Sets the truncation value for prefiltered pixels.\n. * @param preFilterCap The truncation value. Typically in the range [1, 63].\n. * @details This value caps the output of the pre-filter to [-preFilterCap, preFilterCap], helping to reduce the impact of noise and outliers in the pre-filtered image."}, |  | 23601 | {"setPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setPreFilterCap, 0), "setPreFilterCap(preFilterCap) -> None\n. * @brief Sets the truncation value for prefiltered pixels.\n. * @param preFilterCap The truncation value. Typically in the range [1, 63].\n. * @details This value caps the output of the pre-filter to [-preFilterCap, preFilterCap], helping to reduce the impact of noise and outliers in the pre-filtered image."},
| 23650 | {"setPreFilterSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setPreFilterSize, 0), "setPreFilterSize(preFilterSize) -> None\n. * @brief Sets the size of the pre-filter kernel.\n. * @param preFilterSize The size of the pre-filter kernel. Must be an odd integer, typically between 5 and 255.\n. * @details The pre-filter size determines the spatial extent of the pre-filtering operation, which prepares the images for disparity computation by normalizing brightness and enhancing texture. Larger sizes reduce noise but may blur details, while smaller sizes preserve details but are more susceptible to noise."}, |  | 23602 | {"setPreFilterSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setPreFilterSize, 0), "setPreFilterSize(preFilterSize) -> None\n. * @brief Sets the size of the pre-filter kernel.\n. * @param preFilterSize The size of the pre-filter kernel. Must be an odd integer, typically between 5 and 255.\n. * @details The pre-filter size determines the spatial extent of the pre-filtering operation, which prepares the images for disparity computation by normalizing brightness and enhancing texture. Larger sizes reduce noise but may blur details, while smaller sizes preserve details but are more susceptible to noise."},
| 23651 | {"setPreFilterType", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setPreFilterType, 0), "setPreFilterType(preFilterType) -> None\n. * @brief Sets the type of pre-filtering used in the algorithm.\n. * @param preFilterType The type of pre-filter to use. Possible values are:\n. * - PREFILTER_NORMALIZED_RESPONSE (0): Uses normalized response for pre-filtering.\n. * - PREFILTER_XSOBEL (1): Uses the X-Sobel operator for pre-filtering.\n. * @details The pre-filter type affects how the images are prepared before computing the disparity map. Different pre-filtering methods can enhance specific image features or reduce noise, influencing the quality of the disparity map."}, |  | 23603 | {"setPreFilterType", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setPreFilterType, 0), "setPreFilterType(preFilterType) -> None\n. * @brief Sets the type of pre-filtering used in the algorithm.\n. * @param preFilterType The type of pre-filter to use. Possible values are:\n. * - PREFILTER_NORMALIZED_RESPONSE (0): Uses normalized response for pre-filtering.\n. * - PREFILTER_XSOBEL (1): Uses the X-Sobel operator for pre-filtering.\n. * @details The pre-filter type affects how the images are prepared before computing the disparity map. Different pre-filtering methods can enhance specific image features or reduce noise, influencing the quality of the disparity map."},
| 23652 | {"setROI1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setROI1, 0), "setROI1(roi1) -> None\n. * @brief Sets the Region of Interest (ROI) for the left image.\n. * @param roi1 The ROI rectangle for the left image.\n. * @details By setting the ROI, the stereo matching computation is limited to the specified region, improving performance and potentially accuracy by focusing on relevant parts of the image."}, |  | 23604 | {"setROI1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setROI1, 0), "setROI1(roi1) -> None\n. * @brief Sets the Region of Interest (ROI) for the left image.\n. * @param roi1 The ROI rectangle for the left image.\n. * @details By setting the ROI, the stereo matching computation is limited to the specified region, improving performance and potentially accuracy by focusing on relevant parts of the image."},
| 23653 | {"setROI2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setROI2, 0), "setROI2(roi2) -> None\n. * @brief Sets the Region of Interest (ROI) for the right image.\n. * @param roi2 The ROI rectangle for the right image.\n. * @details Similar to setROI1, this limits the computation to the specified region in the right image."}, |  | 23605 | {"setROI2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setROI2, 0), "setROI2(roi2) -> None\n. * @brief Sets the Region of Interest (ROI) for the right image.\n. * @param roi2 The ROI rectangle for the right image.\n. * @details Similar to setROI1, this limits the computation to the specified region in the right image."},
| 23654 | {"setSmallerBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setSmallerBlockSize, 0), "setSmallerBlockSize(blockSize) -> None\n. * @brief Sets the size of the smaller block used for texture check.\n. * @param blockSize The size of the smaller block. Must be an odd integer between 5 and 255.\n. * @details This parameter determines the size of the block used to compute texture variance. Smaller blocks capture finer details but are more sensitive to noise, while larger blocks are more robust but may miss fine details."}, |  | 23606 | {"setSmallerBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setSmallerBlockSize, 0), "setSmallerBlockSize(blockSize) -> None\n. * @brief Sets the size of the smaller block used for texture check.\n. * @param blockSize The size of the smaller block. Must be an odd integer between 5 and 255.\n. * @details This parameter determines the size of the block used to compute texture variance. Smaller blocks capture finer details but are more sensitive to noise, while larger blocks are more robust but may miss fine details."},
| 23655 | {"setTextureThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setTextureThreshold, 0), "setTextureThreshold(textureThreshold) -> None\n. * @brief Sets the threshold for filtering low-texture regions.\n. * @param textureThreshold The threshold value. Must be non-negative.\n. * @details This parameter filters out regions with low texture, where establishing correspondences is difficult, thus reducing noise in the disparity map. Higher values filter more aggressively but may discard valid information."}, |  | 23607 | {"setTextureThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setTextureThreshold, 0), "setTextureThreshold(textureThreshold) -> None\n. * @brief Sets the threshold for filtering low-texture regions.\n. * @param textureThreshold The threshold value. Must be non-negative.\n. * @details This parameter filters out regions with low texture, where establishing correspondences is difficult, thus reducing noise in the disparity map. Higher values filter more aggressively but may discard valid information."},
| 23656 | {"setUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setUniquenessRatio, 0), "setUniquenessRatio(uniquenessRatio) -> None\n. * @brief Sets the uniqueness ratio for filtering ambiguous matches.\n. * @param uniquenessRatio The uniqueness ratio value. Typically in the range [5, 15], but can be from 0 to 100.\n. * @details This parameter ensures that the best match is sufficiently better than the next best match, reducing false positives. Higher values are stricter but may filter out valid matches in difficult regions."}, |  | 23608 | {"setUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoBM_setUniquenessRatio, 0), "setUniquenessRatio(uniquenessRatio) -> None\n. * @brief Sets the uniqueness ratio for filtering ambiguous matches.\n. * @param uniquenessRatio The uniqueness ratio value. Typically in the range [5, 15], but can be from 0 to 100.\n. * @details This parameter ensures that the best match is sufficiently better than the next best match, reducing false positives. Higher values are stricter but may filter out valid matches in difficult regions."},
| 23657 |  |  | 23609 |
| 23658 | {NULL, NULL} |  | 23610 | {NULL, NULL}
| 23659 | }; |  | 23611 | };
| 23660 |  |  | 23612 |
| 23661 | // Converter (StereoBM) |  | 23613 | // Converter (StereoBM)
| 23662 |  |  | 23614 |
| 23663 | template<> |  | 23615 | template<>
| 23664 | struct PyOpenCV_Converter< Ptr<cv::StereoBM> > |  | 23616 | struct PyOpenCV_Converter< Ptr<cv::StereoBM> >
| 23665 | { |  | 23617 | {
| 23666 | static PyObject* from(const Ptr<cv::StereoBM>& r) |  | 23618 | static PyObject* from(const Ptr<cv::StereoBM>& r)
| 23667 | { |  | 23619 | {
| 23668 | return pyopencv_StereoBM_Instance(r); |  | 23620 | return pyopencv_StereoBM_Instance(r);
| 23669 | } |  | 23621 | }
| 23670 | static bool to(PyObject* src, Ptr<cv::StereoBM>& dst, const ArgInfo& info) |  | 23622 | static bool to(PyObject* src, Ptr<cv::StereoBM>& dst, const ArgInfo& info)
| 23671 | { |  | 23623 | {
| 23672 | if(!src || src == Py_None) |  | 23624 | if(!src || src == Py_None)
| 23673 | return true; |  | 23625 | return true;
| 23674 | Ptr<cv::StereoBM> * dst_; |  | 23626 | Ptr<cv::StereoBM> * dst_;
| 23675 | if (pyopencv_StereoBM_getp(src, dst_)) |  | 23627 | if (pyopencv_StereoBM_getp(src, dst_))
| 23676 | { |  | 23628 | {
| 23677 | dst = *dst_; |  | 23629 | dst = *dst_;
| 23678 | return true; |  | 23630 | return true;
| 23679 | } |  | 23631 | }
| 23680 |  |  | 23632 |
| 23681 | failmsg("Expected Ptr<cv::StereoBM> for argument '%s'", info.name); |  | 23633 | failmsg("Expected Ptr<cv::StereoBM> for argument '%s'", info.name);
| 23682 | return false; |  | 23634 | return false;
| 23683 | } |  | 23635 | }
| 23684 | }; |  | 23636 | };
| 23685 |  |  | 23637 |
| 23686 | //================================================================================ |  | 23638 | //================================================================================
| 23687 | // StereoMatcher (Generic) |  | 23639 | // StereoMatcher (Generic)
| 23688 | //================================================================================ |  | 23640 | //================================================================================
| 23689 |  |  | 23641 |
| 23690 | // GetSet (StereoMatcher) |  | 23642 | // GetSet (StereoMatcher)
| 23691 |  |  | 23643 |
| 23692 |  |  | 23644 |
| 23693 |  |  | 23645 |
| 23694 | // Methods (StereoMatcher) |  | 23646 | // Methods (StereoMatcher)
| 23695 |  |  | 23647 |
| 23696 | static PyObject* pyopencv_cv_StereoMatcher_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23648 | static PyObject* pyopencv_cv_StereoMatcher_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 23697 | { |  | 23649 | {
| 23698 | using namespace cv; |  | 23650 | using namespace cv;
| 23699 |  |  | 23651 |
| 23700 |  |  | 23652 |
| 23701 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23653 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23702 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23654 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23703 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23655 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23704 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23656 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23705 | pyPrepareArgumentConversionErrorsStorage(2); |  | 23657 | pyPrepareArgumentConversionErrorsStorage(2);
| 23706 |  |  | 23658 |
| 23707 | { |  | 23659 | {
| 23708 | PyObject* pyobj_left = NULL; |  | 23660 | PyObject* pyobj_left = NULL;
| 23709 | Mat left; |  | 23661 | Mat left;
| 23710 | PyObject* pyobj_right = NULL; |  | 23662 | PyObject* pyobj_right = NULL;
| 23711 | Mat right; |  | 23663 | Mat right;
| 23712 | PyObject* pyobj_disparity = NULL; |  | 23664 | PyObject* pyobj_disparity = NULL;
| 23713 | Mat disparity; |  | 23665 | Mat disparity;
| 23714 |  |  | 23666 |
| 23715 | const char* keywords[] = { "left", "right", "disparity", NULL }; |  | 23667 | const char* keywords[] = { "left", "right", "disparity", NULL };
| 23716 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:StereoMatcher.compute", (char**)keywords, &pyobj_left, &pyobj_right, &pyobj_disparity) && |  | 23668 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:StereoMatcher.compute", (char**)keywords, &pyobj_left, &pyobj_right, &pyobj_disparity) &&
| 23717 | pyopencv_to_safe(pyobj_left, left, ArgInfo("left", 0)) && |  | 23669 | pyopencv_to_safe(pyobj_left, left, ArgInfo("left", 0)) &&
| 23718 | pyopencv_to_safe(pyobj_right, right, ArgInfo("right", 0)) && |  | 23670 | pyopencv_to_safe(pyobj_right, right, ArgInfo("right", 0)) &&
| 23719 | pyopencv_to_safe(pyobj_disparity, disparity, ArgInfo("disparity", 1)) ) |  | 23671 | pyopencv_to_safe(pyobj_disparity, disparity, ArgInfo("disparity", 1)) )
| 23720 | { |  | 23672 | {
| 23721 | ERRWRAP2(_self_->compute(left, right, disparity)); |  | 23673 | ERRWRAP2(_self_->compute(left, right, disparity));
| 23722 | return pyopencv_from(disparity); |  | 23674 | return pyopencv_from(disparity);
| 23723 | } |  | 23675 | }
| 23724 |  |  | 23676 |
| 23725 |  |  | 23677 |
| 23726 | pyPopulateArgumentConversionErrors(); |  | 23678 | pyPopulateArgumentConversionErrors();
| 23727 | } |  | 23679 | }
| 23728 |  |  | 23680 |
| 23729 |  |  | 23681 |
| 23730 | { |  | 23682 | {
| 23731 | PyObject* pyobj_left = NULL; |  | 23683 | PyObject* pyobj_left = NULL;
| 23732 | UMat left; |  | 23684 | UMat left;
| 23733 | PyObject* pyobj_right = NULL; |  | 23685 | PyObject* pyobj_right = NULL;
| 23734 | UMat right; |  | 23686 | UMat right;
| 23735 | PyObject* pyobj_disparity = NULL; |  | 23687 | PyObject* pyobj_disparity = NULL;
| 23736 | UMat disparity; |  | 23688 | UMat disparity;
| 23737 |  |  | 23689 |
| 23738 | const char* keywords[] = { "left", "right", "disparity", NULL }; |  | 23690 | const char* keywords[] = { "left", "right", "disparity", NULL };
| 23739 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:StereoMatcher.compute", (char**)keywords, &pyobj_left, &pyobj_right, &pyobj_disparity) && |  | 23691 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:StereoMatcher.compute", (char**)keywords, &pyobj_left, &pyobj_right, &pyobj_disparity) &&
| 23740 | pyopencv_to_safe(pyobj_left, left, ArgInfo("left", 0)) && |  | 23692 | pyopencv_to_safe(pyobj_left, left, ArgInfo("left", 0)) &&
| 23741 | pyopencv_to_safe(pyobj_right, right, ArgInfo("right", 0)) && |  | 23693 | pyopencv_to_safe(pyobj_right, right, ArgInfo("right", 0)) &&
| 23742 | pyopencv_to_safe(pyobj_disparity, disparity, ArgInfo("disparity", 1)) ) |  | 23694 | pyopencv_to_safe(pyobj_disparity, disparity, ArgInfo("disparity", 1)) )
| 23743 | { |  | 23695 | {
| 23744 | ERRWRAP2(_self_->compute(left, right, disparity)); |  | 23696 | ERRWRAP2(_self_->compute(left, right, disparity));
| 23745 | return pyopencv_from(disparity); |  | 23697 | return pyopencv_from(disparity);
| 23746 | } |  | 23698 | }
| 23747 |  |  | 23699 |
| 23748 |  |  | 23700 |
| 23749 | pyPopulateArgumentConversionErrors(); |  | 23701 | pyPopulateArgumentConversionErrors();
| 23750 | } |  | 23702 | }
| 23751 | pyRaiseCVOverloadException("compute"); |  | 23703 | pyRaiseCVOverloadException("compute");
| 23752 |  |  | 23704 |
| 23753 | return NULL; |  | 23705 | return NULL;
| 23754 | } |  | 23706 | }
| 23755 |  |  | 23707 |
| 23756 | static PyObject* pyopencv_cv_StereoMatcher_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23708 | static PyObject* pyopencv_cv_StereoMatcher_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23757 | { |  | 23709 | {
| 23758 | using namespace cv; |  | 23710 | using namespace cv;
| 23759 |  |  | 23711 |
| 23760 |  |  | 23712 |
| 23761 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23713 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23762 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23714 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23763 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23715 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23764 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23716 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23765 | int retval; |  | 23717 | int retval;
| 23766 |  |  | 23718 |
| 23767 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23719 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23768 | { |  | 23720 | {
| 23769 | ERRWRAP2(retval = _self_->getBlockSize()); |  | 23721 | ERRWRAP2(retval = _self_->getBlockSize());
| 23770 | return pyopencv_from(retval); |  | 23722 | return pyopencv_from(retval);
| 23771 | } |  | 23723 | }
| 23772 |  |  | 23724 |
| 23773 | return NULL; |  | 23725 | return NULL;
| 23774 | } |  | 23726 | }
| 23775 |  |  | 23727 |
| 23776 | static PyObject* pyopencv_cv_StereoMatcher_getDisp12MaxDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23728 | static PyObject* pyopencv_cv_StereoMatcher_getDisp12MaxDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 23777 | { |  | 23729 | {
| 23778 | using namespace cv; |  | 23730 | using namespace cv;
| 23779 |  |  | 23731 |
| 23780 |  |  | 23732 |
| 23781 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23733 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23782 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23734 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23783 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23735 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23784 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23736 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23785 | int retval; |  | 23737 | int retval;
| 23786 |  |  | 23738 |
| 23787 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23739 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23788 | { |  | 23740 | {
| 23789 | ERRWRAP2(retval = _self_->getDisp12MaxDiff()); |  | 23741 | ERRWRAP2(retval = _self_->getDisp12MaxDiff());
| 23790 | return pyopencv_from(retval); |  | 23742 | return pyopencv_from(retval);
| 23791 | } |  | 23743 | }
| 23792 |  |  | 23744 |
| 23793 | return NULL; |  | 23745 | return NULL;
| 23794 | } |  | 23746 | }
| 23795 |  |  | 23747 |
| 23796 | static PyObject* pyopencv_cv_StereoMatcher_getMinDisparity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23748 | static PyObject* pyopencv_cv_StereoMatcher_getMinDisparity(PyObject* self, PyObject* py_args, PyObject* kw)
| 23797 | { |  | 23749 | {
| 23798 | using namespace cv; |  | 23750 | using namespace cv;
| 23799 |  |  | 23751 |
| 23800 |  |  | 23752 |
| 23801 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23753 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23802 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23754 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23803 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23755 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23804 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23756 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23805 | int retval; |  | 23757 | int retval;
| 23806 |  |  | 23758 |
| 23807 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23759 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23808 | { |  | 23760 | {
| 23809 | ERRWRAP2(retval = _self_->getMinDisparity()); |  | 23761 | ERRWRAP2(retval = _self_->getMinDisparity());
| 23810 | return pyopencv_from(retval); |  | 23762 | return pyopencv_from(retval);
| 23811 | } |  | 23763 | }
| 23812 |  |  | 23764 |
| 23813 | return NULL; |  | 23765 | return NULL;
| 23814 | } |  | 23766 | }
| 23815 |  |  | 23767 |
| 23816 | static PyObject* pyopencv_cv_StereoMatcher_getNumDisparities(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23768 | static PyObject* pyopencv_cv_StereoMatcher_getNumDisparities(PyObject* self, PyObject* py_args, PyObject* kw)
| 23817 | { |  | 23769 | {
| 23818 | using namespace cv; |  | 23770 | using namespace cv;
| 23819 |  |  | 23771 |
| 23820 |  |  | 23772 |
| 23821 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23773 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23822 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23774 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23823 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23775 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23824 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23776 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23825 | int retval; |  | 23777 | int retval;
| 23826 |  |  | 23778 |
| 23827 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23779 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23828 | { |  | 23780 | {
| 23829 | ERRWRAP2(retval = _self_->getNumDisparities()); |  | 23781 | ERRWRAP2(retval = _self_->getNumDisparities());
| 23830 | return pyopencv_from(retval); |  | 23782 | return pyopencv_from(retval);
| 23831 | } |  | 23783 | }
| 23832 |  |  | 23784 |
| 23833 | return NULL; |  | 23785 | return NULL;
| 23834 | } |  | 23786 | }
| 23835 |  |  | 23787 |
| 23836 | static PyObject* pyopencv_cv_StereoMatcher_getSpeckleRange(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23788 | static PyObject* pyopencv_cv_StereoMatcher_getSpeckleRange(PyObject* self, PyObject* py_args, PyObject* kw)
| 23837 | { |  | 23789 | {
| 23838 | using namespace cv; |  | 23790 | using namespace cv;
| 23839 |  |  | 23791 |
| 23840 |  |  | 23792 |
| 23841 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23793 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23842 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23794 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23843 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23795 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23844 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23796 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23845 | int retval; |  | 23797 | int retval;
| 23846 |  |  | 23798 |
| 23847 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23799 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23848 | { |  | 23800 | {
| 23849 | ERRWRAP2(retval = _self_->getSpeckleRange()); |  | 23801 | ERRWRAP2(retval = _self_->getSpeckleRange());
| 23850 | return pyopencv_from(retval); |  | 23802 | return pyopencv_from(retval);
| 23851 | } |  | 23803 | }
| 23852 |  |  | 23804 |
| 23853 | return NULL; |  | 23805 | return NULL;
| 23854 | } |  | 23806 | }
| 23855 |  |  | 23807 |
| 23856 | static PyObject* pyopencv_cv_StereoMatcher_getSpeckleWindowSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23808 | static PyObject* pyopencv_cv_StereoMatcher_getSpeckleWindowSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23857 | { |  | 23809 | {
| 23858 | using namespace cv; |  | 23810 | using namespace cv;
| 23859 |  |  | 23811 |
| 23860 |  |  | 23812 |
| 23861 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23813 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23862 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23814 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23863 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23815 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23864 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23816 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23865 | int retval; |  | 23817 | int retval;
| 23866 |  |  | 23818 |
| 23867 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 23819 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 23868 | { |  | 23820 | {
| 23869 | ERRWRAP2(retval = _self_->getSpeckleWindowSize()); |  | 23821 | ERRWRAP2(retval = _self_->getSpeckleWindowSize());
| 23870 | return pyopencv_from(retval); |  | 23822 | return pyopencv_from(retval);
| 23871 | } |  | 23823 | }
| 23872 |  |  | 23824 |
| 23873 | return NULL; |  | 23825 | return NULL;
| 23874 | } |  | 23826 | }
| 23875 |  |  | 23827 |
| 23876 | static PyObject* pyopencv_cv_StereoMatcher_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23828 | static PyObject* pyopencv_cv_StereoMatcher_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23877 | { |  | 23829 | {
| 23878 | using namespace cv; |  | 23830 | using namespace cv;
| 23879 |  |  | 23831 |
| 23880 |  |  | 23832 |
| 23881 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23833 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23882 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23834 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23883 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23835 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23884 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23836 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23885 | PyObject* pyobj_blockSize = NULL; |  | 23837 | PyObject* pyobj_blockSize = NULL;
| 23886 | int blockSize=0; |  | 23838 | int blockSize=0;
| 23887 |  |  | 23839 |
| 23888 | const char* keywords[] = { "blockSize", NULL }; |  | 23840 | const char* keywords[] = { "blockSize", NULL };
| 23889 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setBlockSize", (char**)keywords, &pyobj_blockSize) && |  | 23841 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setBlockSize", (char**)keywords, &pyobj_blockSize) &&
| 23890 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) ) |  | 23842 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) )
| 23891 | { |  | 23843 | {
| 23892 | ERRWRAP2(_self_->setBlockSize(blockSize)); |  | 23844 | ERRWRAP2(_self_->setBlockSize(blockSize));
| 23893 | Py_RETURN_NONE; |  | 23845 | Py_RETURN_NONE;
| 23894 | } |  | 23846 | }
| 23895 |  |  | 23847 |
| 23896 | return NULL; |  | 23848 | return NULL;
| 23897 | } |  | 23849 | }
| 23898 |  |  | 23850 |
| 23899 | static PyObject* pyopencv_cv_StereoMatcher_setDisp12MaxDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23851 | static PyObject* pyopencv_cv_StereoMatcher_setDisp12MaxDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 23900 | { |  | 23852 | {
| 23901 | using namespace cv; |  | 23853 | using namespace cv;
| 23902 |  |  | 23854 |
| 23903 |  |  | 23855 |
| 23904 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23856 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23905 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23857 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23906 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23858 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23907 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23859 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23908 | PyObject* pyobj_disp12MaxDiff = NULL; |  | 23860 | PyObject* pyobj_disp12MaxDiff = NULL;
| 23909 | int disp12MaxDiff=0; |  | 23861 | int disp12MaxDiff=0;
| 23910 |  |  | 23862 |
| 23911 | const char* keywords[] = { "disp12MaxDiff", NULL }; |  | 23863 | const char* keywords[] = { "disp12MaxDiff", NULL };
| 23912 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setDisp12MaxDiff", (char**)keywords, &pyobj_disp12MaxDiff) && |  | 23864 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setDisp12MaxDiff", (char**)keywords, &pyobj_disp12MaxDiff) &&
| 23913 | pyopencv_to_safe(pyobj_disp12MaxDiff, disp12MaxDiff, ArgInfo("disp12MaxDiff", 0)) ) |  | 23865 | pyopencv_to_safe(pyobj_disp12MaxDiff, disp12MaxDiff, ArgInfo("disp12MaxDiff", 0)) )
| 23914 | { |  | 23866 | {
| 23915 | ERRWRAP2(_self_->setDisp12MaxDiff(disp12MaxDiff)); |  | 23867 | ERRWRAP2(_self_->setDisp12MaxDiff(disp12MaxDiff));
| 23916 | Py_RETURN_NONE; |  | 23868 | Py_RETURN_NONE;
| 23917 | } |  | 23869 | }
| 23918 |  |  | 23870 |
| 23919 | return NULL; |  | 23871 | return NULL;
| 23920 | } |  | 23872 | }
| 23921 |  |  | 23873 |
| 23922 | static PyObject* pyopencv_cv_StereoMatcher_setMinDisparity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23874 | static PyObject* pyopencv_cv_StereoMatcher_setMinDisparity(PyObject* self, PyObject* py_args, PyObject* kw)
| 23923 | { |  | 23875 | {
| 23924 | using namespace cv; |  | 23876 | using namespace cv;
| 23925 |  |  | 23877 |
| 23926 |  |  | 23878 |
| 23927 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23879 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23928 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23880 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23929 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23881 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23930 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23882 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23931 | PyObject* pyobj_minDisparity = NULL; |  | 23883 | PyObject* pyobj_minDisparity = NULL;
| 23932 | int minDisparity=0; |  | 23884 | int minDisparity=0;
| 23933 |  |  | 23885 |
| 23934 | const char* keywords[] = { "minDisparity", NULL }; |  | 23886 | const char* keywords[] = { "minDisparity", NULL };
| 23935 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setMinDisparity", (char**)keywords, &pyobj_minDisparity) && |  | 23887 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setMinDisparity", (char**)keywords, &pyobj_minDisparity) &&
| 23936 | pyopencv_to_safe(pyobj_minDisparity, minDisparity, ArgInfo("minDisparity", 0)) ) |  | 23888 | pyopencv_to_safe(pyobj_minDisparity, minDisparity, ArgInfo("minDisparity", 0)) )
| 23937 | { |  | 23889 | {
| 23938 | ERRWRAP2(_self_->setMinDisparity(minDisparity)); |  | 23890 | ERRWRAP2(_self_->setMinDisparity(minDisparity));
| 23939 | Py_RETURN_NONE; |  | 23891 | Py_RETURN_NONE;
| 23940 | } |  | 23892 | }
| 23941 |  |  | 23893 |
| 23942 | return NULL; |  | 23894 | return NULL;
| 23943 | } |  | 23895 | }
| 23944 |  |  | 23896 |
| 23945 | static PyObject* pyopencv_cv_StereoMatcher_setNumDisparities(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23897 | static PyObject* pyopencv_cv_StereoMatcher_setNumDisparities(PyObject* self, PyObject* py_args, PyObject* kw)
| 23946 | { |  | 23898 | {
| 23947 | using namespace cv; |  | 23899 | using namespace cv;
| 23948 |  |  | 23900 |
| 23949 |  |  | 23901 |
| 23950 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23902 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23951 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23903 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23952 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23904 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23953 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23905 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23954 | PyObject* pyobj_numDisparities = NULL; |  | 23906 | PyObject* pyobj_numDisparities = NULL;
| 23955 | int numDisparities=0; |  | 23907 | int numDisparities=0;
| 23956 |  |  | 23908 |
| 23957 | const char* keywords[] = { "numDisparities", NULL }; |  | 23909 | const char* keywords[] = { "numDisparities", NULL };
| 23958 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setNumDisparities", (char**)keywords, &pyobj_numDisparities) && |  | 23910 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setNumDisparities", (char**)keywords, &pyobj_numDisparities) &&
| 23959 | pyopencv_to_safe(pyobj_numDisparities, numDisparities, ArgInfo("numDisparities", 0)) ) |  | 23911 | pyopencv_to_safe(pyobj_numDisparities, numDisparities, ArgInfo("numDisparities", 0)) )
| 23960 | { |  | 23912 | {
| 23961 | ERRWRAP2(_self_->setNumDisparities(numDisparities)); |  | 23913 | ERRWRAP2(_self_->setNumDisparities(numDisparities));
| 23962 | Py_RETURN_NONE; |  | 23914 | Py_RETURN_NONE;
| 23963 | } |  | 23915 | }
| 23964 |  |  | 23916 |
| 23965 | return NULL; |  | 23917 | return NULL;
| 23966 | } |  | 23918 | }
| 23967 |  |  | 23919 |
| 23968 | static PyObject* pyopencv_cv_StereoMatcher_setSpeckleRange(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23920 | static PyObject* pyopencv_cv_StereoMatcher_setSpeckleRange(PyObject* self, PyObject* py_args, PyObject* kw)
| 23969 | { |  | 23921 | {
| 23970 | using namespace cv; |  | 23922 | using namespace cv;
| 23971 |  |  | 23923 |
| 23972 |  |  | 23924 |
| 23973 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23925 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23974 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23926 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23975 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23927 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23976 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23928 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 23977 | PyObject* pyobj_speckleRange = NULL; |  | 23929 | PyObject* pyobj_speckleRange = NULL;
| 23978 | int speckleRange=0; |  | 23930 | int speckleRange=0;
| 23979 |  |  | 23931 |
| 23980 | const char* keywords[] = { "speckleRange", NULL }; |  | 23932 | const char* keywords[] = { "speckleRange", NULL };
| 23981 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setSpeckleRange", (char**)keywords, &pyobj_speckleRange) && |  | 23933 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setSpeckleRange", (char**)keywords, &pyobj_speckleRange) &&
| 23982 | pyopencv_to_safe(pyobj_speckleRange, speckleRange, ArgInfo("speckleRange", 0)) ) |  | 23934 | pyopencv_to_safe(pyobj_speckleRange, speckleRange, ArgInfo("speckleRange", 0)) )
| 23983 | { |  | 23935 | {
| 23984 | ERRWRAP2(_self_->setSpeckleRange(speckleRange)); |  | 23936 | ERRWRAP2(_self_->setSpeckleRange(speckleRange));
| 23985 | Py_RETURN_NONE; |  | 23937 | Py_RETURN_NONE;
| 23986 | } |  | 23938 | }
| 23987 |  |  | 23939 |
| 23988 | return NULL; |  | 23940 | return NULL;
| 23989 | } |  | 23941 | }
| 23990 |  |  | 23942 |
| 23991 | static PyObject* pyopencv_cv_StereoMatcher_setSpeckleWindowSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 23943 | static PyObject* pyopencv_cv_StereoMatcher_setSpeckleWindowSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 23992 | { |  | 23944 | {
| 23993 | using namespace cv; |  | 23945 | using namespace cv;
| 23994 |  |  | 23946 |
| 23995 |  |  | 23947 |
| 23996 | Ptr<cv::StereoMatcher> * self1 = 0; |  | 23948 | Ptr<cv::StereoMatcher> * self1 = 0;
| 23997 | if (!pyopencv_StereoMatcher_getp(self, self1)) |  | 23949 | if (!pyopencv_StereoMatcher_getp(self, self1))
| 23998 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)"); |  | 23950 | return failmsgp("Incorrect type of self (must be 'StereoMatcher' or its derivative)");
| 23999 | Ptr<cv::StereoMatcher> _self_ = *(self1); |  | 23951 | Ptr<cv::StereoMatcher> _self_ = *(self1);
| 24000 | PyObject* pyobj_speckleWindowSize = NULL; |  | 23952 | PyObject* pyobj_speckleWindowSize = NULL;
| 24001 | int speckleWindowSize=0; |  | 23953 | int speckleWindowSize=0;
| 24002 |  |  | 23954 |
| 24003 | const char* keywords[] = { "speckleWindowSize", NULL }; |  | 23955 | const char* keywords[] = { "speckleWindowSize", NULL };
| 24004 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setSpeckleWindowSize", (char**)keywords, &pyobj_speckleWindowSize) && |  | 23956 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoMatcher.setSpeckleWindowSize", (char**)keywords, &pyobj_speckleWindowSize) &&
| 24005 | pyopencv_to_safe(pyobj_speckleWindowSize, speckleWindowSize, ArgInfo("speckleWindowSize", 0)) ) |  | 23957 | pyopencv_to_safe(pyobj_speckleWindowSize, speckleWindowSize, ArgInfo("speckleWindowSize", 0)) )
| 24006 | { |  | 23958 | {
| 24007 | ERRWRAP2(_self_->setSpeckleWindowSize(speckleWindowSize)); |  | 23959 | ERRWRAP2(_self_->setSpeckleWindowSize(speckleWindowSize));
| 24008 | Py_RETURN_NONE; |  | 23960 | Py_RETURN_NONE;
| 24009 | } |  | 23961 | }
| 24010 |  |  | 23962 |
| 24011 | return NULL; |  | 23963 | return NULL;
| 24012 | } |  | 23964 | }
| 24013 |  |  | 23965 |
| 24014 |  |  | 23966 |
| 24015 |  |  | 23967 |
| 24016 | // Tables (StereoMatcher) |  | 23968 | // Tables (StereoMatcher)
| 24017 |  |  | 23969 |
| 24018 | static PyGetSetDef pyopencv_StereoMatcher_getseters[] = |  | 23970 | static PyGetSetDef pyopencv_StereoMatcher_getseters[] =
| 24019 | { |  | 23971 | {
| 24020 | {NULL} /* Sentinel */ |  | 23972 | {NULL} /* Sentinel */
| 24021 | }; |  | 23973 | };
| 24022 |  |  | 23974 |
| 24023 | static PyMethodDef pyopencv_StereoMatcher_methods[] = |  | 23975 | static PyMethodDef pyopencv_StereoMatcher_methods[] =
| 24024 | { |  | 23976 | {
| 24025 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_compute, 0), "compute(left, right[, disparity]) -> disparity\n. @brief Computes disparity map for the specified stereo pair\n. \n. @param left Left 8-bit single-channel image.\n. @param right Right image of the same size and the same type as the left one.\n. @param disparity Output disparity map. It has the same size as the input images. Some algorithms,\n. like StereoBM or StereoSGBM compute 16-bit fixed-point disparity map (where each disparity value\n. has 4 fractional bits), whereas other algorithms output 32-bit floating-point disparity map."}, |  | 23977 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_compute, 0), "compute(left, right[, disparity]) -> disparity\n. @brief Computes disparity map for the specified stereo pair\n. \n. @param left Left 8-bit single-channel image.\n. @param right Right image of the same size and the same type as the left one.\n. @param disparity Output disparity map. It has the same size as the input images. Some algorithms,\n. like StereoBM or StereoSGBM compute 16-bit fixed-point disparity map (where each disparity value\n. has 4 fractional bits), whereas other algorithms output 32-bit floating-point disparity map."},
| 24026 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getBlockSize, 0), "getBlockSize() -> retval\n."}, |  | 23978 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getBlockSize, 0), "getBlockSize() -> retval\n."},
| 24027 | {"getDisp12MaxDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getDisp12MaxDiff, 0), "getDisp12MaxDiff() -> retval\n."}, |  | 23979 | {"getDisp12MaxDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getDisp12MaxDiff, 0), "getDisp12MaxDiff() -> retval\n."},
| 24028 | {"getMinDisparity", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getMinDisparity, 0), "getMinDisparity() -> retval\n."}, |  | 23980 | {"getMinDisparity", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getMinDisparity, 0), "getMinDisparity() -> retval\n."},
| 24029 | {"getNumDisparities", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getNumDisparities, 0), "getNumDisparities() -> retval\n."}, |  | 23981 | {"getNumDisparities", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getNumDisparities, 0), "getNumDisparities() -> retval\n."},
| 24030 | {"getSpeckleRange", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getSpeckleRange, 0), "getSpeckleRange() -> retval\n."}, |  | 23982 | {"getSpeckleRange", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getSpeckleRange, 0), "getSpeckleRange() -> retval\n."},
| 24031 | {"getSpeckleWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getSpeckleWindowSize, 0), "getSpeckleWindowSize() -> retval\n."}, |  | 23983 | {"getSpeckleWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_getSpeckleWindowSize, 0), "getSpeckleWindowSize() -> retval\n."},
| 24032 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setBlockSize, 0), "setBlockSize(blockSize) -> None\n."}, |  | 23984 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setBlockSize, 0), "setBlockSize(blockSize) -> None\n."},
| 24033 | {"setDisp12MaxDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setDisp12MaxDiff, 0), "setDisp12MaxDiff(disp12MaxDiff) -> None\n."}, |  | 23985 | {"setDisp12MaxDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setDisp12MaxDiff, 0), "setDisp12MaxDiff(disp12MaxDiff) -> None\n."},
| 24034 | {"setMinDisparity", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setMinDisparity, 0), "setMinDisparity(minDisparity) -> None\n."}, |  | 23986 | {"setMinDisparity", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setMinDisparity, 0), "setMinDisparity(minDisparity) -> None\n."},
| 24035 | {"setNumDisparities", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setNumDisparities, 0), "setNumDisparities(numDisparities) -> None\n."}, |  | 23987 | {"setNumDisparities", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setNumDisparities, 0), "setNumDisparities(numDisparities) -> None\n."},
| 24036 | {"setSpeckleRange", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setSpeckleRange, 0), "setSpeckleRange(speckleRange) -> None\n."}, |  | 23988 | {"setSpeckleRange", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setSpeckleRange, 0), "setSpeckleRange(speckleRange) -> None\n."},
| 24037 | {"setSpeckleWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setSpeckleWindowSize, 0), "setSpeckleWindowSize(speckleWindowSize) -> None\n."}, |  | 23989 | {"setSpeckleWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoMatcher_setSpeckleWindowSize, 0), "setSpeckleWindowSize(speckleWindowSize) -> None\n."},
| 24038 |  |  | 23990 |
| 24039 | {NULL, NULL} |  | 23991 | {NULL, NULL}
| 24040 | }; |  | 23992 | };
| 24041 |  |  | 23993 |
| 24042 | // Converter (StereoMatcher) |  | 23994 | // Converter (StereoMatcher)
| 24043 |  |  | 23995 |
| 24044 | template<> |  | 23996 | template<>
| 24045 | struct PyOpenCV_Converter< Ptr<cv::StereoMatcher> > |  | 23997 | struct PyOpenCV_Converter< Ptr<cv::StereoMatcher> >
| 24046 | { |  | 23998 | {
| 24047 | static PyObject* from(const Ptr<cv::StereoMatcher>& r) |  | 23999 | static PyObject* from(const Ptr<cv::StereoMatcher>& r)
| 24048 | { |  | 24000 | {
| 24049 | return pyopencv_StereoMatcher_Instance(r); |  | 24001 | return pyopencv_StereoMatcher_Instance(r);
| 24050 | } |  | 24002 | }
| 24051 | static bool to(PyObject* src, Ptr<cv::StereoMatcher>& dst, const ArgInfo& info) |  | 24003 | static bool to(PyObject* src, Ptr<cv::StereoMatcher>& dst, const ArgInfo& info)
| 24052 | { |  | 24004 | {
| 24053 | if(!src || src == Py_None) |  | 24005 | if(!src || src == Py_None)
| 24054 | return true; |  | 24006 | return true;
| 24055 | Ptr<cv::StereoMatcher> * dst_; |  | 24007 | Ptr<cv::StereoMatcher> * dst_;
| 24056 | if (pyopencv_StereoMatcher_getp(src, dst_)) |  | 24008 | if (pyopencv_StereoMatcher_getp(src, dst_))
| 24057 | { |  | 24009 | {
| 24058 | dst = *dst_; |  | 24010 | dst = *dst_;
| 24059 | return true; |  | 24011 | return true;
| 24060 | } |  | 24012 | }
| 24061 |  |  | 24013 |
| 24062 | failmsg("Expected Ptr<cv::StereoMatcher> for argument '%s'", info.name); |  | 24014 | failmsg("Expected Ptr<cv::StereoMatcher> for argument '%s'", info.name);
| 24063 | return false; |  | 24015 | return false;
| 24064 | } |  | 24016 | }
| 24065 | }; |  | 24017 | };
| 24066 |  |  | 24018 |
| 24067 | //================================================================================ |  | 24019 | //================================================================================
| 24068 | // StereoSGBM (Generic) |  | 24020 | // StereoSGBM (Generic)
| 24069 | //================================================================================ |  | 24021 | //================================================================================
| 24070 |  |  | 24022 |
| 24071 | // GetSet (StereoSGBM) |  | 24023 | // GetSet (StereoSGBM)
| 24072 |  |  | 24024 |
| 24073 |  |  | 24025 |
| 24074 |  |  | 24026 |
| 24075 | // Methods (StereoSGBM) |  | 24027 | // Methods (StereoSGBM)
| 24076 |  |  | 24028 |
| 24077 | static PyObject* pyopencv_cv_StereoSGBM_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24029 | static PyObject* pyopencv_cv_StereoSGBM_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 24078 | { |  | 24030 | {
| 24079 | using namespace cv; |  | 24031 | using namespace cv;
| 24080 |  |  | 24032 |
| 24081 | PyObject* pyobj_minDisparity = NULL; |  | 24033 | PyObject* pyobj_minDisparity = NULL;
| 24082 | int minDisparity=0; |  | 24034 | int minDisparity=0;
| 24083 | PyObject* pyobj_numDisparities = NULL; |  | 24035 | PyObject* pyobj_numDisparities = NULL;
| 24084 | int numDisparities=16; |  | 24036 | int numDisparities=16;
| 24085 | PyObject* pyobj_blockSize = NULL; |  | 24037 | PyObject* pyobj_blockSize = NULL;
| 24086 | int blockSize=3; |  | 24038 | int blockSize=3;
| 24087 | PyObject* pyobj_P1 = NULL; |  | 24039 | PyObject* pyobj_P1 = NULL;
| 24088 | int P1=0; |  | 24040 | int P1=0;
| 24089 | PyObject* pyobj_P2 = NULL; |  | 24041 | PyObject* pyobj_P2 = NULL;
| 24090 | int P2=0; |  | 24042 | int P2=0;
| 24091 | PyObject* pyobj_disp12MaxDiff = NULL; |  | 24043 | PyObject* pyobj_disp12MaxDiff = NULL;
| 24092 | int disp12MaxDiff=0; |  | 24044 | int disp12MaxDiff=0;
| 24093 | PyObject* pyobj_preFilterCap = NULL; |  | 24045 | PyObject* pyobj_preFilterCap = NULL;
| 24094 | int preFilterCap=0; |  | 24046 | int preFilterCap=0;
| 24095 | PyObject* pyobj_uniquenessRatio = NULL; |  | 24047 | PyObject* pyobj_uniquenessRatio = NULL;
| 24096 | int uniquenessRatio=0; |  | 24048 | int uniquenessRatio=0;
| 24097 | PyObject* pyobj_speckleWindowSize = NULL; |  | 24049 | PyObject* pyobj_speckleWindowSize = NULL;
| 24098 | int speckleWindowSize=0; |  | 24050 | int speckleWindowSize=0;
| 24099 | PyObject* pyobj_speckleRange = NULL; |  | 24051 | PyObject* pyobj_speckleRange = NULL;
| 24100 | int speckleRange=0; |  | 24052 | int speckleRange=0;
| 24101 | PyObject* pyobj_mode = NULL; |  | 24053 | PyObject* pyobj_mode = NULL;
| 24102 | int mode=StereoSGBM::MODE_SGBM; |  | 24054 | int mode=StereoSGBM::MODE_SGBM;
| 24103 | Ptr<StereoSGBM> retval; |  | 24055 | Ptr<StereoSGBM> retval;
| 24104 |  |  | 24056 |
| 24105 | const char* keywords[] = { "minDisparity", "numDisparities", "blockSize", "P1", "P2", "disp12MaxDiff", "preFilterCap", "uniquenessRatio", "speckleWindowSize", "speckleRange", "mode", NULL }; |  | 24057 | const char* keywords[] = { "minDisparity", "numDisparities", "blockSize", "P1", "P2", "disp12MaxDiff", "preFilterCap", "uniquenessRatio", "speckleWindowSize", "speckleRange", "mode", NULL };
| 24106 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOOOO:StereoSGBM.create", (char**)keywords, &pyobj_minDisparity, &pyobj_numDisparities, &pyobj_blockSize, &pyobj_P1, &pyobj_P2, &pyobj_disp12MaxDiff, &pyobj_preFilterCap, &pyobj_uniquenessRatio, &pyobj_speckleWindowSize, &pyobj_speckleRange, &pyobj_mode) && |  | 24058 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOOOO:StereoSGBM.create", (char**)keywords, &pyobj_minDisparity, &pyobj_numDisparities, &pyobj_blockSize, &pyobj_P1, &pyobj_P2, &pyobj_disp12MaxDiff, &pyobj_preFilterCap, &pyobj_uniquenessRatio, &pyobj_speckleWindowSize, &pyobj_speckleRange, &pyobj_mode) &&
| 24107 | pyopencv_to_safe(pyobj_minDisparity, minDisparity, ArgInfo("minDisparity", 0)) && |  | 24059 | pyopencv_to_safe(pyobj_minDisparity, minDisparity, ArgInfo("minDisparity", 0)) &&
| 24108 | pyopencv_to_safe(pyobj_numDisparities, numDisparities, ArgInfo("numDisparities", 0)) && |  | 24060 | pyopencv_to_safe(pyobj_numDisparities, numDisparities, ArgInfo("numDisparities", 0)) &&
| 24109 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) && |  | 24061 | pyopencv_to_safe(pyobj_blockSize, blockSize, ArgInfo("blockSize", 0)) &&
| 24110 | pyopencv_to_safe(pyobj_P1, P1, ArgInfo("P1", 0)) && |  | 24062 | pyopencv_to_safe(pyobj_P1, P1, ArgInfo("P1", 0)) &&
| 24111 | pyopencv_to_safe(pyobj_P2, P2, ArgInfo("P2", 0)) && |  | 24063 | pyopencv_to_safe(pyobj_P2, P2, ArgInfo("P2", 0)) &&
| 24112 | pyopencv_to_safe(pyobj_disp12MaxDiff, disp12MaxDiff, ArgInfo("disp12MaxDiff", 0)) && |  | 24064 | pyopencv_to_safe(pyobj_disp12MaxDiff, disp12MaxDiff, ArgInfo("disp12MaxDiff", 0)) &&
| 24113 | pyopencv_to_safe(pyobj_preFilterCap, preFilterCap, ArgInfo("preFilterCap", 0)) && |  | 24065 | pyopencv_to_safe(pyobj_preFilterCap, preFilterCap, ArgInfo("preFilterCap", 0)) &&
| 24114 | pyopencv_to_safe(pyobj_uniquenessRatio, uniquenessRatio, ArgInfo("uniquenessRatio", 0)) && |  | 24066 | pyopencv_to_safe(pyobj_uniquenessRatio, uniquenessRatio, ArgInfo("uniquenessRatio", 0)) &&
| 24115 | pyopencv_to_safe(pyobj_speckleWindowSize, speckleWindowSize, ArgInfo("speckleWindowSize", 0)) && |  | 24067 | pyopencv_to_safe(pyobj_speckleWindowSize, speckleWindowSize, ArgInfo("speckleWindowSize", 0)) &&
| 24116 | pyopencv_to_safe(pyobj_speckleRange, speckleRange, ArgInfo("speckleRange", 0)) && |  | 24068 | pyopencv_to_safe(pyobj_speckleRange, speckleRange, ArgInfo("speckleRange", 0)) &&
| 24117 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) ) |  | 24069 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) )
| 24118 | { |  | 24070 | {
| 24119 | ERRWRAP2(retval = cv::StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode)); |  | 24071 | ERRWRAP2(retval = cv::StereoSGBM::create(minDisparity, numDisparities, blockSize, P1, P2, disp12MaxDiff, preFilterCap, uniquenessRatio, speckleWindowSize, speckleRange, mode));
| 24120 | return pyopencv_from(retval); |  | 24072 | return pyopencv_from(retval);
| 24121 | } |  | 24073 | }
| 24122 |  |  | 24074 |
| 24123 | return NULL; |  | 24075 | return NULL;
| 24124 | } |  | 24076 | }
| 24125 |  |  | 24077 |
| 24126 | static PyObject* pyopencv_cv_StereoSGBM_getMode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24078 | static PyObject* pyopencv_cv_StereoSGBM_getMode(PyObject* self, PyObject* py_args, PyObject* kw)
| 24127 | { |  | 24079 | {
| 24128 | using namespace cv; |  | 24080 | using namespace cv;
| 24129 |  |  | 24081 |
| 24130 |  |  | 24082 |
| 24131 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24083 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24132 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24084 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24133 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24085 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24134 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24086 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24135 | int retval; |  | 24087 | int retval;
| 24136 |  |  | 24088 |
| 24137 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24089 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24138 | { |  | 24090 | {
| 24139 | ERRWRAP2(retval = _self_->getMode()); |  | 24091 | ERRWRAP2(retval = _self_->getMode());
| 24140 | return pyopencv_from(retval); |  | 24092 | return pyopencv_from(retval);
| 24141 | } |  | 24093 | }
| 24142 |  |  | 24094 |
| 24143 | return NULL; |  | 24095 | return NULL;
| 24144 | } |  | 24096 | }
| 24145 |  |  | 24097 |
| 24146 | static PyObject* pyopencv_cv_StereoSGBM_getP1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24098 | static PyObject* pyopencv_cv_StereoSGBM_getP1(PyObject* self, PyObject* py_args, PyObject* kw)
| 24147 | { |  | 24099 | {
| 24148 | using namespace cv; |  | 24100 | using namespace cv;
| 24149 |  |  | 24101 |
| 24150 |  |  | 24102 |
| 24151 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24103 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24152 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24104 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24153 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24105 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24154 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24106 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24155 | int retval; |  | 24107 | int retval;
| 24156 |  |  | 24108 |
| 24157 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24109 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24158 | { |  | 24110 | {
| 24159 | ERRWRAP2(retval = _self_->getP1()); |  | 24111 | ERRWRAP2(retval = _self_->getP1());
| 24160 | return pyopencv_from(retval); |  | 24112 | return pyopencv_from(retval);
| 24161 | } |  | 24113 | }
| 24162 |  |  | 24114 |
| 24163 | return NULL; |  | 24115 | return NULL;
| 24164 | } |  | 24116 | }
| 24165 |  |  | 24117 |
| 24166 | static PyObject* pyopencv_cv_StereoSGBM_getP2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24118 | static PyObject* pyopencv_cv_StereoSGBM_getP2(PyObject* self, PyObject* py_args, PyObject* kw)
| 24167 | { |  | 24119 | {
| 24168 | using namespace cv; |  | 24120 | using namespace cv;
| 24169 |  |  | 24121 |
| 24170 |  |  | 24122 |
| 24171 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24123 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24172 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24124 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24173 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24125 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24174 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24126 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24175 | int retval; |  | 24127 | int retval;
| 24176 |  |  | 24128 |
| 24177 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24129 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24178 | { |  | 24130 | {
| 24179 | ERRWRAP2(retval = _self_->getP2()); |  | 24131 | ERRWRAP2(retval = _self_->getP2());
| 24180 | return pyopencv_from(retval); |  | 24132 | return pyopencv_from(retval);
| 24181 | } |  | 24133 | }
| 24182 |  |  | 24134 |
| 24183 | return NULL; |  | 24135 | return NULL;
| 24184 | } |  | 24136 | }
| 24185 |  |  | 24137 |
| 24186 | static PyObject* pyopencv_cv_StereoSGBM_getPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24138 | static PyObject* pyopencv_cv_StereoSGBM_getPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw)
| 24187 | { |  | 24139 | {
| 24188 | using namespace cv; |  | 24140 | using namespace cv;
| 24189 |  |  | 24141 |
| 24190 |  |  | 24142 |
| 24191 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24143 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24192 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24144 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24193 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24145 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24194 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24146 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24195 | int retval; |  | 24147 | int retval;
| 24196 |  |  | 24148 |
| 24197 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24149 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24198 | { |  | 24150 | {
| 24199 | ERRWRAP2(retval = _self_->getPreFilterCap()); |  | 24151 | ERRWRAP2(retval = _self_->getPreFilterCap());
| 24200 | return pyopencv_from(retval); |  | 24152 | return pyopencv_from(retval);
| 24201 | } |  | 24153 | }
| 24202 |  |  | 24154 |
| 24203 | return NULL; |  | 24155 | return NULL;
| 24204 | } |  | 24156 | }
| 24205 |  |  | 24157 |
| 24206 | static PyObject* pyopencv_cv_StereoSGBM_getUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24158 | static PyObject* pyopencv_cv_StereoSGBM_getUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 24207 | { |  | 24159 | {
| 24208 | using namespace cv; |  | 24160 | using namespace cv;
| 24209 |  |  | 24161 |
| 24210 |  |  | 24162 |
| 24211 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24163 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24212 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24164 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24213 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24165 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24214 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24166 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24215 | int retval; |  | 24167 | int retval;
| 24216 |  |  | 24168 |
| 24217 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24169 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24218 | { |  | 24170 | {
| 24219 | ERRWRAP2(retval = _self_->getUniquenessRatio()); |  | 24171 | ERRWRAP2(retval = _self_->getUniquenessRatio());
| 24220 | return pyopencv_from(retval); |  | 24172 | return pyopencv_from(retval);
| 24221 | } |  | 24173 | }
| 24222 |  |  | 24174 |
| 24223 | return NULL; |  | 24175 | return NULL;
| 24224 | } |  | 24176 | }
| 24225 |  |  | 24177 |
| 24226 | static PyObject* pyopencv_cv_StereoSGBM_setMode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24178 | static PyObject* pyopencv_cv_StereoSGBM_setMode(PyObject* self, PyObject* py_args, PyObject* kw)
| 24227 | { |  | 24179 | {
| 24228 | using namespace cv; |  | 24180 | using namespace cv;
| 24229 |  |  | 24181 |
| 24230 |  |  | 24182 |
| 24231 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24183 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24232 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24184 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24233 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24185 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24234 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24186 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24235 | PyObject* pyobj_mode = NULL; |  | 24187 | PyObject* pyobj_mode = NULL;
| 24236 | int mode=0; |  | 24188 | int mode=0;
| 24237 |  |  | 24189 |
| 24238 | const char* keywords[] = { "mode", NULL }; |  | 24190 | const char* keywords[] = { "mode", NULL };
| 24239 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setMode", (char**)keywords, &pyobj_mode) && |  | 24191 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setMode", (char**)keywords, &pyobj_mode) &&
| 24240 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) ) |  | 24192 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) )
| 24241 | { |  | 24193 | {
| 24242 | ERRWRAP2(_self_->setMode(mode)); |  | 24194 | ERRWRAP2(_self_->setMode(mode));
| 24243 | Py_RETURN_NONE; |  | 24195 | Py_RETURN_NONE;
| 24244 | } |  | 24196 | }
| 24245 |  |  | 24197 |
| 24246 | return NULL; |  | 24198 | return NULL;
| 24247 | } |  | 24199 | }
| 24248 |  |  | 24200 |
| 24249 | static PyObject* pyopencv_cv_StereoSGBM_setP1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24201 | static PyObject* pyopencv_cv_StereoSGBM_setP1(PyObject* self, PyObject* py_args, PyObject* kw)
| 24250 | { |  | 24202 | {
| 24251 | using namespace cv; |  | 24203 | using namespace cv;
| 24252 |  |  | 24204 |
| 24253 |  |  | 24205 |
| 24254 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24206 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24255 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24207 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24256 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24208 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24257 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24209 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24258 | PyObject* pyobj_P1 = NULL; |  | 24210 | PyObject* pyobj_P1 = NULL;
| 24259 | int P1=0; |  | 24211 | int P1=0;
| 24260 |  |  | 24212 |
| 24261 | const char* keywords[] = { "P1", NULL }; |  | 24213 | const char* keywords[] = { "P1", NULL };
| 24262 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setP1", (char**)keywords, &pyobj_P1) && |  | 24214 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setP1", (char**)keywords, &pyobj_P1) &&
| 24263 | pyopencv_to_safe(pyobj_P1, P1, ArgInfo("P1", 0)) ) |  | 24215 | pyopencv_to_safe(pyobj_P1, P1, ArgInfo("P1", 0)) )
| 24264 | { |  | 24216 | {
| 24265 | ERRWRAP2(_self_->setP1(P1)); |  | 24217 | ERRWRAP2(_self_->setP1(P1));
| 24266 | Py_RETURN_NONE; |  | 24218 | Py_RETURN_NONE;
| 24267 | } |  | 24219 | }
| 24268 |  |  | 24220 |
| 24269 | return NULL; |  | 24221 | return NULL;
| 24270 | } |  | 24222 | }
| 24271 |  |  | 24223 |
| 24272 | static PyObject* pyopencv_cv_StereoSGBM_setP2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24224 | static PyObject* pyopencv_cv_StereoSGBM_setP2(PyObject* self, PyObject* py_args, PyObject* kw)
| 24273 | { |  | 24225 | {
| 24274 | using namespace cv; |  | 24226 | using namespace cv;
| 24275 |  |  | 24227 |
| 24276 |  |  | 24228 |
| 24277 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24229 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24278 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24230 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24279 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24231 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24280 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24232 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24281 | PyObject* pyobj_P2 = NULL; |  | 24233 | PyObject* pyobj_P2 = NULL;
| 24282 | int P2=0; |  | 24234 | int P2=0;
| 24283 |  |  | 24235 |
| 24284 | const char* keywords[] = { "P2", NULL }; |  | 24236 | const char* keywords[] = { "P2", NULL };
| 24285 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setP2", (char**)keywords, &pyobj_P2) && |  | 24237 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setP2", (char**)keywords, &pyobj_P2) &&
| 24286 | pyopencv_to_safe(pyobj_P2, P2, ArgInfo("P2", 0)) ) |  | 24238 | pyopencv_to_safe(pyobj_P2, P2, ArgInfo("P2", 0)) )
| 24287 | { |  | 24239 | {
| 24288 | ERRWRAP2(_self_->setP2(P2)); |  | 24240 | ERRWRAP2(_self_->setP2(P2));
| 24289 | Py_RETURN_NONE; |  | 24241 | Py_RETURN_NONE;
| 24290 | } |  | 24242 | }
| 24291 |  |  | 24243 |
| 24292 | return NULL; |  | 24244 | return NULL;
| 24293 | } |  | 24245 | }
| 24294 |  |  | 24246 |
| 24295 | static PyObject* pyopencv_cv_StereoSGBM_setPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24247 | static PyObject* pyopencv_cv_StereoSGBM_setPreFilterCap(PyObject* self, PyObject* py_args, PyObject* kw)
| 24296 | { |  | 24248 | {
| 24297 | using namespace cv; |  | 24249 | using namespace cv;
| 24298 |  |  | 24250 |
| 24299 |  |  | 24251 |
| 24300 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24252 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24301 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24253 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24302 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24254 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24303 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24255 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24304 | PyObject* pyobj_preFilterCap = NULL; |  | 24256 | PyObject* pyobj_preFilterCap = NULL;
| 24305 | int preFilterCap=0; |  | 24257 | int preFilterCap=0;
| 24306 |  |  | 24258 |
| 24307 | const char* keywords[] = { "preFilterCap", NULL }; |  | 24259 | const char* keywords[] = { "preFilterCap", NULL };
| 24308 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setPreFilterCap", (char**)keywords, &pyobj_preFilterCap) && |  | 24260 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setPreFilterCap", (char**)keywords, &pyobj_preFilterCap) &&
| 24309 | pyopencv_to_safe(pyobj_preFilterCap, preFilterCap, ArgInfo("preFilterCap", 0)) ) |  | 24261 | pyopencv_to_safe(pyobj_preFilterCap, preFilterCap, ArgInfo("preFilterCap", 0)) )
| 24310 | { |  | 24262 | {
| 24311 | ERRWRAP2(_self_->setPreFilterCap(preFilterCap)); |  | 24263 | ERRWRAP2(_self_->setPreFilterCap(preFilterCap));
| 24312 | Py_RETURN_NONE; |  | 24264 | Py_RETURN_NONE;
| 24313 | } |  | 24265 | }
| 24314 |  |  | 24266 |
| 24315 | return NULL; |  | 24267 | return NULL;
| 24316 | } |  | 24268 | }
| 24317 |  |  | 24269 |
| 24318 | static PyObject* pyopencv_cv_StereoSGBM_setUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24270 | static PyObject* pyopencv_cv_StereoSGBM_setUniquenessRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 24319 | { |  | 24271 | {
| 24320 | using namespace cv; |  | 24272 | using namespace cv;
| 24321 |  |  | 24273 |
| 24322 |  |  | 24274 |
| 24323 | Ptr<cv::StereoSGBM> * self1 = 0; |  | 24275 | Ptr<cv::StereoSGBM> * self1 = 0;
| 24324 | if (!pyopencv_StereoSGBM_getp(self, self1)) |  | 24276 | if (!pyopencv_StereoSGBM_getp(self, self1))
| 24325 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)"); |  | 24277 | return failmsgp("Incorrect type of self (must be 'StereoSGBM' or its derivative)");
| 24326 | Ptr<cv::StereoSGBM> _self_ = *(self1); |  | 24278 | Ptr<cv::StereoSGBM> _self_ = *(self1);
| 24327 | PyObject* pyobj_uniquenessRatio = NULL; |  | 24279 | PyObject* pyobj_uniquenessRatio = NULL;
| 24328 | int uniquenessRatio=0; |  | 24280 | int uniquenessRatio=0;
| 24329 |  |  | 24281 |
| 24330 | const char* keywords[] = { "uniquenessRatio", NULL }; |  | 24282 | const char* keywords[] = { "uniquenessRatio", NULL };
| 24331 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setUniquenessRatio", (char**)keywords, &pyobj_uniquenessRatio) && |  | 24283 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:StereoSGBM.setUniquenessRatio", (char**)keywords, &pyobj_uniquenessRatio) &&
| 24332 | pyopencv_to_safe(pyobj_uniquenessRatio, uniquenessRatio, ArgInfo("uniquenessRatio", 0)) ) |  | 24284 | pyopencv_to_safe(pyobj_uniquenessRatio, uniquenessRatio, ArgInfo("uniquenessRatio", 0)) )
| 24333 | { |  | 24285 | {
| 24334 | ERRWRAP2(_self_->setUniquenessRatio(uniquenessRatio)); |  | 24286 | ERRWRAP2(_self_->setUniquenessRatio(uniquenessRatio));
| 24335 | Py_RETURN_NONE; |  | 24287 | Py_RETURN_NONE;
| 24336 | } |  | 24288 | }
| 24337 |  |  | 24289 |
| 24338 | return NULL; |  | 24290 | return NULL;
| 24339 | } |  | 24291 | }
| 24340 |  |  | 24292 |
| 24341 |  |  | 24293 |
| 24342 |  |  | 24294 |
| 24343 | // Tables (StereoSGBM) |  | 24295 | // Tables (StereoSGBM)
| 24344 |  |  | 24296 |
| 24345 | static PyGetSetDef pyopencv_StereoSGBM_getseters[] = |  | 24297 | static PyGetSetDef pyopencv_StereoSGBM_getseters[] =
| 24346 | { |  | 24298 | {
| 24347 | {NULL} /* Sentinel */ |  | 24299 | {NULL} /* Sentinel */
| 24348 | }; |  | 24300 | };
| 24349 |  |  | 24301 |
| 24350 | static PyMethodDef pyopencv_StereoSGBM_methods[] = |  | 24302 | static PyMethodDef pyopencv_StereoSGBM_methods[] =
| 24351 | { |  | 24303 | {
| 24352 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_create_static, METH_STATIC), "create([, minDisparity[, numDisparities[, blockSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, mode]]]]]]]]]]]) -> retval\n. @brief Creates StereoSGBM object\n. \n. @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes\n. rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.\n. @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than\n. zero. In the current implementation, this parameter must be divisible by 16.\n. @param blockSize Matched block size. It must be an odd number \\>=1 . Normally, it should be\n. somewhere in the 3..11 range.\n. @param P1 The first parameter controlling the disparity smoothness. See below.\n. @param P2 The second parameter controlling the disparity smoothness. The larger the values are,\n. the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1\n. between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor\n. pixels. The algorithm requires P2 \\> P1 . See stereo_match.cpp sample where some reasonably good\n. P1 and P2 values are shown (like 8\\*number_of_image_channels\\*blockSize\\*blockSize and\n. 32\\*number_of_image_channels\\*blockSize\\*blockSize , respectively).\n. @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right\n. disparity check. Set it to a non-positive value to disable the check.\n. @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first\n. computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.\n. The result values are passed to the Birchfield-Tomasi pixel cost function.\n. @param uniquenessRatio Margin in percentage by which the best (minimum) computed cost function\n. value should \"win\" the second best value to consider the found match correct. Normally, a value\n. within the 5-15 range is good enough.\n. @param speckleWindowSize Maximum size of smooth disparity regions to consider their noise speckles\n. and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the\n. 50-200 range.\n. @param speckleRange Maximum disparity variation within each connected component. If you do speckle\n. filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.\n. Normally, 1 or 2 is good enough.\n. @param mode Set it to StereoSGBM::MODE_HH to run the full-scale two-pass dynamic programming\n. algorithm. It will consume O(W\\*H\\*numDisparities) bytes, which is large for 640x480 stereo and\n. huge for HD-size pictures. By default, it is set to false .\n. \n. The first constructor initializes StereoSGBM with all the default parameters. So, you only have to\n. set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter\n. to a custom value."}, |  | 24304 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_create_static, METH_STATIC), "create([, minDisparity[, numDisparities[, blockSize[, P1[, P2[, disp12MaxDiff[, preFilterCap[, uniquenessRatio[, speckleWindowSize[, speckleRange[, mode]]]]]]]]]]]) -> retval\n. @brief Creates StereoSGBM object\n. \n. @param minDisparity Minimum possible disparity value. Normally, it is zero but sometimes\n. rectification algorithms can shift images, so this parameter needs to be adjusted accordingly.\n. @param numDisparities Maximum disparity minus minimum disparity. The value is always greater than\n. zero. In the current implementation, this parameter must be divisible by 16.\n. @param blockSize Matched block size. It must be an odd number \\>=1 . Normally, it should be\n. somewhere in the 3..11 range.\n. @param P1 The first parameter controlling the disparity smoothness. See below.\n. @param P2 The second parameter controlling the disparity smoothness. The larger the values are,\n. the smoother the disparity is. P1 is the penalty on the disparity change by plus or minus 1\n. between neighbor pixels. P2 is the penalty on the disparity change by more than 1 between neighbor\n. pixels. The algorithm requires P2 \\> P1 . See stereo_match.cpp sample where some reasonably good\n. P1 and P2 values are shown (like 8\\*number_of_image_channels\\*blockSize\\*blockSize and\n. 32\\*number_of_image_channels\\*blockSize\\*blockSize , respectively).\n. @param disp12MaxDiff Maximum allowed difference (in integer pixel units) in the left-right\n. disparity check. Set it to a non-positive value to disable the check.\n. @param preFilterCap Truncation value for the prefiltered image pixels. The algorithm first\n. computes x-derivative at each pixel and clips its value by [-preFilterCap, preFilterCap] interval.\n. The result values are passed to the Birchfield-Tomasi pixel cost function.\n. @param uniquenessRatio Margin in percentage by which the best (minimum) computed cost function\n. value should \"win\" the second best value to consider the found match correct. Normally, a value\n. within the 5-15 range is good enough.\n. @param speckleWindowSize Maximum size of smooth disparity regions to consider their noise speckles\n. and invalidate. Set it to 0 to disable speckle filtering. Otherwise, set it somewhere in the\n. 50-200 range.\n. @param speckleRange Maximum disparity variation within each connected component. If you do speckle\n. filtering, set the parameter to a positive value, it will be implicitly multiplied by 16.\n. Normally, 1 or 2 is good enough.\n. @param mode Set it to StereoSGBM::MODE_HH to run the full-scale two-pass dynamic programming\n. algorithm. It will consume O(W\\*H\\*numDisparities) bytes, which is large for 640x480 stereo and\n. huge for HD-size pictures. By default, it is set to false .\n. \n. The first constructor initializes StereoSGBM with all the default parameters. So, you only have to\n. set StereoSGBM::numDisparities at minimum. The second constructor enables you to set each parameter\n. to a custom value."},
| 24353 | {"getMode", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getMode, 0), "getMode() -> retval\n."}, |  | 24305 | {"getMode", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getMode, 0), "getMode() -> retval\n."},
| 24354 | {"getP1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getP1, 0), "getP1() -> retval\n."}, |  | 24306 | {"getP1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getP1, 0), "getP1() -> retval\n."},
| 24355 | {"getP2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getP2, 0), "getP2() -> retval\n."}, |  | 24307 | {"getP2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getP2, 0), "getP2() -> retval\n."},
| 24356 | {"getPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getPreFilterCap, 0), "getPreFilterCap() -> retval\n."}, |  | 24308 | {"getPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getPreFilterCap, 0), "getPreFilterCap() -> retval\n."},
| 24357 | {"getUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getUniquenessRatio, 0), "getUniquenessRatio() -> retval\n."}, |  | 24309 | {"getUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_getUniquenessRatio, 0), "getUniquenessRatio() -> retval\n."},
| 24358 | {"setMode", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setMode, 0), "setMode(mode) -> None\n."}, |  | 24310 | {"setMode", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setMode, 0), "setMode(mode) -> None\n."},
| 24359 | {"setP1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setP1, 0), "setP1(P1) -> None\n."}, |  | 24311 | {"setP1", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setP1, 0), "setP1(P1) -> None\n."},
| 24360 | {"setP2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setP2, 0), "setP2(P2) -> None\n."}, |  | 24312 | {"setP2", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setP2, 0), "setP2(P2) -> None\n."},
| 24361 | {"setPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setPreFilterCap, 0), "setPreFilterCap(preFilterCap) -> None\n."}, |  | 24313 | {"setPreFilterCap", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setPreFilterCap, 0), "setPreFilterCap(preFilterCap) -> None\n."},
| 24362 | {"setUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setUniquenessRatio, 0), "setUniquenessRatio(uniquenessRatio) -> None\n."}, |  | 24314 | {"setUniquenessRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_StereoSGBM_setUniquenessRatio, 0), "setUniquenessRatio(uniquenessRatio) -> None\n."},
| 24363 |  |  | 24315 |
| 24364 | {NULL, NULL} |  | 24316 | {NULL, NULL}
| 24365 | }; |  | 24317 | };
| 24366 |  |  | 24318 |
| 24367 | // Converter (StereoSGBM) |  | 24319 | // Converter (StereoSGBM)
| 24368 |  |  | 24320 |
| 24369 | template<> |  | 24321 | template<>
| 24370 | struct PyOpenCV_Converter< Ptr<cv::StereoSGBM> > |  | 24322 | struct PyOpenCV_Converter< Ptr<cv::StereoSGBM> >
| 24371 | { |  | 24323 | {
| 24372 | static PyObject* from(const Ptr<cv::StereoSGBM>& r) |  | 24324 | static PyObject* from(const Ptr<cv::StereoSGBM>& r)
| 24373 | { |  | 24325 | {
| 24374 | return pyopencv_StereoSGBM_Instance(r); |  | 24326 | return pyopencv_StereoSGBM_Instance(r);
| 24375 | } |  | 24327 | }
| 24376 | static bool to(PyObject* src, Ptr<cv::StereoSGBM>& dst, const ArgInfo& info) |  | 24328 | static bool to(PyObject* src, Ptr<cv::StereoSGBM>& dst, const ArgInfo& info)
| 24377 | { |  | 24329 | {
| 24378 | if(!src || src == Py_None) |  | 24330 | if(!src || src == Py_None)
| 24379 | return true; |  | 24331 | return true;
| 24380 | Ptr<cv::StereoSGBM> * dst_; |  | 24332 | Ptr<cv::StereoSGBM> * dst_;
| 24381 | if (pyopencv_StereoSGBM_getp(src, dst_)) |  | 24333 | if (pyopencv_StereoSGBM_getp(src, dst_))
| 24382 | { |  | 24334 | {
| 24383 | dst = *dst_; |  | 24335 | dst = *dst_;
| 24384 | return true; |  | 24336 | return true;
| 24385 | } |  | 24337 | }
| 24386 |  |  | 24338 |
| 24387 | failmsg("Expected Ptr<cv::StereoSGBM> for argument '%s'", info.name); |  | 24339 | failmsg("Expected Ptr<cv::StereoSGBM> for argument '%s'", info.name);
| 24388 | return false; |  | 24340 | return false;
| 24389 | } |  | 24341 | }
| 24390 | }; |  | 24342 | };
| 24391 |  |  | 24343 |
| 24392 | //================================================================================ |  | 24344 | //================================================================================
| 24393 | // Stitcher (Generic) |  | 24345 | // Stitcher (Generic)
| 24394 | //================================================================================ |  | 24346 | //================================================================================
| 24395 |  |  | 24347 |
| 24396 | // GetSet (Stitcher) |  | 24348 | // GetSet (Stitcher)
| 24397 |  |  | 24349 |
| 24398 |  |  | 24350 |
| 24399 |  |  | 24351 |
| 24400 | // Methods (Stitcher) |  | 24352 | // Methods (Stitcher)
| 24401 |  |  | 24353 |
| 24402 | static PyObject* pyopencv_cv_Stitcher_cameras(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24354 | static PyObject* pyopencv_cv_Stitcher_cameras(PyObject* self, PyObject* py_args, PyObject* kw)
| 24403 | { |  | 24355 | {
| 24404 | using namespace cv; |  | 24356 | using namespace cv;
| 24405 |  |  | 24357 |
| 24406 |  |  | 24358 |
| 24407 | Ptr<cv::Stitcher> * self1 = 0; |  | 24359 | Ptr<cv::Stitcher> * self1 = 0;
| 24408 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24360 | if (!pyopencv_Stitcher_getp(self, self1))
| 24409 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24361 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24410 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24362 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24411 | std::vector<cv::detail::CameraParams> retval; |  | 24363 | std::vector<cv::detail::CameraParams> retval;
| 24412 |  |  | 24364 |
| 24413 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24365 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24414 | { |  | 24366 | {
| 24415 | ERRWRAP2(retval = _self_->cameras()); |  | 24367 | ERRWRAP2(retval = _self_->cameras());
| 24416 | return pyopencv_from(retval); |  | 24368 | return pyopencv_from(retval);
| 24417 | } |  | 24369 | }
| 24418 |  |  | 24370 |
| 24419 | return NULL; |  | 24371 | return NULL;
| 24420 | } |  | 24372 | }
| 24421 |  |  | 24373 |
| 24422 | static PyObject* pyopencv_cv_Stitcher_component(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24374 | static PyObject* pyopencv_cv_Stitcher_component(PyObject* self, PyObject* py_args, PyObject* kw)
| 24423 | { |  | 24375 | {
| 24424 | using namespace cv; |  | 24376 | using namespace cv;
| 24425 |  |  | 24377 |
| 24426 |  |  | 24378 |
| 24427 | Ptr<cv::Stitcher> * self1 = 0; |  | 24379 | Ptr<cv::Stitcher> * self1 = 0;
| 24428 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24380 | if (!pyopencv_Stitcher_getp(self, self1))
| 24429 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24381 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24430 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24382 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24431 | std::vector<int> retval; |  | 24383 | std::vector<int> retval;
| 24432 |  |  | 24384 |
| 24433 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24385 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24434 | { |  | 24386 | {
| 24435 | ERRWRAP2(retval = _self_->component()); |  | 24387 | ERRWRAP2(retval = _self_->component());
| 24436 | return pyopencv_from(retval); |  | 24388 | return pyopencv_from(retval);
| 24437 | } |  | 24389 | }
| 24438 |  |  | 24390 |
| 24439 | return NULL; |  | 24391 | return NULL;
| 24440 | } |  | 24392 | }
| 24441 |  |  | 24393 |
| 24442 | static PyObject* pyopencv_cv_Stitcher_composePanorama(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24394 | static PyObject* pyopencv_cv_Stitcher_composePanorama(PyObject* self, PyObject* py_args, PyObject* kw)
| 24443 | { |  | 24395 | {
| 24444 | using namespace cv; |  | 24396 | using namespace cv;
| 24445 |  |  | 24397 |
| 24446 |  |  | 24398 |
| 24447 | Ptr<cv::Stitcher> * self1 = 0; |  | 24399 | Ptr<cv::Stitcher> * self1 = 0;
| 24448 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24400 | if (!pyopencv_Stitcher_getp(self, self1))
| 24449 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24401 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24450 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24402 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24451 | pyPrepareArgumentConversionErrorsStorage(4); |  | 24403 | pyPrepareArgumentConversionErrorsStorage(4);
| 24452 |  |  | 24404 |
| 24453 | { |  | 24405 | {
| 24454 | PyObject* pyobj_pano = NULL; |  | 24406 | PyObject* pyobj_pano = NULL;
| 24455 | Mat pano; |  | 24407 | Mat pano;
| 24456 | Status retval; |  | 24408 | Status retval;
| 24457 |  |  | 24409 |
| 24458 | const char* keywords[] = { "pano", NULL }; |  | 24410 | const char* keywords[] = { "pano", NULL };
| 24459 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Stitcher.composePanorama", (char**)keywords, &pyobj_pano) && |  | 24411 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Stitcher.composePanorama", (char**)keywords, &pyobj_pano) &&
| 24460 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24412 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24461 | { |  | 24413 | {
| 24462 | ERRWRAP2(retval = _self_->composePanorama(pano)); |  | 24414 | ERRWRAP2(retval = _self_->composePanorama(pano));
| 24463 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24415 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24464 | } |  | 24416 | }
| 24465 |  |  | 24417 |
| 24466 |  |  | 24418 |
| 24467 | pyPopulateArgumentConversionErrors(); |  | 24419 | pyPopulateArgumentConversionErrors();
| 24468 | } |  | 24420 | }
| 24469 |  |  | 24421 |
| 24470 |  |  | 24422 |
| 24471 | { |  | 24423 | {
| 24472 | PyObject* pyobj_images = NULL; |  | 24424 | PyObject* pyobj_images = NULL;
| 24473 | vector_Mat images; |  | 24425 | vector_Mat images;
| 24474 | PyObject* pyobj_pano = NULL; |  | 24426 | PyObject* pyobj_pano = NULL;
| 24475 | Mat pano; |  | 24427 | Mat pano;
| 24476 | Status retval; |  | 24428 | Status retval;
| 24477 |  |  | 24429 |
| 24478 | const char* keywords[] = { "images", "pano", NULL }; |  | 24430 | const char* keywords[] = { "images", "pano", NULL };
| 24479 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.composePanorama", (char**)keywords, &pyobj_images, &pyobj_pano) && |  | 24431 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.composePanorama", (char**)keywords, &pyobj_images, &pyobj_pano) &&
| 24480 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24432 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24481 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24433 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24482 | { |  | 24434 | {
| 24483 | ERRWRAP2(retval = _self_->composePanorama(images, pano)); |  | 24435 | ERRWRAP2(retval = _self_->composePanorama(images, pano));
| 24484 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24436 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24485 | } |  | 24437 | }
| 24486 |  |  | 24438 |
| 24487 |  |  | 24439 |
| 24488 | pyPopulateArgumentConversionErrors(); |  | 24440 | pyPopulateArgumentConversionErrors();
| 24489 | } |  | 24441 | }
| 24490 |  |  | 24442 |
| 24491 |  |  | 24443 |
| 24492 | { |  | 24444 | {
| 24493 | PyObject* pyobj_pano = NULL; |  | 24445 | PyObject* pyobj_pano = NULL;
| 24494 | UMat pano; |  | 24446 | UMat pano;
| 24495 | Status retval; |  | 24447 | Status retval;
| 24496 |  |  | 24448 |
| 24497 | const char* keywords[] = { "pano", NULL }; |  | 24449 | const char* keywords[] = { "pano", NULL };
| 24498 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Stitcher.composePanorama", (char**)keywords, &pyobj_pano) && |  | 24450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Stitcher.composePanorama", (char**)keywords, &pyobj_pano) &&
| 24499 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24451 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24500 | { |  | 24452 | {
| 24501 | ERRWRAP2(retval = _self_->composePanorama(pano)); |  | 24453 | ERRWRAP2(retval = _self_->composePanorama(pano));
| 24502 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24454 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24503 | } |  | 24455 | }
| 24504 |  |  | 24456 |
| 24505 |  |  | 24457 |
| 24506 | pyPopulateArgumentConversionErrors(); |  | 24458 | pyPopulateArgumentConversionErrors();
| 24507 | } |  | 24459 | }
| 24508 |  |  | 24460 |
| 24509 |  |  | 24461 |
| 24510 | { |  | 24462 | {
| 24511 | PyObject* pyobj_images = NULL; |  | 24463 | PyObject* pyobj_images = NULL;
| 24512 | vector_UMat images; |  | 24464 | vector_UMat images;
| 24513 | PyObject* pyobj_pano = NULL; |  | 24465 | PyObject* pyobj_pano = NULL;
| 24514 | UMat pano; |  | 24466 | UMat pano;
| 24515 | Status retval; |  | 24467 | Status retval;
| 24516 |  |  | 24468 |
| 24517 | const char* keywords[] = { "images", "pano", NULL }; |  | 24469 | const char* keywords[] = { "images", "pano", NULL };
| 24518 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.composePanorama", (char**)keywords, &pyobj_images, &pyobj_pano) && |  | 24470 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.composePanorama", (char**)keywords, &pyobj_images, &pyobj_pano) &&
| 24519 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24471 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24520 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24472 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24521 | { |  | 24473 | {
| 24522 | ERRWRAP2(retval = _self_->composePanorama(images, pano)); |  | 24474 | ERRWRAP2(retval = _self_->composePanorama(images, pano));
| 24523 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24475 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24524 | } |  | 24476 | }
| 24525 |  |  | 24477 |
| 24526 |  |  | 24478 |
| 24527 | pyPopulateArgumentConversionErrors(); |  | 24479 | pyPopulateArgumentConversionErrors();
| 24528 | } |  | 24480 | }
| 24529 | pyRaiseCVOverloadException("composePanorama"); |  | 24481 | pyRaiseCVOverloadException("composePanorama");
| 24530 |  |  | 24482 |
| 24531 | return NULL; |  | 24483 | return NULL;
| 24532 | } |  | 24484 | }
| 24533 |  |  | 24485 |
| 24534 | static PyObject* pyopencv_cv_Stitcher_compositingResol(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24486 | static PyObject* pyopencv_cv_Stitcher_compositingResol(PyObject* self, PyObject* py_args, PyObject* kw)
| 24535 | { |  | 24487 | {
| 24536 | using namespace cv; |  | 24488 | using namespace cv;
| 24537 |  |  | 24489 |
| 24538 |  |  | 24490 |
| 24539 | Ptr<cv::Stitcher> * self1 = 0; |  | 24491 | Ptr<cv::Stitcher> * self1 = 0;
| 24540 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24492 | if (!pyopencv_Stitcher_getp(self, self1))
| 24541 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24493 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24542 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24494 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24543 | double retval; |  | 24495 | double retval;
| 24544 |  |  | 24496 |
| 24545 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24497 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24546 | { |  | 24498 | {
| 24547 | ERRWRAP2(retval = _self_->compositingResol()); |  | 24499 | ERRWRAP2(retval = _self_->compositingResol());
| 24548 | return pyopencv_from(retval); |  | 24500 | return pyopencv_from(retval);
| 24549 | } |  | 24501 | }
| 24550 |  |  | 24502 |
| 24551 | return NULL; |  | 24503 | return NULL;
| 24552 | } |  | 24504 | }
| 24553 |  |  | 24505 |
| 24554 | static PyObject* pyopencv_cv_Stitcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24506 | static PyObject* pyopencv_cv_Stitcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 24555 | { |  | 24507 | {
| 24556 | using namespace cv; |  | 24508 | using namespace cv;
| 24557 |  |  | 24509 |
| 24558 | PyObject* pyobj_mode = NULL; |  | 24510 | PyObject* pyobj_mode = NULL;
| 24559 | Mode mode=Stitcher::PANORAMA; |  | 24511 | Mode mode=Stitcher::PANORAMA;
| 24560 | Ptr<Stitcher> retval; |  | 24512 | Ptr<Stitcher> retval;
| 24561 |  |  | 24513 |
| 24562 | const char* keywords[] = { "mode", NULL }; |  | 24514 | const char* keywords[] = { "mode", NULL };
| 24563 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Stitcher.create", (char**)keywords, &pyobj_mode) && |  | 24515 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Stitcher.create", (char**)keywords, &pyobj_mode) &&
| 24564 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) ) |  | 24516 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) )
| 24565 | { |  | 24517 | {
| 24566 | ERRWRAP2(retval = cv::Stitcher::create(mode)); |  | 24518 | ERRWRAP2(retval = cv::Stitcher::create(mode));
| 24567 | return pyopencv_from(retval); |  | 24519 | return pyopencv_from(retval);
| 24568 | } |  | 24520 | }
| 24569 |  |  | 24521 |
| 24570 | return NULL; |  | 24522 | return NULL;
| 24571 | } |  | 24523 | }
| 24572 |  |  | 24524 |
| 24573 | static PyObject* pyopencv_cv_Stitcher_estimateTransform(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24525 | static PyObject* pyopencv_cv_Stitcher_estimateTransform(PyObject* self, PyObject* py_args, PyObject* kw)
| 24574 | { |  | 24526 | {
| 24575 | using namespace cv; |  | 24527 | using namespace cv;
| 24576 |  |  | 24528 |
| 24577 |  |  | 24529 |
| 24578 | Ptr<cv::Stitcher> * self1 = 0; |  | 24530 | Ptr<cv::Stitcher> * self1 = 0;
| 24579 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24531 | if (!pyopencv_Stitcher_getp(self, self1))
| 24580 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24532 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24581 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24533 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24582 | pyPrepareArgumentConversionErrorsStorage(2); |  | 24534 | pyPrepareArgumentConversionErrorsStorage(2);
| 24583 |  |  | 24535 |
| 24584 | { |  | 24536 | {
| 24585 | PyObject* pyobj_images = NULL; |  | 24537 | PyObject* pyobj_images = NULL;
| 24586 | vector_Mat images; |  | 24538 | vector_Mat images;
| 24587 | PyObject* pyobj_masks = NULL; |  | 24539 | PyObject* pyobj_masks = NULL;
| 24588 | vector_Mat masks; |  | 24540 | vector_Mat masks;
| 24589 | Status retval; |  | 24541 | Status retval;
| 24590 |  |  | 24542 |
| 24591 | const char* keywords[] = { "images", "masks", NULL }; |  | 24543 | const char* keywords[] = { "images", "masks", NULL };
| 24592 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.estimateTransform", (char**)keywords, &pyobj_images, &pyobj_masks) && |  | 24544 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.estimateTransform", (char**)keywords, &pyobj_images, &pyobj_masks) &&
| 24593 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24545 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24594 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 24546 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 24595 | { |  | 24547 | {
| 24596 | ERRWRAP2(retval = _self_->estimateTransform(images, masks)); |  | 24548 | ERRWRAP2(retval = _self_->estimateTransform(images, masks));
| 24597 | return pyopencv_from(retval); |  | 24549 | return pyopencv_from(retval);
| 24598 | } |  | 24550 | }
| 24599 |  |  | 24551 |
| 24600 |  |  | 24552 |
| 24601 | pyPopulateArgumentConversionErrors(); |  | 24553 | pyPopulateArgumentConversionErrors();
| 24602 | } |  | 24554 | }
| 24603 |  |  | 24555 |
| 24604 |  |  | 24556 |
| 24605 | { |  | 24557 | {
| 24606 | PyObject* pyobj_images = NULL; |  | 24558 | PyObject* pyobj_images = NULL;
| 24607 | vector_UMat images; |  | 24559 | vector_UMat images;
| 24608 | PyObject* pyobj_masks = NULL; |  | 24560 | PyObject* pyobj_masks = NULL;
| 24609 | vector_UMat masks; |  | 24561 | vector_UMat masks;
| 24610 | Status retval; |  | 24562 | Status retval;
| 24611 |  |  | 24563 |
| 24612 | const char* keywords[] = { "images", "masks", NULL }; |  | 24564 | const char* keywords[] = { "images", "masks", NULL };
| 24613 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.estimateTransform", (char**)keywords, &pyobj_images, &pyobj_masks) && |  | 24565 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.estimateTransform", (char**)keywords, &pyobj_images, &pyobj_masks) &&
| 24614 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24566 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24615 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 24567 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 24616 | { |  | 24568 | {
| 24617 | ERRWRAP2(retval = _self_->estimateTransform(images, masks)); |  | 24569 | ERRWRAP2(retval = _self_->estimateTransform(images, masks));
| 24618 | return pyopencv_from(retval); |  | 24570 | return pyopencv_from(retval);
| 24619 | } |  | 24571 | }
| 24620 |  |  | 24572 |
| 24621 |  |  | 24573 |
| 24622 | pyPopulateArgumentConversionErrors(); |  | 24574 | pyPopulateArgumentConversionErrors();
| 24623 | } |  | 24575 | }
| 24624 | pyRaiseCVOverloadException("estimateTransform"); |  | 24576 | pyRaiseCVOverloadException("estimateTransform");
| 24625 |  |  | 24577 |
| 24626 | return NULL; |  | 24578 | return NULL;
| 24627 | } |  | 24579 | }
| 24628 |  |  | 24580 |
| 24629 | static PyObject* pyopencv_cv_Stitcher_interpolationFlags(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24581 | static PyObject* pyopencv_cv_Stitcher_interpolationFlags(PyObject* self, PyObject* py_args, PyObject* kw)
| 24630 | { |  | 24582 | {
| 24631 | using namespace cv; |  | 24583 | using namespace cv;
| 24632 |  |  | 24584 |
| 24633 |  |  | 24585 |
| 24634 | Ptr<cv::Stitcher> * self1 = 0; |  | 24586 | Ptr<cv::Stitcher> * self1 = 0;
| 24635 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24587 | if (!pyopencv_Stitcher_getp(self, self1))
| 24636 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24588 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24637 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24589 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24638 | InterpolationFlags retval; |  | 24590 | InterpolationFlags retval;
| 24639 |  |  | 24591 |
| 24640 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24592 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24641 | { |  | 24593 | {
| 24642 | ERRWRAP2(retval = _self_->interpolationFlags()); |  | 24594 | ERRWRAP2(retval = _self_->interpolationFlags());
| 24643 | return pyopencv_from(retval); |  | 24595 | return pyopencv_from(retval);
| 24644 | } |  | 24596 | }
| 24645 |  |  | 24597 |
| 24646 | return NULL; |  | 24598 | return NULL;
| 24647 | } |  | 24599 | }
| 24648 |  |  | 24600 |
| 24649 | static PyObject* pyopencv_cv_Stitcher_panoConfidenceThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24601 | static PyObject* pyopencv_cv_Stitcher_panoConfidenceThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 24650 | { |  | 24602 | {
| 24651 | using namespace cv; |  | 24603 | using namespace cv;
| 24652 |  |  | 24604 |
| 24653 |  |  | 24605 |
| 24654 | Ptr<cv::Stitcher> * self1 = 0; |  | 24606 | Ptr<cv::Stitcher> * self1 = 0;
| 24655 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24607 | if (!pyopencv_Stitcher_getp(self, self1))
| 24656 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24608 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24657 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24609 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24658 | double retval; |  | 24610 | double retval;
| 24659 |  |  | 24611 |
| 24660 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24612 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24661 | { |  | 24613 | {
| 24662 | ERRWRAP2(retval = _self_->panoConfidenceThresh()); |  | 24614 | ERRWRAP2(retval = _self_->panoConfidenceThresh());
| 24663 | return pyopencv_from(retval); |  | 24615 | return pyopencv_from(retval);
| 24664 | } |  | 24616 | }
| 24665 |  |  | 24617 |
| 24666 | return NULL; |  | 24618 | return NULL;
| 24667 | } |  | 24619 | }
| 24668 |  |  | 24620 |
| 24669 | static PyObject* pyopencv_cv_Stitcher_registrationResol(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24621 | static PyObject* pyopencv_cv_Stitcher_registrationResol(PyObject* self, PyObject* py_args, PyObject* kw)
| 24670 | { |  | 24622 | {
| 24671 | using namespace cv; |  | 24623 | using namespace cv;
| 24672 |  |  | 24624 |
| 24673 |  |  | 24625 |
| 24674 | Ptr<cv::Stitcher> * self1 = 0; |  | 24626 | Ptr<cv::Stitcher> * self1 = 0;
| 24675 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24627 | if (!pyopencv_Stitcher_getp(self, self1))
| 24676 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24628 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24677 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24629 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24678 | double retval; |  | 24630 | double retval;
| 24679 |  |  | 24631 |
| 24680 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24632 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24681 | { |  | 24633 | {
| 24682 | ERRWRAP2(retval = _self_->registrationResol()); |  | 24634 | ERRWRAP2(retval = _self_->registrationResol());
| 24683 | return pyopencv_from(retval); |  | 24635 | return pyopencv_from(retval);
| 24684 | } |  | 24636 | }
| 24685 |  |  | 24637 |
| 24686 | return NULL; |  | 24638 | return NULL;
| 24687 | } |  | 24639 | }
| 24688 |  |  | 24640 |
| 24689 | static PyObject* pyopencv_cv_Stitcher_seamEstimationResol(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24641 | static PyObject* pyopencv_cv_Stitcher_seamEstimationResol(PyObject* self, PyObject* py_args, PyObject* kw)
| 24690 | { |  | 24642 | {
| 24691 | using namespace cv; |  | 24643 | using namespace cv;
| 24692 |  |  | 24644 |
| 24693 |  |  | 24645 |
| 24694 | Ptr<cv::Stitcher> * self1 = 0; |  | 24646 | Ptr<cv::Stitcher> * self1 = 0;
| 24695 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24647 | if (!pyopencv_Stitcher_getp(self, self1))
| 24696 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24648 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24697 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24649 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24698 | double retval; |  | 24650 | double retval;
| 24699 |  |  | 24651 |
| 24700 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24652 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24701 | { |  | 24653 | {
| 24702 | ERRWRAP2(retval = _self_->seamEstimationResol()); |  | 24654 | ERRWRAP2(retval = _self_->seamEstimationResol());
| 24703 | return pyopencv_from(retval); |  | 24655 | return pyopencv_from(retval);
| 24704 | } |  | 24656 | }
| 24705 |  |  | 24657 |
| 24706 | return NULL; |  | 24658 | return NULL;
| 24707 | } |  | 24659 | }
| 24708 |  |  | 24660 |
| 24709 | static PyObject* pyopencv_cv_Stitcher_setCompositingResol(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24661 | static PyObject* pyopencv_cv_Stitcher_setCompositingResol(PyObject* self, PyObject* py_args, PyObject* kw)
| 24710 | { |  | 24662 | {
| 24711 | using namespace cv; |  | 24663 | using namespace cv;
| 24712 |  |  | 24664 |
| 24713 |  |  | 24665 |
| 24714 | Ptr<cv::Stitcher> * self1 = 0; |  | 24666 | Ptr<cv::Stitcher> * self1 = 0;
| 24715 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24667 | if (!pyopencv_Stitcher_getp(self, self1))
| 24716 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24668 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24717 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24669 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24718 | PyObject* pyobj_resol_mpx = NULL; |  | 24670 | PyObject* pyobj_resol_mpx = NULL;
| 24719 | double resol_mpx=0; |  | 24671 | double resol_mpx=0;
| 24720 |  |  | 24672 |
| 24721 | const char* keywords[] = { "resol_mpx", NULL }; |  | 24673 | const char* keywords[] = { "resol_mpx", NULL };
| 24722 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setCompositingResol", (char**)keywords, &pyobj_resol_mpx) && |  | 24674 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setCompositingResol", (char**)keywords, &pyobj_resol_mpx) &&
| 24723 | pyopencv_to_safe(pyobj_resol_mpx, resol_mpx, ArgInfo("resol_mpx", 0)) ) |  | 24675 | pyopencv_to_safe(pyobj_resol_mpx, resol_mpx, ArgInfo("resol_mpx", 0)) )
| 24724 | { |  | 24676 | {
| 24725 | ERRWRAP2(_self_->setCompositingResol(resol_mpx)); |  | 24677 | ERRWRAP2(_self_->setCompositingResol(resol_mpx));
| 24726 | Py_RETURN_NONE; |  | 24678 | Py_RETURN_NONE;
| 24727 | } |  | 24679 | }
| 24728 |  |  | 24680 |
| 24729 | return NULL; |  | 24681 | return NULL;
| 24730 | } |  | 24682 | }
| 24731 |  |  | 24683 |
| 24732 | static PyObject* pyopencv_cv_Stitcher_setInterpolationFlags(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24684 | static PyObject* pyopencv_cv_Stitcher_setInterpolationFlags(PyObject* self, PyObject* py_args, PyObject* kw)
| 24733 | { |  | 24685 | {
| 24734 | using namespace cv; |  | 24686 | using namespace cv;
| 24735 |  |  | 24687 |
| 24736 |  |  | 24688 |
| 24737 | Ptr<cv::Stitcher> * self1 = 0; |  | 24689 | Ptr<cv::Stitcher> * self1 = 0;
| 24738 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24690 | if (!pyopencv_Stitcher_getp(self, self1))
| 24739 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24691 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24740 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24692 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24741 | PyObject* pyobj_interp_flags = NULL; |  | 24693 | PyObject* pyobj_interp_flags = NULL;
| 24742 | InterpolationFlags interp_flags=static_cast<InterpolationFlags>(0); |  | 24694 | InterpolationFlags interp_flags=static_cast<InterpolationFlags>(0);
| 24743 |  |  | 24695 |
| 24744 | const char* keywords[] = { "interp_flags", NULL }; |  | 24696 | const char* keywords[] = { "interp_flags", NULL };
| 24745 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setInterpolationFlags", (char**)keywords, &pyobj_interp_flags) && |  | 24697 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setInterpolationFlags", (char**)keywords, &pyobj_interp_flags) &&
| 24746 | pyopencv_to_safe(pyobj_interp_flags, interp_flags, ArgInfo("interp_flags", 0)) ) |  | 24698 | pyopencv_to_safe(pyobj_interp_flags, interp_flags, ArgInfo("interp_flags", 0)) )
| 24747 | { |  | 24699 | {
| 24748 | ERRWRAP2(_self_->setInterpolationFlags(interp_flags)); |  | 24700 | ERRWRAP2(_self_->setInterpolationFlags(interp_flags));
| 24749 | Py_RETURN_NONE; |  | 24701 | Py_RETURN_NONE;
| 24750 | } |  | 24702 | }
| 24751 |  |  | 24703 |
| 24752 | return NULL; |  | 24704 | return NULL;
| 24753 | } |  | 24705 | }
| 24754 |  |  | 24706 |
| 24755 | static PyObject* pyopencv_cv_Stitcher_setPanoConfidenceThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24707 | static PyObject* pyopencv_cv_Stitcher_setPanoConfidenceThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 24756 | { |  | 24708 | {
| 24757 | using namespace cv; |  | 24709 | using namespace cv;
| 24758 |  |  | 24710 |
| 24759 |  |  | 24711 |
| 24760 | Ptr<cv::Stitcher> * self1 = 0; |  | 24712 | Ptr<cv::Stitcher> * self1 = 0;
| 24761 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24713 | if (!pyopencv_Stitcher_getp(self, self1))
| 24762 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24714 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24763 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24715 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24764 | PyObject* pyobj_conf_thresh = NULL; |  | 24716 | PyObject* pyobj_conf_thresh = NULL;
| 24765 | double conf_thresh=0; |  | 24717 | double conf_thresh=0;
| 24766 |  |  | 24718 |
| 24767 | const char* keywords[] = { "conf_thresh", NULL }; |  | 24719 | const char* keywords[] = { "conf_thresh", NULL };
| 24768 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setPanoConfidenceThresh", (char**)keywords, &pyobj_conf_thresh) && |  | 24720 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setPanoConfidenceThresh", (char**)keywords, &pyobj_conf_thresh) &&
| 24769 | pyopencv_to_safe(pyobj_conf_thresh, conf_thresh, ArgInfo("conf_thresh", 0)) ) |  | 24721 | pyopencv_to_safe(pyobj_conf_thresh, conf_thresh, ArgInfo("conf_thresh", 0)) )
| 24770 | { |  | 24722 | {
| 24771 | ERRWRAP2(_self_->setPanoConfidenceThresh(conf_thresh)); |  | 24723 | ERRWRAP2(_self_->setPanoConfidenceThresh(conf_thresh));
| 24772 | Py_RETURN_NONE; |  | 24724 | Py_RETURN_NONE;
| 24773 | } |  | 24725 | }
| 24774 |  |  | 24726 |
| 24775 | return NULL; |  | 24727 | return NULL;
| 24776 | } |  | 24728 | }
| 24777 |  |  | 24729 |
| 24778 | static PyObject* pyopencv_cv_Stitcher_setRegistrationResol(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24730 | static PyObject* pyopencv_cv_Stitcher_setRegistrationResol(PyObject* self, PyObject* py_args, PyObject* kw)
| 24779 | { |  | 24731 | {
| 24780 | using namespace cv; |  | 24732 | using namespace cv;
| 24781 |  |  | 24733 |
| 24782 |  |  | 24734 |
| 24783 | Ptr<cv::Stitcher> * self1 = 0; |  | 24735 | Ptr<cv::Stitcher> * self1 = 0;
| 24784 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24736 | if (!pyopencv_Stitcher_getp(self, self1))
| 24785 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24737 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24786 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24738 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24787 | PyObject* pyobj_resol_mpx = NULL; |  | 24739 | PyObject* pyobj_resol_mpx = NULL;
| 24788 | double resol_mpx=0; |  | 24740 | double resol_mpx=0;
| 24789 |  |  | 24741 |
| 24790 | const char* keywords[] = { "resol_mpx", NULL }; |  | 24742 | const char* keywords[] = { "resol_mpx", NULL };
| 24791 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setRegistrationResol", (char**)keywords, &pyobj_resol_mpx) && |  | 24743 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setRegistrationResol", (char**)keywords, &pyobj_resol_mpx) &&
| 24792 | pyopencv_to_safe(pyobj_resol_mpx, resol_mpx, ArgInfo("resol_mpx", 0)) ) |  | 24744 | pyopencv_to_safe(pyobj_resol_mpx, resol_mpx, ArgInfo("resol_mpx", 0)) )
| 24793 | { |  | 24745 | {
| 24794 | ERRWRAP2(_self_->setRegistrationResol(resol_mpx)); |  | 24746 | ERRWRAP2(_self_->setRegistrationResol(resol_mpx));
| 24795 | Py_RETURN_NONE; |  | 24747 | Py_RETURN_NONE;
| 24796 | } |  | 24748 | }
| 24797 |  |  | 24749 |
| 24798 | return NULL; |  | 24750 | return NULL;
| 24799 | } |  | 24751 | }
| 24800 |  |  | 24752 |
| 24801 | static PyObject* pyopencv_cv_Stitcher_setSeamEstimationResol(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24753 | static PyObject* pyopencv_cv_Stitcher_setSeamEstimationResol(PyObject* self, PyObject* py_args, PyObject* kw)
| 24802 | { |  | 24754 | {
| 24803 | using namespace cv; |  | 24755 | using namespace cv;
| 24804 |  |  | 24756 |
| 24805 |  |  | 24757 |
| 24806 | Ptr<cv::Stitcher> * self1 = 0; |  | 24758 | Ptr<cv::Stitcher> * self1 = 0;
| 24807 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24759 | if (!pyopencv_Stitcher_getp(self, self1))
| 24808 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24760 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24809 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24761 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24810 | PyObject* pyobj_resol_mpx = NULL; |  | 24762 | PyObject* pyobj_resol_mpx = NULL;
| 24811 | double resol_mpx=0; |  | 24763 | double resol_mpx=0;
| 24812 |  |  | 24764 |
| 24813 | const char* keywords[] = { "resol_mpx", NULL }; |  | 24765 | const char* keywords[] = { "resol_mpx", NULL };
| 24814 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setSeamEstimationResol", (char**)keywords, &pyobj_resol_mpx) && |  | 24766 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setSeamEstimationResol", (char**)keywords, &pyobj_resol_mpx) &&
| 24815 | pyopencv_to_safe(pyobj_resol_mpx, resol_mpx, ArgInfo("resol_mpx", 0)) ) |  | 24767 | pyopencv_to_safe(pyobj_resol_mpx, resol_mpx, ArgInfo("resol_mpx", 0)) )
| 24816 | { |  | 24768 | {
| 24817 | ERRWRAP2(_self_->setSeamEstimationResol(resol_mpx)); |  | 24769 | ERRWRAP2(_self_->setSeamEstimationResol(resol_mpx));
| 24818 | Py_RETURN_NONE; |  | 24770 | Py_RETURN_NONE;
| 24819 | } |  | 24771 | }
| 24820 |  |  | 24772 |
| 24821 | return NULL; |  | 24773 | return NULL;
| 24822 | } |  | 24774 | }
| 24823 |  |  | 24775 |
| 24824 | static PyObject* pyopencv_cv_Stitcher_setWaveCorrection(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24776 | static PyObject* pyopencv_cv_Stitcher_setWaveCorrection(PyObject* self, PyObject* py_args, PyObject* kw)
| 24825 | { |  | 24777 | {
| 24826 | using namespace cv; |  | 24778 | using namespace cv;
| 24827 |  |  | 24779 |
| 24828 |  |  | 24780 |
| 24829 | Ptr<cv::Stitcher> * self1 = 0; |  | 24781 | Ptr<cv::Stitcher> * self1 = 0;
| 24830 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24782 | if (!pyopencv_Stitcher_getp(self, self1))
| 24831 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24783 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24832 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24784 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24833 | PyObject* pyobj_flag = NULL; |  | 24785 | PyObject* pyobj_flag = NULL;
| 24834 | bool flag=0; |  | 24786 | bool flag=0;
| 24835 |  |  | 24787 |
| 24836 | const char* keywords[] = { "flag", NULL }; |  | 24788 | const char* keywords[] = { "flag", NULL };
| 24837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setWaveCorrection", (char**)keywords, &pyobj_flag) && |  | 24789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stitcher.setWaveCorrection", (char**)keywords, &pyobj_flag) &&
| 24838 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) ) |  | 24790 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) )
| 24839 | { |  | 24791 | {
| 24840 | ERRWRAP2(_self_->setWaveCorrection(flag)); |  | 24792 | ERRWRAP2(_self_->setWaveCorrection(flag));
| 24841 | Py_RETURN_NONE; |  | 24793 | Py_RETURN_NONE;
| 24842 | } |  | 24794 | }
| 24843 |  |  | 24795 |
| 24844 | return NULL; |  | 24796 | return NULL;
| 24845 | } |  | 24797 | }
| 24846 |  |  | 24798 |
| 24847 | static PyObject* pyopencv_cv_Stitcher_stitch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24799 | static PyObject* pyopencv_cv_Stitcher_stitch(PyObject* self, PyObject* py_args, PyObject* kw)
| 24848 | { |  | 24800 | {
| 24849 | using namespace cv; |  | 24801 | using namespace cv;
| 24850 |  |  | 24802 |
| 24851 |  |  | 24803 |
| 24852 | Ptr<cv::Stitcher> * self1 = 0; |  | 24804 | Ptr<cv::Stitcher> * self1 = 0;
| 24853 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24805 | if (!pyopencv_Stitcher_getp(self, self1))
| 24854 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24806 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24855 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24807 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24856 | pyPrepareArgumentConversionErrorsStorage(4); |  | 24808 | pyPrepareArgumentConversionErrorsStorage(4);
| 24857 |  |  | 24809 |
| 24858 | { |  | 24810 | {
| 24859 | PyObject* pyobj_images = NULL; |  | 24811 | PyObject* pyobj_images = NULL;
| 24860 | vector_Mat images; |  | 24812 | vector_Mat images;
| 24861 | PyObject* pyobj_pano = NULL; |  | 24813 | PyObject* pyobj_pano = NULL;
| 24862 | Mat pano; |  | 24814 | Mat pano;
| 24863 | Status retval; |  | 24815 | Status retval;
| 24864 |  |  | 24816 |
| 24865 | const char* keywords[] = { "images", "pano", NULL }; |  | 24817 | const char* keywords[] = { "images", "pano", NULL };
| 24866 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_pano) && |  | 24818 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_pano) &&
| 24867 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24819 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24868 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24820 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24869 | { |  | 24821 | {
| 24870 | ERRWRAP2(retval = _self_->stitch(images, pano)); |  | 24822 | ERRWRAP2(retval = _self_->stitch(images, pano));
| 24871 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24823 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24872 | } |  | 24824 | }
| 24873 |  |  | 24825 |
| 24874 |  |  | 24826 |
| 24875 | pyPopulateArgumentConversionErrors(); |  | 24827 | pyPopulateArgumentConversionErrors();
| 24876 | } |  | 24828 | }
| 24877 |  |  | 24829 |
| 24878 |  |  | 24830 |
| 24879 | { |  | 24831 | {
| 24880 | PyObject* pyobj_images = NULL; |  | 24832 | PyObject* pyobj_images = NULL;
| 24881 | vector_Mat images; |  | 24833 | vector_Mat images;
| 24882 | PyObject* pyobj_masks = NULL; |  | 24834 | PyObject* pyobj_masks = NULL;
| 24883 | vector_Mat masks; |  | 24835 | vector_Mat masks;
| 24884 | PyObject* pyobj_pano = NULL; |  | 24836 | PyObject* pyobj_pano = NULL;
| 24885 | Mat pano; |  | 24837 | Mat pano;
| 24886 | Status retval; |  | 24838 | Status retval;
| 24887 |  |  | 24839 |
| 24888 | const char* keywords[] = { "images", "masks", "pano", NULL }; |  | 24840 | const char* keywords[] = { "images", "masks", "pano", NULL };
| 24889 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_masks, &pyobj_pano) && |  | 24841 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_masks, &pyobj_pano) &&
| 24890 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24842 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24891 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 24843 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 24892 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24844 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24893 | { |  | 24845 | {
| 24894 | ERRWRAP2(retval = _self_->stitch(images, masks, pano)); |  | 24846 | ERRWRAP2(retval = _self_->stitch(images, masks, pano));
| 24895 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24847 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24896 | } |  | 24848 | }
| 24897 |  |  | 24849 |
| 24898 |  |  | 24850 |
| 24899 | pyPopulateArgumentConversionErrors(); |  | 24851 | pyPopulateArgumentConversionErrors();
| 24900 | } |  | 24852 | }
| 24901 |  |  | 24853 |
| 24902 |  |  | 24854 |
| 24903 | { |  | 24855 | {
| 24904 | PyObject* pyobj_images = NULL; |  | 24856 | PyObject* pyobj_images = NULL;
| 24905 | vector_UMat images; |  | 24857 | vector_UMat images;
| 24906 | PyObject* pyobj_pano = NULL; |  | 24858 | PyObject* pyobj_pano = NULL;
| 24907 | UMat pano; |  | 24859 | UMat pano;
| 24908 | Status retval; |  | 24860 | Status retval;
| 24909 |  |  | 24861 |
| 24910 | const char* keywords[] = { "images", "pano", NULL }; |  | 24862 | const char* keywords[] = { "images", "pano", NULL };
| 24911 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_pano) && |  | 24863 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_pano) &&
| 24912 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24864 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24913 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24865 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24914 | { |  | 24866 | {
| 24915 | ERRWRAP2(retval = _self_->stitch(images, pano)); |  | 24867 | ERRWRAP2(retval = _self_->stitch(images, pano));
| 24916 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24868 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24917 | } |  | 24869 | }
| 24918 |  |  | 24870 |
| 24919 |  |  | 24871 |
| 24920 | pyPopulateArgumentConversionErrors(); |  | 24872 | pyPopulateArgumentConversionErrors();
| 24921 | } |  | 24873 | }
| 24922 |  |  | 24874 |
| 24923 |  |  | 24875 |
| 24924 | { |  | 24876 | {
| 24925 | PyObject* pyobj_images = NULL; |  | 24877 | PyObject* pyobj_images = NULL;
| 24926 | vector_UMat images; |  | 24878 | vector_UMat images;
| 24927 | PyObject* pyobj_masks = NULL; |  | 24879 | PyObject* pyobj_masks = NULL;
| 24928 | vector_UMat masks; |  | 24880 | vector_UMat masks;
| 24929 | PyObject* pyobj_pano = NULL; |  | 24881 | PyObject* pyobj_pano = NULL;
| 24930 | UMat pano; |  | 24882 | UMat pano;
| 24931 | Status retval; |  | 24883 | Status retval;
| 24932 |  |  | 24884 |
| 24933 | const char* keywords[] = { "images", "masks", "pano", NULL }; |  | 24885 | const char* keywords[] = { "images", "masks", "pano", NULL };
| 24934 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_masks, &pyobj_pano) && |  | 24886 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Stitcher.stitch", (char**)keywords, &pyobj_images, &pyobj_masks, &pyobj_pano) &&
| 24935 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 24887 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 24936 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 24888 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 24937 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) ) |  | 24889 | pyopencv_to_safe(pyobj_pano, pano, ArgInfo("pano", 1)) )
| 24938 | { |  | 24890 | {
| 24939 | ERRWRAP2(retval = _self_->stitch(images, masks, pano)); |  | 24891 | ERRWRAP2(retval = _self_->stitch(images, masks, pano));
| 24940 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano)); |  | 24892 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(pano));
| 24941 | } |  | 24893 | }
| 24942 |  |  | 24894 |
| 24943 |  |  | 24895 |
| 24944 | pyPopulateArgumentConversionErrors(); |  | 24896 | pyPopulateArgumentConversionErrors();
| 24945 | } |  | 24897 | }
| 24946 | pyRaiseCVOverloadException("stitch"); |  | 24898 | pyRaiseCVOverloadException("stitch");
| 24947 |  |  | 24899 |
| 24948 | return NULL; |  | 24900 | return NULL;
| 24949 | } |  | 24901 | }
| 24950 |  |  | 24902 |
| 24951 | static PyObject* pyopencv_cv_Stitcher_waveCorrection(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24903 | static PyObject* pyopencv_cv_Stitcher_waveCorrection(PyObject* self, PyObject* py_args, PyObject* kw)
| 24952 | { |  | 24904 | {
| 24953 | using namespace cv; |  | 24905 | using namespace cv;
| 24954 |  |  | 24906 |
| 24955 |  |  | 24907 |
| 24956 | Ptr<cv::Stitcher> * self1 = 0; |  | 24908 | Ptr<cv::Stitcher> * self1 = 0;
| 24957 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24909 | if (!pyopencv_Stitcher_getp(self, self1))
| 24958 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24910 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24959 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24911 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24960 | bool retval; |  | 24912 | bool retval;
| 24961 |  |  | 24913 |
| 24962 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24914 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24963 | { |  | 24915 | {
| 24964 | ERRWRAP2(retval = _self_->waveCorrection()); |  | 24916 | ERRWRAP2(retval = _self_->waveCorrection());
| 24965 | return pyopencv_from(retval); |  | 24917 | return pyopencv_from(retval);
| 24966 | } |  | 24918 | }
| 24967 |  |  | 24919 |
| 24968 | return NULL; |  | 24920 | return NULL;
| 24969 | } |  | 24921 | }
| 24970 |  |  | 24922 |
| 24971 | static PyObject* pyopencv_cv_Stitcher_workScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 24923 | static PyObject* pyopencv_cv_Stitcher_workScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 24972 | { |  | 24924 | {
| 24973 | using namespace cv; |  | 24925 | using namespace cv;
| 24974 |  |  | 24926 |
| 24975 |  |  | 24927 |
| 24976 | Ptr<cv::Stitcher> * self1 = 0; |  | 24928 | Ptr<cv::Stitcher> * self1 = 0;
| 24977 | if (!pyopencv_Stitcher_getp(self, self1)) |  | 24929 | if (!pyopencv_Stitcher_getp(self, self1))
| 24978 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)"); |  | 24930 | return failmsgp("Incorrect type of self (must be 'Stitcher' or its derivative)");
| 24979 | Ptr<cv::Stitcher> _self_ = *(self1); |  | 24931 | Ptr<cv::Stitcher> _self_ = *(self1);
| 24980 | double retval; |  | 24932 | double retval;
| 24981 |  |  | 24933 |
| 24982 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 24934 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 24983 | { |  | 24935 | {
| 24984 | ERRWRAP2(retval = _self_->workScale()); |  | 24936 | ERRWRAP2(retval = _self_->workScale());
| 24985 | return pyopencv_from(retval); |  | 24937 | return pyopencv_from(retval);
| 24986 | } |  | 24938 | }
| 24987 |  |  | 24939 |
| 24988 | return NULL; |  | 24940 | return NULL;
| 24989 | } |  | 24941 | }
| 24990 |  |  | 24942 |
| 24991 |  |  | 24943 |
| 24992 |  |  | 24944 |
| 24993 | // Tables (Stitcher) |  | 24945 | // Tables (Stitcher)
| 24994 |  |  | 24946 |
| 24995 | static PyGetSetDef pyopencv_Stitcher_getseters[] = |  | 24947 | static PyGetSetDef pyopencv_Stitcher_getseters[] =
| 24996 | { |  | 24948 | {
| 24997 | {NULL} /* Sentinel */ |  | 24949 | {NULL} /* Sentinel */
| 24998 | }; |  | 24950 | };
| 24999 |  |  | 24951 |
| 25000 | static PyMethodDef pyopencv_Stitcher_methods[] = |  | 24952 | static PyMethodDef pyopencv_Stitcher_methods[] =
| 25001 | { |  | 24953 | {
| 25002 | {"cameras", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_cameras, 0), "cameras() -> retval\n. Returns estimated camera parameters for all stitched images"}, |  | 24954 | {"cameras", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_cameras, 0), "cameras() -> retval\n. Returns estimated camera parameters for all stitched images"},
| 25003 | {"component", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_component, 0), "component() -> retval\n. @brief Returns indeces of input images used in panorama stitching"}, |  | 24955 | {"component", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_component, 0), "component() -> retval\n. @brief Returns indeces of input images used in panorama stitching"},
| 25004 | {"composePanorama", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_composePanorama, 0), "composePanorama([, pano]) -> retval, pano\n. @overload\n\n\n\ncomposePanorama(images[, pano]) -> retval, pano\n. @brief These functions try to compose the given images (or images stored internally from the other function\n. calls) into the final pano under the assumption that the image transformations were estimated\n. before.\n. \n. @note Use the functions only if you're aware of the stitching pipeline, otherwise use\n. Stitcher::stitch.\n. \n. @param images Input images.\n. @param pano Final pano.\n. @return Status code."}, |  | 24956 | {"composePanorama", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_composePanorama, 0), "composePanorama([, pano]) -> retval, pano\n. @overload\n\n\n\ncomposePanorama(images[, pano]) -> retval, pano\n. @brief These functions try to compose the given images (or images stored internally from the other function\n. calls) into the final pano under the assumption that the image transformations were estimated\n. before.\n. \n. @note Use the functions only if you're aware of the stitching pipeline, otherwise use\n. Stitcher::stitch.\n. \n. @param images Input images.\n. @param pano Final pano.\n. @return Status code."},
| 25005 | {"compositingResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_compositingResol, 0), "compositingResol() -> retval\n."}, |  | 24957 | {"compositingResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_compositingResol, 0), "compositingResol() -> retval\n."},
| 25006 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_create_static, METH_STATIC), "create([, mode]) -> retval\n. @brief Creates a Stitcher configured in one of the stitching modes.\n. \n. @param mode Scenario for stitcher operation. This is usually determined by source of images\n. to stitch and their transformation. Default parameters will be chosen for operation in given\n. scenario.\n. @return Stitcher class instance."}, |  | 24958 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_create_static, METH_STATIC), "create([, mode]) -> retval\n. @brief Creates a Stitcher configured in one of the stitching modes.\n. \n. @param mode Scenario for stitcher operation. This is usually determined by source of images\n. to stitch and their transformation. Default parameters will be chosen for operation in given\n. scenario.\n. @return Stitcher class instance."},
| 25007 | {"estimateTransform", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_estimateTransform, 0), "estimateTransform(images[, masks]) -> retval\n. @brief These functions try to match the given images and to estimate rotations of each camera.\n. \n. @note Use the functions only if you're aware of the stitching pipeline, otherwise use\n. Stitcher::stitch.\n. \n. @param images Input images.\n. @param masks Masks for each input image specifying where to look for keypoints (optional).\n. @return Status code."}, |  | 24959 | {"estimateTransform", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_estimateTransform, 0), "estimateTransform(images[, masks]) -> retval\n. @brief These functions try to match the given images and to estimate rotations of each camera.\n. \n. @note Use the functions only if you're aware of the stitching pipeline, otherwise use\n. Stitcher::stitch.\n. \n. @param images Input images.\n. @param masks Masks for each input image specifying where to look for keypoints (optional).\n. @return Status code."},
| 25008 | {"interpolationFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_interpolationFlags, 0), "interpolationFlags() -> retval\n."}, |  | 24960 | {"interpolationFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_interpolationFlags, 0), "interpolationFlags() -> retval\n."},
| 25009 | {"panoConfidenceThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_panoConfidenceThresh, 0), "panoConfidenceThresh() -> retval\n."}, |  | 24961 | {"panoConfidenceThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_panoConfidenceThresh, 0), "panoConfidenceThresh() -> retval\n."},
| 25010 | {"registrationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_registrationResol, 0), "registrationResol() -> retval\n."}, |  | 24962 | {"registrationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_registrationResol, 0), "registrationResol() -> retval\n."},
| 25011 | {"seamEstimationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_seamEstimationResol, 0), "seamEstimationResol() -> retval\n."}, |  | 24963 | {"seamEstimationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_seamEstimationResol, 0), "seamEstimationResol() -> retval\n."},
| 25012 | {"setCompositingResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setCompositingResol, 0), "setCompositingResol(resol_mpx) -> None\n."}, |  | 24964 | {"setCompositingResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setCompositingResol, 0), "setCompositingResol(resol_mpx) -> None\n."},
| 25013 | {"setInterpolationFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setInterpolationFlags, 0), "setInterpolationFlags(interp_flags) -> None\n."}, |  | 24965 | {"setInterpolationFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setInterpolationFlags, 0), "setInterpolationFlags(interp_flags) -> None\n."},
| 25014 | {"setPanoConfidenceThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setPanoConfidenceThresh, 0), "setPanoConfidenceThresh(conf_thresh) -> None\n."}, |  | 24966 | {"setPanoConfidenceThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setPanoConfidenceThresh, 0), "setPanoConfidenceThresh(conf_thresh) -> None\n."},
| 25015 | {"setRegistrationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setRegistrationResol, 0), "setRegistrationResol(resol_mpx) -> None\n."}, |  | 24967 | {"setRegistrationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setRegistrationResol, 0), "setRegistrationResol(resol_mpx) -> None\n."},
| 25016 | {"setSeamEstimationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setSeamEstimationResol, 0), "setSeamEstimationResol(resol_mpx) -> None\n."}, |  | 24968 | {"setSeamEstimationResol", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setSeamEstimationResol, 0), "setSeamEstimationResol(resol_mpx) -> None\n."},
| 25017 | {"setWaveCorrection", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setWaveCorrection, 0), "setWaveCorrection(flag) -> None\n."}, |  | 24969 | {"setWaveCorrection", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_setWaveCorrection, 0), "setWaveCorrection(flag) -> None\n."},
| 25018 | {"stitch", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_stitch, 0), "stitch(images[, pano]) -> retval, pano\n. @overload\n\n\n\nstitch(images, masks[, pano]) -> retval, pano\n. @brief These functions try to stitch the given images.\n. \n. @param images Input images.\n. @param masks Masks for each input image specifying where to look for keypoints (optional).\n. @param pano Final pano.\n. @return Status code."}, |  | 24970 | {"stitch", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_stitch, 0), "stitch(images[, pano]) -> retval, pano\n. @overload\n\n\n\nstitch(images, masks[, pano]) -> retval, pano\n. @brief These functions try to stitch the given images.\n. \n. @param images Input images.\n. @param masks Masks for each input image specifying where to look for keypoints (optional).\n. @param pano Final pano.\n. @return Status code."},
| 25019 | {"waveCorrection", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_waveCorrection, 0), "waveCorrection() -> retval\n."}, |  | 24971 | {"waveCorrection", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_waveCorrection, 0), "waveCorrection() -> retval\n."},
| 25020 | {"workScale", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_workScale, 0), "workScale() -> retval\n."}, |  | 24972 | {"workScale", CV_PY_FN_WITH_KW_(pyopencv_cv_Stitcher_workScale, 0), "workScale() -> retval\n."},
| 25021 |  |  | 24973 |
| 25022 | {NULL, NULL} |  | 24974 | {NULL, NULL}
| 25023 | }; |  | 24975 | };
| 25024 |  |  | 24976 |
| 25025 | // Converter (Stitcher) |  | 24977 | // Converter (Stitcher)
| 25026 |  |  | 24978 |
| 25027 | template<> |  | 24979 | template<>
| 25028 | struct PyOpenCV_Converter< Ptr<cv::Stitcher> > |  | 24980 | struct PyOpenCV_Converter< Ptr<cv::Stitcher> >
| 25029 | { |  | 24981 | {
| 25030 | static PyObject* from(const Ptr<cv::Stitcher>& r) |  | 24982 | static PyObject* from(const Ptr<cv::Stitcher>& r)
| 25031 | { |  | 24983 | {
| 25032 | return pyopencv_Stitcher_Instance(r); |  | 24984 | return pyopencv_Stitcher_Instance(r);
| 25033 | } |  | 24985 | }
| 25034 | static bool to(PyObject* src, Ptr<cv::Stitcher>& dst, const ArgInfo& info) |  | 24986 | static bool to(PyObject* src, Ptr<cv::Stitcher>& dst, const ArgInfo& info)
| 25035 | { |  | 24987 | {
| 25036 | if(!src || src == Py_None) |  | 24988 | if(!src || src == Py_None)
| 25037 | return true; |  | 24989 | return true;
| 25038 | Ptr<cv::Stitcher> * dst_; |  | 24990 | Ptr<cv::Stitcher> * dst_;
| 25039 | if (pyopencv_Stitcher_getp(src, dst_)) |  | 24991 | if (pyopencv_Stitcher_getp(src, dst_))
| 25040 | { |  | 24992 | {
| 25041 | dst = *dst_; |  | 24993 | dst = *dst_;
| 25042 | return true; |  | 24994 | return true;
| 25043 | } |  | 24995 | }
| 25044 |  |  | 24996 |
| 25045 | failmsg("Expected Ptr<cv::Stitcher> for argument '%s'", info.name); |  | 24997 | failmsg("Expected Ptr<cv::Stitcher> for argument '%s'", info.name);
| 25046 | return false; |  | 24998 | return false;
| 25047 | } |  | 24999 | }
| 25048 | }; |  | 25000 | };
| 25049 |  |  | 25001 |
| 25050 | //================================================================================ |  | 25002 | //================================================================================
| 25051 | // Subdiv2D (Generic) |  | 25003 | // Subdiv2D (Generic)
| 25052 | //================================================================================ |  | 25004 | //================================================================================
| 25053 |  |  | 25005 |
| 25054 | // GetSet (Subdiv2D) |  | 25006 | // GetSet (Subdiv2D)
| 25055 |  |  | 25007 |
| 25056 |  |  | 25008 |
| 25057 |  |  | 25009 |
| 25058 | // Methods (Subdiv2D) |  | 25010 | // Methods (Subdiv2D)
| 25059 |  |  | 25011 |
| 25060 | static int pyopencv_cv_Subdiv2D_Subdiv2D(pyopencv_Subdiv2D_t* self, PyObject* py_args, PyObject* kw) |  | 25012 | static int pyopencv_cv_Subdiv2D_Subdiv2D(pyopencv_Subdiv2D_t* self, PyObject* py_args, PyObject* kw)
| 25061 | { |  | 25013 | {
| 25062 | using namespace cv; |  | 25014 | using namespace cv;
| 25063 |  |  | 25015 |
| 25064 | pyPrepareArgumentConversionErrorsStorage(2); |  | 25016 | pyPrepareArgumentConversionErrorsStorage(2);
| 25065 |  |  | 25017 |
| 25066 | { |  | 25018 | {
| 25067 |  |  | 25019 |
| 25068 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25020 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25069 | { |  | 25021 | {
| 25070 | new (&(self->v)) Ptr<cv::Subdiv2D>(); // init Ptr with placement new |  | 25022 | new (&(self->v)) Ptr<cv::Subdiv2D>(); // init Ptr with placement new
| 25071 | if(self) ERRWRAP2(self->v.reset(new cv::Subdiv2D())); |  | 25023 | if(self) ERRWRAP2(self->v.reset(new cv::Subdiv2D()));
| 25072 | return 0; |  | 25024 | return 0;
| 25073 | } |  | 25025 | }
| 25074 |  |  | 25026 |
| 25075 |  |  | 25027 |
| 25076 | pyPopulateArgumentConversionErrors(); |  | 25028 | pyPopulateArgumentConversionErrors();
| 25077 | } |  | 25029 | }
| 25078 |  |  | 25030 |
| 25079 |  |  | 25031 |
| 25080 | { |  | 25032 | {
| 25081 | PyObject* pyobj_rect = NULL; |  | 25033 | PyObject* pyobj_rect = NULL;
| 25082 | Rect rect; |  | 25034 | Rect rect;
| 25083 |  |  | 25035 |
| 25084 | const char* keywords[] = { "rect", NULL }; |  | 25036 | const char* keywords[] = { "rect", NULL };
| 25085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D", (char**)keywords, &pyobj_rect) && |  | 25037 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D", (char**)keywords, &pyobj_rect) &&
| 25086 | pyopencv_to_safe(pyobj_rect, rect, ArgInfo("rect", 0)) ) |  | 25038 | pyopencv_to_safe(pyobj_rect, rect, ArgInfo("rect", 0)) )
| 25087 | { |  | 25039 | {
| 25088 | new (&(self->v)) Ptr<cv::Subdiv2D>(); // init Ptr with placement new |  | 25040 | new (&(self->v)) Ptr<cv::Subdiv2D>(); // init Ptr with placement new
| 25089 | if(self) ERRWRAP2(self->v.reset(new cv::Subdiv2D(rect))); |  | 25041 | if(self) ERRWRAP2(self->v.reset(new cv::Subdiv2D(rect)));
| 25090 | return 0; |  | 25042 | return 0;
| 25091 | } |  | 25043 | }
| 25092 |  |  | 25044 |
| 25093 |  |  | 25045 |
| 25094 | pyPopulateArgumentConversionErrors(); |  | 25046 | pyPopulateArgumentConversionErrors();
| 25095 | } |  | 25047 | }
| 25096 | pyRaiseCVOverloadException("Subdiv2D"); |  | 25048 | pyRaiseCVOverloadException("Subdiv2D");
| 25097 |  |  | 25049 |
| 25098 | return -1; |  | 25050 | return -1;
| 25099 | } |  | 25051 | }
| 25100 |  |  | 25052 |
| 25101 | static PyObject* pyopencv_cv_Subdiv2D_edgeDst(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25053 | static PyObject* pyopencv_cv_Subdiv2D_edgeDst(PyObject* self, PyObject* py_args, PyObject* kw)
| 25102 | { |  | 25054 | {
| 25103 | using namespace cv; |  | 25055 | using namespace cv;
| 25104 |  |  | 25056 |
| 25105 |  |  | 25057 |
| 25106 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25058 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25107 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25059 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25108 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25060 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25109 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25061 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25110 | PyObject* pyobj_edge = NULL; |  | 25062 | PyObject* pyobj_edge = NULL;
| 25111 | int edge=0; |  | 25063 | int edge=0;
| 25112 | Point2f dstpt; |  | 25064 | Point2f dstpt;
| 25113 | int retval; |  | 25065 | int retval;
| 25114 |  |  | 25066 |
| 25115 | const char* keywords[] = { "edge", NULL }; |  | 25067 | const char* keywords[] = { "edge", NULL };
| 25116 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.edgeDst", (char**)keywords, &pyobj_edge) && |  | 25068 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.edgeDst", (char**)keywords, &pyobj_edge) &&
| 25117 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) ) |  | 25069 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) )
| 25118 | { |  | 25070 | {
| 25119 | ERRWRAP2(retval = _self_->edgeDst(edge, &dstpt)); |  | 25071 | ERRWRAP2(retval = _self_->edgeDst(edge, &dstpt));
| 25120 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dstpt)); |  | 25072 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(dstpt));
| 25121 | } |  | 25073 | }
| 25122 |  |  | 25074 |
| 25123 | return NULL; |  | 25075 | return NULL;
| 25124 | } |  | 25076 | }
| 25125 |  |  | 25077 |
| 25126 | static PyObject* pyopencv_cv_Subdiv2D_edgeOrg(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25078 | static PyObject* pyopencv_cv_Subdiv2D_edgeOrg(PyObject* self, PyObject* py_args, PyObject* kw)
| 25127 | { |  | 25079 | {
| 25128 | using namespace cv; |  | 25080 | using namespace cv;
| 25129 |  |  | 25081 |
| 25130 |  |  | 25082 |
| 25131 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25083 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25132 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25084 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25133 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25085 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25134 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25086 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25135 | PyObject* pyobj_edge = NULL; |  | 25087 | PyObject* pyobj_edge = NULL;
| 25136 | int edge=0; |  | 25088 | int edge=0;
| 25137 | Point2f orgpt; |  | 25089 | Point2f orgpt;
| 25138 | int retval; |  | 25090 | int retval;
| 25139 |  |  | 25091 |
| 25140 | const char* keywords[] = { "edge", NULL }; |  | 25092 | const char* keywords[] = { "edge", NULL };
| 25141 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.edgeOrg", (char**)keywords, &pyobj_edge) && |  | 25093 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.edgeOrg", (char**)keywords, &pyobj_edge) &&
| 25142 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) ) |  | 25094 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) )
| 25143 | { |  | 25095 | {
| 25144 | ERRWRAP2(retval = _self_->edgeOrg(edge, &orgpt)); |  | 25096 | ERRWRAP2(retval = _self_->edgeOrg(edge, &orgpt));
| 25145 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(orgpt)); |  | 25097 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(orgpt));
| 25146 | } |  | 25098 | }
| 25147 |  |  | 25099 |
| 25148 | return NULL; |  | 25100 | return NULL;
| 25149 | } |  | 25101 | }
| 25150 |  |  | 25102 |
| 25151 | static PyObject* pyopencv_cv_Subdiv2D_findNearest(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25103 | static PyObject* pyopencv_cv_Subdiv2D_findNearest(PyObject* self, PyObject* py_args, PyObject* kw)
| 25152 | { |  | 25104 | {
| 25153 | using namespace cv; |  | 25105 | using namespace cv;
| 25154 |  |  | 25106 |
| 25155 |  |  | 25107 |
| 25156 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25108 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25157 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25109 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25158 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25110 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25159 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25111 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25160 | PyObject* pyobj_pt = NULL; |  | 25112 | PyObject* pyobj_pt = NULL;
| 25161 | Point2f pt; |  | 25113 | Point2f pt;
| 25162 | Point2f nearestPt; |  | 25114 | Point2f nearestPt;
| 25163 | int retval; |  | 25115 | int retval;
| 25164 |  |  | 25116 |
| 25165 | const char* keywords[] = { "pt", NULL }; |  | 25117 | const char* keywords[] = { "pt", NULL };
| 25166 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.findNearest", (char**)keywords, &pyobj_pt) && |  | 25118 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.findNearest", (char**)keywords, &pyobj_pt) &&
| 25167 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) ) |  | 25119 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) )
| 25168 | { |  | 25120 | {
| 25169 | ERRWRAP2(retval = _self_->findNearest(pt, &nearestPt)); |  | 25121 | ERRWRAP2(retval = _self_->findNearest(pt, &nearestPt));
| 25170 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(nearestPt)); |  | 25122 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(nearestPt));
| 25171 | } |  | 25123 | }
| 25172 |  |  | 25124 |
| 25173 | return NULL; |  | 25125 | return NULL;
| 25174 | } |  | 25126 | }
| 25175 |  |  | 25127 |
| 25176 | static PyObject* pyopencv_cv_Subdiv2D_getEdge(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25128 | static PyObject* pyopencv_cv_Subdiv2D_getEdge(PyObject* self, PyObject* py_args, PyObject* kw)
| 25177 | { |  | 25129 | {
| 25178 | using namespace cv; |  | 25130 | using namespace cv;
| 25179 |  |  | 25131 |
| 25180 |  |  | 25132 |
| 25181 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25133 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25182 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25134 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25183 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25135 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25184 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25136 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25185 | PyObject* pyobj_edge = NULL; |  | 25137 | PyObject* pyobj_edge = NULL;
| 25186 | int edge=0; |  | 25138 | int edge=0;
| 25187 | PyObject* pyobj_nextEdgeType = NULL; |  | 25139 | PyObject* pyobj_nextEdgeType = NULL;
| 25188 | int nextEdgeType=0; |  | 25140 | int nextEdgeType=0;
| 25189 | int retval; |  | 25141 | int retval;
| 25190 |  |  | 25142 |
| 25191 | const char* keywords[] = { "edge", "nextEdgeType", NULL }; |  | 25143 | const char* keywords[] = { "edge", "nextEdgeType", NULL };
| 25192 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Subdiv2D.getEdge", (char**)keywords, &pyobj_edge, &pyobj_nextEdgeType) && |  | 25144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Subdiv2D.getEdge", (char**)keywords, &pyobj_edge, &pyobj_nextEdgeType) &&
| 25193 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) && |  | 25145 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) &&
| 25194 | pyopencv_to_safe(pyobj_nextEdgeType, nextEdgeType, ArgInfo("nextEdgeType", 0)) ) |  | 25146 | pyopencv_to_safe(pyobj_nextEdgeType, nextEdgeType, ArgInfo("nextEdgeType", 0)) )
| 25195 | { |  | 25147 | {
| 25196 | ERRWRAP2(retval = _self_->getEdge(edge, nextEdgeType)); |  | 25148 | ERRWRAP2(retval = _self_->getEdge(edge, nextEdgeType));
| 25197 | return pyopencv_from(retval); |  | 25149 | return pyopencv_from(retval);
| 25198 | } |  | 25150 | }
| 25199 |  |  | 25151 |
| 25200 | return NULL; |  | 25152 | return NULL;
| 25201 | } |  | 25153 | }
| 25202 |  |  | 25154 |
| 25203 | static PyObject* pyopencv_cv_Subdiv2D_getEdgeList(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25155 | static PyObject* pyopencv_cv_Subdiv2D_getEdgeList(PyObject* self, PyObject* py_args, PyObject* kw)
| 25204 | { |  | 25156 | {
| 25205 | using namespace cv; |  | 25157 | using namespace cv;
| 25206 |  |  | 25158 |
| 25207 |  |  | 25159 |
| 25208 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25160 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25209 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25161 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25210 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25162 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25211 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25163 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25212 | vector_Vec4f edgeList; |  | 25164 | vector_Vec4f edgeList;
| 25213 |  |  | 25165 |
| 25214 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25166 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25215 | { |  | 25167 | {
| 25216 | ERRWRAP2(_self_->getEdgeList(edgeList)); |  | 25168 | ERRWRAP2(_self_->getEdgeList(edgeList));
| 25217 | return pyopencv_from(edgeList); |  | 25169 | return pyopencv_from(edgeList);
| 25218 | } |  | 25170 | }
| 25219 |  |  | 25171 |
| 25220 | return NULL; |  | 25172 | return NULL;
| 25221 | } |  | 25173 | }
| 25222 |  |  | 25174 |
| 25223 | static PyObject* pyopencv_cv_Subdiv2D_getLeadingEdgeList(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25175 | static PyObject* pyopencv_cv_Subdiv2D_getLeadingEdgeList(PyObject* self, PyObject* py_args, PyObject* kw)
| 25224 | { |  | 25176 | {
| 25225 | using namespace cv; |  | 25177 | using namespace cv;
| 25226 |  |  | 25178 |
| 25227 |  |  | 25179 |
| 25228 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25180 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25229 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25181 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25230 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25182 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25231 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25183 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25232 | vector_int leadingEdgeList; |  | 25184 | vector_int leadingEdgeList;
| 25233 |  |  | 25185 |
| 25234 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25186 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25235 | { |  | 25187 | {
| 25236 | ERRWRAP2(_self_->getLeadingEdgeList(leadingEdgeList)); |  | 25188 | ERRWRAP2(_self_->getLeadingEdgeList(leadingEdgeList));
| 25237 | return pyopencv_from(leadingEdgeList); |  | 25189 | return pyopencv_from(leadingEdgeList);
| 25238 | } |  | 25190 | }
| 25239 |  |  | 25191 |
| 25240 | return NULL; |  | 25192 | return NULL;
| 25241 | } |  | 25193 | }
| 25242 |  |  | 25194 |
| 25243 | static PyObject* pyopencv_cv_Subdiv2D_getTriangleList(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25195 | static PyObject* pyopencv_cv_Subdiv2D_getTriangleList(PyObject* self, PyObject* py_args, PyObject* kw)
| 25244 | { |  | 25196 | {
| 25245 | using namespace cv; |  | 25197 | using namespace cv;
| 25246 |  |  | 25198 |
| 25247 |  |  | 25199 |
| 25248 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25200 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25249 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25201 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25250 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25202 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25251 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25203 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25252 | vector_Vec6f triangleList; |  | 25204 | vector_Vec6f triangleList;
| 25253 |  |  | 25205 |
| 25254 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25206 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25255 | { |  | 25207 | {
| 25256 | ERRWRAP2(_self_->getTriangleList(triangleList)); |  | 25208 | ERRWRAP2(_self_->getTriangleList(triangleList));
| 25257 | return pyopencv_from(triangleList); |  | 25209 | return pyopencv_from(triangleList);
| 25258 | } |  | 25210 | }
| 25259 |  |  | 25211 |
| 25260 | return NULL; |  | 25212 | return NULL;
| 25261 | } |  | 25213 | }
| 25262 |  |  | 25214 |
| 25263 | static PyObject* pyopencv_cv_Subdiv2D_getVertex(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25215 | static PyObject* pyopencv_cv_Subdiv2D_getVertex(PyObject* self, PyObject* py_args, PyObject* kw)
| 25264 | { |  | 25216 | {
| 25265 | using namespace cv; |  | 25217 | using namespace cv;
| 25266 |  |  | 25218 |
| 25267 |  |  | 25219 |
| 25268 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25220 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25269 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25221 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25270 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25222 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25271 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25223 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25272 | PyObject* pyobj_vertex = NULL; |  | 25224 | PyObject* pyobj_vertex = NULL;
| 25273 | int vertex=0; |  | 25225 | int vertex=0;
| 25274 | int firstEdge; |  | 25226 | int firstEdge;
| 25275 | Point2f retval; |  | 25227 | Point2f retval;
| 25276 |  |  | 25228 |
| 25277 | const char* keywords[] = { "vertex", NULL }; |  | 25229 | const char* keywords[] = { "vertex", NULL };
| 25278 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.getVertex", (char**)keywords, &pyobj_vertex) && |  | 25230 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.getVertex", (char**)keywords, &pyobj_vertex) &&
| 25279 | pyopencv_to_safe(pyobj_vertex, vertex, ArgInfo("vertex", 0)) ) |  | 25231 | pyopencv_to_safe(pyobj_vertex, vertex, ArgInfo("vertex", 0)) )
| 25280 | { |  | 25232 | {
| 25281 | ERRWRAP2(retval = _self_->getVertex(vertex, &firstEdge)); |  | 25233 | ERRWRAP2(retval = _self_->getVertex(vertex, &firstEdge));
| 25282 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(firstEdge)); |  | 25234 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(firstEdge));
| 25283 | } |  | 25235 | }
| 25284 |  |  | 25236 |
| 25285 | return NULL; |  | 25237 | return NULL;
| 25286 | } |  | 25238 | }
| 25287 |  |  | 25239 |
| 25288 | static PyObject* pyopencv_cv_Subdiv2D_getVoronoiFacetList(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25240 | static PyObject* pyopencv_cv_Subdiv2D_getVoronoiFacetList(PyObject* self, PyObject* py_args, PyObject* kw)
| 25289 | { |  | 25241 | {
| 25290 | using namespace cv; |  | 25242 | using namespace cv;
| 25291 |  |  | 25243 |
| 25292 |  |  | 25244 |
| 25293 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25245 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25294 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25246 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25295 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25247 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25296 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25248 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25297 | PyObject* pyobj_idx = NULL; |  | 25249 | PyObject* pyobj_idx = NULL;
| 25298 | vector_int idx; |  | 25250 | vector_int idx;
| 25299 | vector_vector_Point2f facetList; |  | 25251 | vector_vector_Point2f facetList;
| 25300 | vector_Point2f facetCenters; |  | 25252 | vector_Point2f facetCenters;
| 25301 |  |  | 25253 |
| 25302 | const char* keywords[] = { "idx", NULL }; |  | 25254 | const char* keywords[] = { "idx", NULL };
| 25303 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.getVoronoiFacetList", (char**)keywords, &pyobj_idx) && |  | 25255 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.getVoronoiFacetList", (char**)keywords, &pyobj_idx) &&
| 25304 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) ) |  | 25256 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) )
| 25305 | { |  | 25257 | {
| 25306 | ERRWRAP2(_self_->getVoronoiFacetList(idx, facetList, facetCenters)); |  | 25258 | ERRWRAP2(_self_->getVoronoiFacetList(idx, facetList, facetCenters));
| 25307 | return Py_BuildValue("(NN)", pyopencv_from(facetList), pyopencv_from(facetCenters)); |  | 25259 | return Py_BuildValue("(NN)", pyopencv_from(facetList), pyopencv_from(facetCenters));
| 25308 | } |  | 25260 | }
| 25309 |  |  | 25261 |
| 25310 | return NULL; |  | 25262 | return NULL;
| 25311 | } |  | 25263 | }
| 25312 |  |  | 25264 |
| 25313 | static PyObject* pyopencv_cv_Subdiv2D_initDelaunay(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25265 | static PyObject* pyopencv_cv_Subdiv2D_initDelaunay(PyObject* self, PyObject* py_args, PyObject* kw)
| 25314 | { |  | 25266 | {
| 25315 | using namespace cv; |  | 25267 | using namespace cv;
| 25316 |  |  | 25268 |
| 25317 |  |  | 25269 |
| 25318 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25270 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25319 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25271 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25320 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25272 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25321 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25273 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25322 | PyObject* pyobj_rect = NULL; |  | 25274 | PyObject* pyobj_rect = NULL;
| 25323 | Rect rect; |  | 25275 | Rect rect;
| 25324 |  |  | 25276 |
| 25325 | const char* keywords[] = { "rect", NULL }; |  | 25277 | const char* keywords[] = { "rect", NULL };
| 25326 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.initDelaunay", (char**)keywords, &pyobj_rect) && |  | 25278 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.initDelaunay", (char**)keywords, &pyobj_rect) &&
| 25327 | pyopencv_to_safe(pyobj_rect, rect, ArgInfo("rect", 0)) ) |  | 25279 | pyopencv_to_safe(pyobj_rect, rect, ArgInfo("rect", 0)) )
| 25328 | { |  | 25280 | {
| 25329 | ERRWRAP2(_self_->initDelaunay(rect)); |  | 25281 | ERRWRAP2(_self_->initDelaunay(rect));
| 25330 | Py_RETURN_NONE; |  | 25282 | Py_RETURN_NONE;
| 25331 | } |  | 25283 | }
| 25332 |  |  | 25284 |
| 25333 | return NULL; |  | 25285 | return NULL;
| 25334 | } |  | 25286 | }
| 25335 |  |  | 25287 |
| 25336 | static PyObject* pyopencv_cv_Subdiv2D_insert(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25288 | static PyObject* pyopencv_cv_Subdiv2D_insert(PyObject* self, PyObject* py_args, PyObject* kw)
| 25337 | { |  | 25289 | {
| 25338 | using namespace cv; |  | 25290 | using namespace cv;
| 25339 |  |  | 25291 |
| 25340 |  |  | 25292 |
| 25341 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25293 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25342 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25294 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25343 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25295 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25344 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25296 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25345 | pyPrepareArgumentConversionErrorsStorage(2); |  | 25297 | pyPrepareArgumentConversionErrorsStorage(2);
| 25346 |  |  | 25298 |
| 25347 | { |  | 25299 | {
| 25348 | PyObject* pyobj_pt = NULL; |  | 25300 | PyObject* pyobj_pt = NULL;
| 25349 | Point2f pt; |  | 25301 | Point2f pt;
| 25350 | int retval; |  | 25302 | int retval;
| 25351 |  |  | 25303 |
| 25352 | const char* keywords[] = { "pt", NULL }; |  | 25304 | const char* keywords[] = { "pt", NULL };
| 25353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.insert", (char**)keywords, &pyobj_pt) && |  | 25305 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.insert", (char**)keywords, &pyobj_pt) &&
| 25354 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) ) |  | 25306 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) )
| 25355 | { |  | 25307 | {
| 25356 | ERRWRAP2(retval = _self_->insert(pt)); |  | 25308 | ERRWRAP2(retval = _self_->insert(pt));
| 25357 | return pyopencv_from(retval); |  | 25309 | return pyopencv_from(retval);
| 25358 | } |  | 25310 | }
| 25359 |  |  | 25311 |
| 25360 |  |  | 25312 |
| 25361 | pyPopulateArgumentConversionErrors(); |  | 25313 | pyPopulateArgumentConversionErrors();
| 25362 | } |  | 25314 | }
| 25363 |  |  | 25315 |
| 25364 |  |  | 25316 |
| 25365 | { |  | 25317 | {
| 25366 | PyObject* pyobj_ptvec = NULL; |  | 25318 | PyObject* pyobj_ptvec = NULL;
| 25367 | vector_Point2f ptvec; |  | 25319 | vector_Point2f ptvec;
| 25368 |  |  | 25320 |
| 25369 | const char* keywords[] = { "ptvec", NULL }; |  | 25321 | const char* keywords[] = { "ptvec", NULL };
| 25370 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.insert", (char**)keywords, &pyobj_ptvec) && |  | 25322 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.insert", (char**)keywords, &pyobj_ptvec) &&
| 25371 | pyopencv_to_safe(pyobj_ptvec, ptvec, ArgInfo("ptvec", 0)) ) |  | 25323 | pyopencv_to_safe(pyobj_ptvec, ptvec, ArgInfo("ptvec", 0)) )
| 25372 | { |  | 25324 | {
| 25373 | ERRWRAP2(_self_->insert(ptvec)); |  | 25325 | ERRWRAP2(_self_->insert(ptvec));
| 25374 | Py_RETURN_NONE; |  | 25326 | Py_RETURN_NONE;
| 25375 | } |  | 25327 | }
| 25376 |  |  | 25328 |
| 25377 |  |  | 25329 |
| 25378 | pyPopulateArgumentConversionErrors(); |  | 25330 | pyPopulateArgumentConversionErrors();
| 25379 | } |  | 25331 | }
| 25380 | pyRaiseCVOverloadException("insert"); |  | 25332 | pyRaiseCVOverloadException("insert");
| 25381 |  |  | 25333 |
| 25382 | return NULL; |  | 25334 | return NULL;
| 25383 | } |  | 25335 | }
| 25384 |  |  | 25336 |
| 25385 | static PyObject* pyopencv_cv_Subdiv2D_locate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25337 | static PyObject* pyopencv_cv_Subdiv2D_locate(PyObject* self, PyObject* py_args, PyObject* kw)
| 25386 | { |  | 25338 | {
| 25387 | using namespace cv; |  | 25339 | using namespace cv;
| 25388 |  |  | 25340 |
| 25389 |  |  | 25341 |
| 25390 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25342 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25391 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25343 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25392 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25344 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25393 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25345 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25394 | PyObject* pyobj_pt = NULL; |  | 25346 | PyObject* pyobj_pt = NULL;
| 25395 | Point2f pt; |  | 25347 | Point2f pt;
| 25396 | int edge; |  | 25348 | int edge;
| 25397 | int vertex; |  | 25349 | int vertex;
| 25398 | int retval; |  | 25350 | int retval;
| 25399 |  |  | 25351 |
| 25400 | const char* keywords[] = { "pt", NULL }; |  | 25352 | const char* keywords[] = { "pt", NULL };
| 25401 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.locate", (char**)keywords, &pyobj_pt) && |  | 25353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.locate", (char**)keywords, &pyobj_pt) &&
| 25402 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) ) |  | 25354 | pyopencv_to_safe(pyobj_pt, pt, ArgInfo("pt", 0)) )
| 25403 | { |  | 25355 | {
| 25404 | ERRWRAP2(retval = _self_->locate(pt, edge, vertex)); |  | 25356 | ERRWRAP2(retval = _self_->locate(pt, edge, vertex));
| 25405 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(edge), pyopencv_from(vertex)); |  | 25357 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(edge), pyopencv_from(vertex));
| 25406 | } |  | 25358 | }
| 25407 |  |  | 25359 |
| 25408 | return NULL; |  | 25360 | return NULL;
| 25409 | } |  | 25361 | }
| 25410 |  |  | 25362 |
| 25411 | static PyObject* pyopencv_cv_Subdiv2D_nextEdge(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25363 | static PyObject* pyopencv_cv_Subdiv2D_nextEdge(PyObject* self, PyObject* py_args, PyObject* kw)
| 25412 | { |  | 25364 | {
| 25413 | using namespace cv; |  | 25365 | using namespace cv;
| 25414 |  |  | 25366 |
| 25415 |  |  | 25367 |
| 25416 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25368 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25417 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25369 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25418 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25370 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25419 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25371 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25420 | PyObject* pyobj_edge = NULL; |  | 25372 | PyObject* pyobj_edge = NULL;
| 25421 | int edge=0; |  | 25373 | int edge=0;
| 25422 | int retval; |  | 25374 | int retval;
| 25423 |  |  | 25375 |
| 25424 | const char* keywords[] = { "edge", NULL }; |  | 25376 | const char* keywords[] = { "edge", NULL };
| 25425 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.nextEdge", (char**)keywords, &pyobj_edge) && |  | 25377 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.nextEdge", (char**)keywords, &pyobj_edge) &&
| 25426 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) ) |  | 25378 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) )
| 25427 | { |  | 25379 | {
| 25428 | ERRWRAP2(retval = _self_->nextEdge(edge)); |  | 25380 | ERRWRAP2(retval = _self_->nextEdge(edge));
| 25429 | return pyopencv_from(retval); |  | 25381 | return pyopencv_from(retval);
| 25430 | } |  | 25382 | }
| 25431 |  |  | 25383 |
| 25432 | return NULL; |  | 25384 | return NULL;
| 25433 | } |  | 25385 | }
| 25434 |  |  | 25386 |
| 25435 | static PyObject* pyopencv_cv_Subdiv2D_rotateEdge(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25387 | static PyObject* pyopencv_cv_Subdiv2D_rotateEdge(PyObject* self, PyObject* py_args, PyObject* kw)
| 25436 | { |  | 25388 | {
| 25437 | using namespace cv; |  | 25389 | using namespace cv;
| 25438 |  |  | 25390 |
| 25439 |  |  | 25391 |
| 25440 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25392 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25441 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25393 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25442 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25394 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25443 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25395 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25444 | PyObject* pyobj_edge = NULL; |  | 25396 | PyObject* pyobj_edge = NULL;
| 25445 | int edge=0; |  | 25397 | int edge=0;
| 25446 | PyObject* pyobj_rotate = NULL; |  | 25398 | PyObject* pyobj_rotate = NULL;
| 25447 | int rotate=0; |  | 25399 | int rotate=0;
| 25448 | int retval; |  | 25400 | int retval;
| 25449 |  |  | 25401 |
| 25450 | const char* keywords[] = { "edge", "rotate", NULL }; |  | 25402 | const char* keywords[] = { "edge", "rotate", NULL };
| 25451 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Subdiv2D.rotateEdge", (char**)keywords, &pyobj_edge, &pyobj_rotate) && |  | 25403 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Subdiv2D.rotateEdge", (char**)keywords, &pyobj_edge, &pyobj_rotate) &&
| 25452 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) && |  | 25404 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) &&
| 25453 | pyopencv_to_safe(pyobj_rotate, rotate, ArgInfo("rotate", 0)) ) |  | 25405 | pyopencv_to_safe(pyobj_rotate, rotate, ArgInfo("rotate", 0)) )
| 25454 | { |  | 25406 | {
| 25455 | ERRWRAP2(retval = _self_->rotateEdge(edge, rotate)); |  | 25407 | ERRWRAP2(retval = _self_->rotateEdge(edge, rotate));
| 25456 | return pyopencv_from(retval); |  | 25408 | return pyopencv_from(retval);
| 25457 | } |  | 25409 | }
| 25458 |  |  | 25410 |
| 25459 | return NULL; |  | 25411 | return NULL;
| 25460 | } |  | 25412 | }
| 25461 |  |  | 25413 |
| 25462 | static PyObject* pyopencv_cv_Subdiv2D_symEdge(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25414 | static PyObject* pyopencv_cv_Subdiv2D_symEdge(PyObject* self, PyObject* py_args, PyObject* kw)
| 25463 | { |  | 25415 | {
| 25464 | using namespace cv; |  | 25416 | using namespace cv;
| 25465 |  |  | 25417 |
| 25466 |  |  | 25418 |
| 25467 | Ptr<cv::Subdiv2D> * self1 = 0; |  | 25419 | Ptr<cv::Subdiv2D> * self1 = 0;
| 25468 | if (!pyopencv_Subdiv2D_getp(self, self1)) |  | 25420 | if (!pyopencv_Subdiv2D_getp(self, self1))
| 25469 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)"); |  | 25421 | return failmsgp("Incorrect type of self (must be 'Subdiv2D' or its derivative)");
| 25470 | Ptr<cv::Subdiv2D> _self_ = *(self1); |  | 25422 | Ptr<cv::Subdiv2D> _self_ = *(self1);
| 25471 | PyObject* pyobj_edge = NULL; |  | 25423 | PyObject* pyobj_edge = NULL;
| 25472 | int edge=0; |  | 25424 | int edge=0;
| 25473 | int retval; |  | 25425 | int retval;
| 25474 |  |  | 25426 |
| 25475 | const char* keywords[] = { "edge", NULL }; |  | 25427 | const char* keywords[] = { "edge", NULL };
| 25476 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.symEdge", (char**)keywords, &pyobj_edge) && |  | 25428 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Subdiv2D.symEdge", (char**)keywords, &pyobj_edge) &&
| 25477 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) ) |  | 25429 | pyopencv_to_safe(pyobj_edge, edge, ArgInfo("edge", 0)) )
| 25478 | { |  | 25430 | {
| 25479 | ERRWRAP2(retval = _self_->symEdge(edge)); |  | 25431 | ERRWRAP2(retval = _self_->symEdge(edge));
| 25480 | return pyopencv_from(retval); |  | 25432 | return pyopencv_from(retval);
| 25481 | } |  | 25433 | }
| 25482 |  |  | 25434 |
| 25483 | return NULL; |  | 25435 | return NULL;
| 25484 | } |  | 25436 | }
| 25485 |  |  | 25437 |
| 25486 |  |  | 25438 |
| 25487 |  |  | 25439 |
| 25488 | // Tables (Subdiv2D) |  | 25440 | // Tables (Subdiv2D)
| 25489 |  |  | 25441 |
| 25490 | static PyGetSetDef pyopencv_Subdiv2D_getseters[] = |  | 25442 | static PyGetSetDef pyopencv_Subdiv2D_getseters[] =
| 25491 | { |  | 25443 | {
| 25492 | {NULL} /* Sentinel */ |  | 25444 | {NULL} /* Sentinel */
| 25493 | }; |  | 25445 | };
| 25494 |  |  | 25446 |
| 25495 | static PyMethodDef pyopencv_Subdiv2D_methods[] = |  | 25447 | static PyMethodDef pyopencv_Subdiv2D_methods[] =
| 25496 | { |  | 25448 | {
| 25497 | {"edgeDst", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_edgeDst, 0), "edgeDst(edge) -> retval, dstpt\n. @brief Returns the edge destination.\n. \n. @param edge Subdivision edge ID.\n. @param dstpt Output vertex location.\n. \n. @returns vertex ID."}, |  | 25449 | {"edgeDst", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_edgeDst, 0), "edgeDst(edge) -> retval, dstpt\n. @brief Returns the edge destination.\n. \n. @param edge Subdivision edge ID.\n. @param dstpt Output vertex location.\n. \n. @returns vertex ID."},
| 25498 | {"edgeOrg", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_edgeOrg, 0), "edgeOrg(edge) -> retval, orgpt\n. @brief Returns the edge origin.\n. \n. @param edge Subdivision edge ID.\n. @param orgpt Output vertex location.\n. \n. @returns vertex ID."}, |  | 25450 | {"edgeOrg", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_edgeOrg, 0), "edgeOrg(edge) -> retval, orgpt\n. @brief Returns the edge origin.\n. \n. @param edge Subdivision edge ID.\n. @param orgpt Output vertex location.\n. \n. @returns vertex ID."},
| 25499 | {"findNearest", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_findNearest, 0), "findNearest(pt) -> retval, nearestPt\n. @brief Finds the subdivision vertex closest to the given point.\n. \n. @param pt Input point.\n. @param nearestPt Output subdivision vertex point.\n. \n. The function is another function that locates the input point within the subdivision. It finds the\n. subdivision vertex that is the closest to the input point. It is not necessarily one of vertices\n. of the facet containing the input point, though the facet (located using locate() ) is used as a\n. starting point.\n. \n. @returns vertex ID."}, |  | 25451 | {"findNearest", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_findNearest, 0), "findNearest(pt) -> retval, nearestPt\n. @brief Finds the subdivision vertex closest to the given point.\n. \n. @param pt Input point.\n. @param nearestPt Output subdivision vertex point.\n. \n. The function is another function that locates the input point within the subdivision. It finds the\n. subdivision vertex that is the closest to the input point. It is not necessarily one of vertices\n. of the facet containing the input point, though the facet (located using locate() ) is used as a\n. starting point.\n. \n. @returns vertex ID."},
| 25500 | {"getEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getEdge, 0), "getEdge(edge, nextEdgeType) -> retval\n. @brief Returns one of the edges related to the given edge.\n. \n. @param edge Subdivision edge ID.\n. @param nextEdgeType Parameter specifying which of the related edges to return.\n. The following values are possible:\n. - NEXT_AROUND_ORG next around the edge origin ( eOnext on the picture below if e is the input edge)\n. - NEXT_AROUND_DST next around the edge vertex ( eDnext )\n. - PREV_AROUND_ORG previous around the edge origin (reversed eRnext )\n. - PREV_AROUND_DST previous around the edge destination (reversed eLnext )\n. - NEXT_AROUND_LEFT next around the left facet ( eLnext )\n. - NEXT_AROUND_RIGHT next around the right facet ( eRnext )\n. - PREV_AROUND_LEFT previous around the left facet (reversed eOnext )\n. - PREV_AROUND_RIGHT previous around the right facet (reversed eDnext )\n. \n. ![sample output](pics/quadedge.png)\n. \n. @returns edge ID related to the input edge."}, |  | 25452 | {"getEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getEdge, 0), "getEdge(edge, nextEdgeType) -> retval\n. @brief Returns one of the edges related to the given edge.\n. \n. @param edge Subdivision edge ID.\n. @param nextEdgeType Parameter specifying which of the related edges to return.\n. The following values are possible:\n. - NEXT_AROUND_ORG next around the edge origin ( eOnext on the picture below if e is the input edge)\n. - NEXT_AROUND_DST next around the edge vertex ( eDnext )\n. - PREV_AROUND_ORG previous around the edge origin (reversed eRnext )\n. - PREV_AROUND_DST previous around the edge destination (reversed eLnext )\n. - NEXT_AROUND_LEFT next around the left facet ( eLnext )\n. - NEXT_AROUND_RIGHT next around the right facet ( eRnext )\n. - PREV_AROUND_LEFT previous around the left facet (reversed eOnext )\n. - PREV_AROUND_RIGHT previous around the right facet (reversed eDnext )\n. \n. ![sample output](pics/quadedge.png)\n. \n. @returns edge ID related to the input edge."},
| 25501 | {"getEdgeList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getEdgeList, 0), "getEdgeList() -> edgeList\n. @brief Returns a list of all edges.\n. \n. @param edgeList Output vector.\n. \n. The function gives each edge as a 4 numbers vector, where each two are one of the edge\n. vertices. i.e. org_x = v[0], org_y = v[1], dst_x = v[2], dst_y = v[3]."}, |  | 25453 | {"getEdgeList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getEdgeList, 0), "getEdgeList() -> edgeList\n. @brief Returns a list of all edges.\n. \n. @param edgeList Output vector.\n. \n. The function gives each edge as a 4 numbers vector, where each two are one of the edge\n. vertices. i.e. org_x = v[0], org_y = v[1], dst_x = v[2], dst_y = v[3]."},
| 25502 | {"getLeadingEdgeList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getLeadingEdgeList, 0), "getLeadingEdgeList() -> leadingEdgeList\n. @brief Returns a list of the leading edge ID connected to each triangle.\n. \n. @param leadingEdgeList Output vector.\n. \n. The function gives one edge ID for each triangle."}, |  | 25454 | {"getLeadingEdgeList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getLeadingEdgeList, 0), "getLeadingEdgeList() -> leadingEdgeList\n. @brief Returns a list of the leading edge ID connected to each triangle.\n. \n. @param leadingEdgeList Output vector.\n. \n. The function gives one edge ID for each triangle."},
| 25503 | {"getTriangleList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getTriangleList, 0), "getTriangleList() -> triangleList\n. @brief Returns a list of all triangles.\n. \n. @param triangleList Output vector.\n. \n. The function gives each triangle as a 6 numbers vector, where each two are one of the triangle\n. vertices. i.e. p1_x = v[0], p1_y = v[1], p2_x = v[2], p2_y = v[3], p3_x = v[4], p3_y = v[5]."}, |  | 25455 | {"getTriangleList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getTriangleList, 0), "getTriangleList() -> triangleList\n. @brief Returns a list of all triangles.\n. \n. @param triangleList Output vector.\n. \n. The function gives each triangle as a 6 numbers vector, where each two are one of the triangle\n. vertices. i.e. p1_x = v[0], p1_y = v[1], p2_x = v[2], p2_y = v[3], p3_x = v[4], p3_y = v[5]."},
| 25504 | {"getVertex", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getVertex, 0), "getVertex(vertex) -> retval, firstEdge\n. @brief Returns vertex location from vertex ID.\n. \n. @param vertex vertex ID.\n. @param firstEdge Optional. The first edge ID which is connected to the vertex.\n. @returns vertex (x,y)"}, |  | 25456 | {"getVertex", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getVertex, 0), "getVertex(vertex) -> retval, firstEdge\n. @brief Returns vertex location from vertex ID.\n. \n. @param vertex vertex ID.\n. @param firstEdge Optional. The first edge ID which is connected to the vertex.\n. @returns vertex (x,y)"},
| 25505 | {"getVoronoiFacetList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getVoronoiFacetList, 0), "getVoronoiFacetList(idx) -> facetList, facetCenters\n. @brief Returns a list of all Voronoi facets.\n. \n. @param idx Vector of vertices IDs to consider. For all vertices you can pass empty vector.\n. @param facetList Output vector of the Voronoi facets.\n. @param facetCenters Output vector of the Voronoi facets center points."}, |  | 25457 | {"getVoronoiFacetList", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_getVoronoiFacetList, 0), "getVoronoiFacetList(idx) -> facetList, facetCenters\n. @brief Returns a list of all Voronoi facets.\n. \n. @param idx Vector of vertices IDs to consider. For all vertices you can pass empty vector.\n. @param facetList Output vector of the Voronoi facets.\n. @param facetCenters Output vector of the Voronoi facets center points."},
| 25506 | {"initDelaunay", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_initDelaunay, 0), "initDelaunay(rect) -> None\n. @brief Creates a new empty Delaunay subdivision\n. \n. @param rect Rectangle that includes all of the 2D points that are to be added to the subdivision."}, |  | 25458 | {"initDelaunay", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_initDelaunay, 0), "initDelaunay(rect) -> None\n. @brief Creates a new empty Delaunay subdivision\n. \n. @param rect Rectangle that includes all of the 2D points that are to be added to the subdivision."},
| 25507 | {"insert", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_insert, 0), "insert(pt) -> retval\n. @brief Insert a single point into a Delaunay triangulation.\n. \n. @param pt Point to insert.\n. \n. The function inserts a single point into a subdivision and modifies the subdivision topology\n. appropriately. If a point with the same coordinates exists already, no new point is added.\n. @returns the ID of the point.\n. \n. @note If the point is outside of the triangulation specified rect a runtime error is raised.\n\n\n\ninsert(ptvec) -> None\n. @brief Insert multiple points into a Delaunay triangulation.\n. \n. @param ptvec Points to insert.\n. \n. The function inserts a vector of points into a subdivision and modifies the subdivision topology\n. appropriately."}, |  | 25459 | {"insert", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_insert, 0), "insert(pt) -> retval\n. @brief Insert a single point into a Delaunay triangulation.\n. \n. @param pt Point to insert.\n. \n. The function inserts a single point into a subdivision and modifies the subdivision topology\n. appropriately. If a point with the same coordinates exists already, no new point is added.\n. @returns the ID of the point.\n. \n. @note If the point is outside of the triangulation specified rect a runtime error is raised.\n\n\n\ninsert(ptvec) -> None\n. @brief Insert multiple points into a Delaunay triangulation.\n. \n. @param ptvec Points to insert.\n. \n. The function inserts a vector of points into a subdivision and modifies the subdivision topology\n. appropriately."},
| 25508 | {"locate", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_locate, 0), "locate(pt) -> retval, edge, vertex\n. @brief Returns the location of a point within a Delaunay triangulation.\n. \n. @param pt Point to locate.\n. @param edge Output edge that the point belongs to or is located to the right of it.\n. @param vertex Optional output vertex the input point coincides with.\n. \n. The function locates the input point within the subdivision and gives one of the triangle edges\n. or vertices.\n. \n. @returns an integer which specify one of the following five cases for point location:\n. - The point falls into some facet. The function returns #PTLOC_INSIDE and edge will contain one of\n. edges of the facet.\n. - The point falls onto the edge. The function returns #PTLOC_ON_EDGE and edge will contain this edge.\n. - The point coincides with one of the subdivision vertices. The function returns #PTLOC_VERTEX and\n. vertex will contain a pointer to the vertex.\n. - The point is outside the subdivision reference rectangle. The function returns #PTLOC_OUTSIDE_RECT\n. and no pointers are filled.\n. - One of input arguments is invalid. A runtime error is raised or, if silent or \"parent\" error\n. processing mode is selected, #PTLOC_ERROR is returned."}, |  | 25460 | {"locate", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_locate, 0), "locate(pt) -> retval, edge, vertex\n. @brief Returns the location of a point within a Delaunay triangulation.\n. \n. @param pt Point to locate.\n. @param edge Output edge that the point belongs to or is located to the right of it.\n. @param vertex Optional output vertex the input point coincides with.\n. \n. The function locates the input point within the subdivision and gives one of the triangle edges\n. or vertices.\n. \n. @returns an integer which specify one of the following five cases for point location:\n. - The point falls into some facet. The function returns #PTLOC_INSIDE and edge will contain one of\n. edges of the facet.\n. - The point falls onto the edge. The function returns #PTLOC_ON_EDGE and edge will contain this edge.\n. - The point coincides with one of the subdivision vertices. The function returns #PTLOC_VERTEX and\n. vertex will contain a pointer to the vertex.\n. - The point is outside the subdivision reference rectangle. The function returns #PTLOC_OUTSIDE_RECT\n. and no pointers are filled.\n. - One of input arguments is invalid. A runtime error is raised or, if silent or \"parent\" error\n. processing mode is selected, #PTLOC_ERROR is returned."},
| 25509 | {"nextEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_nextEdge, 0), "nextEdge(edge) -> retval\n. @brief Returns next edge around the edge origin.\n. \n. @param edge Subdivision edge ID.\n. \n. @returns an integer which is next edge ID around the edge origin: eOnext on the\n. picture above if e is the input edge)."}, |  | 25461 | {"nextEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_nextEdge, 0), "nextEdge(edge) -> retval\n. @brief Returns next edge around the edge origin.\n. \n. @param edge Subdivision edge ID.\n. \n. @returns an integer which is next edge ID around the edge origin: eOnext on the\n. picture above if e is the input edge)."},
| 25510 | {"rotateEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_rotateEdge, 0), "rotateEdge(edge, rotate) -> retval\n. @brief Returns another edge of the same quad-edge.\n. \n. @param edge Subdivision edge ID.\n. @param rotate Parameter specifying which of the edges of the same quad-edge as the input\n. one to return. The following values are possible:\n. - 0 - the input edge ( e on the picture below if e is the input edge)\n. - 1 - the rotated edge ( eRot )\n. - 2 - the reversed edge (reversed e (in green))\n. - 3 - the reversed rotated edge (reversed eRot (in green))\n. \n. @returns one of the edges ID of the same quad-edge as the input edge."}, |  | 25462 | {"rotateEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_rotateEdge, 0), "rotateEdge(edge, rotate) -> retval\n. @brief Returns another edge of the same quad-edge.\n. \n. @param edge Subdivision edge ID.\n. @param rotate Parameter specifying which of the edges of the same quad-edge as the input\n. one to return. The following values are possible:\n. - 0 - the input edge ( e on the picture below if e is the input edge)\n. - 1 - the rotated edge ( eRot )\n. - 2 - the reversed edge (reversed e (in green))\n. - 3 - the reversed rotated edge (reversed eRot (in green))\n. \n. @returns one of the edges ID of the same quad-edge as the input edge."},
| 25511 | {"symEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_symEdge, 0), "symEdge(edge) -> retval\n."}, |  | 25463 | {"symEdge", CV_PY_FN_WITH_KW_(pyopencv_cv_Subdiv2D_symEdge, 0), "symEdge(edge) -> retval\n."},
| 25512 |  |  | 25464 |
| 25513 | {NULL, NULL} |  | 25465 | {NULL, NULL}
| 25514 | }; |  | 25466 | };
| 25515 |  |  | 25467 |
| 25516 | // Converter (Subdiv2D) |  | 25468 | // Converter (Subdiv2D)
| 25517 |  |  | 25469 |
| 25518 | template<> |  | 25470 | template<>
| 25519 | struct PyOpenCV_Converter< Ptr<cv::Subdiv2D> > |  | 25471 | struct PyOpenCV_Converter< Ptr<cv::Subdiv2D> >
| 25520 | { |  | 25472 | {
| 25521 | static PyObject* from(const Ptr<cv::Subdiv2D>& r) |  | 25473 | static PyObject* from(const Ptr<cv::Subdiv2D>& r)
| 25522 | { |  | 25474 | {
| 25523 | return pyopencv_Subdiv2D_Instance(r); |  | 25475 | return pyopencv_Subdiv2D_Instance(r);
| 25524 | } |  | 25476 | }
| 25525 | static bool to(PyObject* src, Ptr<cv::Subdiv2D>& dst, const ArgInfo& info) |  | 25477 | static bool to(PyObject* src, Ptr<cv::Subdiv2D>& dst, const ArgInfo& info)
| 25526 | { |  | 25478 | {
| 25527 | if(!src || src == Py_None) |  | 25479 | if(!src || src == Py_None)
| 25528 | return true; |  | 25480 | return true;
| 25529 | Ptr<cv::Subdiv2D> * dst_; |  | 25481 | Ptr<cv::Subdiv2D> * dst_;
| 25530 | if (pyopencv_Subdiv2D_getp(src, dst_)) |  | 25482 | if (pyopencv_Subdiv2D_getp(src, dst_))
| 25531 | { |  | 25483 | {
| 25532 | dst = *dst_; |  | 25484 | dst = *dst_;
| 25533 | return true; |  | 25485 | return true;
| 25534 | } |  | 25486 | }
| 25535 |  |  | 25487 |
| 25536 | failmsg("Expected Ptr<cv::Subdiv2D> for argument '%s'", info.name); |  | 25488 | failmsg("Expected Ptr<cv::Subdiv2D> for argument '%s'", info.name);
| 25537 | return false; |  | 25489 | return false;
| 25538 | } |  | 25490 | }
| 25539 | }; |  | 25491 | };
| 25540 |  |  | 25492 |
| 25541 | //================================================================================ |  | 25493 | //================================================================================
| 25542 | // ThinPlateSplineShapeTransformer (Generic) |  | 25494 | // ThinPlateSplineShapeTransformer (Generic)
| 25543 | //================================================================================ |  | 25495 | //================================================================================
| 25544 |  |  | 25496 |
| 25545 | // GetSet (ThinPlateSplineShapeTransformer) |  | 25497 | // GetSet (ThinPlateSplineShapeTransformer)
| 25546 |  |  | 25498 |
| 25547 |  |  | 25499 |
| 25548 |  |  | 25500 |
| 25549 | // Methods (ThinPlateSplineShapeTransformer) |  | 25501 | // Methods (ThinPlateSplineShapeTransformer)
| 25550 |  |  | 25502 |
| 25551 | static PyObject* pyopencv_cv_ThinPlateSplineShapeTransformer_getRegularizationParameter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25503 | static PyObject* pyopencv_cv_ThinPlateSplineShapeTransformer_getRegularizationParameter(PyObject* self, PyObject* py_args, PyObject* kw)
| 25552 | { |  | 25504 | {
| 25553 | using namespace cv; |  | 25505 | using namespace cv;
| 25554 |  |  | 25506 |
| 25555 |  |  | 25507 |
| 25556 | Ptr<cv::ThinPlateSplineShapeTransformer> * self1 = 0; |  | 25508 | Ptr<cv::ThinPlateSplineShapeTransformer> * self1 = 0;
| 25557 | if (!pyopencv_ThinPlateSplineShapeTransformer_getp(self, self1)) |  | 25509 | if (!pyopencv_ThinPlateSplineShapeTransformer_getp(self, self1))
| 25558 | return failmsgp("Incorrect type of self (must be 'ThinPlateSplineShapeTransformer' or its derivative)"); |  | 25510 | return failmsgp("Incorrect type of self (must be 'ThinPlateSplineShapeTransformer' or its derivative)");
| 25559 | Ptr<cv::ThinPlateSplineShapeTransformer> _self_ = *(self1); |  | 25511 | Ptr<cv::ThinPlateSplineShapeTransformer> _self_ = *(self1);
| 25560 | double retval; |  | 25512 | double retval;
| 25561 |  |  | 25513 |
| 25562 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25514 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25563 | { |  | 25515 | {
| 25564 | ERRWRAP2(retval = _self_->getRegularizationParameter()); |  | 25516 | ERRWRAP2(retval = _self_->getRegularizationParameter());
| 25565 | return pyopencv_from(retval); |  | 25517 | return pyopencv_from(retval);
| 25566 | } |  | 25518 | }
| 25567 |  |  | 25519 |
| 25568 | return NULL; |  | 25520 | return NULL;
| 25569 | } |  | 25521 | }
| 25570 |  |  | 25522 |
| 25571 | static PyObject* pyopencv_cv_ThinPlateSplineShapeTransformer_setRegularizationParameter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25523 | static PyObject* pyopencv_cv_ThinPlateSplineShapeTransformer_setRegularizationParameter(PyObject* self, PyObject* py_args, PyObject* kw)
| 25572 | { |  | 25524 | {
| 25573 | using namespace cv; |  | 25525 | using namespace cv;
| 25574 |  |  | 25526 |
| 25575 |  |  | 25527 |
| 25576 | Ptr<cv::ThinPlateSplineShapeTransformer> * self1 = 0; |  | 25528 | Ptr<cv::ThinPlateSplineShapeTransformer> * self1 = 0;
| 25577 | if (!pyopencv_ThinPlateSplineShapeTransformer_getp(self, self1)) |  | 25529 | if (!pyopencv_ThinPlateSplineShapeTransformer_getp(self, self1))
| 25578 | return failmsgp("Incorrect type of self (must be 'ThinPlateSplineShapeTransformer' or its derivative)"); |  | 25530 | return failmsgp("Incorrect type of self (must be 'ThinPlateSplineShapeTransformer' or its derivative)");
| 25579 | Ptr<cv::ThinPlateSplineShapeTransformer> _self_ = *(self1); |  | 25531 | Ptr<cv::ThinPlateSplineShapeTransformer> _self_ = *(self1);
| 25580 | PyObject* pyobj_beta = NULL; |  | 25532 | PyObject* pyobj_beta = NULL;
| 25581 | double beta=0; |  | 25533 | double beta=0;
| 25582 |  |  | 25534 |
| 25583 | const char* keywords[] = { "beta", NULL }; |  | 25535 | const char* keywords[] = { "beta", NULL };
| 25584 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ThinPlateSplineShapeTransformer.setRegularizationParameter", (char**)keywords, &pyobj_beta) && |  | 25536 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ThinPlateSplineShapeTransformer.setRegularizationParameter", (char**)keywords, &pyobj_beta) &&
| 25585 | pyopencv_to_safe(pyobj_beta, beta, ArgInfo("beta", 0)) ) |  | 25537 | pyopencv_to_safe(pyobj_beta, beta, ArgInfo("beta", 0)) )
| 25586 | { |  | 25538 | {
| 25587 | ERRWRAP2(_self_->setRegularizationParameter(beta)); |  | 25539 | ERRWRAP2(_self_->setRegularizationParameter(beta));
| 25588 | Py_RETURN_NONE; |  | 25540 | Py_RETURN_NONE;
| 25589 | } |  | 25541 | }
| 25590 |  |  | 25542 |
| 25591 | return NULL; |  | 25543 | return NULL;
| 25592 | } |  | 25544 | }
| 25593 |  |  | 25545 |
| 25594 |  |  | 25546 |
| 25595 |  |  | 25547 |
| 25596 | // Tables (ThinPlateSplineShapeTransformer) |  | 25548 | // Tables (ThinPlateSplineShapeTransformer)
| 25597 |  |  | 25549 |
| 25598 | static PyGetSetDef pyopencv_ThinPlateSplineShapeTransformer_getseters[] = |  | 25550 | static PyGetSetDef pyopencv_ThinPlateSplineShapeTransformer_getseters[] =
| 25599 | { |  | 25551 | {
| 25600 | {NULL} /* Sentinel */ |  | 25552 | {NULL} /* Sentinel */
| 25601 | }; |  | 25553 | };
| 25602 |  |  | 25554 |
| 25603 | static PyMethodDef pyopencv_ThinPlateSplineShapeTransformer_methods[] = |  | 25555 | static PyMethodDef pyopencv_ThinPlateSplineShapeTransformer_methods[] =
| 25604 | { |  | 25556 | {
| 25605 | {"getRegularizationParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_ThinPlateSplineShapeTransformer_getRegularizationParameter, 0), "getRegularizationParameter() -> retval\n."}, |  | 25557 | {"getRegularizationParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_ThinPlateSplineShapeTransformer_getRegularizationParameter, 0), "getRegularizationParameter() -> retval\n."},
| 25606 | {"setRegularizationParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_ThinPlateSplineShapeTransformer_setRegularizationParameter, 0), "setRegularizationParameter(beta) -> None\n. @brief Set the regularization parameter for relaxing the exact interpolation requirements of the TPS\n. algorithm.\n. \n. @param beta value of the regularization parameter."}, |  | 25558 | {"setRegularizationParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_ThinPlateSplineShapeTransformer_setRegularizationParameter, 0), "setRegularizationParameter(beta) -> None\n. @brief Set the regularization parameter for relaxing the exact interpolation requirements of the TPS\n. algorithm.\n. \n. @param beta value of the regularization parameter."},
| 25607 |  |  | 25559 |
| 25608 | {NULL, NULL} |  | 25560 | {NULL, NULL}
| 25609 | }; |  | 25561 | };
| 25610 |  |  | 25562 |
| 25611 | // Converter (ThinPlateSplineShapeTransformer) |  | 25563 | // Converter (ThinPlateSplineShapeTransformer)
| 25612 |  |  | 25564 |
| 25613 | template<> |  | 25565 | template<>
| 25614 | struct PyOpenCV_Converter< Ptr<cv::ThinPlateSplineShapeTransformer> > |  | 25566 | struct PyOpenCV_Converter< Ptr<cv::ThinPlateSplineShapeTransformer> >
| 25615 | { |  | 25567 | {
| 25616 | static PyObject* from(const Ptr<cv::ThinPlateSplineShapeTransformer>& r) |  | 25568 | static PyObject* from(const Ptr<cv::ThinPlateSplineShapeTransformer>& r)
| 25617 | { |  | 25569 | {
| 25618 | return pyopencv_ThinPlateSplineShapeTransformer_Instance(r); |  | 25570 | return pyopencv_ThinPlateSplineShapeTransformer_Instance(r);
| 25619 | } |  | 25571 | }
| 25620 | static bool to(PyObject* src, Ptr<cv::ThinPlateSplineShapeTransformer>& dst, const ArgInfo& info) |  | 25572 | static bool to(PyObject* src, Ptr<cv::ThinPlateSplineShapeTransformer>& dst, const ArgInfo& info)
| 25621 | { |  | 25573 | {
| 25622 | if(!src || src == Py_None) |  | 25574 | if(!src || src == Py_None)
| 25623 | return true; |  | 25575 | return true;
| 25624 | Ptr<cv::ThinPlateSplineShapeTransformer> * dst_; |  | 25576 | Ptr<cv::ThinPlateSplineShapeTransformer> * dst_;
| 25625 | if (pyopencv_ThinPlateSplineShapeTransformer_getp(src, dst_)) |  | 25577 | if (pyopencv_ThinPlateSplineShapeTransformer_getp(src, dst_))
| 25626 | { |  | 25578 | {
| 25627 | dst = *dst_; |  | 25579 | dst = *dst_;
| 25628 | return true; |  | 25580 | return true;
| 25629 | } |  | 25581 | }
| 25630 |  |  | 25582 |
| 25631 | failmsg("Expected Ptr<cv::ThinPlateSplineShapeTransformer> for argument '%s'", info.name); |  | 25583 | failmsg("Expected Ptr<cv::ThinPlateSplineShapeTransformer> for argument '%s'", info.name);
| 25632 | return false; |  | 25584 | return false;
| 25633 | } |  | 25585 | }
| 25634 | }; |  | 25586 | };
| 25635 |  |  | 25587 |
| 25636 | //================================================================================ |  | 25588 | //================================================================================
| 25637 | // TickMeter (Generic) |  | 25589 | // TickMeter (Generic)
| 25638 | //================================================================================ |  | 25590 | //================================================================================
| 25639 |  |  | 25591 |
| 25640 | // GetSet (TickMeter) |  | 25592 | // GetSet (TickMeter)
| 25641 |  |  | 25593 |
| 25642 |  |  | 25594 |
| 25643 |  |  | 25595 |
| 25644 | // Methods (TickMeter) |  | 25596 | // Methods (TickMeter)
| 25645 |  |  | 25597 |
| 25646 | static int pyopencv_cv_TickMeter_TickMeter(pyopencv_TickMeter_t* self, PyObject* py_args, PyObject* kw) |  | 25598 | static int pyopencv_cv_TickMeter_TickMeter(pyopencv_TickMeter_t* self, PyObject* py_args, PyObject* kw)
| 25647 | { |  | 25599 | {
| 25648 | using namespace cv; |  | 25600 | using namespace cv;
| 25649 |  |  | 25601 |
| 25650 |  |  | 25602 |
| 25651 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25603 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25652 | { |  | 25604 | {
| 25653 | new (&(self->v)) Ptr<cv::TickMeter>(); // init Ptr with placement new |  | 25605 | new (&(self->v)) Ptr<cv::TickMeter>(); // init Ptr with placement new
| 25654 | if(self) ERRWRAP2(self->v.reset(new cv::TickMeter())); |  | 25606 | if(self) ERRWRAP2(self->v.reset(new cv::TickMeter()));
| 25655 | return 0; |  | 25607 | return 0;
| 25656 | } |  | 25608 | }
| 25657 |  |  | 25609 |
| 25658 | return -1; |  | 25610 | return -1;
| 25659 | } |  | 25611 | }
| 25660 |  |  | 25612 |
| 25661 | static PyObject* pyopencv_cv_TickMeter_getAvgTimeMilli(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25613 | static PyObject* pyopencv_cv_TickMeter_getAvgTimeMilli(PyObject* self, PyObject* py_args, PyObject* kw)
| 25662 | { |  | 25614 | {
| 25663 | using namespace cv; |  | 25615 | using namespace cv;
| 25664 |  |  | 25616 |
| 25665 |  |  | 25617 |
| 25666 | Ptr<cv::TickMeter> * self1 = 0; |  | 25618 | Ptr<cv::TickMeter> * self1 = 0;
| 25667 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25619 | if (!pyopencv_TickMeter_getp(self, self1))
| 25668 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25620 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25669 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25621 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25670 | double retval; |  | 25622 | double retval;
| 25671 |  |  | 25623 |
| 25672 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25624 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25673 | { |  | 25625 | {
| 25674 | ERRWRAP2(retval = _self_->getAvgTimeMilli()); |  | 25626 | ERRWRAP2(retval = _self_->getAvgTimeMilli());
| 25675 | return pyopencv_from(retval); |  | 25627 | return pyopencv_from(retval);
| 25676 | } |  | 25628 | }
| 25677 |  |  | 25629 |
| 25678 | return NULL; |  | 25630 | return NULL;
| 25679 | } |  | 25631 | }
| 25680 |  |  | 25632 |
| 25681 | static PyObject* pyopencv_cv_TickMeter_getAvgTimeSec(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25633 | static PyObject* pyopencv_cv_TickMeter_getAvgTimeSec(PyObject* self, PyObject* py_args, PyObject* kw)
| 25682 | { |  | 25634 | {
| 25683 | using namespace cv; |  | 25635 | using namespace cv;
| 25684 |  |  | 25636 |
| 25685 |  |  | 25637 |
| 25686 | Ptr<cv::TickMeter> * self1 = 0; |  | 25638 | Ptr<cv::TickMeter> * self1 = 0;
| 25687 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25639 | if (!pyopencv_TickMeter_getp(self, self1))
| 25688 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25640 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25689 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25641 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25690 | double retval; |  | 25642 | double retval;
| 25691 |  |  | 25643 |
| 25692 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25644 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25693 | { |  | 25645 | {
| 25694 | ERRWRAP2(retval = _self_->getAvgTimeSec()); |  | 25646 | ERRWRAP2(retval = _self_->getAvgTimeSec());
| 25695 | return pyopencv_from(retval); |  | 25647 | return pyopencv_from(retval);
| 25696 | } |  | 25648 | }
| 25697 |  |  | 25649 |
| 25698 | return NULL; |  | 25650 | return NULL;
| 25699 | } |  | 25651 | }
| 25700 |  |  | 25652 |
| 25701 | static PyObject* pyopencv_cv_TickMeter_getCounter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25653 | static PyObject* pyopencv_cv_TickMeter_getCounter(PyObject* self, PyObject* py_args, PyObject* kw)
| 25702 | { |  | 25654 | {
| 25703 | using namespace cv; |  | 25655 | using namespace cv;
| 25704 |  |  | 25656 |
| 25705 |  |  | 25657 |
| 25706 | Ptr<cv::TickMeter> * self1 = 0; |  | 25658 | Ptr<cv::TickMeter> * self1 = 0;
| 25707 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25659 | if (!pyopencv_TickMeter_getp(self, self1))
| 25708 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25660 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25709 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25661 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25710 | int64 retval; |  | 25662 | int64 retval;
| 25711 |  |  | 25663 |
| 25712 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25664 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25713 | { |  | 25665 | {
| 25714 | ERRWRAP2(retval = _self_->getCounter()); |  | 25666 | ERRWRAP2(retval = _self_->getCounter());
| 25715 | return pyopencv_from(retval); |  | 25667 | return pyopencv_from(retval);
| 25716 | } |  | 25668 | }
| 25717 |  |  | 25669 |
| 25718 | return NULL; |  | 25670 | return NULL;
| 25719 | } |  | 25671 | }
| 25720 |  |  | 25672 |
| 25721 | static PyObject* pyopencv_cv_TickMeter_getFPS(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25673 | static PyObject* pyopencv_cv_TickMeter_getFPS(PyObject* self, PyObject* py_args, PyObject* kw)
| 25722 | { |  | 25674 | {
| 25723 | using namespace cv; |  | 25675 | using namespace cv;
| 25724 |  |  | 25676 |
| 25725 |  |  | 25677 |
| 25726 | Ptr<cv::TickMeter> * self1 = 0; |  | 25678 | Ptr<cv::TickMeter> * self1 = 0;
| 25727 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25679 | if (!pyopencv_TickMeter_getp(self, self1))
| 25728 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25680 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25729 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25681 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25730 | double retval; |  | 25682 | double retval;
| 25731 |  |  | 25683 |
| 25732 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25684 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25733 | { |  | 25685 | {
| 25734 | ERRWRAP2(retval = _self_->getFPS()); |  | 25686 | ERRWRAP2(retval = _self_->getFPS());
| 25735 | return pyopencv_from(retval); |  | 25687 | return pyopencv_from(retval);
| 25736 | } |  | 25688 | }
| 25737 |  |  | 25689 |
| 25738 | return NULL; |  | 25690 | return NULL;
| 25739 | } |  | 25691 | }
| 25740 |  |  | 25692 |
| 25741 | static PyObject* pyopencv_cv_TickMeter_getLastTimeMicro(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25693 | static PyObject* pyopencv_cv_TickMeter_getLastTimeMicro(PyObject* self, PyObject* py_args, PyObject* kw)
| 25742 | { |  | 25694 | {
| 25743 | using namespace cv; |  | 25695 | using namespace cv;
| 25744 |  |  | 25696 |
| 25745 |  |  | 25697 |
| 25746 | Ptr<cv::TickMeter> * self1 = 0; |  | 25698 | Ptr<cv::TickMeter> * self1 = 0;
| 25747 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25699 | if (!pyopencv_TickMeter_getp(self, self1))
| 25748 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25700 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25749 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25701 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25750 | double retval; |  | 25702 | double retval;
| 25751 |  |  | 25703 |
| 25752 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25704 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25753 | { |  | 25705 | {
| 25754 | ERRWRAP2(retval = _self_->getLastTimeMicro()); |  | 25706 | ERRWRAP2(retval = _self_->getLastTimeMicro());
| 25755 | return pyopencv_from(retval); |  | 25707 | return pyopencv_from(retval);
| 25756 | } |  | 25708 | }
| 25757 |  |  | 25709 |
| 25758 | return NULL; |  | 25710 | return NULL;
| 25759 | } |  | 25711 | }
| 25760 |  |  | 25712 |
| 25761 | static PyObject* pyopencv_cv_TickMeter_getLastTimeMilli(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25713 | static PyObject* pyopencv_cv_TickMeter_getLastTimeMilli(PyObject* self, PyObject* py_args, PyObject* kw)
| 25762 | { |  | 25714 | {
| 25763 | using namespace cv; |  | 25715 | using namespace cv;
| 25764 |  |  | 25716 |
| 25765 |  |  | 25717 |
| 25766 | Ptr<cv::TickMeter> * self1 = 0; |  | 25718 | Ptr<cv::TickMeter> * self1 = 0;
| 25767 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25719 | if (!pyopencv_TickMeter_getp(self, self1))
| 25768 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25720 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25769 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25721 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25770 | double retval; |  | 25722 | double retval;
| 25771 |  |  | 25723 |
| 25772 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25724 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25773 | { |  | 25725 | {
| 25774 | ERRWRAP2(retval = _self_->getLastTimeMilli()); |  | 25726 | ERRWRAP2(retval = _self_->getLastTimeMilli());
| 25775 | return pyopencv_from(retval); |  | 25727 | return pyopencv_from(retval);
| 25776 | } |  | 25728 | }
| 25777 |  |  | 25729 |
| 25778 | return NULL; |  | 25730 | return NULL;
| 25779 | } |  | 25731 | }
| 25780 |  |  | 25732 |
| 25781 | static PyObject* pyopencv_cv_TickMeter_getLastTimeSec(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25733 | static PyObject* pyopencv_cv_TickMeter_getLastTimeSec(PyObject* self, PyObject* py_args, PyObject* kw)
| 25782 | { |  | 25734 | {
| 25783 | using namespace cv; |  | 25735 | using namespace cv;
| 25784 |  |  | 25736 |
| 25785 |  |  | 25737 |
| 25786 | Ptr<cv::TickMeter> * self1 = 0; |  | 25738 | Ptr<cv::TickMeter> * self1 = 0;
| 25787 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25739 | if (!pyopencv_TickMeter_getp(self, self1))
| 25788 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25740 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25789 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25741 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25790 | double retval; |  | 25742 | double retval;
| 25791 |  |  | 25743 |
| 25792 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25744 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25793 | { |  | 25745 | {
| 25794 | ERRWRAP2(retval = _self_->getLastTimeSec()); |  | 25746 | ERRWRAP2(retval = _self_->getLastTimeSec());
| 25795 | return pyopencv_from(retval); |  | 25747 | return pyopencv_from(retval);
| 25796 | } |  | 25748 | }
| 25797 |  |  | 25749 |
| 25798 | return NULL; |  | 25750 | return NULL;
| 25799 | } |  | 25751 | }
| 25800 |  |  | 25752 |
| 25801 | static PyObject* pyopencv_cv_TickMeter_getLastTimeTicks(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25753 | static PyObject* pyopencv_cv_TickMeter_getLastTimeTicks(PyObject* self, PyObject* py_args, PyObject* kw)
| 25802 | { |  | 25754 | {
| 25803 | using namespace cv; |  | 25755 | using namespace cv;
| 25804 |  |  | 25756 |
| 25805 |  |  | 25757 |
| 25806 | Ptr<cv::TickMeter> * self1 = 0; |  | 25758 | Ptr<cv::TickMeter> * self1 = 0;
| 25807 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25759 | if (!pyopencv_TickMeter_getp(self, self1))
| 25808 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25760 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25809 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25761 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25810 | int64 retval; |  | 25762 | int64 retval;
| 25811 |  |  | 25763 |
| 25812 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25764 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25813 | { |  | 25765 | {
| 25814 | ERRWRAP2(retval = _self_->getLastTimeTicks()); |  | 25766 | ERRWRAP2(retval = _self_->getLastTimeTicks());
| 25815 | return pyopencv_from(retval); |  | 25767 | return pyopencv_from(retval);
| 25816 | } |  | 25768 | }
| 25817 |  |  | 25769 |
| 25818 | return NULL; |  | 25770 | return NULL;
| 25819 | } |  | 25771 | }
| 25820 |  |  | 25772 |
| 25821 | static PyObject* pyopencv_cv_TickMeter_getTimeMicro(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25773 | static PyObject* pyopencv_cv_TickMeter_getTimeMicro(PyObject* self, PyObject* py_args, PyObject* kw)
| 25822 | { |  | 25774 | {
| 25823 | using namespace cv; |  | 25775 | using namespace cv;
| 25824 |  |  | 25776 |
| 25825 |  |  | 25777 |
| 25826 | Ptr<cv::TickMeter> * self1 = 0; |  | 25778 | Ptr<cv::TickMeter> * self1 = 0;
| 25827 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25779 | if (!pyopencv_TickMeter_getp(self, self1))
| 25828 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25780 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25829 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25781 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25830 | double retval; |  | 25782 | double retval;
| 25831 |  |  | 25783 |
| 25832 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25784 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25833 | { |  | 25785 | {
| 25834 | ERRWRAP2(retval = _self_->getTimeMicro()); |  | 25786 | ERRWRAP2(retval = _self_->getTimeMicro());
| 25835 | return pyopencv_from(retval); |  | 25787 | return pyopencv_from(retval);
| 25836 | } |  | 25788 | }
| 25837 |  |  | 25789 |
| 25838 | return NULL; |  | 25790 | return NULL;
| 25839 | } |  | 25791 | }
| 25840 |  |  | 25792 |
| 25841 | static PyObject* pyopencv_cv_TickMeter_getTimeMilli(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25793 | static PyObject* pyopencv_cv_TickMeter_getTimeMilli(PyObject* self, PyObject* py_args, PyObject* kw)
| 25842 | { |  | 25794 | {
| 25843 | using namespace cv; |  | 25795 | using namespace cv;
| 25844 |  |  | 25796 |
| 25845 |  |  | 25797 |
| 25846 | Ptr<cv::TickMeter> * self1 = 0; |  | 25798 | Ptr<cv::TickMeter> * self1 = 0;
| 25847 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25799 | if (!pyopencv_TickMeter_getp(self, self1))
| 25848 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25800 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25849 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25801 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25850 | double retval; |  | 25802 | double retval;
| 25851 |  |  | 25803 |
| 25852 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25804 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25853 | { |  | 25805 | {
| 25854 | ERRWRAP2(retval = _self_->getTimeMilli()); |  | 25806 | ERRWRAP2(retval = _self_->getTimeMilli());
| 25855 | return pyopencv_from(retval); |  | 25807 | return pyopencv_from(retval);
| 25856 | } |  | 25808 | }
| 25857 |  |  | 25809 |
| 25858 | return NULL; |  | 25810 | return NULL;
| 25859 | } |  | 25811 | }
| 25860 |  |  | 25812 |
| 25861 | static PyObject* pyopencv_cv_TickMeter_getTimeSec(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25813 | static PyObject* pyopencv_cv_TickMeter_getTimeSec(PyObject* self, PyObject* py_args, PyObject* kw)
| 25862 | { |  | 25814 | {
| 25863 | using namespace cv; |  | 25815 | using namespace cv;
| 25864 |  |  | 25816 |
| 25865 |  |  | 25817 |
| 25866 | Ptr<cv::TickMeter> * self1 = 0; |  | 25818 | Ptr<cv::TickMeter> * self1 = 0;
| 25867 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25819 | if (!pyopencv_TickMeter_getp(self, self1))
| 25868 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25820 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25869 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25821 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25870 | double retval; |  | 25822 | double retval;
| 25871 |  |  | 25823 |
| 25872 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25824 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25873 | { |  | 25825 | {
| 25874 | ERRWRAP2(retval = _self_->getTimeSec()); |  | 25826 | ERRWRAP2(retval = _self_->getTimeSec());
| 25875 | return pyopencv_from(retval); |  | 25827 | return pyopencv_from(retval);
| 25876 | } |  | 25828 | }
| 25877 |  |  | 25829 |
| 25878 | return NULL; |  | 25830 | return NULL;
| 25879 | } |  | 25831 | }
| 25880 |  |  | 25832 |
| 25881 | static PyObject* pyopencv_cv_TickMeter_getTimeTicks(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25833 | static PyObject* pyopencv_cv_TickMeter_getTimeTicks(PyObject* self, PyObject* py_args, PyObject* kw)
| 25882 | { |  | 25834 | {
| 25883 | using namespace cv; |  | 25835 | using namespace cv;
| 25884 |  |  | 25836 |
| 25885 |  |  | 25837 |
| 25886 | Ptr<cv::TickMeter> * self1 = 0; |  | 25838 | Ptr<cv::TickMeter> * self1 = 0;
| 25887 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25839 | if (!pyopencv_TickMeter_getp(self, self1))
| 25888 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25840 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25889 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25841 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25890 | int64 retval; |  | 25842 | int64 retval;
| 25891 |  |  | 25843 |
| 25892 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25844 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25893 | { |  | 25845 | {
| 25894 | ERRWRAP2(retval = _self_->getTimeTicks()); |  | 25846 | ERRWRAP2(retval = _self_->getTimeTicks());
| 25895 | return pyopencv_from(retval); |  | 25847 | return pyopencv_from(retval);
| 25896 | } |  | 25848 | }
| 25897 |  |  | 25849 |
| 25898 | return NULL; |  | 25850 | return NULL;
| 25899 | } |  | 25851 | }
| 25900 |  |  | 25852 |
| 25901 | static PyObject* pyopencv_cv_TickMeter_reset(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25853 | static PyObject* pyopencv_cv_TickMeter_reset(PyObject* self, PyObject* py_args, PyObject* kw)
| 25902 | { |  | 25854 | {
| 25903 | using namespace cv; |  | 25855 | using namespace cv;
| 25904 |  |  | 25856 |
| 25905 |  |  | 25857 |
| 25906 | Ptr<cv::TickMeter> * self1 = 0; |  | 25858 | Ptr<cv::TickMeter> * self1 = 0;
| 25907 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25859 | if (!pyopencv_TickMeter_getp(self, self1))
| 25908 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25860 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25909 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25861 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25910 |  |  | 25862 |
| 25911 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25863 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25912 | { |  | 25864 | {
| 25913 | ERRWRAP2(_self_->reset()); |  | 25865 | ERRWRAP2(_self_->reset());
| 25914 | Py_RETURN_NONE; |  | 25866 | Py_RETURN_NONE;
| 25915 | } |  | 25867 | }
| 25916 |  |  | 25868 |
| 25917 | return NULL; |  | 25869 | return NULL;
| 25918 | } |  | 25870 | }
| 25919 |  |  | 25871 |
| 25920 | static PyObject* pyopencv_cv_TickMeter_start(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25872 | static PyObject* pyopencv_cv_TickMeter_start(PyObject* self, PyObject* py_args, PyObject* kw)
| 25921 | { |  | 25873 | {
| 25922 | using namespace cv; |  | 25874 | using namespace cv;
| 25923 |  |  | 25875 |
| 25924 |  |  | 25876 |
| 25925 | Ptr<cv::TickMeter> * self1 = 0; |  | 25877 | Ptr<cv::TickMeter> * self1 = 0;
| 25926 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25878 | if (!pyopencv_TickMeter_getp(self, self1))
| 25927 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25879 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25928 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25880 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25929 |  |  | 25881 |
| 25930 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25882 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25931 | { |  | 25883 | {
| 25932 | ERRWRAP2(_self_->start()); |  | 25884 | ERRWRAP2(_self_->start());
| 25933 | Py_RETURN_NONE; |  | 25885 | Py_RETURN_NONE;
| 25934 | } |  | 25886 | }
| 25935 |  |  | 25887 |
| 25936 | return NULL; |  | 25888 | return NULL;
| 25937 | } |  | 25889 | }
| 25938 |  |  | 25890 |
| 25939 | static PyObject* pyopencv_cv_TickMeter_stop(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25891 | static PyObject* pyopencv_cv_TickMeter_stop(PyObject* self, PyObject* py_args, PyObject* kw)
| 25940 | { |  | 25892 | {
| 25941 | using namespace cv; |  | 25893 | using namespace cv;
| 25942 |  |  | 25894 |
| 25943 |  |  | 25895 |
| 25944 | Ptr<cv::TickMeter> * self1 = 0; |  | 25896 | Ptr<cv::TickMeter> * self1 = 0;
| 25945 | if (!pyopencv_TickMeter_getp(self, self1)) |  | 25897 | if (!pyopencv_TickMeter_getp(self, self1))
| 25946 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)"); |  | 25898 | return failmsgp("Incorrect type of self (must be 'TickMeter' or its derivative)");
| 25947 | Ptr<cv::TickMeter> _self_ = *(self1); |  | 25899 | Ptr<cv::TickMeter> _self_ = *(self1);
| 25948 |  |  | 25900 |
| 25949 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25901 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 25950 | { |  | 25902 | {
| 25951 | ERRWRAP2(_self_->stop()); |  | 25903 | ERRWRAP2(_self_->stop());
| 25952 | Py_RETURN_NONE; |  | 25904 | Py_RETURN_NONE;
| 25953 | } |  | 25905 | }
| 25954 |  |  | 25906 |
| 25955 | return NULL; |  | 25907 | return NULL;
| 25956 | } |  | 25908 | }
| 25957 |  |  | 25909 |
| 25958 |  |  | 25910 |
| 25959 |  |  | 25911 |
| 25960 | // Tables (TickMeter) |  | 25912 | // Tables (TickMeter)
| 25961 |  |  | 25913 |
| 25962 | static PyGetSetDef pyopencv_TickMeter_getseters[] = |  | 25914 | static PyGetSetDef pyopencv_TickMeter_getseters[] =
| 25963 | { |  | 25915 | {
| 25964 | {NULL} /* Sentinel */ |  | 25916 | {NULL} /* Sentinel */
| 25965 | }; |  | 25917 | };
| 25966 |  |  | 25918 |
| 25967 | static PyMethodDef pyopencv_TickMeter_methods[] = |  | 25919 | static PyMethodDef pyopencv_TickMeter_methods[] =
| 25968 | { |  | 25920 | {
| 25969 | {"getAvgTimeMilli", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getAvgTimeMilli, 0), "getAvgTimeMilli() -> retval\n."}, |  | 25921 | {"getAvgTimeMilli", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getAvgTimeMilli, 0), "getAvgTimeMilli() -> retval\n."},
| 25970 | {"getAvgTimeSec", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getAvgTimeSec, 0), "getAvgTimeSec() -> retval\n."}, |  | 25922 | {"getAvgTimeSec", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getAvgTimeSec, 0), "getAvgTimeSec() -> retval\n."},
| 25971 | {"getCounter", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getCounter, 0), "getCounter() -> retval\n."}, |  | 25923 | {"getCounter", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getCounter, 0), "getCounter() -> retval\n."},
| 25972 | {"getFPS", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getFPS, 0), "getFPS() -> retval\n."}, |  | 25924 | {"getFPS", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getFPS, 0), "getFPS() -> retval\n."},
| 25973 | {"getLastTimeMicro", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeMicro, 0), "getLastTimeMicro() -> retval\n."}, |  | 25925 | {"getLastTimeMicro", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeMicro, 0), "getLastTimeMicro() -> retval\n."},
| 25974 | {"getLastTimeMilli", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeMilli, 0), "getLastTimeMilli() -> retval\n."}, |  | 25926 | {"getLastTimeMilli", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeMilli, 0), "getLastTimeMilli() -> retval\n."},
| 25975 | {"getLastTimeSec", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeSec, 0), "getLastTimeSec() -> retval\n."}, |  | 25927 | {"getLastTimeSec", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeSec, 0), "getLastTimeSec() -> retval\n."},
| 25976 | {"getLastTimeTicks", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeTicks, 0), "getLastTimeTicks() -> retval\n."}, |  | 25928 | {"getLastTimeTicks", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getLastTimeTicks, 0), "getLastTimeTicks() -> retval\n."},
| 25977 | {"getTimeMicro", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeMicro, 0), "getTimeMicro() -> retval\n."}, |  | 25929 | {"getTimeMicro", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeMicro, 0), "getTimeMicro() -> retval\n."},
| 25978 | {"getTimeMilli", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeMilli, 0), "getTimeMilli() -> retval\n."}, |  | 25930 | {"getTimeMilli", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeMilli, 0), "getTimeMilli() -> retval\n."},
| 25979 | {"getTimeSec", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeSec, 0), "getTimeSec() -> retval\n."}, |  | 25931 | {"getTimeSec", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeSec, 0), "getTimeSec() -> retval\n."},
| 25980 | {"getTimeTicks", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeTicks, 0), "getTimeTicks() -> retval\n."}, |  | 25932 | {"getTimeTicks", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_getTimeTicks, 0), "getTimeTicks() -> retval\n."},
| 25981 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_reset, 0), "reset() -> None\n."}, |  | 25933 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_reset, 0), "reset() -> None\n."},
| 25982 | {"start", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_start, 0), "start() -> None\n."}, |  | 25934 | {"start", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_start, 0), "start() -> None\n."},
| 25983 | {"stop", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_stop, 0), "stop() -> None\n."}, |  | 25935 | {"stop", CV_PY_FN_WITH_KW_(pyopencv_cv_TickMeter_stop, 0), "stop() -> None\n."},
| 25984 |  |  | 25936 |
| 25985 | {NULL, NULL} |  | 25937 | {NULL, NULL}
| 25986 | }; |  | 25938 | };
| 25987 |  |  | 25939 |
| 25988 | // Converter (TickMeter) |  | 25940 | // Converter (TickMeter)
| 25989 |  |  | 25941 |
| 25990 | template<> |  | 25942 | template<>
| 25991 | struct PyOpenCV_Converter< Ptr<cv::TickMeter> > |  | 25943 | struct PyOpenCV_Converter< Ptr<cv::TickMeter> >
| 25992 | { |  | 25944 | {
| 25993 | static PyObject* from(const Ptr<cv::TickMeter>& r) |  | 25945 | static PyObject* from(const Ptr<cv::TickMeter>& r)
| 25994 | { |  | 25946 | {
| 25995 | return pyopencv_TickMeter_Instance(r); |  | 25947 | return pyopencv_TickMeter_Instance(r);
| 25996 | } |  | 25948 | }
| 25997 | static bool to(PyObject* src, Ptr<cv::TickMeter>& dst, const ArgInfo& info) |  | 25949 | static bool to(PyObject* src, Ptr<cv::TickMeter>& dst, const ArgInfo& info)
| 25998 | { |  | 25950 | {
| 25999 | if(!src || src == Py_None) |  | 25951 | if(!src || src == Py_None)
| 26000 | return true; |  | 25952 | return true;
| 26001 | Ptr<cv::TickMeter> * dst_; |  | 25953 | Ptr<cv::TickMeter> * dst_;
| 26002 | if (pyopencv_TickMeter_getp(src, dst_)) |  | 25954 | if (pyopencv_TickMeter_getp(src, dst_))
| 26003 | { |  | 25955 | {
| 26004 | dst = *dst_; |  | 25956 | dst = *dst_;
| 26005 | return true; |  | 25957 | return true;
| 26006 | } |  | 25958 | }
| 26007 |  |  | 25959 |
| 26008 | failmsg("Expected Ptr<cv::TickMeter> for argument '%s'", info.name); |  | 25960 | failmsg("Expected Ptr<cv::TickMeter> for argument '%s'", info.name);
| 26009 | return false; |  | 25961 | return false;
| 26010 | } |  | 25962 | }
| 26011 | }; |  | 25963 | };
| 26012 |  |  | 25964 |
| 26013 | //================================================================================ |  | 25965 | //================================================================================
| 26014 | // Tonemap (Generic) |  | 25966 | // Tonemap (Generic)
| 26015 | //================================================================================ |  | 25967 | //================================================================================
| 26016 |  |  | 25968 |
| 26017 | // GetSet (Tonemap) |  | 25969 | // GetSet (Tonemap)
| 26018 |  |  | 25970 |
| 26019 |  |  | 25971 |
| 26020 |  |  | 25972 |
| 26021 | // Methods (Tonemap) |  | 25973 | // Methods (Tonemap)
| 26022 |  |  | 25974 |
| 26023 | static PyObject* pyopencv_cv_Tonemap_getGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25975 | static PyObject* pyopencv_cv_Tonemap_getGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 26024 | { |  | 25976 | {
| 26025 | using namespace cv; |  | 25977 | using namespace cv;
| 26026 |  |  | 25978 |
| 26027 |  |  | 25979 |
| 26028 | Ptr<cv::Tonemap> * self1 = 0; |  | 25980 | Ptr<cv::Tonemap> * self1 = 0;
| 26029 | if (!pyopencv_Tonemap_getp(self, self1)) |  | 25981 | if (!pyopencv_Tonemap_getp(self, self1))
| 26030 | return failmsgp("Incorrect type of self (must be 'Tonemap' or its derivative)"); |  | 25982 | return failmsgp("Incorrect type of self (must be 'Tonemap' or its derivative)");
| 26031 | Ptr<cv::Tonemap> _self_ = *(self1); |  | 25983 | Ptr<cv::Tonemap> _self_ = *(self1);
| 26032 | float retval; |  | 25984 | float retval;
| 26033 |  |  | 25985 |
| 26034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 25986 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26035 | { |  | 25987 | {
| 26036 | ERRWRAP2(retval = _self_->getGamma()); |  | 25988 | ERRWRAP2(retval = _self_->getGamma());
| 26037 | return pyopencv_from(retval); |  | 25989 | return pyopencv_from(retval);
| 26038 | } |  | 25990 | }
| 26039 |  |  | 25991 |
| 26040 | return NULL; |  | 25992 | return NULL;
| 26041 | } |  | 25993 | }
| 26042 |  |  | 25994 |
| 26043 | static PyObject* pyopencv_cv_Tonemap_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 25995 | static PyObject* pyopencv_cv_Tonemap_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 26044 | { |  | 25996 | {
| 26045 | using namespace cv; |  | 25997 | using namespace cv;
| 26046 |  |  | 25998 |
| 26047 |  |  | 25999 |
| 26048 | Ptr<cv::Tonemap> * self1 = 0; |  | 26000 | Ptr<cv::Tonemap> * self1 = 0;
| 26049 | if (!pyopencv_Tonemap_getp(self, self1)) |  | 26001 | if (!pyopencv_Tonemap_getp(self, self1))
| 26050 | return failmsgp("Incorrect type of self (must be 'Tonemap' or its derivative)"); |  | 26002 | return failmsgp("Incorrect type of self (must be 'Tonemap' or its derivative)");
| 26051 | Ptr<cv::Tonemap> _self_ = *(self1); |  | 26003 | Ptr<cv::Tonemap> _self_ = *(self1);
| 26052 | pyPrepareArgumentConversionErrorsStorage(2); |  | 26004 | pyPrepareArgumentConversionErrorsStorage(2);
| 26053 |  |  | 26005 |
| 26054 | { |  | 26006 | {
| 26055 | PyObject* pyobj_src = NULL; |  | 26007 | PyObject* pyobj_src = NULL;
| 26056 | Mat src; |  | 26008 | Mat src;
| 26057 | PyObject* pyobj_dst = NULL; |  | 26009 | PyObject* pyobj_dst = NULL;
| 26058 | Mat dst; |  | 26010 | Mat dst;
| 26059 |  |  | 26011 |
| 26060 | const char* keywords[] = { "src", "dst", NULL }; |  | 26012 | const char* keywords[] = { "src", "dst", NULL };
| 26061 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Tonemap.process", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 26013 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Tonemap.process", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 26062 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 26014 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 26063 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 26015 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 26064 | { |  | 26016 | {
| 26065 | ERRWRAP2(_self_->process(src, dst)); |  | 26017 | ERRWRAP2(_self_->process(src, dst));
| 26066 | return pyopencv_from(dst); |  | 26018 | return pyopencv_from(dst);
| 26067 | } |  | 26019 | }
| 26068 |  |  | 26020 |
| 26069 |  |  | 26021 |
| 26070 | pyPopulateArgumentConversionErrors(); |  | 26022 | pyPopulateArgumentConversionErrors();
| 26071 | } |  | 26023 | }
| 26072 |  |  | 26024 |
| 26073 |  |  | 26025 |
| 26074 | { |  | 26026 | {
| 26075 | PyObject* pyobj_src = NULL; |  | 26027 | PyObject* pyobj_src = NULL;
| 26076 | UMat src; |  | 26028 | UMat src;
| 26077 | PyObject* pyobj_dst = NULL; |  | 26029 | PyObject* pyobj_dst = NULL;
| 26078 | UMat dst; |  | 26030 | UMat dst;
| 26079 |  |  | 26031 |
| 26080 | const char* keywords[] = { "src", "dst", NULL }; |  | 26032 | const char* keywords[] = { "src", "dst", NULL };
| 26081 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Tonemap.process", (char**)keywords, &pyobj_src, &pyobj_dst) && |  | 26033 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Tonemap.process", (char**)keywords, &pyobj_src, &pyobj_dst) &&
| 26082 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 26034 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 26083 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 26035 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 26084 | { |  | 26036 | {
| 26085 | ERRWRAP2(_self_->process(src, dst)); |  | 26037 | ERRWRAP2(_self_->process(src, dst));
| 26086 | return pyopencv_from(dst); |  | 26038 | return pyopencv_from(dst);
| 26087 | } |  | 26039 | }
| 26088 |  |  | 26040 |
| 26089 |  |  | 26041 |
| 26090 | pyPopulateArgumentConversionErrors(); |  | 26042 | pyPopulateArgumentConversionErrors();
| 26091 | } |  | 26043 | }
| 26092 | pyRaiseCVOverloadException("process"); |  | 26044 | pyRaiseCVOverloadException("process");
| 26093 |  |  | 26045 |
| 26094 | return NULL; |  | 26046 | return NULL;
| 26095 | } |  | 26047 | }
| 26096 |  |  | 26048 |
| 26097 | static PyObject* pyopencv_cv_Tonemap_setGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26049 | static PyObject* pyopencv_cv_Tonemap_setGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 26098 | { |  | 26050 | {
| 26099 | using namespace cv; |  | 26051 | using namespace cv;
| 26100 |  |  | 26052 |
| 26101 |  |  | 26053 |
| 26102 | Ptr<cv::Tonemap> * self1 = 0; |  | 26054 | Ptr<cv::Tonemap> * self1 = 0;
| 26103 | if (!pyopencv_Tonemap_getp(self, self1)) |  | 26055 | if (!pyopencv_Tonemap_getp(self, self1))
| 26104 | return failmsgp("Incorrect type of self (must be 'Tonemap' or its derivative)"); |  | 26056 | return failmsgp("Incorrect type of self (must be 'Tonemap' or its derivative)");
| 26105 | Ptr<cv::Tonemap> _self_ = *(self1); |  | 26057 | Ptr<cv::Tonemap> _self_ = *(self1);
| 26106 | PyObject* pyobj_gamma = NULL; |  | 26058 | PyObject* pyobj_gamma = NULL;
| 26107 | float gamma=0.f; |  | 26059 | float gamma=0.f;
| 26108 |  |  | 26060 |
| 26109 | const char* keywords[] = { "gamma", NULL }; |  | 26061 | const char* keywords[] = { "gamma", NULL };
| 26110 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Tonemap.setGamma", (char**)keywords, &pyobj_gamma) && |  | 26062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Tonemap.setGamma", (char**)keywords, &pyobj_gamma) &&
| 26111 | pyopencv_to_safe(pyobj_gamma, gamma, ArgInfo("gamma", 0)) ) |  | 26063 | pyopencv_to_safe(pyobj_gamma, gamma, ArgInfo("gamma", 0)) )
| 26112 | { |  | 26064 | {
| 26113 | ERRWRAP2(_self_->setGamma(gamma)); |  | 26065 | ERRWRAP2(_self_->setGamma(gamma));
| 26114 | Py_RETURN_NONE; |  | 26066 | Py_RETURN_NONE;
| 26115 | } |  | 26067 | }
| 26116 |  |  | 26068 |
| 26117 | return NULL; |  | 26069 | return NULL;
| 26118 | } |  | 26070 | }
| 26119 |  |  | 26071 |
| 26120 |  |  | 26072 |
| 26121 |  |  | 26073 |
| 26122 | // Tables (Tonemap) |  | 26074 | // Tables (Tonemap)
| 26123 |  |  | 26075 |
| 26124 | static PyGetSetDef pyopencv_Tonemap_getseters[] = |  | 26076 | static PyGetSetDef pyopencv_Tonemap_getseters[] =
| 26125 | { |  | 26077 | {
| 26126 | {NULL} /* Sentinel */ |  | 26078 | {NULL} /* Sentinel */
| 26127 | }; |  | 26079 | };
| 26128 |  |  | 26080 |
| 26129 | static PyMethodDef pyopencv_Tonemap_methods[] = |  | 26081 | static PyMethodDef pyopencv_Tonemap_methods[] =
| 26130 | { |  | 26082 | {
| 26131 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_Tonemap_getGamma, 0), "getGamma() -> retval\n."}, |  | 26083 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_Tonemap_getGamma, 0), "getGamma() -> retval\n."},
| 26132 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_Tonemap_process, 0), "process(src[, dst]) -> dst\n. @brief Tonemaps image\n. \n. @param src source image - CV_32FC3 Mat (float 32 bits 3 channels)\n. @param dst destination image - CV_32FC3 Mat with values in [0, 1] range"}, |  | 26084 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_Tonemap_process, 0), "process(src[, dst]) -> dst\n. @brief Tonemaps image\n. \n. @param src source image - CV_32FC3 Mat (float 32 bits 3 channels)\n. @param dst destination image - CV_32FC3 Mat with values in [0, 1] range"},
| 26133 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_Tonemap_setGamma, 0), "setGamma(gamma) -> None\n."}, |  | 26085 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_Tonemap_setGamma, 0), "setGamma(gamma) -> None\n."},
| 26134 |  |  | 26086 |
| 26135 | {NULL, NULL} |  | 26087 | {NULL, NULL}
| 26136 | }; |  | 26088 | };
| 26137 |  |  | 26089 |
| 26138 | // Converter (Tonemap) |  | 26090 | // Converter (Tonemap)
| 26139 |  |  | 26091 |
| 26140 | template<> |  | 26092 | template<>
| 26141 | struct PyOpenCV_Converter< Ptr<cv::Tonemap> > |  | 26093 | struct PyOpenCV_Converter< Ptr<cv::Tonemap> >
| 26142 | { |  | 26094 | {
| 26143 | static PyObject* from(const Ptr<cv::Tonemap>& r) |  | 26095 | static PyObject* from(const Ptr<cv::Tonemap>& r)
| 26144 | { |  | 26096 | {
| 26145 | return pyopencv_Tonemap_Instance(r); |  | 26097 | return pyopencv_Tonemap_Instance(r);
| 26146 | } |  | 26098 | }
| 26147 | static bool to(PyObject* src, Ptr<cv::Tonemap>& dst, const ArgInfo& info) |  | 26099 | static bool to(PyObject* src, Ptr<cv::Tonemap>& dst, const ArgInfo& info)
| 26148 | { |  | 26100 | {
| 26149 | if(!src || src == Py_None) |  | 26101 | if(!src || src == Py_None)
| 26150 | return true; |  | 26102 | return true;
| 26151 | Ptr<cv::Tonemap> * dst_; |  | 26103 | Ptr<cv::Tonemap> * dst_;
| 26152 | if (pyopencv_Tonemap_getp(src, dst_)) |  | 26104 | if (pyopencv_Tonemap_getp(src, dst_))
| 26153 | { |  | 26105 | {
| 26154 | dst = *dst_; |  | 26106 | dst = *dst_;
| 26155 | return true; |  | 26107 | return true;
| 26156 | } |  | 26108 | }
| 26157 |  |  | 26109 |
| 26158 | failmsg("Expected Ptr<cv::Tonemap> for argument '%s'", info.name); |  | 26110 | failmsg("Expected Ptr<cv::Tonemap> for argument '%s'", info.name);
| 26159 | return false; |  | 26111 | return false;
| 26160 | } |  | 26112 | }
| 26161 | }; |  | 26113 | };
| 26162 |  |  | 26114 |
| 26163 | //================================================================================ |  | 26115 | //================================================================================
| 26164 | // TonemapDrago (Generic) |  | 26116 | // TonemapDrago (Generic)
| 26165 | //================================================================================ |  | 26117 | //================================================================================
| 26166 |  |  | 26118 |
| 26167 | // GetSet (TonemapDrago) |  | 26119 | // GetSet (TonemapDrago)
| 26168 |  |  | 26120 |
| 26169 |  |  | 26121 |
| 26170 |  |  | 26122 |
| 26171 | // Methods (TonemapDrago) |  | 26123 | // Methods (TonemapDrago)
| 26172 |  |  | 26124 |
| 26173 | static PyObject* pyopencv_cv_TonemapDrago_getBias(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26125 | static PyObject* pyopencv_cv_TonemapDrago_getBias(PyObject* self, PyObject* py_args, PyObject* kw)
| 26174 | { |  | 26126 | {
| 26175 | using namespace cv; |  | 26127 | using namespace cv;
| 26176 |  |  | 26128 |
| 26177 |  |  | 26129 |
| 26178 | Ptr<cv::TonemapDrago> * self1 = 0; |  | 26130 | Ptr<cv::TonemapDrago> * self1 = 0;
| 26179 | if (!pyopencv_TonemapDrago_getp(self, self1)) |  | 26131 | if (!pyopencv_TonemapDrago_getp(self, self1))
| 26180 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)"); |  | 26132 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)");
| 26181 | Ptr<cv::TonemapDrago> _self_ = *(self1); |  | 26133 | Ptr<cv::TonemapDrago> _self_ = *(self1);
| 26182 | float retval; |  | 26134 | float retval;
| 26183 |  |  | 26135 |
| 26184 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 26136 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26185 | { |  | 26137 | {
| 26186 | ERRWRAP2(retval = _self_->getBias()); |  | 26138 | ERRWRAP2(retval = _self_->getBias());
| 26187 | return pyopencv_from(retval); |  | 26139 | return pyopencv_from(retval);
| 26188 | } |  | 26140 | }
| 26189 |  |  | 26141 |
| 26190 | return NULL; |  | 26142 | return NULL;
| 26191 | } |  | 26143 | }
| 26192 |  |  | 26144 |
| 26193 | static PyObject* pyopencv_cv_TonemapDrago_getSaturation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26145 | static PyObject* pyopencv_cv_TonemapDrago_getSaturation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26194 | { |  | 26146 | {
| 26195 | using namespace cv; |  | 26147 | using namespace cv;
| 26196 |  |  | 26148 |
| 26197 |  |  | 26149 |
| 26198 | Ptr<cv::TonemapDrago> * self1 = 0; |  | 26150 | Ptr<cv::TonemapDrago> * self1 = 0;
| 26199 | if (!pyopencv_TonemapDrago_getp(self, self1)) |  | 26151 | if (!pyopencv_TonemapDrago_getp(self, self1))
| 26200 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)"); |  | 26152 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)");
| 26201 | Ptr<cv::TonemapDrago> _self_ = *(self1); |  | 26153 | Ptr<cv::TonemapDrago> _self_ = *(self1);
| 26202 | float retval; |  | 26154 | float retval;
| 26203 |  |  | 26155 |
| 26204 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 26156 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26205 | { |  | 26157 | {
| 26206 | ERRWRAP2(retval = _self_->getSaturation()); |  | 26158 | ERRWRAP2(retval = _self_->getSaturation());
| 26207 | return pyopencv_from(retval); |  | 26159 | return pyopencv_from(retval);
| 26208 | } |  | 26160 | }
| 26209 |  |  | 26161 |
| 26210 | return NULL; |  | 26162 | return NULL;
| 26211 | } |  | 26163 | }
| 26212 |  |  | 26164 |
| 26213 | static PyObject* pyopencv_cv_TonemapDrago_setBias(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26165 | static PyObject* pyopencv_cv_TonemapDrago_setBias(PyObject* self, PyObject* py_args, PyObject* kw)
| 26214 | { |  | 26166 | {
| 26215 | using namespace cv; |  | 26167 | using namespace cv;
| 26216 |  |  | 26168 |
| 26217 |  |  | 26169 |
| 26218 | Ptr<cv::TonemapDrago> * self1 = 0; |  | 26170 | Ptr<cv::TonemapDrago> * self1 = 0;
| 26219 | if (!pyopencv_TonemapDrago_getp(self, self1)) |  | 26171 | if (!pyopencv_TonemapDrago_getp(self, self1))
| 26220 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)"); |  | 26172 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)");
| 26221 | Ptr<cv::TonemapDrago> _self_ = *(self1); |  | 26173 | Ptr<cv::TonemapDrago> _self_ = *(self1);
| 26222 | PyObject* pyobj_bias = NULL; |  | 26174 | PyObject* pyobj_bias = NULL;
| 26223 | float bias=0.f; |  | 26175 | float bias=0.f;
| 26224 |  |  | 26176 |
| 26225 | const char* keywords[] = { "bias", NULL }; |  | 26177 | const char* keywords[] = { "bias", NULL };
| 26226 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapDrago.setBias", (char**)keywords, &pyobj_bias) && |  | 26178 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapDrago.setBias", (char**)keywords, &pyobj_bias) &&
| 26227 | pyopencv_to_safe(pyobj_bias, bias, ArgInfo("bias", 0)) ) |  | 26179 | pyopencv_to_safe(pyobj_bias, bias, ArgInfo("bias", 0)) )
| 26228 | { |  | 26180 | {
| 26229 | ERRWRAP2(_self_->setBias(bias)); |  | 26181 | ERRWRAP2(_self_->setBias(bias));
| 26230 | Py_RETURN_NONE; |  | 26182 | Py_RETURN_NONE;
| 26231 | } |  | 26183 | }
| 26232 |  |  | 26184 |
| 26233 | return NULL; |  | 26185 | return NULL;
| 26234 | } |  | 26186 | }
| 26235 |  |  | 26187 |
| 26236 | static PyObject* pyopencv_cv_TonemapDrago_setSaturation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26188 | static PyObject* pyopencv_cv_TonemapDrago_setSaturation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26237 | { |  | 26189 | {
| 26238 | using namespace cv; |  | 26190 | using namespace cv;
| 26239 |  |  | 26191 |
| 26240 |  |  | 26192 |
| 26241 | Ptr<cv::TonemapDrago> * self1 = 0; |  | 26193 | Ptr<cv::TonemapDrago> * self1 = 0;
| 26242 | if (!pyopencv_TonemapDrago_getp(self, self1)) |  | 26194 | if (!pyopencv_TonemapDrago_getp(self, self1))
| 26243 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)"); |  | 26195 | return failmsgp("Incorrect type of self (must be 'TonemapDrago' or its derivative)");
| 26244 | Ptr<cv::TonemapDrago> _self_ = *(self1); |  | 26196 | Ptr<cv::TonemapDrago> _self_ = *(self1);
| 26245 | PyObject* pyobj_saturation = NULL; |  | 26197 | PyObject* pyobj_saturation = NULL;
| 26246 | float saturation=0.f; |  | 26198 | float saturation=0.f;
| 26247 |  |  | 26199 |
| 26248 | const char* keywords[] = { "saturation", NULL }; |  | 26200 | const char* keywords[] = { "saturation", NULL };
| 26249 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapDrago.setSaturation", (char**)keywords, &pyobj_saturation) && |  | 26201 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapDrago.setSaturation", (char**)keywords, &pyobj_saturation) &&
| 26250 | pyopencv_to_safe(pyobj_saturation, saturation, ArgInfo("saturation", 0)) ) |  | 26202 | pyopencv_to_safe(pyobj_saturation, saturation, ArgInfo("saturation", 0)) )
| 26251 | { |  | 26203 | {
| 26252 | ERRWRAP2(_self_->setSaturation(saturation)); |  | 26204 | ERRWRAP2(_self_->setSaturation(saturation));
| 26253 | Py_RETURN_NONE; |  | 26205 | Py_RETURN_NONE;
| 26254 | } |  | 26206 | }
| 26255 |  |  | 26207 |
| 26256 | return NULL; |  | 26208 | return NULL;
| 26257 | } |  | 26209 | }
| 26258 |  |  | 26210 |
| 26259 |  |  | 26211 |
| 26260 |  |  | 26212 |
| 26261 | // Tables (TonemapDrago) |  | 26213 | // Tables (TonemapDrago)
| 26262 |  |  | 26214 |
| 26263 | static PyGetSetDef pyopencv_TonemapDrago_getseters[] = |  | 26215 | static PyGetSetDef pyopencv_TonemapDrago_getseters[] =
| 26264 | { |  | 26216 | {
| 26265 | {NULL} /* Sentinel */ |  | 26217 | {NULL} /* Sentinel */
| 26266 | }; |  | 26218 | };
| 26267 |  |  | 26219 |
| 26268 | static PyMethodDef pyopencv_TonemapDrago_methods[] = |  | 26220 | static PyMethodDef pyopencv_TonemapDrago_methods[] =
| 26269 | { |  | 26221 | {
| 26270 | {"getBias", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_getBias, 0), "getBias() -> retval\n."}, |  | 26222 | {"getBias", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_getBias, 0), "getBias() -> retval\n."},
| 26271 | {"getSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_getSaturation, 0), "getSaturation() -> retval\n."}, |  | 26223 | {"getSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_getSaturation, 0), "getSaturation() -> retval\n."},
| 26272 | {"setBias", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_setBias, 0), "setBias(bias) -> None\n."}, |  | 26224 | {"setBias", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_setBias, 0), "setBias(bias) -> None\n."},
| 26273 | {"setSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_setSaturation, 0), "setSaturation(saturation) -> None\n."}, |  | 26225 | {"setSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapDrago_setSaturation, 0), "setSaturation(saturation) -> None\n."},
| 26274 |  |  | 26226 |
| 26275 | {NULL, NULL} |  | 26227 | {NULL, NULL}
| 26276 | }; |  | 26228 | };
| 26277 |  |  | 26229 |
| 26278 | // Converter (TonemapDrago) |  | 26230 | // Converter (TonemapDrago)
| 26279 |  |  | 26231 |
| 26280 | template<> |  | 26232 | template<>
| 26281 | struct PyOpenCV_Converter< Ptr<cv::TonemapDrago> > |  | 26233 | struct PyOpenCV_Converter< Ptr<cv::TonemapDrago> >
| 26282 | { |  | 26234 | {
| 26283 | static PyObject* from(const Ptr<cv::TonemapDrago>& r) |  | 26235 | static PyObject* from(const Ptr<cv::TonemapDrago>& r)
| 26284 | { |  | 26236 | {
| 26285 | return pyopencv_TonemapDrago_Instance(r); |  | 26237 | return pyopencv_TonemapDrago_Instance(r);
| 26286 | } |  | 26238 | }
| 26287 | static bool to(PyObject* src, Ptr<cv::TonemapDrago>& dst, const ArgInfo& info) |  | 26239 | static bool to(PyObject* src, Ptr<cv::TonemapDrago>& dst, const ArgInfo& info)
| 26288 | { |  | 26240 | {
| 26289 | if(!src || src == Py_None) |  | 26241 | if(!src || src == Py_None)
| 26290 | return true; |  | 26242 | return true;
| 26291 | Ptr<cv::TonemapDrago> * dst_; |  | 26243 | Ptr<cv::TonemapDrago> * dst_;
| 26292 | if (pyopencv_TonemapDrago_getp(src, dst_)) |  | 26244 | if (pyopencv_TonemapDrago_getp(src, dst_))
| 26293 | { |  | 26245 | {
| 26294 | dst = *dst_; |  | 26246 | dst = *dst_;
| 26295 | return true; |  | 26247 | return true;
| 26296 | } |  | 26248 | }
| 26297 |  |  | 26249 |
| 26298 | failmsg("Expected Ptr<cv::TonemapDrago> for argument '%s'", info.name); |  | 26250 | failmsg("Expected Ptr<cv::TonemapDrago> for argument '%s'", info.name);
| 26299 | return false; |  | 26251 | return false;
| 26300 | } |  | 26252 | }
| 26301 | }; |  | 26253 | };
| 26302 |  |  | 26254 |
| 26303 | //================================================================================ |  | 26255 | //================================================================================
| 26304 | // TonemapMantiuk (Generic) |  | 26256 | // TonemapMantiuk (Generic)
| 26305 | //================================================================================ |  | 26257 | //================================================================================
| 26306 |  |  | 26258 |
| 26307 | // GetSet (TonemapMantiuk) |  | 26259 | // GetSet (TonemapMantiuk)
| 26308 |  |  | 26260 |
| 26309 |  |  | 26261 |
| 26310 |  |  | 26262 |
| 26311 | // Methods (TonemapMantiuk) |  | 26263 | // Methods (TonemapMantiuk)
| 26312 |  |  | 26264 |
| 26313 | static PyObject* pyopencv_cv_TonemapMantiuk_getSaturation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26265 | static PyObject* pyopencv_cv_TonemapMantiuk_getSaturation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26314 | { |  | 26266 | {
| 26315 | using namespace cv; |  | 26267 | using namespace cv;
| 26316 |  |  | 26268 |
| 26317 |  |  | 26269 |
| 26318 | Ptr<cv::TonemapMantiuk> * self1 = 0; |  | 26270 | Ptr<cv::TonemapMantiuk> * self1 = 0;
| 26319 | if (!pyopencv_TonemapMantiuk_getp(self, self1)) |  | 26271 | if (!pyopencv_TonemapMantiuk_getp(self, self1))
| 26320 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)"); |  | 26272 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)");
| 26321 | Ptr<cv::TonemapMantiuk> _self_ = *(self1); |  | 26273 | Ptr<cv::TonemapMantiuk> _self_ = *(self1);
| 26322 | float retval; |  | 26274 | float retval;
| 26323 |  |  | 26275 |
| 26324 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 26276 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26325 | { |  | 26277 | {
| 26326 | ERRWRAP2(retval = _self_->getSaturation()); |  | 26278 | ERRWRAP2(retval = _self_->getSaturation());
| 26327 | return pyopencv_from(retval); |  | 26279 | return pyopencv_from(retval);
| 26328 | } |  | 26280 | }
| 26329 |  |  | 26281 |
| 26330 | return NULL; |  | 26282 | return NULL;
| 26331 | } |  | 26283 | }
| 26332 |  |  | 26284 |
| 26333 | static PyObject* pyopencv_cv_TonemapMantiuk_getScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26285 | static PyObject* pyopencv_cv_TonemapMantiuk_getScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 26334 | { |  | 26286 | {
| 26335 | using namespace cv; |  | 26287 | using namespace cv;
| 26336 |  |  | 26288 |
| 26337 |  |  | 26289 |
| 26338 | Ptr<cv::TonemapMantiuk> * self1 = 0; |  | 26290 | Ptr<cv::TonemapMantiuk> * self1 = 0;
| 26339 | if (!pyopencv_TonemapMantiuk_getp(self, self1)) |  | 26291 | if (!pyopencv_TonemapMantiuk_getp(self, self1))
| 26340 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)"); |  | 26292 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)");
| 26341 | Ptr<cv::TonemapMantiuk> _self_ = *(self1); |  | 26293 | Ptr<cv::TonemapMantiuk> _self_ = *(self1);
| 26342 | float retval; |  | 26294 | float retval;
| 26343 |  |  | 26295 |
| 26344 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 26296 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26345 | { |  | 26297 | {
| 26346 | ERRWRAP2(retval = _self_->getScale()); |  | 26298 | ERRWRAP2(retval = _self_->getScale());
| 26347 | return pyopencv_from(retval); |  | 26299 | return pyopencv_from(retval);
| 26348 | } |  | 26300 | }
| 26349 |  |  | 26301 |
| 26350 | return NULL; |  | 26302 | return NULL;
| 26351 | } |  | 26303 | }
| 26352 |  |  | 26304 |
| 26353 | static PyObject* pyopencv_cv_TonemapMantiuk_setSaturation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26305 | static PyObject* pyopencv_cv_TonemapMantiuk_setSaturation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26354 | { |  | 26306 | {
| 26355 | using namespace cv; |  | 26307 | using namespace cv;
| 26356 |  |  | 26308 |
| 26357 |  |  | 26309 |
| 26358 | Ptr<cv::TonemapMantiuk> * self1 = 0; |  | 26310 | Ptr<cv::TonemapMantiuk> * self1 = 0;
| 26359 | if (!pyopencv_TonemapMantiuk_getp(self, self1)) |  | 26311 | if (!pyopencv_TonemapMantiuk_getp(self, self1))
| 26360 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)"); |  | 26312 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)");
| 26361 | Ptr<cv::TonemapMantiuk> _self_ = *(self1); |  | 26313 | Ptr<cv::TonemapMantiuk> _self_ = *(self1);
| 26362 | PyObject* pyobj_saturation = NULL; |  | 26314 | PyObject* pyobj_saturation = NULL;
| 26363 | float saturation=0.f; |  | 26315 | float saturation=0.f;
| 26364 |  |  | 26316 |
| 26365 | const char* keywords[] = { "saturation", NULL }; |  | 26317 | const char* keywords[] = { "saturation", NULL };
| 26366 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapMantiuk.setSaturation", (char**)keywords, &pyobj_saturation) && |  | 26318 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapMantiuk.setSaturation", (char**)keywords, &pyobj_saturation) &&
| 26367 | pyopencv_to_safe(pyobj_saturation, saturation, ArgInfo("saturation", 0)) ) |  | 26319 | pyopencv_to_safe(pyobj_saturation, saturation, ArgInfo("saturation", 0)) )
| 26368 | { |  | 26320 | {
| 26369 | ERRWRAP2(_self_->setSaturation(saturation)); |  | 26321 | ERRWRAP2(_self_->setSaturation(saturation));
| 26370 | Py_RETURN_NONE; |  | 26322 | Py_RETURN_NONE;
| 26371 | } |  | 26323 | }
| 26372 |  |  | 26324 |
| 26373 | return NULL; |  | 26325 | return NULL;
| 26374 | } |  | 26326 | }
| 26375 |  |  | 26327 |
| 26376 | static PyObject* pyopencv_cv_TonemapMantiuk_setScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26328 | static PyObject* pyopencv_cv_TonemapMantiuk_setScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 26377 | { |  | 26329 | {
| 26378 | using namespace cv; |  | 26330 | using namespace cv;
| 26379 |  |  | 26331 |
| 26380 |  |  | 26332 |
| 26381 | Ptr<cv::TonemapMantiuk> * self1 = 0; |  | 26333 | Ptr<cv::TonemapMantiuk> * self1 = 0;
| 26382 | if (!pyopencv_TonemapMantiuk_getp(self, self1)) |  | 26334 | if (!pyopencv_TonemapMantiuk_getp(self, self1))
| 26383 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)"); |  | 26335 | return failmsgp("Incorrect type of self (must be 'TonemapMantiuk' or its derivative)");
| 26384 | Ptr<cv::TonemapMantiuk> _self_ = *(self1); |  | 26336 | Ptr<cv::TonemapMantiuk> _self_ = *(self1);
| 26385 | PyObject* pyobj_scale = NULL; |  | 26337 | PyObject* pyobj_scale = NULL;
| 26386 | float scale=0.f; |  | 26338 | float scale=0.f;
| 26387 |  |  | 26339 |
| 26388 | const char* keywords[] = { "scale", NULL }; |  | 26340 | const char* keywords[] = { "scale", NULL };
| 26389 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapMantiuk.setScale", (char**)keywords, &pyobj_scale) && |  | 26341 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapMantiuk.setScale", (char**)keywords, &pyobj_scale) &&
| 26390 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) ) |  | 26342 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) )
| 26391 | { |  | 26343 | {
| 26392 | ERRWRAP2(_self_->setScale(scale)); |  | 26344 | ERRWRAP2(_self_->setScale(scale));
| 26393 | Py_RETURN_NONE; |  | 26345 | Py_RETURN_NONE;
| 26394 | } |  | 26346 | }
| 26395 |  |  | 26347 |
| 26396 | return NULL; |  | 26348 | return NULL;
| 26397 | } |  | 26349 | }
| 26398 |  |  | 26350 |
| 26399 |  |  | 26351 |
| 26400 |  |  | 26352 |
| 26401 | // Tables (TonemapMantiuk) |  | 26353 | // Tables (TonemapMantiuk)
| 26402 |  |  | 26354 |
| 26403 | static PyGetSetDef pyopencv_TonemapMantiuk_getseters[] = |  | 26355 | static PyGetSetDef pyopencv_TonemapMantiuk_getseters[] =
| 26404 | { |  | 26356 | {
| 26405 | {NULL} /* Sentinel */ |  | 26357 | {NULL} /* Sentinel */
| 26406 | }; |  | 26358 | };
| 26407 |  |  | 26359 |
| 26408 | static PyMethodDef pyopencv_TonemapMantiuk_methods[] = |  | 26360 | static PyMethodDef pyopencv_TonemapMantiuk_methods[] =
| 26409 | { |  | 26361 | {
| 26410 | {"getSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_getSaturation, 0), "getSaturation() -> retval\n."}, |  | 26362 | {"getSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_getSaturation, 0), "getSaturation() -> retval\n."},
| 26411 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_getScale, 0), "getScale() -> retval\n."}, |  | 26363 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_getScale, 0), "getScale() -> retval\n."},
| 26412 | {"setSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_setSaturation, 0), "setSaturation(saturation) -> None\n."}, |  | 26364 | {"setSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_setSaturation, 0), "setSaturation(saturation) -> None\n."},
| 26413 | {"setScale", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_setScale, 0), "setScale(scale) -> None\n."}, |  | 26365 | {"setScale", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapMantiuk_setScale, 0), "setScale(scale) -> None\n."},
| 26414 |  |  | 26366 |
| 26415 | {NULL, NULL} |  | 26367 | {NULL, NULL}
| 26416 | }; |  | 26368 | };
| 26417 |  |  | 26369 |
| 26418 | // Converter (TonemapMantiuk) |  | 26370 | // Converter (TonemapMantiuk)
| 26419 |  |  | 26371 |
| 26420 | template<> |  | 26372 | template<>
| 26421 | struct PyOpenCV_Converter< Ptr<cv::TonemapMantiuk> > |  | 26373 | struct PyOpenCV_Converter< Ptr<cv::TonemapMantiuk> >
| 26422 | { |  | 26374 | {
| 26423 | static PyObject* from(const Ptr<cv::TonemapMantiuk>& r) |  | 26375 | static PyObject* from(const Ptr<cv::TonemapMantiuk>& r)
| 26424 | { |  | 26376 | {
| 26425 | return pyopencv_TonemapMantiuk_Instance(r); |  | 26377 | return pyopencv_TonemapMantiuk_Instance(r);
| 26426 | } |  | 26378 | }
| 26427 | static bool to(PyObject* src, Ptr<cv::TonemapMantiuk>& dst, const ArgInfo& info) |  | 26379 | static bool to(PyObject* src, Ptr<cv::TonemapMantiuk>& dst, const ArgInfo& info)
| 26428 | { |  | 26380 | {
| 26429 | if(!src || src == Py_None) |  | 26381 | if(!src || src == Py_None)
| 26430 | return true; |  | 26382 | return true;
| 26431 | Ptr<cv::TonemapMantiuk> * dst_; |  | 26383 | Ptr<cv::TonemapMantiuk> * dst_;
| 26432 | if (pyopencv_TonemapMantiuk_getp(src, dst_)) |  | 26384 | if (pyopencv_TonemapMantiuk_getp(src, dst_))
| 26433 | { |  | 26385 | {
| 26434 | dst = *dst_; |  | 26386 | dst = *dst_;
| 26435 | return true; |  | 26387 | return true;
| 26436 | } |  | 26388 | }
| 26437 |  |  | 26389 |
| 26438 | failmsg("Expected Ptr<cv::TonemapMantiuk> for argument '%s'", info.name); |  | 26390 | failmsg("Expected Ptr<cv::TonemapMantiuk> for argument '%s'", info.name);
| 26439 | return false; |  | 26391 | return false;
| 26440 | } |  | 26392 | }
| 26441 | }; |  | 26393 | };
| 26442 |  |  | 26394 |
| 26443 | //================================================================================ |  | 26395 | //================================================================================
| 26444 | // TonemapReinhard (Generic) |  | 26396 | // TonemapReinhard (Generic)
| 26445 | //================================================================================ |  | 26397 | //================================================================================
| 26446 |  |  | 26398 |
| 26447 | // GetSet (TonemapReinhard) |  | 26399 | // GetSet (TonemapReinhard)
| 26448 |  |  | 26400 |
| 26449 |  |  | 26401 |
| 26450 |  |  | 26402 |
| 26451 | // Methods (TonemapReinhard) |  | 26403 | // Methods (TonemapReinhard)
| 26452 |  |  | 26404 |
| 26453 | static PyObject* pyopencv_cv_TonemapReinhard_getColorAdaptation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26405 | static PyObject* pyopencv_cv_TonemapReinhard_getColorAdaptation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26454 | { |  | 26406 | {
| 26455 | using namespace cv; |  | 26407 | using namespace cv;
| 26456 |  |  | 26408 |
| 26457 |  |  | 26409 |
| 26458 | Ptr<cv::TonemapReinhard> * self1 = 0; |  | 26410 | Ptr<cv::TonemapReinhard> * self1 = 0;
| 26459 | if (!pyopencv_TonemapReinhard_getp(self, self1)) |  | 26411 | if (!pyopencv_TonemapReinhard_getp(self, self1))
| 26460 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)"); |  | 26412 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)");
| 26461 | Ptr<cv::TonemapReinhard> _self_ = *(self1); |  | 26413 | Ptr<cv::TonemapReinhard> _self_ = *(self1);
| 26462 | float retval; |  | 26414 | float retval;
| 26463 |  |  | 26415 |
| 26464 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 26416 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26465 | { |  | 26417 | {
| 26466 | ERRWRAP2(retval = _self_->getColorAdaptation()); |  | 26418 | ERRWRAP2(retval = _self_->getColorAdaptation());
| 26467 | return pyopencv_from(retval); |  | 26419 | return pyopencv_from(retval);
| 26468 | } |  | 26420 | }
| 26469 |  |  | 26421 |
| 26470 | return NULL; |  | 26422 | return NULL;
| 26471 | } |  | 26423 | }
| 26472 |  |  | 26424 |
| 26473 | static PyObject* pyopencv_cv_TonemapReinhard_getIntensity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26425 | static PyObject* pyopencv_cv_TonemapReinhard_getIntensity(PyObject* self, PyObject* py_args, PyObject* kw)
| 26474 | { |  | 26426 | {
| 26475 | using namespace cv; |  | 26427 | using namespace cv;
| 26476 |  |  | 26428 |
| 26477 |  |  | 26429 |
| 26478 | Ptr<cv::TonemapReinhard> * self1 = 0; |  | 26430 | Ptr<cv::TonemapReinhard> * self1 = 0;
| 26479 | if (!pyopencv_TonemapReinhard_getp(self, self1)) |  | 26431 | if (!pyopencv_TonemapReinhard_getp(self, self1))
| 26480 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)"); |  | 26432 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)");
| 26481 | Ptr<cv::TonemapReinhard> _self_ = *(self1); |  | 26433 | Ptr<cv::TonemapReinhard> _self_ = *(self1);
| 26482 | float retval; |  | 26434 | float retval;
| 26483 |  |  | 26435 |
| 26484 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 26436 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26485 | { |  | 26437 | {
| 26486 | ERRWRAP2(retval = _self_->getIntensity()); |  | 26438 | ERRWRAP2(retval = _self_->getIntensity());
| 26487 | return pyopencv_from(retval); |  | 26439 | return pyopencv_from(retval);
| 26488 | } |  | 26440 | }
| 26489 |  |  | 26441 |
| 26490 | return NULL; |  | 26442 | return NULL;
| 26491 | } |  | 26443 | }
| 26492 |  |  | 26444 |
| 26493 | static PyObject* pyopencv_cv_TonemapReinhard_getLightAdaptation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26445 | static PyObject* pyopencv_cv_TonemapReinhard_getLightAdaptation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26494 | { |  | 26446 | {
| 26495 | using namespace cv; |  | 26447 | using namespace cv;
| 26496 |  |  | 26448 |
| 26497 |  |  | 26449 |
| 26498 | Ptr<cv::TonemapReinhard> * self1 = 0; |  | 26450 | Ptr<cv::TonemapReinhard> * self1 = 0;
| 26499 | if (!pyopencv_TonemapReinhard_getp(self, self1)) |  | 26451 | if (!pyopencv_TonemapReinhard_getp(self, self1))
| 26500 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)"); |  | 26452 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)");
| 26501 | Ptr<cv::TonemapReinhard> _self_ = *(self1); |  | 26453 | Ptr<cv::TonemapReinhard> _self_ = *(self1);
| 26502 | float retval; |  | 26454 | float retval;
| 26503 |  |  | 26455 |
| 26504 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 26456 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 26505 | { |  | 26457 | {
| 26506 | ERRWRAP2(retval = _self_->getLightAdaptation()); |  | 26458 | ERRWRAP2(retval = _self_->getLightAdaptation());
| 26507 | return pyopencv_from(retval); |  | 26459 | return pyopencv_from(retval);
| 26508 | } |  | 26460 | }
| 26509 |  |  | 26461 |
| 26510 | return NULL; |  | 26462 | return NULL;
| 26511 | } |  | 26463 | }
| 26512 |  |  | 26464 |
| 26513 | static PyObject* pyopencv_cv_TonemapReinhard_setColorAdaptation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26465 | static PyObject* pyopencv_cv_TonemapReinhard_setColorAdaptation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26514 | { |  | 26466 | {
| 26515 | using namespace cv; |  | 26467 | using namespace cv;
| 26516 |  |  | 26468 |
| 26517 |  |  | 26469 |
| 26518 | Ptr<cv::TonemapReinhard> * self1 = 0; |  | 26470 | Ptr<cv::TonemapReinhard> * self1 = 0;
| 26519 | if (!pyopencv_TonemapReinhard_getp(self, self1)) |  | 26471 | if (!pyopencv_TonemapReinhard_getp(self, self1))
| 26520 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)"); |  | 26472 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)");
| 26521 | Ptr<cv::TonemapReinhard> _self_ = *(self1); |  | 26473 | Ptr<cv::TonemapReinhard> _self_ = *(self1);
| 26522 | PyObject* pyobj_color_adapt = NULL; |  | 26474 | PyObject* pyobj_color_adapt = NULL;
| 26523 | float color_adapt=0.f; |  | 26475 | float color_adapt=0.f;
| 26524 |  |  | 26476 |
| 26525 | const char* keywords[] = { "color_adapt", NULL }; |  | 26477 | const char* keywords[] = { "color_adapt", NULL };
| 26526 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapReinhard.setColorAdaptation", (char**)keywords, &pyobj_color_adapt) && |  | 26478 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapReinhard.setColorAdaptation", (char**)keywords, &pyobj_color_adapt) &&
| 26527 | pyopencv_to_safe(pyobj_color_adapt, color_adapt, ArgInfo("color_adapt", 0)) ) |  | 26479 | pyopencv_to_safe(pyobj_color_adapt, color_adapt, ArgInfo("color_adapt", 0)) )
| 26528 | { |  | 26480 | {
| 26529 | ERRWRAP2(_self_->setColorAdaptation(color_adapt)); |  | 26481 | ERRWRAP2(_self_->setColorAdaptation(color_adapt));
| 26530 | Py_RETURN_NONE; |  | 26482 | Py_RETURN_NONE;
| 26531 | } |  | 26483 | }
| 26532 |  |  | 26484 |
| 26533 | return NULL; |  | 26485 | return NULL;
| 26534 | } |  | 26486 | }
| 26535 |  |  | 26487 |
| 26536 | static PyObject* pyopencv_cv_TonemapReinhard_setIntensity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26488 | static PyObject* pyopencv_cv_TonemapReinhard_setIntensity(PyObject* self, PyObject* py_args, PyObject* kw)
| 26537 | { |  | 26489 | {
| 26538 | using namespace cv; |  | 26490 | using namespace cv;
| 26539 |  |  | 26491 |
| 26540 |  |  | 26492 |
| 26541 | Ptr<cv::TonemapReinhard> * self1 = 0; |  | 26493 | Ptr<cv::TonemapReinhard> * self1 = 0;
| 26542 | if (!pyopencv_TonemapReinhard_getp(self, self1)) |  | 26494 | if (!pyopencv_TonemapReinhard_getp(self, self1))
| 26543 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)"); |  | 26495 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)");
| 26544 | Ptr<cv::TonemapReinhard> _self_ = *(self1); |  | 26496 | Ptr<cv::TonemapReinhard> _self_ = *(self1);
| 26545 | PyObject* pyobj_intensity = NULL; |  | 26497 | PyObject* pyobj_intensity = NULL;
| 26546 | float intensity=0.f; |  | 26498 | float intensity=0.f;
| 26547 |  |  | 26499 |
| 26548 | const char* keywords[] = { "intensity", NULL }; |  | 26500 | const char* keywords[] = { "intensity", NULL };
| 26549 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapReinhard.setIntensity", (char**)keywords, &pyobj_intensity) && |  | 26501 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapReinhard.setIntensity", (char**)keywords, &pyobj_intensity) &&
| 26550 | pyopencv_to_safe(pyobj_intensity, intensity, ArgInfo("intensity", 0)) ) |  | 26502 | pyopencv_to_safe(pyobj_intensity, intensity, ArgInfo("intensity", 0)) )
| 26551 | { |  | 26503 | {
| 26552 | ERRWRAP2(_self_->setIntensity(intensity)); |  | 26504 | ERRWRAP2(_self_->setIntensity(intensity));
| 26553 | Py_RETURN_NONE; |  | 26505 | Py_RETURN_NONE;
| 26554 | } |  | 26506 | }
| 26555 |  |  | 26507 |
| 26556 | return NULL; |  | 26508 | return NULL;
| 26557 | } |  | 26509 | }
| 26558 |  |  | 26510 |
| 26559 | static PyObject* pyopencv_cv_TonemapReinhard_setLightAdaptation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26511 | static PyObject* pyopencv_cv_TonemapReinhard_setLightAdaptation(PyObject* self, PyObject* py_args, PyObject* kw)
| 26560 | { |  | 26512 | {
| 26561 | using namespace cv; |  | 26513 | using namespace cv;
| 26562 |  |  | 26514 |
| 26563 |  |  | 26515 |
| 26564 | Ptr<cv::TonemapReinhard> * self1 = 0; |  | 26516 | Ptr<cv::TonemapReinhard> * self1 = 0;
| 26565 | if (!pyopencv_TonemapReinhard_getp(self, self1)) |  | 26517 | if (!pyopencv_TonemapReinhard_getp(self, self1))
| 26566 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)"); |  | 26518 | return failmsgp("Incorrect type of self (must be 'TonemapReinhard' or its derivative)");
| 26567 | Ptr<cv::TonemapReinhard> _self_ = *(self1); |  | 26519 | Ptr<cv::TonemapReinhard> _self_ = *(self1);
| 26568 | PyObject* pyobj_light_adapt = NULL; |  | 26520 | PyObject* pyobj_light_adapt = NULL;
| 26569 | float light_adapt=0.f; |  | 26521 | float light_adapt=0.f;
| 26570 |  |  | 26522 |
| 26571 | const char* keywords[] = { "light_adapt", NULL }; |  | 26523 | const char* keywords[] = { "light_adapt", NULL };
| 26572 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapReinhard.setLightAdaptation", (char**)keywords, &pyobj_light_adapt) && |  | 26524 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TonemapReinhard.setLightAdaptation", (char**)keywords, &pyobj_light_adapt) &&
| 26573 | pyopencv_to_safe(pyobj_light_adapt, light_adapt, ArgInfo("light_adapt", 0)) ) |  | 26525 | pyopencv_to_safe(pyobj_light_adapt, light_adapt, ArgInfo("light_adapt", 0)) )
| 26574 | { |  | 26526 | {
| 26575 | ERRWRAP2(_self_->setLightAdaptation(light_adapt)); |  | 26527 | ERRWRAP2(_self_->setLightAdaptation(light_adapt));
| 26576 | Py_RETURN_NONE; |  | 26528 | Py_RETURN_NONE;
| 26577 | } |  | 26529 | }
| 26578 |  |  | 26530 |
| 26579 | return NULL; |  | 26531 | return NULL;
| 26580 | } |  | 26532 | }
| 26581 |  |  | 26533 |
| 26582 |  |  | 26534 |
| 26583 |  |  | 26535 |
| 26584 | // Tables (TonemapReinhard) |  | 26536 | // Tables (TonemapReinhard)
| 26585 |  |  | 26537 |
| 26586 | static PyGetSetDef pyopencv_TonemapReinhard_getseters[] = |  | 26538 | static PyGetSetDef pyopencv_TonemapReinhard_getseters[] =
| 26587 | { |  | 26539 | {
| 26588 | {NULL} /* Sentinel */ |  | 26540 | {NULL} /* Sentinel */
| 26589 | }; |  | 26541 | };
| 26590 |  |  | 26542 |
| 26591 | static PyMethodDef pyopencv_TonemapReinhard_methods[] = |  | 26543 | static PyMethodDef pyopencv_TonemapReinhard_methods[] =
| 26592 | { |  | 26544 | {
| 26593 | {"getColorAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_getColorAdaptation, 0), "getColorAdaptation() -> retval\n."}, |  | 26545 | {"getColorAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_getColorAdaptation, 0), "getColorAdaptation() -> retval\n."},
| 26594 | {"getIntensity", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_getIntensity, 0), "getIntensity() -> retval\n."}, |  | 26546 | {"getIntensity", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_getIntensity, 0), "getIntensity() -> retval\n."},
| 26595 | {"getLightAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_getLightAdaptation, 0), "getLightAdaptation() -> retval\n."}, |  | 26547 | {"getLightAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_getLightAdaptation, 0), "getLightAdaptation() -> retval\n."},
| 26596 | {"setColorAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_setColorAdaptation, 0), "setColorAdaptation(color_adapt) -> None\n."}, |  | 26548 | {"setColorAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_setColorAdaptation, 0), "setColorAdaptation(color_adapt) -> None\n."},
| 26597 | {"setIntensity", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_setIntensity, 0), "setIntensity(intensity) -> None\n."}, |  | 26549 | {"setIntensity", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_setIntensity, 0), "setIntensity(intensity) -> None\n."},
| 26598 | {"setLightAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_setLightAdaptation, 0), "setLightAdaptation(light_adapt) -> None\n."}, |  | 26550 | {"setLightAdaptation", CV_PY_FN_WITH_KW_(pyopencv_cv_TonemapReinhard_setLightAdaptation, 0), "setLightAdaptation(light_adapt) -> None\n."},
| 26599 |  |  | 26551 |
| 26600 | {NULL, NULL} |  | 26552 | {NULL, NULL}
| 26601 | }; |  | 26553 | };
| 26602 |  |  | 26554 |
| 26603 | // Converter (TonemapReinhard) |  | 26555 | // Converter (TonemapReinhard)
| 26604 |  |  | 26556 |
| 26605 | template<> |  | 26557 | template<>
| 26606 | struct PyOpenCV_Converter< Ptr<cv::TonemapReinhard> > |  | 26558 | struct PyOpenCV_Converter< Ptr<cv::TonemapReinhard> >
| 26607 | { |  | 26559 | {
| 26608 | static PyObject* from(const Ptr<cv::TonemapReinhard>& r) |  | 26560 | static PyObject* from(const Ptr<cv::TonemapReinhard>& r)
| 26609 | { |  | 26561 | {
| 26610 | return pyopencv_TonemapReinhard_Instance(r); |  | 26562 | return pyopencv_TonemapReinhard_Instance(r);
| 26611 | } |  | 26563 | }
| 26612 | static bool to(PyObject* src, Ptr<cv::TonemapReinhard>& dst, const ArgInfo& info) |  | 26564 | static bool to(PyObject* src, Ptr<cv::TonemapReinhard>& dst, const ArgInfo& info)
| 26613 | { |  | 26565 | {
| 26614 | if(!src || src == Py_None) |  | 26566 | if(!src || src == Py_None)
| 26615 | return true; |  | 26567 | return true;
| 26616 | Ptr<cv::TonemapReinhard> * dst_; |  | 26568 | Ptr<cv::TonemapReinhard> * dst_;
| 26617 | if (pyopencv_TonemapReinhard_getp(src, dst_)) |  | 26569 | if (pyopencv_TonemapReinhard_getp(src, dst_))
| 26618 | { |  | 26570 | {
| 26619 | dst = *dst_; |  | 26571 | dst = *dst_;
| 26620 | return true; |  | 26572 | return true;
| 26621 | } |  | 26573 | }
| 26622 |  |  | 26574 |
| 26623 | failmsg("Expected Ptr<cv::TonemapReinhard> for argument '%s'", info.name); |  | 26575 | failmsg("Expected Ptr<cv::TonemapReinhard> for argument '%s'", info.name);
| 26624 | return false; |  | 26576 | return false;
| 26625 | } |  | 26577 | }
| 26626 | }; |  | 26578 | };
| 26627 |  |  | 26579 |
| 26628 | //================================================================================ |  | 26580 | //================================================================================
| 26629 | // Tracker (Generic) |  | 26581 | // Tracker (Generic)
| 26630 | //================================================================================ |  | 26582 | //================================================================================
| 26631 |  |  | 26583 |
| 26632 | // GetSet (Tracker) |  | 26584 | // GetSet (Tracker)
| 26633 |  |  | 26585 |
| 26634 |  |  | 26586 |
| 26635 |  |  | 26587 |
| 26636 | // Methods (Tracker) |  | 26588 | // Methods (Tracker)
| 26637 |  |  | 26589 |
| 26638 | static PyObject* pyopencv_cv_Tracker_init(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26590 | static PyObject* pyopencv_cv_Tracker_init(PyObject* self, PyObject* py_args, PyObject* kw)
| 26639 | { |  | 26591 | {
| 26640 | using namespace cv; |  | 26592 | using namespace cv;
| 26641 |  |  | 26593 |
| 26642 |  |  | 26594 |
| 26643 | Ptr<cv::Tracker> * self1 = 0; |  | 26595 | Ptr<cv::Tracker> * self1 = 0;
| 26644 | if (!pyopencv_Tracker_getp(self, self1)) |  | 26596 | if (!pyopencv_Tracker_getp(self, self1))
| 26645 | return failmsgp("Incorrect type of self (must be 'Tracker' or its derivative)"); |  | 26597 | return failmsgp("Incorrect type of self (must be 'Tracker' or its derivative)");
| 26646 | Ptr<cv::Tracker> _self_ = *(self1); |  | 26598 | Ptr<cv::Tracker> _self_ = *(self1);
| 26647 | pyPrepareArgumentConversionErrorsStorage(2); |  | 26599 | pyPrepareArgumentConversionErrorsStorage(2);
| 26648 |  |  | 26600 |
| 26649 | { |  | 26601 | {
| 26650 | PyObject* pyobj_image = NULL; |  | 26602 | PyObject* pyobj_image = NULL;
| 26651 | Mat image; |  | 26603 | Mat image;
| 26652 | PyObject* pyobj_boundingBox = NULL; |  | 26604 | PyObject* pyobj_boundingBox = NULL;
| 26653 | Rect boundingBox; |  | 26605 | Rect boundingBox;
| 26654 |  |  | 26606 |
| 26655 | const char* keywords[] = { "image", "boundingBox", NULL }; |  | 26607 | const char* keywords[] = { "image", "boundingBox", NULL };
| 26656 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) && |  | 26608 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) &&
| 26657 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 26609 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 26658 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) ) |  | 26610 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) )
| 26659 | { |  | 26611 | {
| 26660 | ERRWRAP2(_self_->init(image, boundingBox)); |  | 26612 | ERRWRAP2(_self_->init(image, boundingBox));
| 26661 | Py_RETURN_NONE; |  | 26613 | Py_RETURN_NONE;
| 26662 | } |  | 26614 | }
| 26663 |  |  | 26615 |
| 26664 |  |  | 26616 |
| 26665 | pyPopulateArgumentConversionErrors(); |  | 26617 | pyPopulateArgumentConversionErrors();
| 26666 | } |  | 26618 | }
| 26667 |  |  | 26619 |
| 26668 |  |  | 26620 |
| 26669 | { |  | 26621 | {
| 26670 | PyObject* pyobj_image = NULL; |  | 26622 | PyObject* pyobj_image = NULL;
| 26671 | UMat image; |  | 26623 | UMat image;
| 26672 | PyObject* pyobj_boundingBox = NULL; |  | 26624 | PyObject* pyobj_boundingBox = NULL;
| 26673 | Rect boundingBox; |  | 26625 | Rect boundingBox;
| 26674 |  |  | 26626 |
| 26675 | const char* keywords[] = { "image", "boundingBox", NULL }; |  | 26627 | const char* keywords[] = { "image", "boundingBox", NULL };
| 26676 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) && |  | 26628 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) &&
| 26677 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 26629 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 26678 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) ) |  | 26630 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) )
| 26679 | { |  | 26631 | {
| 26680 | ERRWRAP2(_self_->init(image, boundingBox)); |  | 26632 | ERRWRAP2(_self_->init(image, boundingBox));
| 26681 | Py_RETURN_NONE; |  | 26633 | Py_RETURN_NONE;
| 26682 | } |  | 26634 | }
| 26683 |  |  | 26635 |
| 26684 |  |  | 26636 |
| 26685 | pyPopulateArgumentConversionErrors(); |  | 26637 | pyPopulateArgumentConversionErrors();
| 26686 | } |  | 26638 | }
| 26687 | pyRaiseCVOverloadException("init"); |  | 26639 | pyRaiseCVOverloadException("init");
| 26688 |  |  | 26640 |
| 26689 | return NULL; |  | 26641 | return NULL;
| 26690 | } |  | 26642 | }
| 26691 |  |  | 26643 |
| 26692 | static PyObject* pyopencv_cv_Tracker_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26644 | static PyObject* pyopencv_cv_Tracker_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 26693 | { |  | 26645 | {
| 26694 | using namespace cv; |  | 26646 | using namespace cv;
| 26695 |  |  | 26647 |
| 26696 |  |  | 26648 |
| 26697 | Ptr<cv::Tracker> * self1 = 0; |  | 26649 | Ptr<cv::Tracker> * self1 = 0;
| 26698 | if (!pyopencv_Tracker_getp(self, self1)) |  | 26650 | if (!pyopencv_Tracker_getp(self, self1))
| 26699 | return failmsgp("Incorrect type of self (must be 'Tracker' or its derivative)"); |  | 26651 | return failmsgp("Incorrect type of self (must be 'Tracker' or its derivative)");
| 26700 | Ptr<cv::Tracker> _self_ = *(self1); |  | 26652 | Ptr<cv::Tracker> _self_ = *(self1);
| 26701 | pyPrepareArgumentConversionErrorsStorage(2); |  | 26653 | pyPrepareArgumentConversionErrorsStorage(2);
| 26702 |  |  | 26654 |
| 26703 | { |  | 26655 | {
| 26704 | PyObject* pyobj_image = NULL; |  | 26656 | PyObject* pyobj_image = NULL;
| 26705 | Mat image; |  | 26657 | Mat image;
| 26706 | Rect boundingBox; |  | 26658 | Rect boundingBox;
| 26707 | bool retval; |  | 26659 | bool retval;
| 26708 |  |  | 26660 |
| 26709 | const char* keywords[] = { "image", NULL }; |  | 26661 | const char* keywords[] = { "image", NULL };
| 26710 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Tracker.update", (char**)keywords, &pyobj_image) && |  | 26662 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Tracker.update", (char**)keywords, &pyobj_image) &&
| 26711 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 26663 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 26712 | { |  | 26664 | {
| 26713 | ERRWRAP2(retval = _self_->update(image, boundingBox)); |  | 26665 | ERRWRAP2(retval = _self_->update(image, boundingBox));
| 26714 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox)); |  | 26666 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox));
| 26715 | } |  | 26667 | }
| 26716 |  |  | 26668 |
| 26717 |  |  | 26669 |
| 26718 | pyPopulateArgumentConversionErrors(); |  | 26670 | pyPopulateArgumentConversionErrors();
| 26719 | } |  | 26671 | }
| 26720 |  |  | 26672 |
| 26721 |  |  | 26673 |
| 26722 | { |  | 26674 | {
| 26723 | PyObject* pyobj_image = NULL; |  | 26675 | PyObject* pyobj_image = NULL;
| 26724 | UMat image; |  | 26676 | UMat image;
| 26725 | Rect boundingBox; |  | 26677 | Rect boundingBox;
| 26726 | bool retval; |  | 26678 | bool retval;
| 26727 |  |  | 26679 |
| 26728 | const char* keywords[] = { "image", NULL }; |  | 26680 | const char* keywords[] = { "image", NULL };
| 26729 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Tracker.update", (char**)keywords, &pyobj_image) && |  | 26681 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Tracker.update", (char**)keywords, &pyobj_image) &&
| 26730 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 26682 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 26731 | { |  | 26683 | {
| 26732 | ERRWRAP2(retval = _self_->update(image, boundingBox)); |  | 26684 | ERRWRAP2(retval = _self_->update(image, boundingBox));
| 26733 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox)); |  | 26685 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox));
| 26734 | } |  | 26686 | }
| 26735 |  |  | 26687 |
| 26736 |  |  | 26688 |
| 26737 | pyPopulateArgumentConversionErrors(); |  | 26689 | pyPopulateArgumentConversionErrors();
| 26738 | } |  | 26690 | }
| 26739 | pyRaiseCVOverloadException("update"); |  | 26691 | pyRaiseCVOverloadException("update");
| 26740 |  |  | 26692 |
| 26741 | return NULL; |  | 26693 | return NULL;
| 26742 | } |  | 26694 | }
| 26743 |  |  | 26695 |
| 26744 |  |  | 26696 |
| 26745 |  |  | 26697 |
| 26746 | // Tables (Tracker) |  | 26698 | // Tables (Tracker)
| 26747 |  |  | 26699 |
| 26748 | static PyGetSetDef pyopencv_Tracker_getseters[] = |  | 26700 | static PyGetSetDef pyopencv_Tracker_getseters[] =
| 26749 | { |  | 26701 | {
| 26750 | {NULL} /* Sentinel */ |  | 26702 | {NULL} /* Sentinel */
| 26751 | }; |  | 26703 | };
| 26752 |  |  | 26704 |
| 26753 | static PyMethodDef pyopencv_Tracker_methods[] = |  | 26705 | static PyMethodDef pyopencv_Tracker_methods[] =
| 26754 | { |  | 26706 | {
| 26755 | {"init", CV_PY_FN_WITH_KW_(pyopencv_cv_Tracker_init, 0), "init(image, boundingBox) -> None\n. @brief Initialize the tracker with a known bounding box that surrounded the target\n. @param image The initial frame\n. @param boundingBox The initial bounding box"}, |  | 26707 | {"init", CV_PY_FN_WITH_KW_(pyopencv_cv_Tracker_init, 0), "init(image, boundingBox) -> None\n. @brief Initialize the tracker with a known bounding box that surrounded the target\n. @param image The initial frame\n. @param boundingBox The initial bounding box"},
| 26756 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_Tracker_update, 0), "update(image) -> retval, boundingBox\n. @brief Update the tracker, find the new most likely bounding box for the target\n. @param image The current frame\n. @param boundingBox The bounding box that represent the new target location, if true was returned, not\n. modified otherwise\n. \n. @return True means that target was located and false means that tracker cannot locate target in\n. current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed\n. missing from the frame (say, out of sight)"}, |  | 26708 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_Tracker_update, 0), "update(image) -> retval, boundingBox\n. @brief Update the tracker, find the new most likely bounding box for the target\n. @param image The current frame\n. @param boundingBox The bounding box that represent the new target location, if true was returned, not\n. modified otherwise\n. \n. @return True means that target was located and false means that tracker cannot locate target in\n. current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed\n. missing from the frame (say, out of sight)"},
| 26757 |  |  | 26709 |
| 26758 | {NULL, NULL} |  | 26710 | {NULL, NULL}
| 26759 | }; |  | 26711 | };
| 26760 |  |  | 26712 |
| 26761 | // Converter (Tracker) |  | 26713 | // Converter (Tracker)
| 26762 |  |  | 26714 |
| 26763 | template<> |  | 26715 | template<>
| 26764 | struct PyOpenCV_Converter< Ptr<cv::Tracker> > |  | 26716 | struct PyOpenCV_Converter< Ptr<cv::Tracker> >
| 26765 | { |  | 26717 | {
| 26766 | static PyObject* from(const Ptr<cv::Tracker>& r) |  | 26718 | static PyObject* from(const Ptr<cv::Tracker>& r)
| 26767 | { |  | 26719 | {
| 26768 | return pyopencv_Tracker_Instance(r); |  | 26720 | return pyopencv_Tracker_Instance(r);
| 26769 | } |  | 26721 | }
| 26770 | static bool to(PyObject* src, Ptr<cv::Tracker>& dst, const ArgInfo& info) |  | 26722 | static bool to(PyObject* src, Ptr<cv::Tracker>& dst, const ArgInfo& info)
| 26771 | { |  | 26723 | {
| 26772 | if(!src || src == Py_None) |  | 26724 | if(!src || src == Py_None)
| 26773 | return true; |  | 26725 | return true;
| 26774 | Ptr<cv::Tracker> * dst_; |  | 26726 | Ptr<cv::Tracker> * dst_;
| 26775 | if (pyopencv_Tracker_getp(src, dst_)) |  | 26727 | if (pyopencv_Tracker_getp(src, dst_))
| 26776 | { |  | 26728 | {
| 26777 | dst = *dst_; |  | 26729 | dst = *dst_;
| 26778 | return true; |  | 26730 | return true;
| 26779 | } |  | 26731 | }
| 26780 |  |  | 26732 |
| 26781 | failmsg("Expected Ptr<cv::Tracker> for argument '%s'", info.name); |  | 26733 | failmsg("Expected Ptr<cv::Tracker> for argument '%s'", info.name);
| 26782 | return false; |  | 26734 | return false;
| 26783 | } |  | 26735 | }
| 26784 | }; |  | 26736 | };
| 26785 |  |  | 26737 |
| 26786 | //================================================================================ |  | 26738 | //================================================================================
| 26787 | // TrackerCSRT (Generic) |  | 26739 | // TrackerCSRT (Generic)
| 26788 | //================================================================================ |  | 26740 | //================================================================================
| 26789 |  |  | 26741 |
| 26790 | // GetSet (TrackerCSRT) |  | 26742 | // GetSet (TrackerCSRT)
| 26791 |  |  | 26743 |
| 26792 |  |  | 26744 |
| 26793 |  |  | 26745 |
| 26794 | // Methods (TrackerCSRT) |  | 26746 | // Methods (TrackerCSRT)
| 26795 |  |  | 26747 |
| 26796 | static PyObject* pyopencv_cv_TrackerCSRT_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26748 | static PyObject* pyopencv_cv_TrackerCSRT_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 26797 | { |  | 26749 | {
| 26798 | using namespace cv; |  | 26750 | using namespace cv;
| 26799 |  |  | 26751 |
| 26800 | PyObject* pyobj_parameters = NULL; |  | 26752 | PyObject* pyobj_parameters = NULL;
| 26801 | cv::TrackerCSRT::Params parameters=TrackerCSRT::Params(); |  | 26753 | cv::TrackerCSRT::Params parameters=TrackerCSRT::Params();
| 26802 | Ptr<TrackerCSRT> retval; |  | 26754 | Ptr<TrackerCSRT> retval;
| 26803 |  |  | 26755 |
| 26804 | const char* keywords[] = { "parameters", NULL }; |  | 26756 | const char* keywords[] = { "parameters", NULL };
| 26805 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerCSRT.create", (char**)keywords, &pyobj_parameters) && |  | 26757 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerCSRT.create", (char**)keywords, &pyobj_parameters) &&
| 26806 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 26758 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 26807 | { |  | 26759 | {
| 26808 | ERRWRAP2(retval = cv::TrackerCSRT::create(parameters)); |  | 26760 | ERRWRAP2(retval = cv::TrackerCSRT::create(parameters));
| 26809 | return pyopencv_from(retval); |  | 26761 | return pyopencv_from(retval);
| 26810 | } |  | 26762 | }
| 26811 |  |  | 26763 |
| 26812 | return NULL; |  | 26764 | return NULL;
| 26813 | } |  | 26765 | }
| 26814 |  |  | 26766 |
| 26815 | static PyObject* pyopencv_cv_TrackerCSRT_setInitialMask(PyObject* self, PyObject* py_args, PyObject* kw) |  | 26767 | static PyObject* pyopencv_cv_TrackerCSRT_setInitialMask(PyObject* self, PyObject* py_args, PyObject* kw)
| 26816 | { |  | 26768 | {
| 26817 | using namespace cv; |  | 26769 | using namespace cv;
| 26818 |  |  | 26770 |
| 26819 |  |  | 26771 |
| 26820 | Ptr<cv::TrackerCSRT> * self1 = 0; |  | 26772 | Ptr<cv::TrackerCSRT> * self1 = 0;
| 26821 | if (!pyopencv_TrackerCSRT_getp(self, self1)) |  | 26773 | if (!pyopencv_TrackerCSRT_getp(self, self1))
| 26822 | return failmsgp("Incorrect type of self (must be 'TrackerCSRT' or its derivative)"); |  | 26774 | return failmsgp("Incorrect type of self (must be 'TrackerCSRT' or its derivative)");
| 26823 | Ptr<cv::TrackerCSRT> _self_ = *(self1); |  | 26775 | Ptr<cv::TrackerCSRT> _self_ = *(self1);
| 26824 | pyPrepareArgumentConversionErrorsStorage(2); |  | 26776 | pyPrepareArgumentConversionErrorsStorage(2);
| 26825 |  |  | 26777 |
| 26826 | { |  | 26778 | {
| 26827 | PyObject* pyobj_mask = NULL; |  | 26779 | PyObject* pyobj_mask = NULL;
| 26828 | Mat mask; |  | 26780 | Mat mask;
| 26829 |  |  | 26781 |
| 26830 | const char* keywords[] = { "mask", NULL }; |  | 26782 | const char* keywords[] = { "mask", NULL };
| 26831 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) && |  | 26783 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) &&
| 26832 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 26784 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 26833 | { |  | 26785 | {
| 26834 | ERRWRAP2(_self_->setInitialMask(mask)); |  | 26786 | ERRWRAP2(_self_->setInitialMask(mask));
| 26835 | Py_RETURN_NONE; |  | 26787 | Py_RETURN_NONE;
| 26836 | } |  | 26788 | }
| 26837 |  |  | 26789 |
| 26838 |  |  | 26790 |
| 26839 | pyPopulateArgumentConversionErrors(); |  | 26791 | pyPopulateArgumentConversionErrors();
| 26840 | } |  | 26792 | }
| 26841 |  |  | 26793 |
| 26842 |  |  | 26794 |
| 26843 | { |  | 26795 | {
| 26844 | PyObject* pyobj_mask = NULL; |  | 26796 | PyObject* pyobj_mask = NULL;
| 26845 | UMat mask; |  | 26797 | UMat mask;
| 26846 |  |  | 26798 |
| 26847 | const char* keywords[] = { "mask", NULL }; |  | 26799 | const char* keywords[] = { "mask", NULL };
| 26848 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) && |  | 26800 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) &&
| 26849 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 26801 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 26850 | { |  | 26802 | {
| 26851 | ERRWRAP2(_self_->setInitialMask(mask)); |  | 26803 | ERRWRAP2(_self_->setInitialMask(mask));
| 26852 | Py_RETURN_NONE; |  | 26804 | Py_RETURN_NONE;
| 26853 | } |  | 26805 | }
| 26854 |  |  | 26806 |
| 26855 |  |  | 26807 |
| 26856 | pyPopulateArgumentConversionErrors(); |  | 26808 | pyPopulateArgumentConversionErrors();
| 26857 | } |  | 26809 | }
| 26858 | pyRaiseCVOverloadException("setInitialMask"); |  | 26810 | pyRaiseCVOverloadException("setInitialMask");
| 26859 |  |  | 26811 |
| 26860 | return NULL; |  | 26812 | return NULL;
| 26861 | } |  | 26813 | }
| 26862 |  |  | 26814 |
| 26863 |  |  | 26815 |
| 26864 |  |  | 26816 |
| 26865 | // Tables (TrackerCSRT) |  | 26817 | // Tables (TrackerCSRT)
| 26866 |  |  | 26818 |
| 26867 | static PyGetSetDef pyopencv_TrackerCSRT_getseters[] = |  | 26819 | static PyGetSetDef pyopencv_TrackerCSRT_getseters[] =
| 26868 | { |  | 26820 | {
| 26869 | {NULL} /* Sentinel */ |  | 26821 | {NULL} /* Sentinel */
| 26870 | }; |  | 26822 | };
| 26871 |  |  | 26823 |
| 26872 | static PyMethodDef pyopencv_TrackerCSRT_methods[] = |  | 26824 | static PyMethodDef pyopencv_TrackerCSRT_methods[] =
| 26873 | { |  | 26825 | {
| 26874 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerCSRT_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Create CSRT tracker instance\n. @param parameters CSRT parameters TrackerCSRT::Params"}, |  | 26826 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerCSRT_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Create CSRT tracker instance\n. @param parameters CSRT parameters TrackerCSRT::Params"},
| 26875 | {"setInitialMask", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerCSRT_setInitialMask, 0), "setInitialMask(mask) -> None\n."}, |  | 26827 | {"setInitialMask", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerCSRT_setInitialMask, 0), "setInitialMask(mask) -> None\n."},
| 26876 |  |  | 26828 |
| 26877 | {NULL, NULL} |  | 26829 | {NULL, NULL}
| 26878 | }; |  | 26830 | };
| 26879 |  |  | 26831 |
| 26880 | // Converter (TrackerCSRT) |  | 26832 | // Converter (TrackerCSRT)
| 26881 |  |  | 26833 |
| 26882 | template<> |  | 26834 | template<>
| 26883 | struct PyOpenCV_Converter< Ptr<cv::TrackerCSRT> > |  | 26835 | struct PyOpenCV_Converter< Ptr<cv::TrackerCSRT> >
| 26884 | { |  | 26836 | {
| 26885 | static PyObject* from(const Ptr<cv::TrackerCSRT>& r) |  | 26837 | static PyObject* from(const Ptr<cv::TrackerCSRT>& r)
| 26886 | { |  | 26838 | {
| 26887 | return pyopencv_TrackerCSRT_Instance(r); |  | 26839 | return pyopencv_TrackerCSRT_Instance(r);
| 26888 | } |  | 26840 | }
| 26889 | static bool to(PyObject* src, Ptr<cv::TrackerCSRT>& dst, const ArgInfo& info) |  | 26841 | static bool to(PyObject* src, Ptr<cv::TrackerCSRT>& dst, const ArgInfo& info)
| 26890 | { |  | 26842 | {
| 26891 | if(!src || src == Py_None) |  | 26843 | if(!src || src == Py_None)
| 26892 | return true; |  | 26844 | return true;
| 26893 | Ptr<cv::TrackerCSRT> * dst_; |  | 26845 | Ptr<cv::TrackerCSRT> * dst_;
| 26894 | if (pyopencv_TrackerCSRT_getp(src, dst_)) |  | 26846 | if (pyopencv_TrackerCSRT_getp(src, dst_))
| 26895 | { |  | 26847 | {
| 26896 | dst = *dst_; |  | 26848 | dst = *dst_;
| 26897 | return true; |  | 26849 | return true;
| 26898 | } |  | 26850 | }
| 26899 |  |  | 26851 |
| 26900 | failmsg("Expected Ptr<cv::TrackerCSRT> for argument '%s'", info.name); |  | 26852 | failmsg("Expected Ptr<cv::TrackerCSRT> for argument '%s'", info.name);
| 26901 | return false; |  | 26853 | return false;
| 26902 | } |  | 26854 | }
| 26903 | }; |  | 26855 | };
| 26904 |  |  | 26856 |
| 26905 | //================================================================================ |  | 26857 | //================================================================================
| 26906 | // TrackerCSRT_Params (Generic) |  | 26858 | // TrackerCSRT_Params (Generic)
| 26907 | //================================================================================ |  | 26859 | //================================================================================
| 26908 |  |  | 26860 |
| 26909 | // GetSet (TrackerCSRT_Params) |  | 26861 | // GetSet (TrackerCSRT_Params)
| 26910 |  |  | 26862 |
| 26911 |  |  | 26863 |
| 26912 | static PyObject* pyopencv_TrackerCSRT_Params_get_admm_iterations(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26864 | static PyObject* pyopencv_TrackerCSRT_Params_get_admm_iterations(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 26913 | { |  | 26865 | {
| 26914 | return pyopencv_from(p->v.admm_iterations); |  | 26866 | return pyopencv_from(p->v.admm_iterations);
| 26915 | } |  | 26867 | }
| 26916 |  |  | 26868 |
| 26917 | static int pyopencv_TrackerCSRT_Params_set_admm_iterations(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26869 | static int pyopencv_TrackerCSRT_Params_set_admm_iterations(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 26918 | { |  | 26870 | {
| 26919 | if (!value) |  | 26871 | if (!value)
| 26920 | { |  | 26872 | {
| 26921 | PyErr_SetString(PyExc_TypeError, "Cannot delete the admm_iterations attribute"); |  | 26873 | PyErr_SetString(PyExc_TypeError, "Cannot delete the admm_iterations attribute");
| 26922 | return -1; |  | 26874 | return -1;
| 26923 | } |  | 26875 | }
| 26924 | return pyopencv_to_safe(value, p->v.admm_iterations, ArgInfo("value", 0)) ? 0 : -1; |  | 26876 | return pyopencv_to_safe(value, p->v.admm_iterations, ArgInfo("value", 0)) ? 0 : -1;
| 26925 | } |  | 26877 | }
| 26926 |  |  | 26878 |
| 26927 | static PyObject* pyopencv_TrackerCSRT_Params_get_background_ratio(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26879 | static PyObject* pyopencv_TrackerCSRT_Params_get_background_ratio(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 26928 | { |  | 26880 | {
| 26929 | return pyopencv_from(p->v.background_ratio); |  | 26881 | return pyopencv_from(p->v.background_ratio);
| 26930 | } |  | 26882 | }
| 26931 |  |  | 26883 |
| 26932 | static int pyopencv_TrackerCSRT_Params_set_background_ratio(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26884 | static int pyopencv_TrackerCSRT_Params_set_background_ratio(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 26933 | { |  | 26885 | {
| 26934 | if (!value) |  | 26886 | if (!value)
| 26935 | { |  | 26887 | {
| 26936 | PyErr_SetString(PyExc_TypeError, "Cannot delete the background_ratio attribute"); |  | 26888 | PyErr_SetString(PyExc_TypeError, "Cannot delete the background_ratio attribute");
| 26937 | return -1; |  | 26889 | return -1;
| 26938 | } |  | 26890 | }
| 26939 | return pyopencv_to_safe(value, p->v.background_ratio, ArgInfo("value", 0)) ? 0 : -1; |  | 26891 | return pyopencv_to_safe(value, p->v.background_ratio, ArgInfo("value", 0)) ? 0 : -1;
| 26940 | } |  | 26892 | }
| 26941 |  |  | 26893 |
| 26942 | static PyObject* pyopencv_TrackerCSRT_Params_get_cheb_attenuation(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26894 | static PyObject* pyopencv_TrackerCSRT_Params_get_cheb_attenuation(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 26943 | { |  | 26895 | {
| 26944 | return pyopencv_from(p->v.cheb_attenuation); |  | 26896 | return pyopencv_from(p->v.cheb_attenuation);
| 26945 | } |  | 26897 | }
| 26946 |  |  | 26898 |
| 26947 | static int pyopencv_TrackerCSRT_Params_set_cheb_attenuation(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26899 | static int pyopencv_TrackerCSRT_Params_set_cheb_attenuation(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 26948 | { |  | 26900 | {
| 26949 | if (!value) |  | 26901 | if (!value)
| 26950 | { |  | 26902 | {
| 26951 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cheb_attenuation attribute"); |  | 26903 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cheb_attenuation attribute");
| 26952 | return -1; |  | 26904 | return -1;
| 26953 | } |  | 26905 | }
| 26954 | return pyopencv_to_safe(value, p->v.cheb_attenuation, ArgInfo("value", 0)) ? 0 : -1; |  | 26906 | return pyopencv_to_safe(value, p->v.cheb_attenuation, ArgInfo("value", 0)) ? 0 : -1;
| 26955 | } |  | 26907 | }
| 26956 |  |  | 26908 |
| 26957 | static PyObject* pyopencv_TrackerCSRT_Params_get_filter_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26909 | static PyObject* pyopencv_TrackerCSRT_Params_get_filter_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 26958 | { |  | 26910 | {
| 26959 | return pyopencv_from(p->v.filter_lr); |  | 26911 | return pyopencv_from(p->v.filter_lr);
| 26960 | } |  | 26912 | }
| 26961 |  |  | 26913 |
| 26962 | static int pyopencv_TrackerCSRT_Params_set_filter_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26914 | static int pyopencv_TrackerCSRT_Params_set_filter_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 26963 | { |  | 26915 | {
| 26964 | if (!value) |  | 26916 | if (!value)
| 26965 | { |  | 26917 | {
| 26966 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filter_lr attribute"); |  | 26918 | PyErr_SetString(PyExc_TypeError, "Cannot delete the filter_lr attribute");
| 26967 | return -1; |  | 26919 | return -1;
| 26968 | } |  | 26920 | }
| 26969 | return pyopencv_to_safe(value, p->v.filter_lr, ArgInfo("value", 0)) ? 0 : -1; |  | 26921 | return pyopencv_to_safe(value, p->v.filter_lr, ArgInfo("value", 0)) ? 0 : -1;
| 26970 | } |  | 26922 | }
| 26971 |  |  | 26923 |
| 26972 | static PyObject* pyopencv_TrackerCSRT_Params_get_gsl_sigma(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26924 | static PyObject* pyopencv_TrackerCSRT_Params_get_gsl_sigma(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 26973 | { |  | 26925 | {
| 26974 | return pyopencv_from(p->v.gsl_sigma); |  | 26926 | return pyopencv_from(p->v.gsl_sigma);
| 26975 | } |  | 26927 | }
| 26976 |  |  | 26928 |
| 26977 | static int pyopencv_TrackerCSRT_Params_set_gsl_sigma(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26929 | static int pyopencv_TrackerCSRT_Params_set_gsl_sigma(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 26978 | { |  | 26930 | {
| 26979 | if (!value) |  | 26931 | if (!value)
| 26980 | { |  | 26932 | {
| 26981 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gsl_sigma attribute"); |  | 26933 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gsl_sigma attribute");
| 26982 | return -1; |  | 26934 | return -1;
| 26983 | } |  | 26935 | }
| 26984 | return pyopencv_to_safe(value, p->v.gsl_sigma, ArgInfo("value", 0)) ? 0 : -1; |  | 26936 | return pyopencv_to_safe(value, p->v.gsl_sigma, ArgInfo("value", 0)) ? 0 : -1;
| 26985 | } |  | 26937 | }
| 26986 |  |  | 26938 |
| 26987 | static PyObject* pyopencv_TrackerCSRT_Params_get_histogram_bins(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26939 | static PyObject* pyopencv_TrackerCSRT_Params_get_histogram_bins(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 26988 | { |  | 26940 | {
| 26989 | return pyopencv_from(p->v.histogram_bins); |  | 26941 | return pyopencv_from(p->v.histogram_bins);
| 26990 | } |  | 26942 | }
| 26991 |  |  | 26943 |
| 26992 | static int pyopencv_TrackerCSRT_Params_set_histogram_bins(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26944 | static int pyopencv_TrackerCSRT_Params_set_histogram_bins(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 26993 | { |  | 26945 | {
| 26994 | if (!value) |  | 26946 | if (!value)
| 26995 | { |  | 26947 | {
| 26996 | PyErr_SetString(PyExc_TypeError, "Cannot delete the histogram_bins attribute"); |  | 26948 | PyErr_SetString(PyExc_TypeError, "Cannot delete the histogram_bins attribute");
| 26997 | return -1; |  | 26949 | return -1;
| 26998 | } |  | 26950 | }
| 26999 | return pyopencv_to_safe(value, p->v.histogram_bins, ArgInfo("value", 0)) ? 0 : -1; |  | 26951 | return pyopencv_to_safe(value, p->v.histogram_bins, ArgInfo("value", 0)) ? 0 : -1;
| 27000 | } |  | 26952 | }
| 27001 |  |  | 26953 |
| 27002 | static PyObject* pyopencv_TrackerCSRT_Params_get_histogram_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26954 | static PyObject* pyopencv_TrackerCSRT_Params_get_histogram_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27003 | { |  | 26955 | {
| 27004 | return pyopencv_from(p->v.histogram_lr); |  | 26956 | return pyopencv_from(p->v.histogram_lr);
| 27005 | } |  | 26957 | }
| 27006 |  |  | 26958 |
| 27007 | static int pyopencv_TrackerCSRT_Params_set_histogram_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26959 | static int pyopencv_TrackerCSRT_Params_set_histogram_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27008 | { |  | 26960 | {
| 27009 | if (!value) |  | 26961 | if (!value)
| 27010 | { |  | 26962 | {
| 27011 | PyErr_SetString(PyExc_TypeError, "Cannot delete the histogram_lr attribute"); |  | 26963 | PyErr_SetString(PyExc_TypeError, "Cannot delete the histogram_lr attribute");
| 27012 | return -1; |  | 26964 | return -1;
| 27013 | } |  | 26965 | }
| 27014 | return pyopencv_to_safe(value, p->v.histogram_lr, ArgInfo("value", 0)) ? 0 : -1; |  | 26966 | return pyopencv_to_safe(value, p->v.histogram_lr, ArgInfo("value", 0)) ? 0 : -1;
| 27015 | } |  | 26967 | }
| 27016 |  |  | 26968 |
| 27017 | static PyObject* pyopencv_TrackerCSRT_Params_get_hog_clip(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26969 | static PyObject* pyopencv_TrackerCSRT_Params_get_hog_clip(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27018 | { |  | 26970 | {
| 27019 | return pyopencv_from(p->v.hog_clip); |  | 26971 | return pyopencv_from(p->v.hog_clip);
| 27020 | } |  | 26972 | }
| 27021 |  |  | 26973 |
| 27022 | static int pyopencv_TrackerCSRT_Params_set_hog_clip(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26974 | static int pyopencv_TrackerCSRT_Params_set_hog_clip(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27023 | { |  | 26975 | {
| 27024 | if (!value) |  | 26976 | if (!value)
| 27025 | { |  | 26977 | {
| 27026 | PyErr_SetString(PyExc_TypeError, "Cannot delete the hog_clip attribute"); |  | 26978 | PyErr_SetString(PyExc_TypeError, "Cannot delete the hog_clip attribute");
| 27027 | return -1; |  | 26979 | return -1;
| 27028 | } |  | 26980 | }
| 27029 | return pyopencv_to_safe(value, p->v.hog_clip, ArgInfo("value", 0)) ? 0 : -1; |  | 26981 | return pyopencv_to_safe(value, p->v.hog_clip, ArgInfo("value", 0)) ? 0 : -1;
| 27030 | } |  | 26982 | }
| 27031 |  |  | 26983 |
| 27032 | static PyObject* pyopencv_TrackerCSRT_Params_get_hog_orientations(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26984 | static PyObject* pyopencv_TrackerCSRT_Params_get_hog_orientations(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27033 | { |  | 26985 | {
| 27034 | return pyopencv_from(p->v.hog_orientations); |  | 26986 | return pyopencv_from(p->v.hog_orientations);
| 27035 | } |  | 26987 | }
| 27036 |  |  | 26988 |
| 27037 | static int pyopencv_TrackerCSRT_Params_set_hog_orientations(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 26989 | static int pyopencv_TrackerCSRT_Params_set_hog_orientations(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27038 | { |  | 26990 | {
| 27039 | if (!value) |  | 26991 | if (!value)
| 27040 | { |  | 26992 | {
| 27041 | PyErr_SetString(PyExc_TypeError, "Cannot delete the hog_orientations attribute"); |  | 26993 | PyErr_SetString(PyExc_TypeError, "Cannot delete the hog_orientations attribute");
| 27042 | return -1; |  | 26994 | return -1;
| 27043 | } |  | 26995 | }
| 27044 | return pyopencv_to_safe(value, p->v.hog_orientations, ArgInfo("value", 0)) ? 0 : -1; |  | 26996 | return pyopencv_to_safe(value, p->v.hog_orientations, ArgInfo("value", 0)) ? 0 : -1;
| 27045 | } |  | 26997 | }
| 27046 |  |  | 26998 |
| 27047 | static PyObject* pyopencv_TrackerCSRT_Params_get_kaiser_alpha(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 26999 | static PyObject* pyopencv_TrackerCSRT_Params_get_kaiser_alpha(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27048 | { |  | 27000 | {
| 27049 | return pyopencv_from(p->v.kaiser_alpha); |  | 27001 | return pyopencv_from(p->v.kaiser_alpha);
| 27050 | } |  | 27002 | }
| 27051 |  |  | 27003 |
| 27052 | static int pyopencv_TrackerCSRT_Params_set_kaiser_alpha(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27004 | static int pyopencv_TrackerCSRT_Params_set_kaiser_alpha(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27053 | { |  | 27005 | {
| 27054 | if (!value) |  | 27006 | if (!value)
| 27055 | { |  | 27007 | {
| 27056 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kaiser_alpha attribute"); |  | 27008 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kaiser_alpha attribute");
| 27057 | return -1; |  | 27009 | return -1;
| 27058 | } |  | 27010 | }
| 27059 | return pyopencv_to_safe(value, p->v.kaiser_alpha, ArgInfo("value", 0)) ? 0 : -1; |  | 27011 | return pyopencv_to_safe(value, p->v.kaiser_alpha, ArgInfo("value", 0)) ? 0 : -1;
| 27060 | } |  | 27012 | }
| 27061 |  |  | 27013 |
| 27062 | static PyObject* pyopencv_TrackerCSRT_Params_get_num_hog_channels_used(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27014 | static PyObject* pyopencv_TrackerCSRT_Params_get_num_hog_channels_used(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27063 | { |  | 27015 | {
| 27064 | return pyopencv_from(p->v.num_hog_channels_used); |  | 27016 | return pyopencv_from(p->v.num_hog_channels_used);
| 27065 | } |  | 27017 | }
| 27066 |  |  | 27018 |
| 27067 | static int pyopencv_TrackerCSRT_Params_set_num_hog_channels_used(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27019 | static int pyopencv_TrackerCSRT_Params_set_num_hog_channels_used(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27068 | { |  | 27020 | {
| 27069 | if (!value) |  | 27021 | if (!value)
| 27070 | { |  | 27022 | {
| 27071 | PyErr_SetString(PyExc_TypeError, "Cannot delete the num_hog_channels_used attribute"); |  | 27023 | PyErr_SetString(PyExc_TypeError, "Cannot delete the num_hog_channels_used attribute");
| 27072 | return -1; |  | 27024 | return -1;
| 27073 | } |  | 27025 | }
| 27074 | return pyopencv_to_safe(value, p->v.num_hog_channels_used, ArgInfo("value", 0)) ? 0 : -1; |  | 27026 | return pyopencv_to_safe(value, p->v.num_hog_channels_used, ArgInfo("value", 0)) ? 0 : -1;
| 27075 | } |  | 27027 | }
| 27076 |  |  | 27028 |
| 27077 | static PyObject* pyopencv_TrackerCSRT_Params_get_number_of_scales(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27029 | static PyObject* pyopencv_TrackerCSRT_Params_get_number_of_scales(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27078 | { |  | 27030 | {
| 27079 | return pyopencv_from(p->v.number_of_scales); |  | 27031 | return pyopencv_from(p->v.number_of_scales);
| 27080 | } |  | 27032 | }
| 27081 |  |  | 27033 |
| 27082 | static int pyopencv_TrackerCSRT_Params_set_number_of_scales(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27034 | static int pyopencv_TrackerCSRT_Params_set_number_of_scales(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27083 | { |  | 27035 | {
| 27084 | if (!value) |  | 27036 | if (!value)
| 27085 | { |  | 27037 | {
| 27086 | PyErr_SetString(PyExc_TypeError, "Cannot delete the number_of_scales attribute"); |  | 27038 | PyErr_SetString(PyExc_TypeError, "Cannot delete the number_of_scales attribute");
| 27087 | return -1; |  | 27039 | return -1;
| 27088 | } |  | 27040 | }
| 27089 | return pyopencv_to_safe(value, p->v.number_of_scales, ArgInfo("value", 0)) ? 0 : -1; |  | 27041 | return pyopencv_to_safe(value, p->v.number_of_scales, ArgInfo("value", 0)) ? 0 : -1;
| 27090 | } |  | 27042 | }
| 27091 |  |  | 27043 |
| 27092 | static PyObject* pyopencv_TrackerCSRT_Params_get_padding(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27044 | static PyObject* pyopencv_TrackerCSRT_Params_get_padding(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27093 | { |  | 27045 | {
| 27094 | return pyopencv_from(p->v.padding); |  | 27046 | return pyopencv_from(p->v.padding);
| 27095 | } |  | 27047 | }
| 27096 |  |  | 27048 |
| 27097 | static int pyopencv_TrackerCSRT_Params_set_padding(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27049 | static int pyopencv_TrackerCSRT_Params_set_padding(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27098 | { |  | 27050 | {
| 27099 | if (!value) |  | 27051 | if (!value)
| 27100 | { |  | 27052 | {
| 27101 | PyErr_SetString(PyExc_TypeError, "Cannot delete the padding attribute"); |  | 27053 | PyErr_SetString(PyExc_TypeError, "Cannot delete the padding attribute");
| 27102 | return -1; |  | 27054 | return -1;
| 27103 | } |  | 27055 | }
| 27104 | return pyopencv_to_safe(value, p->v.padding, ArgInfo("value", 0)) ? 0 : -1; |  | 27056 | return pyopencv_to_safe(value, p->v.padding, ArgInfo("value", 0)) ? 0 : -1;
| 27105 | } |  | 27057 | }
| 27106 |  |  | 27058 |
| 27107 | static PyObject* pyopencv_TrackerCSRT_Params_get_psr_threshold(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27059 | static PyObject* pyopencv_TrackerCSRT_Params_get_psr_threshold(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27108 | { |  | 27060 | {
| 27109 | return pyopencv_from(p->v.psr_threshold); |  | 27061 | return pyopencv_from(p->v.psr_threshold);
| 27110 | } |  | 27062 | }
| 27111 |  |  | 27063 |
| 27112 | static int pyopencv_TrackerCSRT_Params_set_psr_threshold(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27064 | static int pyopencv_TrackerCSRT_Params_set_psr_threshold(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27113 | { |  | 27065 | {
| 27114 | if (!value) |  | 27066 | if (!value)
| 27115 | { |  | 27067 | {
| 27116 | PyErr_SetString(PyExc_TypeError, "Cannot delete the psr_threshold attribute"); |  | 27068 | PyErr_SetString(PyExc_TypeError, "Cannot delete the psr_threshold attribute");
| 27117 | return -1; |  | 27069 | return -1;
| 27118 | } |  | 27070 | }
| 27119 | return pyopencv_to_safe(value, p->v.psr_threshold, ArgInfo("value", 0)) ? 0 : -1; |  | 27071 | return pyopencv_to_safe(value, p->v.psr_threshold, ArgInfo("value", 0)) ? 0 : -1;
| 27120 | } |  | 27072 | }
| 27121 |  |  | 27073 |
| 27122 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27074 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27123 | { |  | 27075 | {
| 27124 | return pyopencv_from(p->v.scale_lr); |  | 27076 | return pyopencv_from(p->v.scale_lr);
| 27125 | } |  | 27077 | }
| 27126 |  |  | 27078 |
| 27127 | static int pyopencv_TrackerCSRT_Params_set_scale_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27079 | static int pyopencv_TrackerCSRT_Params_set_scale_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27128 | { |  | 27080 | {
| 27129 | if (!value) |  | 27081 | if (!value)
| 27130 | { |  | 27082 | {
| 27131 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_lr attribute"); |  | 27083 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_lr attribute");
| 27132 | return -1; |  | 27084 | return -1;
| 27133 | } |  | 27085 | }
| 27134 | return pyopencv_to_safe(value, p->v.scale_lr, ArgInfo("value", 0)) ? 0 : -1; |  | 27086 | return pyopencv_to_safe(value, p->v.scale_lr, ArgInfo("value", 0)) ? 0 : -1;
| 27135 | } |  | 27087 | }
| 27136 |  |  | 27088 |
| 27137 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_model_max_area(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27089 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_model_max_area(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27138 | { |  | 27090 | {
| 27139 | return pyopencv_from(p->v.scale_model_max_area); |  | 27091 | return pyopencv_from(p->v.scale_model_max_area);
| 27140 | } |  | 27092 | }
| 27141 |  |  | 27093 |
| 27142 | static int pyopencv_TrackerCSRT_Params_set_scale_model_max_area(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27094 | static int pyopencv_TrackerCSRT_Params_set_scale_model_max_area(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27143 | { |  | 27095 | {
| 27144 | if (!value) |  | 27096 | if (!value)
| 27145 | { |  | 27097 | {
| 27146 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_model_max_area attribute"); |  | 27098 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_model_max_area attribute");
| 27147 | return -1; |  | 27099 | return -1;
| 27148 | } |  | 27100 | }
| 27149 | return pyopencv_to_safe(value, p->v.scale_model_max_area, ArgInfo("value", 0)) ? 0 : -1; |  | 27101 | return pyopencv_to_safe(value, p->v.scale_model_max_area, ArgInfo("value", 0)) ? 0 : -1;
| 27150 | } |  | 27102 | }
| 27151 |  |  | 27103 |
| 27152 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_sigma_factor(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27104 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_sigma_factor(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27153 | { |  | 27105 | {
| 27154 | return pyopencv_from(p->v.scale_sigma_factor); |  | 27106 | return pyopencv_from(p->v.scale_sigma_factor);
| 27155 | } |  | 27107 | }
| 27156 |  |  | 27108 |
| 27157 | static int pyopencv_TrackerCSRT_Params_set_scale_sigma_factor(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27109 | static int pyopencv_TrackerCSRT_Params_set_scale_sigma_factor(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27158 | { |  | 27110 | {
| 27159 | if (!value) |  | 27111 | if (!value)
| 27160 | { |  | 27112 | {
| 27161 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_sigma_factor attribute"); |  | 27113 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_sigma_factor attribute");
| 27162 | return -1; |  | 27114 | return -1;
| 27163 | } |  | 27115 | }
| 27164 | return pyopencv_to_safe(value, p->v.scale_sigma_factor, ArgInfo("value", 0)) ? 0 : -1; |  | 27116 | return pyopencv_to_safe(value, p->v.scale_sigma_factor, ArgInfo("value", 0)) ? 0 : -1;
| 27165 | } |  | 27117 | }
| 27166 |  |  | 27118 |
| 27167 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_step(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27119 | static PyObject* pyopencv_TrackerCSRT_Params_get_scale_step(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27168 | { |  | 27120 | {
| 27169 | return pyopencv_from(p->v.scale_step); |  | 27121 | return pyopencv_from(p->v.scale_step);
| 27170 | } |  | 27122 | }
| 27171 |  |  | 27123 |
| 27172 | static int pyopencv_TrackerCSRT_Params_set_scale_step(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27124 | static int pyopencv_TrackerCSRT_Params_set_scale_step(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27173 | { |  | 27125 | {
| 27174 | if (!value) |  | 27126 | if (!value)
| 27175 | { |  | 27127 | {
| 27176 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_step attribute"); |  | 27128 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale_step attribute");
| 27177 | return -1; |  | 27129 | return -1;
| 27178 | } |  | 27130 | }
| 27179 | return pyopencv_to_safe(value, p->v.scale_step, ArgInfo("value", 0)) ? 0 : -1; |  | 27131 | return pyopencv_to_safe(value, p->v.scale_step, ArgInfo("value", 0)) ? 0 : -1;
| 27180 | } |  | 27132 | }
| 27181 |  |  | 27133 |
| 27182 | static PyObject* pyopencv_TrackerCSRT_Params_get_template_size(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27134 | static PyObject* pyopencv_TrackerCSRT_Params_get_template_size(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27183 | { |  | 27135 | {
| 27184 | return pyopencv_from(p->v.template_size); |  | 27136 | return pyopencv_from(p->v.template_size);
| 27185 | } |  | 27137 | }
| 27186 |  |  | 27138 |
| 27187 | static int pyopencv_TrackerCSRT_Params_set_template_size(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27139 | static int pyopencv_TrackerCSRT_Params_set_template_size(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27188 | { |  | 27140 | {
| 27189 | if (!value) |  | 27141 | if (!value)
| 27190 | { |  | 27142 | {
| 27191 | PyErr_SetString(PyExc_TypeError, "Cannot delete the template_size attribute"); |  | 27143 | PyErr_SetString(PyExc_TypeError, "Cannot delete the template_size attribute");
| 27192 | return -1; |  | 27144 | return -1;
| 27193 | } |  | 27145 | }
| 27194 | return pyopencv_to_safe(value, p->v.template_size, ArgInfo("value", 0)) ? 0 : -1; |  | 27146 | return pyopencv_to_safe(value, p->v.template_size, ArgInfo("value", 0)) ? 0 : -1;
| 27195 | } |  | 27147 | }
| 27196 |  |  | 27148 |
| 27197 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_channel_weights(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27149 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_channel_weights(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27198 | { |  | 27150 | {
| 27199 | return pyopencv_from(p->v.use_channel_weights); |  | 27151 | return pyopencv_from(p->v.use_channel_weights);
| 27200 | } |  | 27152 | }
| 27201 |  |  | 27153 |
| 27202 | static int pyopencv_TrackerCSRT_Params_set_use_channel_weights(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27154 | static int pyopencv_TrackerCSRT_Params_set_use_channel_weights(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27203 | { |  | 27155 | {
| 27204 | if (!value) |  | 27156 | if (!value)
| 27205 | { |  | 27157 | {
| 27206 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_channel_weights attribute"); |  | 27158 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_channel_weights attribute");
| 27207 | return -1; |  | 27159 | return -1;
| 27208 | } |  | 27160 | }
| 27209 | return pyopencv_to_safe(value, p->v.use_channel_weights, ArgInfo("value", 0)) ? 0 : -1; |  | 27161 | return pyopencv_to_safe(value, p->v.use_channel_weights, ArgInfo("value", 0)) ? 0 : -1;
| 27210 | } |  | 27162 | }
| 27211 |  |  | 27163 |
| 27212 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_color_names(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27164 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_color_names(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27213 | { |  | 27165 | {
| 27214 | return pyopencv_from(p->v.use_color_names); |  | 27166 | return pyopencv_from(p->v.use_color_names);
| 27215 | } |  | 27167 | }
| 27216 |  |  | 27168 |
| 27217 | static int pyopencv_TrackerCSRT_Params_set_use_color_names(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27169 | static int pyopencv_TrackerCSRT_Params_set_use_color_names(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27218 | { |  | 27170 | {
| 27219 | if (!value) |  | 27171 | if (!value)
| 27220 | { |  | 27172 | {
| 27221 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_color_names attribute"); |  | 27173 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_color_names attribute");
| 27222 | return -1; |  | 27174 | return -1;
| 27223 | } |  | 27175 | }
| 27224 | return pyopencv_to_safe(value, p->v.use_color_names, ArgInfo("value", 0)) ? 0 : -1; |  | 27176 | return pyopencv_to_safe(value, p->v.use_color_names, ArgInfo("value", 0)) ? 0 : -1;
| 27225 | } |  | 27177 | }
| 27226 |  |  | 27178 |
| 27227 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_gray(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27179 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_gray(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27228 | { |  | 27180 | {
| 27229 | return pyopencv_from(p->v.use_gray); |  | 27181 | return pyopencv_from(p->v.use_gray);
| 27230 | } |  | 27182 | }
| 27231 |  |  | 27183 |
| 27232 | static int pyopencv_TrackerCSRT_Params_set_use_gray(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27184 | static int pyopencv_TrackerCSRT_Params_set_use_gray(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27233 | { |  | 27185 | {
| 27234 | if (!value) |  | 27186 | if (!value)
| 27235 | { |  | 27187 | {
| 27236 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_gray attribute"); |  | 27188 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_gray attribute");
| 27237 | return -1; |  | 27189 | return -1;
| 27238 | } |  | 27190 | }
| 27239 | return pyopencv_to_safe(value, p->v.use_gray, ArgInfo("value", 0)) ? 0 : -1; |  | 27191 | return pyopencv_to_safe(value, p->v.use_gray, ArgInfo("value", 0)) ? 0 : -1;
| 27240 | } |  | 27192 | }
| 27241 |  |  | 27193 |
| 27242 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_hog(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27194 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_hog(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27243 | { |  | 27195 | {
| 27244 | return pyopencv_from(p->v.use_hog); |  | 27196 | return pyopencv_from(p->v.use_hog);
| 27245 | } |  | 27197 | }
| 27246 |  |  | 27198 |
| 27247 | static int pyopencv_TrackerCSRT_Params_set_use_hog(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27199 | static int pyopencv_TrackerCSRT_Params_set_use_hog(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27248 | { |  | 27200 | {
| 27249 | if (!value) |  | 27201 | if (!value)
| 27250 | { |  | 27202 | {
| 27251 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_hog attribute"); |  | 27203 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_hog attribute");
| 27252 | return -1; |  | 27204 | return -1;
| 27253 | } |  | 27205 | }
| 27254 | return pyopencv_to_safe(value, p->v.use_hog, ArgInfo("value", 0)) ? 0 : -1; |  | 27206 | return pyopencv_to_safe(value, p->v.use_hog, ArgInfo("value", 0)) ? 0 : -1;
| 27255 | } |  | 27207 | }
| 27256 |  |  | 27208 |
| 27257 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_rgb(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27209 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_rgb(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27258 | { |  | 27210 | {
| 27259 | return pyopencv_from(p->v.use_rgb); |  | 27211 | return pyopencv_from(p->v.use_rgb);
| 27260 | } |  | 27212 | }
| 27261 |  |  | 27213 |
| 27262 | static int pyopencv_TrackerCSRT_Params_set_use_rgb(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27214 | static int pyopencv_TrackerCSRT_Params_set_use_rgb(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27263 | { |  | 27215 | {
| 27264 | if (!value) |  | 27216 | if (!value)
| 27265 | { |  | 27217 | {
| 27266 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_rgb attribute"); |  | 27218 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_rgb attribute");
| 27267 | return -1; |  | 27219 | return -1;
| 27268 | } |  | 27220 | }
| 27269 | return pyopencv_to_safe(value, p->v.use_rgb, ArgInfo("value", 0)) ? 0 : -1; |  | 27221 | return pyopencv_to_safe(value, p->v.use_rgb, ArgInfo("value", 0)) ? 0 : -1;
| 27270 | } |  | 27222 | }
| 27271 |  |  | 27223 |
| 27272 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_segmentation(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27224 | static PyObject* pyopencv_TrackerCSRT_Params_get_use_segmentation(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27273 | { |  | 27225 | {
| 27274 | return pyopencv_from(p->v.use_segmentation); |  | 27226 | return pyopencv_from(p->v.use_segmentation);
| 27275 | } |  | 27227 | }
| 27276 |  |  | 27228 |
| 27277 | static int pyopencv_TrackerCSRT_Params_set_use_segmentation(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27229 | static int pyopencv_TrackerCSRT_Params_set_use_segmentation(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27278 | { |  | 27230 | {
| 27279 | if (!value) |  | 27231 | if (!value)
| 27280 | { |  | 27232 | {
| 27281 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_segmentation attribute"); |  | 27233 | PyErr_SetString(PyExc_TypeError, "Cannot delete the use_segmentation attribute");
| 27282 | return -1; |  | 27234 | return -1;
| 27283 | } |  | 27235 | }
| 27284 | return pyopencv_to_safe(value, p->v.use_segmentation, ArgInfo("value", 0)) ? 0 : -1; |  | 27236 | return pyopencv_to_safe(value, p->v.use_segmentation, ArgInfo("value", 0)) ? 0 : -1;
| 27285 | } |  | 27237 | }
| 27286 |  |  | 27238 |
| 27287 | static PyObject* pyopencv_TrackerCSRT_Params_get_weights_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27239 | static PyObject* pyopencv_TrackerCSRT_Params_get_weights_lr(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27288 | { |  | 27240 | {
| 27289 | return pyopencv_from(p->v.weights_lr); |  | 27241 | return pyopencv_from(p->v.weights_lr);
| 27290 | } |  | 27242 | }
| 27291 |  |  | 27243 |
| 27292 | static int pyopencv_TrackerCSRT_Params_set_weights_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27244 | static int pyopencv_TrackerCSRT_Params_set_weights_lr(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27293 | { |  | 27245 | {
| 27294 | if (!value) |  | 27246 | if (!value)
| 27295 | { |  | 27247 | {
| 27296 | PyErr_SetString(PyExc_TypeError, "Cannot delete the weights_lr attribute"); |  | 27248 | PyErr_SetString(PyExc_TypeError, "Cannot delete the weights_lr attribute");
| 27297 | return -1; |  | 27249 | return -1;
| 27298 | } |  | 27250 | }
| 27299 | return pyopencv_to_safe(value, p->v.weights_lr, ArgInfo("value", 0)) ? 0 : -1; |  | 27251 | return pyopencv_to_safe(value, p->v.weights_lr, ArgInfo("value", 0)) ? 0 : -1;
| 27300 | } |  | 27252 | }
| 27301 |  |  | 27253 |
| 27302 | static PyObject* pyopencv_TrackerCSRT_Params_get_window_function(pyopencv_TrackerCSRT_Params_t* p, void *closure) |  | 27254 | static PyObject* pyopencv_TrackerCSRT_Params_get_window_function(pyopencv_TrackerCSRT_Params_t* p, void *closure)
| 27303 | { |  | 27255 | {
| 27304 | return pyopencv_from(p->v.window_function); |  | 27256 | return pyopencv_from(p->v.window_function);
| 27305 | } |  | 27257 | }
| 27306 |  |  | 27258 |
| 27307 | static int pyopencv_TrackerCSRT_Params_set_window_function(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure) |  | 27259 | static int pyopencv_TrackerCSRT_Params_set_window_function(pyopencv_TrackerCSRT_Params_t* p, PyObject *value, void *closure)
| 27308 | { |  | 27260 | {
| 27309 | if (!value) |  | 27261 | if (!value)
| 27310 | { |  | 27262 | {
| 27311 | PyErr_SetString(PyExc_TypeError, "Cannot delete the window_function attribute"); |  | 27263 | PyErr_SetString(PyExc_TypeError, "Cannot delete the window_function attribute");
| 27312 | return -1; |  | 27264 | return -1;
| 27313 | } |  | 27265 | }
| 27314 | return pyopencv_to_safe(value, p->v.window_function, ArgInfo("value", 0)) ? 0 : -1; |  | 27266 | return pyopencv_to_safe(value, p->v.window_function, ArgInfo("value", 0)) ? 0 : -1;
| 27315 | } |  | 27267 | }
| 27316 |  |  | 27268 |
| 27317 |  |  | 27269 |
| 27318 | // Methods (TrackerCSRT_Params) |  | 27270 | // Methods (TrackerCSRT_Params)
| 27319 |  |  | 27271 |
| 27320 | static int pyopencv_cv_TrackerCSRT_Params_TrackerCSRT_Params(pyopencv_TrackerCSRT_Params_t* self, PyObject* py_args, PyObject* kw) |  | 27272 | static int pyopencv_cv_TrackerCSRT_Params_TrackerCSRT_Params(pyopencv_TrackerCSRT_Params_t* self, PyObject* py_args, PyObject* kw)
| 27321 | { |  | 27273 | {
| 27322 | using namespace cv; |  | 27274 | using namespace cv;
| 27323 |  |  | 27275 |
| 27324 |  |  | 27276 |
| 27325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 27277 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 27326 | { |  | 27278 | {
| 27327 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerCSRT::Params()); |  | 27279 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerCSRT::Params());
| 27328 | return 0; |  | 27280 | return 0;
| 27329 | } |  | 27281 | }
| 27330 |  |  | 27282 |
| 27331 | return -1; |  | 27283 | return -1;
| 27332 | } |  | 27284 | }
| 27333 |  |  | 27285 |
| 27334 |  |  | 27286 |
| 27335 |  |  | 27287 |
| 27336 | // Tables (TrackerCSRT_Params) |  | 27288 | // Tables (TrackerCSRT_Params)
| 27337 |  |  | 27289 |
| 27338 | static PyGetSetDef pyopencv_TrackerCSRT_Params_getseters[] = |  | 27290 | static PyGetSetDef pyopencv_TrackerCSRT_Params_getseters[] =
| 27339 | { |  | 27291 | {
| 27340 | {(char*)"admm_iterations", (getter)pyopencv_TrackerCSRT_Params_get_admm_iterations, (setter)pyopencv_TrackerCSRT_Params_set_admm_iterations, (char*)"admm_iterations", NULL}, |  | 27292 | {(char*)"admm_iterations", (getter)pyopencv_TrackerCSRT_Params_get_admm_iterations, (setter)pyopencv_TrackerCSRT_Params_set_admm_iterations, (char*)"admm_iterations", NULL},
| 27341 | {(char*)"background_ratio", (getter)pyopencv_TrackerCSRT_Params_get_background_ratio, (setter)pyopencv_TrackerCSRT_Params_set_background_ratio, (char*)"background_ratio", NULL}, |  | 27293 | {(char*)"background_ratio", (getter)pyopencv_TrackerCSRT_Params_get_background_ratio, (setter)pyopencv_TrackerCSRT_Params_set_background_ratio, (char*)"background_ratio", NULL},
| 27342 | {(char*)"cheb_attenuation", (getter)pyopencv_TrackerCSRT_Params_get_cheb_attenuation, (setter)pyopencv_TrackerCSRT_Params_set_cheb_attenuation, (char*)"cheb_attenuation", NULL}, |  | 27294 | {(char*)"cheb_attenuation", (getter)pyopencv_TrackerCSRT_Params_get_cheb_attenuation, (setter)pyopencv_TrackerCSRT_Params_set_cheb_attenuation, (char*)"cheb_attenuation", NULL},
| 27343 | {(char*)"filter_lr", (getter)pyopencv_TrackerCSRT_Params_get_filter_lr, (setter)pyopencv_TrackerCSRT_Params_set_filter_lr, (char*)"filter_lr", NULL}, |  | 27295 | {(char*)"filter_lr", (getter)pyopencv_TrackerCSRT_Params_get_filter_lr, (setter)pyopencv_TrackerCSRT_Params_set_filter_lr, (char*)"filter_lr", NULL},
| 27344 | {(char*)"gsl_sigma", (getter)pyopencv_TrackerCSRT_Params_get_gsl_sigma, (setter)pyopencv_TrackerCSRT_Params_set_gsl_sigma, (char*)"gsl_sigma", NULL}, |  | 27296 | {(char*)"gsl_sigma", (getter)pyopencv_TrackerCSRT_Params_get_gsl_sigma, (setter)pyopencv_TrackerCSRT_Params_set_gsl_sigma, (char*)"gsl_sigma", NULL},
| 27345 | {(char*)"histogram_bins", (getter)pyopencv_TrackerCSRT_Params_get_histogram_bins, (setter)pyopencv_TrackerCSRT_Params_set_histogram_bins, (char*)"histogram_bins", NULL}, |  | 27297 | {(char*)"histogram_bins", (getter)pyopencv_TrackerCSRT_Params_get_histogram_bins, (setter)pyopencv_TrackerCSRT_Params_set_histogram_bins, (char*)"histogram_bins", NULL},
| 27346 | {(char*)"histogram_lr", (getter)pyopencv_TrackerCSRT_Params_get_histogram_lr, (setter)pyopencv_TrackerCSRT_Params_set_histogram_lr, (char*)"histogram_lr", NULL}, |  | 27298 | {(char*)"histogram_lr", (getter)pyopencv_TrackerCSRT_Params_get_histogram_lr, (setter)pyopencv_TrackerCSRT_Params_set_histogram_lr, (char*)"histogram_lr", NULL},
| 27347 | {(char*)"hog_clip", (getter)pyopencv_TrackerCSRT_Params_get_hog_clip, (setter)pyopencv_TrackerCSRT_Params_set_hog_clip, (char*)"hog_clip", NULL}, |  | 27299 | {(char*)"hog_clip", (getter)pyopencv_TrackerCSRT_Params_get_hog_clip, (setter)pyopencv_TrackerCSRT_Params_set_hog_clip, (char*)"hog_clip", NULL},
| 27348 | {(char*)"hog_orientations", (getter)pyopencv_TrackerCSRT_Params_get_hog_orientations, (setter)pyopencv_TrackerCSRT_Params_set_hog_orientations, (char*)"hog_orientations", NULL}, |  | 27300 | {(char*)"hog_orientations", (getter)pyopencv_TrackerCSRT_Params_get_hog_orientations, (setter)pyopencv_TrackerCSRT_Params_set_hog_orientations, (char*)"hog_orientations", NULL},
| 27349 | {(char*)"kaiser_alpha", (getter)pyopencv_TrackerCSRT_Params_get_kaiser_alpha, (setter)pyopencv_TrackerCSRT_Params_set_kaiser_alpha, (char*)"kaiser_alpha", NULL}, |  | 27301 | {(char*)"kaiser_alpha", (getter)pyopencv_TrackerCSRT_Params_get_kaiser_alpha, (setter)pyopencv_TrackerCSRT_Params_set_kaiser_alpha, (char*)"kaiser_alpha", NULL},
| 27350 | {(char*)"num_hog_channels_used", (getter)pyopencv_TrackerCSRT_Params_get_num_hog_channels_used, (setter)pyopencv_TrackerCSRT_Params_set_num_hog_channels_used, (char*)"num_hog_channels_used", NULL}, |  | 27302 | {(char*)"num_hog_channels_used", (getter)pyopencv_TrackerCSRT_Params_get_num_hog_channels_used, (setter)pyopencv_TrackerCSRT_Params_set_num_hog_channels_used, (char*)"num_hog_channels_used", NULL},
| 27351 | {(char*)"number_of_scales", (getter)pyopencv_TrackerCSRT_Params_get_number_of_scales, (setter)pyopencv_TrackerCSRT_Params_set_number_of_scales, (char*)"number_of_scales", NULL}, |  | 27303 | {(char*)"number_of_scales", (getter)pyopencv_TrackerCSRT_Params_get_number_of_scales, (setter)pyopencv_TrackerCSRT_Params_set_number_of_scales, (char*)"number_of_scales", NULL},
| 27352 | {(char*)"padding", (getter)pyopencv_TrackerCSRT_Params_get_padding, (setter)pyopencv_TrackerCSRT_Params_set_padding, (char*)"padding", NULL}, |  | 27304 | {(char*)"padding", (getter)pyopencv_TrackerCSRT_Params_get_padding, (setter)pyopencv_TrackerCSRT_Params_set_padding, (char*)"padding", NULL},
| 27353 | {(char*)"psr_threshold", (getter)pyopencv_TrackerCSRT_Params_get_psr_threshold, (setter)pyopencv_TrackerCSRT_Params_set_psr_threshold, (char*)"psr_threshold", NULL}, |  | 27305 | {(char*)"psr_threshold", (getter)pyopencv_TrackerCSRT_Params_get_psr_threshold, (setter)pyopencv_TrackerCSRT_Params_set_psr_threshold, (char*)"psr_threshold", NULL},
| 27354 | {(char*)"scale_lr", (getter)pyopencv_TrackerCSRT_Params_get_scale_lr, (setter)pyopencv_TrackerCSRT_Params_set_scale_lr, (char*)"scale_lr", NULL}, |  | 27306 | {(char*)"scale_lr", (getter)pyopencv_TrackerCSRT_Params_get_scale_lr, (setter)pyopencv_TrackerCSRT_Params_set_scale_lr, (char*)"scale_lr", NULL},
| 27355 | {(char*)"scale_model_max_area", (getter)pyopencv_TrackerCSRT_Params_get_scale_model_max_area, (setter)pyopencv_TrackerCSRT_Params_set_scale_model_max_area, (char*)"scale_model_max_area", NULL}, |  | 27307 | {(char*)"scale_model_max_area", (getter)pyopencv_TrackerCSRT_Params_get_scale_model_max_area, (setter)pyopencv_TrackerCSRT_Params_set_scale_model_max_area, (char*)"scale_model_max_area", NULL},
| 27356 | {(char*)"scale_sigma_factor", (getter)pyopencv_TrackerCSRT_Params_get_scale_sigma_factor, (setter)pyopencv_TrackerCSRT_Params_set_scale_sigma_factor, (char*)"scale_sigma_factor", NULL}, |  | 27308 | {(char*)"scale_sigma_factor", (getter)pyopencv_TrackerCSRT_Params_get_scale_sigma_factor, (setter)pyopencv_TrackerCSRT_Params_set_scale_sigma_factor, (char*)"scale_sigma_factor", NULL},
| 27357 | {(char*)"scale_step", (getter)pyopencv_TrackerCSRT_Params_get_scale_step, (setter)pyopencv_TrackerCSRT_Params_set_scale_step, (char*)"scale_step", NULL}, |  | 27309 | {(char*)"scale_step", (getter)pyopencv_TrackerCSRT_Params_get_scale_step, (setter)pyopencv_TrackerCSRT_Params_set_scale_step, (char*)"scale_step", NULL},
| 27358 | {(char*)"template_size", (getter)pyopencv_TrackerCSRT_Params_get_template_size, (setter)pyopencv_TrackerCSRT_Params_set_template_size, (char*)"template_size", NULL}, |  | 27310 | {(char*)"template_size", (getter)pyopencv_TrackerCSRT_Params_get_template_size, (setter)pyopencv_TrackerCSRT_Params_set_template_size, (char*)"template_size", NULL},
| 27359 | {(char*)"use_channel_weights", (getter)pyopencv_TrackerCSRT_Params_get_use_channel_weights, (setter)pyopencv_TrackerCSRT_Params_set_use_channel_weights, (char*)"use_channel_weights", NULL}, |  | 27311 | {(char*)"use_channel_weights", (getter)pyopencv_TrackerCSRT_Params_get_use_channel_weights, (setter)pyopencv_TrackerCSRT_Params_set_use_channel_weights, (char*)"use_channel_weights", NULL},
| 27360 | {(char*)"use_color_names", (getter)pyopencv_TrackerCSRT_Params_get_use_color_names, (setter)pyopencv_TrackerCSRT_Params_set_use_color_names, (char*)"use_color_names", NULL}, |  | 27312 | {(char*)"use_color_names", (getter)pyopencv_TrackerCSRT_Params_get_use_color_names, (setter)pyopencv_TrackerCSRT_Params_set_use_color_names, (char*)"use_color_names", NULL},
| 27361 | {(char*)"use_gray", (getter)pyopencv_TrackerCSRT_Params_get_use_gray, (setter)pyopencv_TrackerCSRT_Params_set_use_gray, (char*)"use_gray", NULL}, |  | 27313 | {(char*)"use_gray", (getter)pyopencv_TrackerCSRT_Params_get_use_gray, (setter)pyopencv_TrackerCSRT_Params_set_use_gray, (char*)"use_gray", NULL},
| 27362 | {(char*)"use_hog", (getter)pyopencv_TrackerCSRT_Params_get_use_hog, (setter)pyopencv_TrackerCSRT_Params_set_use_hog, (char*)"use_hog", NULL}, |  | 27314 | {(char*)"use_hog", (getter)pyopencv_TrackerCSRT_Params_get_use_hog, (setter)pyopencv_TrackerCSRT_Params_set_use_hog, (char*)"use_hog", NULL},
| 27363 | {(char*)"use_rgb", (getter)pyopencv_TrackerCSRT_Params_get_use_rgb, (setter)pyopencv_TrackerCSRT_Params_set_use_rgb, (char*)"use_rgb", NULL}, |  | 27315 | {(char*)"use_rgb", (getter)pyopencv_TrackerCSRT_Params_get_use_rgb, (setter)pyopencv_TrackerCSRT_Params_set_use_rgb, (char*)"use_rgb", NULL},
| 27364 | {(char*)"use_segmentation", (getter)pyopencv_TrackerCSRT_Params_get_use_segmentation, (setter)pyopencv_TrackerCSRT_Params_set_use_segmentation, (char*)"use_segmentation", NULL}, |  | 27316 | {(char*)"use_segmentation", (getter)pyopencv_TrackerCSRT_Params_get_use_segmentation, (setter)pyopencv_TrackerCSRT_Params_set_use_segmentation, (char*)"use_segmentation", NULL},
| 27365 | {(char*)"weights_lr", (getter)pyopencv_TrackerCSRT_Params_get_weights_lr, (setter)pyopencv_TrackerCSRT_Params_set_weights_lr, (char*)"weights_lr", NULL}, |  | 27317 | {(char*)"weights_lr", (getter)pyopencv_TrackerCSRT_Params_get_weights_lr, (setter)pyopencv_TrackerCSRT_Params_set_weights_lr, (char*)"weights_lr", NULL},
| 27366 | {(char*)"window_function", (getter)pyopencv_TrackerCSRT_Params_get_window_function, (setter)pyopencv_TrackerCSRT_Params_set_window_function, (char*)"window_function", NULL}, |  | 27318 | {(char*)"window_function", (getter)pyopencv_TrackerCSRT_Params_get_window_function, (setter)pyopencv_TrackerCSRT_Params_set_window_function, (char*)"window_function", NULL},
| 27367 | {NULL} /* Sentinel */ |  | 27319 | {NULL} /* Sentinel */
| 27368 | }; |  | 27320 | };
| 27369 |  |  | 27321 |
| 27370 | static PyMethodDef pyopencv_TrackerCSRT_Params_methods[] = |  | 27322 | static PyMethodDef pyopencv_TrackerCSRT_Params_methods[] =
| 27371 | { |  | 27323 | {
| 27372 |  |  | 27324 |
| 27373 | {NULL, NULL} |  | 27325 | {NULL, NULL}
| 27374 | }; |  | 27326 | };
| 27375 |  |  | 27327 |
| 27376 | // Converter (TrackerCSRT_Params) |  | 27328 | // Converter (TrackerCSRT_Params)
| 27377 |  |  | 27329 |
| 27378 | template<> |  | 27330 | template<>
| 27379 | struct PyOpenCV_Converter< cv::TrackerCSRT::Params > |  | 27331 | struct PyOpenCV_Converter< cv::TrackerCSRT::Params >
| 27380 | { |  | 27332 | {
| 27381 | static PyObject* from(const cv::TrackerCSRT::Params& r) |  | 27333 | static PyObject* from(const cv::TrackerCSRT::Params& r)
| 27382 | { |  | 27334 | {
| 27383 | return pyopencv_TrackerCSRT_Params_Instance(r); |  | 27335 | return pyopencv_TrackerCSRT_Params_Instance(r);
| 27384 | } |  | 27336 | }
| 27385 | static bool to(PyObject* src, cv::TrackerCSRT::Params& dst, const ArgInfo& info) |  | 27337 | static bool to(PyObject* src, cv::TrackerCSRT::Params& dst, const ArgInfo& info)
| 27386 | { |  | 27338 | {
| 27387 | if(!src || src == Py_None) |  | 27339 | if(!src || src == Py_None)
| 27388 | return true; |  | 27340 | return true;
| 27389 | cv::TrackerCSRT::Params * dst_; |  | 27341 | cv::TrackerCSRT::Params * dst_;
| 27390 | if (pyopencv_TrackerCSRT_Params_getp(src, dst_)) |  | 27342 | if (pyopencv_TrackerCSRT_Params_getp(src, dst_))
| 27391 | { |  | 27343 | {
| 27392 | dst = *dst_; |  | 27344 | dst = *dst_;
| 27393 | return true; |  | 27345 | return true;
| 27394 | } |  | 27346 | }
| 27395 |  |  | 27347 |
| 27396 | failmsg("Expected cv::TrackerCSRT::Params for argument '%s'", info.name); |  | 27348 | failmsg("Expected cv::TrackerCSRT::Params for argument '%s'", info.name);
| 27397 | return false; |  | 27349 | return false;
| 27398 | } |  | 27350 | }
| 27399 | }; |  | 27351 | };
| 27400 |  |  | 27352 |
| 27401 | //================================================================================ |  | 27353 | //================================================================================
| 27402 | // TrackerDaSiamRPN (Generic) |  | 27354 | // TrackerDaSiamRPN (Generic)
| 27403 | //================================================================================ |  | 27355 | //================================================================================
| 27404 |  |  | 27356 |
| 27405 | // GetSet (TrackerDaSiamRPN) |  | 27357 | // GetSet (TrackerDaSiamRPN)
| 27406 |  |  | 27358 |
| 27407 |  |  | 27359 |
| 27408 |  |  | 27360 |
| 27409 | // Methods (TrackerDaSiamRPN) |  | 27361 | // Methods (TrackerDaSiamRPN)
| 27410 |  |  | 27362 |
| 27411 | static PyObject* pyopencv_cv_TrackerDaSiamRPN_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 27363 | static PyObject* pyopencv_cv_TrackerDaSiamRPN_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 27412 | { |  | 27364 | {
| 27413 | using namespace cv; |  | 27365 | using namespace cv;
| 27414 |  |  | 27366 |
| 27415 | pyPrepareArgumentConversionErrorsStorage(2); |  | 27367 | pyPrepareArgumentConversionErrorsStorage(2);
| 27416 |  |  | 27368 |
| 27417 | { |  | 27369 | {
| 27418 | PyObject* pyobj_parameters = NULL; |  | 27370 | PyObject* pyobj_parameters = NULL;
| 27419 | cv::TrackerDaSiamRPN::Params parameters=TrackerDaSiamRPN::Params(); |  | 27371 | cv::TrackerDaSiamRPN::Params parameters=TrackerDaSiamRPN::Params();
| 27420 | Ptr<TrackerDaSiamRPN> retval; |  | 27372 | Ptr<TrackerDaSiamRPN> retval;
| 27421 |  |  | 27373 |
| 27422 | const char* keywords[] = { "parameters", NULL }; |  | 27374 | const char* keywords[] = { "parameters", NULL };
| 27423 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerDaSiamRPN.create", (char**)keywords, &pyobj_parameters) && |  | 27375 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerDaSiamRPN.create", (char**)keywords, &pyobj_parameters) &&
| 27424 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 27376 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 27425 | { |  | 27377 | {
| 27426 | ERRWRAP2(retval = cv::TrackerDaSiamRPN::create(parameters)); |  | 27378 | ERRWRAP2(retval = cv::TrackerDaSiamRPN::create(parameters));
| 27427 | return pyopencv_from(retval); |  | 27379 | return pyopencv_from(retval);
| 27428 | } |  | 27380 | }
| 27429 |  |  | 27381 |
| 27430 |  |  | 27382 |
| 27431 | pyPopulateArgumentConversionErrors(); |  | 27383 | pyPopulateArgumentConversionErrors();
| 27432 | } |  | 27384 | }
| 27433 |  |  | 27385 |
| 27434 |  |  | 27386 |
| 27435 | { |  | 27387 | {
| 27436 | PyObject* pyobj_siam_rpn = NULL; |  | 27388 | PyObject* pyobj_siam_rpn = NULL;
| 27437 | cv::dnn::Net siam_rpn; |  | 27389 | cv::dnn::Net siam_rpn;
| 27438 | PyObject* pyobj_kernel_cls1 = NULL; |  | 27390 | PyObject* pyobj_kernel_cls1 = NULL;
| 27439 | cv::dnn::Net kernel_cls1; |  | 27391 | cv::dnn::Net kernel_cls1;
| 27440 | PyObject* pyobj_kernel_r1 = NULL; |  | 27392 | PyObject* pyobj_kernel_r1 = NULL;
| 27441 | cv::dnn::Net kernel_r1; |  | 27393 | cv::dnn::Net kernel_r1;
| 27442 | Ptr<TrackerDaSiamRPN> retval; |  | 27394 | Ptr<TrackerDaSiamRPN> retval;
| 27443 |  |  | 27395 |
| 27444 | const char* keywords[] = { "siam_rpn", "kernel_cls1", "kernel_r1", NULL }; |  | 27396 | const char* keywords[] = { "siam_rpn", "kernel_cls1", "kernel_r1", NULL };
| 27445 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:TrackerDaSiamRPN.create", (char**)keywords, &pyobj_siam_rpn, &pyobj_kernel_cls1, &pyobj_kernel_r1) && |  | 27397 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:TrackerDaSiamRPN.create", (char**)keywords, &pyobj_siam_rpn, &pyobj_kernel_cls1, &pyobj_kernel_r1) &&
| 27446 | pyopencv_to_safe(pyobj_siam_rpn, siam_rpn, ArgInfo("siam_rpn", 0)) && |  | 27398 | pyopencv_to_safe(pyobj_siam_rpn, siam_rpn, ArgInfo("siam_rpn", 0)) &&
| 27447 | pyopencv_to_safe(pyobj_kernel_cls1, kernel_cls1, ArgInfo("kernel_cls1", 0)) && |  | 27399 | pyopencv_to_safe(pyobj_kernel_cls1, kernel_cls1, ArgInfo("kernel_cls1", 0)) &&
| 27448 | pyopencv_to_safe(pyobj_kernel_r1, kernel_r1, ArgInfo("kernel_r1", 0)) ) |  | 27400 | pyopencv_to_safe(pyobj_kernel_r1, kernel_r1, ArgInfo("kernel_r1", 0)) )
| 27449 | { |  | 27401 | {
| 27450 | ERRWRAP2(retval = cv::TrackerDaSiamRPN::create(siam_rpn, kernel_cls1, kernel_r1)); |  | 27402 | ERRWRAP2(retval = cv::TrackerDaSiamRPN::create(siam_rpn, kernel_cls1, kernel_r1));
| 27451 | return pyopencv_from(retval); |  | 27403 | return pyopencv_from(retval);
| 27452 | } |  | 27404 | }
| 27453 |  |  | 27405 |
| 27454 |  |  | 27406 |
| 27455 | pyPopulateArgumentConversionErrors(); |  | 27407 | pyPopulateArgumentConversionErrors();
| 27456 | } |  | 27408 | }
| 27457 | pyRaiseCVOverloadException("create"); |  | 27409 | pyRaiseCVOverloadException("create");
| 27458 |  |  | 27410 |
| 27459 | return NULL; |  | 27411 | return NULL;
| 27460 | } |  | 27412 | }
| 27461 |  |  | 27413 |
| 27462 | static PyObject* pyopencv_cv_TrackerDaSiamRPN_getTrackingScore(PyObject* self, PyObject* py_args, PyObject* kw) |  | 27414 | static PyObject* pyopencv_cv_TrackerDaSiamRPN_getTrackingScore(PyObject* self, PyObject* py_args, PyObject* kw)
| 27463 | { |  | 27415 | {
| 27464 | using namespace cv; |  | 27416 | using namespace cv;
| 27465 |  |  | 27417 |
| 27466 |  |  | 27418 |
| 27467 | Ptr<cv::TrackerDaSiamRPN> * self1 = 0; |  | 27419 | Ptr<cv::TrackerDaSiamRPN> * self1 = 0;
| 27468 | if (!pyopencv_TrackerDaSiamRPN_getp(self, self1)) |  | 27420 | if (!pyopencv_TrackerDaSiamRPN_getp(self, self1))
| 27469 | return failmsgp("Incorrect type of self (must be 'TrackerDaSiamRPN' or its derivative)"); |  | 27421 | return failmsgp("Incorrect type of self (must be 'TrackerDaSiamRPN' or its derivative)");
| 27470 | Ptr<cv::TrackerDaSiamRPN> _self_ = *(self1); |  | 27422 | Ptr<cv::TrackerDaSiamRPN> _self_ = *(self1);
| 27471 | float retval; |  | 27423 | float retval;
| 27472 |  |  | 27424 |
| 27473 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 27425 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 27474 | { |  | 27426 | {
| 27475 | ERRWRAP2(retval = _self_->getTrackingScore()); |  | 27427 | ERRWRAP2(retval = _self_->getTrackingScore());
| 27476 | return pyopencv_from(retval); |  | 27428 | return pyopencv_from(retval);
| 27477 | } |  | 27429 | }
| 27478 |  |  | 27430 |
| 27479 | return NULL; |  | 27431 | return NULL;
| 27480 | } |  | 27432 | }
| 27481 |  |  | 27433 |
| 27482 |  |  | 27434 |
| 27483 |  |  | 27435 |
| 27484 | // Tables (TrackerDaSiamRPN) |  | 27436 | // Tables (TrackerDaSiamRPN)
| 27485 |  |  | 27437 |
| 27486 | static PyGetSetDef pyopencv_TrackerDaSiamRPN_getseters[] = |  | 27438 | static PyGetSetDef pyopencv_TrackerDaSiamRPN_getseters[] =
| 27487 | { |  | 27439 | {
| 27488 | {NULL} /* Sentinel */ |  | 27440 | {NULL} /* Sentinel */
| 27489 | }; |  | 27441 | };
| 27490 |  |  | 27442 |
| 27491 | static PyMethodDef pyopencv_TrackerDaSiamRPN_methods[] = |  | 27443 | static PyMethodDef pyopencv_TrackerDaSiamRPN_methods[] =
| 27492 | { |  | 27444 | {
| 27493 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerDaSiamRPN_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters DaSiamRPN parameters TrackerDaSiamRPN::Params\n\n\n\ncreate(siam_rpn, kernel_cls1, kernel_r1) -> retval\n. @brief Constructor\n. * @param siam_rpn pre-loaded SiamRPN model\n. * @param kernel_cls1 pre-loaded CLS model\n. * @param kernel_r1 pre-loaded R1 model"}, |  | 27445 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerDaSiamRPN_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters DaSiamRPN parameters TrackerDaSiamRPN::Params\n\n\n\ncreate(siam_rpn, kernel_cls1, kernel_r1) -> retval\n. @brief Constructor\n. * @param siam_rpn pre-loaded SiamRPN model\n. * @param kernel_cls1 pre-loaded CLS model\n. * @param kernel_r1 pre-loaded R1 model"},
| 27494 | {"getTrackingScore", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerDaSiamRPN_getTrackingScore, 0), "getTrackingScore() -> retval\n. @brief Return tracking score"}, |  | 27446 | {"getTrackingScore", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerDaSiamRPN_getTrackingScore, 0), "getTrackingScore() -> retval\n. @brief Return tracking score"},
| 27495 |  |  | 27447 |
| 27496 | {NULL, NULL} |  | 27448 | {NULL, NULL}
| 27497 | }; |  | 27449 | };
| 27498 |  |  | 27450 |
| 27499 | // Converter (TrackerDaSiamRPN) |  | 27451 | // Converter (TrackerDaSiamRPN)
| 27500 |  |  | 27452 |
| 27501 | template<> |  | 27453 | template<>
| 27502 | struct PyOpenCV_Converter< Ptr<cv::TrackerDaSiamRPN> > |  | 27454 | struct PyOpenCV_Converter< Ptr<cv::TrackerDaSiamRPN> >
| 27503 | { |  | 27455 | {
| 27504 | static PyObject* from(const Ptr<cv::TrackerDaSiamRPN>& r) |  | 27456 | static PyObject* from(const Ptr<cv::TrackerDaSiamRPN>& r)
| 27505 | { |  | 27457 | {
| 27506 | return pyopencv_TrackerDaSiamRPN_Instance(r); |  | 27458 | return pyopencv_TrackerDaSiamRPN_Instance(r);
| 27507 | } |  | 27459 | }
| 27508 | static bool to(PyObject* src, Ptr<cv::TrackerDaSiamRPN>& dst, const ArgInfo& info) |  | 27460 | static bool to(PyObject* src, Ptr<cv::TrackerDaSiamRPN>& dst, const ArgInfo& info)
| 27509 | { |  | 27461 | {
| 27510 | if(!src || src == Py_None) |  | 27462 | if(!src || src == Py_None)
| 27511 | return true; |  | 27463 | return true;
| 27512 | Ptr<cv::TrackerDaSiamRPN> * dst_; |  | 27464 | Ptr<cv::TrackerDaSiamRPN> * dst_;
| 27513 | if (pyopencv_TrackerDaSiamRPN_getp(src, dst_)) |  | 27465 | if (pyopencv_TrackerDaSiamRPN_getp(src, dst_))
| 27514 | { |  | 27466 | {
| 27515 | dst = *dst_; |  | 27467 | dst = *dst_;
| 27516 | return true; |  | 27468 | return true;
| 27517 | } |  | 27469 | }
| 27518 |  |  | 27470 |
| 27519 | failmsg("Expected Ptr<cv::TrackerDaSiamRPN> for argument '%s'", info.name); |  | 27471 | failmsg("Expected Ptr<cv::TrackerDaSiamRPN> for argument '%s'", info.name);
| 27520 | return false; |  | 27472 | return false;
| 27521 | } |  | 27473 | }
| 27522 | }; |  | 27474 | };
| 27523 |  |  | 27475 |
| 27524 | //================================================================================ |  | 27476 | //================================================================================
| 27525 | // TrackerDaSiamRPN_Params (Generic) |  | 27477 | // TrackerDaSiamRPN_Params (Generic)
| 27526 | //================================================================================ |  | 27478 | //================================================================================
| 27527 |  |  | 27479 |
| 27528 | // GetSet (TrackerDaSiamRPN_Params) |  | 27480 | // GetSet (TrackerDaSiamRPN_Params)
| 27529 |  |  | 27481 |
| 27530 |  |  | 27482 |
| 27531 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_backend(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure) |  | 27483 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_backend(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure)
| 27532 | { |  | 27484 | {
| 27533 | return pyopencv_from(p->v.backend); |  | 27485 | return pyopencv_from(p->v.backend);
| 27534 | } |  | 27486 | }
| 27535 |  |  | 27487 |
| 27536 | static int pyopencv_TrackerDaSiamRPN_Params_set_backend(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure) |  | 27488 | static int pyopencv_TrackerDaSiamRPN_Params_set_backend(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure)
| 27537 | { |  | 27489 | {
| 27538 | if (!value) |  | 27490 | if (!value)
| 27539 | { |  | 27491 | {
| 27540 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backend attribute"); |  | 27492 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backend attribute");
| 27541 | return -1; |  | 27493 | return -1;
| 27542 | } |  | 27494 | }
| 27543 | return pyopencv_to_safe(value, p->v.backend, ArgInfo("value", 0)) ? 0 : -1; |  | 27495 | return pyopencv_to_safe(value, p->v.backend, ArgInfo("value", 0)) ? 0 : -1;
| 27544 | } |  | 27496 | }
| 27545 |  |  | 27497 |
| 27546 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_kernel_cls1(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure) |  | 27498 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_kernel_cls1(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure)
| 27547 | { |  | 27499 | {
| 27548 | return pyopencv_from(p->v.kernel_cls1); |  | 27500 | return pyopencv_from(p->v.kernel_cls1);
| 27549 | } |  | 27501 | }
| 27550 |  |  | 27502 |
| 27551 | static int pyopencv_TrackerDaSiamRPN_Params_set_kernel_cls1(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure) |  | 27503 | static int pyopencv_TrackerDaSiamRPN_Params_set_kernel_cls1(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure)
| 27552 | { |  | 27504 | {
| 27553 | if (!value) |  | 27505 | if (!value)
| 27554 | { |  | 27506 | {
| 27555 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kernel_cls1 attribute"); |  | 27507 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kernel_cls1 attribute");
| 27556 | return -1; |  | 27508 | return -1;
| 27557 | } |  | 27509 | }
| 27558 | return pyopencv_to_safe(value, p->v.kernel_cls1, ArgInfo("value", 0)) ? 0 : -1; |  | 27510 | return pyopencv_to_safe(value, p->v.kernel_cls1, ArgInfo("value", 0)) ? 0 : -1;
| 27559 | } |  | 27511 | }
| 27560 |  |  | 27512 |
| 27561 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_kernel_r1(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure) |  | 27513 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_kernel_r1(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure)
| 27562 | { |  | 27514 | {
| 27563 | return pyopencv_from(p->v.kernel_r1); |  | 27515 | return pyopencv_from(p->v.kernel_r1);
| 27564 | } |  | 27516 | }
| 27565 |  |  | 27517 |
| 27566 | static int pyopencv_TrackerDaSiamRPN_Params_set_kernel_r1(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure) |  | 27518 | static int pyopencv_TrackerDaSiamRPN_Params_set_kernel_r1(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure)
| 27567 | { |  | 27519 | {
| 27568 | if (!value) |  | 27520 | if (!value)
| 27569 | { |  | 27521 | {
| 27570 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kernel_r1 attribute"); |  | 27522 | PyErr_SetString(PyExc_TypeError, "Cannot delete the kernel_r1 attribute");
| 27571 | return -1; |  | 27523 | return -1;
| 27572 | } |  | 27524 | }
| 27573 | return pyopencv_to_safe(value, p->v.kernel_r1, ArgInfo("value", 0)) ? 0 : -1; |  | 27525 | return pyopencv_to_safe(value, p->v.kernel_r1, ArgInfo("value", 0)) ? 0 : -1;
| 27574 | } |  | 27526 | }
| 27575 |  |  | 27527 |
| 27576 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_model(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure) |  | 27528 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_model(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure)
| 27577 | { |  | 27529 | {
| 27578 | return pyopencv_from(p->v.model); |  | 27530 | return pyopencv_from(p->v.model);
| 27579 | } |  | 27531 | }
| 27580 |  |  | 27532 |
| 27581 | static int pyopencv_TrackerDaSiamRPN_Params_set_model(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure) |  | 27533 | static int pyopencv_TrackerDaSiamRPN_Params_set_model(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure)
| 27582 | { |  | 27534 | {
| 27583 | if (!value) |  | 27535 | if (!value)
| 27584 | { |  | 27536 | {
| 27585 | PyErr_SetString(PyExc_TypeError, "Cannot delete the model attribute"); |  | 27537 | PyErr_SetString(PyExc_TypeError, "Cannot delete the model attribute");
| 27586 | return -1; |  | 27538 | return -1;
| 27587 | } |  | 27539 | }
| 27588 | return pyopencv_to_safe(value, p->v.model, ArgInfo("value", 0)) ? 0 : -1; |  | 27540 | return pyopencv_to_safe(value, p->v.model, ArgInfo("value", 0)) ? 0 : -1;
| 27589 | } |  | 27541 | }
| 27590 |  |  | 27542 |
| 27591 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_target(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure) |  | 27543 | static PyObject* pyopencv_TrackerDaSiamRPN_Params_get_target(pyopencv_TrackerDaSiamRPN_Params_t* p, void *closure)
| 27592 | { |  | 27544 | {
| 27593 | return pyopencv_from(p->v.target); |  | 27545 | return pyopencv_from(p->v.target);
| 27594 | } |  | 27546 | }
| 27595 |  |  | 27547 |
| 27596 | static int pyopencv_TrackerDaSiamRPN_Params_set_target(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure) |  | 27548 | static int pyopencv_TrackerDaSiamRPN_Params_set_target(pyopencv_TrackerDaSiamRPN_Params_t* p, PyObject *value, void *closure)
| 27597 | { |  | 27549 | {
| 27598 | if (!value) |  | 27550 | if (!value)
| 27599 | { |  | 27551 | {
| 27600 | PyErr_SetString(PyExc_TypeError, "Cannot delete the target attribute"); |  | 27552 | PyErr_SetString(PyExc_TypeError, "Cannot delete the target attribute");
| 27601 | return -1; |  | 27553 | return -1;
| 27602 | } |  | 27554 | }
| 27603 | return pyopencv_to_safe(value, p->v.target, ArgInfo("value", 0)) ? 0 : -1; |  | 27555 | return pyopencv_to_safe(value, p->v.target, ArgInfo("value", 0)) ? 0 : -1;
| 27604 | } |  | 27556 | }
| 27605 |  |  | 27557 |
| 27606 |  |  | 27558 |
| 27607 | // Methods (TrackerDaSiamRPN_Params) |  | 27559 | // Methods (TrackerDaSiamRPN_Params)
| 27608 |  |  | 27560 |
| 27609 | static int pyopencv_cv_TrackerDaSiamRPN_Params_TrackerDaSiamRPN_Params(pyopencv_TrackerDaSiamRPN_Params_t* self, PyObject* py_args, PyObject* kw) |  | 27561 | static int pyopencv_cv_TrackerDaSiamRPN_Params_TrackerDaSiamRPN_Params(pyopencv_TrackerDaSiamRPN_Params_t* self, PyObject* py_args, PyObject* kw)
| 27610 | { |  | 27562 | {
| 27611 | using namespace cv; |  | 27563 | using namespace cv;
| 27612 |  |  | 27564 |
| 27613 |  |  | 27565 |
| 27614 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 27566 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 27615 | { |  | 27567 | {
| 27616 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerDaSiamRPN::Params()); |  | 27568 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerDaSiamRPN::Params());
| 27617 | return 0; |  | 27569 | return 0;
| 27618 | } |  | 27570 | }
| 27619 |  |  | 27571 |
| 27620 | return -1; |  | 27572 | return -1;
| 27621 | } |  | 27573 | }
| 27622 |  |  | 27574 |
| 27623 |  |  | 27575 |
| 27624 |  |  | 27576 |
| 27625 | // Tables (TrackerDaSiamRPN_Params) |  | 27577 | // Tables (TrackerDaSiamRPN_Params)
| 27626 |  |  | 27578 |
| 27627 | static PyGetSetDef pyopencv_TrackerDaSiamRPN_Params_getseters[] = |  | 27579 | static PyGetSetDef pyopencv_TrackerDaSiamRPN_Params_getseters[] =
| 27628 | { |  | 27580 | {
| 27629 | {(char*)"backend", (getter)pyopencv_TrackerDaSiamRPN_Params_get_backend, (setter)pyopencv_TrackerDaSiamRPN_Params_set_backend, (char*)"backend", NULL}, |  | 27581 | {(char*)"backend", (getter)pyopencv_TrackerDaSiamRPN_Params_get_backend, (setter)pyopencv_TrackerDaSiamRPN_Params_set_backend, (char*)"backend", NULL},
| 27630 | {(char*)"kernel_cls1", (getter)pyopencv_TrackerDaSiamRPN_Params_get_kernel_cls1, (setter)pyopencv_TrackerDaSiamRPN_Params_set_kernel_cls1, (char*)"kernel_cls1", NULL}, |  | 27582 | {(char*)"kernel_cls1", (getter)pyopencv_TrackerDaSiamRPN_Params_get_kernel_cls1, (setter)pyopencv_TrackerDaSiamRPN_Params_set_kernel_cls1, (char*)"kernel_cls1", NULL},
| 27631 | {(char*)"kernel_r1", (getter)pyopencv_TrackerDaSiamRPN_Params_get_kernel_r1, (setter)pyopencv_TrackerDaSiamRPN_Params_set_kernel_r1, (char*)"kernel_r1", NULL}, |  | 27583 | {(char*)"kernel_r1", (getter)pyopencv_TrackerDaSiamRPN_Params_get_kernel_r1, (setter)pyopencv_TrackerDaSiamRPN_Params_set_kernel_r1, (char*)"kernel_r1", NULL},
| 27632 | {(char*)"model", (getter)pyopencv_TrackerDaSiamRPN_Params_get_model, (setter)pyopencv_TrackerDaSiamRPN_Params_set_model, (char*)"model", NULL}, |  | 27584 | {(char*)"model", (getter)pyopencv_TrackerDaSiamRPN_Params_get_model, (setter)pyopencv_TrackerDaSiamRPN_Params_set_model, (char*)"model", NULL},
| 27633 | {(char*)"target", (getter)pyopencv_TrackerDaSiamRPN_Params_get_target, (setter)pyopencv_TrackerDaSiamRPN_Params_set_target, (char*)"target", NULL}, |  | 27585 | {(char*)"target", (getter)pyopencv_TrackerDaSiamRPN_Params_get_target, (setter)pyopencv_TrackerDaSiamRPN_Params_set_target, (char*)"target", NULL},
| 27634 | {NULL} /* Sentinel */ |  | 27586 | {NULL} /* Sentinel */
| 27635 | }; |  | 27587 | };
| 27636 |  |  | 27588 |
| 27637 | static PyMethodDef pyopencv_TrackerDaSiamRPN_Params_methods[] = |  | 27589 | static PyMethodDef pyopencv_TrackerDaSiamRPN_Params_methods[] =
| 27638 | { |  | 27590 | {
| 27639 |  |  | 27591 |
| 27640 | {NULL, NULL} |  | 27592 | {NULL, NULL}
| 27641 | }; |  | 27593 | };
| 27642 |  |  | 27594 |
| 27643 | // Converter (TrackerDaSiamRPN_Params) |  | 27595 | // Converter (TrackerDaSiamRPN_Params)
| 27644 |  |  | 27596 |
| 27645 | template<> |  | 27597 | template<>
| 27646 | struct PyOpenCV_Converter< cv::TrackerDaSiamRPN::Params > |  | 27598 | struct PyOpenCV_Converter< cv::TrackerDaSiamRPN::Params >
| 27647 | { |  | 27599 | {
| 27648 | static PyObject* from(const cv::TrackerDaSiamRPN::Params& r) |  | 27600 | static PyObject* from(const cv::TrackerDaSiamRPN::Params& r)
| 27649 | { |  | 27601 | {
| 27650 | return pyopencv_TrackerDaSiamRPN_Params_Instance(r); |  | 27602 | return pyopencv_TrackerDaSiamRPN_Params_Instance(r);
| 27651 | } |  | 27603 | }
| 27652 | static bool to(PyObject* src, cv::TrackerDaSiamRPN::Params& dst, const ArgInfo& info) |  | 27604 | static bool to(PyObject* src, cv::TrackerDaSiamRPN::Params& dst, const ArgInfo& info)
| 27653 | { |  | 27605 | {
| 27654 | if(!src || src == Py_None) |  | 27606 | if(!src || src == Py_None)
| 27655 | return true; |  | 27607 | return true;
| 27656 | cv::TrackerDaSiamRPN::Params * dst_; |  | 27608 | cv::TrackerDaSiamRPN::Params * dst_;
| 27657 | if (pyopencv_TrackerDaSiamRPN_Params_getp(src, dst_)) |  | 27609 | if (pyopencv_TrackerDaSiamRPN_Params_getp(src, dst_))
| 27658 | { |  | 27610 | {
| 27659 | dst = *dst_; |  | 27611 | dst = *dst_;
| 27660 | return true; |  | 27612 | return true;
| 27661 | } |  | 27613 | }
| 27662 |  |  | 27614 |
| 27663 | failmsg("Expected cv::TrackerDaSiamRPN::Params for argument '%s'", info.name); |  | 27615 | failmsg("Expected cv::TrackerDaSiamRPN::Params for argument '%s'", info.name);
| 27664 | return false; |  | 27616 | return false;
| 27665 | } |  | 27617 | }
| 27666 | }; |  | 27618 | };
| 27667 |  |  | 27619 |
| 27668 | //================================================================================ |  | 27620 | //================================================================================
| 27669 | // TrackerGOTURN (Generic) |  | 27621 | // TrackerGOTURN (Generic)
| 27670 | //================================================================================ |  | 27622 | //================================================================================
| 27671 |  |  | 27623 |
| 27672 | // GetSet (TrackerGOTURN) |  | 27624 | // GetSet (TrackerGOTURN)
| 27673 |  |  | 27625 |
| 27674 |  |  | 27626 |
| 27675 |  |  | 27627 |
| 27676 | // Methods (TrackerGOTURN) |  | 27628 | // Methods (TrackerGOTURN)
| 27677 |  |  | 27629 |
| 27678 | static PyObject* pyopencv_cv_TrackerGOTURN_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 27630 | static PyObject* pyopencv_cv_TrackerGOTURN_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 27679 | { |  | 27631 | {
| 27680 | using namespace cv; |  | 27632 | using namespace cv;
| 27681 |  |  | 27633 |
| 27682 | pyPrepareArgumentConversionErrorsStorage(2); |  | 27634 | pyPrepareArgumentConversionErrorsStorage(2);
| 27683 |  |  | 27635 |
| 27684 | { |  | 27636 | {
| 27685 | PyObject* pyobj_parameters = NULL; |  | 27637 | PyObject* pyobj_parameters = NULL;
| 27686 | cv::TrackerGOTURN::Params parameters=TrackerGOTURN::Params(); |  | 27638 | cv::TrackerGOTURN::Params parameters=TrackerGOTURN::Params();
| 27687 | Ptr<TrackerGOTURN> retval; |  | 27639 | Ptr<TrackerGOTURN> retval;
| 27688 |  |  | 27640 |
| 27689 | const char* keywords[] = { "parameters", NULL }; |  | 27641 | const char* keywords[] = { "parameters", NULL };
| 27690 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerGOTURN.create", (char**)keywords, &pyobj_parameters) && |  | 27642 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerGOTURN.create", (char**)keywords, &pyobj_parameters) &&
| 27691 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 27643 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 27692 | { |  | 27644 | {
| 27693 | ERRWRAP2(retval = cv::TrackerGOTURN::create(parameters)); |  | 27645 | ERRWRAP2(retval = cv::TrackerGOTURN::create(parameters));
| 27694 | return pyopencv_from(retval); |  | 27646 | return pyopencv_from(retval);
| 27695 | } |  | 27647 | }
| 27696 |  |  | 27648 |
| 27697 |  |  | 27649 |
| 27698 | pyPopulateArgumentConversionErrors(); |  | 27650 | pyPopulateArgumentConversionErrors();
| 27699 | } |  | 27651 | }
| 27700 |  |  | 27652 |
| 27701 |  |  | 27653 |
| 27702 | { |  | 27654 | {
| 27703 | PyObject* pyobj_model = NULL; |  | 27655 | PyObject* pyobj_model = NULL;
| 27704 | cv::dnn::Net model; |  | 27656 | cv::dnn::Net model;
| 27705 | Ptr<TrackerGOTURN> retval; |  | 27657 | Ptr<TrackerGOTURN> retval;
| 27706 |  |  | 27658 |
| 27707 | const char* keywords[] = { "model", NULL }; |  | 27659 | const char* keywords[] = { "model", NULL };
| 27708 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TrackerGOTURN.create", (char**)keywords, &pyobj_model) && |  | 27660 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TrackerGOTURN.create", (char**)keywords, &pyobj_model) &&
| 27709 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) ) |  | 27661 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) )
| 27710 | { |  | 27662 | {
| 27711 | ERRWRAP2(retval = cv::TrackerGOTURN::create(model)); |  | 27663 | ERRWRAP2(retval = cv::TrackerGOTURN::create(model));
| 27712 | return pyopencv_from(retval); |  | 27664 | return pyopencv_from(retval);
| 27713 | } |  | 27665 | }
| 27714 |  |  | 27666 |
| 27715 |  |  | 27667 |
| 27716 | pyPopulateArgumentConversionErrors(); |  | 27668 | pyPopulateArgumentConversionErrors();
| 27717 | } |  | 27669 | }
| 27718 | pyRaiseCVOverloadException("create"); |  | 27670 | pyRaiseCVOverloadException("create");
| 27719 |  |  | 27671 |
| 27720 | return NULL; |  | 27672 | return NULL;
| 27721 | } |  | 27673 | }
| 27722 |  |  | 27674 |
| 27723 |  |  | 27675 |
| 27724 |  |  | 27676 |
| 27725 | // Tables (TrackerGOTURN) |  | 27677 | // Tables (TrackerGOTURN)
| 27726 |  |  | 27678 |
| 27727 | static PyGetSetDef pyopencv_TrackerGOTURN_getseters[] = |  | 27679 | static PyGetSetDef pyopencv_TrackerGOTURN_getseters[] =
| 27728 | { |  | 27680 | {
| 27729 | {NULL} /* Sentinel */ |  | 27681 | {NULL} /* Sentinel */
| 27730 | }; |  | 27682 | };
| 27731 |  |  | 27683 |
| 27732 | static PyMethodDef pyopencv_TrackerGOTURN_methods[] = |  | 27684 | static PyMethodDef pyopencv_TrackerGOTURN_methods[] =
| 27733 | { |  | 27685 | {
| 27734 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerGOTURN_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters GOTURN parameters TrackerGOTURN::Params\n\n\n\ncreate(model) -> retval\n. @brief Constructor\n. @param model pre-loaded GOTURN model"}, |  | 27686 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerGOTURN_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters GOTURN parameters TrackerGOTURN::Params\n\n\n\ncreate(model) -> retval\n. @brief Constructor\n. @param model pre-loaded GOTURN model"},
| 27735 |  |  | 27687 |
| 27736 | {NULL, NULL} |  | 27688 | {NULL, NULL}
| 27737 | }; |  | 27689 | };
| 27738 |  |  | 27690 |
| 27739 | // Converter (TrackerGOTURN) |  | 27691 | // Converter (TrackerGOTURN)
| 27740 |  |  | 27692 |
| 27741 | template<> |  | 27693 | template<>
| 27742 | struct PyOpenCV_Converter< Ptr<cv::TrackerGOTURN> > |  | 27694 | struct PyOpenCV_Converter< Ptr<cv::TrackerGOTURN> >
| 27743 | { |  | 27695 | {
| 27744 | static PyObject* from(const Ptr<cv::TrackerGOTURN>& r) |  | 27696 | static PyObject* from(const Ptr<cv::TrackerGOTURN>& r)
| 27745 | { |  | 27697 | {
| 27746 | return pyopencv_TrackerGOTURN_Instance(r); |  | 27698 | return pyopencv_TrackerGOTURN_Instance(r);
| 27747 | } |  | 27699 | }
| 27748 | static bool to(PyObject* src, Ptr<cv::TrackerGOTURN>& dst, const ArgInfo& info) |  | 27700 | static bool to(PyObject* src, Ptr<cv::TrackerGOTURN>& dst, const ArgInfo& info)
| 27749 | { |  | 27701 | {
| 27750 | if(!src || src == Py_None) |  | 27702 | if(!src || src == Py_None)
| 27751 | return true; |  | 27703 | return true;
| 27752 | Ptr<cv::TrackerGOTURN> * dst_; |  | 27704 | Ptr<cv::TrackerGOTURN> * dst_;
| 27753 | if (pyopencv_TrackerGOTURN_getp(src, dst_)) |  | 27705 | if (pyopencv_TrackerGOTURN_getp(src, dst_))
| 27754 | { |  | 27706 | {
| 27755 | dst = *dst_; |  | 27707 | dst = *dst_;
| 27756 | return true; |  | 27708 | return true;
| 27757 | } |  | 27709 | }
| 27758 |  |  | 27710 |
| 27759 | failmsg("Expected Ptr<cv::TrackerGOTURN> for argument '%s'", info.name); |  | 27711 | failmsg("Expected Ptr<cv::TrackerGOTURN> for argument '%s'", info.name);
| 27760 | return false; |  | 27712 | return false;
| 27761 | } |  | 27713 | }
| 27762 | }; |  | 27714 | };
| 27763 |  |  | 27715 |
| 27764 | //================================================================================ |  | 27716 | //================================================================================
| 27765 | // TrackerGOTURN_Params (Generic) |  | 27717 | // TrackerGOTURN_Params (Generic)
| 27766 | //================================================================================ |  | 27718 | //================================================================================
| 27767 |  |  | 27719 |
| 27768 | // GetSet (TrackerGOTURN_Params) |  | 27720 | // GetSet (TrackerGOTURN_Params)
| 27769 |  |  | 27721 |
| 27770 |  |  | 27722 |
| 27771 | static PyObject* pyopencv_TrackerGOTURN_Params_get_modelBin(pyopencv_TrackerGOTURN_Params_t* p, void *closure) |  | 27723 | static PyObject* pyopencv_TrackerGOTURN_Params_get_modelBin(pyopencv_TrackerGOTURN_Params_t* p, void *closure)
| 27772 | { |  | 27724 | {
| 27773 | return pyopencv_from(p->v.modelBin); |  | 27725 | return pyopencv_from(p->v.modelBin);
| 27774 | } |  | 27726 | }
| 27775 |  |  | 27727 |
| 27776 | static int pyopencv_TrackerGOTURN_Params_set_modelBin(pyopencv_TrackerGOTURN_Params_t* p, PyObject *value, void *closure) |  | 27728 | static int pyopencv_TrackerGOTURN_Params_set_modelBin(pyopencv_TrackerGOTURN_Params_t* p, PyObject *value, void *closure)
| 27777 | { |  | 27729 | {
| 27778 | if (!value) |  | 27730 | if (!value)
| 27779 | { |  | 27731 | {
| 27780 | PyErr_SetString(PyExc_TypeError, "Cannot delete the modelBin attribute"); |  | 27732 | PyErr_SetString(PyExc_TypeError, "Cannot delete the modelBin attribute");
| 27781 | return -1; |  | 27733 | return -1;
| 27782 | } |  | 27734 | }
| 27783 | return pyopencv_to_safe(value, p->v.modelBin, ArgInfo("value", 0)) ? 0 : -1; |  | 27735 | return pyopencv_to_safe(value, p->v.modelBin, ArgInfo("value", 0)) ? 0 : -1;
| 27784 | } |  | 27736 | }
| 27785 |  |  | 27737 |
| 27786 | static PyObject* pyopencv_TrackerGOTURN_Params_get_modelTxt(pyopencv_TrackerGOTURN_Params_t* p, void *closure) |  | 27738 | static PyObject* pyopencv_TrackerGOTURN_Params_get_modelTxt(pyopencv_TrackerGOTURN_Params_t* p, void *closure)
| 27787 | { |  | 27739 | {
| 27788 | return pyopencv_from(p->v.modelTxt); |  | 27740 | return pyopencv_from(p->v.modelTxt);
| 27789 | } |  | 27741 | }
| 27790 |  |  | 27742 |
| 27791 | static int pyopencv_TrackerGOTURN_Params_set_modelTxt(pyopencv_TrackerGOTURN_Params_t* p, PyObject *value, void *closure) |  | 27743 | static int pyopencv_TrackerGOTURN_Params_set_modelTxt(pyopencv_TrackerGOTURN_Params_t* p, PyObject *value, void *closure)
| 27792 | { |  | 27744 | {
| 27793 | if (!value) |  | 27745 | if (!value)
| 27794 | { |  | 27746 | {
| 27795 | PyErr_SetString(PyExc_TypeError, "Cannot delete the modelTxt attribute"); |  | 27747 | PyErr_SetString(PyExc_TypeError, "Cannot delete the modelTxt attribute");
| 27796 | return -1; |  | 27748 | return -1;
| 27797 | } |  | 27749 | }
| 27798 | return pyopencv_to_safe(value, p->v.modelTxt, ArgInfo("value", 0)) ? 0 : -1; |  | 27750 | return pyopencv_to_safe(value, p->v.modelTxt, ArgInfo("value", 0)) ? 0 : -1;
| 27799 | } |  | 27751 | }
| 27800 |  |  | 27752 |
| 27801 |  |  | 27753 |
| 27802 | // Methods (TrackerGOTURN_Params) |  | 27754 | // Methods (TrackerGOTURN_Params)
| 27803 |  |  | 27755 |
| 27804 | static int pyopencv_cv_TrackerGOTURN_Params_TrackerGOTURN_Params(pyopencv_TrackerGOTURN_Params_t* self, PyObject* py_args, PyObject* kw) |  | 27756 | static int pyopencv_cv_TrackerGOTURN_Params_TrackerGOTURN_Params(pyopencv_TrackerGOTURN_Params_t* self, PyObject* py_args, PyObject* kw)
| 27805 | { |  | 27757 | {
| 27806 | using namespace cv; |  | 27758 | using namespace cv;
| 27807 |  |  | 27759 |
| 27808 |  |  | 27760 |
| 27809 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 27761 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 27810 | { |  | 27762 | {
| 27811 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerGOTURN::Params()); |  | 27763 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerGOTURN::Params());
| 27812 | return 0; |  | 27764 | return 0;
| 27813 | } |  | 27765 | }
| 27814 |  |  | 27766 |
| 27815 | return -1; |  | 27767 | return -1;
| 27816 | } |  | 27768 | }
| 27817 |  |  | 27769 |
| 27818 |  |  | 27770 |
| 27819 |  |  | 27771 |
| 27820 | // Tables (TrackerGOTURN_Params) |  | 27772 | // Tables (TrackerGOTURN_Params)
| 27821 |  |  | 27773 |
| 27822 | static PyGetSetDef pyopencv_TrackerGOTURN_Params_getseters[] = |  | 27774 | static PyGetSetDef pyopencv_TrackerGOTURN_Params_getseters[] =
| 27823 | { |  | 27775 | {
| 27824 | {(char*)"modelBin", (getter)pyopencv_TrackerGOTURN_Params_get_modelBin, (setter)pyopencv_TrackerGOTURN_Params_set_modelBin, (char*)"modelBin", NULL}, |  | 27776 | {(char*)"modelBin", (getter)pyopencv_TrackerGOTURN_Params_get_modelBin, (setter)pyopencv_TrackerGOTURN_Params_set_modelBin, (char*)"modelBin", NULL},
| 27825 | {(char*)"modelTxt", (getter)pyopencv_TrackerGOTURN_Params_get_modelTxt, (setter)pyopencv_TrackerGOTURN_Params_set_modelTxt, (char*)"modelTxt", NULL}, |  | 27777 | {(char*)"modelTxt", (getter)pyopencv_TrackerGOTURN_Params_get_modelTxt, (setter)pyopencv_TrackerGOTURN_Params_set_modelTxt, (char*)"modelTxt", NULL},
| 27826 | {NULL} /* Sentinel */ |  | 27778 | {NULL} /* Sentinel */
| 27827 | }; |  | 27779 | };
| 27828 |  |  | 27780 |
| 27829 | static PyMethodDef pyopencv_TrackerGOTURN_Params_methods[] = |  | 27781 | static PyMethodDef pyopencv_TrackerGOTURN_Params_methods[] =
| 27830 | { |  | 27782 | {
| 27831 |  |  | 27783 |
| 27832 | {NULL, NULL} |  | 27784 | {NULL, NULL}
| 27833 | }; |  | 27785 | };
| 27834 |  |  | 27786 |
| 27835 | // Converter (TrackerGOTURN_Params) |  | 27787 | // Converter (TrackerGOTURN_Params)
| 27836 |  |  | 27788 |
| 27837 | template<> |  | 27789 | template<>
| 27838 | struct PyOpenCV_Converter< cv::TrackerGOTURN::Params > |  | 27790 | struct PyOpenCV_Converter< cv::TrackerGOTURN::Params >
| 27839 | { |  | 27791 | {
| 27840 | static PyObject* from(const cv::TrackerGOTURN::Params& r) |  | 27792 | static PyObject* from(const cv::TrackerGOTURN::Params& r)
| 27841 | { |  | 27793 | {
| 27842 | return pyopencv_TrackerGOTURN_Params_Instance(r); |  | 27794 | return pyopencv_TrackerGOTURN_Params_Instance(r);
| 27843 | } |  | 27795 | }
| 27844 | static bool to(PyObject* src, cv::TrackerGOTURN::Params& dst, const ArgInfo& info) |  | 27796 | static bool to(PyObject* src, cv::TrackerGOTURN::Params& dst, const ArgInfo& info)
| 27845 | { |  | 27797 | {
| 27846 | if(!src || src == Py_None) |  | 27798 | if(!src || src == Py_None)
| 27847 | return true; |  | 27799 | return true;
| 27848 | cv::TrackerGOTURN::Params * dst_; |  | 27800 | cv::TrackerGOTURN::Params * dst_;
| 27849 | if (pyopencv_TrackerGOTURN_Params_getp(src, dst_)) |  | 27801 | if (pyopencv_TrackerGOTURN_Params_getp(src, dst_))
| 27850 | { |  | 27802 | {
| 27851 | dst = *dst_; |  | 27803 | dst = *dst_;
| 27852 | return true; |  | 27804 | return true;
| 27853 | } |  | 27805 | }
| 27854 |  |  | 27806 |
| 27855 | failmsg("Expected cv::TrackerGOTURN::Params for argument '%s'", info.name); |  | 27807 | failmsg("Expected cv::TrackerGOTURN::Params for argument '%s'", info.name);
| 27856 | return false; |  | 27808 | return false;
| 27857 | } |  | 27809 | }
| 27858 | }; |  | 27810 | };
| 27859 |  |  | 27811 |
| 27860 | //================================================================================ |  | 27812 | //================================================================================
| 27861 | // TrackerKCF (Generic) |  | 27813 | // TrackerKCF (Generic)
| 27862 | //================================================================================ |  | 27814 | //================================================================================
| 27863 |  |  | 27815 |
| 27864 | // GetSet (TrackerKCF) |  | 27816 | // GetSet (TrackerKCF)
| 27865 |  |  | 27817 |
| 27866 |  |  | 27818 |
| 27867 |  |  | 27819 |
| 27868 | // Methods (TrackerKCF) |  | 27820 | // Methods (TrackerKCF)
| 27869 |  |  | 27821 |
| 27870 | static PyObject* pyopencv_cv_TrackerKCF_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 27822 | static PyObject* pyopencv_cv_TrackerKCF_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 27871 | { |  | 27823 | {
| 27872 | using namespace cv; |  | 27824 | using namespace cv;
| 27873 |  |  | 27825 |
| 27874 | PyObject* pyobj_parameters = NULL; |  | 27826 | PyObject* pyobj_parameters = NULL;
| 27875 | cv::TrackerKCF::Params parameters=TrackerKCF::Params(); |  | 27827 | cv::TrackerKCF::Params parameters=TrackerKCF::Params();
| 27876 | Ptr<TrackerKCF> retval; |  | 27828 | Ptr<TrackerKCF> retval;
| 27877 |  |  | 27829 |
| 27878 | const char* keywords[] = { "parameters", NULL }; |  | 27830 | const char* keywords[] = { "parameters", NULL };
| 27879 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerKCF.create", (char**)keywords, &pyobj_parameters) && |  | 27831 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerKCF.create", (char**)keywords, &pyobj_parameters) &&
| 27880 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 27832 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 27881 | { |  | 27833 | {
| 27882 | ERRWRAP2(retval = cv::TrackerKCF::create(parameters)); |  | 27834 | ERRWRAP2(retval = cv::TrackerKCF::create(parameters));
| 27883 | return pyopencv_from(retval); |  | 27835 | return pyopencv_from(retval);
| 27884 | } |  | 27836 | }
| 27885 |  |  | 27837 |
| 27886 | return NULL; |  | 27838 | return NULL;
| 27887 | } |  | 27839 | }
| 27888 |  |  | 27840 |
| 27889 |  |  | 27841 |
| 27890 |  |  | 27842 |
| 27891 | // Tables (TrackerKCF) |  | 27843 | // Tables (TrackerKCF)
| 27892 |  |  | 27844 |
| 27893 | static PyGetSetDef pyopencv_TrackerKCF_getseters[] = |  | 27845 | static PyGetSetDef pyopencv_TrackerKCF_getseters[] =
| 27894 | { |  | 27846 | {
| 27895 | {NULL} /* Sentinel */ |  | 27847 | {NULL} /* Sentinel */
| 27896 | }; |  | 27848 | };
| 27897 |  |  | 27849 |
| 27898 | static PyMethodDef pyopencv_TrackerKCF_methods[] = |  | 27850 | static PyMethodDef pyopencv_TrackerKCF_methods[] =
| 27899 | { |  | 27851 | {
| 27900 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerKCF_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Create KCF tracker instance\n. @param parameters KCF parameters TrackerKCF::Params"}, |  | 27852 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerKCF_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Create KCF tracker instance\n. @param parameters KCF parameters TrackerKCF::Params"},
| 27901 |  |  | 27853 |
| 27902 | {NULL, NULL} |  | 27854 | {NULL, NULL}
| 27903 | }; |  | 27855 | };
| 27904 |  |  | 27856 |
| 27905 | // Converter (TrackerKCF) |  | 27857 | // Converter (TrackerKCF)
| 27906 |  |  | 27858 |
| 27907 | template<> |  | 27859 | template<>
| 27908 | struct PyOpenCV_Converter< Ptr<cv::TrackerKCF> > |  | 27860 | struct PyOpenCV_Converter< Ptr<cv::TrackerKCF> >
| 27909 | { |  | 27861 | {
| 27910 | static PyObject* from(const Ptr<cv::TrackerKCF>& r) |  | 27862 | static PyObject* from(const Ptr<cv::TrackerKCF>& r)
| 27911 | { |  | 27863 | {
| 27912 | return pyopencv_TrackerKCF_Instance(r); |  | 27864 | return pyopencv_TrackerKCF_Instance(r);
| 27913 | } |  | 27865 | }
| 27914 | static bool to(PyObject* src, Ptr<cv::TrackerKCF>& dst, const ArgInfo& info) |  | 27866 | static bool to(PyObject* src, Ptr<cv::TrackerKCF>& dst, const ArgInfo& info)
| 27915 | { |  | 27867 | {
| 27916 | if(!src || src == Py_None) |  | 27868 | if(!src || src == Py_None)
| 27917 | return true; |  | 27869 | return true;
| 27918 | Ptr<cv::TrackerKCF> * dst_; |  | 27870 | Ptr<cv::TrackerKCF> * dst_;
| 27919 | if (pyopencv_TrackerKCF_getp(src, dst_)) |  | 27871 | if (pyopencv_TrackerKCF_getp(src, dst_))
| 27920 | { |  | 27872 | {
| 27921 | dst = *dst_; |  | 27873 | dst = *dst_;
| 27922 | return true; |  | 27874 | return true;
| 27923 | } |  | 27875 | }
| 27924 |  |  | 27876 |
| 27925 | failmsg("Expected Ptr<cv::TrackerKCF> for argument '%s'", info.name); |  | 27877 | failmsg("Expected Ptr<cv::TrackerKCF> for argument '%s'", info.name);
| 27926 | return false; |  | 27878 | return false;
| 27927 | } |  | 27879 | }
| 27928 | }; |  | 27880 | };
| 27929 |  |  | 27881 |
| 27930 | //================================================================================ |  | 27882 | //================================================================================
| 27931 | // TrackerKCF_Params (Generic) |  | 27883 | // TrackerKCF_Params (Generic)
| 27932 | //================================================================================ |  | 27884 | //================================================================================
| 27933 |  |  | 27885 |
| 27934 | // GetSet (TrackerKCF_Params) |  | 27886 | // GetSet (TrackerKCF_Params)
| 27935 |  |  | 27887 |
| 27936 |  |  | 27888 |
| 27937 | static PyObject* pyopencv_TrackerKCF_Params_get_compress_feature(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27889 | static PyObject* pyopencv_TrackerKCF_Params_get_compress_feature(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 27938 | { |  | 27890 | {
| 27939 | return pyopencv_from(p->v.compress_feature); |  | 27891 | return pyopencv_from(p->v.compress_feature);
| 27940 | } |  | 27892 | }
| 27941 |  |  | 27893 |
| 27942 | static int pyopencv_TrackerKCF_Params_set_compress_feature(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27894 | static int pyopencv_TrackerKCF_Params_set_compress_feature(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 27943 | { |  | 27895 | {
| 27944 | if (!value) |  | 27896 | if (!value)
| 27945 | { |  | 27897 | {
| 27946 | PyErr_SetString(PyExc_TypeError, "Cannot delete the compress_feature attribute"); |  | 27898 | PyErr_SetString(PyExc_TypeError, "Cannot delete the compress_feature attribute");
| 27947 | return -1; |  | 27899 | return -1;
| 27948 | } |  | 27900 | }
| 27949 | return pyopencv_to_safe(value, p->v.compress_feature, ArgInfo("value", 0)) ? 0 : -1; |  | 27901 | return pyopencv_to_safe(value, p->v.compress_feature, ArgInfo("value", 0)) ? 0 : -1;
| 27950 | } |  | 27902 | }
| 27951 |  |  | 27903 |
| 27952 | static PyObject* pyopencv_TrackerKCF_Params_get_compressed_size(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27904 | static PyObject* pyopencv_TrackerKCF_Params_get_compressed_size(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 27953 | { |  | 27905 | {
| 27954 | return pyopencv_from(p->v.compressed_size); |  | 27906 | return pyopencv_from(p->v.compressed_size);
| 27955 | } |  | 27907 | }
| 27956 |  |  | 27908 |
| 27957 | static int pyopencv_TrackerKCF_Params_set_compressed_size(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27909 | static int pyopencv_TrackerKCF_Params_set_compressed_size(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 27958 | { |  | 27910 | {
| 27959 | if (!value) |  | 27911 | if (!value)
| 27960 | { |  | 27912 | {
| 27961 | PyErr_SetString(PyExc_TypeError, "Cannot delete the compressed_size attribute"); |  | 27913 | PyErr_SetString(PyExc_TypeError, "Cannot delete the compressed_size attribute");
| 27962 | return -1; |  | 27914 | return -1;
| 27963 | } |  | 27915 | }
| 27964 | return pyopencv_to_safe(value, p->v.compressed_size, ArgInfo("value", 0)) ? 0 : -1; |  | 27916 | return pyopencv_to_safe(value, p->v.compressed_size, ArgInfo("value", 0)) ? 0 : -1;
| 27965 | } |  | 27917 | }
| 27966 |  |  | 27918 |
| 27967 | static PyObject* pyopencv_TrackerKCF_Params_get_desc_npca(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27919 | static PyObject* pyopencv_TrackerKCF_Params_get_desc_npca(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 27968 | { |  | 27920 | {
| 27969 | return pyopencv_from(p->v.desc_npca); |  | 27921 | return pyopencv_from(p->v.desc_npca);
| 27970 | } |  | 27922 | }
| 27971 |  |  | 27923 |
| 27972 | static int pyopencv_TrackerKCF_Params_set_desc_npca(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27924 | static int pyopencv_TrackerKCF_Params_set_desc_npca(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 27973 | { |  | 27925 | {
| 27974 | if (!value) |  | 27926 | if (!value)
| 27975 | { |  | 27927 | {
| 27976 | PyErr_SetString(PyExc_TypeError, "Cannot delete the desc_npca attribute"); |  | 27928 | PyErr_SetString(PyExc_TypeError, "Cannot delete the desc_npca attribute");
| 27977 | return -1; |  | 27929 | return -1;
| 27978 | } |  | 27930 | }
| 27979 | return pyopencv_to_safe(value, p->v.desc_npca, ArgInfo("value", 0)) ? 0 : -1; |  | 27931 | return pyopencv_to_safe(value, p->v.desc_npca, ArgInfo("value", 0)) ? 0 : -1;
| 27980 | } |  | 27932 | }
| 27981 |  |  | 27933 |
| 27982 | static PyObject* pyopencv_TrackerKCF_Params_get_desc_pca(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27934 | static PyObject* pyopencv_TrackerKCF_Params_get_desc_pca(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 27983 | { |  | 27935 | {
| 27984 | return pyopencv_from(p->v.desc_pca); |  | 27936 | return pyopencv_from(p->v.desc_pca);
| 27985 | } |  | 27937 | }
| 27986 |  |  | 27938 |
| 27987 | static int pyopencv_TrackerKCF_Params_set_desc_pca(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27939 | static int pyopencv_TrackerKCF_Params_set_desc_pca(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 27988 | { |  | 27940 | {
| 27989 | if (!value) |  | 27941 | if (!value)
| 27990 | { |  | 27942 | {
| 27991 | PyErr_SetString(PyExc_TypeError, "Cannot delete the desc_pca attribute"); |  | 27943 | PyErr_SetString(PyExc_TypeError, "Cannot delete the desc_pca attribute");
| 27992 | return -1; |  | 27944 | return -1;
| 27993 | } |  | 27945 | }
| 27994 | return pyopencv_to_safe(value, p->v.desc_pca, ArgInfo("value", 0)) ? 0 : -1; |  | 27946 | return pyopencv_to_safe(value, p->v.desc_pca, ArgInfo("value", 0)) ? 0 : -1;
| 27995 | } |  | 27947 | }
| 27996 |  |  | 27948 |
| 27997 | static PyObject* pyopencv_TrackerKCF_Params_get_detect_thresh(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27949 | static PyObject* pyopencv_TrackerKCF_Params_get_detect_thresh(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 27998 | { |  | 27950 | {
| 27999 | return pyopencv_from(p->v.detect_thresh); |  | 27951 | return pyopencv_from(p->v.detect_thresh);
| 28000 | } |  | 27952 | }
| 28001 |  |  | 27953 |
| 28002 | static int pyopencv_TrackerKCF_Params_set_detect_thresh(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27954 | static int pyopencv_TrackerKCF_Params_set_detect_thresh(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28003 | { |  | 27955 | {
| 28004 | if (!value) |  | 27956 | if (!value)
| 28005 | { |  | 27957 | {
| 28006 | PyErr_SetString(PyExc_TypeError, "Cannot delete the detect_thresh attribute"); |  | 27958 | PyErr_SetString(PyExc_TypeError, "Cannot delete the detect_thresh attribute");
| 28007 | return -1; |  | 27959 | return -1;
| 28008 | } |  | 27960 | }
| 28009 | return pyopencv_to_safe(value, p->v.detect_thresh, ArgInfo("value", 0)) ? 0 : -1; |  | 27961 | return pyopencv_to_safe(value, p->v.detect_thresh, ArgInfo("value", 0)) ? 0 : -1;
| 28010 | } |  | 27962 | }
| 28011 |  |  | 27963 |
| 28012 | static PyObject* pyopencv_TrackerKCF_Params_get_interp_factor(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27964 | static PyObject* pyopencv_TrackerKCF_Params_get_interp_factor(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28013 | { |  | 27965 | {
| 28014 | return pyopencv_from(p->v.interp_factor); |  | 27966 | return pyopencv_from(p->v.interp_factor);
| 28015 | } |  | 27967 | }
| 28016 |  |  | 27968 |
| 28017 | static int pyopencv_TrackerKCF_Params_set_interp_factor(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27969 | static int pyopencv_TrackerKCF_Params_set_interp_factor(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28018 | { |  | 27970 | {
| 28019 | if (!value) |  | 27971 | if (!value)
| 28020 | { |  | 27972 | {
| 28021 | PyErr_SetString(PyExc_TypeError, "Cannot delete the interp_factor attribute"); |  | 27973 | PyErr_SetString(PyExc_TypeError, "Cannot delete the interp_factor attribute");
| 28022 | return -1; |  | 27974 | return -1;
| 28023 | } |  | 27975 | }
| 28024 | return pyopencv_to_safe(value, p->v.interp_factor, ArgInfo("value", 0)) ? 0 : -1; |  | 27976 | return pyopencv_to_safe(value, p->v.interp_factor, ArgInfo("value", 0)) ? 0 : -1;
| 28025 | } |  | 27977 | }
| 28026 |  |  | 27978 |
| 28027 | static PyObject* pyopencv_TrackerKCF_Params_get_lambda(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27979 | static PyObject* pyopencv_TrackerKCF_Params_get_lambda(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28028 | { |  | 27980 | {
| 28029 | return pyopencv_from(p->v.lambda); |  | 27981 | return pyopencv_from(p->v.lambda);
| 28030 | } |  | 27982 | }
| 28031 |  |  | 27983 |
| 28032 | static int pyopencv_TrackerKCF_Params_set_lambda(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27984 | static int pyopencv_TrackerKCF_Params_set_lambda(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28033 | { |  | 27985 | {
| 28034 | if (!value) |  | 27986 | if (!value)
| 28035 | { |  | 27987 | {
| 28036 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lambda attribute"); |  | 27988 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lambda attribute");
| 28037 | return -1; |  | 27989 | return -1;
| 28038 | } |  | 27990 | }
| 28039 | return pyopencv_to_safe(value, p->v.lambda, ArgInfo("value", 0)) ? 0 : -1; |  | 27991 | return pyopencv_to_safe(value, p->v.lambda, ArgInfo("value", 0)) ? 0 : -1;
| 28040 | } |  | 27992 | }
| 28041 |  |  | 27993 |
| 28042 | static PyObject* pyopencv_TrackerKCF_Params_get_max_patch_size(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 27994 | static PyObject* pyopencv_TrackerKCF_Params_get_max_patch_size(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28043 | { |  | 27995 | {
| 28044 | return pyopencv_from(p->v.max_patch_size); |  | 27996 | return pyopencv_from(p->v.max_patch_size);
| 28045 | } |  | 27997 | }
| 28046 |  |  | 27998 |
| 28047 | static int pyopencv_TrackerKCF_Params_set_max_patch_size(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 27999 | static int pyopencv_TrackerKCF_Params_set_max_patch_size(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28048 | { |  | 28000 | {
| 28049 | if (!value) |  | 28001 | if (!value)
| 28050 | { |  | 28002 | {
| 28051 | PyErr_SetString(PyExc_TypeError, "Cannot delete the max_patch_size attribute"); |  | 28003 | PyErr_SetString(PyExc_TypeError, "Cannot delete the max_patch_size attribute");
| 28052 | return -1; |  | 28004 | return -1;
| 28053 | } |  | 28005 | }
| 28054 | return pyopencv_to_safe(value, p->v.max_patch_size, ArgInfo("value", 0)) ? 0 : -1; |  | 28006 | return pyopencv_to_safe(value, p->v.max_patch_size, ArgInfo("value", 0)) ? 0 : -1;
| 28055 | } |  | 28007 | }
| 28056 |  |  | 28008 |
| 28057 | static PyObject* pyopencv_TrackerKCF_Params_get_output_sigma_factor(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 28009 | static PyObject* pyopencv_TrackerKCF_Params_get_output_sigma_factor(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28058 | { |  | 28010 | {
| 28059 | return pyopencv_from(p->v.output_sigma_factor); |  | 28011 | return pyopencv_from(p->v.output_sigma_factor);
| 28060 | } |  | 28012 | }
| 28061 |  |  | 28013 |
| 28062 | static int pyopencv_TrackerKCF_Params_set_output_sigma_factor(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 28014 | static int pyopencv_TrackerKCF_Params_set_output_sigma_factor(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28063 | { |  | 28015 | {
| 28064 | if (!value) |  | 28016 | if (!value)
| 28065 | { |  | 28017 | {
| 28066 | PyErr_SetString(PyExc_TypeError, "Cannot delete the output_sigma_factor attribute"); |  | 28018 | PyErr_SetString(PyExc_TypeError, "Cannot delete the output_sigma_factor attribute");
| 28067 | return -1; |  | 28019 | return -1;
| 28068 | } |  | 28020 | }
| 28069 | return pyopencv_to_safe(value, p->v.output_sigma_factor, ArgInfo("value", 0)) ? 0 : -1; |  | 28021 | return pyopencv_to_safe(value, p->v.output_sigma_factor, ArgInfo("value", 0)) ? 0 : -1;
| 28070 | } |  | 28022 | }
| 28071 |  |  | 28023 |
| 28072 | static PyObject* pyopencv_TrackerKCF_Params_get_pca_learning_rate(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 28024 | static PyObject* pyopencv_TrackerKCF_Params_get_pca_learning_rate(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28073 | { |  | 28025 | {
| 28074 | return pyopencv_from(p->v.pca_learning_rate); |  | 28026 | return pyopencv_from(p->v.pca_learning_rate);
| 28075 | } |  | 28027 | }
| 28076 |  |  | 28028 |
| 28077 | static int pyopencv_TrackerKCF_Params_set_pca_learning_rate(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 28029 | static int pyopencv_TrackerKCF_Params_set_pca_learning_rate(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28078 | { |  | 28030 | {
| 28079 | if (!value) |  | 28031 | if (!value)
| 28080 | { |  | 28032 | {
| 28081 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pca_learning_rate attribute"); |  | 28033 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pca_learning_rate attribute");
| 28082 | return -1; |  | 28034 | return -1;
| 28083 | } |  | 28035 | }
| 28084 | return pyopencv_to_safe(value, p->v.pca_learning_rate, ArgInfo("value", 0)) ? 0 : -1; |  | 28036 | return pyopencv_to_safe(value, p->v.pca_learning_rate, ArgInfo("value", 0)) ? 0 : -1;
| 28085 | } |  | 28037 | }
| 28086 |  |  | 28038 |
| 28087 | static PyObject* pyopencv_TrackerKCF_Params_get_resize(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 28039 | static PyObject* pyopencv_TrackerKCF_Params_get_resize(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28088 | { |  | 28040 | {
| 28089 | return pyopencv_from(p->v.resize); |  | 28041 | return pyopencv_from(p->v.resize);
| 28090 | } |  | 28042 | }
| 28091 |  |  | 28043 |
| 28092 | static int pyopencv_TrackerKCF_Params_set_resize(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 28044 | static int pyopencv_TrackerKCF_Params_set_resize(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28093 | { |  | 28045 | {
| 28094 | if (!value) |  | 28046 | if (!value)
| 28095 | { |  | 28047 | {
| 28096 | PyErr_SetString(PyExc_TypeError, "Cannot delete the resize attribute"); |  | 28048 | PyErr_SetString(PyExc_TypeError, "Cannot delete the resize attribute");
| 28097 | return -1; |  | 28049 | return -1;
| 28098 | } |  | 28050 | }
| 28099 | return pyopencv_to_safe(value, p->v.resize, ArgInfo("value", 0)) ? 0 : -1; |  | 28051 | return pyopencv_to_safe(value, p->v.resize, ArgInfo("value", 0)) ? 0 : -1;
| 28100 | } |  | 28052 | }
| 28101 |  |  | 28053 |
| 28102 | static PyObject* pyopencv_TrackerKCF_Params_get_sigma(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 28054 | static PyObject* pyopencv_TrackerKCF_Params_get_sigma(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28103 | { |  | 28055 | {
| 28104 | return pyopencv_from(p->v.sigma); |  | 28056 | return pyopencv_from(p->v.sigma);
| 28105 | } |  | 28057 | }
| 28106 |  |  | 28058 |
| 28107 | static int pyopencv_TrackerKCF_Params_set_sigma(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 28059 | static int pyopencv_TrackerKCF_Params_set_sigma(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28108 | { |  | 28060 | {
| 28109 | if (!value) |  | 28061 | if (!value)
| 28110 | { |  | 28062 | {
| 28111 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sigma attribute"); |  | 28063 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sigma attribute");
| 28112 | return -1; |  | 28064 | return -1;
| 28113 | } |  | 28065 | }
| 28114 | return pyopencv_to_safe(value, p->v.sigma, ArgInfo("value", 0)) ? 0 : -1; |  | 28066 | return pyopencv_to_safe(value, p->v.sigma, ArgInfo("value", 0)) ? 0 : -1;
| 28115 | } |  | 28067 | }
| 28116 |  |  | 28068 |
| 28117 | static PyObject* pyopencv_TrackerKCF_Params_get_split_coeff(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 28069 | static PyObject* pyopencv_TrackerKCF_Params_get_split_coeff(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28118 | { |  | 28070 | {
| 28119 | return pyopencv_from(p->v.split_coeff); |  | 28071 | return pyopencv_from(p->v.split_coeff);
| 28120 | } |  | 28072 | }
| 28121 |  |  | 28073 |
| 28122 | static int pyopencv_TrackerKCF_Params_set_split_coeff(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 28074 | static int pyopencv_TrackerKCF_Params_set_split_coeff(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28123 | { |  | 28075 | {
| 28124 | if (!value) |  | 28076 | if (!value)
| 28125 | { |  | 28077 | {
| 28126 | PyErr_SetString(PyExc_TypeError, "Cannot delete the split_coeff attribute"); |  | 28078 | PyErr_SetString(PyExc_TypeError, "Cannot delete the split_coeff attribute");
| 28127 | return -1; |  | 28079 | return -1;
| 28128 | } |  | 28080 | }
| 28129 | return pyopencv_to_safe(value, p->v.split_coeff, ArgInfo("value", 0)) ? 0 : -1; |  | 28081 | return pyopencv_to_safe(value, p->v.split_coeff, ArgInfo("value", 0)) ? 0 : -1;
| 28130 | } |  | 28082 | }
| 28131 |  |  | 28083 |
| 28132 | static PyObject* pyopencv_TrackerKCF_Params_get_wrap_kernel(pyopencv_TrackerKCF_Params_t* p, void *closure) |  | 28084 | static PyObject* pyopencv_TrackerKCF_Params_get_wrap_kernel(pyopencv_TrackerKCF_Params_t* p, void *closure)
| 28133 | { |  | 28085 | {
| 28134 | return pyopencv_from(p->v.wrap_kernel); |  | 28086 | return pyopencv_from(p->v.wrap_kernel);
| 28135 | } |  | 28087 | }
| 28136 |  |  | 28088 |
| 28137 | static int pyopencv_TrackerKCF_Params_set_wrap_kernel(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure) |  | 28089 | static int pyopencv_TrackerKCF_Params_set_wrap_kernel(pyopencv_TrackerKCF_Params_t* p, PyObject *value, void *closure)
| 28138 | { |  | 28090 | {
| 28139 | if (!value) |  | 28091 | if (!value)
| 28140 | { |  | 28092 | {
| 28141 | PyErr_SetString(PyExc_TypeError, "Cannot delete the wrap_kernel attribute"); |  | 28093 | PyErr_SetString(PyExc_TypeError, "Cannot delete the wrap_kernel attribute");
| 28142 | return -1; |  | 28094 | return -1;
| 28143 | } |  | 28095 | }
| 28144 | return pyopencv_to_safe(value, p->v.wrap_kernel, ArgInfo("value", 0)) ? 0 : -1; |  | 28096 | return pyopencv_to_safe(value, p->v.wrap_kernel, ArgInfo("value", 0)) ? 0 : -1;
| 28145 | } |  | 28097 | }
| 28146 |  |  | 28098 |
| 28147 |  |  | 28099 |
| 28148 | // Methods (TrackerKCF_Params) |  | 28100 | // Methods (TrackerKCF_Params)
| 28149 |  |  | 28101 |
| 28150 | static int pyopencv_cv_TrackerKCF_Params_TrackerKCF_Params(pyopencv_TrackerKCF_Params_t* self, PyObject* py_args, PyObject* kw) |  | 28102 | static int pyopencv_cv_TrackerKCF_Params_TrackerKCF_Params(pyopencv_TrackerKCF_Params_t* self, PyObject* py_args, PyObject* kw)
| 28151 | { |  | 28103 | {
| 28152 | using namespace cv; |  | 28104 | using namespace cv;
| 28153 |  |  | 28105 |
| 28154 |  |  | 28106 |
| 28155 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 28107 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 28156 | { |  | 28108 | {
| 28157 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerKCF::Params()); |  | 28109 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerKCF::Params());
| 28158 | return 0; |  | 28110 | return 0;
| 28159 | } |  | 28111 | }
| 28160 |  |  | 28112 |
| 28161 | return -1; |  | 28113 | return -1;
| 28162 | } |  | 28114 | }
| 28163 |  |  | 28115 |
| 28164 |  |  | 28116 |
| 28165 |  |  | 28117 |
| 28166 | // Tables (TrackerKCF_Params) |  | 28118 | // Tables (TrackerKCF_Params)
| 28167 |  |  | 28119 |
| 28168 | static PyGetSetDef pyopencv_TrackerKCF_Params_getseters[] = |  | 28120 | static PyGetSetDef pyopencv_TrackerKCF_Params_getseters[] =
| 28169 | { |  | 28121 | {
| 28170 | {(char*)"compress_feature", (getter)pyopencv_TrackerKCF_Params_get_compress_feature, (setter)pyopencv_TrackerKCF_Params_set_compress_feature, (char*)"compress_feature", NULL}, |  | 28122 | {(char*)"compress_feature", (getter)pyopencv_TrackerKCF_Params_get_compress_feature, (setter)pyopencv_TrackerKCF_Params_set_compress_feature, (char*)"compress_feature", NULL},
| 28171 | {(char*)"compressed_size", (getter)pyopencv_TrackerKCF_Params_get_compressed_size, (setter)pyopencv_TrackerKCF_Params_set_compressed_size, (char*)"compressed_size", NULL}, |  | 28123 | {(char*)"compressed_size", (getter)pyopencv_TrackerKCF_Params_get_compressed_size, (setter)pyopencv_TrackerKCF_Params_set_compressed_size, (char*)"compressed_size", NULL},
| 28172 | {(char*)"desc_npca", (getter)pyopencv_TrackerKCF_Params_get_desc_npca, (setter)pyopencv_TrackerKCF_Params_set_desc_npca, (char*)"desc_npca", NULL}, |  | 28124 | {(char*)"desc_npca", (getter)pyopencv_TrackerKCF_Params_get_desc_npca, (setter)pyopencv_TrackerKCF_Params_set_desc_npca, (char*)"desc_npca", NULL},
| 28173 | {(char*)"desc_pca", (getter)pyopencv_TrackerKCF_Params_get_desc_pca, (setter)pyopencv_TrackerKCF_Params_set_desc_pca, (char*)"desc_pca", NULL}, |  | 28125 | {(char*)"desc_pca", (getter)pyopencv_TrackerKCF_Params_get_desc_pca, (setter)pyopencv_TrackerKCF_Params_set_desc_pca, (char*)"desc_pca", NULL},
| 28174 | {(char*)"detect_thresh", (getter)pyopencv_TrackerKCF_Params_get_detect_thresh, (setter)pyopencv_TrackerKCF_Params_set_detect_thresh, (char*)"detect_thresh", NULL}, |  | 28126 | {(char*)"detect_thresh", (getter)pyopencv_TrackerKCF_Params_get_detect_thresh, (setter)pyopencv_TrackerKCF_Params_set_detect_thresh, (char*)"detect_thresh", NULL},
| 28175 | {(char*)"interp_factor", (getter)pyopencv_TrackerKCF_Params_get_interp_factor, (setter)pyopencv_TrackerKCF_Params_set_interp_factor, (char*)"interp_factor", NULL}, |  | 28127 | {(char*)"interp_factor", (getter)pyopencv_TrackerKCF_Params_get_interp_factor, (setter)pyopencv_TrackerKCF_Params_set_interp_factor, (char*)"interp_factor", NULL},
| 28176 | {(char*)"lambda_", (getter)pyopencv_TrackerKCF_Params_get_lambda, (setter)pyopencv_TrackerKCF_Params_set_lambda, (char*)"lambda_", NULL}, |  | 28128 | {(char*)"lambda_", (getter)pyopencv_TrackerKCF_Params_get_lambda, (setter)pyopencv_TrackerKCF_Params_set_lambda, (char*)"lambda_", NULL},
| 28177 | {(char*)"max_patch_size", (getter)pyopencv_TrackerKCF_Params_get_max_patch_size, (setter)pyopencv_TrackerKCF_Params_set_max_patch_size, (char*)"max_patch_size", NULL}, |  | 28129 | {(char*)"max_patch_size", (getter)pyopencv_TrackerKCF_Params_get_max_patch_size, (setter)pyopencv_TrackerKCF_Params_set_max_patch_size, (char*)"max_patch_size", NULL},
| 28178 | {(char*)"output_sigma_factor", (getter)pyopencv_TrackerKCF_Params_get_output_sigma_factor, (setter)pyopencv_TrackerKCF_Params_set_output_sigma_factor, (char*)"output_sigma_factor", NULL}, |  | 28130 | {(char*)"output_sigma_factor", (getter)pyopencv_TrackerKCF_Params_get_output_sigma_factor, (setter)pyopencv_TrackerKCF_Params_set_output_sigma_factor, (char*)"output_sigma_factor", NULL},
| 28179 | {(char*)"pca_learning_rate", (getter)pyopencv_TrackerKCF_Params_get_pca_learning_rate, (setter)pyopencv_TrackerKCF_Params_set_pca_learning_rate, (char*)"pca_learning_rate", NULL}, |  | 28131 | {(char*)"pca_learning_rate", (getter)pyopencv_TrackerKCF_Params_get_pca_learning_rate, (setter)pyopencv_TrackerKCF_Params_set_pca_learning_rate, (char*)"pca_learning_rate", NULL},
| 28180 | {(char*)"resize", (getter)pyopencv_TrackerKCF_Params_get_resize, (setter)pyopencv_TrackerKCF_Params_set_resize, (char*)"resize", NULL}, |  | 28132 | {(char*)"resize", (getter)pyopencv_TrackerKCF_Params_get_resize, (setter)pyopencv_TrackerKCF_Params_set_resize, (char*)"resize", NULL},
| 28181 | {(char*)"sigma", (getter)pyopencv_TrackerKCF_Params_get_sigma, (setter)pyopencv_TrackerKCF_Params_set_sigma, (char*)"sigma", NULL}, |  | 28133 | {(char*)"sigma", (getter)pyopencv_TrackerKCF_Params_get_sigma, (setter)pyopencv_TrackerKCF_Params_set_sigma, (char*)"sigma", NULL},
| 28182 | {(char*)"split_coeff", (getter)pyopencv_TrackerKCF_Params_get_split_coeff, (setter)pyopencv_TrackerKCF_Params_set_split_coeff, (char*)"split_coeff", NULL}, |  | 28134 | {(char*)"split_coeff", (getter)pyopencv_TrackerKCF_Params_get_split_coeff, (setter)pyopencv_TrackerKCF_Params_set_split_coeff, (char*)"split_coeff", NULL},
| 28183 | {(char*)"wrap_kernel", (getter)pyopencv_TrackerKCF_Params_get_wrap_kernel, (setter)pyopencv_TrackerKCF_Params_set_wrap_kernel, (char*)"wrap_kernel", NULL}, |  | 28135 | {(char*)"wrap_kernel", (getter)pyopencv_TrackerKCF_Params_get_wrap_kernel, (setter)pyopencv_TrackerKCF_Params_set_wrap_kernel, (char*)"wrap_kernel", NULL},
| 28184 | {NULL} /* Sentinel */ |  | 28136 | {NULL} /* Sentinel */
| 28185 | }; |  | 28137 | };
| 28186 |  |  | 28138 |
| 28187 | static PyMethodDef pyopencv_TrackerKCF_Params_methods[] = |  | 28139 | static PyMethodDef pyopencv_TrackerKCF_Params_methods[] =
| 28188 | { |  | 28140 | {
| 28189 |  |  | 28141 |
| 28190 | {NULL, NULL} |  | 28142 | {NULL, NULL}
| 28191 | }; |  | 28143 | };
| 28192 |  |  | 28144 |
| 28193 | // Converter (TrackerKCF_Params) |  | 28145 | // Converter (TrackerKCF_Params)
| 28194 |  |  | 28146 |
| 28195 | template<> |  | 28147 | template<>
| 28196 | struct PyOpenCV_Converter< cv::TrackerKCF::Params > |  | 28148 | struct PyOpenCV_Converter< cv::TrackerKCF::Params >
| 28197 | { |  | 28149 | {
| 28198 | static PyObject* from(const cv::TrackerKCF::Params& r) |  | 28150 | static PyObject* from(const cv::TrackerKCF::Params& r)
| 28199 | { |  | 28151 | {
| 28200 | return pyopencv_TrackerKCF_Params_Instance(r); |  | 28152 | return pyopencv_TrackerKCF_Params_Instance(r);
| 28201 | } |  | 28153 | }
| 28202 | static bool to(PyObject* src, cv::TrackerKCF::Params& dst, const ArgInfo& info) |  | 28154 | static bool to(PyObject* src, cv::TrackerKCF::Params& dst, const ArgInfo& info)
| 28203 | { |  | 28155 | {
| 28204 | if(!src || src == Py_None) |  | 28156 | if(!src || src == Py_None)
| 28205 | return true; |  | 28157 | return true;
| 28206 | cv::TrackerKCF::Params * dst_; |  | 28158 | cv::TrackerKCF::Params * dst_;
| 28207 | if (pyopencv_TrackerKCF_Params_getp(src, dst_)) |  | 28159 | if (pyopencv_TrackerKCF_Params_getp(src, dst_))
| 28208 | { |  | 28160 | {
| 28209 | dst = *dst_; |  | 28161 | dst = *dst_;
| 28210 | return true; |  | 28162 | return true;
| 28211 | } |  | 28163 | }
| 28212 |  |  | 28164 |
| 28213 | failmsg("Expected cv::TrackerKCF::Params for argument '%s'", info.name); |  | 28165 | failmsg("Expected cv::TrackerKCF::Params for argument '%s'", info.name);
| 28214 | return false; |  | 28166 | return false;
| 28215 | } |  | 28167 | }
| 28216 | }; |  | 28168 | };
| 28217 |  |  | 28169 |
| 28218 | //================================================================================ |  | 28170 | //================================================================================
| 28219 | // TrackerMIL (Generic) |  | 28171 | // TrackerMIL (Generic)
| 28220 | //================================================================================ |  | 28172 | //================================================================================
| 28221 |  |  | 28173 |
| 28222 | // GetSet (TrackerMIL) |  | 28174 | // GetSet (TrackerMIL)
| 28223 |  |  | 28175 |
| 28224 |  |  | 28176 |
| 28225 |  |  | 28177 |
| 28226 | // Methods (TrackerMIL) |  | 28178 | // Methods (TrackerMIL)
| 28227 |  |  | 28179 |
| 28228 | static PyObject* pyopencv_cv_TrackerMIL_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 28180 | static PyObject* pyopencv_cv_TrackerMIL_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 28229 | { |  | 28181 | {
| 28230 | using namespace cv; |  | 28182 | using namespace cv;
| 28231 |  |  | 28183 |
| 28232 | PyObject* pyobj_parameters = NULL; |  | 28184 | PyObject* pyobj_parameters = NULL;
| 28233 | cv::TrackerMIL::Params parameters=TrackerMIL::Params(); |  | 28185 | cv::TrackerMIL::Params parameters=TrackerMIL::Params();
| 28234 | Ptr<TrackerMIL> retval; |  | 28186 | Ptr<TrackerMIL> retval;
| 28235 |  |  | 28187 |
| 28236 | const char* keywords[] = { "parameters", NULL }; |  | 28188 | const char* keywords[] = { "parameters", NULL };
| 28237 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerMIL.create", (char**)keywords, &pyobj_parameters) && |  | 28189 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerMIL.create", (char**)keywords, &pyobj_parameters) &&
| 28238 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 28190 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 28239 | { |  | 28191 | {
| 28240 | ERRWRAP2(retval = cv::TrackerMIL::create(parameters)); |  | 28192 | ERRWRAP2(retval = cv::TrackerMIL::create(parameters));
| 28241 | return pyopencv_from(retval); |  | 28193 | return pyopencv_from(retval);
| 28242 | } |  | 28194 | }
| 28243 |  |  | 28195 |
| 28244 | return NULL; |  | 28196 | return NULL;
| 28245 | } |  | 28197 | }
| 28246 |  |  | 28198 |
| 28247 |  |  | 28199 |
| 28248 |  |  | 28200 |
| 28249 | // Tables (TrackerMIL) |  | 28201 | // Tables (TrackerMIL)
| 28250 |  |  | 28202 |
| 28251 | static PyGetSetDef pyopencv_TrackerMIL_getseters[] = |  | 28203 | static PyGetSetDef pyopencv_TrackerMIL_getseters[] =
| 28252 | { |  | 28204 | {
| 28253 | {NULL} /* Sentinel */ |  | 28205 | {NULL} /* Sentinel */
| 28254 | }; |  | 28206 | };
| 28255 |  |  | 28207 |
| 28256 | static PyMethodDef pyopencv_TrackerMIL_methods[] = |  | 28208 | static PyMethodDef pyopencv_TrackerMIL_methods[] =
| 28257 | { |  | 28209 | {
| 28258 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerMIL_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Create MIL tracker instance\n. * @param parameters MIL parameters TrackerMIL::Params"}, |  | 28210 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerMIL_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Create MIL tracker instance\n. * @param parameters MIL parameters TrackerMIL::Params"},
| 28259 |  |  | 28211 |
| 28260 | {NULL, NULL} |  | 28212 | {NULL, NULL}
| 28261 | }; |  | 28213 | };
| 28262 |  |  | 28214 |
| 28263 | // Converter (TrackerMIL) |  | 28215 | // Converter (TrackerMIL)
| 28264 |  |  | 28216 |
| 28265 | template<> |  | 28217 | template<>
| 28266 | struct PyOpenCV_Converter< Ptr<cv::TrackerMIL> > |  | 28218 | struct PyOpenCV_Converter< Ptr<cv::TrackerMIL> >
| 28267 | { |  | 28219 | {
| 28268 | static PyObject* from(const Ptr<cv::TrackerMIL>& r) |  | 28220 | static PyObject* from(const Ptr<cv::TrackerMIL>& r)
| 28269 | { |  | 28221 | {
| 28270 | return pyopencv_TrackerMIL_Instance(r); |  | 28222 | return pyopencv_TrackerMIL_Instance(r);
| 28271 | } |  | 28223 | }
| 28272 | static bool to(PyObject* src, Ptr<cv::TrackerMIL>& dst, const ArgInfo& info) |  | 28224 | static bool to(PyObject* src, Ptr<cv::TrackerMIL>& dst, const ArgInfo& info)
| 28273 | { |  | 28225 | {
| 28274 | if(!src || src == Py_None) |  | 28226 | if(!src || src == Py_None)
| 28275 | return true; |  | 28227 | return true;
| 28276 | Ptr<cv::TrackerMIL> * dst_; |  | 28228 | Ptr<cv::TrackerMIL> * dst_;
| 28277 | if (pyopencv_TrackerMIL_getp(src, dst_)) |  | 28229 | if (pyopencv_TrackerMIL_getp(src, dst_))
| 28278 | { |  | 28230 | {
| 28279 | dst = *dst_; |  | 28231 | dst = *dst_;
| 28280 | return true; |  | 28232 | return true;
| 28281 | } |  | 28233 | }
| 28282 |  |  | 28234 |
| 28283 | failmsg("Expected Ptr<cv::TrackerMIL> for argument '%s'", info.name); |  | 28235 | failmsg("Expected Ptr<cv::TrackerMIL> for argument '%s'", info.name);
| 28284 | return false; |  | 28236 | return false;
| 28285 | } |  | 28237 | }
| 28286 | }; |  | 28238 | };
| 28287 |  |  | 28239 |
| 28288 | //================================================================================ |  | 28240 | //================================================================================
| 28289 | // TrackerMIL_Params (Generic) |  | 28241 | // TrackerMIL_Params (Generic)
| 28290 | //================================================================================ |  | 28242 | //================================================================================
| 28291 |  |  | 28243 |
| 28292 | // GetSet (TrackerMIL_Params) |  | 28244 | // GetSet (TrackerMIL_Params)
| 28293 |  |  | 28245 |
| 28294 |  |  | 28246 |
| 28295 | static PyObject* pyopencv_TrackerMIL_Params_get_featureSetNumFeatures(pyopencv_TrackerMIL_Params_t* p, void *closure) |  | 28247 | static PyObject* pyopencv_TrackerMIL_Params_get_featureSetNumFeatures(pyopencv_TrackerMIL_Params_t* p, void *closure)
| 28296 | { |  | 28248 | {
| 28297 | return pyopencv_from(p->v.featureSetNumFeatures); |  | 28249 | return pyopencv_from(p->v.featureSetNumFeatures);
| 28298 | } |  | 28250 | }
| 28299 |  |  | 28251 |
| 28300 | static int pyopencv_TrackerMIL_Params_set_featureSetNumFeatures(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure) |  | 28252 | static int pyopencv_TrackerMIL_Params_set_featureSetNumFeatures(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure)
| 28301 | { |  | 28253 | {
| 28302 | if (!value) |  | 28254 | if (!value)
| 28303 | { |  | 28255 | {
| 28304 | PyErr_SetString(PyExc_TypeError, "Cannot delete the featureSetNumFeatures attribute"); |  | 28256 | PyErr_SetString(PyExc_TypeError, "Cannot delete the featureSetNumFeatures attribute");
| 28305 | return -1; |  | 28257 | return -1;
| 28306 | } |  | 28258 | }
| 28307 | return pyopencv_to_safe(value, p->v.featureSetNumFeatures, ArgInfo("value", 0)) ? 0 : -1; |  | 28259 | return pyopencv_to_safe(value, p->v.featureSetNumFeatures, ArgInfo("value", 0)) ? 0 : -1;
| 28308 | } |  | 28260 | }
| 28309 |  |  | 28261 |
| 28310 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerInitInRadius(pyopencv_TrackerMIL_Params_t* p, void *closure) |  | 28262 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerInitInRadius(pyopencv_TrackerMIL_Params_t* p, void *closure)
| 28311 | { |  | 28263 | {
| 28312 | return pyopencv_from(p->v.samplerInitInRadius); |  | 28264 | return pyopencv_from(p->v.samplerInitInRadius);
| 28313 | } |  | 28265 | }
| 28314 |  |  | 28266 |
| 28315 | static int pyopencv_TrackerMIL_Params_set_samplerInitInRadius(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure) |  | 28267 | static int pyopencv_TrackerMIL_Params_set_samplerInitInRadius(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure)
| 28316 | { |  | 28268 | {
| 28317 | if (!value) |  | 28269 | if (!value)
| 28318 | { |  | 28270 | {
| 28319 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerInitInRadius attribute"); |  | 28271 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerInitInRadius attribute");
| 28320 | return -1; |  | 28272 | return -1;
| 28321 | } |  | 28273 | }
| 28322 | return pyopencv_to_safe(value, p->v.samplerInitInRadius, ArgInfo("value", 0)) ? 0 : -1; |  | 28274 | return pyopencv_to_safe(value, p->v.samplerInitInRadius, ArgInfo("value", 0)) ? 0 : -1;
| 28323 | } |  | 28275 | }
| 28324 |  |  | 28276 |
| 28325 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerInitMaxNegNum(pyopencv_TrackerMIL_Params_t* p, void *closure) |  | 28277 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerInitMaxNegNum(pyopencv_TrackerMIL_Params_t* p, void *closure)
| 28326 | { |  | 28278 | {
| 28327 | return pyopencv_from(p->v.samplerInitMaxNegNum); |  | 28279 | return pyopencv_from(p->v.samplerInitMaxNegNum);
| 28328 | } |  | 28280 | }
| 28329 |  |  | 28281 |
| 28330 | static int pyopencv_TrackerMIL_Params_set_samplerInitMaxNegNum(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure) |  | 28282 | static int pyopencv_TrackerMIL_Params_set_samplerInitMaxNegNum(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure)
| 28331 | { |  | 28283 | {
| 28332 | if (!value) |  | 28284 | if (!value)
| 28333 | { |  | 28285 | {
| 28334 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerInitMaxNegNum attribute"); |  | 28286 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerInitMaxNegNum attribute");
| 28335 | return -1; |  | 28287 | return -1;
| 28336 | } |  | 28288 | }
| 28337 | return pyopencv_to_safe(value, p->v.samplerInitMaxNegNum, ArgInfo("value", 0)) ? 0 : -1; |  | 28289 | return pyopencv_to_safe(value, p->v.samplerInitMaxNegNum, ArgInfo("value", 0)) ? 0 : -1;
| 28338 | } |  | 28290 | }
| 28339 |  |  | 28291 |
| 28340 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerSearchWinSize(pyopencv_TrackerMIL_Params_t* p, void *closure) |  | 28292 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerSearchWinSize(pyopencv_TrackerMIL_Params_t* p, void *closure)
| 28341 | { |  | 28293 | {
| 28342 | return pyopencv_from(p->v.samplerSearchWinSize); |  | 28294 | return pyopencv_from(p->v.samplerSearchWinSize);
| 28343 | } |  | 28295 | }
| 28344 |  |  | 28296 |
| 28345 | static int pyopencv_TrackerMIL_Params_set_samplerSearchWinSize(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure) |  | 28297 | static int pyopencv_TrackerMIL_Params_set_samplerSearchWinSize(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure)
| 28346 | { |  | 28298 | {
| 28347 | if (!value) |  | 28299 | if (!value)
| 28348 | { |  | 28300 | {
| 28349 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerSearchWinSize attribute"); |  | 28301 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerSearchWinSize attribute");
| 28350 | return -1; |  | 28302 | return -1;
| 28351 | } |  | 28303 | }
| 28352 | return pyopencv_to_safe(value, p->v.samplerSearchWinSize, ArgInfo("value", 0)) ? 0 : -1; |  | 28304 | return pyopencv_to_safe(value, p->v.samplerSearchWinSize, ArgInfo("value", 0)) ? 0 : -1;
| 28353 | } |  | 28305 | }
| 28354 |  |  | 28306 |
| 28355 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerTrackInRadius(pyopencv_TrackerMIL_Params_t* p, void *closure) |  | 28307 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerTrackInRadius(pyopencv_TrackerMIL_Params_t* p, void *closure)
| 28356 | { |  | 28308 | {
| 28357 | return pyopencv_from(p->v.samplerTrackInRadius); |  | 28309 | return pyopencv_from(p->v.samplerTrackInRadius);
| 28358 | } |  | 28310 | }
| 28359 |  |  | 28311 |
| 28360 | static int pyopencv_TrackerMIL_Params_set_samplerTrackInRadius(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure) |  | 28312 | static int pyopencv_TrackerMIL_Params_set_samplerTrackInRadius(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure)
| 28361 | { |  | 28313 | {
| 28362 | if (!value) |  | 28314 | if (!value)
| 28363 | { |  | 28315 | {
| 28364 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerTrackInRadius attribute"); |  | 28316 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerTrackInRadius attribute");
| 28365 | return -1; |  | 28317 | return -1;
| 28366 | } |  | 28318 | }
| 28367 | return pyopencv_to_safe(value, p->v.samplerTrackInRadius, ArgInfo("value", 0)) ? 0 : -1; |  | 28319 | return pyopencv_to_safe(value, p->v.samplerTrackInRadius, ArgInfo("value", 0)) ? 0 : -1;
| 28368 | } |  | 28320 | }
| 28369 |  |  | 28321 |
| 28370 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerTrackMaxNegNum(pyopencv_TrackerMIL_Params_t* p, void *closure) |  | 28322 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerTrackMaxNegNum(pyopencv_TrackerMIL_Params_t* p, void *closure)
| 28371 | { |  | 28323 | {
| 28372 | return pyopencv_from(p->v.samplerTrackMaxNegNum); |  | 28324 | return pyopencv_from(p->v.samplerTrackMaxNegNum);
| 28373 | } |  | 28325 | }
| 28374 |  |  | 28326 |
| 28375 | static int pyopencv_TrackerMIL_Params_set_samplerTrackMaxNegNum(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure) |  | 28327 | static int pyopencv_TrackerMIL_Params_set_samplerTrackMaxNegNum(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure)
| 28376 | { |  | 28328 | {
| 28377 | if (!value) |  | 28329 | if (!value)
| 28378 | { |  | 28330 | {
| 28379 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerTrackMaxNegNum attribute"); |  | 28331 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerTrackMaxNegNum attribute");
| 28380 | return -1; |  | 28332 | return -1;
| 28381 | } |  | 28333 | }
| 28382 | return pyopencv_to_safe(value, p->v.samplerTrackMaxNegNum, ArgInfo("value", 0)) ? 0 : -1; |  | 28334 | return pyopencv_to_safe(value, p->v.samplerTrackMaxNegNum, ArgInfo("value", 0)) ? 0 : -1;
| 28383 | } |  | 28335 | }
| 28384 |  |  | 28336 |
| 28385 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerTrackMaxPosNum(pyopencv_TrackerMIL_Params_t* p, void *closure) |  | 28337 | static PyObject* pyopencv_TrackerMIL_Params_get_samplerTrackMaxPosNum(pyopencv_TrackerMIL_Params_t* p, void *closure)
| 28386 | { |  | 28338 | {
| 28387 | return pyopencv_from(p->v.samplerTrackMaxPosNum); |  | 28339 | return pyopencv_from(p->v.samplerTrackMaxPosNum);
| 28388 | } |  | 28340 | }
| 28389 |  |  | 28341 |
| 28390 | static int pyopencv_TrackerMIL_Params_set_samplerTrackMaxPosNum(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure) |  | 28342 | static int pyopencv_TrackerMIL_Params_set_samplerTrackMaxPosNum(pyopencv_TrackerMIL_Params_t* p, PyObject *value, void *closure)
| 28391 | { |  | 28343 | {
| 28392 | if (!value) |  | 28344 | if (!value)
| 28393 | { |  | 28345 | {
| 28394 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerTrackMaxPosNum attribute"); |  | 28346 | PyErr_SetString(PyExc_TypeError, "Cannot delete the samplerTrackMaxPosNum attribute");
| 28395 | return -1; |  | 28347 | return -1;
| 28396 | } |  | 28348 | }
| 28397 | return pyopencv_to_safe(value, p->v.samplerTrackMaxPosNum, ArgInfo("value", 0)) ? 0 : -1; |  | 28349 | return pyopencv_to_safe(value, p->v.samplerTrackMaxPosNum, ArgInfo("value", 0)) ? 0 : -1;
| 28398 | } |  | 28350 | }
| 28399 |  |  | 28351 |
| 28400 |  |  | 28352 |
| 28401 | // Methods (TrackerMIL_Params) |  | 28353 | // Methods (TrackerMIL_Params)
| 28402 |  |  | 28354 |
| 28403 | static int pyopencv_cv_TrackerMIL_Params_TrackerMIL_Params(pyopencv_TrackerMIL_Params_t* self, PyObject* py_args, PyObject* kw) |  | 28355 | static int pyopencv_cv_TrackerMIL_Params_TrackerMIL_Params(pyopencv_TrackerMIL_Params_t* self, PyObject* py_args, PyObject* kw)
| 28404 | { |  | 28356 | {
| 28405 | using namespace cv; |  | 28357 | using namespace cv;
| 28406 |  |  | 28358 |
| 28407 |  |  | 28359 |
| 28408 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 28360 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 28409 | { |  | 28361 | {
| 28410 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerMIL::Params()); |  | 28362 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerMIL::Params());
| 28411 | return 0; |  | 28363 | return 0;
| 28412 | } |  | 28364 | }
| 28413 |  |  | 28365 |
| 28414 | return -1; |  | 28366 | return -1;
| 28415 | } |  | 28367 | }
| 28416 |  |  | 28368 |
| 28417 |  |  | 28369 |
| 28418 |  |  | 28370 |
| 28419 | // Tables (TrackerMIL_Params) |  | 28371 | // Tables (TrackerMIL_Params)
| 28420 |  |  | 28372 |
| 28421 | static PyGetSetDef pyopencv_TrackerMIL_Params_getseters[] = |  | 28373 | static PyGetSetDef pyopencv_TrackerMIL_Params_getseters[] =
| 28422 | { |  | 28374 | {
| 28423 | {(char*)"featureSetNumFeatures", (getter)pyopencv_TrackerMIL_Params_get_featureSetNumFeatures, (setter)pyopencv_TrackerMIL_Params_set_featureSetNumFeatures, (char*)"featureSetNumFeatures", NULL}, |  | 28375 | {(char*)"featureSetNumFeatures", (getter)pyopencv_TrackerMIL_Params_get_featureSetNumFeatures, (setter)pyopencv_TrackerMIL_Params_set_featureSetNumFeatures, (char*)"featureSetNumFeatures", NULL},
| 28424 | {(char*)"samplerInitInRadius", (getter)pyopencv_TrackerMIL_Params_get_samplerInitInRadius, (setter)pyopencv_TrackerMIL_Params_set_samplerInitInRadius, (char*)"samplerInitInRadius", NULL}, |  | 28376 | {(char*)"samplerInitInRadius", (getter)pyopencv_TrackerMIL_Params_get_samplerInitInRadius, (setter)pyopencv_TrackerMIL_Params_set_samplerInitInRadius, (char*)"samplerInitInRadius", NULL},
| 28425 | {(char*)"samplerInitMaxNegNum", (getter)pyopencv_TrackerMIL_Params_get_samplerInitMaxNegNum, (setter)pyopencv_TrackerMIL_Params_set_samplerInitMaxNegNum, (char*)"samplerInitMaxNegNum", NULL}, |  | 28377 | {(char*)"samplerInitMaxNegNum", (getter)pyopencv_TrackerMIL_Params_get_samplerInitMaxNegNum, (setter)pyopencv_TrackerMIL_Params_set_samplerInitMaxNegNum, (char*)"samplerInitMaxNegNum", NULL},
| 28426 | {(char*)"samplerSearchWinSize", (getter)pyopencv_TrackerMIL_Params_get_samplerSearchWinSize, (setter)pyopencv_TrackerMIL_Params_set_samplerSearchWinSize, (char*)"samplerSearchWinSize", NULL}, |  | 28378 | {(char*)"samplerSearchWinSize", (getter)pyopencv_TrackerMIL_Params_get_samplerSearchWinSize, (setter)pyopencv_TrackerMIL_Params_set_samplerSearchWinSize, (char*)"samplerSearchWinSize", NULL},
| 28427 | {(char*)"samplerTrackInRadius", (getter)pyopencv_TrackerMIL_Params_get_samplerTrackInRadius, (setter)pyopencv_TrackerMIL_Params_set_samplerTrackInRadius, (char*)"samplerTrackInRadius", NULL}, |  | 28379 | {(char*)"samplerTrackInRadius", (getter)pyopencv_TrackerMIL_Params_get_samplerTrackInRadius, (setter)pyopencv_TrackerMIL_Params_set_samplerTrackInRadius, (char*)"samplerTrackInRadius", NULL},
| 28428 | {(char*)"samplerTrackMaxNegNum", (getter)pyopencv_TrackerMIL_Params_get_samplerTrackMaxNegNum, (setter)pyopencv_TrackerMIL_Params_set_samplerTrackMaxNegNum, (char*)"samplerTrackMaxNegNum", NULL}, |  | 28380 | {(char*)"samplerTrackMaxNegNum", (getter)pyopencv_TrackerMIL_Params_get_samplerTrackMaxNegNum, (setter)pyopencv_TrackerMIL_Params_set_samplerTrackMaxNegNum, (char*)"samplerTrackMaxNegNum", NULL},
| 28429 | {(char*)"samplerTrackMaxPosNum", (getter)pyopencv_TrackerMIL_Params_get_samplerTrackMaxPosNum, (setter)pyopencv_TrackerMIL_Params_set_samplerTrackMaxPosNum, (char*)"samplerTrackMaxPosNum", NULL}, |  | 28381 | {(char*)"samplerTrackMaxPosNum", (getter)pyopencv_TrackerMIL_Params_get_samplerTrackMaxPosNum, (setter)pyopencv_TrackerMIL_Params_set_samplerTrackMaxPosNum, (char*)"samplerTrackMaxPosNum", NULL},
| 28430 | {NULL} /* Sentinel */ |  | 28382 | {NULL} /* Sentinel */
| 28431 | }; |  | 28383 | };
| 28432 |  |  | 28384 |
| 28433 | static PyMethodDef pyopencv_TrackerMIL_Params_methods[] = |  | 28385 | static PyMethodDef pyopencv_TrackerMIL_Params_methods[] =
| 28434 | { |  | 28386 | {
| 28435 |  |  | 28387 |
| 28436 | {NULL, NULL} |  | 28388 | {NULL, NULL}
| 28437 | }; |  | 28389 | };
| 28438 |  |  | 28390 |
| 28439 | // Converter (TrackerMIL_Params) |  | 28391 | // Converter (TrackerMIL_Params)
| 28440 |  |  | 28392 |
| 28441 | template<> |  | 28393 | template<>
| 28442 | struct PyOpenCV_Converter< cv::TrackerMIL::Params > |  | 28394 | struct PyOpenCV_Converter< cv::TrackerMIL::Params >
| 28443 | { |  | 28395 | {
| 28444 | static PyObject* from(const cv::TrackerMIL::Params& r) |  | 28396 | static PyObject* from(const cv::TrackerMIL::Params& r)
| 28445 | { |  | 28397 | {
| 28446 | return pyopencv_TrackerMIL_Params_Instance(r); |  | 28398 | return pyopencv_TrackerMIL_Params_Instance(r);
| 28447 | } |  | 28399 | }
| 28448 | static bool to(PyObject* src, cv::TrackerMIL::Params& dst, const ArgInfo& info) |  | 28400 | static bool to(PyObject* src, cv::TrackerMIL::Params& dst, const ArgInfo& info)
| 28449 | { |  | 28401 | {
| 28450 | if(!src || src == Py_None) |  | 28402 | if(!src || src == Py_None)
| 28451 | return true; |  | 28403 | return true;
| 28452 | cv::TrackerMIL::Params * dst_; |  | 28404 | cv::TrackerMIL::Params * dst_;
| 28453 | if (pyopencv_TrackerMIL_Params_getp(src, dst_)) |  | 28405 | if (pyopencv_TrackerMIL_Params_getp(src, dst_))
| 28454 | { |  | 28406 | {
| 28455 | dst = *dst_; |  | 28407 | dst = *dst_;
| 28456 | return true; |  | 28408 | return true;
| 28457 | } |  | 28409 | }
| 28458 |  |  | 28410 |
| 28459 | failmsg("Expected cv::TrackerMIL::Params for argument '%s'", info.name); |  | 28411 | failmsg("Expected cv::TrackerMIL::Params for argument '%s'", info.name);
| 28460 | return false; |  | 28412 | return false;
| 28461 | } |  | 28413 | }
| 28462 | }; |  | 28414 | };
| 28463 |  |  | 28415 |
| 28464 | //================================================================================ |  | 28416 | //================================================================================
| 28465 | // TrackerNano (Generic) |  | 28417 | // TrackerNano (Generic)
| 28466 | //================================================================================ |  | 28418 | //================================================================================
| 28467 |  |  | 28419 |
| 28468 | // GetSet (TrackerNano) |  | 28420 | // GetSet (TrackerNano)
| 28469 |  |  | 28421 |
| 28470 |  |  | 28422 |
| 28471 |  |  | 28423 |
| 28472 | // Methods (TrackerNano) |  | 28424 | // Methods (TrackerNano)
| 28473 |  |  | 28425 |
| 28474 | static PyObject* pyopencv_cv_TrackerNano_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 28426 | static PyObject* pyopencv_cv_TrackerNano_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 28475 | { |  | 28427 | {
| 28476 | using namespace cv; |  | 28428 | using namespace cv;
| 28477 |  |  | 28429 |
| 28478 | pyPrepareArgumentConversionErrorsStorage(2); |  | 28430 | pyPrepareArgumentConversionErrorsStorage(2);
| 28479 |  |  | 28431 |
| 28480 | { |  | 28432 | {
| 28481 | PyObject* pyobj_parameters = NULL; |  | 28433 | PyObject* pyobj_parameters = NULL;
| 28482 | cv::TrackerNano::Params parameters=TrackerNano::Params(); |  | 28434 | cv::TrackerNano::Params parameters=TrackerNano::Params();
| 28483 | Ptr<TrackerNano> retval; |  | 28435 | Ptr<TrackerNano> retval;
| 28484 |  |  | 28436 |
| 28485 | const char* keywords[] = { "parameters", NULL }; |  | 28437 | const char* keywords[] = { "parameters", NULL };
| 28486 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerNano.create", (char**)keywords, &pyobj_parameters) && |  | 28438 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerNano.create", (char**)keywords, &pyobj_parameters) &&
| 28487 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 28439 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 28488 | { |  | 28440 | {
| 28489 | ERRWRAP2(retval = cv::TrackerNano::create(parameters)); |  | 28441 | ERRWRAP2(retval = cv::TrackerNano::create(parameters));
| 28490 | return pyopencv_from(retval); |  | 28442 | return pyopencv_from(retval);
| 28491 | } |  | 28443 | }
| 28492 |  |  | 28444 |
| 28493 |  |  | 28445 |
| 28494 | pyPopulateArgumentConversionErrors(); |  | 28446 | pyPopulateArgumentConversionErrors();
| 28495 | } |  | 28447 | }
| 28496 |  |  | 28448 |
| 28497 |  |  | 28449 |
| 28498 | { |  | 28450 | {
| 28499 | PyObject* pyobj_backbone = NULL; |  | 28451 | PyObject* pyobj_backbone = NULL;
| 28500 | cv::dnn::Net backbone; |  | 28452 | cv::dnn::Net backbone;
| 28501 | PyObject* pyobj_neckhead = NULL; |  | 28453 | PyObject* pyobj_neckhead = NULL;
| 28502 | cv::dnn::Net neckhead; |  | 28454 | cv::dnn::Net neckhead;
| 28503 | Ptr<TrackerNano> retval; |  | 28455 | Ptr<TrackerNano> retval;
| 28504 |  |  | 28456 |
| 28505 | const char* keywords[] = { "backbone", "neckhead", NULL }; |  | 28457 | const char* keywords[] = { "backbone", "neckhead", NULL };
| 28506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:TrackerNano.create", (char**)keywords, &pyobj_backbone, &pyobj_neckhead) && |  | 28458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:TrackerNano.create", (char**)keywords, &pyobj_backbone, &pyobj_neckhead) &&
| 28507 | pyopencv_to_safe(pyobj_backbone, backbone, ArgInfo("backbone", 0)) && |  | 28459 | pyopencv_to_safe(pyobj_backbone, backbone, ArgInfo("backbone", 0)) &&
| 28508 | pyopencv_to_safe(pyobj_neckhead, neckhead, ArgInfo("neckhead", 0)) ) |  | 28460 | pyopencv_to_safe(pyobj_neckhead, neckhead, ArgInfo("neckhead", 0)) )
| 28509 | { |  | 28461 | {
| 28510 | ERRWRAP2(retval = cv::TrackerNano::create(backbone, neckhead)); |  | 28462 | ERRWRAP2(retval = cv::TrackerNano::create(backbone, neckhead));
| 28511 | return pyopencv_from(retval); |  | 28463 | return pyopencv_from(retval);
| 28512 | } |  | 28464 | }
| 28513 |  |  | 28465 |
| 28514 |  |  | 28466 |
| 28515 | pyPopulateArgumentConversionErrors(); |  | 28467 | pyPopulateArgumentConversionErrors();
| 28516 | } |  | 28468 | }
| 28517 | pyRaiseCVOverloadException("create"); |  | 28469 | pyRaiseCVOverloadException("create");
| 28518 |  |  | 28470 |
| 28519 | return NULL; |  | 28471 | return NULL;
| 28520 | } |  | 28472 | }
| 28521 |  |  | 28473 |
| 28522 | static PyObject* pyopencv_cv_TrackerNano_getTrackingScore(PyObject* self, PyObject* py_args, PyObject* kw) |  | 28474 | static PyObject* pyopencv_cv_TrackerNano_getTrackingScore(PyObject* self, PyObject* py_args, PyObject* kw)
| 28523 | { |  | 28475 | {
| 28524 | using namespace cv; |  | 28476 | using namespace cv;
| 28525 |  |  | 28477 |
| 28526 |  |  | 28478 |
| 28527 | Ptr<cv::TrackerNano> * self1 = 0; |  | 28479 | Ptr<cv::TrackerNano> * self1 = 0;
| 28528 | if (!pyopencv_TrackerNano_getp(self, self1)) |  | 28480 | if (!pyopencv_TrackerNano_getp(self, self1))
| 28529 | return failmsgp("Incorrect type of self (must be 'TrackerNano' or its derivative)"); |  | 28481 | return failmsgp("Incorrect type of self (must be 'TrackerNano' or its derivative)");
| 28530 | Ptr<cv::TrackerNano> _self_ = *(self1); |  | 28482 | Ptr<cv::TrackerNano> _self_ = *(self1);
| 28531 | float retval; |  | 28483 | float retval;
| 28532 |  |  | 28484 |
| 28533 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 28485 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 28534 | { |  | 28486 | {
| 28535 | ERRWRAP2(retval = _self_->getTrackingScore()); |  | 28487 | ERRWRAP2(retval = _self_->getTrackingScore());
| 28536 | return pyopencv_from(retval); |  | 28488 | return pyopencv_from(retval);
| 28537 | } |  | 28489 | }
| 28538 |  |  | 28490 |
| 28539 | return NULL; |  | 28491 | return NULL;
| 28540 | } |  | 28492 | }
| 28541 |  |  | 28493 |
| 28542 |  |  | 28494 |
| 28543 |  |  | 28495 |
| 28544 | // Tables (TrackerNano) |  | 28496 | // Tables (TrackerNano)
| 28545 |  |  | 28497 |
| 28546 | static PyGetSetDef pyopencv_TrackerNano_getseters[] = |  | 28498 | static PyGetSetDef pyopencv_TrackerNano_getseters[] =
| 28547 | { |  | 28499 | {
| 28548 | {NULL} /* Sentinel */ |  | 28500 | {NULL} /* Sentinel */
| 28549 | }; |  | 28501 | };
| 28550 |  |  | 28502 |
| 28551 | static PyMethodDef pyopencv_TrackerNano_methods[] = |  | 28503 | static PyMethodDef pyopencv_TrackerNano_methods[] =
| 28552 | { |  | 28504 | {
| 28553 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerNano_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters NanoTrack parameters TrackerNano::Params\n\n\n\ncreate(backbone, neckhead) -> retval\n. @brief Constructor\n. * @param backbone pre-loaded backbone model\n. * @param neckhead pre-loaded neckhead model"}, |  | 28505 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerNano_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters NanoTrack parameters TrackerNano::Params\n\n\n\ncreate(backbone, neckhead) -> retval\n. @brief Constructor\n. * @param backbone pre-loaded backbone model\n. * @param neckhead pre-loaded neckhead model"},
| 28554 | {"getTrackingScore", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerNano_getTrackingScore, 0), "getTrackingScore() -> retval\n. @brief Return tracking score"}, |  | 28506 | {"getTrackingScore", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerNano_getTrackingScore, 0), "getTrackingScore() -> retval\n. @brief Return tracking score"},
| 28555 |  |  | 28507 |
| 28556 | {NULL, NULL} |  | 28508 | {NULL, NULL}
| 28557 | }; |  | 28509 | };
| 28558 |  |  | 28510 |
| 28559 | // Converter (TrackerNano) |  | 28511 | // Converter (TrackerNano)
| 28560 |  |  | 28512 |
| 28561 | template<> |  | 28513 | template<>
| 28562 | struct PyOpenCV_Converter< Ptr<cv::TrackerNano> > |  | 28514 | struct PyOpenCV_Converter< Ptr<cv::TrackerNano> >
| 28563 | { |  | 28515 | {
| 28564 | static PyObject* from(const Ptr<cv::TrackerNano>& r) |  | 28516 | static PyObject* from(const Ptr<cv::TrackerNano>& r)
| 28565 | { |  | 28517 | {
| 28566 | return pyopencv_TrackerNano_Instance(r); |  | 28518 | return pyopencv_TrackerNano_Instance(r);
| 28567 | } |  | 28519 | }
| 28568 | static bool to(PyObject* src, Ptr<cv::TrackerNano>& dst, const ArgInfo& info) |  | 28520 | static bool to(PyObject* src, Ptr<cv::TrackerNano>& dst, const ArgInfo& info)
| 28569 | { |  | 28521 | {
| 28570 | if(!src || src == Py_None) |  | 28522 | if(!src || src == Py_None)
| 28571 | return true; |  | 28523 | return true;
| 28572 | Ptr<cv::TrackerNano> * dst_; |  | 28524 | Ptr<cv::TrackerNano> * dst_;
| 28573 | if (pyopencv_TrackerNano_getp(src, dst_)) |  | 28525 | if (pyopencv_TrackerNano_getp(src, dst_))
| 28574 | { |  | 28526 | {
| 28575 | dst = *dst_; |  | 28527 | dst = *dst_;
| 28576 | return true; |  | 28528 | return true;
| 28577 | } |  | 28529 | }
| 28578 |  |  | 28530 |
| 28579 | failmsg("Expected Ptr<cv::TrackerNano> for argument '%s'", info.name); |  | 28531 | failmsg("Expected Ptr<cv::TrackerNano> for argument '%s'", info.name);
| 28580 | return false; |  | 28532 | return false;
| 28581 | } |  | 28533 | }
| 28582 | }; |  | 28534 | };
| 28583 |  |  | 28535 |
| 28584 | //================================================================================ |  | 28536 | //================================================================================
| 28585 | // TrackerNano_Params (Generic) |  | 28537 | // TrackerNano_Params (Generic)
| 28586 | //================================================================================ |  | 28538 | //================================================================================
| 28587 |  |  | 28539 |
| 28588 | // GetSet (TrackerNano_Params) |  | 28540 | // GetSet (TrackerNano_Params)
| 28589 |  |  | 28541 |
| 28590 |  |  | 28542 |
| 28591 | static PyObject* pyopencv_TrackerNano_Params_get_backbone(pyopencv_TrackerNano_Params_t* p, void *closure) |  | 28543 | static PyObject* pyopencv_TrackerNano_Params_get_backbone(pyopencv_TrackerNano_Params_t* p, void *closure)
| 28592 | { |  | 28544 | {
| 28593 | return pyopencv_from(p->v.backbone); |  | 28545 | return pyopencv_from(p->v.backbone);
| 28594 | } |  | 28546 | }
| 28595 |  |  | 28547 |
| 28596 | static int pyopencv_TrackerNano_Params_set_backbone(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure) |  | 28548 | static int pyopencv_TrackerNano_Params_set_backbone(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure)
| 28597 | { |  | 28549 | {
| 28598 | if (!value) |  | 28550 | if (!value)
| 28599 | { |  | 28551 | {
| 28600 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backbone attribute"); |  | 28552 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backbone attribute");
| 28601 | return -1; |  | 28553 | return -1;
| 28602 | } |  | 28554 | }
| 28603 | return pyopencv_to_safe(value, p->v.backbone, ArgInfo("value", 0)) ? 0 : -1; |  | 28555 | return pyopencv_to_safe(value, p->v.backbone, ArgInfo("value", 0)) ? 0 : -1;
| 28604 | } |  | 28556 | }
| 28605 |  |  | 28557 |
| 28606 | static PyObject* pyopencv_TrackerNano_Params_get_backend(pyopencv_TrackerNano_Params_t* p, void *closure) |  | 28558 | static PyObject* pyopencv_TrackerNano_Params_get_backend(pyopencv_TrackerNano_Params_t* p, void *closure)
| 28607 | { |  | 28559 | {
| 28608 | return pyopencv_from(p->v.backend); |  | 28560 | return pyopencv_from(p->v.backend);
| 28609 | } |  | 28561 | }
| 28610 |  |  | 28562 |
| 28611 | static int pyopencv_TrackerNano_Params_set_backend(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure) |  | 28563 | static int pyopencv_TrackerNano_Params_set_backend(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure)
| 28612 | { |  | 28564 | {
| 28613 | if (!value) |  | 28565 | if (!value)
| 28614 | { |  | 28566 | {
| 28615 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backend attribute"); |  | 28567 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backend attribute");
| 28616 | return -1; |  | 28568 | return -1;
| 28617 | } |  | 28569 | }
| 28618 | return pyopencv_to_safe(value, p->v.backend, ArgInfo("value", 0)) ? 0 : -1; |  | 28570 | return pyopencv_to_safe(value, p->v.backend, ArgInfo("value", 0)) ? 0 : -1;
| 28619 | } |  | 28571 | }
| 28620 |  |  | 28572 |
| 28621 | static PyObject* pyopencv_TrackerNano_Params_get_neckhead(pyopencv_TrackerNano_Params_t* p, void *closure) |  | 28573 | static PyObject* pyopencv_TrackerNano_Params_get_neckhead(pyopencv_TrackerNano_Params_t* p, void *closure)
| 28622 | { |  | 28574 | {
| 28623 | return pyopencv_from(p->v.neckhead); |  | 28575 | return pyopencv_from(p->v.neckhead);
| 28624 | } |  | 28576 | }
| 28625 |  |  | 28577 |
| 28626 | static int pyopencv_TrackerNano_Params_set_neckhead(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure) |  | 28578 | static int pyopencv_TrackerNano_Params_set_neckhead(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure)
| 28627 | { |  | 28579 | {
| 28628 | if (!value) |  | 28580 | if (!value)
| 28629 | { |  | 28581 | {
| 28630 | PyErr_SetString(PyExc_TypeError, "Cannot delete the neckhead attribute"); |  | 28582 | PyErr_SetString(PyExc_TypeError, "Cannot delete the neckhead attribute");
| 28631 | return -1; |  | 28583 | return -1;
| 28632 | } |  | 28584 | }
| 28633 | return pyopencv_to_safe(value, p->v.neckhead, ArgInfo("value", 0)) ? 0 : -1; |  | 28585 | return pyopencv_to_safe(value, p->v.neckhead, ArgInfo("value", 0)) ? 0 : -1;
| 28634 | } |  | 28586 | }
| 28635 |  |  | 28587 |
| 28636 | static PyObject* pyopencv_TrackerNano_Params_get_target(pyopencv_TrackerNano_Params_t* p, void *closure) |  | 28588 | static PyObject* pyopencv_TrackerNano_Params_get_target(pyopencv_TrackerNano_Params_t* p, void *closure)
| 28637 | { |  | 28589 | {
| 28638 | return pyopencv_from(p->v.target); |  | 28590 | return pyopencv_from(p->v.target);
| 28639 | } |  | 28591 | }
| 28640 |  |  | 28592 |
| 28641 | static int pyopencv_TrackerNano_Params_set_target(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure) |  | 28593 | static int pyopencv_TrackerNano_Params_set_target(pyopencv_TrackerNano_Params_t* p, PyObject *value, void *closure)
| 28642 | { |  | 28594 | {
| 28643 | if (!value) |  | 28595 | if (!value)
| 28644 | { |  | 28596 | {
| 28645 | PyErr_SetString(PyExc_TypeError, "Cannot delete the target attribute"); |  | 28597 | PyErr_SetString(PyExc_TypeError, "Cannot delete the target attribute");
| 28646 | return -1; |  | 28598 | return -1;
| 28647 | } |  | 28599 | }
| 28648 | return pyopencv_to_safe(value, p->v.target, ArgInfo("value", 0)) ? 0 : -1; |  | 28600 | return pyopencv_to_safe(value, p->v.target, ArgInfo("value", 0)) ? 0 : -1;
| 28649 | } |  | 28601 | }
| 28650 |  |  | 28602 |
| 28651 |  |  | 28603 |
| 28652 | // Methods (TrackerNano_Params) |  | 28604 | // Methods (TrackerNano_Params)
| 28653 |  |  | 28605 |
| 28654 | static int pyopencv_cv_TrackerNano_Params_TrackerNano_Params(pyopencv_TrackerNano_Params_t* self, PyObject* py_args, PyObject* kw) |  | 28606 | static int pyopencv_cv_TrackerNano_Params_TrackerNano_Params(pyopencv_TrackerNano_Params_t* self, PyObject* py_args, PyObject* kw)
| 28655 | { |  | 28607 | {
| 28656 | using namespace cv; |  | 28608 | using namespace cv;
| 28657 |  |  | 28609 |
| 28658 |  |  | 28610 |
| 28659 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 28611 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 28660 | { |  | 28612 | {
| 28661 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerNano::Params()); |  | 28613 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerNano::Params());
| 28662 | return 0; |  | 28614 | return 0;
| 28663 | } |  | 28615 | }
| 28664 |  |  | 28616 |
| 28665 | return -1; |  | 28617 | return -1;
| 28666 | } |  | 28618 | }
| 28667 |  |  | 28619 |
| 28668 |  |  | 28620 |
| 28669 |  |  | 28621 |
| 28670 | // Tables (TrackerNano_Params) |  | 28622 | // Tables (TrackerNano_Params)
| 28671 |  |  | 28623 |
| 28672 | static PyGetSetDef pyopencv_TrackerNano_Params_getseters[] = |  | 28624 | static PyGetSetDef pyopencv_TrackerNano_Params_getseters[] =
| 28673 | { |  | 28625 | {
| 28674 | {(char*)"backbone", (getter)pyopencv_TrackerNano_Params_get_backbone, (setter)pyopencv_TrackerNano_Params_set_backbone, (char*)"backbone", NULL}, |  | 28626 | {(char*)"backbone", (getter)pyopencv_TrackerNano_Params_get_backbone, (setter)pyopencv_TrackerNano_Params_set_backbone, (char*)"backbone", NULL},
| 28675 | {(char*)"backend", (getter)pyopencv_TrackerNano_Params_get_backend, (setter)pyopencv_TrackerNano_Params_set_backend, (char*)"backend", NULL}, |  | 28627 | {(char*)"backend", (getter)pyopencv_TrackerNano_Params_get_backend, (setter)pyopencv_TrackerNano_Params_set_backend, (char*)"backend", NULL},
| 28676 | {(char*)"neckhead", (getter)pyopencv_TrackerNano_Params_get_neckhead, (setter)pyopencv_TrackerNano_Params_set_neckhead, (char*)"neckhead", NULL}, |  | 28628 | {(char*)"neckhead", (getter)pyopencv_TrackerNano_Params_get_neckhead, (setter)pyopencv_TrackerNano_Params_set_neckhead, (char*)"neckhead", NULL},
| 28677 | {(char*)"target", (getter)pyopencv_TrackerNano_Params_get_target, (setter)pyopencv_TrackerNano_Params_set_target, (char*)"target", NULL}, |  | 28629 | {(char*)"target", (getter)pyopencv_TrackerNano_Params_get_target, (setter)pyopencv_TrackerNano_Params_set_target, (char*)"target", NULL},
| 28678 | {NULL} /* Sentinel */ |  | 28630 | {NULL} /* Sentinel */
| 28679 | }; |  | 28631 | };
| 28680 |  |  | 28632 |
| 28681 | static PyMethodDef pyopencv_TrackerNano_Params_methods[] = |  | 28633 | static PyMethodDef pyopencv_TrackerNano_Params_methods[] =
| 28682 | { |  | 28634 | {
| 28683 |  |  | 28635 |
| 28684 | {NULL, NULL} |  | 28636 | {NULL, NULL}
| 28685 | }; |  | 28637 | };
| 28686 |  |  | 28638 |
| 28687 | // Converter (TrackerNano_Params) |  | 28639 | // Converter (TrackerNano_Params)
| 28688 |  |  | 28640 |
| 28689 | template<> |  | 28641 | template<>
| 28690 | struct PyOpenCV_Converter< cv::TrackerNano::Params > |  | 28642 | struct PyOpenCV_Converter< cv::TrackerNano::Params >
| 28691 | { |  | 28643 | {
| 28692 | static PyObject* from(const cv::TrackerNano::Params& r) |  | 28644 | static PyObject* from(const cv::TrackerNano::Params& r)
| 28693 | { |  | 28645 | {
| 28694 | return pyopencv_TrackerNano_Params_Instance(r); |  | 28646 | return pyopencv_TrackerNano_Params_Instance(r);
| 28695 | } |  | 28647 | }
| 28696 | static bool to(PyObject* src, cv::TrackerNano::Params& dst, const ArgInfo& info) |  | 28648 | static bool to(PyObject* src, cv::TrackerNano::Params& dst, const ArgInfo& info)
| 28697 | { |  | 28649 | {
| 28698 | if(!src || src == Py_None) |  | 28650 | if(!src || src == Py_None)
| 28699 | return true; |  | 28651 | return true;
| 28700 | cv::TrackerNano::Params * dst_; |  | 28652 | cv::TrackerNano::Params * dst_;
| 28701 | if (pyopencv_TrackerNano_Params_getp(src, dst_)) |  | 28653 | if (pyopencv_TrackerNano_Params_getp(src, dst_))
| 28702 | { |  | 28654 | {
| 28703 | dst = *dst_; |  | 28655 | dst = *dst_;
| 28704 | return true; |  | 28656 | return true;
| 28705 | } |  | 28657 | }
| 28706 |  |  | 28658 |
| 28707 | failmsg("Expected cv::TrackerNano::Params for argument '%s'", info.name); |  | 28659 | failmsg("Expected cv::TrackerNano::Params for argument '%s'", info.name);
| 28708 | return false; |  | 28660 | return false;
| 28709 | } |  | 28661 | }
| 28710 | }; |  | 28662 | };
| 28711 |  |  | 28663 |
| 28712 | //================================================================================ |  | 28664 | //================================================================================
| 28713 | // TrackerVit (Generic) |  | 28665 | // TrackerVit (Generic)
| 28714 | //================================================================================ |  | 28666 | //================================================================================
| 28715 |  |  | 28667 |
| 28716 | // GetSet (TrackerVit) |  | 28668 | // GetSet (TrackerVit)
| 28717 |  |  | 28669 |
| 28718 |  |  | 28670 |
| 28719 |  |  | 28671 |
| 28720 | // Methods (TrackerVit) |  | 28672 | // Methods (TrackerVit)
| 28721 |  |  | 28673 |
| 28722 | static PyObject* pyopencv_cv_TrackerVit_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 28674 | static PyObject* pyopencv_cv_TrackerVit_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 28723 | { |  | 28675 | {
| 28724 | using namespace cv; |  | 28676 | using namespace cv;
| 28725 |  |  | 28677 |
| 28726 | pyPrepareArgumentConversionErrorsStorage(2); |  | 28678 | pyPrepareArgumentConversionErrorsStorage(2);
| 28727 |  |  | 28679 |
| 28728 | { |  | 28680 | {
| 28729 | PyObject* pyobj_parameters = NULL; |  | 28681 | PyObject* pyobj_parameters = NULL;
| 28730 | cv::TrackerVit::Params parameters=TrackerVit::Params(); |  | 28682 | cv::TrackerVit::Params parameters=TrackerVit::Params();
| 28731 | Ptr<TrackerVit> retval; |  | 28683 | Ptr<TrackerVit> retval;
| 28732 |  |  | 28684 |
| 28733 | const char* keywords[] = { "parameters", NULL }; |  | 28685 | const char* keywords[] = { "parameters", NULL };
| 28734 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerVit.create", (char**)keywords, &pyobj_parameters) && |  | 28686 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:TrackerVit.create", (char**)keywords, &pyobj_parameters) &&
| 28735 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 28687 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 28736 | { |  | 28688 | {
| 28737 | ERRWRAP2(retval = cv::TrackerVit::create(parameters)); |  | 28689 | ERRWRAP2(retval = cv::TrackerVit::create(parameters));
| 28738 | return pyopencv_from(retval); |  | 28690 | return pyopencv_from(retval);
| 28739 | } |  | 28691 | }
| 28740 |  |  | 28692 |
| 28741 |  |  | 28693 |
| 28742 | pyPopulateArgumentConversionErrors(); |  | 28694 | pyPopulateArgumentConversionErrors();
| 28743 | } |  | 28695 | }
| 28744 |  |  | 28696 |
| 28745 |  |  | 28697 |
| 28746 | { |  | 28698 | {
| 28747 | PyObject* pyobj_model = NULL; |  | 28699 | PyObject* pyobj_model = NULL;
| 28748 | cv::dnn::Net model; |  | 28700 | cv::dnn::Net model;
| 28749 | PyObject* pyobj_meanvalue = NULL; |  | 28701 | PyObject* pyobj_meanvalue = NULL;
| 28750 | Scalar meanvalue=Scalar(0.485, 0.456, 0.406); |  | 28702 | Scalar meanvalue=Scalar(0.485, 0.456, 0.406);
| 28751 | PyObject* pyobj_stdvalue = NULL; |  | 28703 | PyObject* pyobj_stdvalue = NULL;
| 28752 | Scalar stdvalue=Scalar(0.229, 0.224, 0.225); |  | 28704 | Scalar stdvalue=Scalar(0.229, 0.224, 0.225);
| 28753 | PyObject* pyobj_tracking_score_threshold = NULL; |  | 28705 | PyObject* pyobj_tracking_score_threshold = NULL;
| 28754 | float tracking_score_threshold=0.20f; |  | 28706 | float tracking_score_threshold=0.20f;
| 28755 | Ptr<TrackerVit> retval; |  | 28707 | Ptr<TrackerVit> retval;
| 28756 |  |  | 28708 |
| 28757 | const char* keywords[] = { "model", "meanvalue", "stdvalue", "tracking_score_threshold", NULL }; |  | 28709 | const char* keywords[] = { "model", "meanvalue", "stdvalue", "tracking_score_threshold", NULL };
| 28758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:TrackerVit.create", (char**)keywords, &pyobj_model, &pyobj_meanvalue, &pyobj_stdvalue, &pyobj_tracking_score_threshold) && |  | 28710 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:TrackerVit.create", (char**)keywords, &pyobj_model, &pyobj_meanvalue, &pyobj_stdvalue, &pyobj_tracking_score_threshold) &&
| 28759 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) && |  | 28711 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) &&
| 28760 | pyopencv_to_safe(pyobj_meanvalue, meanvalue, ArgInfo("meanvalue", 0)) && |  | 28712 | pyopencv_to_safe(pyobj_meanvalue, meanvalue, ArgInfo("meanvalue", 0)) &&
| 28761 | pyopencv_to_safe(pyobj_stdvalue, stdvalue, ArgInfo("stdvalue", 0)) && |  | 28713 | pyopencv_to_safe(pyobj_stdvalue, stdvalue, ArgInfo("stdvalue", 0)) &&
| 28762 | pyopencv_to_safe(pyobj_tracking_score_threshold, tracking_score_threshold, ArgInfo("tracking_score_threshold", 0)) ) |  | 28714 | pyopencv_to_safe(pyobj_tracking_score_threshold, tracking_score_threshold, ArgInfo("tracking_score_threshold", 0)) )
| 28763 | { |  | 28715 | {
| 28764 | ERRWRAP2(retval = cv::TrackerVit::create(model, meanvalue, stdvalue, tracking_score_threshold)); |  | 28716 | ERRWRAP2(retval = cv::TrackerVit::create(model, meanvalue, stdvalue, tracking_score_threshold));
| 28765 | return pyopencv_from(retval); |  | 28717 | return pyopencv_from(retval);
| 28766 | } |  | 28718 | }
| 28767 |  |  | 28719 |
| 28768 |  |  | 28720 |
| 28769 | pyPopulateArgumentConversionErrors(); |  | 28721 | pyPopulateArgumentConversionErrors();
| 28770 | } |  | 28722 | }
| 28771 | pyRaiseCVOverloadException("create"); |  | 28723 | pyRaiseCVOverloadException("create");
| 28772 |  |  | 28724 |
| 28773 | return NULL; |  | 28725 | return NULL;
| 28774 | } |  | 28726 | }
| 28775 |  |  | 28727 |
| 28776 | static PyObject* pyopencv_cv_TrackerVit_getTrackingScore(PyObject* self, PyObject* py_args, PyObject* kw) |  | 28728 | static PyObject* pyopencv_cv_TrackerVit_getTrackingScore(PyObject* self, PyObject* py_args, PyObject* kw)
| 28777 | { |  | 28729 | {
| 28778 | using namespace cv; |  | 28730 | using namespace cv;
| 28779 |  |  | 28731 |
| 28780 |  |  | 28732 |
| 28781 | Ptr<cv::TrackerVit> * self1 = 0; |  | 28733 | Ptr<cv::TrackerVit> * self1 = 0;
| 28782 | if (!pyopencv_TrackerVit_getp(self, self1)) |  | 28734 | if (!pyopencv_TrackerVit_getp(self, self1))
| 28783 | return failmsgp("Incorrect type of self (must be 'TrackerVit' or its derivative)"); |  | 28735 | return failmsgp("Incorrect type of self (must be 'TrackerVit' or its derivative)");
| 28784 | Ptr<cv::TrackerVit> _self_ = *(self1); |  | 28736 | Ptr<cv::TrackerVit> _self_ = *(self1);
| 28785 | float retval; |  | 28737 | float retval;
| 28786 |  |  | 28738 |
| 28787 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 28739 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 28788 | { |  | 28740 | {
| 28789 | ERRWRAP2(retval = _self_->getTrackingScore()); |  | 28741 | ERRWRAP2(retval = _self_->getTrackingScore());
| 28790 | return pyopencv_from(retval); |  | 28742 | return pyopencv_from(retval);
| 28791 | } |  | 28743 | }
| 28792 |  |  | 28744 |
| 28793 | return NULL; |  | 28745 | return NULL;
| 28794 | } |  | 28746 | }
| 28795 |  |  | 28747 |
| 28796 |  |  | 28748 |
| 28797 |  |  | 28749 |
| 28798 | // Tables (TrackerVit) |  | 28750 | // Tables (TrackerVit)
| 28799 |  |  | 28751 |
| 28800 | static PyGetSetDef pyopencv_TrackerVit_getseters[] = |  | 28752 | static PyGetSetDef pyopencv_TrackerVit_getseters[] =
| 28801 | { |  | 28753 | {
| 28802 | {NULL} /* Sentinel */ |  | 28754 | {NULL} /* Sentinel */
| 28803 | }; |  | 28755 | };
| 28804 |  |  | 28756 |
| 28805 | static PyMethodDef pyopencv_TrackerVit_methods[] = |  | 28757 | static PyMethodDef pyopencv_TrackerVit_methods[] =
| 28806 | { |  | 28758 | {
| 28807 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerVit_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters vit tracker parameters TrackerVit::Params\n\n\n\ncreate(model[, meanvalue[, stdvalue[, tracking_score_threshold]]]) -> retval\n. @brief Constructor\n. * @param model pre-loaded DNN model\n. * @param meanvalue mean value for image preprocessing\n. * @param stdvalue std value for image preprocessing\n. * @param tracking_score_threshold threshold for tracking score"}, |  | 28759 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerVit_create_static, METH_STATIC), "create([, parameters]) -> retval\n. @brief Constructor\n. @param parameters vit tracker parameters TrackerVit::Params\n\n\n\ncreate(model[, meanvalue[, stdvalue[, tracking_score_threshold]]]) -> retval\n. @brief Constructor\n. * @param model pre-loaded DNN model\n. * @param meanvalue mean value for image preprocessing\n. * @param stdvalue std value for image preprocessing\n. * @param tracking_score_threshold threshold for tracking score"},
| 28808 | {"getTrackingScore", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerVit_getTrackingScore, 0), "getTrackingScore() -> retval\n. @brief Return tracking score"}, |  | 28760 | {"getTrackingScore", CV_PY_FN_WITH_KW_(pyopencv_cv_TrackerVit_getTrackingScore, 0), "getTrackingScore() -> retval\n. @brief Return tracking score"},
| 28809 |  |  | 28761 |
| 28810 | {NULL, NULL} |  | 28762 | {NULL, NULL}
| 28811 | }; |  | 28763 | };
| 28812 |  |  | 28764 |
| 28813 | // Converter (TrackerVit) |  | 28765 | // Converter (TrackerVit)
| 28814 |  |  | 28766 |
| 28815 | template<> |  | 28767 | template<>
| 28816 | struct PyOpenCV_Converter< Ptr<cv::TrackerVit> > |  | 28768 | struct PyOpenCV_Converter< Ptr<cv::TrackerVit> >
| 28817 | { |  | 28769 | {
| 28818 | static PyObject* from(const Ptr<cv::TrackerVit>& r) |  | 28770 | static PyObject* from(const Ptr<cv::TrackerVit>& r)
| 28819 | { |  | 28771 | {
| 28820 | return pyopencv_TrackerVit_Instance(r); |  | 28772 | return pyopencv_TrackerVit_Instance(r);
| 28821 | } |  | 28773 | }
| 28822 | static bool to(PyObject* src, Ptr<cv::TrackerVit>& dst, const ArgInfo& info) |  | 28774 | static bool to(PyObject* src, Ptr<cv::TrackerVit>& dst, const ArgInfo& info)
| 28823 | { |  | 28775 | {
| 28824 | if(!src || src == Py_None) |  | 28776 | if(!src || src == Py_None)
| 28825 | return true; |  | 28777 | return true;
| 28826 | Ptr<cv::TrackerVit> * dst_; |  | 28778 | Ptr<cv::TrackerVit> * dst_;
| 28827 | if (pyopencv_TrackerVit_getp(src, dst_)) |  | 28779 | if (pyopencv_TrackerVit_getp(src, dst_))
| 28828 | { |  | 28780 | {
| 28829 | dst = *dst_; |  | 28781 | dst = *dst_;
| 28830 | return true; |  | 28782 | return true;
| 28831 | } |  | 28783 | }
| 28832 |  |  | 28784 |
| 28833 | failmsg("Expected Ptr<cv::TrackerVit> for argument '%s'", info.name); |  | 28785 | failmsg("Expected Ptr<cv::TrackerVit> for argument '%s'", info.name);
| 28834 | return false; |  | 28786 | return false;
| 28835 | } |  | 28787 | }
| 28836 | }; |  | 28788 | };
| 28837 |  |  | 28789 |
| 28838 | //================================================================================ |  | 28790 | //================================================================================
| 28839 | // TrackerVit_Params (Generic) |  | 28791 | // TrackerVit_Params (Generic)
| 28840 | //================================================================================ |  | 28792 | //================================================================================
| 28841 |  |  | 28793 |
| 28842 | // GetSet (TrackerVit_Params) |  | 28794 | // GetSet (TrackerVit_Params)
| 28843 |  |  | 28795 |
| 28844 |  |  | 28796 |
| 28845 | static PyObject* pyopencv_TrackerVit_Params_get_backend(pyopencv_TrackerVit_Params_t* p, void *closure) |  | 28797 | static PyObject* pyopencv_TrackerVit_Params_get_backend(pyopencv_TrackerVit_Params_t* p, void *closure)
| 28846 | { |  | 28798 | {
| 28847 | return pyopencv_from(p->v.backend); |  | 28799 | return pyopencv_from(p->v.backend);
| 28848 | } |  | 28800 | }
| 28849 |  |  | 28801 |
| 28850 | static int pyopencv_TrackerVit_Params_set_backend(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure) |  | 28802 | static int pyopencv_TrackerVit_Params_set_backend(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure)
| 28851 | { |  | 28803 | {
| 28852 | if (!value) |  | 28804 | if (!value)
| 28853 | { |  | 28805 | {
| 28854 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backend attribute"); |  | 28806 | PyErr_SetString(PyExc_TypeError, "Cannot delete the backend attribute");
| 28855 | return -1; |  | 28807 | return -1;
| 28856 | } |  | 28808 | }
| 28857 | return pyopencv_to_safe(value, p->v.backend, ArgInfo("value", 0)) ? 0 : -1; |  | 28809 | return pyopencv_to_safe(value, p->v.backend, ArgInfo("value", 0)) ? 0 : -1;
| 28858 | } |  | 28810 | }
| 28859 |  |  | 28811 |
| 28860 | static PyObject* pyopencv_TrackerVit_Params_get_meanvalue(pyopencv_TrackerVit_Params_t* p, void *closure) |  | 28812 | static PyObject* pyopencv_TrackerVit_Params_get_meanvalue(pyopencv_TrackerVit_Params_t* p, void *closure)
| 28861 | { |  | 28813 | {
| 28862 | return pyopencv_from(p->v.meanvalue); |  | 28814 | return pyopencv_from(p->v.meanvalue);
| 28863 | } |  | 28815 | }
| 28864 |  |  | 28816 |
| 28865 | static int pyopencv_TrackerVit_Params_set_meanvalue(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure) |  | 28817 | static int pyopencv_TrackerVit_Params_set_meanvalue(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure)
| 28866 | { |  | 28818 | {
| 28867 | if (!value) |  | 28819 | if (!value)
| 28868 | { |  | 28820 | {
| 28869 | PyErr_SetString(PyExc_TypeError, "Cannot delete the meanvalue attribute"); |  | 28821 | PyErr_SetString(PyExc_TypeError, "Cannot delete the meanvalue attribute");
| 28870 | return -1; |  | 28822 | return -1;
| 28871 | } |  | 28823 | }
| 28872 | return pyopencv_to_safe(value, p->v.meanvalue, ArgInfo("value", 0)) ? 0 : -1; |  | 28824 | return pyopencv_to_safe(value, p->v.meanvalue, ArgInfo("value", 0)) ? 0 : -1;
| 28873 | } |  | 28825 | }
| 28874 |  |  | 28826 |
| 28875 | static PyObject* pyopencv_TrackerVit_Params_get_net(pyopencv_TrackerVit_Params_t* p, void *closure) |  | 28827 | static PyObject* pyopencv_TrackerVit_Params_get_net(pyopencv_TrackerVit_Params_t* p, void *closure)
| 28876 | { |  | 28828 | {
| 28877 | return pyopencv_from(p->v.net); |  | 28829 | return pyopencv_from(p->v.net);
| 28878 | } |  | 28830 | }
| 28879 |  |  | 28831 |
| 28880 | static int pyopencv_TrackerVit_Params_set_net(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure) |  | 28832 | static int pyopencv_TrackerVit_Params_set_net(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure)
| 28881 | { |  | 28833 | {
| 28882 | if (!value) |  | 28834 | if (!value)
| 28883 | { |  | 28835 | {
| 28884 | PyErr_SetString(PyExc_TypeError, "Cannot delete the net attribute"); |  | 28836 | PyErr_SetString(PyExc_TypeError, "Cannot delete the net attribute");
| 28885 | return -1; |  | 28837 | return -1;
| 28886 | } |  | 28838 | }
| 28887 | return pyopencv_to_safe(value, p->v.net, ArgInfo("value", 0)) ? 0 : -1; |  | 28839 | return pyopencv_to_safe(value, p->v.net, ArgInfo("value", 0)) ? 0 : -1;
| 28888 | } |  | 28840 | }
| 28889 |  |  | 28841 |
| 28890 | static PyObject* pyopencv_TrackerVit_Params_get_stdvalue(pyopencv_TrackerVit_Params_t* p, void *closure) |  | 28842 | static PyObject* pyopencv_TrackerVit_Params_get_stdvalue(pyopencv_TrackerVit_Params_t* p, void *closure)
| 28891 | { |  | 28843 | {
| 28892 | return pyopencv_from(p->v.stdvalue); |  | 28844 | return pyopencv_from(p->v.stdvalue);
| 28893 | } |  | 28845 | }
| 28894 |  |  | 28846 |
| 28895 | static int pyopencv_TrackerVit_Params_set_stdvalue(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure) |  | 28847 | static int pyopencv_TrackerVit_Params_set_stdvalue(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure)
| 28896 | { |  | 28848 | {
| 28897 | if (!value) |  | 28849 | if (!value)
| 28898 | { |  | 28850 | {
| 28899 | PyErr_SetString(PyExc_TypeError, "Cannot delete the stdvalue attribute"); |  | 28851 | PyErr_SetString(PyExc_TypeError, "Cannot delete the stdvalue attribute");
| 28900 | return -1; |  | 28852 | return -1;
| 28901 | } |  | 28853 | }
| 28902 | return pyopencv_to_safe(value, p->v.stdvalue, ArgInfo("value", 0)) ? 0 : -1; |  | 28854 | return pyopencv_to_safe(value, p->v.stdvalue, ArgInfo("value", 0)) ? 0 : -1;
| 28903 | } |  | 28855 | }
| 28904 |  |  | 28856 |
| 28905 | static PyObject* pyopencv_TrackerVit_Params_get_target(pyopencv_TrackerVit_Params_t* p, void *closure) |  | 28857 | static PyObject* pyopencv_TrackerVit_Params_get_target(pyopencv_TrackerVit_Params_t* p, void *closure)
| 28906 | { |  | 28858 | {
| 28907 | return pyopencv_from(p->v.target); |  | 28859 | return pyopencv_from(p->v.target);
| 28908 | } |  | 28860 | }
| 28909 |  |  | 28861 |
| 28910 | static int pyopencv_TrackerVit_Params_set_target(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure) |  | 28862 | static int pyopencv_TrackerVit_Params_set_target(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure)
| 28911 | { |  | 28863 | {
| 28912 | if (!value) |  | 28864 | if (!value)
| 28913 | { |  | 28865 | {
| 28914 | PyErr_SetString(PyExc_TypeError, "Cannot delete the target attribute"); |  | 28866 | PyErr_SetString(PyExc_TypeError, "Cannot delete the target attribute");
| 28915 | return -1; |  | 28867 | return -1;
| 28916 | } |  | 28868 | }
| 28917 | return pyopencv_to_safe(value, p->v.target, ArgInfo("value", 0)) ? 0 : -1; |  | 28869 | return pyopencv_to_safe(value, p->v.target, ArgInfo("value", 0)) ? 0 : -1;
| 28918 | } |  | 28870 | }
| 28919 |  |  | 28871 |
| 28920 | static PyObject* pyopencv_TrackerVit_Params_get_tracking_score_threshold(pyopencv_TrackerVit_Params_t* p, void *closure) |  | 28872 | static PyObject* pyopencv_TrackerVit_Params_get_tracking_score_threshold(pyopencv_TrackerVit_Params_t* p, void *closure)
| 28921 | { |  | 28873 | {
| 28922 | return pyopencv_from(p->v.tracking_score_threshold); |  | 28874 | return pyopencv_from(p->v.tracking_score_threshold);
| 28923 | } |  | 28875 | }
| 28924 |  |  | 28876 |
| 28925 | static int pyopencv_TrackerVit_Params_set_tracking_score_threshold(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure) |  | 28877 | static int pyopencv_TrackerVit_Params_set_tracking_score_threshold(pyopencv_TrackerVit_Params_t* p, PyObject *value, void *closure)
| 28926 | { |  | 28878 | {
| 28927 | if (!value) |  | 28879 | if (!value)
| 28928 | { |  | 28880 | {
| 28929 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tracking_score_threshold attribute"); |  | 28881 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tracking_score_threshold attribute");
| 28930 | return -1; |  | 28882 | return -1;
| 28931 | } |  | 28883 | }
| 28932 | return pyopencv_to_safe(value, p->v.tracking_score_threshold, ArgInfo("value", 0)) ? 0 : -1; |  | 28884 | return pyopencv_to_safe(value, p->v.tracking_score_threshold, ArgInfo("value", 0)) ? 0 : -1;
| 28933 | } |  | 28885 | }
| 28934 |  |  | 28886 |
| 28935 |  |  | 28887 |
| 28936 | // Methods (TrackerVit_Params) |  | 28888 | // Methods (TrackerVit_Params)
| 28937 |  |  | 28889 |
| 28938 | static int pyopencv_cv_TrackerVit_Params_TrackerVit_Params(pyopencv_TrackerVit_Params_t* self, PyObject* py_args, PyObject* kw) |  | 28890 | static int pyopencv_cv_TrackerVit_Params_TrackerVit_Params(pyopencv_TrackerVit_Params_t* self, PyObject* py_args, PyObject* kw)
| 28939 | { |  | 28891 | {
| 28940 | using namespace cv; |  | 28892 | using namespace cv;
| 28941 |  |  | 28893 |
| 28942 |  |  | 28894 |
| 28943 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 28895 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 28944 | { |  | 28896 | {
| 28945 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerVit::Params()); |  | 28897 | if(self) ERRWRAP2(new (&(self->v)) cv::TrackerVit::Params());
| 28946 | return 0; |  | 28898 | return 0;
| 28947 | } |  | 28899 | }
| 28948 |  |  | 28900 |
| 28949 | return -1; |  | 28901 | return -1;
| 28950 | } |  | 28902 | }
| 28951 |  |  | 28903 |
| 28952 |  |  | 28904 |
| 28953 |  |  | 28905 |
| 28954 | // Tables (TrackerVit_Params) |  | 28906 | // Tables (TrackerVit_Params)
| 28955 |  |  | 28907 |
| 28956 | static PyGetSetDef pyopencv_TrackerVit_Params_getseters[] = |  | 28908 | static PyGetSetDef pyopencv_TrackerVit_Params_getseters[] =
| 28957 | { |  | 28909 | {
| 28958 | {(char*)"backend", (getter)pyopencv_TrackerVit_Params_get_backend, (setter)pyopencv_TrackerVit_Params_set_backend, (char*)"backend", NULL}, |  | 28910 | {(char*)"backend", (getter)pyopencv_TrackerVit_Params_get_backend, (setter)pyopencv_TrackerVit_Params_set_backend, (char*)"backend", NULL},
| 28959 | {(char*)"meanvalue", (getter)pyopencv_TrackerVit_Params_get_meanvalue, (setter)pyopencv_TrackerVit_Params_set_meanvalue, (char*)"meanvalue", NULL}, |  | 28911 | {(char*)"meanvalue", (getter)pyopencv_TrackerVit_Params_get_meanvalue, (setter)pyopencv_TrackerVit_Params_set_meanvalue, (char*)"meanvalue", NULL},
| 28960 | {(char*)"net", (getter)pyopencv_TrackerVit_Params_get_net, (setter)pyopencv_TrackerVit_Params_set_net, (char*)"net", NULL}, |  | 28912 | {(char*)"net", (getter)pyopencv_TrackerVit_Params_get_net, (setter)pyopencv_TrackerVit_Params_set_net, (char*)"net", NULL},
| 28961 | {(char*)"stdvalue", (getter)pyopencv_TrackerVit_Params_get_stdvalue, (setter)pyopencv_TrackerVit_Params_set_stdvalue, (char*)"stdvalue", NULL}, |  | 28913 | {(char*)"stdvalue", (getter)pyopencv_TrackerVit_Params_get_stdvalue, (setter)pyopencv_TrackerVit_Params_set_stdvalue, (char*)"stdvalue", NULL},
| 28962 | {(char*)"target", (getter)pyopencv_TrackerVit_Params_get_target, (setter)pyopencv_TrackerVit_Params_set_target, (char*)"target", NULL}, |  | 28914 | {(char*)"target", (getter)pyopencv_TrackerVit_Params_get_target, (setter)pyopencv_TrackerVit_Params_set_target, (char*)"target", NULL},
| 28963 | {(char*)"tracking_score_threshold", (getter)pyopencv_TrackerVit_Params_get_tracking_score_threshold, (setter)pyopencv_TrackerVit_Params_set_tracking_score_threshold, (char*)"tracking_score_threshold", NULL}, |  | 28915 | {(char*)"tracking_score_threshold", (getter)pyopencv_TrackerVit_Params_get_tracking_score_threshold, (setter)pyopencv_TrackerVit_Params_set_tracking_score_threshold, (char*)"tracking_score_threshold", NULL},
| 28964 | {NULL} /* Sentinel */ |  | 28916 | {NULL} /* Sentinel */
| 28965 | }; |  | 28917 | };
| 28966 |  |  | 28918 |
| 28967 | static PyMethodDef pyopencv_TrackerVit_Params_methods[] = |  | 28919 | static PyMethodDef pyopencv_TrackerVit_Params_methods[] =
| 28968 | { |  | 28920 | {
| 28969 |  |  | 28921 |
| 28970 | {NULL, NULL} |  | 28922 | {NULL, NULL}
| 28971 | }; |  | 28923 | };
| 28972 |  |  | 28924 |
| 28973 | // Converter (TrackerVit_Params) |  | 28925 | // Converter (TrackerVit_Params)
| 28974 |  |  | 28926 |
| 28975 | template<> |  | 28927 | template<>
| 28976 | struct PyOpenCV_Converter< cv::TrackerVit::Params > |  | 28928 | struct PyOpenCV_Converter< cv::TrackerVit::Params >
| 28977 | { |  | 28929 | {
| 28978 | static PyObject* from(const cv::TrackerVit::Params& r) |  | 28930 | static PyObject* from(const cv::TrackerVit::Params& r)
| 28979 | { |  | 28931 | {
| 28980 | return pyopencv_TrackerVit_Params_Instance(r); |  | 28932 | return pyopencv_TrackerVit_Params_Instance(r);
| 28981 | } |  | 28933 | }
| 28982 | static bool to(PyObject* src, cv::TrackerVit::Params& dst, const ArgInfo& info) |  | 28934 | static bool to(PyObject* src, cv::TrackerVit::Params& dst, const ArgInfo& info)
| 28983 | { |  | 28935 | {
| 28984 | if(!src || src == Py_None) |  | 28936 | if(!src || src == Py_None)
| 28985 | return true; |  | 28937 | return true;
| 28986 | cv::TrackerVit::Params * dst_; |  | 28938 | cv::TrackerVit::Params * dst_;
| 28987 | if (pyopencv_TrackerVit_Params_getp(src, dst_)) |  | 28939 | if (pyopencv_TrackerVit_Params_getp(src, dst_))
| 28988 | { |  | 28940 | {
| 28989 | dst = *dst_; |  | 28941 | dst = *dst_;
| 28990 | return true; |  | 28942 | return true;
| 28991 | } |  | 28943 | }
| 28992 |  |  | 28944 |
| 28993 | failmsg("Expected cv::TrackerVit::Params for argument '%s'", info.name); |  | 28945 | failmsg("Expected cv::TrackerVit::Params for argument '%s'", info.name);
| 28994 | return false; |  | 28946 | return false;
| 28995 | } |  | 28947 | }
| 28996 | }; |  | 28948 | };
| 28997 |  |  | 28949 |
| 28998 | //================================================================================ |  | 28950 | //================================================================================
| 28999 | // UMat (Generic) |  | 28951 | // UMat (Generic)
| 29000 | //================================================================================ |  | 28952 | //================================================================================
| 29001 |  |  | 28953 |
| 29002 | // GetSet (UMat) |  | 28954 | // GetSet (UMat)
| 29003 |  |  | 28955 |
| 29004 |  |  | 28956 |
| 29005 | static PyObject* pyopencv_UMat_get_offset(pyopencv_UMat_t* p, void *closure) |  | 28957 | static PyObject* pyopencv_UMat_get_offset(pyopencv_UMat_t* p, void *closure)
| 29006 | { |  | 28958 | {
| 29007 | return pyopencv_from(p->v->offset); |  | 28959 | return pyopencv_from(p->v->offset);
| 29008 | } |  | 28960 | }
| 29009 |  |  | 28961 |
| 29010 | static int pyopencv_UMat_set_offset(pyopencv_UMat_t* p, PyObject *value, void *closure) |  | 28962 | static int pyopencv_UMat_set_offset(pyopencv_UMat_t* p, PyObject *value, void *closure)
| 29011 | { |  | 28963 | {
| 29012 | if (!value) |  | 28964 | if (!value)
| 29013 | { |  | 28965 | {
| 29014 | PyErr_SetString(PyExc_TypeError, "Cannot delete the offset attribute"); |  | 28966 | PyErr_SetString(PyExc_TypeError, "Cannot delete the offset attribute");
| 29015 | return -1; |  | 28967 | return -1;
| 29016 | } |  | 28968 | }
| 29017 | return pyopencv_to_safe(value, p->v->offset, ArgInfo("value", 0)) ? 0 : -1; |  | 28969 | return pyopencv_to_safe(value, p->v->offset, ArgInfo("value", 0)) ? 0 : -1;
| 29018 | } |  | 28970 | }
| 29019 |  |  | 28971 |
| 29020 |  |  | 28972 |
| 29021 | // Methods (UMat) |  | 28973 | // Methods (UMat)
| 29022 |  |  | 28974 |
| 29023 | static int pyopencv_cv_UMat_UMat(pyopencv_UMat_t* self, PyObject* py_args, PyObject* kw) |  | 28975 | static int pyopencv_cv_UMat_UMat(pyopencv_UMat_t* self, PyObject* py_args, PyObject* kw)
| 29024 | { |  | 28976 | {
| 29025 | using namespace cv; |  | 28977 | using namespace cv;
| 29026 |  |  | 28978 |
| 29027 | pyPrepareArgumentConversionErrorsStorage(9); |  | 28979 | pyPrepareArgumentConversionErrorsStorage(9);
| 29028 |  |  | 28980 |
| 29029 | { |  | 28981 | {
| 29030 | PyObject* pyobj_usageFlags = NULL; |  | 28982 | PyObject* pyobj_usageFlags = NULL;
| 29031 | UMatUsageFlags usageFlags=USAGE_DEFAULT; |  | 28983 | UMatUsageFlags usageFlags=USAGE_DEFAULT;
| 29032 |  |  | 28984 |
| 29033 | const char* keywords[] = { "usageFlags", NULL }; |  | 28985 | const char* keywords[] = { "usageFlags", NULL };
| 29034 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:UMat", (char**)keywords, &pyobj_usageFlags) && |  | 28986 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:UMat", (char**)keywords, &pyobj_usageFlags) &&
| 29035 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) ) |  | 28987 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) )
| 29036 | { |  | 28988 | {
| 29037 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 28989 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29038 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(usageFlags))); |  | 28990 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(usageFlags)));
| 29039 | return 0; |  | 28991 | return 0;
| 29040 | } |  | 28992 | }
| 29041 |  |  | 28993 |
| 29042 |  |  | 28994 |
| 29043 | pyPopulateArgumentConversionErrors(); |  | 28995 | pyPopulateArgumentConversionErrors();
| 29044 | } |  | 28996 | }
| 29045 |  |  | 28997 |
| 29046 |  |  | 28998 |
| 29047 | { |  | 28999 | {
| 29048 | PyObject* pyobj_rows = NULL; |  | 29000 | PyObject* pyobj_rows = NULL;
| 29049 | int rows=0; |  | 29001 | int rows=0;
| 29050 | PyObject* pyobj_cols = NULL; |  | 29002 | PyObject* pyobj_cols = NULL;
| 29051 | int cols=0; |  | 29003 | int cols=0;
| 29052 | PyObject* pyobj_type = NULL; |  | 29004 | PyObject* pyobj_type = NULL;
| 29053 | int type=0; |  | 29005 | int type=0;
| 29054 | PyObject* pyobj_usageFlags = NULL; |  | 29006 | PyObject* pyobj_usageFlags = NULL;
| 29055 | UMatUsageFlags usageFlags=USAGE_DEFAULT; |  | 29007 | UMatUsageFlags usageFlags=USAGE_DEFAULT;
| 29056 |  |  | 29008 |
| 29057 | const char* keywords[] = { "rows", "cols", "type", "usageFlags", NULL }; |  | 29009 | const char* keywords[] = { "rows", "cols", "type", "usageFlags", NULL };
| 29058 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:UMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_usageFlags) && |  | 29010 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:UMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_usageFlags) &&
| 29059 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 29011 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 29060 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 29012 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 29061 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 29013 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 29062 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) ) |  | 29014 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) )
| 29063 | { |  | 29015 | {
| 29064 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29016 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29065 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(rows, cols, type, usageFlags))); |  | 29017 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(rows, cols, type, usageFlags)));
| 29066 | return 0; |  | 29018 | return 0;
| 29067 | } |  | 29019 | }
| 29068 |  |  | 29020 |
| 29069 |  |  | 29021 |
| 29070 | pyPopulateArgumentConversionErrors(); |  | 29022 | pyPopulateArgumentConversionErrors();
| 29071 | } |  | 29023 | }
| 29072 |  |  | 29024 |
| 29073 |  |  | 29025 |
| 29074 | { |  | 29026 | {
| 29075 | PyObject* pyobj_size = NULL; |  | 29027 | PyObject* pyobj_size = NULL;
| 29076 | Size size; |  | 29028 | Size size;
| 29077 | PyObject* pyobj_type = NULL; |  | 29029 | PyObject* pyobj_type = NULL;
| 29078 | int type=0; |  | 29030 | int type=0;
| 29079 | PyObject* pyobj_usageFlags = NULL; |  | 29031 | PyObject* pyobj_usageFlags = NULL;
| 29080 | UMatUsageFlags usageFlags=USAGE_DEFAULT; |  | 29032 | UMatUsageFlags usageFlags=USAGE_DEFAULT;
| 29081 |  |  | 29033 |
| 29082 | const char* keywords[] = { "size", "type", "usageFlags", NULL }; |  | 29034 | const char* keywords[] = { "size", "type", "usageFlags", NULL };
| 29083 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:UMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_usageFlags) && |  | 29035 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:UMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_usageFlags) &&
| 29084 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 29036 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 29085 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 29037 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 29086 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) ) |  | 29038 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) )
| 29087 | { |  | 29039 | {
| 29088 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29040 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29089 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(size, type, usageFlags))); |  | 29041 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(size, type, usageFlags)));
| 29090 | return 0; |  | 29042 | return 0;
| 29091 | } |  | 29043 | }
| 29092 |  |  | 29044 |
| 29093 |  |  | 29045 |
| 29094 | pyPopulateArgumentConversionErrors(); |  | 29046 | pyPopulateArgumentConversionErrors();
| 29095 | } |  | 29047 | }
| 29096 |  |  | 29048 |
| 29097 |  |  | 29049 |
| 29098 | { |  | 29050 | {
| 29099 | PyObject* pyobj_rows = NULL; |  | 29051 | PyObject* pyobj_rows = NULL;
| 29100 | int rows=0; |  | 29052 | int rows=0;
| 29101 | PyObject* pyobj_cols = NULL; |  | 29053 | PyObject* pyobj_cols = NULL;
| 29102 | int cols=0; |  | 29054 | int cols=0;
| 29103 | PyObject* pyobj_type = NULL; |  | 29055 | PyObject* pyobj_type = NULL;
| 29104 | int type=0; |  | 29056 | int type=0;
| 29105 | PyObject* pyobj_s = NULL; |  | 29057 | PyObject* pyobj_s = NULL;
| 29106 | Scalar s; |  | 29058 | Scalar s;
| 29107 | PyObject* pyobj_usageFlags = NULL; |  | 29059 | PyObject* pyobj_usageFlags = NULL;
| 29108 | UMatUsageFlags usageFlags=USAGE_DEFAULT; |  | 29060 | UMatUsageFlags usageFlags=USAGE_DEFAULT;
| 29109 |  |  | 29061 |
| 29110 | const char* keywords[] = { "rows", "cols", "type", "s", "usageFlags", NULL }; |  | 29062 | const char* keywords[] = { "rows", "cols", "type", "s", "usageFlags", NULL };
| 29111 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:UMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_s, &pyobj_usageFlags) && |  | 29063 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:UMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_s, &pyobj_usageFlags) &&
| 29112 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 29064 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 29113 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 29065 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 29114 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 29066 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 29115 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 29067 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 29116 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) ) |  | 29068 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) )
| 29117 | { |  | 29069 | {
| 29118 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29070 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29119 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(rows, cols, type, s, usageFlags))); |  | 29071 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(rows, cols, type, s, usageFlags)));
| 29120 | return 0; |  | 29072 | return 0;
| 29121 | } |  | 29073 | }
| 29122 |  |  | 29074 |
| 29123 |  |  | 29075 |
| 29124 | pyPopulateArgumentConversionErrors(); |  | 29076 | pyPopulateArgumentConversionErrors();
| 29125 | } |  | 29077 | }
| 29126 |  |  | 29078 |
| 29127 |  |  | 29079 |
| 29128 | { |  | 29080 | {
| 29129 | PyObject* pyobj_size = NULL; |  | 29081 | PyObject* pyobj_size = NULL;
| 29130 | Size size; |  | 29082 | Size size;
| 29131 | PyObject* pyobj_type = NULL; |  | 29083 | PyObject* pyobj_type = NULL;
| 29132 | int type=0; |  | 29084 | int type=0;
| 29133 | PyObject* pyobj_s = NULL; |  | 29085 | PyObject* pyobj_s = NULL;
| 29134 | Scalar s; |  | 29086 | Scalar s;
| 29135 | PyObject* pyobj_usageFlags = NULL; |  | 29087 | PyObject* pyobj_usageFlags = NULL;
| 29136 | UMatUsageFlags usageFlags=USAGE_DEFAULT; |  | 29088 | UMatUsageFlags usageFlags=USAGE_DEFAULT;
| 29137 |  |  | 29089 |
| 29138 | const char* keywords[] = { "size", "type", "s", "usageFlags", NULL }; |  | 29090 | const char* keywords[] = { "size", "type", "s", "usageFlags", NULL };
| 29139 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:UMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_s, &pyobj_usageFlags) && |  | 29091 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:UMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_s, &pyobj_usageFlags) &&
| 29140 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 29092 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 29141 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 29093 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 29142 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 29094 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 29143 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) ) |  | 29095 | pyopencv_to_safe(pyobj_usageFlags, usageFlags, ArgInfo("usageFlags", 0)) )
| 29144 | { |  | 29096 | {
| 29145 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29097 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29146 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(size, type, s, usageFlags))); |  | 29098 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(size, type, s, usageFlags)));
| 29147 | return 0; |  | 29099 | return 0;
| 29148 | } |  | 29100 | }
| 29149 |  |  | 29101 |
| 29150 |  |  | 29102 |
| 29151 | pyPopulateArgumentConversionErrors(); |  | 29103 | pyPopulateArgumentConversionErrors();
| 29152 | } |  | 29104 | }
| 29153 |  |  | 29105 |
| 29154 |  |  | 29106 |
| 29155 | { |  | 29107 | {
| 29156 | PyObject* pyobj_m = NULL; |  | 29108 | PyObject* pyobj_m = NULL;
| 29157 | UMat m; |  | 29109 | UMat m;
| 29158 |  |  | 29110 |
| 29159 | const char* keywords[] = { "m", NULL }; |  | 29111 | const char* keywords[] = { "m", NULL };
| 29160 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:UMat", (char**)keywords, &pyobj_m) && |  | 29112 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:UMat", (char**)keywords, &pyobj_m) &&
| 29161 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) ) |  | 29113 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) )
| 29162 | { |  | 29114 | {
| 29163 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29115 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29164 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m))); |  | 29116 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m)));
| 29165 | return 0; |  | 29117 | return 0;
| 29166 | } |  | 29118 | }
| 29167 |  |  | 29119 |
| 29168 |  |  | 29120 |
| 29169 | pyPopulateArgumentConversionErrors(); |  | 29121 | pyPopulateArgumentConversionErrors();
| 29170 | } |  | 29122 | }
| 29171 |  |  | 29123 |
| 29172 |  |  | 29124 |
| 29173 | { |  | 29125 | {
| 29174 | PyObject* pyobj_m = NULL; |  | 29126 | PyObject* pyobj_m = NULL;
| 29175 | UMat m; |  | 29127 | UMat m;
| 29176 | PyObject* pyobj_rowRange = NULL; |  | 29128 | PyObject* pyobj_rowRange = NULL;
| 29177 | Range rowRange; |  | 29129 | Range rowRange;
| 29178 | PyObject* pyobj_colRange = NULL; |  | 29130 | PyObject* pyobj_colRange = NULL;
| 29179 | Range colRange=Range::all(); |  | 29131 | Range colRange=Range::all();
| 29180 |  |  | 29132 |
| 29181 | const char* keywords[] = { "m", "rowRange", "colRange", NULL }; |  | 29133 | const char* keywords[] = { "m", "rowRange", "colRange", NULL };
| 29182 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:UMat", (char**)keywords, &pyobj_m, &pyobj_rowRange, &pyobj_colRange) && |  | 29134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:UMat", (char**)keywords, &pyobj_m, &pyobj_rowRange, &pyobj_colRange) &&
| 29183 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) && |  | 29135 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) &&
| 29184 | pyopencv_to_safe(pyobj_rowRange, rowRange, ArgInfo("rowRange", 0)) && |  | 29136 | pyopencv_to_safe(pyobj_rowRange, rowRange, ArgInfo("rowRange", 0)) &&
| 29185 | pyopencv_to_safe(pyobj_colRange, colRange, ArgInfo("colRange", 0)) ) |  | 29137 | pyopencv_to_safe(pyobj_colRange, colRange, ArgInfo("colRange", 0)) )
| 29186 | { |  | 29138 | {
| 29187 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29139 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29188 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m, rowRange, colRange))); |  | 29140 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m, rowRange, colRange)));
| 29189 | return 0; |  | 29141 | return 0;
| 29190 | } |  | 29142 | }
| 29191 |  |  | 29143 |
| 29192 |  |  | 29144 |
| 29193 | pyPopulateArgumentConversionErrors(); |  | 29145 | pyPopulateArgumentConversionErrors();
| 29194 | } |  | 29146 | }
| 29195 |  |  | 29147 |
| 29196 |  |  | 29148 |
| 29197 | { |  | 29149 | {
| 29198 | PyObject* pyobj_m = NULL; |  | 29150 | PyObject* pyobj_m = NULL;
| 29199 | UMat m; |  | 29151 | UMat m;
| 29200 | PyObject* pyobj_roi = NULL; |  | 29152 | PyObject* pyobj_roi = NULL;
| 29201 | Rect roi; |  | 29153 | Rect roi;
| 29202 |  |  | 29154 |
| 29203 | const char* keywords[] = { "m", "roi", NULL }; |  | 29155 | const char* keywords[] = { "m", "roi", NULL };
| 29204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:UMat", (char**)keywords, &pyobj_m, &pyobj_roi) && |  | 29156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:UMat", (char**)keywords, &pyobj_m, &pyobj_roi) &&
| 29205 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) && |  | 29157 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) &&
| 29206 | pyopencv_to_safe(pyobj_roi, roi, ArgInfo("roi", 0)) ) |  | 29158 | pyopencv_to_safe(pyobj_roi, roi, ArgInfo("roi", 0)) )
| 29207 | { |  | 29159 | {
| 29208 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29160 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29209 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m, roi))); |  | 29161 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m, roi)));
| 29210 | return 0; |  | 29162 | return 0;
| 29211 | } |  | 29163 | }
| 29212 |  |  | 29164 |
| 29213 |  |  | 29165 |
| 29214 | pyPopulateArgumentConversionErrors(); |  | 29166 | pyPopulateArgumentConversionErrors();
| 29215 | } |  | 29167 | }
| 29216 |  |  | 29168 |
| 29217 |  |  | 29169 |
| 29218 | { |  | 29170 | {
| 29219 | PyObject* pyobj_m = NULL; |  | 29171 | PyObject* pyobj_m = NULL;
| 29220 | UMat m; |  | 29172 | UMat m;
| 29221 | PyObject* pyobj_ranges = NULL; |  | 29173 | PyObject* pyobj_ranges = NULL;
| 29222 | vector_Range ranges; |  | 29174 | vector_Range ranges;
| 29223 |  |  | 29175 |
| 29224 | const char* keywords[] = { "m", "ranges", NULL }; |  | 29176 | const char* keywords[] = { "m", "ranges", NULL };
| 29225 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:UMat", (char**)keywords, &pyobj_m, &pyobj_ranges) && |  | 29177 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:UMat", (char**)keywords, &pyobj_m, &pyobj_ranges) &&
| 29226 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) && |  | 29178 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) &&
| 29227 | pyopencv_to_safe(pyobj_ranges, ranges, ArgInfo("ranges", 0)) ) |  | 29179 | pyopencv_to_safe(pyobj_ranges, ranges, ArgInfo("ranges", 0)) )
| 29228 | { |  | 29180 | {
| 29229 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new |  | 29181 | new (&(self->v)) Ptr<cv::UMat>(); // init Ptr with placement new
| 29230 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m, ranges))); |  | 29182 | if(self) ERRWRAP2(self->v.reset(new cv::UMat(m, ranges)));
| 29231 | return 0; |  | 29183 | return 0;
| 29232 | } |  | 29184 | }
| 29233 |  |  | 29185 |
| 29234 |  |  | 29186 |
| 29235 | pyPopulateArgumentConversionErrors(); |  | 29187 | pyPopulateArgumentConversionErrors();
| 29236 | } |  | 29188 | }
| 29237 | pyRaiseCVOverloadException("UMat"); |  | 29189 | pyRaiseCVOverloadException("UMat");
| 29238 |  |  | 29190 |
| 29239 | return -1; |  | 29191 | return -1;
| 29240 | } |  | 29192 | }
| 29241 |  |  | 29193 |
| 29242 | static PyObject* pyopencv_cv_UMat_context_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29194 | static PyObject* pyopencv_cv_UMat_context_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 29243 | { |  | 29195 | {
| 29244 | using namespace cv; |  | 29196 | using namespace cv;
| 29245 |  |  | 29197 |
| 29246 | void* retval; |  | 29198 | void* retval;
| 29247 |  |  | 29199 |
| 29248 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29200 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29249 | { |  | 29201 | {
| 29250 | ERRWRAP2(retval = cv_UMat_context()); |  | 29202 | ERRWRAP2(retval = cv_UMat_context());
| 29251 | return pyopencv_from(retval); |  | 29203 | return pyopencv_from(retval);
| 29252 | } |  | 29204 | }
| 29253 |  |  | 29205 |
| 29254 | return NULL; |  | 29206 | return NULL;
| 29255 | } |  | 29207 | }
| 29256 |  |  | 29208 |
| 29257 | static PyObject* pyopencv_cv_UMat_get(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29209 | static PyObject* pyopencv_cv_UMat_get(PyObject* self, PyObject* py_args, PyObject* kw)
| 29258 | { |  | 29210 | {
| 29259 | using namespace cv; |  | 29211 | using namespace cv;
| 29260 |  |  | 29212 |
| 29261 |  |  | 29213 |
| 29262 | Ptr<cv::UMat> * self1 = 0; |  | 29214 | Ptr<cv::UMat> * self1 = 0;
| 29263 | if (!pyopencv_UMat_getp(self, self1)) |  | 29215 | if (!pyopencv_UMat_getp(self, self1))
| 29264 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)"); |  | 29216 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)");
| 29265 | Ptr<cv::UMat> _self_ = *(self1); |  | 29217 | Ptr<cv::UMat> _self_ = *(self1);
| 29266 | Mat retval; |  | 29218 | Mat retval;
| 29267 |  |  | 29219 |
| 29268 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29220 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29269 | { |  | 29221 | {
| 29270 | ERRWRAP2(retval = cv_UMat_get(_self_)); |  | 29222 | ERRWRAP2(retval = cv_UMat_get(_self_));
| 29271 | return pyopencv_from(retval); |  | 29223 | return pyopencv_from(retval);
| 29272 | } |  | 29224 | }
| 29273 |  |  | 29225 |
| 29274 | return NULL; |  | 29226 | return NULL;
| 29275 | } |  | 29227 | }
| 29276 |  |  | 29228 |
| 29277 | static PyObject* pyopencv_cv_UMat_handle(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29229 | static PyObject* pyopencv_cv_UMat_handle(PyObject* self, PyObject* py_args, PyObject* kw)
| 29278 | { |  | 29230 | {
| 29279 | using namespace cv; |  | 29231 | using namespace cv;
| 29280 |  |  | 29232 |
| 29281 |  |  | 29233 |
| 29282 | Ptr<cv::UMat> * self1 = 0; |  | 29234 | Ptr<cv::UMat> * self1 = 0;
| 29283 | if (!pyopencv_UMat_getp(self, self1)) |  | 29235 | if (!pyopencv_UMat_getp(self, self1))
| 29284 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)"); |  | 29236 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)");
| 29285 | Ptr<cv::UMat> _self_ = *(self1); |  | 29237 | Ptr<cv::UMat> _self_ = *(self1);
| 29286 | PyObject* pyobj_accessFlags = NULL; |  | 29238 | PyObject* pyobj_accessFlags = NULL;
| 29287 | AccessFlag accessFlags=static_cast<AccessFlag>(0); |  | 29239 | AccessFlag accessFlags=static_cast<AccessFlag>(0);
| 29288 | void* retval; |  | 29240 | void* retval;
| 29289 |  |  | 29241 |
| 29290 | const char* keywords[] = { "accessFlags", NULL }; |  | 29242 | const char* keywords[] = { "accessFlags", NULL };
| 29291 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:UMat.handle", (char**)keywords, &pyobj_accessFlags) && |  | 29243 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:UMat.handle", (char**)keywords, &pyobj_accessFlags) &&
| 29292 | pyopencv_to_safe(pyobj_accessFlags, accessFlags, ArgInfo("accessFlags", 0)) ) |  | 29244 | pyopencv_to_safe(pyobj_accessFlags, accessFlags, ArgInfo("accessFlags", 0)) )
| 29293 | { |  | 29245 | {
| 29294 | ERRWRAP2(retval = _self_->handle(accessFlags)); |  | 29246 | ERRWRAP2(retval = _self_->handle(accessFlags));
| 29295 | return pyopencv_from(retval); |  | 29247 | return pyopencv_from(retval);
| 29296 | } |  | 29248 | }
| 29297 |  |  | 29249 |
| 29298 | return NULL; |  | 29250 | return NULL;
| 29299 | } |  | 29251 | }
| 29300 |  |  | 29252 |
| 29301 | static PyObject* pyopencv_cv_UMat_isContinuous(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29253 | static PyObject* pyopencv_cv_UMat_isContinuous(PyObject* self, PyObject* py_args, PyObject* kw)
| 29302 | { |  | 29254 | {
| 29303 | using namespace cv; |  | 29255 | using namespace cv;
| 29304 |  |  | 29256 |
| 29305 |  |  | 29257 |
| 29306 | Ptr<cv::UMat> * self1 = 0; |  | 29258 | Ptr<cv::UMat> * self1 = 0;
| 29307 | if (!pyopencv_UMat_getp(self, self1)) |  | 29259 | if (!pyopencv_UMat_getp(self, self1))
| 29308 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)"); |  | 29260 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)");
| 29309 | Ptr<cv::UMat> _self_ = *(self1); |  | 29261 | Ptr<cv::UMat> _self_ = *(self1);
| 29310 | bool retval; |  | 29262 | bool retval;
| 29311 |  |  | 29263 |
| 29312 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29264 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29313 | { |  | 29265 | {
| 29314 | ERRWRAP2(retval = _self_->isContinuous()); |  | 29266 | ERRWRAP2(retval = _self_->isContinuous());
| 29315 | return pyopencv_from(retval); |  | 29267 | return pyopencv_from(retval);
| 29316 | } |  | 29268 | }
| 29317 |  |  | 29269 |
| 29318 | return NULL; |  | 29270 | return NULL;
| 29319 | } |  | 29271 | }
| 29320 |  |  | 29272 |
| 29321 | static PyObject* pyopencv_cv_UMat_isSubmatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29273 | static PyObject* pyopencv_cv_UMat_isSubmatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 29322 | { |  | 29274 | {
| 29323 | using namespace cv; |  | 29275 | using namespace cv;
| 29324 |  |  | 29276 |
| 29325 |  |  | 29277 |
| 29326 | Ptr<cv::UMat> * self1 = 0; |  | 29278 | Ptr<cv::UMat> * self1 = 0;
| 29327 | if (!pyopencv_UMat_getp(self, self1)) |  | 29279 | if (!pyopencv_UMat_getp(self, self1))
| 29328 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)"); |  | 29280 | return failmsgp("Incorrect type of self (must be 'UMat' or its derivative)");
| 29329 | Ptr<cv::UMat> _self_ = *(self1); |  | 29281 | Ptr<cv::UMat> _self_ = *(self1);
| 29330 | bool retval; |  | 29282 | bool retval;
| 29331 |  |  | 29283 |
| 29332 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29284 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29333 | { |  | 29285 | {
| 29334 | ERRWRAP2(retval = _self_->isSubmatrix()); |  | 29286 | ERRWRAP2(retval = _self_->isSubmatrix());
| 29335 | return pyopencv_from(retval); |  | 29287 | return pyopencv_from(retval);
| 29336 | } |  | 29288 | }
| 29337 |  |  | 29289 |
| 29338 | return NULL; |  | 29290 | return NULL;
| 29339 | } |  | 29291 | }
| 29340 |  |  | 29292 |
| 29341 | static PyObject* pyopencv_cv_UMat_queue_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29293 | static PyObject* pyopencv_cv_UMat_queue_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 29342 | { |  | 29294 | {
| 29343 | using namespace cv; |  | 29295 | using namespace cv;
| 29344 |  |  | 29296 |
| 29345 | void* retval; |  | 29297 | void* retval;
| 29346 |  |  | 29298 |
| 29347 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29299 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29348 | { |  | 29300 | {
| 29349 | ERRWRAP2(retval = cv_UMat_queue()); |  | 29301 | ERRWRAP2(retval = cv_UMat_queue());
| 29350 | return pyopencv_from(retval); |  | 29302 | return pyopencv_from(retval);
| 29351 | } |  | 29303 | }
| 29352 |  |  | 29304 |
| 29353 | return NULL; |  | 29305 | return NULL;
| 29354 | } |  | 29306 | }
| 29355 |  |  | 29307 |
| 29356 |  |  | 29308 |
| 29357 |  |  | 29309 |
| 29358 | // Tables (UMat) |  | 29310 | // Tables (UMat)
| 29359 |  |  | 29311 |
| 29360 | static PyGetSetDef pyopencv_UMat_getseters[] = |  | 29312 | static PyGetSetDef pyopencv_UMat_getseters[] =
| 29361 | { |  | 29313 | {
| 29362 | {(char*)"offset", (getter)pyopencv_UMat_get_offset, (setter)pyopencv_UMat_set_offset, (char*)"offset", NULL}, |  | 29314 | {(char*)"offset", (getter)pyopencv_UMat_get_offset, (setter)pyopencv_UMat_set_offset, (char*)"offset", NULL},
| 29363 | {NULL} /* Sentinel */ |  | 29315 | {NULL} /* Sentinel */
| 29364 | }; |  | 29316 | };
| 29365 |  |  | 29317 |
| 29366 | static PyMethodDef pyopencv_UMat_methods[] = |  | 29318 | static PyMethodDef pyopencv_UMat_methods[] =
| 29367 | { |  | 29319 | {
| 29368 | {"context", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_context_static, METH_STATIC), "context() -> retval\n."}, |  | 29320 | {"context", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_context_static, METH_STATIC), "context() -> retval\n."},
| 29369 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_get, 0), "get() -> retval\n."}, |  | 29321 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_get, 0), "get() -> retval\n."},
| 29370 | {"handle", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_handle, 0), "handle(accessFlags) -> retval\n."}, |  | 29322 | {"handle", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_handle, 0), "handle(accessFlags) -> retval\n."},
| 29371 | {"isContinuous", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_isContinuous, 0), "isContinuous() -> retval\n."}, |  | 29323 | {"isContinuous", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_isContinuous, 0), "isContinuous() -> retval\n."},
| 29372 | {"isSubmatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_isSubmatrix, 0), "isSubmatrix() -> retval\n."}, |  | 29324 | {"isSubmatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_isSubmatrix, 0), "isSubmatrix() -> retval\n."},
| 29373 | {"queue", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_queue_static, METH_STATIC), "queue() -> retval\n."}, |  | 29325 | {"queue", CV_PY_FN_WITH_KW_(pyopencv_cv_UMat_queue_static, METH_STATIC), "queue() -> retval\n."},
| 29374 |  |  | 29326 |
| 29375 | {NULL, NULL} |  | 29327 | {NULL, NULL}
| 29376 | }; |  | 29328 | };
| 29377 |  |  | 29329 |
| 29378 | // Converter (UMat) |  | 29330 | // Converter (UMat)
| 29379 |  |  | 29331 |
| 29380 | template<> |  | 29332 | template<>
| 29381 | struct PyOpenCV_Converter< Ptr<cv::UMat> > |  | 29333 | struct PyOpenCV_Converter< Ptr<cv::UMat> >
| 29382 | { |  | 29334 | {
| 29383 | static PyObject* from(const Ptr<cv::UMat>& r) |  | 29335 | static PyObject* from(const Ptr<cv::UMat>& r)
| 29384 | { |  | 29336 | {
| 29385 | return pyopencv_UMat_Instance(r); |  | 29337 | return pyopencv_UMat_Instance(r);
| 29386 | } |  | 29338 | }
| 29387 | static bool to(PyObject* src, Ptr<cv::UMat>& dst, const ArgInfo& info) |  | 29339 | static bool to(PyObject* src, Ptr<cv::UMat>& dst, const ArgInfo& info)
| 29388 | { |  | 29340 | {
| 29389 | if(!src || src == Py_None) |  | 29341 | if(!src || src == Py_None)
| 29390 | return true; |  | 29342 | return true;
| 29391 | Ptr<cv::UMat> * dst_; |  | 29343 | Ptr<cv::UMat> * dst_;
| 29392 | if (pyopencv_UMat_getp(src, dst_)) |  | 29344 | if (pyopencv_UMat_getp(src, dst_))
| 29393 | { |  | 29345 | {
| 29394 | dst = *dst_; |  | 29346 | dst = *dst_;
| 29395 | return true; |  | 29347 | return true;
| 29396 | } |  | 29348 | }
| 29397 |  |  | 29349 |
| 29398 | { |  | 29350 | {
| 29399 | Ptr<Mat> _src; |  | 29351 | Ptr<Mat> _src;
| 29400 | if (pyopencv_to_safe(src, _src, info)) |  | 29352 | if (pyopencv_to_safe(src, _src, info))
| 29401 | { |  | 29353 | {
| 29402 | return cv_mappable_to(_src, dst); |  | 29354 | return cv_mappable_to(_src, dst);
| 29403 | } |  | 29355 | }
| 29404 | } |  | 29356 | }
| 29405 |  |  | 29357 |
| 29406 | failmsg("Expected Ptr<cv::UMat> for argument '%s'", info.name); |  | 29358 | failmsg("Expected Ptr<cv::UMat> for argument '%s'", info.name);
| 29407 | return false; |  | 29359 | return false;
| 29408 | } |  | 29360 | }
| 29409 | }; |  | 29361 | };
| 29410 |  |  | 29362 |
| 29411 | //================================================================================ |  | 29363 | //================================================================================
| 29412 | // UsacParams (Generic) |  | 29364 | // UsacParams (Generic)
| 29413 | //================================================================================ |  | 29365 | //================================================================================
| 29414 |  |  | 29366 |
| 29415 | // GetSet (UsacParams) |  | 29367 | // GetSet (UsacParams)
| 29416 |  |  | 29368 |
| 29417 |  |  | 29369 |
| 29418 | static PyObject* pyopencv_UsacParams_get_confidence(pyopencv_UsacParams_t* p, void *closure) |  | 29370 | static PyObject* pyopencv_UsacParams_get_confidence(pyopencv_UsacParams_t* p, void *closure)
| 29419 | { |  | 29371 | {
| 29420 | return pyopencv_from(p->v.confidence); |  | 29372 | return pyopencv_from(p->v.confidence);
| 29421 | } |  | 29373 | }
| 29422 |  |  | 29374 |
| 29423 | static int pyopencv_UsacParams_set_confidence(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29375 | static int pyopencv_UsacParams_set_confidence(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29424 | { |  | 29376 | {
| 29425 | if (!value) |  | 29377 | if (!value)
| 29426 | { |  | 29378 | {
| 29427 | PyErr_SetString(PyExc_TypeError, "Cannot delete the confidence attribute"); |  | 29379 | PyErr_SetString(PyExc_TypeError, "Cannot delete the confidence attribute");
| 29428 | return -1; |  | 29380 | return -1;
| 29429 | } |  | 29381 | }
| 29430 | return pyopencv_to_safe(value, p->v.confidence, ArgInfo("value", 0)) ? 0 : -1; |  | 29382 | return pyopencv_to_safe(value, p->v.confidence, ArgInfo("value", 0)) ? 0 : -1;
| 29431 | } |  | 29383 | }
| 29432 |  |  | 29384 |
| 29433 | static PyObject* pyopencv_UsacParams_get_final_polisher(pyopencv_UsacParams_t* p, void *closure) |  | 29385 | static PyObject* pyopencv_UsacParams_get_final_polisher(pyopencv_UsacParams_t* p, void *closure)
| 29434 | { |  | 29386 | {
| 29435 | return pyopencv_from(p->v.final_polisher); |  | 29387 | return pyopencv_from(p->v.final_polisher);
| 29436 | } |  | 29388 | }
| 29437 |  |  | 29389 |
| 29438 | static int pyopencv_UsacParams_set_final_polisher(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29390 | static int pyopencv_UsacParams_set_final_polisher(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29439 | { |  | 29391 | {
| 29440 | if (!value) |  | 29392 | if (!value)
| 29441 | { |  | 29393 | {
| 29442 | PyErr_SetString(PyExc_TypeError, "Cannot delete the final_polisher attribute"); |  | 29394 | PyErr_SetString(PyExc_TypeError, "Cannot delete the final_polisher attribute");
| 29443 | return -1; |  | 29395 | return -1;
| 29444 | } |  | 29396 | }
| 29445 | return pyopencv_to_safe(value, p->v.final_polisher, ArgInfo("value", 0)) ? 0 : -1; |  | 29397 | return pyopencv_to_safe(value, p->v.final_polisher, ArgInfo("value", 0)) ? 0 : -1;
| 29446 | } |  | 29398 | }
| 29447 |  |  | 29399 |
| 29448 | static PyObject* pyopencv_UsacParams_get_final_polisher_iterations(pyopencv_UsacParams_t* p, void *closure) |  | 29400 | static PyObject* pyopencv_UsacParams_get_final_polisher_iterations(pyopencv_UsacParams_t* p, void *closure)
| 29449 | { |  | 29401 | {
| 29450 | return pyopencv_from(p->v.final_polisher_iterations); |  | 29402 | return pyopencv_from(p->v.final_polisher_iterations);
| 29451 | } |  | 29403 | }
| 29452 |  |  | 29404 |
| 29453 | static int pyopencv_UsacParams_set_final_polisher_iterations(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29405 | static int pyopencv_UsacParams_set_final_polisher_iterations(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29454 | { |  | 29406 | {
| 29455 | if (!value) |  | 29407 | if (!value)
| 29456 | { |  | 29408 | {
| 29457 | PyErr_SetString(PyExc_TypeError, "Cannot delete the final_polisher_iterations attribute"); |  | 29409 | PyErr_SetString(PyExc_TypeError, "Cannot delete the final_polisher_iterations attribute");
| 29458 | return -1; |  | 29410 | return -1;
| 29459 | } |  | 29411 | }
| 29460 | return pyopencv_to_safe(value, p->v.final_polisher_iterations, ArgInfo("value", 0)) ? 0 : -1; |  | 29412 | return pyopencv_to_safe(value, p->v.final_polisher_iterations, ArgInfo("value", 0)) ? 0 : -1;
| 29461 | } |  | 29413 | }
| 29462 |  |  | 29414 |
| 29463 | static PyObject* pyopencv_UsacParams_get_isParallel(pyopencv_UsacParams_t* p, void *closure) |  | 29415 | static PyObject* pyopencv_UsacParams_get_isParallel(pyopencv_UsacParams_t* p, void *closure)
| 29464 | { |  | 29416 | {
| 29465 | return pyopencv_from(p->v.isParallel); |  | 29417 | return pyopencv_from(p->v.isParallel);
| 29466 | } |  | 29418 | }
| 29467 |  |  | 29419 |
| 29468 | static int pyopencv_UsacParams_set_isParallel(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29420 | static int pyopencv_UsacParams_set_isParallel(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29469 | { |  | 29421 | {
| 29470 | if (!value) |  | 29422 | if (!value)
| 29471 | { |  | 29423 | {
| 29472 | PyErr_SetString(PyExc_TypeError, "Cannot delete the isParallel attribute"); |  | 29424 | PyErr_SetString(PyExc_TypeError, "Cannot delete the isParallel attribute");
| 29473 | return -1; |  | 29425 | return -1;
| 29474 | } |  | 29426 | }
| 29475 | return pyopencv_to_safe(value, p->v.isParallel, ArgInfo("value", 0)) ? 0 : -1; |  | 29427 | return pyopencv_to_safe(value, p->v.isParallel, ArgInfo("value", 0)) ? 0 : -1;
| 29476 | } |  | 29428 | }
| 29477 |  |  | 29429 |
| 29478 | static PyObject* pyopencv_UsacParams_get_loIterations(pyopencv_UsacParams_t* p, void *closure) |  | 29430 | static PyObject* pyopencv_UsacParams_get_loIterations(pyopencv_UsacParams_t* p, void *closure)
| 29479 | { |  | 29431 | {
| 29480 | return pyopencv_from(p->v.loIterations); |  | 29432 | return pyopencv_from(p->v.loIterations);
| 29481 | } |  | 29433 | }
| 29482 |  |  | 29434 |
| 29483 | static int pyopencv_UsacParams_set_loIterations(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29435 | static int pyopencv_UsacParams_set_loIterations(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29484 | { |  | 29436 | {
| 29485 | if (!value) |  | 29437 | if (!value)
| 29486 | { |  | 29438 | {
| 29487 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loIterations attribute"); |  | 29439 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loIterations attribute");
| 29488 | return -1; |  | 29440 | return -1;
| 29489 | } |  | 29441 | }
| 29490 | return pyopencv_to_safe(value, p->v.loIterations, ArgInfo("value", 0)) ? 0 : -1; |  | 29442 | return pyopencv_to_safe(value, p->v.loIterations, ArgInfo("value", 0)) ? 0 : -1;
| 29491 | } |  | 29443 | }
| 29492 |  |  | 29444 |
| 29493 | static PyObject* pyopencv_UsacParams_get_loMethod(pyopencv_UsacParams_t* p, void *closure) |  | 29445 | static PyObject* pyopencv_UsacParams_get_loMethod(pyopencv_UsacParams_t* p, void *closure)
| 29494 | { |  | 29446 | {
| 29495 | return pyopencv_from(p->v.loMethod); |  | 29447 | return pyopencv_from(p->v.loMethod);
| 29496 | } |  | 29448 | }
| 29497 |  |  | 29449 |
| 29498 | static int pyopencv_UsacParams_set_loMethod(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29450 | static int pyopencv_UsacParams_set_loMethod(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29499 | { |  | 29451 | {
| 29500 | if (!value) |  | 29452 | if (!value)
| 29501 | { |  | 29453 | {
| 29502 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loMethod attribute"); |  | 29454 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loMethod attribute");
| 29503 | return -1; |  | 29455 | return -1;
| 29504 | } |  | 29456 | }
| 29505 | return pyopencv_to_safe(value, p->v.loMethod, ArgInfo("value", 0)) ? 0 : -1; |  | 29457 | return pyopencv_to_safe(value, p->v.loMethod, ArgInfo("value", 0)) ? 0 : -1;
| 29506 | } |  | 29458 | }
| 29507 |  |  | 29459 |
| 29508 | static PyObject* pyopencv_UsacParams_get_loSampleSize(pyopencv_UsacParams_t* p, void *closure) |  | 29460 | static PyObject* pyopencv_UsacParams_get_loSampleSize(pyopencv_UsacParams_t* p, void *closure)
| 29509 | { |  | 29461 | {
| 29510 | return pyopencv_from(p->v.loSampleSize); |  | 29462 | return pyopencv_from(p->v.loSampleSize);
| 29511 | } |  | 29463 | }
| 29512 |  |  | 29464 |
| 29513 | static int pyopencv_UsacParams_set_loSampleSize(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29465 | static int pyopencv_UsacParams_set_loSampleSize(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29514 | { |  | 29466 | {
| 29515 | if (!value) |  | 29467 | if (!value)
| 29516 | { |  | 29468 | {
| 29517 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loSampleSize attribute"); |  | 29469 | PyErr_SetString(PyExc_TypeError, "Cannot delete the loSampleSize attribute");
| 29518 | return -1; |  | 29470 | return -1;
| 29519 | } |  | 29471 | }
| 29520 | return pyopencv_to_safe(value, p->v.loSampleSize, ArgInfo("value", 0)) ? 0 : -1; |  | 29472 | return pyopencv_to_safe(value, p->v.loSampleSize, ArgInfo("value", 0)) ? 0 : -1;
| 29521 | } |  | 29473 | }
| 29522 |  |  | 29474 |
| 29523 | static PyObject* pyopencv_UsacParams_get_maxIterations(pyopencv_UsacParams_t* p, void *closure) |  | 29475 | static PyObject* pyopencv_UsacParams_get_maxIterations(pyopencv_UsacParams_t* p, void *closure)
| 29524 | { |  | 29476 | {
| 29525 | return pyopencv_from(p->v.maxIterations); |  | 29477 | return pyopencv_from(p->v.maxIterations);
| 29526 | } |  | 29478 | }
| 29527 |  |  | 29479 |
| 29528 | static int pyopencv_UsacParams_set_maxIterations(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29480 | static int pyopencv_UsacParams_set_maxIterations(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29529 | { |  | 29481 | {
| 29530 | if (!value) |  | 29482 | if (!value)
| 29531 | { |  | 29483 | {
| 29532 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxIterations attribute"); |  | 29484 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxIterations attribute");
| 29533 | return -1; |  | 29485 | return -1;
| 29534 | } |  | 29486 | }
| 29535 | return pyopencv_to_safe(value, p->v.maxIterations, ArgInfo("value", 0)) ? 0 : -1; |  | 29487 | return pyopencv_to_safe(value, p->v.maxIterations, ArgInfo("value", 0)) ? 0 : -1;
| 29536 | } |  | 29488 | }
| 29537 |  |  | 29489 |
| 29538 | static PyObject* pyopencv_UsacParams_get_neighborsSearch(pyopencv_UsacParams_t* p, void *closure) |  | 29490 | static PyObject* pyopencv_UsacParams_get_neighborsSearch(pyopencv_UsacParams_t* p, void *closure)
| 29539 | { |  | 29491 | {
| 29540 | return pyopencv_from(p->v.neighborsSearch); |  | 29492 | return pyopencv_from(p->v.neighborsSearch);
| 29541 | } |  | 29493 | }
| 29542 |  |  | 29494 |
| 29543 | static int pyopencv_UsacParams_set_neighborsSearch(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29495 | static int pyopencv_UsacParams_set_neighborsSearch(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29544 | { |  | 29496 | {
| 29545 | if (!value) |  | 29497 | if (!value)
| 29546 | { |  | 29498 | {
| 29547 | PyErr_SetString(PyExc_TypeError, "Cannot delete the neighborsSearch attribute"); |  | 29499 | PyErr_SetString(PyExc_TypeError, "Cannot delete the neighborsSearch attribute");
| 29548 | return -1; |  | 29500 | return -1;
| 29549 | } |  | 29501 | }
| 29550 | return pyopencv_to_safe(value, p->v.neighborsSearch, ArgInfo("value", 0)) ? 0 : -1; |  | 29502 | return pyopencv_to_safe(value, p->v.neighborsSearch, ArgInfo("value", 0)) ? 0 : -1;
| 29551 | } |  | 29503 | }
| 29552 |  |  | 29504 |
| 29553 | static PyObject* pyopencv_UsacParams_get_randomGeneratorState(pyopencv_UsacParams_t* p, void *closure) |  | 29505 | static PyObject* pyopencv_UsacParams_get_randomGeneratorState(pyopencv_UsacParams_t* p, void *closure)
| 29554 | { |  | 29506 | {
| 29555 | return pyopencv_from(p->v.randomGeneratorState); |  | 29507 | return pyopencv_from(p->v.randomGeneratorState);
| 29556 | } |  | 29508 | }
| 29557 |  |  | 29509 |
| 29558 | static int pyopencv_UsacParams_set_randomGeneratorState(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29510 | static int pyopencv_UsacParams_set_randomGeneratorState(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29559 | { |  | 29511 | {
| 29560 | if (!value) |  | 29512 | if (!value)
| 29561 | { |  | 29513 | {
| 29562 | PyErr_SetString(PyExc_TypeError, "Cannot delete the randomGeneratorState attribute"); |  | 29514 | PyErr_SetString(PyExc_TypeError, "Cannot delete the randomGeneratorState attribute");
| 29563 | return -1; |  | 29515 | return -1;
| 29564 | } |  | 29516 | }
| 29565 | return pyopencv_to_safe(value, p->v.randomGeneratorState, ArgInfo("value", 0)) ? 0 : -1; |  | 29517 | return pyopencv_to_safe(value, p->v.randomGeneratorState, ArgInfo("value", 0)) ? 0 : -1;
| 29566 | } |  | 29518 | }
| 29567 |  |  | 29519 |
| 29568 | static PyObject* pyopencv_UsacParams_get_sampler(pyopencv_UsacParams_t* p, void *closure) |  | 29520 | static PyObject* pyopencv_UsacParams_get_sampler(pyopencv_UsacParams_t* p, void *closure)
| 29569 | { |  | 29521 | {
| 29570 | return pyopencv_from(p->v.sampler); |  | 29522 | return pyopencv_from(p->v.sampler);
| 29571 | } |  | 29523 | }
| 29572 |  |  | 29524 |
| 29573 | static int pyopencv_UsacParams_set_sampler(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29525 | static int pyopencv_UsacParams_set_sampler(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29574 | { |  | 29526 | {
| 29575 | if (!value) |  | 29527 | if (!value)
| 29576 | { |  | 29528 | {
| 29577 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sampler attribute"); |  | 29529 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sampler attribute");
| 29578 | return -1; |  | 29530 | return -1;
| 29579 | } |  | 29531 | }
| 29580 | return pyopencv_to_safe(value, p->v.sampler, ArgInfo("value", 0)) ? 0 : -1; |  | 29532 | return pyopencv_to_safe(value, p->v.sampler, ArgInfo("value", 0)) ? 0 : -1;
| 29581 | } |  | 29533 | }
| 29582 |  |  | 29534 |
| 29583 | static PyObject* pyopencv_UsacParams_get_score(pyopencv_UsacParams_t* p, void *closure) |  | 29535 | static PyObject* pyopencv_UsacParams_get_score(pyopencv_UsacParams_t* p, void *closure)
| 29584 | { |  | 29536 | {
| 29585 | return pyopencv_from(p->v.score); |  | 29537 | return pyopencv_from(p->v.score);
| 29586 | } |  | 29538 | }
| 29587 |  |  | 29539 |
| 29588 | static int pyopencv_UsacParams_set_score(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29540 | static int pyopencv_UsacParams_set_score(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29589 | { |  | 29541 | {
| 29590 | if (!value) |  | 29542 | if (!value)
| 29591 | { |  | 29543 | {
| 29592 | PyErr_SetString(PyExc_TypeError, "Cannot delete the score attribute"); |  | 29544 | PyErr_SetString(PyExc_TypeError, "Cannot delete the score attribute");
| 29593 | return -1; |  | 29545 | return -1;
| 29594 | } |  | 29546 | }
| 29595 | return pyopencv_to_safe(value, p->v.score, ArgInfo("value", 0)) ? 0 : -1; |  | 29547 | return pyopencv_to_safe(value, p->v.score, ArgInfo("value", 0)) ? 0 : -1;
| 29596 | } |  | 29548 | }
| 29597 |  |  | 29549 |
| 29598 | static PyObject* pyopencv_UsacParams_get_threshold(pyopencv_UsacParams_t* p, void *closure) |  | 29550 | static PyObject* pyopencv_UsacParams_get_threshold(pyopencv_UsacParams_t* p, void *closure)
| 29599 | { |  | 29551 | {
| 29600 | return pyopencv_from(p->v.threshold); |  | 29552 | return pyopencv_from(p->v.threshold);
| 29601 | } |  | 29553 | }
| 29602 |  |  | 29554 |
| 29603 | static int pyopencv_UsacParams_set_threshold(pyopencv_UsacParams_t* p, PyObject *value, void *closure) |  | 29555 | static int pyopencv_UsacParams_set_threshold(pyopencv_UsacParams_t* p, PyObject *value, void *closure)
| 29604 | { |  | 29556 | {
| 29605 | if (!value) |  | 29557 | if (!value)
| 29606 | { |  | 29558 | {
| 29607 | PyErr_SetString(PyExc_TypeError, "Cannot delete the threshold attribute"); |  | 29559 | PyErr_SetString(PyExc_TypeError, "Cannot delete the threshold attribute");
| 29608 | return -1; |  | 29560 | return -1;
| 29609 | } |  | 29561 | }
| 29610 | return pyopencv_to_safe(value, p->v.threshold, ArgInfo("value", 0)) ? 0 : -1; |  | 29562 | return pyopencv_to_safe(value, p->v.threshold, ArgInfo("value", 0)) ? 0 : -1;
| 29611 | } |  | 29563 | }
| 29612 |  |  | 29564 |
| 29613 |  |  | 29565 |
| 29614 | // Methods (UsacParams) |  | 29566 | // Methods (UsacParams)
| 29615 |  |  | 29567 |
| 29616 | static int pyopencv_cv_UsacParams_UsacParams(pyopencv_UsacParams_t* self, PyObject* py_args, PyObject* kw) |  | 29568 | static int pyopencv_cv_UsacParams_UsacParams(pyopencv_UsacParams_t* self, PyObject* py_args, PyObject* kw)
| 29617 | { |  | 29569 | {
| 29618 | using namespace cv; |  | 29570 | using namespace cv;
| 29619 |  |  | 29571 |
| 29620 |  |  | 29572 |
| 29621 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29573 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29622 | { |  | 29574 | {
| 29623 | if(self) ERRWRAP2(new (&(self->v)) cv::UsacParams()); |  | 29575 | if(self) ERRWRAP2(new (&(self->v)) cv::UsacParams());
| 29624 | return 0; |  | 29576 | return 0;
| 29625 | } |  | 29577 | }
| 29626 |  |  | 29578 |
| 29627 | return -1; |  | 29579 | return -1;
| 29628 | } |  | 29580 | }
| 29629 |  |  | 29581 |
| 29630 |  |  | 29582 |
| 29631 |  |  | 29583 |
| 29632 | // Tables (UsacParams) |  | 29584 | // Tables (UsacParams)
| 29633 |  |  | 29585 |
| 29634 | static PyGetSetDef pyopencv_UsacParams_getseters[] = |  | 29586 | static PyGetSetDef pyopencv_UsacParams_getseters[] =
| 29635 | { |  | 29587 | {
| 29636 | {(char*)"confidence", (getter)pyopencv_UsacParams_get_confidence, (setter)pyopencv_UsacParams_set_confidence, (char*)"confidence", NULL}, |  | 29588 | {(char*)"confidence", (getter)pyopencv_UsacParams_get_confidence, (setter)pyopencv_UsacParams_set_confidence, (char*)"confidence", NULL},
| 29637 | {(char*)"final_polisher", (getter)pyopencv_UsacParams_get_final_polisher, (setter)pyopencv_UsacParams_set_final_polisher, (char*)"final_polisher", NULL}, |  | 29589 | {(char*)"final_polisher", (getter)pyopencv_UsacParams_get_final_polisher, (setter)pyopencv_UsacParams_set_final_polisher, (char*)"final_polisher", NULL},
| 29638 | {(char*)"final_polisher_iterations", (getter)pyopencv_UsacParams_get_final_polisher_iterations, (setter)pyopencv_UsacParams_set_final_polisher_iterations, (char*)"final_polisher_iterations", NULL}, |  | 29590 | {(char*)"final_polisher_iterations", (getter)pyopencv_UsacParams_get_final_polisher_iterations, (setter)pyopencv_UsacParams_set_final_polisher_iterations, (char*)"final_polisher_iterations", NULL},
| 29639 | {(char*)"isParallel", (getter)pyopencv_UsacParams_get_isParallel, (setter)pyopencv_UsacParams_set_isParallel, (char*)"isParallel", NULL}, |  | 29591 | {(char*)"isParallel", (getter)pyopencv_UsacParams_get_isParallel, (setter)pyopencv_UsacParams_set_isParallel, (char*)"isParallel", NULL},
| 29640 | {(char*)"loIterations", (getter)pyopencv_UsacParams_get_loIterations, (setter)pyopencv_UsacParams_set_loIterations, (char*)"loIterations", NULL}, |  | 29592 | {(char*)"loIterations", (getter)pyopencv_UsacParams_get_loIterations, (setter)pyopencv_UsacParams_set_loIterations, (char*)"loIterations", NULL},
| 29641 | {(char*)"loMethod", (getter)pyopencv_UsacParams_get_loMethod, (setter)pyopencv_UsacParams_set_loMethod, (char*)"loMethod", NULL}, |  | 29593 | {(char*)"loMethod", (getter)pyopencv_UsacParams_get_loMethod, (setter)pyopencv_UsacParams_set_loMethod, (char*)"loMethod", NULL},
| 29642 | {(char*)"loSampleSize", (getter)pyopencv_UsacParams_get_loSampleSize, (setter)pyopencv_UsacParams_set_loSampleSize, (char*)"loSampleSize", NULL}, |  | 29594 | {(char*)"loSampleSize", (getter)pyopencv_UsacParams_get_loSampleSize, (setter)pyopencv_UsacParams_set_loSampleSize, (char*)"loSampleSize", NULL},
| 29643 | {(char*)"maxIterations", (getter)pyopencv_UsacParams_get_maxIterations, (setter)pyopencv_UsacParams_set_maxIterations, (char*)"maxIterations", NULL}, |  | 29595 | {(char*)"maxIterations", (getter)pyopencv_UsacParams_get_maxIterations, (setter)pyopencv_UsacParams_set_maxIterations, (char*)"maxIterations", NULL},
| 29644 | {(char*)"neighborsSearch", (getter)pyopencv_UsacParams_get_neighborsSearch, (setter)pyopencv_UsacParams_set_neighborsSearch, (char*)"neighborsSearch", NULL}, |  | 29596 | {(char*)"neighborsSearch", (getter)pyopencv_UsacParams_get_neighborsSearch, (setter)pyopencv_UsacParams_set_neighborsSearch, (char*)"neighborsSearch", NULL},
| 29645 | {(char*)"randomGeneratorState", (getter)pyopencv_UsacParams_get_randomGeneratorState, (setter)pyopencv_UsacParams_set_randomGeneratorState, (char*)"randomGeneratorState", NULL}, |  | 29597 | {(char*)"randomGeneratorState", (getter)pyopencv_UsacParams_get_randomGeneratorState, (setter)pyopencv_UsacParams_set_randomGeneratorState, (char*)"randomGeneratorState", NULL},
| 29646 | {(char*)"sampler", (getter)pyopencv_UsacParams_get_sampler, (setter)pyopencv_UsacParams_set_sampler, (char*)"sampler", NULL}, |  | 29598 | {(char*)"sampler", (getter)pyopencv_UsacParams_get_sampler, (setter)pyopencv_UsacParams_set_sampler, (char*)"sampler", NULL},
| 29647 | {(char*)"score", (getter)pyopencv_UsacParams_get_score, (setter)pyopencv_UsacParams_set_score, (char*)"score", NULL}, |  | 29599 | {(char*)"score", (getter)pyopencv_UsacParams_get_score, (setter)pyopencv_UsacParams_set_score, (char*)"score", NULL},
| 29648 | {(char*)"threshold", (getter)pyopencv_UsacParams_get_threshold, (setter)pyopencv_UsacParams_set_threshold, (char*)"threshold", NULL}, |  | 29600 | {(char*)"threshold", (getter)pyopencv_UsacParams_get_threshold, (setter)pyopencv_UsacParams_set_threshold, (char*)"threshold", NULL},
| 29649 | {NULL} /* Sentinel */ |  | 29601 | {NULL} /* Sentinel */
| 29650 | }; |  | 29602 | };
| 29651 |  |  | 29603 |
| 29652 | static PyMethodDef pyopencv_UsacParams_methods[] = |  | 29604 | static PyMethodDef pyopencv_UsacParams_methods[] =
| 29653 | { |  | 29605 | {
| 29654 |  |  | 29606 |
| 29655 | {NULL, NULL} |  | 29607 | {NULL, NULL}
| 29656 | }; |  | 29608 | };
| 29657 |  |  | 29609 |
| 29658 | // Converter (UsacParams) |  | 29610 | // Converter (UsacParams)
| 29659 |  |  | 29611 |
| 29660 | template<> |  | 29612 | template<>
| 29661 | struct PyOpenCV_Converter< cv::UsacParams > |  | 29613 | struct PyOpenCV_Converter< cv::UsacParams >
| 29662 | { |  | 29614 | {
| 29663 | static PyObject* from(const cv::UsacParams& r) |  | 29615 | static PyObject* from(const cv::UsacParams& r)
| 29664 | { |  | 29616 | {
| 29665 | return pyopencv_UsacParams_Instance(r); |  | 29617 | return pyopencv_UsacParams_Instance(r);
| 29666 | } |  | 29618 | }
| 29667 | static bool to(PyObject* src, cv::UsacParams& dst, const ArgInfo& info) |  | 29619 | static bool to(PyObject* src, cv::UsacParams& dst, const ArgInfo& info)
| 29668 | { |  | 29620 | {
| 29669 | if(!src || src == Py_None) |  | 29621 | if(!src || src == Py_None)
| 29670 | return true; |  | 29622 | return true;
| 29671 | cv::UsacParams * dst_; |  | 29623 | cv::UsacParams * dst_;
| 29672 | if (pyopencv_UsacParams_getp(src, dst_)) |  | 29624 | if (pyopencv_UsacParams_getp(src, dst_))
| 29673 | { |  | 29625 | {
| 29674 | dst = *dst_; |  | 29626 | dst = *dst_;
| 29675 | return true; |  | 29627 | return true;
| 29676 | } |  | 29628 | }
| 29677 |  |  | 29629 |
| 29678 | failmsg("Expected cv::UsacParams for argument '%s'", info.name); |  | 29630 | failmsg("Expected cv::UsacParams for argument '%s'", info.name);
| 29679 | return false; |  | 29631 | return false;
| 29680 | } |  | 29632 | }
| 29681 | }; |  | 29633 | };
| 29682 |  |  | 29634 |
| 29683 | //================================================================================ |  | 29635 | //================================================================================
| 29684 | // VariationalRefinement (Generic) |  | 29636 | // VariationalRefinement (Generic)
| 29685 | //================================================================================ |  | 29637 | //================================================================================
| 29686 |  |  | 29638 |
| 29687 | // GetSet (VariationalRefinement) |  | 29639 | // GetSet (VariationalRefinement)
| 29688 |  |  | 29640 |
| 29689 |  |  | 29641 |
| 29690 |  |  | 29642 |
| 29691 | // Methods (VariationalRefinement) |  | 29643 | // Methods (VariationalRefinement)
| 29692 |  |  | 29644 |
| 29693 | static PyObject* pyopencv_cv_VariationalRefinement_calcUV(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29645 | static PyObject* pyopencv_cv_VariationalRefinement_calcUV(PyObject* self, PyObject* py_args, PyObject* kw)
| 29694 | { |  | 29646 | {
| 29695 | using namespace cv; |  | 29647 | using namespace cv;
| 29696 |  |  | 29648 |
| 29697 |  |  | 29649 |
| 29698 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29650 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29699 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29651 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29700 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29652 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29701 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29653 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29702 | pyPrepareArgumentConversionErrorsStorage(2); |  | 29654 | pyPrepareArgumentConversionErrorsStorage(2);
| 29703 |  |  | 29655 |
| 29704 | { |  | 29656 | {
| 29705 | PyObject* pyobj_I0 = NULL; |  | 29657 | PyObject* pyobj_I0 = NULL;
| 29706 | Mat I0; |  | 29658 | Mat I0;
| 29707 | PyObject* pyobj_I1 = NULL; |  | 29659 | PyObject* pyobj_I1 = NULL;
| 29708 | Mat I1; |  | 29660 | Mat I1;
| 29709 | PyObject* pyobj_flow_u = NULL; |  | 29661 | PyObject* pyobj_flow_u = NULL;
| 29710 | Mat flow_u; |  | 29662 | Mat flow_u;
| 29711 | PyObject* pyobj_flow_v = NULL; |  | 29663 | PyObject* pyobj_flow_v = NULL;
| 29712 | Mat flow_v; |  | 29664 | Mat flow_v;
| 29713 |  |  | 29665 |
| 29714 | const char* keywords[] = { "I0", "I1", "flow_u", "flow_v", NULL }; |  | 29666 | const char* keywords[] = { "I0", "I1", "flow_u", "flow_v", NULL };
| 29715 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:VariationalRefinement.calcUV", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow_u, &pyobj_flow_v) && |  | 29667 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:VariationalRefinement.calcUV", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow_u, &pyobj_flow_v) &&
| 29716 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) && |  | 29668 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) &&
| 29717 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) && |  | 29669 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) &&
| 29718 | pyopencv_to_safe(pyobj_flow_u, flow_u, ArgInfo("flow_u", 1)) && |  | 29670 | pyopencv_to_safe(pyobj_flow_u, flow_u, ArgInfo("flow_u", 1)) &&
| 29719 | pyopencv_to_safe(pyobj_flow_v, flow_v, ArgInfo("flow_v", 1)) ) |  | 29671 | pyopencv_to_safe(pyobj_flow_v, flow_v, ArgInfo("flow_v", 1)) )
| 29720 | { |  | 29672 | {
| 29721 | ERRWRAP2(_self_->calcUV(I0, I1, flow_u, flow_v)); |  | 29673 | ERRWRAP2(_self_->calcUV(I0, I1, flow_u, flow_v));
| 29722 | return Py_BuildValue("(NN)", pyopencv_from(flow_u), pyopencv_from(flow_v)); |  | 29674 | return Py_BuildValue("(NN)", pyopencv_from(flow_u), pyopencv_from(flow_v));
| 29723 | } |  | 29675 | }
| 29724 |  |  | 29676 |
| 29725 |  |  | 29677 |
| 29726 | pyPopulateArgumentConversionErrors(); |  | 29678 | pyPopulateArgumentConversionErrors();
| 29727 | } |  | 29679 | }
| 29728 |  |  | 29680 |
| 29729 |  |  | 29681 |
| 29730 | { |  | 29682 | {
| 29731 | PyObject* pyobj_I0 = NULL; |  | 29683 | PyObject* pyobj_I0 = NULL;
| 29732 | UMat I0; |  | 29684 | UMat I0;
| 29733 | PyObject* pyobj_I1 = NULL; |  | 29685 | PyObject* pyobj_I1 = NULL;
| 29734 | UMat I1; |  | 29686 | UMat I1;
| 29735 | PyObject* pyobj_flow_u = NULL; |  | 29687 | PyObject* pyobj_flow_u = NULL;
| 29736 | UMat flow_u; |  | 29688 | UMat flow_u;
| 29737 | PyObject* pyobj_flow_v = NULL; |  | 29689 | PyObject* pyobj_flow_v = NULL;
| 29738 | UMat flow_v; |  | 29690 | UMat flow_v;
| 29739 |  |  | 29691 |
| 29740 | const char* keywords[] = { "I0", "I1", "flow_u", "flow_v", NULL }; |  | 29692 | const char* keywords[] = { "I0", "I1", "flow_u", "flow_v", NULL };
| 29741 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:VariationalRefinement.calcUV", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow_u, &pyobj_flow_v) && |  | 29693 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:VariationalRefinement.calcUV", (char**)keywords, &pyobj_I0, &pyobj_I1, &pyobj_flow_u, &pyobj_flow_v) &&
| 29742 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) && |  | 29694 | pyopencv_to_safe(pyobj_I0, I0, ArgInfo("I0", 0)) &&
| 29743 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) && |  | 29695 | pyopencv_to_safe(pyobj_I1, I1, ArgInfo("I1", 0)) &&
| 29744 | pyopencv_to_safe(pyobj_flow_u, flow_u, ArgInfo("flow_u", 1)) && |  | 29696 | pyopencv_to_safe(pyobj_flow_u, flow_u, ArgInfo("flow_u", 1)) &&
| 29745 | pyopencv_to_safe(pyobj_flow_v, flow_v, ArgInfo("flow_v", 1)) ) |  | 29697 | pyopencv_to_safe(pyobj_flow_v, flow_v, ArgInfo("flow_v", 1)) )
| 29746 | { |  | 29698 | {
| 29747 | ERRWRAP2(_self_->calcUV(I0, I1, flow_u, flow_v)); |  | 29699 | ERRWRAP2(_self_->calcUV(I0, I1, flow_u, flow_v));
| 29748 | return Py_BuildValue("(NN)", pyopencv_from(flow_u), pyopencv_from(flow_v)); |  | 29700 | return Py_BuildValue("(NN)", pyopencv_from(flow_u), pyopencv_from(flow_v));
| 29749 | } |  | 29701 | }
| 29750 |  |  | 29702 |
| 29751 |  |  | 29703 |
| 29752 | pyPopulateArgumentConversionErrors(); |  | 29704 | pyPopulateArgumentConversionErrors();
| 29753 | } |  | 29705 | }
| 29754 | pyRaiseCVOverloadException("calcUV"); |  | 29706 | pyRaiseCVOverloadException("calcUV");
| 29755 |  |  | 29707 |
| 29756 | return NULL; |  | 29708 | return NULL;
| 29757 | } |  | 29709 | }
| 29758 |  |  | 29710 |
| 29759 | static PyObject* pyopencv_cv_VariationalRefinement_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29711 | static PyObject* pyopencv_cv_VariationalRefinement_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 29760 | { |  | 29712 | {
| 29761 | using namespace cv; |  | 29713 | using namespace cv;
| 29762 |  |  | 29714 |
| 29763 | Ptr<VariationalRefinement> retval; |  | 29715 | Ptr<VariationalRefinement> retval;
| 29764 |  |  | 29716 |
| 29765 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29717 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29766 | { |  | 29718 | {
| 29767 | ERRWRAP2(retval = cv::VariationalRefinement::create()); |  | 29719 | ERRWRAP2(retval = cv::VariationalRefinement::create());
| 29768 | return pyopencv_from(retval); |  | 29720 | return pyopencv_from(retval);
| 29769 | } |  | 29721 | }
| 29770 |  |  | 29722 |
| 29771 | return NULL; |  | 29723 | return NULL;
| 29772 | } |  | 29724 | }
| 29773 |  |  | 29725 |
| 29774 | static PyObject* pyopencv_cv_VariationalRefinement_getAlpha(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29726 | static PyObject* pyopencv_cv_VariationalRefinement_getAlpha(PyObject* self, PyObject* py_args, PyObject* kw)
| 29775 | { |  | 29727 | {
| 29776 | using namespace cv; |  | 29728 | using namespace cv;
| 29777 |  |  | 29729 |
| 29778 |  |  | 29730 |
| 29779 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29731 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29780 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29732 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29781 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29733 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29782 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29734 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29783 | float retval; |  | 29735 | float retval;
| 29784 |  |  | 29736 |
| 29785 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29737 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29786 | { |  | 29738 | {
| 29787 | ERRWRAP2(retval = _self_->getAlpha()); |  | 29739 | ERRWRAP2(retval = _self_->getAlpha());
| 29788 | return pyopencv_from(retval); |  | 29740 | return pyopencv_from(retval);
| 29789 | } |  | 29741 | }
| 29790 |  |  | 29742 |
| 29791 | return NULL; |  | 29743 | return NULL;
| 29792 | } |  | 29744 | }
| 29793 |  |  | 29745 |
| 29794 | static PyObject* pyopencv_cv_VariationalRefinement_getDelta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29746 | static PyObject* pyopencv_cv_VariationalRefinement_getDelta(PyObject* self, PyObject* py_args, PyObject* kw)
| 29795 | { |  | 29747 | {
| 29796 | using namespace cv; |  | 29748 | using namespace cv;
| 29797 |  |  | 29749 |
| 29798 |  |  | 29750 |
| 29799 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29751 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29800 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29752 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29801 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29753 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29802 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29754 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29803 | float retval; |  | 29755 | float retval;
| 29804 |  |  | 29756 |
| 29805 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29757 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29806 | { |  | 29758 | {
| 29807 | ERRWRAP2(retval = _self_->getDelta()); |  | 29759 | ERRWRAP2(retval = _self_->getDelta());
| 29808 | return pyopencv_from(retval); |  | 29760 | return pyopencv_from(retval);
| 29809 | } |  | 29761 | }
| 29810 |  |  | 29762 |
| 29811 | return NULL; |  | 29763 | return NULL;
| 29812 | } |  | 29764 | }
| 29813 |  |  | 29765 |
| 29814 | static PyObject* pyopencv_cv_VariationalRefinement_getEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29766 | static PyObject* pyopencv_cv_VariationalRefinement_getEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 29815 | { |  | 29767 | {
| 29816 | using namespace cv; |  | 29768 | using namespace cv;
| 29817 |  |  | 29769 |
| 29818 |  |  | 29770 |
| 29819 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29771 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29820 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29772 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29821 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29773 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29822 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29774 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29823 | float retval; |  | 29775 | float retval;
| 29824 |  |  | 29776 |
| 29825 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29777 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29826 | { |  | 29778 | {
| 29827 | ERRWRAP2(retval = _self_->getEpsilon()); |  | 29779 | ERRWRAP2(retval = _self_->getEpsilon());
| 29828 | return pyopencv_from(retval); |  | 29780 | return pyopencv_from(retval);
| 29829 | } |  | 29781 | }
| 29830 |  |  | 29782 |
| 29831 | return NULL; |  | 29783 | return NULL;
| 29832 | } |  | 29784 | }
| 29833 |  |  | 29785 |
| 29834 | static PyObject* pyopencv_cv_VariationalRefinement_getFixedPointIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29786 | static PyObject* pyopencv_cv_VariationalRefinement_getFixedPointIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 29835 | { |  | 29787 | {
| 29836 | using namespace cv; |  | 29788 | using namespace cv;
| 29837 |  |  | 29789 |
| 29838 |  |  | 29790 |
| 29839 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29791 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29840 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29792 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29841 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29793 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29842 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29794 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29843 | int retval; |  | 29795 | int retval;
| 29844 |  |  | 29796 |
| 29845 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29797 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29846 | { |  | 29798 | {
| 29847 | ERRWRAP2(retval = _self_->getFixedPointIterations()); |  | 29799 | ERRWRAP2(retval = _self_->getFixedPointIterations());
| 29848 | return pyopencv_from(retval); |  | 29800 | return pyopencv_from(retval);
| 29849 | } |  | 29801 | }
| 29850 |  |  | 29802 |
| 29851 | return NULL; |  | 29803 | return NULL;
| 29852 | } |  | 29804 | }
| 29853 |  |  | 29805 |
| 29854 | static PyObject* pyopencv_cv_VariationalRefinement_getGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29806 | static PyObject* pyopencv_cv_VariationalRefinement_getGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 29855 | { |  | 29807 | {
| 29856 | using namespace cv; |  | 29808 | using namespace cv;
| 29857 |  |  | 29809 |
| 29858 |  |  | 29810 |
| 29859 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29811 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29860 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29812 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29861 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29813 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29862 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29814 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29863 | float retval; |  | 29815 | float retval;
| 29864 |  |  | 29816 |
| 29865 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29817 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29866 | { |  | 29818 | {
| 29867 | ERRWRAP2(retval = _self_->getGamma()); |  | 29819 | ERRWRAP2(retval = _self_->getGamma());
| 29868 | return pyopencv_from(retval); |  | 29820 | return pyopencv_from(retval);
| 29869 | } |  | 29821 | }
| 29870 |  |  | 29822 |
| 29871 | return NULL; |  | 29823 | return NULL;
| 29872 | } |  | 29824 | }
| 29873 |  |  | 29825 |
| 29874 | static PyObject* pyopencv_cv_VariationalRefinement_getOmega(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29826 | static PyObject* pyopencv_cv_VariationalRefinement_getOmega(PyObject* self, PyObject* py_args, PyObject* kw)
| 29875 | { |  | 29827 | {
| 29876 | using namespace cv; |  | 29828 | using namespace cv;
| 29877 |  |  | 29829 |
| 29878 |  |  | 29830 |
| 29879 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29831 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29880 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29832 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29881 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29833 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29882 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29834 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29883 | float retval; |  | 29835 | float retval;
| 29884 |  |  | 29836 |
| 29885 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29837 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29886 | { |  | 29838 | {
| 29887 | ERRWRAP2(retval = _self_->getOmega()); |  | 29839 | ERRWRAP2(retval = _self_->getOmega());
| 29888 | return pyopencv_from(retval); |  | 29840 | return pyopencv_from(retval);
| 29889 | } |  | 29841 | }
| 29890 |  |  | 29842 |
| 29891 | return NULL; |  | 29843 | return NULL;
| 29892 | } |  | 29844 | }
| 29893 |  |  | 29845 |
| 29894 | static PyObject* pyopencv_cv_VariationalRefinement_getSorIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29846 | static PyObject* pyopencv_cv_VariationalRefinement_getSorIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 29895 | { |  | 29847 | {
| 29896 | using namespace cv; |  | 29848 | using namespace cv;
| 29897 |  |  | 29849 |
| 29898 |  |  | 29850 |
| 29899 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29851 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29900 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29852 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29901 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29853 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29902 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29854 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29903 | int retval; |  | 29855 | int retval;
| 29904 |  |  | 29856 |
| 29905 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 29857 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 29906 | { |  | 29858 | {
| 29907 | ERRWRAP2(retval = _self_->getSorIterations()); |  | 29859 | ERRWRAP2(retval = _self_->getSorIterations());
| 29908 | return pyopencv_from(retval); |  | 29860 | return pyopencv_from(retval);
| 29909 | } |  | 29861 | }
| 29910 |  |  | 29862 |
| 29911 | return NULL; |  | 29863 | return NULL;
| 29912 | } |  | 29864 | }
| 29913 |  |  | 29865 |
| 29914 | static PyObject* pyopencv_cv_VariationalRefinement_setAlpha(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29866 | static PyObject* pyopencv_cv_VariationalRefinement_setAlpha(PyObject* self, PyObject* py_args, PyObject* kw)
| 29915 | { |  | 29867 | {
| 29916 | using namespace cv; |  | 29868 | using namespace cv;
| 29917 |  |  | 29869 |
| 29918 |  |  | 29870 |
| 29919 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29871 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29920 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29872 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29921 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29873 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29922 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29874 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29923 | PyObject* pyobj_val = NULL; |  | 29875 | PyObject* pyobj_val = NULL;
| 29924 | float val=0.f; |  | 29876 | float val=0.f;
| 29925 |  |  | 29877 |
| 29926 | const char* keywords[] = { "val", NULL }; |  | 29878 | const char* keywords[] = { "val", NULL };
| 29927 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setAlpha", (char**)keywords, &pyobj_val) && |  | 29879 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setAlpha", (char**)keywords, &pyobj_val) &&
| 29928 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 29880 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 29929 | { |  | 29881 | {
| 29930 | ERRWRAP2(_self_->setAlpha(val)); |  | 29882 | ERRWRAP2(_self_->setAlpha(val));
| 29931 | Py_RETURN_NONE; |  | 29883 | Py_RETURN_NONE;
| 29932 | } |  | 29884 | }
| 29933 |  |  | 29885 |
| 29934 | return NULL; |  | 29886 | return NULL;
| 29935 | } |  | 29887 | }
| 29936 |  |  | 29888 |
| 29937 | static PyObject* pyopencv_cv_VariationalRefinement_setDelta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29889 | static PyObject* pyopencv_cv_VariationalRefinement_setDelta(PyObject* self, PyObject* py_args, PyObject* kw)
| 29938 | { |  | 29890 | {
| 29939 | using namespace cv; |  | 29891 | using namespace cv;
| 29940 |  |  | 29892 |
| 29941 |  |  | 29893 |
| 29942 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29894 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29943 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29895 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29944 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29896 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29945 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29897 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29946 | PyObject* pyobj_val = NULL; |  | 29898 | PyObject* pyobj_val = NULL;
| 29947 | float val=0.f; |  | 29899 | float val=0.f;
| 29948 |  |  | 29900 |
| 29949 | const char* keywords[] = { "val", NULL }; |  | 29901 | const char* keywords[] = { "val", NULL };
| 29950 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setDelta", (char**)keywords, &pyobj_val) && |  | 29902 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setDelta", (char**)keywords, &pyobj_val) &&
| 29951 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 29903 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 29952 | { |  | 29904 | {
| 29953 | ERRWRAP2(_self_->setDelta(val)); |  | 29905 | ERRWRAP2(_self_->setDelta(val));
| 29954 | Py_RETURN_NONE; |  | 29906 | Py_RETURN_NONE;
| 29955 | } |  | 29907 | }
| 29956 |  |  | 29908 |
| 29957 | return NULL; |  | 29909 | return NULL;
| 29958 | } |  | 29910 | }
| 29959 |  |  | 29911 |
| 29960 | static PyObject* pyopencv_cv_VariationalRefinement_setEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29912 | static PyObject* pyopencv_cv_VariationalRefinement_setEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 29961 | { |  | 29913 | {
| 29962 | using namespace cv; |  | 29914 | using namespace cv;
| 29963 |  |  | 29915 |
| 29964 |  |  | 29916 |
| 29965 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29917 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29966 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29918 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29967 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29919 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29968 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29920 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29969 | PyObject* pyobj_val = NULL; |  | 29921 | PyObject* pyobj_val = NULL;
| 29970 | float val=0.f; |  | 29922 | float val=0.f;
| 29971 |  |  | 29923 |
| 29972 | const char* keywords[] = { "val", NULL }; |  | 29924 | const char* keywords[] = { "val", NULL };
| 29973 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setEpsilon", (char**)keywords, &pyobj_val) && |  | 29925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setEpsilon", (char**)keywords, &pyobj_val) &&
| 29974 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 29926 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 29975 | { |  | 29927 | {
| 29976 | ERRWRAP2(_self_->setEpsilon(val)); |  | 29928 | ERRWRAP2(_self_->setEpsilon(val));
| 29977 | Py_RETURN_NONE; |  | 29929 | Py_RETURN_NONE;
| 29978 | } |  | 29930 | }
| 29979 |  |  | 29931 |
| 29980 | return NULL; |  | 29932 | return NULL;
| 29981 | } |  | 29933 | }
| 29982 |  |  | 29934 |
| 29983 | static PyObject* pyopencv_cv_VariationalRefinement_setFixedPointIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29935 | static PyObject* pyopencv_cv_VariationalRefinement_setFixedPointIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 29984 | { |  | 29936 | {
| 29985 | using namespace cv; |  | 29937 | using namespace cv;
| 29986 |  |  | 29938 |
| 29987 |  |  | 29939 |
| 29988 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29940 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 29989 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29941 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 29990 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29942 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 29991 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29943 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 29992 | PyObject* pyobj_val = NULL; |  | 29944 | PyObject* pyobj_val = NULL;
| 29993 | int val=0; |  | 29945 | int val=0;
| 29994 |  |  | 29946 |
| 29995 | const char* keywords[] = { "val", NULL }; |  | 29947 | const char* keywords[] = { "val", NULL };
| 29996 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setFixedPointIterations", (char**)keywords, &pyobj_val) && |  | 29948 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setFixedPointIterations", (char**)keywords, &pyobj_val) &&
| 29997 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 29949 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 29998 | { |  | 29950 | {
| 29999 | ERRWRAP2(_self_->setFixedPointIterations(val)); |  | 29951 | ERRWRAP2(_self_->setFixedPointIterations(val));
| 30000 | Py_RETURN_NONE; |  | 29952 | Py_RETURN_NONE;
| 30001 | } |  | 29953 | }
| 30002 |  |  | 29954 |
| 30003 | return NULL; |  | 29955 | return NULL;
| 30004 | } |  | 29956 | }
| 30005 |  |  | 29957 |
| 30006 | static PyObject* pyopencv_cv_VariationalRefinement_setGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29958 | static PyObject* pyopencv_cv_VariationalRefinement_setGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 30007 | { |  | 29959 | {
| 30008 | using namespace cv; |  | 29960 | using namespace cv;
| 30009 |  |  | 29961 |
| 30010 |  |  | 29962 |
| 30011 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29963 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 30012 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29964 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 30013 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29965 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 30014 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29966 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 30015 | PyObject* pyobj_val = NULL; |  | 29967 | PyObject* pyobj_val = NULL;
| 30016 | float val=0.f; |  | 29968 | float val=0.f;
| 30017 |  |  | 29969 |
| 30018 | const char* keywords[] = { "val", NULL }; |  | 29970 | const char* keywords[] = { "val", NULL };
| 30019 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setGamma", (char**)keywords, &pyobj_val) && |  | 29971 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setGamma", (char**)keywords, &pyobj_val) &&
| 30020 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 29972 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 30021 | { |  | 29973 | {
| 30022 | ERRWRAP2(_self_->setGamma(val)); |  | 29974 | ERRWRAP2(_self_->setGamma(val));
| 30023 | Py_RETURN_NONE; |  | 29975 | Py_RETURN_NONE;
| 30024 | } |  | 29976 | }
| 30025 |  |  | 29977 |
| 30026 | return NULL; |  | 29978 | return NULL;
| 30027 | } |  | 29979 | }
| 30028 |  |  | 29980 |
| 30029 | static PyObject* pyopencv_cv_VariationalRefinement_setOmega(PyObject* self, PyObject* py_args, PyObject* kw) |  | 29981 | static PyObject* pyopencv_cv_VariationalRefinement_setOmega(PyObject* self, PyObject* py_args, PyObject* kw)
| 30030 | { |  | 29982 | {
| 30031 | using namespace cv; |  | 29983 | using namespace cv;
| 30032 |  |  | 29984 |
| 30033 |  |  | 29985 |
| 30034 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 29986 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 30035 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 29987 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 30036 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 29988 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 30037 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 29989 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 30038 | PyObject* pyobj_val = NULL; |  | 29990 | PyObject* pyobj_val = NULL;
| 30039 | float val=0.f; |  | 29991 | float val=0.f;
| 30040 |  |  | 29992 |
| 30041 | const char* keywords[] = { "val", NULL }; |  | 29993 | const char* keywords[] = { "val", NULL };
| 30042 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setOmega", (char**)keywords, &pyobj_val) && |  | 29994 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setOmega", (char**)keywords, &pyobj_val) &&
| 30043 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 29995 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 30044 | { |  | 29996 | {
| 30045 | ERRWRAP2(_self_->setOmega(val)); |  | 29997 | ERRWRAP2(_self_->setOmega(val));
| 30046 | Py_RETURN_NONE; |  | 29998 | Py_RETURN_NONE;
| 30047 | } |  | 29999 | }
| 30048 |  |  | 30000 |
| 30049 | return NULL; |  | 30001 | return NULL;
| 30050 | } |  | 30002 | }
| 30051 |  |  | 30003 |
| 30052 | static PyObject* pyopencv_cv_VariationalRefinement_setSorIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30004 | static PyObject* pyopencv_cv_VariationalRefinement_setSorIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 30053 | { |  | 30005 | {
| 30054 | using namespace cv; |  | 30006 | using namespace cv;
| 30055 |  |  | 30007 |
| 30056 |  |  | 30008 |
| 30057 | Ptr<cv::VariationalRefinement> * self1 = 0; |  | 30009 | Ptr<cv::VariationalRefinement> * self1 = 0;
| 30058 | if (!pyopencv_VariationalRefinement_getp(self, self1)) |  | 30010 | if (!pyopencv_VariationalRefinement_getp(self, self1))
| 30059 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)"); |  | 30011 | return failmsgp("Incorrect type of self (must be 'VariationalRefinement' or its derivative)");
| 30060 | Ptr<cv::VariationalRefinement> _self_ = *(self1); |  | 30012 | Ptr<cv::VariationalRefinement> _self_ = *(self1);
| 30061 | PyObject* pyobj_val = NULL; |  | 30013 | PyObject* pyobj_val = NULL;
| 30062 | int val=0; |  | 30014 | int val=0;
| 30063 |  |  | 30015 |
| 30064 | const char* keywords[] = { "val", NULL }; |  | 30016 | const char* keywords[] = { "val", NULL };
| 30065 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setSorIterations", (char**)keywords, &pyobj_val) && |  | 30017 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VariationalRefinement.setSorIterations", (char**)keywords, &pyobj_val) &&
| 30066 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 30018 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 30067 | { |  | 30019 | {
| 30068 | ERRWRAP2(_self_->setSorIterations(val)); |  | 30020 | ERRWRAP2(_self_->setSorIterations(val));
| 30069 | Py_RETURN_NONE; |  | 30021 | Py_RETURN_NONE;
| 30070 | } |  | 30022 | }
| 30071 |  |  | 30023 |
| 30072 | return NULL; |  | 30024 | return NULL;
| 30073 | } |  | 30025 | }
| 30074 |  |  | 30026 |
| 30075 |  |  | 30027 |
| 30076 |  |  | 30028 |
| 30077 | // Tables (VariationalRefinement) |  | 30029 | // Tables (VariationalRefinement)
| 30078 |  |  | 30030 |
| 30079 | static PyGetSetDef pyopencv_VariationalRefinement_getseters[] = |  | 30031 | static PyGetSetDef pyopencv_VariationalRefinement_getseters[] =
| 30080 | { |  | 30032 | {
| 30081 | {NULL} /* Sentinel */ |  | 30033 | {NULL} /* Sentinel */
| 30082 | }; |  | 30034 | };
| 30083 |  |  | 30035 |
| 30084 | static PyMethodDef pyopencv_VariationalRefinement_methods[] = |  | 30036 | static PyMethodDef pyopencv_VariationalRefinement_methods[] =
| 30085 | { |  | 30037 | {
| 30086 | {"calcUV", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_calcUV, 0), "calcUV(I0, I1, flow_u, flow_v) -> flow_u, flow_v\n. @brief @ref calc function overload to handle separate horizontal (u) and vertical (v) flow components\n. (to avoid extra splits/merges)"}, |  | 30038 | {"calcUV", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_calcUV, 0), "calcUV(I0, I1, flow_u, flow_v) -> flow_u, flow_v\n. @brief @ref calc function overload to handle separate horizontal (u) and vertical (v) flow components\n. (to avoid extra splits/merges)"},
| 30087 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_create_static, METH_STATIC), "create() -> retval\n. @brief Creates an instance of VariationalRefinement"}, |  | 30039 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_create_static, METH_STATIC), "create() -> retval\n. @brief Creates an instance of VariationalRefinement"},
| 30088 | {"getAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getAlpha, 0), "getAlpha() -> retval\n. @brief Weight of the smoothness term\n. @see setAlpha"}, |  | 30040 | {"getAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getAlpha, 0), "getAlpha() -> retval\n. @brief Weight of the smoothness term\n. @see setAlpha"},
| 30089 | {"getDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getDelta, 0), "getDelta() -> retval\n. @brief Weight of the color constancy term\n. @see setDelta"}, |  | 30041 | {"getDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getDelta, 0), "getDelta() -> retval\n. @brief Weight of the color constancy term\n. @see setDelta"},
| 30090 | {"getEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getEpsilon, 0), "getEpsilon() -> retval\n. @brief Norm value shift for robust penalizer\n. @see setEpsilon"}, |  | 30042 | {"getEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getEpsilon, 0), "getEpsilon() -> retval\n. @brief Norm value shift for robust penalizer\n. @see setEpsilon"},
| 30091 | {"getFixedPointIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getFixedPointIterations, 0), "getFixedPointIterations() -> retval\n. @brief Number of outer (fixed-point) iterations in the minimization procedure.\n. @see setFixedPointIterations"}, |  | 30043 | {"getFixedPointIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getFixedPointIterations, 0), "getFixedPointIterations() -> retval\n. @brief Number of outer (fixed-point) iterations in the minimization procedure.\n. @see setFixedPointIterations"},
| 30092 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getGamma, 0), "getGamma() -> retval\n. @brief Weight of the gradient constancy term\n. @see setGamma"}, |  | 30044 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getGamma, 0), "getGamma() -> retval\n. @brief Weight of the gradient constancy term\n. @see setGamma"},
| 30093 | {"getOmega", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getOmega, 0), "getOmega() -> retval\n. @brief Relaxation factor in SOR\n. @see setOmega"}, |  | 30045 | {"getOmega", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getOmega, 0), "getOmega() -> retval\n. @brief Relaxation factor in SOR\n. @see setOmega"},
| 30094 | {"getSorIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getSorIterations, 0), "getSorIterations() -> retval\n. @brief Number of inner successive over-relaxation (SOR) iterations\n. in the minimization procedure to solve the respective linear system.\n. @see setSorIterations"}, |  | 30046 | {"getSorIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_getSorIterations, 0), "getSorIterations() -> retval\n. @brief Number of inner successive over-relaxation (SOR) iterations\n. in the minimization procedure to solve the respective linear system.\n. @see setSorIterations"},
| 30095 | {"setAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setAlpha, 0), "setAlpha(val) -> None\n. @copybrief getAlpha @see getAlpha"}, |  | 30047 | {"setAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setAlpha, 0), "setAlpha(val) -> None\n. @copybrief getAlpha @see getAlpha"},
| 30096 | {"setDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setDelta, 0), "setDelta(val) -> None\n. @copybrief getDelta @see getDelta"}, |  | 30048 | {"setDelta", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setDelta, 0), "setDelta(val) -> None\n. @copybrief getDelta @see getDelta"},
| 30097 | {"setEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setEpsilon, 0), "setEpsilon(val) -> None\n. @copybrief getEpsilon @see getEpsilon"}, |  | 30049 | {"setEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setEpsilon, 0), "setEpsilon(val) -> None\n. @copybrief getEpsilon @see getEpsilon"},
| 30098 | {"setFixedPointIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setFixedPointIterations, 0), "setFixedPointIterations(val) -> None\n. @copybrief getFixedPointIterations @see getFixedPointIterations"}, |  | 30050 | {"setFixedPointIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setFixedPointIterations, 0), "setFixedPointIterations(val) -> None\n. @copybrief getFixedPointIterations @see getFixedPointIterations"},
| 30099 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setGamma, 0), "setGamma(val) -> None\n. @copybrief getGamma @see getGamma"}, |  | 30051 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setGamma, 0), "setGamma(val) -> None\n. @copybrief getGamma @see getGamma"},
| 30100 | {"setOmega", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setOmega, 0), "setOmega(val) -> None\n. @copybrief getOmega @see getOmega"}, |  | 30052 | {"setOmega", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setOmega, 0), "setOmega(val) -> None\n. @copybrief getOmega @see getOmega"},
| 30101 | {"setSorIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setSorIterations, 0), "setSorIterations(val) -> None\n. @copybrief getSorIterations @see getSorIterations"}, |  | 30053 | {"setSorIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_VariationalRefinement_setSorIterations, 0), "setSorIterations(val) -> None\n. @copybrief getSorIterations @see getSorIterations"},
| 30102 |  |  | 30054 |
| 30103 | {NULL, NULL} |  | 30055 | {NULL, NULL}
| 30104 | }; |  | 30056 | };
| 30105 |  |  | 30057 |
| 30106 | // Converter (VariationalRefinement) |  | 30058 | // Converter (VariationalRefinement)
| 30107 |  |  | 30059 |
| 30108 | template<> |  | 30060 | template<>
| 30109 | struct PyOpenCV_Converter< Ptr<cv::VariationalRefinement> > |  | 30061 | struct PyOpenCV_Converter< Ptr<cv::VariationalRefinement> >
| 30110 | { |  | 30062 | {
| 30111 | static PyObject* from(const Ptr<cv::VariationalRefinement>& r) |  | 30063 | static PyObject* from(const Ptr<cv::VariationalRefinement>& r)
| 30112 | { |  | 30064 | {
| 30113 | return pyopencv_VariationalRefinement_Instance(r); |  | 30065 | return pyopencv_VariationalRefinement_Instance(r);
| 30114 | } |  | 30066 | }
| 30115 | static bool to(PyObject* src, Ptr<cv::VariationalRefinement>& dst, const ArgInfo& info) |  | 30067 | static bool to(PyObject* src, Ptr<cv::VariationalRefinement>& dst, const ArgInfo& info)
| 30116 | { |  | 30068 | {
| 30117 | if(!src || src == Py_None) |  | 30069 | if(!src || src == Py_None)
| 30118 | return true; |  | 30070 | return true;
| 30119 | Ptr<cv::VariationalRefinement> * dst_; |  | 30071 | Ptr<cv::VariationalRefinement> * dst_;
| 30120 | if (pyopencv_VariationalRefinement_getp(src, dst_)) |  | 30072 | if (pyopencv_VariationalRefinement_getp(src, dst_))
| 30121 | { |  | 30073 | {
| 30122 | dst = *dst_; |  | 30074 | dst = *dst_;
| 30123 | return true; |  | 30075 | return true;
| 30124 | } |  | 30076 | }
| 30125 |  |  | 30077 |
| 30126 | failmsg("Expected Ptr<cv::VariationalRefinement> for argument '%s'", info.name); |  | 30078 | failmsg("Expected Ptr<cv::VariationalRefinement> for argument '%s'", info.name);
| 30127 | return false; |  | 30079 | return false;
| 30128 | } |  | 30080 | }
| 30129 | }; |  | 30081 | };
| 30130 |  |  | 30082 |
| 30131 | //================================================================================ |  | 30083 | //================================================================================
| 30132 | // VideoCapture (Generic) |  | 30084 | // VideoCapture (Generic)
| 30133 | //================================================================================ |  | 30085 | //================================================================================
| 30134 |  |  | 30086 |
| 30135 | // GetSet (VideoCapture) |  | 30087 | // GetSet (VideoCapture)
| 30136 |  |  | 30088 |
| 30137 |  |  | 30089 |
| 30138 |  |  | 30090 |
| 30139 | // Methods (VideoCapture) |  | 30091 | // Methods (VideoCapture)
| 30140 |  |  | 30092 |
| 30141 | static int pyopencv_cv_VideoCapture_VideoCapture(pyopencv_VideoCapture_t* self, PyObject* py_args, PyObject* kw) |  | 30093 | static int pyopencv_cv_VideoCapture_VideoCapture(pyopencv_VideoCapture_t* self, PyObject* py_args, PyObject* kw)
| 30142 | { |  | 30094 | {
| 30143 | using namespace cv; |  | 30095 | using namespace cv;
| 30144 |  |  | 30096 |
| 30145 | pyPrepareArgumentConversionErrorsStorage(6); |  | 30097 | pyPrepareArgumentConversionErrorsStorage(6);
| 30146 |  |  | 30098 |
| 30147 | { |  | 30099 | {
| 30148 |  |  | 30100 |
| 30149 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30101 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30150 | { |  | 30102 | {
| 30151 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new |  | 30103 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new
| 30152 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture())); |  | 30104 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture()));
| 30153 | return 0; |  | 30105 | return 0;
| 30154 | } |  | 30106 | }
| 30155 |  |  | 30107 |
| 30156 |  |  | 30108 |
| 30157 | pyPopulateArgumentConversionErrors(); |  | 30109 | pyPopulateArgumentConversionErrors();
| 30158 | } |  | 30110 | }
| 30159 |  |  | 30111 |
| 30160 |  |  | 30112 |
| 30161 | { |  | 30113 | {
| 30162 | PyObject* pyobj_filename = NULL; |  | 30114 | PyObject* pyobj_filename = NULL;
| 30163 | String filename; |  | 30115 | String filename;
| 30164 | PyObject* pyobj_apiPreference = NULL; |  | 30116 | PyObject* pyobj_apiPreference = NULL;
| 30165 | int apiPreference=CAP_ANY; |  | 30117 | int apiPreference=CAP_ANY;
| 30166 |  |  | 30118 |
| 30167 | const char* keywords[] = { "filename", "apiPreference", NULL }; |  | 30119 | const char* keywords[] = { "filename", "apiPreference", NULL };
| 30168 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture", (char**)keywords, &pyobj_filename, &pyobj_apiPreference) && |  | 30120 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture", (char**)keywords, &pyobj_filename, &pyobj_apiPreference) &&
| 30169 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30121 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30170 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) ) |  | 30122 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) )
| 30171 | { |  | 30123 | {
| 30172 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new |  | 30124 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new
| 30173 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(filename, apiPreference))); |  | 30125 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(filename, apiPreference)));
| 30174 | return 0; |  | 30126 | return 0;
| 30175 | } |  | 30127 | }
| 30176 |  |  | 30128 |
| 30177 |  |  | 30129 |
| 30178 | pyPopulateArgumentConversionErrors(); |  | 30130 | pyPopulateArgumentConversionErrors();
| 30179 | } |  | 30131 | }
| 30180 |  |  | 30132 |
| 30181 |  |  | 30133 |
| 30182 | { |  | 30134 | {
| 30183 | PyObject* pyobj_filename = NULL; |  | 30135 | PyObject* pyobj_filename = NULL;
| 30184 | String filename; |  | 30136 | String filename;
| 30185 | PyObject* pyobj_apiPreference = NULL; |  | 30137 | PyObject* pyobj_apiPreference = NULL;
| 30186 | int apiPreference=0; |  | 30138 | int apiPreference=0;
| 30187 | PyObject* pyobj_params = NULL; |  | 30139 | PyObject* pyobj_params = NULL;
| 30188 | vector_int params; |  | 30140 | vector_int params;
| 30189 |  |  | 30141 |
| 30190 | const char* keywords[] = { "filename", "apiPreference", "params", NULL }; |  | 30142 | const char* keywords[] = { "filename", "apiPreference", "params", NULL };
| 30191 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_params) && |  | 30143 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_params) &&
| 30192 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30144 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30193 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30145 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30194 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30146 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30195 | { |  | 30147 | {
| 30196 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new |  | 30148 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new
| 30197 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(filename, apiPreference, params))); |  | 30149 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(filename, apiPreference, params)));
| 30198 | return 0; |  | 30150 | return 0;
| 30199 | } |  | 30151 | }
| 30200 |  |  | 30152 |
| 30201 |  |  | 30153 |
| 30202 | pyPopulateArgumentConversionErrors(); |  | 30154 | pyPopulateArgumentConversionErrors();
| 30203 | } |  | 30155 | }
| 30204 |  |  | 30156 |
| 30205 |  |  | 30157 |
| 30206 | { |  | 30158 | {
| 30207 | PyObject* pyobj_index = NULL; |  | 30159 | PyObject* pyobj_index = NULL;
| 30208 | int index=0; |  | 30160 | int index=0;
| 30209 | PyObject* pyobj_apiPreference = NULL; |  | 30161 | PyObject* pyobj_apiPreference = NULL;
| 30210 | int apiPreference=CAP_ANY; |  | 30162 | int apiPreference=CAP_ANY;
| 30211 |  |  | 30163 |
| 30212 | const char* keywords[] = { "index", "apiPreference", NULL }; |  | 30164 | const char* keywords[] = { "index", "apiPreference", NULL };
| 30213 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture", (char**)keywords, &pyobj_index, &pyobj_apiPreference) && |  | 30165 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture", (char**)keywords, &pyobj_index, &pyobj_apiPreference) &&
| 30214 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 30166 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 30215 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) ) |  | 30167 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) )
| 30216 | { |  | 30168 | {
| 30217 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new |  | 30169 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new
| 30218 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(index, apiPreference))); |  | 30170 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(index, apiPreference)));
| 30219 | return 0; |  | 30171 | return 0;
| 30220 | } |  | 30172 | }
| 30221 |  |  | 30173 |
| 30222 |  |  | 30174 |
| 30223 | pyPopulateArgumentConversionErrors(); |  | 30175 | pyPopulateArgumentConversionErrors();
| 30224 | } |  | 30176 | }
| 30225 |  |  | 30177 |
| 30226 |  |  | 30178 |
| 30227 | { |  | 30179 | {
| 30228 | PyObject* pyobj_index = NULL; |  | 30180 | PyObject* pyobj_index = NULL;
| 30229 | int index=0; |  | 30181 | int index=0;
| 30230 | PyObject* pyobj_apiPreference = NULL; |  | 30182 | PyObject* pyobj_apiPreference = NULL;
| 30231 | int apiPreference=0; |  | 30183 | int apiPreference=0;
| 30232 | PyObject* pyobj_params = NULL; |  | 30184 | PyObject* pyobj_params = NULL;
| 30233 | vector_int params; |  | 30185 | vector_int params;
| 30234 |  |  | 30186 |
| 30235 | const char* keywords[] = { "index", "apiPreference", "params", NULL }; |  | 30187 | const char* keywords[] = { "index", "apiPreference", "params", NULL };
| 30236 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture", (char**)keywords, &pyobj_index, &pyobj_apiPreference, &pyobj_params) && |  | 30188 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture", (char**)keywords, &pyobj_index, &pyobj_apiPreference, &pyobj_params) &&
| 30237 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 30189 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 30238 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30190 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30239 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30191 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30240 | { |  | 30192 | {
| 30241 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new |  | 30193 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new
| 30242 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(index, apiPreference, params))); |  | 30194 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(index, apiPreference, params)));
| 30243 | return 0; |  | 30195 | return 0;
| 30244 | } |  | 30196 | }
| 30245 |  |  | 30197 |
| 30246 |  |  | 30198 |
| 30247 | pyPopulateArgumentConversionErrors(); |  | 30199 | pyPopulateArgumentConversionErrors();
| 30248 | } |  | 30200 | }
| 30249 |  |  | 30201 |
| 30250 |  |  | 30202 |
| 30251 | { |  | 30203 | {
| 30252 | PyObject* pyobj_source = NULL; |  | 30204 | PyObject* pyobj_source = NULL;
| 30253 | Ptr<IStreamReader> source; |  | 30205 | Ptr<IStreamReader> source;
| 30254 | PyObject* pyobj_apiPreference = NULL; |  | 30206 | PyObject* pyobj_apiPreference = NULL;
| 30255 | int apiPreference=0; |  | 30207 | int apiPreference=0;
| 30256 | PyObject* pyobj_params = NULL; |  | 30208 | PyObject* pyobj_params = NULL;
| 30257 | vector_int params; |  | 30209 | vector_int params;
| 30258 |  |  | 30210 |
| 30259 | const char* keywords[] = { "source", "apiPreference", "params", NULL }; |  | 30211 | const char* keywords[] = { "source", "apiPreference", "params", NULL };
| 30260 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture", (char**)keywords, &pyobj_source, &pyobj_apiPreference, &pyobj_params) && |  | 30212 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture", (char**)keywords, &pyobj_source, &pyobj_apiPreference, &pyobj_params) &&
| 30261 | pyopencv_to_safe(pyobj_source, source, ArgInfo("source", 0)) && |  | 30213 | pyopencv_to_safe(pyobj_source, source, ArgInfo("source", 0)) &&
| 30262 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30214 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30263 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30215 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30264 | { |  | 30216 | {
| 30265 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new |  | 30217 | new (&(self->v)) Ptr<cv::VideoCapture>(); // init Ptr with placement new
| 30266 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(source, apiPreference, params))); |  | 30218 | if(self) ERRWRAP2(self->v.reset(new cv::VideoCapture(source, apiPreference, params)));
| 30267 | return 0; |  | 30219 | return 0;
| 30268 | } |  | 30220 | }
| 30269 |  |  | 30221 |
| 30270 |  |  | 30222 |
| 30271 | pyPopulateArgumentConversionErrors(); |  | 30223 | pyPopulateArgumentConversionErrors();
| 30272 | } |  | 30224 | }
| 30273 | pyRaiseCVOverloadException("VideoCapture"); |  | 30225 | pyRaiseCVOverloadException("VideoCapture");
| 30274 |  |  | 30226 |
| 30275 | return -1; |  | 30227 | return -1;
| 30276 | } |  | 30228 | }
| 30277 |  |  | 30229 |
| 30278 | static PyObject* pyopencv_cv_VideoCapture_get(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30230 | static PyObject* pyopencv_cv_VideoCapture_get(PyObject* self, PyObject* py_args, PyObject* kw)
| 30279 | { |  | 30231 | {
| 30280 | using namespace cv; |  | 30232 | using namespace cv;
| 30281 |  |  | 30233 |
| 30282 |  |  | 30234 |
| 30283 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30235 | Ptr<cv::VideoCapture> * self1 = 0;
| 30284 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30236 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30285 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30237 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30286 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30238 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30287 | PyObject* pyobj_propId = NULL; |  | 30239 | PyObject* pyobj_propId = NULL;
| 30288 | int propId=0; |  | 30240 | int propId=0;
| 30289 | double retval; |  | 30241 | double retval;
| 30290 |  |  | 30242 |
| 30291 | const char* keywords[] = { "propId", NULL }; |  | 30243 | const char* keywords[] = { "propId", NULL };
| 30292 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoCapture.get", (char**)keywords, &pyobj_propId) && |  | 30244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoCapture.get", (char**)keywords, &pyobj_propId) &&
| 30293 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) ) |  | 30245 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) )
| 30294 | { |  | 30246 | {
| 30295 | ERRWRAP2(retval = _self_->get(propId)); |  | 30247 | ERRWRAP2(retval = _self_->get(propId));
| 30296 | return pyopencv_from(retval); |  | 30248 | return pyopencv_from(retval);
| 30297 | } |  | 30249 | }
| 30298 |  |  | 30250 |
| 30299 | return NULL; |  | 30251 | return NULL;
| 30300 | } |  | 30252 | }
| 30301 |  |  | 30253 |
| 30302 | static PyObject* pyopencv_cv_VideoCapture_getBackendName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30254 | static PyObject* pyopencv_cv_VideoCapture_getBackendName(PyObject* self, PyObject* py_args, PyObject* kw)
| 30303 | { |  | 30255 | {
| 30304 | using namespace cv; |  | 30256 | using namespace cv;
| 30305 |  |  | 30257 |
| 30306 |  |  | 30258 |
| 30307 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30259 | Ptr<cv::VideoCapture> * self1 = 0;
| 30308 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30260 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30309 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30261 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30310 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30262 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30311 | String retval; |  | 30263 | String retval;
| 30312 |  |  | 30264 |
| 30313 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30265 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30314 | { |  | 30266 | {
| 30315 | ERRWRAP2(retval = _self_->getBackendName()); |  | 30267 | ERRWRAP2(retval = _self_->getBackendName());
| 30316 | return pyopencv_from(retval); |  | 30268 | return pyopencv_from(retval);
| 30317 | } |  | 30269 | }
| 30318 |  |  | 30270 |
| 30319 | return NULL; |  | 30271 | return NULL;
| 30320 | } |  | 30272 | }
| 30321 |  |  | 30273 |
| 30322 | static PyObject* pyopencv_cv_VideoCapture_getExceptionMode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30274 | static PyObject* pyopencv_cv_VideoCapture_getExceptionMode(PyObject* self, PyObject* py_args, PyObject* kw)
| 30323 | { |  | 30275 | {
| 30324 | using namespace cv; |  | 30276 | using namespace cv;
| 30325 |  |  | 30277 |
| 30326 |  |  | 30278 |
| 30327 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30279 | Ptr<cv::VideoCapture> * self1 = 0;
| 30328 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30280 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30329 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30281 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30330 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30282 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30331 | bool retval; |  | 30283 | bool retval;
| 30332 |  |  | 30284 |
| 30333 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30285 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30334 | { |  | 30286 | {
| 30335 | ERRWRAP2(retval = _self_->getExceptionMode()); |  | 30287 | ERRWRAP2(retval = _self_->getExceptionMode());
| 30336 | return pyopencv_from(retval); |  | 30288 | return pyopencv_from(retval);
| 30337 | } |  | 30289 | }
| 30338 |  |  | 30290 |
| 30339 | return NULL; |  | 30291 | return NULL;
| 30340 | } |  | 30292 | }
| 30341 |  |  | 30293 |
| 30342 | static PyObject* pyopencv_cv_VideoCapture_grab(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30294 | static PyObject* pyopencv_cv_VideoCapture_grab(PyObject* self, PyObject* py_args, PyObject* kw)
| 30343 | { |  | 30295 | {
| 30344 | using namespace cv; |  | 30296 | using namespace cv;
| 30345 |  |  | 30297 |
| 30346 |  |  | 30298 |
| 30347 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30299 | Ptr<cv::VideoCapture> * self1 = 0;
| 30348 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30300 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30349 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30301 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30350 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30302 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30351 | bool retval; |  | 30303 | bool retval;
| 30352 |  |  | 30304 |
| 30353 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30305 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30354 | { |  | 30306 | {
| 30355 | ERRWRAP2(retval = _self_->grab()); |  | 30307 | ERRWRAP2(retval = _self_->grab());
| 30356 | return pyopencv_from(retval); |  | 30308 | return pyopencv_from(retval);
| 30357 | } |  | 30309 | }
| 30358 |  |  | 30310 |
| 30359 | return NULL; |  | 30311 | return NULL;
| 30360 | } |  | 30312 | }
| 30361 |  |  | 30313 |
| 30362 | static PyObject* pyopencv_cv_VideoCapture_isOpened(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30314 | static PyObject* pyopencv_cv_VideoCapture_isOpened(PyObject* self, PyObject* py_args, PyObject* kw)
| 30363 | { |  | 30315 | {
| 30364 | using namespace cv; |  | 30316 | using namespace cv;
| 30365 |  |  | 30317 |
| 30366 |  |  | 30318 |
| 30367 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30319 | Ptr<cv::VideoCapture> * self1 = 0;
| 30368 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30320 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30369 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30321 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30370 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30322 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30371 | bool retval; |  | 30323 | bool retval;
| 30372 |  |  | 30324 |
| 30373 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30374 | { |  | 30326 | {
| 30375 | ERRWRAP2(retval = _self_->isOpened()); |  | 30327 | ERRWRAP2(retval = _self_->isOpened());
| 30376 | return pyopencv_from(retval); |  | 30328 | return pyopencv_from(retval);
| 30377 | } |  | 30329 | }
| 30378 |  |  | 30330 |
| 30379 | return NULL; |  | 30331 | return NULL;
| 30380 | } |  | 30332 | }
| 30381 |  |  | 30333 |
| 30382 | static PyObject* pyopencv_cv_VideoCapture_open(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30334 | static PyObject* pyopencv_cv_VideoCapture_open(PyObject* self, PyObject* py_args, PyObject* kw)
| 30383 | { |  | 30335 | {
| 30384 | using namespace cv; |  | 30336 | using namespace cv;
| 30385 |  |  | 30337 |
| 30386 |  |  | 30338 |
| 30387 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30339 | Ptr<cv::VideoCapture> * self1 = 0;
| 30388 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30340 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30389 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30341 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30390 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30342 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30391 | pyPrepareArgumentConversionErrorsStorage(5); |  | 30343 | pyPrepareArgumentConversionErrorsStorage(5);
| 30392 |  |  | 30344 |
| 30393 | { |  | 30345 | {
| 30394 | PyObject* pyobj_filename = NULL; |  | 30346 | PyObject* pyobj_filename = NULL;
| 30395 | String filename; |  | 30347 | String filename;
| 30396 | PyObject* pyobj_apiPreference = NULL; |  | 30348 | PyObject* pyobj_apiPreference = NULL;
| 30397 | int apiPreference=CAP_ANY; |  | 30349 | int apiPreference=CAP_ANY;
| 30398 | bool retval; |  | 30350 | bool retval;
| 30399 |  |  | 30351 |
| 30400 | const char* keywords[] = { "filename", "apiPreference", NULL }; |  | 30352 | const char* keywords[] = { "filename", "apiPreference", NULL };
| 30401 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference) && |  | 30353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference) &&
| 30402 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30354 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30403 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) ) |  | 30355 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) )
| 30404 | { |  | 30356 | {
| 30405 | ERRWRAP2(retval = _self_->open(filename, apiPreference)); |  | 30357 | ERRWRAP2(retval = _self_->open(filename, apiPreference));
| 30406 | return pyopencv_from(retval); |  | 30358 | return pyopencv_from(retval);
| 30407 | } |  | 30359 | }
| 30408 |  |  | 30360 |
| 30409 |  |  | 30361 |
| 30410 | pyPopulateArgumentConversionErrors(); |  | 30362 | pyPopulateArgumentConversionErrors();
| 30411 | } |  | 30363 | }
| 30412 |  |  | 30364 |
| 30413 |  |  | 30365 |
| 30414 | { |  | 30366 | {
| 30415 | PyObject* pyobj_filename = NULL; |  | 30367 | PyObject* pyobj_filename = NULL;
| 30416 | String filename; |  | 30368 | String filename;
| 30417 | PyObject* pyobj_apiPreference = NULL; |  | 30369 | PyObject* pyobj_apiPreference = NULL;
| 30418 | int apiPreference=0; |  | 30370 | int apiPreference=0;
| 30419 | PyObject* pyobj_params = NULL; |  | 30371 | PyObject* pyobj_params = NULL;
| 30420 | vector_int params; |  | 30372 | vector_int params;
| 30421 | bool retval; |  | 30373 | bool retval;
| 30422 |  |  | 30374 |
| 30423 | const char* keywords[] = { "filename", "apiPreference", "params", NULL }; |  | 30375 | const char* keywords[] = { "filename", "apiPreference", "params", NULL };
| 30424 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_params) && |  | 30376 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_params) &&
| 30425 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30377 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30426 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30378 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30427 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30379 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30428 | { |  | 30380 | {
| 30429 | ERRWRAP2(retval = _self_->open(filename, apiPreference, params)); |  | 30381 | ERRWRAP2(retval = _self_->open(filename, apiPreference, params));
| 30430 | return pyopencv_from(retval); |  | 30382 | return pyopencv_from(retval);
| 30431 | } |  | 30383 | }
| 30432 |  |  | 30384 |
| 30433 |  |  | 30385 |
| 30434 | pyPopulateArgumentConversionErrors(); |  | 30386 | pyPopulateArgumentConversionErrors();
| 30435 | } |  | 30387 | }
| 30436 |  |  | 30388 |
| 30437 |  |  | 30389 |
| 30438 | { |  | 30390 | {
| 30439 | PyObject* pyobj_index = NULL; |  | 30391 | PyObject* pyobj_index = NULL;
| 30440 | int index=0; |  | 30392 | int index=0;
| 30441 | PyObject* pyobj_apiPreference = NULL; |  | 30393 | PyObject* pyobj_apiPreference = NULL;
| 30442 | int apiPreference=CAP_ANY; |  | 30394 | int apiPreference=CAP_ANY;
| 30443 | bool retval; |  | 30395 | bool retval;
| 30444 |  |  | 30396 |
| 30445 | const char* keywords[] = { "index", "apiPreference", NULL }; |  | 30397 | const char* keywords[] = { "index", "apiPreference", NULL };
| 30446 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture.open", (char**)keywords, &pyobj_index, &pyobj_apiPreference) && |  | 30398 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture.open", (char**)keywords, &pyobj_index, &pyobj_apiPreference) &&
| 30447 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 30399 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 30448 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) ) |  | 30400 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) )
| 30449 | { |  | 30401 | {
| 30450 | ERRWRAP2(retval = _self_->open(index, apiPreference)); |  | 30402 | ERRWRAP2(retval = _self_->open(index, apiPreference));
| 30451 | return pyopencv_from(retval); |  | 30403 | return pyopencv_from(retval);
| 30452 | } |  | 30404 | }
| 30453 |  |  | 30405 |
| 30454 |  |  | 30406 |
| 30455 | pyPopulateArgumentConversionErrors(); |  | 30407 | pyPopulateArgumentConversionErrors();
| 30456 | } |  | 30408 | }
| 30457 |  |  | 30409 |
| 30458 |  |  | 30410 |
| 30459 | { |  | 30411 | {
| 30460 | PyObject* pyobj_index = NULL; |  | 30412 | PyObject* pyobj_index = NULL;
| 30461 | int index=0; |  | 30413 | int index=0;
| 30462 | PyObject* pyobj_apiPreference = NULL; |  | 30414 | PyObject* pyobj_apiPreference = NULL;
| 30463 | int apiPreference=0; |  | 30415 | int apiPreference=0;
| 30464 | PyObject* pyobj_params = NULL; |  | 30416 | PyObject* pyobj_params = NULL;
| 30465 | vector_int params; |  | 30417 | vector_int params;
| 30466 | bool retval; |  | 30418 | bool retval;
| 30467 |  |  | 30419 |
| 30468 | const char* keywords[] = { "index", "apiPreference", "params", NULL }; |  | 30420 | const char* keywords[] = { "index", "apiPreference", "params", NULL };
| 30469 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture.open", (char**)keywords, &pyobj_index, &pyobj_apiPreference, &pyobj_params) && |  | 30421 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture.open", (char**)keywords, &pyobj_index, &pyobj_apiPreference, &pyobj_params) &&
| 30470 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 30422 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 30471 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30423 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30472 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30424 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30473 | { |  | 30425 | {
| 30474 | ERRWRAP2(retval = _self_->open(index, apiPreference, params)); |  | 30426 | ERRWRAP2(retval = _self_->open(index, apiPreference, params));
| 30475 | return pyopencv_from(retval); |  | 30427 | return pyopencv_from(retval);
| 30476 | } |  | 30428 | }
| 30477 |  |  | 30429 |
| 30478 |  |  | 30430 |
| 30479 | pyPopulateArgumentConversionErrors(); |  | 30431 | pyPopulateArgumentConversionErrors();
| 30480 | } |  | 30432 | }
| 30481 |  |  | 30433 |
| 30482 |  |  | 30434 |
| 30483 | { |  | 30435 | {
| 30484 | PyObject* pyobj_source = NULL; |  | 30436 | PyObject* pyobj_source = NULL;
| 30485 | Ptr<IStreamReader> source; |  | 30437 | Ptr<IStreamReader> source;
| 30486 | PyObject* pyobj_apiPreference = NULL; |  | 30438 | PyObject* pyobj_apiPreference = NULL;
| 30487 | int apiPreference=0; |  | 30439 | int apiPreference=0;
| 30488 | PyObject* pyobj_params = NULL; |  | 30440 | PyObject* pyobj_params = NULL;
| 30489 | vector_int params; |  | 30441 | vector_int params;
| 30490 | bool retval; |  | 30442 | bool retval;
| 30491 |  |  | 30443 |
| 30492 | const char* keywords[] = { "source", "apiPreference", "params", NULL }; |  | 30444 | const char* keywords[] = { "source", "apiPreference", "params", NULL };
| 30493 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture.open", (char**)keywords, &pyobj_source, &pyobj_apiPreference, &pyobj_params) && |  | 30445 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:VideoCapture.open", (char**)keywords, &pyobj_source, &pyobj_apiPreference, &pyobj_params) &&
| 30494 | pyopencv_to_safe(pyobj_source, source, ArgInfo("source", 0)) && |  | 30446 | pyopencv_to_safe(pyobj_source, source, ArgInfo("source", 0)) &&
| 30495 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30447 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30496 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30448 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30497 | { |  | 30449 | {
| 30498 | ERRWRAP2(retval = _self_->open(source, apiPreference, params)); |  | 30450 | ERRWRAP2(retval = _self_->open(source, apiPreference, params));
| 30499 | return pyopencv_from(retval); |  | 30451 | return pyopencv_from(retval);
| 30500 | } |  | 30452 | }
| 30501 |  |  | 30453 |
| 30502 |  |  | 30454 |
| 30503 | pyPopulateArgumentConversionErrors(); |  | 30455 | pyPopulateArgumentConversionErrors();
| 30504 | } |  | 30456 | }
| 30505 | pyRaiseCVOverloadException("open"); |  | 30457 | pyRaiseCVOverloadException("open");
| 30506 |  |  | 30458 |
| 30507 | return NULL; |  | 30459 | return NULL;
| 30508 | } |  | 30460 | }
| 30509 |  |  | 30461 |
| 30510 | static PyObject* pyopencv_cv_VideoCapture_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30462 | static PyObject* pyopencv_cv_VideoCapture_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 30511 | { |  | 30463 | {
| 30512 | using namespace cv; |  | 30464 | using namespace cv;
| 30513 |  |  | 30465 |
| 30514 |  |  | 30466 |
| 30515 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30467 | Ptr<cv::VideoCapture> * self1 = 0;
| 30516 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30468 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30517 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30469 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30518 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30470 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30519 | pyPrepareArgumentConversionErrorsStorage(2); |  | 30471 | pyPrepareArgumentConversionErrorsStorage(2);
| 30520 |  |  | 30472 |
| 30521 | { |  | 30473 | {
| 30522 | PyObject* pyobj_image = NULL; |  | 30474 | PyObject* pyobj_image = NULL;
| 30523 | Mat image; |  | 30475 | Mat image;
| 30524 | bool retval; |  | 30476 | bool retval;
| 30525 |  |  | 30477 |
| 30526 | const char* keywords[] = { "image", NULL }; |  | 30478 | const char* keywords[] = { "image", NULL };
| 30527 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:VideoCapture.read", (char**)keywords, &pyobj_image) && |  | 30479 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:VideoCapture.read", (char**)keywords, &pyobj_image) &&
| 30528 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 30480 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 30529 | { |  | 30481 | {
| 30530 | ERRWRAP2(retval = _self_->read(image)); |  | 30482 | ERRWRAP2(retval = _self_->read(image));
| 30531 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image)); |  | 30483 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image));
| 30532 | } |  | 30484 | }
| 30533 |  |  | 30485 |
| 30534 |  |  | 30486 |
| 30535 | pyPopulateArgumentConversionErrors(); |  | 30487 | pyPopulateArgumentConversionErrors();
| 30536 | } |  | 30488 | }
| 30537 |  |  | 30489 |
| 30538 |  |  | 30490 |
| 30539 | { |  | 30491 | {
| 30540 | PyObject* pyobj_image = NULL; |  | 30492 | PyObject* pyobj_image = NULL;
| 30541 | UMat image; |  | 30493 | UMat image;
| 30542 | bool retval; |  | 30494 | bool retval;
| 30543 |  |  | 30495 |
| 30544 | const char* keywords[] = { "image", NULL }; |  | 30496 | const char* keywords[] = { "image", NULL };
| 30545 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:VideoCapture.read", (char**)keywords, &pyobj_image) && |  | 30497 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:VideoCapture.read", (char**)keywords, &pyobj_image) &&
| 30546 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 30498 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 30547 | { |  | 30499 | {
| 30548 | ERRWRAP2(retval = _self_->read(image)); |  | 30500 | ERRWRAP2(retval = _self_->read(image));
| 30549 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image)); |  | 30501 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image));
| 30550 | } |  | 30502 | }
| 30551 |  |  | 30503 |
| 30552 |  |  | 30504 |
| 30553 | pyPopulateArgumentConversionErrors(); |  | 30505 | pyPopulateArgumentConversionErrors();
| 30554 | } |  | 30506 | }
| 30555 | pyRaiseCVOverloadException("read"); |  | 30507 | pyRaiseCVOverloadException("read");
| 30556 |  |  | 30508 |
| 30557 | return NULL; |  | 30509 | return NULL;
| 30558 | } |  | 30510 | }
| 30559 |  |  | 30511 |
| 30560 | static PyObject* pyopencv_cv_VideoCapture_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30512 | static PyObject* pyopencv_cv_VideoCapture_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 30561 | { |  | 30513 | {
| 30562 | using namespace cv; |  | 30514 | using namespace cv;
| 30563 |  |  | 30515 |
| 30564 |  |  | 30516 |
| 30565 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30517 | Ptr<cv::VideoCapture> * self1 = 0;
| 30566 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30518 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30567 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30519 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30568 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30520 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30569 |  |  | 30521 |
| 30570 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30522 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30571 | { |  | 30523 | {
| 30572 | ERRWRAP2(_self_->release()); |  | 30524 | ERRWRAP2(_self_->release());
| 30573 | Py_RETURN_NONE; |  | 30525 | Py_RETURN_NONE;
| 30574 | } |  | 30526 | }
| 30575 |  |  | 30527 |
| 30576 | return NULL; |  | 30528 | return NULL;
| 30577 | } |  | 30529 | }
| 30578 |  |  | 30530 |
| 30579 | static PyObject* pyopencv_cv_VideoCapture_retrieve(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30531 | static PyObject* pyopencv_cv_VideoCapture_retrieve(PyObject* self, PyObject* py_args, PyObject* kw)
| 30580 | { |  | 30532 | {
| 30581 | using namespace cv; |  | 30533 | using namespace cv;
| 30582 |  |  | 30534 |
| 30583 |  |  | 30535 |
| 30584 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30536 | Ptr<cv::VideoCapture> * self1 = 0;
| 30585 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30537 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30586 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30538 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30587 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30539 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30588 | pyPrepareArgumentConversionErrorsStorage(2); |  | 30540 | pyPrepareArgumentConversionErrorsStorage(2);
| 30589 |  |  | 30541 |
| 30590 | { |  | 30542 | {
| 30591 | PyObject* pyobj_image = NULL; |  | 30543 | PyObject* pyobj_image = NULL;
| 30592 | Mat image; |  | 30544 | Mat image;
| 30593 | PyObject* pyobj_flag = NULL; |  | 30545 | PyObject* pyobj_flag = NULL;
| 30594 | int flag=0; |  | 30546 | int flag=0;
| 30595 | bool retval; |  | 30547 | bool retval;
| 30596 |  |  | 30548 |
| 30597 | const char* keywords[] = { "image", "flag", NULL }; |  | 30549 | const char* keywords[] = { "image", "flag", NULL };
| 30598 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:VideoCapture.retrieve", (char**)keywords, &pyobj_image, &pyobj_flag) && |  | 30550 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:VideoCapture.retrieve", (char**)keywords, &pyobj_image, &pyobj_flag) &&
| 30599 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 30551 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 30600 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) ) |  | 30552 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) )
| 30601 | { |  | 30553 | {
| 30602 | ERRWRAP2(retval = _self_->retrieve(image, flag)); |  | 30554 | ERRWRAP2(retval = _self_->retrieve(image, flag));
| 30603 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image)); |  | 30555 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image));
| 30604 | } |  | 30556 | }
| 30605 |  |  | 30557 |
| 30606 |  |  | 30558 |
| 30607 | pyPopulateArgumentConversionErrors(); |  | 30559 | pyPopulateArgumentConversionErrors();
| 30608 | } |  | 30560 | }
| 30609 |  |  | 30561 |
| 30610 |  |  | 30562 |
| 30611 | { |  | 30563 | {
| 30612 | PyObject* pyobj_image = NULL; |  | 30564 | PyObject* pyobj_image = NULL;
| 30613 | UMat image; |  | 30565 | UMat image;
| 30614 | PyObject* pyobj_flag = NULL; |  | 30566 | PyObject* pyobj_flag = NULL;
| 30615 | int flag=0; |  | 30567 | int flag=0;
| 30616 | bool retval; |  | 30568 | bool retval;
| 30617 |  |  | 30569 |
| 30618 | const char* keywords[] = { "image", "flag", NULL }; |  | 30570 | const char* keywords[] = { "image", "flag", NULL };
| 30619 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:VideoCapture.retrieve", (char**)keywords, &pyobj_image, &pyobj_flag) && |  | 30571 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:VideoCapture.retrieve", (char**)keywords, &pyobj_image, &pyobj_flag) &&
| 30620 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 30572 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 30621 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) ) |  | 30573 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) )
| 30622 | { |  | 30574 | {
| 30623 | ERRWRAP2(retval = _self_->retrieve(image, flag)); |  | 30575 | ERRWRAP2(retval = _self_->retrieve(image, flag));
| 30624 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image)); |  | 30576 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(image));
| 30625 | } |  | 30577 | }
| 30626 |  |  | 30578 |
| 30627 |  |  | 30579 |
| 30628 | pyPopulateArgumentConversionErrors(); |  | 30580 | pyPopulateArgumentConversionErrors();
| 30629 | } |  | 30581 | }
| 30630 | pyRaiseCVOverloadException("retrieve"); |  | 30582 | pyRaiseCVOverloadException("retrieve");
| 30631 |  |  | 30583 |
| 30632 | return NULL; |  | 30584 | return NULL;
| 30633 | } |  | 30585 | }
| 30634 |  |  | 30586 |
| 30635 | static PyObject* pyopencv_cv_VideoCapture_set(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30587 | static PyObject* pyopencv_cv_VideoCapture_set(PyObject* self, PyObject* py_args, PyObject* kw)
| 30636 | { |  | 30588 | {
| 30637 | using namespace cv; |  | 30589 | using namespace cv;
| 30638 |  |  | 30590 |
| 30639 |  |  | 30591 |
| 30640 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30592 | Ptr<cv::VideoCapture> * self1 = 0;
| 30641 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30593 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30642 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30594 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30643 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30595 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30644 | PyObject* pyobj_propId = NULL; |  | 30596 | PyObject* pyobj_propId = NULL;
| 30645 | int propId=0; |  | 30597 | int propId=0;
| 30646 | PyObject* pyobj_value = NULL; |  | 30598 | PyObject* pyobj_value = NULL;
| 30647 | double value=0; |  | 30599 | double value=0;
| 30648 | bool retval; |  | 30600 | bool retval;
| 30649 |  |  | 30601 |
| 30650 | const char* keywords[] = { "propId", "value", NULL }; |  | 30602 | const char* keywords[] = { "propId", "value", NULL };
| 30651 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:VideoCapture.set", (char**)keywords, &pyobj_propId, &pyobj_value) && |  | 30603 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:VideoCapture.set", (char**)keywords, &pyobj_propId, &pyobj_value) &&
| 30652 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) && |  | 30604 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) &&
| 30653 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 30605 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 30654 | { |  | 30606 | {
| 30655 | ERRWRAP2(retval = _self_->set(propId, value)); |  | 30607 | ERRWRAP2(retval = _self_->set(propId, value));
| 30656 | return pyopencv_from(retval); |  | 30608 | return pyopencv_from(retval);
| 30657 | } |  | 30609 | }
| 30658 |  |  | 30610 |
| 30659 | return NULL; |  | 30611 | return NULL;
| 30660 | } |  | 30612 | }
| 30661 |  |  | 30613 |
| 30662 | static PyObject* pyopencv_cv_VideoCapture_setExceptionMode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30614 | static PyObject* pyopencv_cv_VideoCapture_setExceptionMode(PyObject* self, PyObject* py_args, PyObject* kw)
| 30663 | { |  | 30615 | {
| 30664 | using namespace cv; |  | 30616 | using namespace cv;
| 30665 |  |  | 30617 |
| 30666 |  |  | 30618 |
| 30667 | Ptr<cv::VideoCapture> * self1 = 0; |  | 30619 | Ptr<cv::VideoCapture> * self1 = 0;
| 30668 | if (!pyopencv_VideoCapture_getp(self, self1)) |  | 30620 | if (!pyopencv_VideoCapture_getp(self, self1))
| 30669 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)"); |  | 30621 | return failmsgp("Incorrect type of self (must be 'VideoCapture' or its derivative)");
| 30670 | Ptr<cv::VideoCapture> _self_ = *(self1); |  | 30622 | Ptr<cv::VideoCapture> _self_ = *(self1);
| 30671 | PyObject* pyobj_enable = NULL; |  | 30623 | PyObject* pyobj_enable = NULL;
| 30672 | bool enable=0; |  | 30624 | bool enable=0;
| 30673 |  |  | 30625 |
| 30674 | const char* keywords[] = { "enable", NULL }; |  | 30626 | const char* keywords[] = { "enable", NULL };
| 30675 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoCapture.setExceptionMode", (char**)keywords, &pyobj_enable) && |  | 30627 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoCapture.setExceptionMode", (char**)keywords, &pyobj_enable) &&
| 30676 | pyopencv_to_safe(pyobj_enable, enable, ArgInfo("enable", 0)) ) |  | 30628 | pyopencv_to_safe(pyobj_enable, enable, ArgInfo("enable", 0)) )
| 30677 | { |  | 30629 | {
| 30678 | ERRWRAP2(_self_->setExceptionMode(enable)); |  | 30630 | ERRWRAP2(_self_->setExceptionMode(enable));
| 30679 | Py_RETURN_NONE; |  | 30631 | Py_RETURN_NONE;
| 30680 | } |  | 30632 | }
| 30681 |  |  | 30633 |
| 30682 | return NULL; |  | 30634 | return NULL;
| 30683 | } |  | 30635 | }
| 30684 |  |  | 30636 |
| 30685 | static PyObject* pyopencv_cv_VideoCapture_waitAny_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30637 | static PyObject* pyopencv_cv_VideoCapture_waitAny_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 30686 | { |  | 30638 | {
| 30687 | using namespace cv; |  | 30639 | using namespace cv;
| 30688 |  |  | 30640 |
| 30689 | PyObject* pyobj_streams = NULL; |  | 30641 | PyObject* pyobj_streams = NULL;
| 30690 | vector_VideoCapture streams; |  | 30642 | vector_VideoCapture streams;
| 30691 | vector_int readyIndex; |  | 30643 | vector_int readyIndex;
| 30692 | PyObject* pyobj_timeoutNs = NULL; |  | 30644 | PyObject* pyobj_timeoutNs = NULL;
| 30693 | int64 timeoutNs=0; |  | 30645 | int64 timeoutNs=0;
| 30694 | bool retval; |  | 30646 | bool retval;
| 30695 |  |  | 30647 |
| 30696 | const char* keywords[] = { "streams", "timeoutNs", NULL }; |  | 30648 | const char* keywords[] = { "streams", "timeoutNs", NULL };
| 30697 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture.waitAny", (char**)keywords, &pyobj_streams, &pyobj_timeoutNs) && |  | 30649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:VideoCapture.waitAny", (char**)keywords, &pyobj_streams, &pyobj_timeoutNs) &&
| 30698 | pyopencv_to_safe(pyobj_streams, streams, ArgInfo("streams", 0)) && |  | 30650 | pyopencv_to_safe(pyobj_streams, streams, ArgInfo("streams", 0)) &&
| 30699 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) ) |  | 30651 | pyopencv_to_safe(pyobj_timeoutNs, timeoutNs, ArgInfo("timeoutNs", 0)) )
| 30700 | { |  | 30652 | {
| 30701 | ERRWRAP2(retval = cv::VideoCapture::waitAny(streams, readyIndex, timeoutNs)); |  | 30653 | ERRWRAP2(retval = cv::VideoCapture::waitAny(streams, readyIndex, timeoutNs));
| 30702 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(readyIndex)); |  | 30654 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(readyIndex));
| 30703 | } |  | 30655 | }
| 30704 |  |  | 30656 |
| 30705 | return NULL; |  | 30657 | return NULL;
| 30706 | } |  | 30658 | }
| 30707 |  |  | 30659 |
| 30708 |  |  | 30660 |
| 30709 |  |  | 30661 |
| 30710 | // Tables (VideoCapture) |  | 30662 | // Tables (VideoCapture)
| 30711 |  |  | 30663 |
| 30712 | static PyGetSetDef pyopencv_VideoCapture_getseters[] = |  | 30664 | static PyGetSetDef pyopencv_VideoCapture_getseters[] =
| 30713 | { |  | 30665 | {
| 30714 | {NULL} /* Sentinel */ |  | 30666 | {NULL} /* Sentinel */
| 30715 | }; |  | 30667 | };
| 30716 |  |  | 30668 |
| 30717 | static PyMethodDef pyopencv_VideoCapture_methods[] = |  | 30669 | static PyMethodDef pyopencv_VideoCapture_methods[] =
| 30718 | { |  | 30670 | {
| 30719 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_get, 0), "get(propId) -> retval\n. @brief Returns the specified VideoCapture property\n. \n. @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)\n. or one from @ref videoio_flags_others\n. @return Value for the specified property. Value 0 is returned when querying a property that is\n. not supported by the backend used by the VideoCapture instance.\n. \n. @note Reading / writing properties involves many layers. Some unexpected result might happens\n. along this chain.\n. @code{.txt}\n. VideoCapture -> API Backend -> Operating System -> Device Driver -> Device Hardware\n. @endcode\n. The returned value might be different from what really used by the device or it could be encoded\n. using device dependent rules (eg. steps or percentage). Effective behaviour depends from device\n. driver and API Backend"}, |  | 30671 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_get, 0), "get(propId) -> retval\n. @brief Returns the specified VideoCapture property\n. \n. @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)\n. or one from @ref videoio_flags_others\n. @return Value for the specified property. Value 0 is returned when querying a property that is\n. not supported by the backend used by the VideoCapture instance.\n. \n. @note Reading / writing properties involves many layers. Some unexpected result might happens\n. along this chain.\n. @code{.txt}\n. VideoCapture -> API Backend -> Operating System -> Device Driver -> Device Hardware\n. @endcode\n. The returned value might be different from what really used by the device or it could be encoded\n. using device dependent rules (eg. steps or percentage). Effective behaviour depends from device\n. driver and API Backend"},
| 30720 | {"getBackendName", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_getBackendName, 0), "getBackendName() -> retval\n. @brief Returns used backend API name\n. \n. @note Stream should be opened."}, |  | 30672 | {"getBackendName", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_getBackendName, 0), "getBackendName() -> retval\n. @brief Returns used backend API name\n. \n. @note Stream should be opened."},
| 30721 | {"getExceptionMode", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_getExceptionMode, 0), "getExceptionMode() -> retval\n."}, |  | 30673 | {"getExceptionMode", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_getExceptionMode, 0), "getExceptionMode() -> retval\n."},
| 30722 | {"grab", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_grab, 0), "grab() -> retval\n. @brief Grabs the next frame from video file or capturing device.\n. \n. @return `true` (non-zero) in the case of success.\n. \n. The method/function grabs the next frame from video file or camera and returns true (non-zero) in\n. the case of success.\n. \n. The primary use of the function is in multi-camera environments, especially when the cameras do not\n. have hardware synchronization. That is, you call VideoCapture::grab() for each camera and after that\n. call the slower method VideoCapture::retrieve() to decode and get frame from each camera. This way\n. the overhead on demosaicing or motion jpeg decompression etc. is eliminated and the retrieved frames\n. from different cameras will be closer in time.\n. \n. Also, when a connected camera is multi-head (for example, a stereo camera or a Kinect device), the\n. correct way of retrieving data from it is to call VideoCapture::grab() first and then call\n. VideoCapture::retrieve() one or more times with different values of the channel parameter.\n. \n. @ref tutorial_kinect_openni"}, |  | 30674 | {"grab", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_grab, 0), "grab() -> retval\n. @brief Grabs the next frame from video file or capturing device.\n. \n. @return `true` (non-zero) in the case of success.\n. \n. The method/function grabs the next frame from video file or camera and returns true (non-zero) in\n. the case of success.\n. \n. The primary use of the function is in multi-camera environments, especially when the cameras do not\n. have hardware synchronization. That is, you call VideoCapture::grab() for each camera and after that\n. call the slower method VideoCapture::retrieve() to decode and get frame from each camera. This way\n. the overhead on demosaicing or motion jpeg decompression etc. is eliminated and the retrieved frames\n. from different cameras will be closer in time.\n. \n. Also, when a connected camera is multi-head (for example, a stereo camera or a Kinect device), the\n. correct way of retrieving data from it is to call VideoCapture::grab() first and then call\n. VideoCapture::retrieve() one or more times with different values of the channel parameter.\n. \n. @ref tutorial_kinect_openni"},
| 30723 | {"isOpened", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_isOpened, 0), "isOpened() -> retval\n. @brief Returns true if video capturing has been initialized already.\n. \n. If the previous call to VideoCapture constructor or VideoCapture::open() succeeded, the method returns\n. true."}, |  | 30675 | {"isOpened", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_isOpened, 0), "isOpened() -> retval\n. @brief Returns true if video capturing has been initialized already.\n. \n. If the previous call to VideoCapture constructor or VideoCapture::open() succeeded, the method returns\n. true."},
| 30724 | {"open", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_open, 0), "open(filename[, apiPreference]) -> retval\n. @brief Opens a video file or a capturing device or an IP video stream for video capturing.\n. \n. @overload\n. \n. Parameters are same as the constructor VideoCapture(const String& filename, int apiPreference = CAP_ANY)\n. @return `true` if the file has been successfully opened\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(filename, apiPreference, params) -> retval\n. @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference and parameters\n. \n. @overload\n. \n. The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.\n. See cv::VideoCaptureProperties\n. \n. @return `true` if the file has been successfully opened\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(index[, apiPreference]) -> retval\n. @brief Opens a camera for video capturing\n. \n. @overload\n. \n. Parameters are same as the constructor VideoCapture(int index, int apiPreference = CAP_ANY)\n. @return `true` if the camera has been successfully opened.\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(index, apiPreference, params) -> retval\n. @brief Opens a camera for video capturing with API Preference and parameters\n. \n. @overload\n. \n. The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.\n. See cv::VideoCaptureProperties\n. \n. @return `true` if the camera has been successfully opened.\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(source, apiPreference, params) -> retval\n. @brief Opens a video using data stream.\n. \n. @overload\n. \n. The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.\n. See cv::VideoCaptureProperties\n. \n. @return `true` if the file has been successfully opened\n. \n. The method first calls VideoCapture::release to close the already opened file or camera."}, |  | 30676 | {"open", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_open, 0), "open(filename[, apiPreference]) -> retval\n. @brief Opens a video file or a capturing device or an IP video stream for video capturing.\n. \n. @overload\n. \n. Parameters are same as the constructor VideoCapture(const String& filename, int apiPreference = CAP_ANY)\n. @return `true` if the file has been successfully opened\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(filename, apiPreference, params) -> retval\n. @brief Opens a video file or a capturing device or an IP video stream for video capturing with API Preference and parameters\n. \n. @overload\n. \n. The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.\n. See cv::VideoCaptureProperties\n. \n. @return `true` if the file has been successfully opened\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(index[, apiPreference]) -> retval\n. @brief Opens a camera for video capturing\n. \n. @overload\n. \n. Parameters are same as the constructor VideoCapture(int index, int apiPreference = CAP_ANY)\n. @return `true` if the camera has been successfully opened.\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(index, apiPreference, params) -> retval\n. @brief Opens a camera for video capturing with API Preference and parameters\n. \n. @overload\n. \n. The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.\n. See cv::VideoCaptureProperties\n. \n. @return `true` if the camera has been successfully opened.\n. \n. The method first calls VideoCapture::release to close the already opened file or camera.\n\n\n\nopen(source, apiPreference, params) -> retval\n. @brief Opens a video using data stream.\n. \n. @overload\n. \n. The `params` parameter allows to specify extra parameters encoded as pairs `(paramId_1, paramValue_1, paramId_2, paramValue_2, ...)`.\n. See cv::VideoCaptureProperties\n. \n. @return `true` if the file has been successfully opened\n. \n. The method first calls VideoCapture::release to close the already opened file or camera."},
| 30725 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_read, 0), "read([, image]) -> retval, image\n. @brief Grabs, decodes and returns the next video frame.\n. \n. @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.\n. @return `false` if no frames has been grabbed\n. \n. The method/function combines VideoCapture::grab() and VideoCapture::retrieve() in one call. This is the\n. most convenient method for reading video files or capturing data from decode and returns the just\n. grabbed frame. If no frames has been grabbed (camera has been disconnected, or there are no more\n. frames in video file), the method returns false and the function returns empty image (with %cv::Mat, test it with Mat::empty()).\n. \n. @note In @ref videoio_c \"C API\", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video\n. capturing structure. It is not allowed to modify or release the image! You can copy the frame using\n. cvCloneImage and then do whatever you want with the copy."}, |  | 30677 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_read, 0), "read([, image]) -> retval, image\n. @brief Grabs, decodes and returns the next video frame.\n. \n. @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.\n. @return `false` if no frames has been grabbed\n. \n. The method/function combines VideoCapture::grab() and VideoCapture::retrieve() in one call. This is the\n. most convenient method for reading video files or capturing data from decode and returns the just\n. grabbed frame. If no frames has been grabbed (camera has been disconnected, or there are no more\n. frames in video file), the method returns false and the function returns empty image (with %cv::Mat, test it with Mat::empty()).\n. \n. @note In @ref videoio_c \"C API\", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video\n. capturing structure. It is not allowed to modify or release the image! You can copy the frame using\n. cvCloneImage and then do whatever you want with the copy."},
| 30726 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_release, 0), "release() -> None\n. @brief Closes video file or capturing device.\n. \n. The method is automatically called by subsequent VideoCapture::open and by VideoCapture\n. destructor.\n. \n. The C function also deallocates memory and clears \\*capture pointer."}, |  | 30678 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_release, 0), "release() -> None\n. @brief Closes video file or capturing device.\n. \n. The method is automatically called by subsequent VideoCapture::open and by VideoCapture\n. destructor.\n. \n. The C function also deallocates memory and clears \\*capture pointer."},
| 30727 | {"retrieve", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_retrieve, 0), "retrieve([, image[, flag]]) -> retval, image\n. @brief Decodes and returns the grabbed video frame.\n. \n. @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.\n. @param flag it could be a frame index or a driver specific flag\n. @return `false` if no frames has been grabbed\n. \n. The method decodes and returns the just grabbed frame. If no frames has been grabbed\n. (camera has been disconnected, or there are no more frames in video file), the method returns false\n. and the function returns an empty image (with %cv::Mat, test it with Mat::empty()).\n. \n. @sa read()\n. \n. @note In @ref videoio_c \"C API\", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video\n. capturing structure. It is not allowed to modify or release the image! You can copy the frame using\n. cvCloneImage and then do whatever you want with the copy."}, |  | 30679 | {"retrieve", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_retrieve, 0), "retrieve([, image[, flag]]) -> retval, image\n. @brief Decodes and returns the grabbed video frame.\n. \n. @param [out] image the video frame is returned here. If no frames has been grabbed the image will be empty.\n. @param flag it could be a frame index or a driver specific flag\n. @return `false` if no frames has been grabbed\n. \n. The method decodes and returns the just grabbed frame. If no frames has been grabbed\n. (camera has been disconnected, or there are no more frames in video file), the method returns false\n. and the function returns an empty image (with %cv::Mat, test it with Mat::empty()).\n. \n. @sa read()\n. \n. @note In @ref videoio_c \"C API\", functions cvRetrieveFrame() and cv.RetrieveFrame() return image stored inside the video\n. capturing structure. It is not allowed to modify or release the image! You can copy the frame using\n. cvCloneImage and then do whatever you want with the copy."},
| 30728 | {"set", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_set, 0), "set(propId, value) -> retval\n. @brief Sets a property in the VideoCapture.\n. \n. @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)\n. or one from @ref videoio_flags_others\n. @param value Value of the property.\n. @return `true` if the property is supported by backend used by the VideoCapture instance.\n. @note Even if it returns `true` this doesn't ensure that the property\n. value has been accepted by the capture device. See note in VideoCapture::get()"}, |  | 30680 | {"set", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_set, 0), "set(propId, value) -> retval\n. @brief Sets a property in the VideoCapture.\n. \n. @param propId Property identifier from cv::VideoCaptureProperties (eg. cv::CAP_PROP_POS_MSEC, cv::CAP_PROP_POS_FRAMES, ...)\n. or one from @ref videoio_flags_others\n. @param value Value of the property.\n. @return `true` if the property is supported by backend used by the VideoCapture instance.\n. @note Even if it returns `true` this doesn't ensure that the property\n. value has been accepted by the capture device. See note in VideoCapture::get()"},
| 30729 | {"setExceptionMode", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_setExceptionMode, 0), "setExceptionMode(enable) -> None\n. Switches exceptions mode\n. *\n. * methods raise exceptions if not successful instead of returning an error code"}, |  | 30681 | {"setExceptionMode", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_setExceptionMode, 0), "setExceptionMode(enable) -> None\n. Switches exceptions mode\n. *\n. * methods raise exceptions if not successful instead of returning an error code"},
| 30730 | {"waitAny", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_waitAny_static, METH_STATIC), "waitAny(streams[, timeoutNs]) -> retval, readyIndex\n. @brief Wait for ready frames from VideoCapture.\n. \n. @param streams input video streams\n. @param readyIndex stream indexes with grabbed frames (ready to use .retrieve() to fetch actual frame)\n. @param timeoutNs number of nanoseconds (0 - infinite)\n. @return `true` if streamReady is not empty\n. \n. @throws Exception %Exception on stream errors (check .isOpened() to filter out malformed streams) or VideoCapture type is not supported\n. \n. The primary use of the function is in multi-camera environments.\n. The method fills the ready state vector, grabs video frame, if camera is ready.\n. \n. After this call use VideoCapture::retrieve() to decode and fetch frame data."}, |  | 30682 | {"waitAny", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoCapture_waitAny_static, METH_STATIC), "waitAny(streams[, timeoutNs]) -> retval, readyIndex\n. @brief Wait for ready frames from VideoCapture.\n. \n. @param streams input video streams\n. @param readyIndex stream indexes with grabbed frames (ready to use .retrieve() to fetch actual frame)\n. @param timeoutNs number of nanoseconds (0 - infinite)\n. @return `true` if streamReady is not empty\n. \n. @throws Exception %Exception on stream errors (check .isOpened() to filter out malformed streams) or VideoCapture type is not supported\n. \n. The primary use of the function is in multi-camera environments.\n. The method fills the ready state vector, grabs video frame, if camera is ready.\n. \n. After this call use VideoCapture::retrieve() to decode and fetch frame data."},
| 30731 |  |  | 30683 |
| 30732 | {NULL, NULL} |  | 30684 | {NULL, NULL}
| 30733 | }; |  | 30685 | };
| 30734 |  |  | 30686 |
| 30735 | // Converter (VideoCapture) |  | 30687 | // Converter (VideoCapture)
| 30736 |  |  | 30688 |
| 30737 | template<> |  | 30689 | template<>
| 30738 | struct PyOpenCV_Converter< Ptr<cv::VideoCapture> > |  | 30690 | struct PyOpenCV_Converter< Ptr<cv::VideoCapture> >
| 30739 | { |  | 30691 | {
| 30740 | static PyObject* from(const Ptr<cv::VideoCapture>& r) |  | 30692 | static PyObject* from(const Ptr<cv::VideoCapture>& r)
| 30741 | { |  | 30693 | {
| 30742 | return pyopencv_VideoCapture_Instance(r); |  | 30694 | return pyopencv_VideoCapture_Instance(r);
| 30743 | } |  | 30695 | }
| 30744 | static bool to(PyObject* src, Ptr<cv::VideoCapture>& dst, const ArgInfo& info) |  | 30696 | static bool to(PyObject* src, Ptr<cv::VideoCapture>& dst, const ArgInfo& info)
| 30745 | { |  | 30697 | {
| 30746 | if(!src || src == Py_None) |  | 30698 | if(!src || src == Py_None)
| 30747 | return true; |  | 30699 | return true;
| 30748 | Ptr<cv::VideoCapture> * dst_; |  | 30700 | Ptr<cv::VideoCapture> * dst_;
| 30749 | if (pyopencv_VideoCapture_getp(src, dst_)) |  | 30701 | if (pyopencv_VideoCapture_getp(src, dst_))
| 30750 | { |  | 30702 | {
| 30751 | dst = *dst_; |  | 30703 | dst = *dst_;
| 30752 | return true; |  | 30704 | return true;
| 30753 | } |  | 30705 | }
| 30754 |  |  | 30706 |
| 30755 | failmsg("Expected Ptr<cv::VideoCapture> for argument '%s'", info.name); |  | 30707 | failmsg("Expected Ptr<cv::VideoCapture> for argument '%s'", info.name);
| 30756 | return false; |  | 30708 | return false;
| 30757 | } |  | 30709 | }
| 30758 | }; |  | 30710 | };
| 30759 |  |  | 30711 |
| 30760 | //================================================================================ |  | 30712 | //================================================================================
| 30761 | // VideoWriter (Generic) |  | 30713 | // VideoWriter (Generic)
| 30762 | //================================================================================ |  | 30714 | //================================================================================
| 30763 |  |  | 30715 |
| 30764 | // GetSet (VideoWriter) |  | 30716 | // GetSet (VideoWriter)
| 30765 |  |  | 30717 |
| 30766 |  |  | 30718 |
| 30767 |  |  | 30719 |
| 30768 | // Methods (VideoWriter) |  | 30720 | // Methods (VideoWriter)
| 30769 |  |  | 30721 |
| 30770 | static int pyopencv_cv_VideoWriter_VideoWriter(pyopencv_VideoWriter_t* self, PyObject* py_args, PyObject* kw) |  | 30722 | static int pyopencv_cv_VideoWriter_VideoWriter(pyopencv_VideoWriter_t* self, PyObject* py_args, PyObject* kw)
| 30771 | { |  | 30723 | {
| 30772 | using namespace cv; |  | 30724 | using namespace cv;
| 30773 |  |  | 30725 |
| 30774 | pyPrepareArgumentConversionErrorsStorage(5); |  | 30726 | pyPrepareArgumentConversionErrorsStorage(5);
| 30775 |  |  | 30727 |
| 30776 | { |  | 30728 | {
| 30777 |  |  | 30729 |
| 30778 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30730 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30779 | { |  | 30731 | {
| 30780 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new |  | 30732 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new
| 30781 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter())); |  | 30733 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter()));
| 30782 | return 0; |  | 30734 | return 0;
| 30783 | } |  | 30735 | }
| 30784 |  |  | 30736 |
| 30785 |  |  | 30737 |
| 30786 | pyPopulateArgumentConversionErrors(); |  | 30738 | pyPopulateArgumentConversionErrors();
| 30787 | } |  | 30739 | }
| 30788 |  |  | 30740 |
| 30789 |  |  | 30741 |
| 30790 | { |  | 30742 | {
| 30791 | PyObject* pyobj_filename = NULL; |  | 30743 | PyObject* pyobj_filename = NULL;
| 30792 | String filename; |  | 30744 | String filename;
| 30793 | PyObject* pyobj_fourcc = NULL; |  | 30745 | PyObject* pyobj_fourcc = NULL;
| 30794 | int fourcc=0; |  | 30746 | int fourcc=0;
| 30795 | PyObject* pyobj_fps = NULL; |  | 30747 | PyObject* pyobj_fps = NULL;
| 30796 | double fps=0; |  | 30748 | double fps=0;
| 30797 | PyObject* pyobj_frameSize = NULL; |  | 30749 | PyObject* pyobj_frameSize = NULL;
| 30798 | Size frameSize; |  | 30750 | Size frameSize;
| 30799 | PyObject* pyobj_isColor = NULL; |  | 30751 | PyObject* pyobj_isColor = NULL;
| 30800 | bool isColor=true; |  | 30752 | bool isColor=true;
| 30801 |  |  | 30753 |
| 30802 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "isColor", NULL }; |  | 30754 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "isColor", NULL };
| 30803 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) && |  | 30755 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) &&
| 30804 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30756 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30805 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 30757 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 30806 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 30758 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 30807 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 30759 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 30808 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) ) |  | 30760 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) )
| 30809 | { |  | 30761 | {
| 30810 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new |  | 30762 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new
| 30811 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, fourcc, fps, frameSize, isColor))); |  | 30763 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, fourcc, fps, frameSize, isColor)));
| 30812 | return 0; |  | 30764 | return 0;
| 30813 | } |  | 30765 | }
| 30814 |  |  | 30766 |
| 30815 |  |  | 30767 |
| 30816 | pyPopulateArgumentConversionErrors(); |  | 30768 | pyPopulateArgumentConversionErrors();
| 30817 | } |  | 30769 | }
| 30818 |  |  | 30770 |
| 30819 |  |  | 30771 |
| 30820 | { |  | 30772 | {
| 30821 | PyObject* pyobj_filename = NULL; |  | 30773 | PyObject* pyobj_filename = NULL;
| 30822 | String filename; |  | 30774 | String filename;
| 30823 | PyObject* pyobj_apiPreference = NULL; |  | 30775 | PyObject* pyobj_apiPreference = NULL;
| 30824 | int apiPreference=0; |  | 30776 | int apiPreference=0;
| 30825 | PyObject* pyobj_fourcc = NULL; |  | 30777 | PyObject* pyobj_fourcc = NULL;
| 30826 | int fourcc=0; |  | 30778 | int fourcc=0;
| 30827 | PyObject* pyobj_fps = NULL; |  | 30779 | PyObject* pyobj_fps = NULL;
| 30828 | double fps=0; |  | 30780 | double fps=0;
| 30829 | PyObject* pyobj_frameSize = NULL; |  | 30781 | PyObject* pyobj_frameSize = NULL;
| 30830 | Size frameSize; |  | 30782 | Size frameSize;
| 30831 | PyObject* pyobj_isColor = NULL; |  | 30783 | PyObject* pyobj_isColor = NULL;
| 30832 | bool isColor=true; |  | 30784 | bool isColor=true;
| 30833 |  |  | 30785 |
| 30834 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "isColor", NULL }; |  | 30786 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "isColor", NULL };
| 30835 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) && |  | 30787 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) &&
| 30836 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30788 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30837 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30789 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30838 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 30790 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 30839 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 30791 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 30840 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 30792 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 30841 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) ) |  | 30793 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) )
| 30842 | { |  | 30794 | {
| 30843 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new |  | 30795 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new
| 30844 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, apiPreference, fourcc, fps, frameSize, isColor))); |  | 30796 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, apiPreference, fourcc, fps, frameSize, isColor)));
| 30845 | return 0; |  | 30797 | return 0;
| 30846 | } |  | 30798 | }
| 30847 |  |  | 30799 |
| 30848 |  |  | 30800 |
| 30849 | pyPopulateArgumentConversionErrors(); |  | 30801 | pyPopulateArgumentConversionErrors();
| 30850 | } |  | 30802 | }
| 30851 |  |  | 30803 |
| 30852 |  |  | 30804 |
| 30853 | { |  | 30805 | {
| 30854 | PyObject* pyobj_filename = NULL; |  | 30806 | PyObject* pyobj_filename = NULL;
| 30855 | String filename; |  | 30807 | String filename;
| 30856 | PyObject* pyobj_fourcc = NULL; |  | 30808 | PyObject* pyobj_fourcc = NULL;
| 30857 | int fourcc=0; |  | 30809 | int fourcc=0;
| 30858 | PyObject* pyobj_fps = NULL; |  | 30810 | PyObject* pyobj_fps = NULL;
| 30859 | double fps=0; |  | 30811 | double fps=0;
| 30860 | PyObject* pyobj_frameSize = NULL; |  | 30812 | PyObject* pyobj_frameSize = NULL;
| 30861 | Size frameSize; |  | 30813 | Size frameSize;
| 30862 | PyObject* pyobj_params = NULL; |  | 30814 | PyObject* pyobj_params = NULL;
| 30863 | vector_int params; |  | 30815 | vector_int params;
| 30864 |  |  | 30816 |
| 30865 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "params", NULL }; |  | 30817 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "params", NULL };
| 30866 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) && |  | 30818 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) &&
| 30867 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30819 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30868 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 30820 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 30869 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 30821 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 30870 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 30822 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 30871 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30823 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30872 | { |  | 30824 | {
| 30873 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new |  | 30825 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new
| 30874 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, fourcc, fps, frameSize, params))); |  | 30826 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, fourcc, fps, frameSize, params)));
| 30875 | return 0; |  | 30827 | return 0;
| 30876 | } |  | 30828 | }
| 30877 |  |  | 30829 |
| 30878 |  |  | 30830 |
| 30879 | pyPopulateArgumentConversionErrors(); |  | 30831 | pyPopulateArgumentConversionErrors();
| 30880 | } |  | 30832 | }
| 30881 |  |  | 30833 |
| 30882 |  |  | 30834 |
| 30883 | { |  | 30835 | {
| 30884 | PyObject* pyobj_filename = NULL; |  | 30836 | PyObject* pyobj_filename = NULL;
| 30885 | String filename; |  | 30837 | String filename;
| 30886 | PyObject* pyobj_apiPreference = NULL; |  | 30838 | PyObject* pyobj_apiPreference = NULL;
| 30887 | int apiPreference=0; |  | 30839 | int apiPreference=0;
| 30888 | PyObject* pyobj_fourcc = NULL; |  | 30840 | PyObject* pyobj_fourcc = NULL;
| 30889 | int fourcc=0; |  | 30841 | int fourcc=0;
| 30890 | PyObject* pyobj_fps = NULL; |  | 30842 | PyObject* pyobj_fps = NULL;
| 30891 | double fps=0; |  | 30843 | double fps=0;
| 30892 | PyObject* pyobj_frameSize = NULL; |  | 30844 | PyObject* pyobj_frameSize = NULL;
| 30893 | Size frameSize; |  | 30845 | Size frameSize;
| 30894 | PyObject* pyobj_params = NULL; |  | 30846 | PyObject* pyobj_params = NULL;
| 30895 | vector_int params; |  | 30847 | vector_int params;
| 30896 |  |  | 30848 |
| 30897 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "params", NULL }; |  | 30849 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "params", NULL };
| 30898 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) && |  | 30850 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:VideoWriter", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) &&
| 30899 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30851 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 30900 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 30852 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 30901 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 30853 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 30902 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 30854 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 30903 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 30855 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 30904 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 30856 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 30905 | { |  | 30857 | {
| 30906 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new |  | 30858 | new (&(self->v)) Ptr<cv::VideoWriter>(); // init Ptr with placement new
| 30907 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, apiPreference, fourcc, fps, frameSize, params))); |  | 30859 | if(self) ERRWRAP2(self->v.reset(new cv::VideoWriter(filename, apiPreference, fourcc, fps, frameSize, params)));
| 30908 | return 0; |  | 30860 | return 0;
| 30909 | } |  | 30861 | }
| 30910 |  |  | 30862 |
| 30911 |  |  | 30863 |
| 30912 | pyPopulateArgumentConversionErrors(); |  | 30864 | pyPopulateArgumentConversionErrors();
| 30913 | } |  | 30865 | }
| 30914 | pyRaiseCVOverloadException("VideoWriter"); |  | 30866 | pyRaiseCVOverloadException("VideoWriter");
| 30915 |  |  | 30867 |
| 30916 | return -1; |  | 30868 | return -1;
| 30917 | } |  | 30869 | }
| 30918 |  |  | 30870 |
| 30919 | static PyObject* pyopencv_cv_VideoWriter_fourcc_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30871 | static PyObject* pyopencv_cv_VideoWriter_fourcc_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 30920 | { |  | 30872 | {
| 30921 | using namespace cv; |  | 30873 | using namespace cv;
| 30922 |  |  | 30874 |
| 30923 | PyObject* pyobj_c1 = NULL; |  | 30875 | PyObject* pyobj_c1 = NULL;
| 30924 | char c1; |  | 30876 | char c1;
| 30925 | PyObject* pyobj_c2 = NULL; |  | 30877 | PyObject* pyobj_c2 = NULL;
| 30926 | char c2; |  | 30878 | char c2;
| 30927 | PyObject* pyobj_c3 = NULL; |  | 30879 | PyObject* pyobj_c3 = NULL;
| 30928 | char c3; |  | 30880 | char c3;
| 30929 | PyObject* pyobj_c4 = NULL; |  | 30881 | PyObject* pyobj_c4 = NULL;
| 30930 | char c4; |  | 30882 | char c4;
| 30931 | int retval; |  | 30883 | int retval;
| 30932 |  |  | 30884 |
| 30933 | const char* keywords[] = { "c1", "c2", "c3", "c4", NULL }; |  | 30885 | const char* keywords[] = { "c1", "c2", "c3", "c4", NULL };
| 30934 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:VideoWriter.fourcc", (char**)keywords, &pyobj_c1, &pyobj_c2, &pyobj_c3, &pyobj_c4) && |  | 30886 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:VideoWriter.fourcc", (char**)keywords, &pyobj_c1, &pyobj_c2, &pyobj_c3, &pyobj_c4) &&
| 30935 | convert_to_char(pyobj_c1, &c1, ArgInfo("c1", 0)) && |  | 30887 | convert_to_char(pyobj_c1, &c1, ArgInfo("c1", 0)) &&
| 30936 | convert_to_char(pyobj_c2, &c2, ArgInfo("c2", 0)) && |  | 30888 | convert_to_char(pyobj_c2, &c2, ArgInfo("c2", 0)) &&
| 30937 | convert_to_char(pyobj_c3, &c3, ArgInfo("c3", 0)) && |  | 30889 | convert_to_char(pyobj_c3, &c3, ArgInfo("c3", 0)) &&
| 30938 | convert_to_char(pyobj_c4, &c4, ArgInfo("c4", 0)) ) |  | 30890 | convert_to_char(pyobj_c4, &c4, ArgInfo("c4", 0)) )
| 30939 | { |  | 30891 | {
| 30940 | ERRWRAP2(retval = cv::VideoWriter::fourcc(c1, c2, c3, c4)); |  | 30892 | ERRWRAP2(retval = cv::VideoWriter::fourcc(c1, c2, c3, c4));
| 30941 | return pyopencv_from(retval); |  | 30893 | return pyopencv_from(retval);
| 30942 | } |  | 30894 | }
| 30943 |  |  | 30895 |
| 30944 | return NULL; |  | 30896 | return NULL;
| 30945 | } |  | 30897 | }
| 30946 |  |  | 30898 |
| 30947 | static PyObject* pyopencv_cv_VideoWriter_get(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30899 | static PyObject* pyopencv_cv_VideoWriter_get(PyObject* self, PyObject* py_args, PyObject* kw)
| 30948 | { |  | 30900 | {
| 30949 | using namespace cv; |  | 30901 | using namespace cv;
| 30950 |  |  | 30902 |
| 30951 |  |  | 30903 |
| 30952 | Ptr<cv::VideoWriter> * self1 = 0; |  | 30904 | Ptr<cv::VideoWriter> * self1 = 0;
| 30953 | if (!pyopencv_VideoWriter_getp(self, self1)) |  | 30905 | if (!pyopencv_VideoWriter_getp(self, self1))
| 30954 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)"); |  | 30906 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)");
| 30955 | Ptr<cv::VideoWriter> _self_ = *(self1); |  | 30907 | Ptr<cv::VideoWriter> _self_ = *(self1);
| 30956 | PyObject* pyobj_propId = NULL; |  | 30908 | PyObject* pyobj_propId = NULL;
| 30957 | int propId=0; |  | 30909 | int propId=0;
| 30958 | double retval; |  | 30910 | double retval;
| 30959 |  |  | 30911 |
| 30960 | const char* keywords[] = { "propId", NULL }; |  | 30912 | const char* keywords[] = { "propId", NULL };
| 30961 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoWriter.get", (char**)keywords, &pyobj_propId) && |  | 30913 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoWriter.get", (char**)keywords, &pyobj_propId) &&
| 30962 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) ) |  | 30914 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) )
| 30963 | { |  | 30915 | {
| 30964 | ERRWRAP2(retval = _self_->get(propId)); |  | 30916 | ERRWRAP2(retval = _self_->get(propId));
| 30965 | return pyopencv_from(retval); |  | 30917 | return pyopencv_from(retval);
| 30966 | } |  | 30918 | }
| 30967 |  |  | 30919 |
| 30968 | return NULL; |  | 30920 | return NULL;
| 30969 | } |  | 30921 | }
| 30970 |  |  | 30922 |
| 30971 | static PyObject* pyopencv_cv_VideoWriter_getBackendName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30923 | static PyObject* pyopencv_cv_VideoWriter_getBackendName(PyObject* self, PyObject* py_args, PyObject* kw)
| 30972 | { |  | 30924 | {
| 30973 | using namespace cv; |  | 30925 | using namespace cv;
| 30974 |  |  | 30926 |
| 30975 |  |  | 30927 |
| 30976 | Ptr<cv::VideoWriter> * self1 = 0; |  | 30928 | Ptr<cv::VideoWriter> * self1 = 0;
| 30977 | if (!pyopencv_VideoWriter_getp(self, self1)) |  | 30929 | if (!pyopencv_VideoWriter_getp(self, self1))
| 30978 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)"); |  | 30930 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)");
| 30979 | Ptr<cv::VideoWriter> _self_ = *(self1); |  | 30931 | Ptr<cv::VideoWriter> _self_ = *(self1);
| 30980 | String retval; |  | 30932 | String retval;
| 30981 |  |  | 30933 |
| 30982 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30934 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 30983 | { |  | 30935 | {
| 30984 | ERRWRAP2(retval = _self_->getBackendName()); |  | 30936 | ERRWRAP2(retval = _self_->getBackendName());
| 30985 | return pyopencv_from(retval); |  | 30937 | return pyopencv_from(retval);
| 30986 | } |  | 30938 | }
| 30987 |  |  | 30939 |
| 30988 | return NULL; |  | 30940 | return NULL;
| 30989 | } |  | 30941 | }
| 30990 |  |  | 30942 |
| 30991 | static PyObject* pyopencv_cv_VideoWriter_isOpened(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30943 | static PyObject* pyopencv_cv_VideoWriter_isOpened(PyObject* self, PyObject* py_args, PyObject* kw)
| 30992 | { |  | 30944 | {
| 30993 | using namespace cv; |  | 30945 | using namespace cv;
| 30994 |  |  | 30946 |
| 30995 |  |  | 30947 |
| 30996 | Ptr<cv::VideoWriter> * self1 = 0; |  | 30948 | Ptr<cv::VideoWriter> * self1 = 0;
| 30997 | if (!pyopencv_VideoWriter_getp(self, self1)) |  | 30949 | if (!pyopencv_VideoWriter_getp(self, self1))
| 30998 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)"); |  | 30950 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)");
| 30999 | Ptr<cv::VideoWriter> _self_ = *(self1); |  | 30951 | Ptr<cv::VideoWriter> _self_ = *(self1);
| 31000 | bool retval; |  | 30952 | bool retval;
| 31001 |  |  | 30953 |
| 31002 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 30954 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 31003 | { |  | 30955 | {
| 31004 | ERRWRAP2(retval = _self_->isOpened()); |  | 30956 | ERRWRAP2(retval = _self_->isOpened());
| 31005 | return pyopencv_from(retval); |  | 30957 | return pyopencv_from(retval);
| 31006 | } |  | 30958 | }
| 31007 |  |  | 30959 |
| 31008 | return NULL; |  | 30960 | return NULL;
| 31009 | } |  | 30961 | }
| 31010 |  |  | 30962 |
| 31011 | static PyObject* pyopencv_cv_VideoWriter_open(PyObject* self, PyObject* py_args, PyObject* kw) |  | 30963 | static PyObject* pyopencv_cv_VideoWriter_open(PyObject* self, PyObject* py_args, PyObject* kw)
| 31012 | { |  | 30964 | {
| 31013 | using namespace cv; |  | 30965 | using namespace cv;
| 31014 |  |  | 30966 |
| 31015 |  |  | 30967 |
| 31016 | Ptr<cv::VideoWriter> * self1 = 0; |  | 30968 | Ptr<cv::VideoWriter> * self1 = 0;
| 31017 | if (!pyopencv_VideoWriter_getp(self, self1)) |  | 30969 | if (!pyopencv_VideoWriter_getp(self, self1))
| 31018 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)"); |  | 30970 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)");
| 31019 | Ptr<cv::VideoWriter> _self_ = *(self1); |  | 30971 | Ptr<cv::VideoWriter> _self_ = *(self1);
| 31020 | pyPrepareArgumentConversionErrorsStorage(4); |  | 30972 | pyPrepareArgumentConversionErrorsStorage(4);
| 31021 |  |  | 30973 |
| 31022 | { |  | 30974 | {
| 31023 | PyObject* pyobj_filename = NULL; |  | 30975 | PyObject* pyobj_filename = NULL;
| 31024 | String filename; |  | 30976 | String filename;
| 31025 | PyObject* pyobj_fourcc = NULL; |  | 30977 | PyObject* pyobj_fourcc = NULL;
| 31026 | int fourcc=0; |  | 30978 | int fourcc=0;
| 31027 | PyObject* pyobj_fps = NULL; |  | 30979 | PyObject* pyobj_fps = NULL;
| 31028 | double fps=0; |  | 30980 | double fps=0;
| 31029 | PyObject* pyobj_frameSize = NULL; |  | 30981 | PyObject* pyobj_frameSize = NULL;
| 31030 | Size frameSize; |  | 30982 | Size frameSize;
| 31031 | PyObject* pyobj_isColor = NULL; |  | 30983 | PyObject* pyobj_isColor = NULL;
| 31032 | bool isColor=true; |  | 30984 | bool isColor=true;
| 31033 | bool retval; |  | 30985 | bool retval;
| 31034 |  |  | 30986 |
| 31035 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "isColor", NULL }; |  | 30987 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "isColor", NULL };
| 31036 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) && |  | 30988 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) &&
| 31037 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 30989 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 31038 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 30990 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 31039 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 30991 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 31040 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 30992 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 31041 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) ) |  | 30993 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) )
| 31042 | { |  | 30994 | {
| 31043 | ERRWRAP2(retval = _self_->open(filename, fourcc, fps, frameSize, isColor)); |  | 30995 | ERRWRAP2(retval = _self_->open(filename, fourcc, fps, frameSize, isColor));
| 31044 | return pyopencv_from(retval); |  | 30996 | return pyopencv_from(retval);
| 31045 | } |  | 30997 | }
| 31046 |  |  | 30998 |
| 31047 |  |  | 30999 |
| 31048 | pyPopulateArgumentConversionErrors(); |  | 31000 | pyPopulateArgumentConversionErrors();
| 31049 | } |  | 31001 | }
| 31050 |  |  | 31002 |
| 31051 |  |  | 31003 |
| 31052 | { |  | 31004 | {
| 31053 | PyObject* pyobj_filename = NULL; |  | 31005 | PyObject* pyobj_filename = NULL;
| 31054 | String filename; |  | 31006 | String filename;
| 31055 | PyObject* pyobj_apiPreference = NULL; |  | 31007 | PyObject* pyobj_apiPreference = NULL;
| 31056 | int apiPreference=0; |  | 31008 | int apiPreference=0;
| 31057 | PyObject* pyobj_fourcc = NULL; |  | 31009 | PyObject* pyobj_fourcc = NULL;
| 31058 | int fourcc=0; |  | 31010 | int fourcc=0;
| 31059 | PyObject* pyobj_fps = NULL; |  | 31011 | PyObject* pyobj_fps = NULL;
| 31060 | double fps=0; |  | 31012 | double fps=0;
| 31061 | PyObject* pyobj_frameSize = NULL; |  | 31013 | PyObject* pyobj_frameSize = NULL;
| 31062 | Size frameSize; |  | 31014 | Size frameSize;
| 31063 | PyObject* pyobj_isColor = NULL; |  | 31015 | PyObject* pyobj_isColor = NULL;
| 31064 | bool isColor=true; |  | 31016 | bool isColor=true;
| 31065 | bool retval; |  | 31017 | bool retval;
| 31066 |  |  | 31018 |
| 31067 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "isColor", NULL }; |  | 31019 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "isColor", NULL };
| 31068 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) && |  | 31020 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|O:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_isColor) &&
| 31069 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 31021 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 31070 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 31022 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 31071 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 31023 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 31072 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 31024 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 31073 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 31025 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 31074 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) ) |  | 31026 | pyopencv_to_safe(pyobj_isColor, isColor, ArgInfo("isColor", 0)) )
| 31075 | { |  | 31027 | {
| 31076 | ERRWRAP2(retval = _self_->open(filename, apiPreference, fourcc, fps, frameSize, isColor)); |  | 31028 | ERRWRAP2(retval = _self_->open(filename, apiPreference, fourcc, fps, frameSize, isColor));
| 31077 | return pyopencv_from(retval); |  | 31029 | return pyopencv_from(retval);
| 31078 | } |  | 31030 | }
| 31079 |  |  | 31031 |
| 31080 |  |  | 31032 |
| 31081 | pyPopulateArgumentConversionErrors(); |  | 31033 | pyPopulateArgumentConversionErrors();
| 31082 | } |  | 31034 | }
| 31083 |  |  | 31035 |
| 31084 |  |  | 31036 |
| 31085 | { |  | 31037 | {
| 31086 | PyObject* pyobj_filename = NULL; |  | 31038 | PyObject* pyobj_filename = NULL;
| 31087 | String filename; |  | 31039 | String filename;
| 31088 | PyObject* pyobj_fourcc = NULL; |  | 31040 | PyObject* pyobj_fourcc = NULL;
| 31089 | int fourcc=0; |  | 31041 | int fourcc=0;
| 31090 | PyObject* pyobj_fps = NULL; |  | 31042 | PyObject* pyobj_fps = NULL;
| 31091 | double fps=0; |  | 31043 | double fps=0;
| 31092 | PyObject* pyobj_frameSize = NULL; |  | 31044 | PyObject* pyobj_frameSize = NULL;
| 31093 | Size frameSize; |  | 31045 | Size frameSize;
| 31094 | PyObject* pyobj_params = NULL; |  | 31046 | PyObject* pyobj_params = NULL;
| 31095 | vector_int params; |  | 31047 | vector_int params;
| 31096 | bool retval; |  | 31048 | bool retval;
| 31097 |  |  | 31049 |
| 31098 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "params", NULL }; |  | 31050 | const char* keywords[] = { "filename", "fourcc", "fps", "frameSize", "params", NULL };
| 31099 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) && |  | 31051 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) &&
| 31100 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 31052 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 31101 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 31053 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 31102 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 31054 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 31103 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 31055 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 31104 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 31056 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 31105 | { |  | 31057 | {
| 31106 | ERRWRAP2(retval = _self_->open(filename, fourcc, fps, frameSize, params)); |  | 31058 | ERRWRAP2(retval = _self_->open(filename, fourcc, fps, frameSize, params));
| 31107 | return pyopencv_from(retval); |  | 31059 | return pyopencv_from(retval);
| 31108 | } |  | 31060 | }
| 31109 |  |  | 31061 |
| 31110 |  |  | 31062 |
| 31111 | pyPopulateArgumentConversionErrors(); |  | 31063 | pyPopulateArgumentConversionErrors();
| 31112 | } |  | 31064 | }
| 31113 |  |  | 31065 |
| 31114 |  |  | 31066 |
| 31115 | { |  | 31067 | {
| 31116 | PyObject* pyobj_filename = NULL; |  | 31068 | PyObject* pyobj_filename = NULL;
| 31117 | String filename; |  | 31069 | String filename;
| 31118 | PyObject* pyobj_apiPreference = NULL; |  | 31070 | PyObject* pyobj_apiPreference = NULL;
| 31119 | int apiPreference=0; |  | 31071 | int apiPreference=0;
| 31120 | PyObject* pyobj_fourcc = NULL; |  | 31072 | PyObject* pyobj_fourcc = NULL;
| 31121 | int fourcc=0; |  | 31073 | int fourcc=0;
| 31122 | PyObject* pyobj_fps = NULL; |  | 31074 | PyObject* pyobj_fps = NULL;
| 31123 | double fps=0; |  | 31075 | double fps=0;
| 31124 | PyObject* pyobj_frameSize = NULL; |  | 31076 | PyObject* pyobj_frameSize = NULL;
| 31125 | Size frameSize; |  | 31077 | Size frameSize;
| 31126 | PyObject* pyobj_params = NULL; |  | 31078 | PyObject* pyobj_params = NULL;
| 31127 | vector_int params; |  | 31079 | vector_int params;
| 31128 | bool retval; |  | 31080 | bool retval;
| 31129 |  |  | 31081 |
| 31130 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "params", NULL }; |  | 31082 | const char* keywords[] = { "filename", "apiPreference", "fourcc", "fps", "frameSize", "params", NULL };
| 31131 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) && |  | 31083 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:VideoWriter.open", (char**)keywords, &pyobj_filename, &pyobj_apiPreference, &pyobj_fourcc, &pyobj_fps, &pyobj_frameSize, &pyobj_params) &&
| 31132 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 31084 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 31133 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) && |  | 31085 | pyopencv_to_safe(pyobj_apiPreference, apiPreference, ArgInfo("apiPreference", 0)) &&
| 31134 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) && |  | 31086 | pyopencv_to_safe(pyobj_fourcc, fourcc, ArgInfo("fourcc", 0)) &&
| 31135 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) && |  | 31087 | pyopencv_to_safe(pyobj_fps, fps, ArgInfo("fps", 0)) &&
| 31136 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) && |  | 31088 | pyopencv_to_safe(pyobj_frameSize, frameSize, ArgInfo("frameSize", 0)) &&
| 31137 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 31089 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 31138 | { |  | 31090 | {
| 31139 | ERRWRAP2(retval = _self_->open(filename, apiPreference, fourcc, fps, frameSize, params)); |  | 31091 | ERRWRAP2(retval = _self_->open(filename, apiPreference, fourcc, fps, frameSize, params));
| 31140 | return pyopencv_from(retval); |  | 31092 | return pyopencv_from(retval);
| 31141 | } |  | 31093 | }
| 31142 |  |  | 31094 |
| 31143 |  |  | 31095 |
| 31144 | pyPopulateArgumentConversionErrors(); |  | 31096 | pyPopulateArgumentConversionErrors();
| 31145 | } |  | 31097 | }
| 31146 | pyRaiseCVOverloadException("open"); |  | 31098 | pyRaiseCVOverloadException("open");
| 31147 |  |  | 31099 |
| 31148 | return NULL; |  | 31100 | return NULL;
| 31149 | } |  | 31101 | }
| 31150 |  |  | 31102 |
| 31151 | static PyObject* pyopencv_cv_VideoWriter_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31103 | static PyObject* pyopencv_cv_VideoWriter_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 31152 | { |  | 31104 | {
| 31153 | using namespace cv; |  | 31105 | using namespace cv;
| 31154 |  |  | 31106 |
| 31155 |  |  | 31107 |
| 31156 | Ptr<cv::VideoWriter> * self1 = 0; |  | 31108 | Ptr<cv::VideoWriter> * self1 = 0;
| 31157 | if (!pyopencv_VideoWriter_getp(self, self1)) |  | 31109 | if (!pyopencv_VideoWriter_getp(self, self1))
| 31158 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)"); |  | 31110 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)");
| 31159 | Ptr<cv::VideoWriter> _self_ = *(self1); |  | 31111 | Ptr<cv::VideoWriter> _self_ = *(self1);
| 31160 |  |  | 31112 |
| 31161 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 31113 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 31162 | { |  | 31114 | {
| 31163 | ERRWRAP2(_self_->release()); |  | 31115 | ERRWRAP2(_self_->release());
| 31164 | Py_RETURN_NONE; |  | 31116 | Py_RETURN_NONE;
| 31165 | } |  | 31117 | }
| 31166 |  |  | 31118 |
| 31167 | return NULL; |  | 31119 | return NULL;
| 31168 | } |  | 31120 | }
| 31169 |  |  | 31121 |
| 31170 | static PyObject* pyopencv_cv_VideoWriter_set(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31122 | static PyObject* pyopencv_cv_VideoWriter_set(PyObject* self, PyObject* py_args, PyObject* kw)
| 31171 | { |  | 31123 | {
| 31172 | using namespace cv; |  | 31124 | using namespace cv;
| 31173 |  |  | 31125 |
| 31174 |  |  | 31126 |
| 31175 | Ptr<cv::VideoWriter> * self1 = 0; |  | 31127 | Ptr<cv::VideoWriter> * self1 = 0;
| 31176 | if (!pyopencv_VideoWriter_getp(self, self1)) |  | 31128 | if (!pyopencv_VideoWriter_getp(self, self1))
| 31177 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)"); |  | 31129 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)");
| 31178 | Ptr<cv::VideoWriter> _self_ = *(self1); |  | 31130 | Ptr<cv::VideoWriter> _self_ = *(self1);
| 31179 | PyObject* pyobj_propId = NULL; |  | 31131 | PyObject* pyobj_propId = NULL;
| 31180 | int propId=0; |  | 31132 | int propId=0;
| 31181 | PyObject* pyobj_value = NULL; |  | 31133 | PyObject* pyobj_value = NULL;
| 31182 | double value=0; |  | 31134 | double value=0;
| 31183 | bool retval; |  | 31135 | bool retval;
| 31184 |  |  | 31136 |
| 31185 | const char* keywords[] = { "propId", "value", NULL }; |  | 31137 | const char* keywords[] = { "propId", "value", NULL };
| 31186 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:VideoWriter.set", (char**)keywords, &pyobj_propId, &pyobj_value) && |  | 31138 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:VideoWriter.set", (char**)keywords, &pyobj_propId, &pyobj_value) &&
| 31187 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) && |  | 31139 | pyopencv_to_safe(pyobj_propId, propId, ArgInfo("propId", 0)) &&
| 31188 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 31140 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 31189 | { |  | 31141 | {
| 31190 | ERRWRAP2(retval = _self_->set(propId, value)); |  | 31142 | ERRWRAP2(retval = _self_->set(propId, value));
| 31191 | return pyopencv_from(retval); |  | 31143 | return pyopencv_from(retval);
| 31192 | } |  | 31144 | }
| 31193 |  |  | 31145 |
| 31194 | return NULL; |  | 31146 | return NULL;
| 31195 | } |  | 31147 | }
| 31196 |  |  | 31148 |
| 31197 | static PyObject* pyopencv_cv_VideoWriter_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31149 | static PyObject* pyopencv_cv_VideoWriter_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 31198 | { |  | 31150 | {
| 31199 | using namespace cv; |  | 31151 | using namespace cv;
| 31200 |  |  | 31152 |
| 31201 |  |  | 31153 |
| 31202 | Ptr<cv::VideoWriter> * self1 = 0; |  | 31154 | Ptr<cv::VideoWriter> * self1 = 0;
| 31203 | if (!pyopencv_VideoWriter_getp(self, self1)) |  | 31155 | if (!pyopencv_VideoWriter_getp(self, self1))
| 31204 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)"); |  | 31156 | return failmsgp("Incorrect type of self (must be 'VideoWriter' or its derivative)");
| 31205 | Ptr<cv::VideoWriter> _self_ = *(self1); |  | 31157 | Ptr<cv::VideoWriter> _self_ = *(self1);
| 31206 | pyPrepareArgumentConversionErrorsStorage(2); |  | 31158 | pyPrepareArgumentConversionErrorsStorage(2);
| 31207 |  |  | 31159 |
| 31208 | { |  | 31160 | {
| 31209 | PyObject* pyobj_image = NULL; |  | 31161 | PyObject* pyobj_image = NULL;
| 31210 | Mat image; |  | 31162 | Mat image;
| 31211 |  |  | 31163 |
| 31212 | const char* keywords[] = { "image", NULL }; |  | 31164 | const char* keywords[] = { "image", NULL };
| 31213 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoWriter.write", (char**)keywords, &pyobj_image) && |  | 31165 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoWriter.write", (char**)keywords, &pyobj_image) &&
| 31214 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 31166 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 31215 | { |  | 31167 | {
| 31216 | ERRWRAP2(_self_->write(image)); |  | 31168 | ERRWRAP2(_self_->write(image));
| 31217 | Py_RETURN_NONE; |  | 31169 | Py_RETURN_NONE;
| 31218 | } |  | 31170 | }
| 31219 |  |  | 31171 |
| 31220 |  |  | 31172 |
| 31221 | pyPopulateArgumentConversionErrors(); |  | 31173 | pyPopulateArgumentConversionErrors();
| 31222 | } |  | 31174 | }
| 31223 |  |  | 31175 |
| 31224 |  |  | 31176 |
| 31225 | { |  | 31177 | {
| 31226 | PyObject* pyobj_image = NULL; |  | 31178 | PyObject* pyobj_image = NULL;
| 31227 | UMat image; |  | 31179 | UMat image;
| 31228 |  |  | 31180 |
| 31229 | const char* keywords[] = { "image", NULL }; |  | 31181 | const char* keywords[] = { "image", NULL };
| 31230 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoWriter.write", (char**)keywords, &pyobj_image) && |  | 31182 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:VideoWriter.write", (char**)keywords, &pyobj_image) &&
| 31231 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 31183 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 31232 | { |  | 31184 | {
| 31233 | ERRWRAP2(_self_->write(image)); |  | 31185 | ERRWRAP2(_self_->write(image));
| 31234 | Py_RETURN_NONE; |  | 31186 | Py_RETURN_NONE;
| 31235 | } |  | 31187 | }
| 31236 |  |  | 31188 |
| 31237 |  |  | 31189 |
| 31238 | pyPopulateArgumentConversionErrors(); |  | 31190 | pyPopulateArgumentConversionErrors();
| 31239 | } |  | 31191 | }
| 31240 | pyRaiseCVOverloadException("write"); |  | 31192 | pyRaiseCVOverloadException("write");
| 31241 |  |  | 31193 |
| 31242 | return NULL; |  | 31194 | return NULL;
| 31243 | } |  | 31195 | }
| 31244 |  |  | 31196 |
| 31245 |  |  | 31197 |
| 31246 |  |  | 31198 |
| 31247 | // Tables (VideoWriter) |  | 31199 | // Tables (VideoWriter)
| 31248 |  |  | 31200 |
| 31249 | static PyGetSetDef pyopencv_VideoWriter_getseters[] = |  | 31201 | static PyGetSetDef pyopencv_VideoWriter_getseters[] =
| 31250 | { |  | 31202 | {
| 31251 | {NULL} /* Sentinel */ |  | 31203 | {NULL} /* Sentinel */
| 31252 | }; |  | 31204 | };
| 31253 |  |  | 31205 |
| 31254 | static PyMethodDef pyopencv_VideoWriter_methods[] = |  | 31206 | static PyMethodDef pyopencv_VideoWriter_methods[] =
| 31255 | { |  | 31207 | {
| 31256 | {"fourcc", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_fourcc_static, METH_STATIC), "fourcc(c1, c2, c3, c4) -> retval\n. @brief Concatenates 4 chars to a fourcc code\n. \n. @return a fourcc code\n. \n. This static method constructs the fourcc code of the codec to be used in the constructor\n. VideoWriter::VideoWriter or VideoWriter::open."}, |  | 31208 | {"fourcc", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_fourcc_static, METH_STATIC), "fourcc(c1, c2, c3, c4) -> retval\n. @brief Concatenates 4 chars to a fourcc code\n. \n. @return a fourcc code\n. \n. This static method constructs the fourcc code of the codec to be used in the constructor\n. VideoWriter::VideoWriter or VideoWriter::open."},
| 31257 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_get, 0), "get(propId) -> retval\n. @brief Returns the specified VideoWriter property\n. \n. @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)\n. or one of @ref videoio_flags_others\n. \n. @return Value for the specified property. Value 0 is returned when querying a property that is\n. not supported by the backend used by the VideoWriter instance."}, |  | 31209 | {"get", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_get, 0), "get(propId) -> retval\n. @brief Returns the specified VideoWriter property\n. \n. @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)\n. or one of @ref videoio_flags_others\n. \n. @return Value for the specified property. Value 0 is returned when querying a property that is\n. not supported by the backend used by the VideoWriter instance."},
| 31258 | {"getBackendName", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_getBackendName, 0), "getBackendName() -> retval\n. @brief Returns used backend API name\n. \n. @note Stream should be opened."}, |  | 31210 | {"getBackendName", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_getBackendName, 0), "getBackendName() -> retval\n. @brief Returns used backend API name\n. \n. @note Stream should be opened."},
| 31259 | {"isOpened", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_isOpened, 0), "isOpened() -> retval\n. @brief Returns true if video writer has been successfully initialized."}, |  | 31211 | {"isOpened", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_isOpened, 0), "isOpened() -> retval\n. @brief Returns true if video writer has been successfully initialized."},
| 31260 | {"open", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_open, 0), "open(filename, fourcc, fps, frameSize[, isColor]) -> retval\n. @brief Initializes or reinitializes video writer.\n. \n. The method opens video writer. Parameters are the same as in the constructor\n. VideoWriter::VideoWriter.\n. @return `true` if video writer has been successfully initialized\n. \n. The method first calls VideoWriter::release to close the already opened file.\n\n\n\nopen(filename, apiPreference, fourcc, fps, frameSize[, isColor]) -> retval\n. @overload\n\n\n\nopen(filename, fourcc, fps, frameSize, params) -> retval\n. @overload\n\n\n\nopen(filename, apiPreference, fourcc, fps, frameSize, params) -> retval\n. @overload"}, |  | 31212 | {"open", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_open, 0), "open(filename, fourcc, fps, frameSize[, isColor]) -> retval\n. @brief Initializes or reinitializes video writer.\n. \n. The method opens video writer. Parameters are the same as in the constructor\n. VideoWriter::VideoWriter.\n. @return `true` if video writer has been successfully initialized\n. \n. The method first calls VideoWriter::release to close the already opened file.\n\n\n\nopen(filename, apiPreference, fourcc, fps, frameSize[, isColor]) -> retval\n. @overload\n\n\n\nopen(filename, fourcc, fps, frameSize, params) -> retval\n. @overload\n\n\n\nopen(filename, apiPreference, fourcc, fps, frameSize, params) -> retval\n. @overload"},
| 31261 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_release, 0), "release() -> None\n. @brief Closes the video writer.\n. \n. The method is automatically called by subsequent VideoWriter::open and by the VideoWriter\n. destructor."}, |  | 31213 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_release, 0), "release() -> None\n. @brief Closes the video writer.\n. \n. The method is automatically called by subsequent VideoWriter::open and by the VideoWriter\n. destructor."},
| 31262 | {"set", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_set, 0), "set(propId, value) -> retval\n. @brief Sets a property in the VideoWriter.\n. \n. @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)\n. or one of @ref videoio_flags_others\n. \n. @param value Value of the property.\n. @return `true` if the property is supported by the backend used by the VideoWriter instance."}, |  | 31214 | {"set", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_set, 0), "set(propId, value) -> retval\n. @brief Sets a property in the VideoWriter.\n. \n. @param propId Property identifier from cv::VideoWriterProperties (eg. cv::VIDEOWRITER_PROP_QUALITY)\n. or one of @ref videoio_flags_others\n. \n. @param value Value of the property.\n. @return `true` if the property is supported by the backend used by the VideoWriter instance."},
| 31263 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_write, 0), "write(image) -> None\n. @brief Writes the next video frame\n. \n. @param image The written frame. In general, color images are expected in BGR format.\n. \n. The function/method writes the specified image to video file. It must have the same size as has\n. been specified when opening the video writer."}, |  | 31215 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_VideoWriter_write, 0), "write(image) -> None\n. @brief Writes the next video frame\n. \n. @param image The written frame. In general, color images are expected in BGR format.\n. \n. The function/method writes the specified image to video file. It must have the same size as has\n. been specified when opening the video writer."},
| 31264 |  |  | 31216 |
| 31265 | {NULL, NULL} |  | 31217 | {NULL, NULL}
| 31266 | }; |  | 31218 | };
| 31267 |  |  | 31219 |
| 31268 | // Converter (VideoWriter) |  | 31220 | // Converter (VideoWriter)
| 31269 |  |  | 31221 |
| 31270 | template<> |  | 31222 | template<>
| 31271 | struct PyOpenCV_Converter< Ptr<cv::VideoWriter> > |  | 31223 | struct PyOpenCV_Converter< Ptr<cv::VideoWriter> >
| 31272 | { |  | 31224 | {
| 31273 | static PyObject* from(const Ptr<cv::VideoWriter>& r) |  | 31225 | static PyObject* from(const Ptr<cv::VideoWriter>& r)
| 31274 | { |  | 31226 | {
| 31275 | return pyopencv_VideoWriter_Instance(r); |  | 31227 | return pyopencv_VideoWriter_Instance(r);
| 31276 | } |  | 31228 | }
| 31277 | static bool to(PyObject* src, Ptr<cv::VideoWriter>& dst, const ArgInfo& info) |  | 31229 | static bool to(PyObject* src, Ptr<cv::VideoWriter>& dst, const ArgInfo& info)
| 31278 | { |  | 31230 | {
| 31279 | if(!src || src == Py_None) |  | 31231 | if(!src || src == Py_None)
| 31280 | return true; |  | 31232 | return true;
| 31281 | Ptr<cv::VideoWriter> * dst_; |  | 31233 | Ptr<cv::VideoWriter> * dst_;
| 31282 | if (pyopencv_VideoWriter_getp(src, dst_)) |  | 31234 | if (pyopencv_VideoWriter_getp(src, dst_))
| 31283 | { |  | 31235 | {
| 31284 | dst = *dst_; |  | 31236 | dst = *dst_;
| 31285 | return true; |  | 31237 | return true;
| 31286 | } |  | 31238 | }
| 31287 |  |  | 31239 |
| 31288 | failmsg("Expected Ptr<cv::VideoWriter> for argument '%s'", info.name); |  | 31240 | failmsg("Expected Ptr<cv::VideoWriter> for argument '%s'", info.name);
| 31289 | return false; |  | 31241 | return false;
| 31290 | } |  | 31242 | }
| 31291 | }; |  | 31243 | };
| 31292 |  |  | 31244 |
| 31293 | //================================================================================ |  | 31245 | //================================================================================
| 31294 | // WarperCreator (Generic) |  | 31246 | // WarperCreator (Generic)
| 31295 | //================================================================================ |  | 31247 | //================================================================================
| 31296 |  |  | 31248 |
| 31297 | // GetSet (WarperCreator) |  | 31249 | // GetSet (WarperCreator)
| 31298 |  |  | 31250 |
| 31299 |  |  | 31251 |
| 31300 |  |  | 31252 |
| 31301 | // Methods (WarperCreator) |  | 31253 | // Methods (WarperCreator)
| 31302 |  |  | 31254 |
| 31303 |  |  | 31255 |
| 31304 |  |  | 31256 |
| 31305 | // Tables (WarperCreator) |  | 31257 | // Tables (WarperCreator)
| 31306 |  |  | 31258 |
| 31307 | static PyGetSetDef pyopencv_WarperCreator_getseters[] = |  | 31259 | static PyGetSetDef pyopencv_WarperCreator_getseters[] =
| 31308 | { |  | 31260 | {
| 31309 | {NULL} /* Sentinel */ |  | 31261 | {NULL} /* Sentinel */
| 31310 | }; |  | 31262 | };
| 31311 |  |  | 31263 |
| 31312 | static PyMethodDef pyopencv_WarperCreator_methods[] = |  | 31264 | static PyMethodDef pyopencv_WarperCreator_methods[] =
| 31313 | { |  | 31265 | {
| 31314 |  |  | 31266 |
| 31315 | {NULL, NULL} |  | 31267 | {NULL, NULL}
| 31316 | }; |  | 31268 | };
| 31317 |  |  | 31269 |
| 31318 | // Converter (WarperCreator) |  | 31270 | // Converter (WarperCreator)
| 31319 |  |  | 31271 |
| 31320 | template<> |  | 31272 | template<>
| 31321 | struct PyOpenCV_Converter< Ptr<cv::WarperCreator> > |  | 31273 | struct PyOpenCV_Converter< Ptr<cv::WarperCreator> >
| 31322 | { |  | 31274 | {
| 31323 | static PyObject* from(const Ptr<cv::WarperCreator>& r) |  | 31275 | static PyObject* from(const Ptr<cv::WarperCreator>& r)
| 31324 | { |  | 31276 | {
| 31325 | return pyopencv_WarperCreator_Instance(r); |  | 31277 | return pyopencv_WarperCreator_Instance(r);
| 31326 | } |  | 31278 | }
| 31327 | static bool to(PyObject* src, Ptr<cv::WarperCreator>& dst, const ArgInfo& info) |  | 31279 | static bool to(PyObject* src, Ptr<cv::WarperCreator>& dst, const ArgInfo& info)
| 31328 | { |  | 31280 | {
| 31329 | if(!src || src == Py_None) |  | 31281 | if(!src || src == Py_None)
| 31330 | return true; |  | 31282 | return true;
| 31331 | Ptr<cv::WarperCreator> * dst_; |  | 31283 | Ptr<cv::WarperCreator> * dst_;
| 31332 | if (pyopencv_WarperCreator_getp(src, dst_)) |  | 31284 | if (pyopencv_WarperCreator_getp(src, dst_))
| 31333 | { |  | 31285 | {
| 31334 | dst = *dst_; |  | 31286 | dst = *dst_;
| 31335 | return true; |  | 31287 | return true;
| 31336 | } |  | 31288 | }
| 31337 |  |  | 31289 |
| 31338 | failmsg("Expected Ptr<cv::WarperCreator> for argument '%s'", info.name); |  | 31290 | failmsg("Expected Ptr<cv::WarperCreator> for argument '%s'", info.name);
| 31339 | return false; |  | 31291 | return false;
| 31340 | } |  | 31292 | }
| 31341 | }; |  | 31293 | };
| 31342 |  |  | 31294 |
| 31343 | //================================================================================ |  | 31295 | //================================================================================
| 31344 | // aruco_ArucoDetector (Generic) |  | 31296 | // aruco_ArucoDetector (Generic)
| 31345 | //================================================================================ |  | 31297 | //================================================================================
| 31346 |  |  | 31298 |
| 31347 | // GetSet (aruco_ArucoDetector) |  | 31299 | // GetSet (aruco_ArucoDetector)
| 31348 |  |  | 31300 |
| 31349 |  |  | 31301 |
| 31350 |  |  | 31302 |
| 31351 | // Methods (aruco_ArucoDetector) |  | 31303 | // Methods (aruco_ArucoDetector)
| 31352 |  |  | 31304 |
| 31353 | static int pyopencv_cv_aruco_aruco_ArucoDetector_ArucoDetector(pyopencv_aruco_ArucoDetector_t* self, PyObject* py_args, PyObject* kw) |  | 31305 | static int pyopencv_cv_aruco_aruco_ArucoDetector_ArucoDetector(pyopencv_aruco_ArucoDetector_t* self, PyObject* py_args, PyObject* kw)
| 31354 | { |  | 31306 | {
| 31355 | using namespace cv::aruco; |  | 31307 | using namespace cv::aruco;
| 31356 |  |  | 31308 |
| 31357 | pyPrepareArgumentConversionErrorsStorage(2); |  | 31309 | pyPrepareArgumentConversionErrorsStorage(2);
| 31358 |  |  | 31310 |
| 31359 | { |  | 31311 | {
| 31360 | PyObject* pyobj_dictionary = NULL; |  | 31312 | PyObject* pyobj_dictionary = NULL;
| 31361 | Dictionary dictionary=getPredefinedDictionary(cv::aruco::DICT_4X4_50); |  | 31313 | Dictionary dictionary=getPredefinedDictionary(cv::aruco::DICT_4X4_50);
| 31362 | PyObject* pyobj_detectorParams = NULL; |  | 31314 | PyObject* pyobj_detectorParams = NULL;
| 31363 | DetectorParameters detectorParams; |  | 31315 | DetectorParameters detectorParams;
| 31364 | PyObject* pyobj_refineParams = NULL; |  | 31316 | PyObject* pyobj_refineParams = NULL;
| 31365 | RefineParameters refineParams; |  | 31317 | RefineParameters refineParams;
| 31366 |  |  | 31318 |
| 31367 | const char* keywords[] = { "dictionary", "detectorParams", "refineParams", NULL }; |  | 31319 | const char* keywords[] = { "dictionary", "detectorParams", "refineParams", NULL };
| 31368 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:ArucoDetector", (char**)keywords, &pyobj_dictionary, &pyobj_detectorParams, &pyobj_refineParams) && |  | 31320 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:ArucoDetector", (char**)keywords, &pyobj_dictionary, &pyobj_detectorParams, &pyobj_refineParams) &&
| 31369 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) && |  | 31321 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) &&
| 31370 | pyopencv_to_safe(pyobj_detectorParams, detectorParams, ArgInfo("detectorParams", 0)) && |  | 31322 | pyopencv_to_safe(pyobj_detectorParams, detectorParams, ArgInfo("detectorParams", 0)) &&
| 31371 | pyopencv_to_safe(pyobj_refineParams, refineParams, ArgInfo("refineParams", 0)) ) |  | 31323 | pyopencv_to_safe(pyobj_refineParams, refineParams, ArgInfo("refineParams", 0)) )
| 31372 | { |  | 31324 | {
| 31373 | new (&(self->v)) Ptr<cv::aruco::ArucoDetector>(); // init Ptr with placement new |  | 31325 | new (&(self->v)) Ptr<cv::aruco::ArucoDetector>(); // init Ptr with placement new
| 31374 | if(self) ERRWRAP2(self->v.reset(new cv::aruco::ArucoDetector(dictionary, detectorParams, refineParams))); |  | 31326 | if(self) ERRWRAP2(self->v.reset(new cv::aruco::ArucoDetector(dictionary, detectorParams, refineParams)));
| 31375 | return 0; |  | 31327 | return 0;
| 31376 | } |  | 31328 | }
| 31377 |  |  | 31329 |
| 31378 |  |  | 31330 |
| 31379 | pyPopulateArgumentConversionErrors(); |  | 31331 | pyPopulateArgumentConversionErrors();
| 31380 | } |  | 31332 | }
| 31381 |  |  | 31333 |
| 31382 |  |  | 31334 |
| 31383 | { |  | 31335 | {
| 31384 | PyObject* pyobj_dictionaries = NULL; |  | 31336 | PyObject* pyobj_dictionaries = NULL;
| 31385 | vector_Dictionary dictionaries; |  | 31337 | vector_Dictionary dictionaries;
| 31386 | PyObject* pyobj_detectorParams = NULL; |  | 31338 | PyObject* pyobj_detectorParams = NULL;
| 31387 | DetectorParameters detectorParams; |  | 31339 | DetectorParameters detectorParams;
| 31388 | PyObject* pyobj_refineParams = NULL; |  | 31340 | PyObject* pyobj_refineParams = NULL;
| 31389 | RefineParameters refineParams; |  | 31341 | RefineParameters refineParams;
| 31390 |  |  | 31342 |
| 31391 | const char* keywords[] = { "dictionaries", "detectorParams", "refineParams", NULL }; |  | 31343 | const char* keywords[] = { "dictionaries", "detectorParams", "refineParams", NULL };
| 31392 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ArucoDetector", (char**)keywords, &pyobj_dictionaries, &pyobj_detectorParams, &pyobj_refineParams) && |  | 31344 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ArucoDetector", (char**)keywords, &pyobj_dictionaries, &pyobj_detectorParams, &pyobj_refineParams) &&
| 31393 | pyopencv_to_safe(pyobj_dictionaries, dictionaries, ArgInfo("dictionaries", 0)) && |  | 31345 | pyopencv_to_safe(pyobj_dictionaries, dictionaries, ArgInfo("dictionaries", 0)) &&
| 31394 | pyopencv_to_safe(pyobj_detectorParams, detectorParams, ArgInfo("detectorParams", 0)) && |  | 31346 | pyopencv_to_safe(pyobj_detectorParams, detectorParams, ArgInfo("detectorParams", 0)) &&
| 31395 | pyopencv_to_safe(pyobj_refineParams, refineParams, ArgInfo("refineParams", 0)) ) |  | 31347 | pyopencv_to_safe(pyobj_refineParams, refineParams, ArgInfo("refineParams", 0)) )
| 31396 | { |  | 31348 | {
| 31397 | new (&(self->v)) Ptr<cv::aruco::ArucoDetector>(); // init Ptr with placement new |  | 31349 | new (&(self->v)) Ptr<cv::aruco::ArucoDetector>(); // init Ptr with placement new
| 31398 | if(self) ERRWRAP2(self->v.reset(new cv::aruco::ArucoDetector(dictionaries, detectorParams, refineParams))); |  | 31350 | if(self) ERRWRAP2(self->v.reset(new cv::aruco::ArucoDetector(dictionaries, detectorParams, refineParams)));
| 31399 | return 0; |  | 31351 | return 0;
| 31400 | } |  | 31352 | }
| 31401 |  |  | 31353 |
| 31402 |  |  | 31354 |
| 31403 | pyPopulateArgumentConversionErrors(); |  | 31355 | pyPopulateArgumentConversionErrors();
| 31404 | } |  | 31356 | }
| 31405 | pyRaiseCVOverloadException("ArucoDetector"); |  | 31357 | pyRaiseCVOverloadException("ArucoDetector");
| 31406 |  |  | 31358 |
| 31407 | return -1; |  | 31359 | return -1;
| 31408 | } |  | 31360 | }
| 31409 |  |  | 31361 |
| 31410 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31362 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkers(PyObject* self, PyObject* py_args, PyObject* kw)
| 31411 | { |  | 31363 | {
| 31412 | using namespace cv::aruco; |  | 31364 | using namespace cv::aruco;
| 31413 |  |  | 31365 |
| 31414 |  |  | 31366 |
| 31415 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31367 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31416 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31368 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31417 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31369 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31418 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31370 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31419 | pyPrepareArgumentConversionErrorsStorage(2); |  | 31371 | pyPrepareArgumentConversionErrorsStorage(2);
| 31420 |  |  | 31372 |
| 31421 | { |  | 31373 | {
| 31422 | PyObject* pyobj_image = NULL; |  | 31374 | PyObject* pyobj_image = NULL;
| 31423 | Mat image; |  | 31375 | Mat image;
| 31424 | PyObject* pyobj_corners = NULL; |  | 31376 | PyObject* pyobj_corners = NULL;
| 31425 | vector_Mat corners; |  | 31377 | vector_Mat corners;
| 31426 | PyObject* pyobj_ids = NULL; |  | 31378 | PyObject* pyobj_ids = NULL;
| 31427 | Mat ids; |  | 31379 | Mat ids;
| 31428 | PyObject* pyobj_rejectedImgPoints = NULL; |  | 31380 | PyObject* pyobj_rejectedImgPoints = NULL;
| 31429 | vector_Mat rejectedImgPoints; |  | 31381 | vector_Mat rejectedImgPoints;
| 31430 |  |  | 31382 |
| 31431 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", NULL }; |  | 31383 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", NULL };
| 31432 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_ArucoDetector.detectMarkers", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints) && |  | 31384 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_ArucoDetector.detectMarkers", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints) &&
| 31433 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 31385 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 31434 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) && |  | 31386 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) &&
| 31435 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) && |  | 31387 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) &&
| 31436 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) ) |  | 31388 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) )
| 31437 | { |  | 31389 | {
| 31438 | ERRWRAP2(_self_->detectMarkers(image, corners, ids, rejectedImgPoints)); |  | 31390 | ERRWRAP2(_self_->detectMarkers(image, corners, ids, rejectedImgPoints));
| 31439 | return Py_BuildValue("(NNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints)); |  | 31391 | return Py_BuildValue("(NNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints));
| 31440 | } |  | 31392 | }
| 31441 |  |  | 31393 |
| 31442 |  |  | 31394 |
| 31443 | pyPopulateArgumentConversionErrors(); |  | 31395 | pyPopulateArgumentConversionErrors();
| 31444 | } |  | 31396 | }
| 31445 |  |  | 31397 |
| 31446 |  |  | 31398 |
| 31447 | { |  | 31399 | {
| 31448 | PyObject* pyobj_image = NULL; |  | 31400 | PyObject* pyobj_image = NULL;
| 31449 | UMat image; |  | 31401 | UMat image;
| 31450 | PyObject* pyobj_corners = NULL; |  | 31402 | PyObject* pyobj_corners = NULL;
| 31451 | vector_UMat corners; |  | 31403 | vector_UMat corners;
| 31452 | PyObject* pyobj_ids = NULL; |  | 31404 | PyObject* pyobj_ids = NULL;
| 31453 | UMat ids; |  | 31405 | UMat ids;
| 31454 | PyObject* pyobj_rejectedImgPoints = NULL; |  | 31406 | PyObject* pyobj_rejectedImgPoints = NULL;
| 31455 | vector_UMat rejectedImgPoints; |  | 31407 | vector_UMat rejectedImgPoints;
| 31456 |  |  | 31408 |
| 31457 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", NULL }; |  | 31409 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", NULL };
| 31458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_ArucoDetector.detectMarkers", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints) && |  | 31410 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_ArucoDetector.detectMarkers", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints) &&
| 31459 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 31411 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 31460 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) && |  | 31412 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) &&
| 31461 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) && |  | 31413 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) &&
| 31462 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) ) |  | 31414 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) )
| 31463 | { |  | 31415 | {
| 31464 | ERRWRAP2(_self_->detectMarkers(image, corners, ids, rejectedImgPoints)); |  | 31416 | ERRWRAP2(_self_->detectMarkers(image, corners, ids, rejectedImgPoints));
| 31465 | return Py_BuildValue("(NNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints)); |  | 31417 | return Py_BuildValue("(NNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints));
| 31466 | } |  | 31418 | }
| 31467 |  |  | 31419 |
| 31468 |  |  | 31420 |
| 31469 | pyPopulateArgumentConversionErrors(); |  | 31421 | pyPopulateArgumentConversionErrors();
| 31470 | } |  | 31422 | }
| 31471 | pyRaiseCVOverloadException("detectMarkers"); |  | 31423 | pyRaiseCVOverloadException("detectMarkers");
| 31472 |  |  | 31424 |
| 31473 | return NULL; |  | 31425 | return NULL;
| 31474 | } |  | 31426 | }
| 31475 |  |  | 31427 |
| 31476 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkersMultiDict(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31428 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkersMultiDict(PyObject* self, PyObject* py_args, PyObject* kw)
| 31477 | { |  | 31429 | {
| 31478 | using namespace cv::aruco; |  | 31430 | using namespace cv::aruco;
| 31479 |  |  | 31431 |
| 31480 |  |  | 31432 |
| 31481 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31433 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31482 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31434 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31483 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31435 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31484 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31436 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31485 | pyPrepareArgumentConversionErrorsStorage(2); |  | 31437 | pyPrepareArgumentConversionErrorsStorage(2);
| 31486 |  |  | 31438 |
| 31487 | { |  | 31439 | {
| 31488 | PyObject* pyobj_image = NULL; |  | 31440 | PyObject* pyobj_image = NULL;
| 31489 | Mat image; |  | 31441 | Mat image;
| 31490 | PyObject* pyobj_corners = NULL; |  | 31442 | PyObject* pyobj_corners = NULL;
| 31491 | vector_Mat corners; |  | 31443 | vector_Mat corners;
| 31492 | PyObject* pyobj_ids = NULL; |  | 31444 | PyObject* pyobj_ids = NULL;
| 31493 | Mat ids; |  | 31445 | Mat ids;
| 31494 | PyObject* pyobj_rejectedImgPoints = NULL; |  | 31446 | PyObject* pyobj_rejectedImgPoints = NULL;
| 31495 | vector_Mat rejectedImgPoints; |  | 31447 | vector_Mat rejectedImgPoints;
| 31496 | PyObject* pyobj_dictIndices = NULL; |  | 31448 | PyObject* pyobj_dictIndices = NULL;
| 31497 | Mat dictIndices; |  | 31449 | Mat dictIndices;
| 31498 |  |  | 31450 |
| 31499 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", "dictIndices", NULL }; |  | 31451 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", "dictIndices", NULL };
| 31500 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_ArucoDetector.detectMarkersMultiDict", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints, &pyobj_dictIndices) && |  | 31452 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_ArucoDetector.detectMarkersMultiDict", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints, &pyobj_dictIndices) &&
| 31501 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 31453 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 31502 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) && |  | 31454 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) &&
| 31503 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) && |  | 31455 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) &&
| 31504 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) && |  | 31456 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) &&
| 31505 | pyopencv_to_safe(pyobj_dictIndices, dictIndices, ArgInfo("dictIndices", 1)) ) |  | 31457 | pyopencv_to_safe(pyobj_dictIndices, dictIndices, ArgInfo("dictIndices", 1)) )
| 31506 | { |  | 31458 | {
| 31507 | ERRWRAP2(_self_->detectMarkersMultiDict(image, corners, ids, rejectedImgPoints, dictIndices)); |  | 31459 | ERRWRAP2(_self_->detectMarkersMultiDict(image, corners, ids, rejectedImgPoints, dictIndices));
| 31508 | return Py_BuildValue("(NNNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints), pyopencv_from(dictIndices)); |  | 31460 | return Py_BuildValue("(NNNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints), pyopencv_from(dictIndices));
| 31509 | } |  | 31461 | }
| 31510 |  |  | 31462 |
| 31511 |  |  | 31463 |
| 31512 | pyPopulateArgumentConversionErrors(); |  | 31464 | pyPopulateArgumentConversionErrors();
| 31513 | } |  | 31465 | }
| 31514 |  |  | 31466 |
| 31515 |  |  | 31467 |
| 31516 | { |  | 31468 | {
| 31517 | PyObject* pyobj_image = NULL; |  | 31469 | PyObject* pyobj_image = NULL;
| 31518 | UMat image; |  | 31470 | UMat image;
| 31519 | PyObject* pyobj_corners = NULL; |  | 31471 | PyObject* pyobj_corners = NULL;
| 31520 | vector_UMat corners; |  | 31472 | vector_UMat corners;
| 31521 | PyObject* pyobj_ids = NULL; |  | 31473 | PyObject* pyobj_ids = NULL;
| 31522 | UMat ids; |  | 31474 | UMat ids;
| 31523 | PyObject* pyobj_rejectedImgPoints = NULL; |  | 31475 | PyObject* pyobj_rejectedImgPoints = NULL;
| 31524 | vector_UMat rejectedImgPoints; |  | 31476 | vector_UMat rejectedImgPoints;
| 31525 | PyObject* pyobj_dictIndices = NULL; |  | 31477 | PyObject* pyobj_dictIndices = NULL;
| 31526 | UMat dictIndices; |  | 31478 | UMat dictIndices;
| 31527 |  |  | 31479 |
| 31528 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", "dictIndices", NULL }; |  | 31480 | const char* keywords[] = { "image", "corners", "ids", "rejectedImgPoints", "dictIndices", NULL };
| 31529 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_ArucoDetector.detectMarkersMultiDict", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints, &pyobj_dictIndices) && |  | 31481 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_ArucoDetector.detectMarkersMultiDict", (char**)keywords, &pyobj_image, &pyobj_corners, &pyobj_ids, &pyobj_rejectedImgPoints, &pyobj_dictIndices) &&
| 31530 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 31482 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 31531 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) && |  | 31483 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 1)) &&
| 31532 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) && |  | 31484 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 1)) &&
| 31533 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) && |  | 31485 | pyopencv_to_safe(pyobj_rejectedImgPoints, rejectedImgPoints, ArgInfo("rejectedImgPoints", 1)) &&
| 31534 | pyopencv_to_safe(pyobj_dictIndices, dictIndices, ArgInfo("dictIndices", 1)) ) |  | 31486 | pyopencv_to_safe(pyobj_dictIndices, dictIndices, ArgInfo("dictIndices", 1)) )
| 31535 | { |  | 31487 | {
| 31536 | ERRWRAP2(_self_->detectMarkersMultiDict(image, corners, ids, rejectedImgPoints, dictIndices)); |  | 31488 | ERRWRAP2(_self_->detectMarkersMultiDict(image, corners, ids, rejectedImgPoints, dictIndices));
| 31537 | return Py_BuildValue("(NNNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints), pyopencv_from(dictIndices)); |  | 31489 | return Py_BuildValue("(NNNN)", pyopencv_from(corners), pyopencv_from(ids), pyopencv_from(rejectedImgPoints), pyopencv_from(dictIndices));
| 31538 | } |  | 31490 | }
| 31539 |  |  | 31491 |
| 31540 |  |  | 31492 |
| 31541 | pyPopulateArgumentConversionErrors(); |  | 31493 | pyPopulateArgumentConversionErrors();
| 31542 | } |  | 31494 | }
| 31543 | pyRaiseCVOverloadException("detectMarkersMultiDict"); |  | 31495 | pyRaiseCVOverloadException("detectMarkersMultiDict");
| 31544 |  |  | 31496 |
| 31545 | return NULL; |  | 31497 | return NULL;
| 31546 | } |  | 31498 | }
| 31547 |  |  | 31499 |
| 31548 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31500 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 31549 | { |  | 31501 | {
| 31550 | using namespace cv::aruco; |  | 31502 | using namespace cv::aruco;
| 31551 |  |  | 31503 |
| 31552 |  |  | 31504 |
| 31553 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31505 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31554 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31506 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31555 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31507 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31556 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31508 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31557 | DetectorParameters retval; |  | 31509 | DetectorParameters retval;
| 31558 |  |  | 31510 |
| 31559 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 31511 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 31560 | { |  | 31512 | {
| 31561 | ERRWRAP2(retval = _self_->getDetectorParameters()); |  | 31513 | ERRWRAP2(retval = _self_->getDetectorParameters());
| 31562 | return pyopencv_from(retval); |  | 31514 | return pyopencv_from(retval);
| 31563 | } |  | 31515 | }
| 31564 |  |  | 31516 |
| 31565 | return NULL; |  | 31517 | return NULL;
| 31566 | } |  | 31518 | }
| 31567 |  |  | 31519 |
| 31568 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getDictionaries(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31520 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getDictionaries(PyObject* self, PyObject* py_args, PyObject* kw)
| 31569 | { |  | 31521 | {
| 31570 | using namespace cv::aruco; |  | 31522 | using namespace cv::aruco;
| 31571 |  |  | 31523 |
| 31572 |  |  | 31524 |
| 31573 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31525 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31574 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31526 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31575 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31527 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31576 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31528 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31577 | std::vector<Dictionary> retval; |  | 31529 | std::vector<Dictionary> retval;
| 31578 |  |  | 31530 |
| 31579 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 31531 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 31580 | { |  | 31532 | {
| 31581 | ERRWRAP2(retval = _self_->getDictionaries()); |  | 31533 | ERRWRAP2(retval = _self_->getDictionaries());
| 31582 | return pyopencv_from(retval); |  | 31534 | return pyopencv_from(retval);
| 31583 | } |  | 31535 | }
| 31584 |  |  | 31536 |
| 31585 | return NULL; |  | 31537 | return NULL;
| 31586 | } |  | 31538 | }
| 31587 |  |  | 31539 |
| 31588 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getDictionary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31540 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getDictionary(PyObject* self, PyObject* py_args, PyObject* kw)
| 31589 | { |  | 31541 | {
| 31590 | using namespace cv::aruco; |  | 31542 | using namespace cv::aruco;
| 31591 |  |  | 31543 |
| 31592 |  |  | 31544 |
| 31593 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31545 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31594 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31546 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31595 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31547 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31596 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31548 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31597 | Dictionary retval; |  | 31549 | Dictionary retval;
| 31598 |  |  | 31550 |
| 31599 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 31551 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 31600 | { |  | 31552 | {
| 31601 | ERRWRAP2(retval = _self_->getDictionary()); |  | 31553 | ERRWRAP2(retval = _self_->getDictionary());
| 31602 | return pyopencv_from(retval); |  | 31554 | return pyopencv_from(retval);
| 31603 | } |  | 31555 | }
| 31604 |  |  | 31556 |
| 31605 | return NULL; |  | 31557 | return NULL;
| 31606 | } |  | 31558 | }
| 31607 |  |  | 31559 |
| 31608 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31560 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_getRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 31609 | { |  | 31561 | {
| 31610 | using namespace cv::aruco; |  | 31562 | using namespace cv::aruco;
| 31611 |  |  | 31563 |
| 31612 |  |  | 31564 |
| 31613 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31565 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31614 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31566 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31615 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31567 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31616 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31568 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31617 | RefineParameters retval; |  | 31569 | RefineParameters retval;
| 31618 |  |  | 31570 |
| 31619 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 31571 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 31620 | { |  | 31572 | {
| 31621 | ERRWRAP2(retval = _self_->getRefineParameters()); |  | 31573 | ERRWRAP2(retval = _self_->getRefineParameters());
| 31622 | return pyopencv_from(retval); |  | 31574 | return pyopencv_from(retval);
| 31623 | } |  | 31575 | }
| 31624 |  |  | 31576 |
| 31625 | return NULL; |  | 31577 | return NULL;
| 31626 | } |  | 31578 | }
| 31627 |  |  | 31579 |
| 31628 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31580 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 31629 | { |  | 31581 | {
| 31630 | using namespace cv::aruco; |  | 31582 | using namespace cv::aruco;
| 31631 |  |  | 31583 |
| 31632 |  |  | 31584 |
| 31633 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31585 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31634 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31586 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31635 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31587 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31636 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31588 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31637 | PyObject* pyobj_fn = NULL; |  | 31589 | PyObject* pyobj_fn = NULL;
| 31638 | cv::FileNode fn; |  | 31590 | cv::FileNode fn;
| 31639 |  |  | 31591 |
| 31640 | const char* keywords[] = { "fn", NULL }; |  | 31592 | const char* keywords[] = { "fn", NULL };
| 31641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.read", (char**)keywords, &pyobj_fn) && |  | 31593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.read", (char**)keywords, &pyobj_fn) &&
| 31642 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 31594 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 31643 | { |  | 31595 | {
| 31644 | ERRWRAP2(_self_->read(fn)); |  | 31596 | ERRWRAP2(_self_->read(fn));
| 31645 | Py_RETURN_NONE; |  | 31597 | Py_RETURN_NONE;
| 31646 | } |  | 31598 | }
| 31647 |  |  | 31599 |
| 31648 | return NULL; |  | 31600 | return NULL;
| 31649 | } |  | 31601 | }
| 31650 |  |  | 31602 |
| 31651 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_refineDetectedMarkers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31603 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_refineDetectedMarkers(PyObject* self, PyObject* py_args, PyObject* kw)
| 31652 | { |  | 31604 | {
| 31653 | using namespace cv::aruco; |  | 31605 | using namespace cv::aruco;
| 31654 |  |  | 31606 |
| 31655 |  |  | 31607 |
| 31656 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31608 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31657 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31609 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31658 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31610 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31659 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31611 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31660 | pyPrepareArgumentConversionErrorsStorage(2); |  | 31612 | pyPrepareArgumentConversionErrorsStorage(2);
| 31661 |  |  | 31613 |
| 31662 | { |  | 31614 | {
| 31663 | PyObject* pyobj_image = NULL; |  | 31615 | PyObject* pyobj_image = NULL;
| 31664 | Mat image; |  | 31616 | Mat image;
| 31665 | PyObject* pyobj_board = NULL; |  | 31617 | PyObject* pyobj_board = NULL;
| 31666 | Board board; |  | 31618 | Board board;
| 31667 | PyObject* pyobj_detectedCorners = NULL; |  | 31619 | PyObject* pyobj_detectedCorners = NULL;
| 31668 | vector_Mat detectedCorners; |  | 31620 | vector_Mat detectedCorners;
| 31669 | PyObject* pyobj_detectedIds = NULL; |  | 31621 | PyObject* pyobj_detectedIds = NULL;
| 31670 | Mat detectedIds; |  | 31622 | Mat detectedIds;
| 31671 | PyObject* pyobj_rejectedCorners = NULL; |  | 31623 | PyObject* pyobj_rejectedCorners = NULL;
| 31672 | vector_Mat rejectedCorners; |  | 31624 | vector_Mat rejectedCorners;
| 31673 | PyObject* pyobj_cameraMatrix = NULL; |  | 31625 | PyObject* pyobj_cameraMatrix = NULL;
| 31674 | Mat cameraMatrix; |  | 31626 | Mat cameraMatrix;
| 31675 | PyObject* pyobj_distCoeffs = NULL; |  | 31627 | PyObject* pyobj_distCoeffs = NULL;
| 31676 | Mat distCoeffs; |  | 31628 | Mat distCoeffs;
| 31677 | PyObject* pyobj_recoveredIdxs = NULL; |  | 31629 | PyObject* pyobj_recoveredIdxs = NULL;
| 31678 | Mat recoveredIdxs; |  | 31630 | Mat recoveredIdxs;
| 31679 |  |  | 31631 |
| 31680 | const char* keywords[] = { "image", "board", "detectedCorners", "detectedIds", "rejectedCorners", "cameraMatrix", "distCoeffs", "recoveredIdxs", NULL }; |  | 31632 | const char* keywords[] = { "image", "board", "detectedCorners", "detectedIds", "rejectedCorners", "cameraMatrix", "distCoeffs", "recoveredIdxs", NULL };
| 31681 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOO:aruco_ArucoDetector.refineDetectedMarkers", (char**)keywords, &pyobj_image, &pyobj_board, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_rejectedCorners, &pyobj_cameraMatrix, &pyobj_distCoeffs, &pyobj_recoveredIdxs) && |  | 31633 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOO:aruco_ArucoDetector.refineDetectedMarkers", (char**)keywords, &pyobj_image, &pyobj_board, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_rejectedCorners, &pyobj_cameraMatrix, &pyobj_distCoeffs, &pyobj_recoveredIdxs) &&
| 31682 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 31634 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 31683 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) && |  | 31635 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) &&
| 31684 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 1)) && |  | 31636 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 1)) &&
| 31685 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 1)) && |  | 31637 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 1)) &&
| 31686 | pyopencv_to_safe(pyobj_rejectedCorners, rejectedCorners, ArgInfo("rejectedCorners", 1)) && |  | 31638 | pyopencv_to_safe(pyobj_rejectedCorners, rejectedCorners, ArgInfo("rejectedCorners", 1)) &&
| 31687 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) && |  | 31639 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) &&
| 31688 | pyopencv_to_safe(pyobj_distCoeffs, distCoeffs, ArgInfo("distCoeffs", 0)) && |  | 31640 | pyopencv_to_safe(pyobj_distCoeffs, distCoeffs, ArgInfo("distCoeffs", 0)) &&
| 31689 | pyopencv_to_safe(pyobj_recoveredIdxs, recoveredIdxs, ArgInfo("recoveredIdxs", 1)) ) |  | 31641 | pyopencv_to_safe(pyobj_recoveredIdxs, recoveredIdxs, ArgInfo("recoveredIdxs", 1)) )
| 31690 | { |  | 31642 | {
| 31691 | ERRWRAP2(_self_->refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners, cameraMatrix, distCoeffs, recoveredIdxs)); |  | 31643 | ERRWRAP2(_self_->refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners, cameraMatrix, distCoeffs, recoveredIdxs));
| 31692 | return Py_BuildValue("(NNNN)", pyopencv_from(detectedCorners), pyopencv_from(detectedIds), pyopencv_from(rejectedCorners), pyopencv_from(recoveredIdxs)); |  | 31644 | return Py_BuildValue("(NNNN)", pyopencv_from(detectedCorners), pyopencv_from(detectedIds), pyopencv_from(rejectedCorners), pyopencv_from(recoveredIdxs));
| 31693 | } |  | 31645 | }
| 31694 |  |  | 31646 |
| 31695 |  |  | 31647 |
| 31696 | pyPopulateArgumentConversionErrors(); |  | 31648 | pyPopulateArgumentConversionErrors();
| 31697 | } |  | 31649 | }
| 31698 |  |  | 31650 |
| 31699 |  |  | 31651 |
| 31700 | { |  | 31652 | {
| 31701 | PyObject* pyobj_image = NULL; |  | 31653 | PyObject* pyobj_image = NULL;
| 31702 | UMat image; |  | 31654 | UMat image;
| 31703 | PyObject* pyobj_board = NULL; |  | 31655 | PyObject* pyobj_board = NULL;
| 31704 | Board board; |  | 31656 | Board board;
| 31705 | PyObject* pyobj_detectedCorners = NULL; |  | 31657 | PyObject* pyobj_detectedCorners = NULL;
| 31706 | vector_UMat detectedCorners; |  | 31658 | vector_UMat detectedCorners;
| 31707 | PyObject* pyobj_detectedIds = NULL; |  | 31659 | PyObject* pyobj_detectedIds = NULL;
| 31708 | UMat detectedIds; |  | 31660 | UMat detectedIds;
| 31709 | PyObject* pyobj_rejectedCorners = NULL; |  | 31661 | PyObject* pyobj_rejectedCorners = NULL;
| 31710 | vector_UMat rejectedCorners; |  | 31662 | vector_UMat rejectedCorners;
| 31711 | PyObject* pyobj_cameraMatrix = NULL; |  | 31663 | PyObject* pyobj_cameraMatrix = NULL;
| 31712 | UMat cameraMatrix; |  | 31664 | UMat cameraMatrix;
| 31713 | PyObject* pyobj_distCoeffs = NULL; |  | 31665 | PyObject* pyobj_distCoeffs = NULL;
| 31714 | UMat distCoeffs; |  | 31666 | UMat distCoeffs;
| 31715 | PyObject* pyobj_recoveredIdxs = NULL; |  | 31667 | PyObject* pyobj_recoveredIdxs = NULL;
| 31716 | UMat recoveredIdxs; |  | 31668 | UMat recoveredIdxs;
| 31717 |  |  | 31669 |
| 31718 | const char* keywords[] = { "image", "board", "detectedCorners", "detectedIds", "rejectedCorners", "cameraMatrix", "distCoeffs", "recoveredIdxs", NULL }; |  | 31670 | const char* keywords[] = { "image", "board", "detectedCorners", "detectedIds", "rejectedCorners", "cameraMatrix", "distCoeffs", "recoveredIdxs", NULL };
| 31719 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOO:aruco_ArucoDetector.refineDetectedMarkers", (char**)keywords, &pyobj_image, &pyobj_board, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_rejectedCorners, &pyobj_cameraMatrix, &pyobj_distCoeffs, &pyobj_recoveredIdxs) && |  | 31671 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOO:aruco_ArucoDetector.refineDetectedMarkers", (char**)keywords, &pyobj_image, &pyobj_board, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_rejectedCorners, &pyobj_cameraMatrix, &pyobj_distCoeffs, &pyobj_recoveredIdxs) &&
| 31720 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 31672 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 31721 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) && |  | 31673 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) &&
| 31722 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 1)) && |  | 31674 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 1)) &&
| 31723 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 1)) && |  | 31675 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 1)) &&
| 31724 | pyopencv_to_safe(pyobj_rejectedCorners, rejectedCorners, ArgInfo("rejectedCorners", 1)) && |  | 31676 | pyopencv_to_safe(pyobj_rejectedCorners, rejectedCorners, ArgInfo("rejectedCorners", 1)) &&
| 31725 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) && |  | 31677 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) &&
| 31726 | pyopencv_to_safe(pyobj_distCoeffs, distCoeffs, ArgInfo("distCoeffs", 0)) && |  | 31678 | pyopencv_to_safe(pyobj_distCoeffs, distCoeffs, ArgInfo("distCoeffs", 0)) &&
| 31727 | pyopencv_to_safe(pyobj_recoveredIdxs, recoveredIdxs, ArgInfo("recoveredIdxs", 1)) ) |  | 31679 | pyopencv_to_safe(pyobj_recoveredIdxs, recoveredIdxs, ArgInfo("recoveredIdxs", 1)) )
| 31728 | { |  | 31680 | {
| 31729 | ERRWRAP2(_self_->refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners, cameraMatrix, distCoeffs, recoveredIdxs)); |  | 31681 | ERRWRAP2(_self_->refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners, cameraMatrix, distCoeffs, recoveredIdxs));
| 31730 | return Py_BuildValue("(NNNN)", pyopencv_from(detectedCorners), pyopencv_from(detectedIds), pyopencv_from(rejectedCorners), pyopencv_from(recoveredIdxs)); |  | 31682 | return Py_BuildValue("(NNNN)", pyopencv_from(detectedCorners), pyopencv_from(detectedIds), pyopencv_from(rejectedCorners), pyopencv_from(recoveredIdxs));
| 31731 | } |  | 31683 | }
| 31732 |  |  | 31684 |
| 31733 |  |  | 31685 |
| 31734 | pyPopulateArgumentConversionErrors(); |  | 31686 | pyPopulateArgumentConversionErrors();
| 31735 | } |  | 31687 | }
| 31736 | pyRaiseCVOverloadException("refineDetectedMarkers"); |  | 31688 | pyRaiseCVOverloadException("refineDetectedMarkers");
| 31737 |  |  | 31689 |
| 31738 | return NULL; |  | 31690 | return NULL;
| 31739 | } |  | 31691 | }
| 31740 |  |  | 31692 |
| 31741 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31693 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 31742 | { |  | 31694 | {
| 31743 | using namespace cv::aruco; |  | 31695 | using namespace cv::aruco;
| 31744 |  |  | 31696 |
| 31745 |  |  | 31697 |
| 31746 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31698 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31747 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31699 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31748 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31700 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31749 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31701 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31750 | PyObject* pyobj_detectorParameters = NULL; |  | 31702 | PyObject* pyobj_detectorParameters = NULL;
| 31751 | DetectorParameters detectorParameters; |  | 31703 | DetectorParameters detectorParameters;
| 31752 |  |  | 31704 |
| 31753 | const char* keywords[] = { "detectorParameters", NULL }; |  | 31705 | const char* keywords[] = { "detectorParameters", NULL };
| 31754 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setDetectorParameters", (char**)keywords, &pyobj_detectorParameters) && |  | 31706 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setDetectorParameters", (char**)keywords, &pyobj_detectorParameters) &&
| 31755 | pyopencv_to_safe(pyobj_detectorParameters, detectorParameters, ArgInfo("detectorParameters", 0)) ) |  | 31707 | pyopencv_to_safe(pyobj_detectorParameters, detectorParameters, ArgInfo("detectorParameters", 0)) )
| 31756 | { |  | 31708 | {
| 31757 | ERRWRAP2(_self_->setDetectorParameters(detectorParameters)); |  | 31709 | ERRWRAP2(_self_->setDetectorParameters(detectorParameters));
| 31758 | Py_RETURN_NONE; |  | 31710 | Py_RETURN_NONE;
| 31759 | } |  | 31711 | }
| 31760 |  |  | 31712 |
| 31761 | return NULL; |  | 31713 | return NULL;
| 31762 | } |  | 31714 | }
| 31763 |  |  | 31715 |
| 31764 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setDictionaries(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31716 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setDictionaries(PyObject* self, PyObject* py_args, PyObject* kw)
| 31765 | { |  | 31717 | {
| 31766 | using namespace cv::aruco; |  | 31718 | using namespace cv::aruco;
| 31767 |  |  | 31719 |
| 31768 |  |  | 31720 |
| 31769 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31721 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31770 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31722 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31771 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31723 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31772 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31724 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31773 | PyObject* pyobj_dictionaries = NULL; |  | 31725 | PyObject* pyobj_dictionaries = NULL;
| 31774 | vector_Dictionary dictionaries; |  | 31726 | vector_Dictionary dictionaries;
| 31775 |  |  | 31727 |
| 31776 | const char* keywords[] = { "dictionaries", NULL }; |  | 31728 | const char* keywords[] = { "dictionaries", NULL };
| 31777 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setDictionaries", (char**)keywords, &pyobj_dictionaries) && |  | 31729 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setDictionaries", (char**)keywords, &pyobj_dictionaries) &&
| 31778 | pyopencv_to_safe(pyobj_dictionaries, dictionaries, ArgInfo("dictionaries", 0)) ) |  | 31730 | pyopencv_to_safe(pyobj_dictionaries, dictionaries, ArgInfo("dictionaries", 0)) )
| 31779 | { |  | 31731 | {
| 31780 | ERRWRAP2(_self_->setDictionaries(dictionaries)); |  | 31732 | ERRWRAP2(_self_->setDictionaries(dictionaries));
| 31781 | Py_RETURN_NONE; |  | 31733 | Py_RETURN_NONE;
| 31782 | } |  | 31734 | }
| 31783 |  |  | 31735 |
| 31784 | return NULL; |  | 31736 | return NULL;
| 31785 | } |  | 31737 | }
| 31786 |  |  | 31738 |
| 31787 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setDictionary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31739 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setDictionary(PyObject* self, PyObject* py_args, PyObject* kw)
| 31788 | { |  | 31740 | {
| 31789 | using namespace cv::aruco; |  | 31741 | using namespace cv::aruco;
| 31790 |  |  | 31742 |
| 31791 |  |  | 31743 |
| 31792 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31744 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31793 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31745 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31794 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31746 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31795 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31747 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31796 | PyObject* pyobj_dictionary = NULL; |  | 31748 | PyObject* pyobj_dictionary = NULL;
| 31797 | Dictionary dictionary; |  | 31749 | Dictionary dictionary;
| 31798 |  |  | 31750 |
| 31799 | const char* keywords[] = { "dictionary", NULL }; |  | 31751 | const char* keywords[] = { "dictionary", NULL };
| 31800 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setDictionary", (char**)keywords, &pyobj_dictionary) && |  | 31752 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setDictionary", (char**)keywords, &pyobj_dictionary) &&
| 31801 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) ) |  | 31753 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) )
| 31802 | { |  | 31754 | {
| 31803 | ERRWRAP2(_self_->setDictionary(dictionary)); |  | 31755 | ERRWRAP2(_self_->setDictionary(dictionary));
| 31804 | Py_RETURN_NONE; |  | 31756 | Py_RETURN_NONE;
| 31805 | } |  | 31757 | }
| 31806 |  |  | 31758 |
| 31807 | return NULL; |  | 31759 | return NULL;
| 31808 | } |  | 31760 | }
| 31809 |  |  | 31761 |
| 31810 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31762 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_setRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 31811 | { |  | 31763 | {
| 31812 | using namespace cv::aruco; |  | 31764 | using namespace cv::aruco;
| 31813 |  |  | 31765 |
| 31814 |  |  | 31766 |
| 31815 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31767 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31816 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31768 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31817 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31769 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31818 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31770 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31819 | PyObject* pyobj_refineParameters = NULL; |  | 31771 | PyObject* pyobj_refineParameters = NULL;
| 31820 | RefineParameters refineParameters; |  | 31772 | RefineParameters refineParameters;
| 31821 |  |  | 31773 |
| 31822 | const char* keywords[] = { "refineParameters", NULL }; |  | 31774 | const char* keywords[] = { "refineParameters", NULL };
| 31823 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setRefineParameters", (char**)keywords, &pyobj_refineParameters) && |  | 31775 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_ArucoDetector.setRefineParameters", (char**)keywords, &pyobj_refineParameters) &&
| 31824 | pyopencv_to_safe(pyobj_refineParameters, refineParameters, ArgInfo("refineParameters", 0)) ) |  | 31776 | pyopencv_to_safe(pyobj_refineParameters, refineParameters, ArgInfo("refineParameters", 0)) )
| 31825 | { |  | 31777 | {
| 31826 | ERRWRAP2(_self_->setRefineParameters(refineParameters)); |  | 31778 | ERRWRAP2(_self_->setRefineParameters(refineParameters));
| 31827 | Py_RETURN_NONE; |  | 31779 | Py_RETURN_NONE;
| 31828 | } |  | 31780 | }
| 31829 |  |  | 31781 |
| 31830 | return NULL; |  | 31782 | return NULL;
| 31831 | } |  | 31783 | }
| 31832 |  |  | 31784 |
| 31833 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31785 | static PyObject* pyopencv_cv_aruco_aruco_ArucoDetector_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 31834 | { |  | 31786 | {
| 31835 | using namespace cv::aruco; |  | 31787 | using namespace cv::aruco;
| 31836 |  |  | 31788 |
| 31837 |  |  | 31789 |
| 31838 | Ptr<cv::aruco::ArucoDetector> * self1 = 0; |  | 31790 | Ptr<cv::aruco::ArucoDetector> * self1 = 0;
| 31839 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1)) |  | 31791 | if (!pyopencv_aruco_ArucoDetector_getp(self, self1))
| 31840 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)"); |  | 31792 | return failmsgp("Incorrect type of self (must be 'aruco_ArucoDetector' or its derivative)");
| 31841 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1); |  | 31793 | Ptr<cv::aruco::ArucoDetector> _self_ = *(self1);
| 31842 | PyObject* pyobj_fs = NULL; |  | 31794 | PyObject* pyobj_fs = NULL;
| 31843 | Ptr<cv::FileStorage> fs; |  | 31795 | Ptr<cv::FileStorage> fs;
| 31844 | PyObject* pyobj_name = NULL; |  | 31796 | PyObject* pyobj_name = NULL;
| 31845 | String name; |  | 31797 | String name;
| 31846 |  |  | 31798 |
| 31847 | const char* keywords[] = { "fs", "name", NULL }; |  | 31799 | const char* keywords[] = { "fs", "name", NULL };
| 31848 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:aruco_ArucoDetector.write", (char**)keywords, &pyobj_fs, &pyobj_name) && |  | 31800 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:aruco_ArucoDetector.write", (char**)keywords, &pyobj_fs, &pyobj_name) &&
| 31849 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) && |  | 31801 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) &&
| 31850 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 31802 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 31851 | { |  | 31803 | {
| 31852 | ERRWRAP2(_self_->write(*fs, name)); |  | 31804 | ERRWRAP2(_self_->write(*fs, name));
| 31853 | Py_RETURN_NONE; |  | 31805 | Py_RETURN_NONE;
| 31854 | } |  | 31806 | }
| 31855 |  |  | 31807 |
| 31856 | return NULL; |  | 31808 | return NULL;
| 31857 | } |  | 31809 | }
| 31858 |  |  | 31810 |
| 31859 |  |  | 31811 |
| 31860 |  |  | 31812 |
| 31861 | // Tables (aruco_ArucoDetector) |  | 31813 | // Tables (aruco_ArucoDetector)
| 31862 |  |  | 31814 |
| 31863 | static PyGetSetDef pyopencv_aruco_ArucoDetector_getseters[] = |  | 31815 | static PyGetSetDef pyopencv_aruco_ArucoDetector_getseters[] =
| 31864 | { |  | 31816 | {
| 31865 | {NULL} /* Sentinel */ |  | 31817 | {NULL} /* Sentinel */
| 31866 | }; |  | 31818 | };
| 31867 |  |  | 31819 |
| 31868 | static PyMethodDef pyopencv_aruco_ArucoDetector_methods[] = |  | 31820 | static PyMethodDef pyopencv_aruco_ArucoDetector_methods[] =
| 31869 | { |  | 31821 | {
| 31870 | {"detectMarkers", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkers, 0), "detectMarkers(image[, corners[, ids[, rejectedImgPoints]]]) -> corners, ids, rejectedImgPoints\n. @brief Basic marker detection\n. *\n. * @param image input image\n. * @param corners vector of detected marker corners. For each marker, its four corners\n. * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,\n. * the dimensions of this array is Nx4. The order of the corners is clockwise.\n. * @param ids vector of identifiers of the detected markers. The identifier is of type int\n. * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.\n. * The identifiers have the same order than the markers in the imgPoints array.\n. * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a\n. * correct codification. Useful for debugging purposes.\n. *\n. * Performs marker detection in the input image. Only markers included in the first specified dictionary\n. * are searched. For each detected marker, it returns the 2D position of its corner in the image\n. * and its corresponding identifier.\n. * Note that this function does not perform pose estimation.\n. * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort\n. * input image with corresponding camera model, if camera parameters are known\n. * @sa undistort, estimatePoseSingleMarkers, estimatePoseBoard"}, |  | 31822 | {"detectMarkers", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkers, 0), "detectMarkers(image[, corners[, ids[, rejectedImgPoints]]]) -> corners, ids, rejectedImgPoints\n. @brief Basic marker detection\n. *\n. * @param image input image\n. * @param corners vector of detected marker corners. For each marker, its four corners\n. * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,\n. * the dimensions of this array is Nx4. The order of the corners is clockwise.\n. * @param ids vector of identifiers of the detected markers. The identifier is of type int\n. * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.\n. * The identifiers have the same order than the markers in the imgPoints array.\n. * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a\n. * correct codification. Useful for debugging purposes.\n. *\n. * Performs marker detection in the input image. Only markers included in the first specified dictionary\n. * are searched. For each detected marker, it returns the 2D position of its corner in the image\n. * and its corresponding identifier.\n. * Note that this function does not perform pose estimation.\n. * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort\n. * input image with corresponding camera model, if camera parameters are known\n. * @sa undistort, estimatePoseSingleMarkers, estimatePoseBoard"},
| 31871 | {"detectMarkersMultiDict", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkersMultiDict, 0), "detectMarkersMultiDict(image[, corners[, ids[, rejectedImgPoints[, dictIndices]]]]) -> corners, ids, rejectedImgPoints, dictIndices\n. @brief Basic marker detection\n. *\n. * @param image input image\n. * @param corners vector of detected marker corners. For each marker, its four corners\n. * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,\n. * the dimensions of this array is Nx4. The order of the corners is clockwise.\n. * @param ids vector of identifiers of the detected markers. The identifier is of type int\n. * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.\n. * The identifiers have the same order than the markers in the imgPoints array.\n. * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a\n. * correct codification. Useful for debugging purposes.\n. * @param dictIndices vector of dictionary indices for each detected marker. Use getDictionaries() to get the\n. * list of corresponding dictionaries.\n. *\n. * Performs marker detection in the input image. Only markers included in the specific dictionaries\n. * are searched. For each detected marker, it returns the 2D position of its corner in the image\n. * and its corresponding identifier.\n. * Note that this function does not perform pose estimation.\n. * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort\n. * input image with corresponding camera model, if camera parameters are known\n. * @sa undistort, estimatePoseSingleMarkers, estimatePoseBoard"}, |  | 31823 | {"detectMarkersMultiDict", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_detectMarkersMultiDict, 0), "detectMarkersMultiDict(image[, corners[, ids[, rejectedImgPoints[, dictIndices]]]]) -> corners, ids, rejectedImgPoints, dictIndices\n. @brief Basic marker detection\n. *\n. * @param image input image\n. * @param corners vector of detected marker corners. For each marker, its four corners\n. * are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers,\n. * the dimensions of this array is Nx4. The order of the corners is clockwise.\n. * @param ids vector of identifiers of the detected markers. The identifier is of type int\n. * (e.g. std::vector<int>). For N detected markers, the size of ids is also N.\n. * The identifiers have the same order than the markers in the imgPoints array.\n. * @param rejectedImgPoints contains the imgPoints of those squares whose inner code has not a\n. * correct codification. Useful for debugging purposes.\n. * @param dictIndices vector of dictionary indices for each detected marker. Use getDictionaries() to get the\n. * list of corresponding dictionaries.\n. *\n. * Performs marker detection in the input image. Only markers included in the specific dictionaries\n. * are searched. For each detected marker, it returns the 2D position of its corner in the image\n. * and its corresponding identifier.\n. * Note that this function does not perform pose estimation.\n. * @note The function does not correct lens distortion or takes it into account. It's recommended to undistort\n. * input image with corresponding camera model, if camera parameters are known\n. * @sa undistort, estimatePoseSingleMarkers, estimatePoseBoard"},
| 31872 | {"getDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getDetectorParameters, 0), "getDetectorParameters() -> retval\n."}, |  | 31824 | {"getDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getDetectorParameters, 0), "getDetectorParameters() -> retval\n."},
| 31873 | {"getDictionaries", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getDictionaries, 0), "getDictionaries() -> retval\n. @brief Returns all dictionaries currently used for marker detection as a vector.\n. *\n. * @return A std::vector<Dictionary> containing all dictionaries used by the ArucoDetector."}, |  | 31825 | {"getDictionaries", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getDictionaries, 0), "getDictionaries() -> retval\n. @brief Returns all dictionaries currently used for marker detection as a vector.\n. *\n. * @return A std::vector<Dictionary> containing all dictionaries used by the ArucoDetector."},
| 31874 | {"getDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getDictionary, 0), "getDictionary() -> retval\n. @brief Returns first dictionary from internal list used for marker detection.\n. *\n. * @return The first dictionary from the configured ArucoDetector."}, |  | 31826 | {"getDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getDictionary, 0), "getDictionary() -> retval\n. @brief Returns first dictionary from internal list used for marker detection.\n. *\n. * @return The first dictionary from the configured ArucoDetector."},
| 31875 | {"getRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getRefineParameters, 0), "getRefineParameters() -> retval\n."}, |  | 31827 | {"getRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_getRefineParameters, 0), "getRefineParameters() -> retval\n."},
| 31876 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_read, 0), "read(fn) -> None\n. @brief Reads algorithm parameters from a file storage"}, |  | 31828 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_read, 0), "read(fn) -> None\n. @brief Reads algorithm parameters from a file storage"},
| 31877 | {"refineDetectedMarkers", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_refineDetectedMarkers, 0), "refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners[, cameraMatrix[, distCoeffs[, recoveredIdxs]]]) -> detectedCorners, detectedIds, rejectedCorners, recoveredIdxs\n. @brief Refine not detected markers based on the already detected and the board layout\n. *\n. * @param image input image\n. * @param board layout of markers in the board.\n. * @param detectedCorners vector of already detected marker corners.\n. * @param detectedIds vector of already detected marker identifiers.\n. * @param rejectedCorners vector of rejected candidates during the marker detection process.\n. * @param cameraMatrix optional input 3x3 floating-point camera matrix\n. * \\f$A = \\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\\f$\n. * @param distCoeffs optional vector of distortion coefficients\n. * \\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\\f$ of 4, 5, 8 or 12 elements\n. * @param recoveredIdxs Optional array to returns the indexes of the recovered candidates in the\n. * original rejectedCorners array.\n. *\n. * This function tries to find markers that were not detected in the basic detecMarkers function.\n. * First, based on the current detected marker and the board layout, the function interpolates\n. * the position of the missing markers. Then it tries to find correspondence between the reprojected\n. * markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters.\n. * If camera parameters and distortion coefficients are provided, missing markers are reprojected\n. * using projectPoint function. If not, missing marker projections are interpolated using global\n. * homography, and all the marker corners in the board must have the same Z coordinate.\n. * @note This function assumes that the board only contains markers from one dictionary, so only the\n. * first configured dictionary is used. It has to match the dictionary of the board to work properly."}, |  | 31829 | {"refineDetectedMarkers", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_refineDetectedMarkers, 0), "refineDetectedMarkers(image, board, detectedCorners, detectedIds, rejectedCorners[, cameraMatrix[, distCoeffs[, recoveredIdxs]]]) -> detectedCorners, detectedIds, rejectedCorners, recoveredIdxs\n. @brief Refine not detected markers based on the already detected and the board layout\n. *\n. * @param image input image\n. * @param board layout of markers in the board.\n. * @param detectedCorners vector of already detected marker corners.\n. * @param detectedIds vector of already detected marker identifiers.\n. * @param rejectedCorners vector of rejected candidates during the marker detection process.\n. * @param cameraMatrix optional input 3x3 floating-point camera matrix\n. * \\f$A = \\vecthreethree{f_x}{0}{c_x}{0}{f_y}{c_y}{0}{0}{1}\\f$\n. * @param distCoeffs optional vector of distortion coefficients\n. * \\f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6],[s_1, s_2, s_3, s_4]])\\f$ of 4, 5, 8 or 12 elements\n. * @param recoveredIdxs Optional array to returns the indexes of the recovered candidates in the\n. * original rejectedCorners array.\n. *\n. * This function tries to find markers that were not detected in the basic detecMarkers function.\n. * First, based on the current detected marker and the board layout, the function interpolates\n. * the position of the missing markers. Then it tries to find correspondence between the reprojected\n. * markers and the rejected candidates based on the minRepDistance and errorCorrectionRate parameters.\n. * If camera parameters and distortion coefficients are provided, missing markers are reprojected\n. * using projectPoint function. If not, missing marker projections are interpolated using global\n. * homography, and all the marker corners in the board must have the same Z coordinate.\n. * @note This function assumes that the board only contains markers from one dictionary, so only the\n. * first configured dictionary is used. It has to match the dictionary of the board to work properly."},
| 31878 | {"setDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setDetectorParameters, 0), "setDetectorParameters(detectorParameters) -> None\n."}, |  | 31830 | {"setDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setDetectorParameters, 0), "setDetectorParameters(detectorParameters) -> None\n."},
| 31879 | {"setDictionaries", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setDictionaries, 0), "setDictionaries(dictionaries) -> None\n. @brief Sets the entire collection of dictionaries to be used for marker detection, replacing any existing dictionaries.\n. *\n. * @param dictionaries A std::vector<Dictionary> containing the new set of dictionaries to be used.\n. *\n. * Configures the ArucoDetector to use the provided vector of dictionaries for marker detection.\n. * This method replaces any dictionaries that were previously set.\n. * @note Setting an empty vector of dictionaries will throw an error."}, |  | 31831 | {"setDictionaries", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setDictionaries, 0), "setDictionaries(dictionaries) -> None\n. @brief Sets the entire collection of dictionaries to be used for marker detection, replacing any existing dictionaries.\n. *\n. * @param dictionaries A std::vector<Dictionary> containing the new set of dictionaries to be used.\n. *\n. * Configures the ArucoDetector to use the provided vector of dictionaries for marker detection.\n. * This method replaces any dictionaries that were previously set.\n. * @note Setting an empty vector of dictionaries will throw an error."},
| 31880 | {"setDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setDictionary, 0), "setDictionary(dictionary) -> None\n. @brief Sets and replaces the first dictionary in internal list to be used for marker detection.\n. *\n. * @param dictionary The new dictionary that will replace the first dictionary in the internal list."}, |  | 31832 | {"setDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setDictionary, 0), "setDictionary(dictionary) -> None\n. @brief Sets and replaces the first dictionary in internal list to be used for marker detection.\n. *\n. * @param dictionary The new dictionary that will replace the first dictionary in the internal list."},
| 31881 | {"setRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setRefineParameters, 0), "setRefineParameters(refineParameters) -> None\n."}, |  | 31833 | {"setRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_setRefineParameters, 0), "setRefineParameters(refineParameters) -> None\n."},
| 31882 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_write, 0), "write(fs, name) -> None\n. @brief simplified API for language bindings"}, |  | 31834 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_ArucoDetector_write, 0), "write(fs, name) -> None\n. @brief simplified API for language bindings"},
| 31883 |  |  | 31835 |
| 31884 | {NULL, NULL} |  | 31836 | {NULL, NULL}
| 31885 | }; |  | 31837 | };
| 31886 |  |  | 31838 |
| 31887 | // Converter (aruco_ArucoDetector) |  | 31839 | // Converter (aruco_ArucoDetector)
| 31888 |  |  | 31840 |
| 31889 | template<> |  | 31841 | template<>
| 31890 | struct PyOpenCV_Converter< Ptr<cv::aruco::ArucoDetector> > |  | 31842 | struct PyOpenCV_Converter< Ptr<cv::aruco::ArucoDetector> >
| 31891 | { |  | 31843 | {
| 31892 | static PyObject* from(const Ptr<cv::aruco::ArucoDetector>& r) |  | 31844 | static PyObject* from(const Ptr<cv::aruco::ArucoDetector>& r)
| 31893 | { |  | 31845 | {
| 31894 | return pyopencv_aruco_ArucoDetector_Instance(r); |  | 31846 | return pyopencv_aruco_ArucoDetector_Instance(r);
| 31895 | } |  | 31847 | }
| 31896 | static bool to(PyObject* src, Ptr<cv::aruco::ArucoDetector>& dst, const ArgInfo& info) |  | 31848 | static bool to(PyObject* src, Ptr<cv::aruco::ArucoDetector>& dst, const ArgInfo& info)
| 31897 | { |  | 31849 | {
| 31898 | if(!src || src == Py_None) |  | 31850 | if(!src || src == Py_None)
| 31899 | return true; |  | 31851 | return true;
| 31900 | Ptr<cv::aruco::ArucoDetector> * dst_; |  | 31852 | Ptr<cv::aruco::ArucoDetector> * dst_;
| 31901 | if (pyopencv_aruco_ArucoDetector_getp(src, dst_)) |  | 31853 | if (pyopencv_aruco_ArucoDetector_getp(src, dst_))
| 31902 | { |  | 31854 | {
| 31903 | dst = *dst_; |  | 31855 | dst = *dst_;
| 31904 | return true; |  | 31856 | return true;
| 31905 | } |  | 31857 | }
| 31906 |  |  | 31858 |
| 31907 | failmsg("Expected Ptr<cv::aruco::ArucoDetector> for argument '%s'", info.name); |  | 31859 | failmsg("Expected Ptr<cv::aruco::ArucoDetector> for argument '%s'", info.name);
| 31908 | return false; |  | 31860 | return false;
| 31909 | } |  | 31861 | }
| 31910 | }; |  | 31862 | };
| 31911 |  |  | 31863 |
| 31912 | //================================================================================ |  | 31864 | //================================================================================
| 31913 | // aruco_Board (Generic) |  | 31865 | // aruco_Board (Generic)
| 31914 | //================================================================================ |  | 31866 | //================================================================================
| 31915 |  |  | 31867 |
| 31916 | // GetSet (aruco_Board) |  | 31868 | // GetSet (aruco_Board)
| 31917 |  |  | 31869 |
| 31918 |  |  | 31870 |
| 31919 |  |  | 31871 |
| 31920 | // Methods (aruco_Board) |  | 31872 | // Methods (aruco_Board)
| 31921 |  |  | 31873 |
| 31922 | static int pyopencv_cv_aruco_aruco_Board_Board(pyopencv_aruco_Board_t* self, PyObject* py_args, PyObject* kw) |  | 31874 | static int pyopencv_cv_aruco_aruco_Board_Board(pyopencv_aruco_Board_t* self, PyObject* py_args, PyObject* kw)
| 31923 | { |  | 31875 | {
| 31924 | using namespace cv::aruco; |  | 31876 | using namespace cv::aruco;
| 31925 |  |  | 31877 |
| 31926 | pyPrepareArgumentConversionErrorsStorage(2); |  | 31878 | pyPrepareArgumentConversionErrorsStorage(2);
| 31927 |  |  | 31879 |
| 31928 | { |  | 31880 | {
| 31929 | PyObject* pyobj_objPoints = NULL; |  | 31881 | PyObject* pyobj_objPoints = NULL;
| 31930 | vector_Mat objPoints; |  | 31882 | vector_Mat objPoints;
| 31931 | PyObject* pyobj_dictionary = NULL; |  | 31883 | PyObject* pyobj_dictionary = NULL;
| 31932 | Dictionary dictionary; |  | 31884 | Dictionary dictionary;
| 31933 | PyObject* pyobj_ids = NULL; |  | 31885 | PyObject* pyobj_ids = NULL;
| 31934 | Mat ids; |  | 31886 | Mat ids;
| 31935 |  |  | 31887 |
| 31936 | const char* keywords[] = { "objPoints", "dictionary", "ids", NULL }; |  | 31888 | const char* keywords[] = { "objPoints", "dictionary", "ids", NULL };
| 31937 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Board", (char**)keywords, &pyobj_objPoints, &pyobj_dictionary, &pyobj_ids) && |  | 31889 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Board", (char**)keywords, &pyobj_objPoints, &pyobj_dictionary, &pyobj_ids) &&
| 31938 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 0)) && |  | 31890 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 0)) &&
| 31939 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) && |  | 31891 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) &&
| 31940 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) ) |  | 31892 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) )
| 31941 | { |  | 31893 | {
| 31942 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Board(objPoints, dictionary, ids)); |  | 31894 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Board(objPoints, dictionary, ids));
| 31943 | return 0; |  | 31895 | return 0;
| 31944 | } |  | 31896 | }
| 31945 |  |  | 31897 |
| 31946 |  |  | 31898 |
| 31947 | pyPopulateArgumentConversionErrors(); |  | 31899 | pyPopulateArgumentConversionErrors();
| 31948 | } |  | 31900 | }
| 31949 |  |  | 31901 |
| 31950 |  |  | 31902 |
| 31951 | { |  | 31903 | {
| 31952 | PyObject* pyobj_objPoints = NULL; |  | 31904 | PyObject* pyobj_objPoints = NULL;
| 31953 | vector_UMat objPoints; |  | 31905 | vector_UMat objPoints;
| 31954 | PyObject* pyobj_dictionary = NULL; |  | 31906 | PyObject* pyobj_dictionary = NULL;
| 31955 | Dictionary dictionary; |  | 31907 | Dictionary dictionary;
| 31956 | PyObject* pyobj_ids = NULL; |  | 31908 | PyObject* pyobj_ids = NULL;
| 31957 | UMat ids; |  | 31909 | UMat ids;
| 31958 |  |  | 31910 |
| 31959 | const char* keywords[] = { "objPoints", "dictionary", "ids", NULL }; |  | 31911 | const char* keywords[] = { "objPoints", "dictionary", "ids", NULL };
| 31960 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Board", (char**)keywords, &pyobj_objPoints, &pyobj_dictionary, &pyobj_ids) && |  | 31912 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Board", (char**)keywords, &pyobj_objPoints, &pyobj_dictionary, &pyobj_ids) &&
| 31961 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 0)) && |  | 31913 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 0)) &&
| 31962 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) && |  | 31914 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) &&
| 31963 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) ) |  | 31915 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) )
| 31964 | { |  | 31916 | {
| 31965 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Board(objPoints, dictionary, ids)); |  | 31917 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Board(objPoints, dictionary, ids));
| 31966 | return 0; |  | 31918 | return 0;
| 31967 | } |  | 31919 | }
| 31968 |  |  | 31920 |
| 31969 |  |  | 31921 |
| 31970 | pyPopulateArgumentConversionErrors(); |  | 31922 | pyPopulateArgumentConversionErrors();
| 31971 | } |  | 31923 | }
| 31972 | pyRaiseCVOverloadException("Board"); |  | 31924 | pyRaiseCVOverloadException("Board");
| 31973 |  |  | 31925 |
| 31974 | return -1; |  | 31926 | return -1;
| 31975 | } |  | 31927 | }
| 31976 |  |  | 31928 |
| 31977 | static PyObject* pyopencv_cv_aruco_aruco_Board_generateImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31929 | static PyObject* pyopencv_cv_aruco_aruco_Board_generateImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 31978 | { |  | 31930 | {
| 31979 | using namespace cv::aruco; |  | 31931 | using namespace cv::aruco;
| 31980 |  |  | 31932 |
| 31981 |  |  | 31933 |
| 31982 | cv::aruco::Board * self1 = 0; |  | 31934 | cv::aruco::Board * self1 = 0;
| 31983 | if (!pyopencv_aruco_Board_getp(self, self1)) |  | 31935 | if (!pyopencv_aruco_Board_getp(self, self1))
| 31984 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)"); |  | 31936 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)");
| 31985 | cv::aruco::Board* _self_ = (self1); |  | 31937 | cv::aruco::Board* _self_ = (self1);
| 31986 | pyPrepareArgumentConversionErrorsStorage(2); |  | 31938 | pyPrepareArgumentConversionErrorsStorage(2);
| 31987 |  |  | 31939 |
| 31988 | { |  | 31940 | {
| 31989 | PyObject* pyobj_outSize = NULL; |  | 31941 | PyObject* pyobj_outSize = NULL;
| 31990 | Size outSize; |  | 31942 | Size outSize;
| 31991 | PyObject* pyobj_img = NULL; |  | 31943 | PyObject* pyobj_img = NULL;
| 31992 | Mat img; |  | 31944 | Mat img;
| 31993 | PyObject* pyobj_marginSize = NULL; |  | 31945 | PyObject* pyobj_marginSize = NULL;
| 31994 | int marginSize=0; |  | 31946 | int marginSize=0;
| 31995 | PyObject* pyobj_borderBits = NULL; |  | 31947 | PyObject* pyobj_borderBits = NULL;
| 31996 | int borderBits=1; |  | 31948 | int borderBits=1;
| 31997 |  |  | 31949 |
| 31998 | const char* keywords[] = { "outSize", "img", "marginSize", "borderBits", NULL }; |  | 31950 | const char* keywords[] = { "outSize", "img", "marginSize", "borderBits", NULL };
| 31999 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_Board.generateImage", (char**)keywords, &pyobj_outSize, &pyobj_img, &pyobj_marginSize, &pyobj_borderBits) && |  | 31951 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_Board.generateImage", (char**)keywords, &pyobj_outSize, &pyobj_img, &pyobj_marginSize, &pyobj_borderBits) &&
| 32000 | pyopencv_to_safe(pyobj_outSize, outSize, ArgInfo("outSize", 0)) && |  | 31952 | pyopencv_to_safe(pyobj_outSize, outSize, ArgInfo("outSize", 0)) &&
| 32001 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) && |  | 31953 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) &&
| 32002 | pyopencv_to_safe(pyobj_marginSize, marginSize, ArgInfo("marginSize", 0)) && |  | 31954 | pyopencv_to_safe(pyobj_marginSize, marginSize, ArgInfo("marginSize", 0)) &&
| 32003 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) ) |  | 31955 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) )
| 32004 | { |  | 31956 | {
| 32005 | ERRWRAP2(_self_->generateImage(outSize, img, marginSize, borderBits)); |  | 31957 | ERRWRAP2(_self_->generateImage(outSize, img, marginSize, borderBits));
| 32006 | return pyopencv_from(img); |  | 31958 | return pyopencv_from(img);
| 32007 | } |  | 31959 | }
| 32008 |  |  | 31960 |
| 32009 |  |  | 31961 |
| 32010 | pyPopulateArgumentConversionErrors(); |  | 31962 | pyPopulateArgumentConversionErrors();
| 32011 | } |  | 31963 | }
| 32012 |  |  | 31964 |
| 32013 |  |  | 31965 |
| 32014 | { |  | 31966 | {
| 32015 | PyObject* pyobj_outSize = NULL; |  | 31967 | PyObject* pyobj_outSize = NULL;
| 32016 | Size outSize; |  | 31968 | Size outSize;
| 32017 | PyObject* pyobj_img = NULL; |  | 31969 | PyObject* pyobj_img = NULL;
| 32018 | UMat img; |  | 31970 | UMat img;
| 32019 | PyObject* pyobj_marginSize = NULL; |  | 31971 | PyObject* pyobj_marginSize = NULL;
| 32020 | int marginSize=0; |  | 31972 | int marginSize=0;
| 32021 | PyObject* pyobj_borderBits = NULL; |  | 31973 | PyObject* pyobj_borderBits = NULL;
| 32022 | int borderBits=1; |  | 31974 | int borderBits=1;
| 32023 |  |  | 31975 |
| 32024 | const char* keywords[] = { "outSize", "img", "marginSize", "borderBits", NULL }; |  | 31976 | const char* keywords[] = { "outSize", "img", "marginSize", "borderBits", NULL };
| 32025 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_Board.generateImage", (char**)keywords, &pyobj_outSize, &pyobj_img, &pyobj_marginSize, &pyobj_borderBits) && |  | 31977 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:aruco_Board.generateImage", (char**)keywords, &pyobj_outSize, &pyobj_img, &pyobj_marginSize, &pyobj_borderBits) &&
| 32026 | pyopencv_to_safe(pyobj_outSize, outSize, ArgInfo("outSize", 0)) && |  | 31978 | pyopencv_to_safe(pyobj_outSize, outSize, ArgInfo("outSize", 0)) &&
| 32027 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) && |  | 31979 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) &&
| 32028 | pyopencv_to_safe(pyobj_marginSize, marginSize, ArgInfo("marginSize", 0)) && |  | 31980 | pyopencv_to_safe(pyobj_marginSize, marginSize, ArgInfo("marginSize", 0)) &&
| 32029 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) ) |  | 31981 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) )
| 32030 | { |  | 31982 | {
| 32031 | ERRWRAP2(_self_->generateImage(outSize, img, marginSize, borderBits)); |  | 31983 | ERRWRAP2(_self_->generateImage(outSize, img, marginSize, borderBits));
| 32032 | return pyopencv_from(img); |  | 31984 | return pyopencv_from(img);
| 32033 | } |  | 31985 | }
| 32034 |  |  | 31986 |
| 32035 |  |  | 31987 |
| 32036 | pyPopulateArgumentConversionErrors(); |  | 31988 | pyPopulateArgumentConversionErrors();
| 32037 | } |  | 31989 | }
| 32038 | pyRaiseCVOverloadException("generateImage"); |  | 31990 | pyRaiseCVOverloadException("generateImage");
| 32039 |  |  | 31991 |
| 32040 | return NULL; |  | 31992 | return NULL;
| 32041 | } |  | 31993 | }
| 32042 |  |  | 31994 |
| 32043 | static PyObject* pyopencv_cv_aruco_aruco_Board_getDictionary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 31995 | static PyObject* pyopencv_cv_aruco_aruco_Board_getDictionary(PyObject* self, PyObject* py_args, PyObject* kw)
| 32044 | { |  | 31996 | {
| 32045 | using namespace cv::aruco; |  | 31997 | using namespace cv::aruco;
| 32046 |  |  | 31998 |
| 32047 |  |  | 31999 |
| 32048 | cv::aruco::Board * self1 = 0; |  | 32000 | cv::aruco::Board * self1 = 0;
| 32049 | if (!pyopencv_aruco_Board_getp(self, self1)) |  | 32001 | if (!pyopencv_aruco_Board_getp(self, self1))
| 32050 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)"); |  | 32002 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)");
| 32051 | cv::aruco::Board* _self_ = (self1); |  | 32003 | cv::aruco::Board* _self_ = (self1);
| 32052 | Dictionary retval; |  | 32004 | Dictionary retval;
| 32053 |  |  | 32005 |
| 32054 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32006 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32055 | { |  | 32007 | {
| 32056 | ERRWRAP2(retval = _self_->getDictionary()); |  | 32008 | ERRWRAP2(retval = _self_->getDictionary());
| 32057 | return pyopencv_from(retval); |  | 32009 | return pyopencv_from(retval);
| 32058 | } |  | 32010 | }
| 32059 |  |  | 32011 |
| 32060 | return NULL; |  | 32012 | return NULL;
| 32061 | } |  | 32013 | }
| 32062 |  |  | 32014 |
| 32063 | static PyObject* pyopencv_cv_aruco_aruco_Board_getIds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32015 | static PyObject* pyopencv_cv_aruco_aruco_Board_getIds(PyObject* self, PyObject* py_args, PyObject* kw)
| 32064 | { |  | 32016 | {
| 32065 | using namespace cv::aruco; |  | 32017 | using namespace cv::aruco;
| 32066 |  |  | 32018 |
| 32067 |  |  | 32019 |
| 32068 | cv::aruco::Board * self1 = 0; |  | 32020 | cv::aruco::Board * self1 = 0;
| 32069 | if (!pyopencv_aruco_Board_getp(self, self1)) |  | 32021 | if (!pyopencv_aruco_Board_getp(self, self1))
| 32070 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)"); |  | 32022 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)");
| 32071 | cv::aruco::Board* _self_ = (self1); |  | 32023 | cv::aruco::Board* _self_ = (self1);
| 32072 | std::vector<int> retval; |  | 32024 | std::vector<int> retval;
| 32073 |  |  | 32025 |
| 32074 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32026 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32075 | { |  | 32027 | {
| 32076 | ERRWRAP2(retval = _self_->getIds()); |  | 32028 | ERRWRAP2(retval = _self_->getIds());
| 32077 | return pyopencv_from(retval); |  | 32029 | return pyopencv_from(retval);
| 32078 | } |  | 32030 | }
| 32079 |  |  | 32031 |
| 32080 | return NULL; |  | 32032 | return NULL;
| 32081 | } |  | 32033 | }
| 32082 |  |  | 32034 |
| 32083 | static PyObject* pyopencv_cv_aruco_aruco_Board_getObjPoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32035 | static PyObject* pyopencv_cv_aruco_aruco_Board_getObjPoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 32084 | { |  | 32036 | {
| 32085 | using namespace cv::aruco; |  | 32037 | using namespace cv::aruco;
| 32086 |  |  | 32038 |
| 32087 |  |  | 32039 |
| 32088 | cv::aruco::Board * self1 = 0; |  | 32040 | cv::aruco::Board * self1 = 0;
| 32089 | if (!pyopencv_aruco_Board_getp(self, self1)) |  | 32041 | if (!pyopencv_aruco_Board_getp(self, self1))
| 32090 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)"); |  | 32042 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)");
| 32091 | cv::aruco::Board* _self_ = (self1); |  | 32043 | cv::aruco::Board* _self_ = (self1);
| 32092 | std::vector<std::vector<Point3f> > retval; |  | 32044 | std::vector<std::vector<Point3f> > retval;
| 32093 |  |  | 32045 |
| 32094 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32046 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32095 | { |  | 32047 | {
| 32096 | ERRWRAP2(retval = _self_->getObjPoints()); |  | 32048 | ERRWRAP2(retval = _self_->getObjPoints());
| 32097 | return pyopencv_from(retval); |  | 32049 | return pyopencv_from(retval);
| 32098 | } |  | 32050 | }
| 32099 |  |  | 32051 |
| 32100 | return NULL; |  | 32052 | return NULL;
| 32101 | } |  | 32053 | }
| 32102 |  |  | 32054 |
| 32103 | static PyObject* pyopencv_cv_aruco_aruco_Board_getRightBottomCorner(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32055 | static PyObject* pyopencv_cv_aruco_aruco_Board_getRightBottomCorner(PyObject* self, PyObject* py_args, PyObject* kw)
| 32104 | { |  | 32056 | {
| 32105 | using namespace cv::aruco; |  | 32057 | using namespace cv::aruco;
| 32106 |  |  | 32058 |
| 32107 |  |  | 32059 |
| 32108 | cv::aruco::Board * self1 = 0; |  | 32060 | cv::aruco::Board * self1 = 0;
| 32109 | if (!pyopencv_aruco_Board_getp(self, self1)) |  | 32061 | if (!pyopencv_aruco_Board_getp(self, self1))
| 32110 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)"); |  | 32062 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)");
| 32111 | cv::aruco::Board* _self_ = (self1); |  | 32063 | cv::aruco::Board* _self_ = (self1);
| 32112 | Point3f retval; |  | 32064 | Point3f retval;
| 32113 |  |  | 32065 |
| 32114 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32066 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32115 | { |  | 32067 | {
| 32116 | ERRWRAP2(retval = _self_->getRightBottomCorner()); |  | 32068 | ERRWRAP2(retval = _self_->getRightBottomCorner());
| 32117 | return pyopencv_from(retval); |  | 32069 | return pyopencv_from(retval);
| 32118 | } |  | 32070 | }
| 32119 |  |  | 32071 |
| 32120 | return NULL; |  | 32072 | return NULL;
| 32121 | } |  | 32073 | }
| 32122 |  |  | 32074 |
| 32123 | static PyObject* pyopencv_cv_aruco_aruco_Board_matchImagePoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32075 | static PyObject* pyopencv_cv_aruco_aruco_Board_matchImagePoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 32124 | { |  | 32076 | {
| 32125 | using namespace cv::aruco; |  | 32077 | using namespace cv::aruco;
| 32126 |  |  | 32078 |
| 32127 |  |  | 32079 |
| 32128 | cv::aruco::Board * self1 = 0; |  | 32080 | cv::aruco::Board * self1 = 0;
| 32129 | if (!pyopencv_aruco_Board_getp(self, self1)) |  | 32081 | if (!pyopencv_aruco_Board_getp(self, self1))
| 32130 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)"); |  | 32082 | return failmsgp("Incorrect type of self (must be 'aruco_Board' or its derivative)");
| 32131 | cv::aruco::Board* _self_ = (self1); |  | 32083 | cv::aruco::Board* _self_ = (self1);
| 32132 | pyPrepareArgumentConversionErrorsStorage(2); |  | 32084 | pyPrepareArgumentConversionErrorsStorage(2);
| 32133 |  |  | 32085 |
| 32134 | { |  | 32086 | {
| 32135 | PyObject* pyobj_detectedCorners = NULL; |  | 32087 | PyObject* pyobj_detectedCorners = NULL;
| 32136 | vector_Mat detectedCorners; |  | 32088 | vector_Mat detectedCorners;
| 32137 | PyObject* pyobj_detectedIds = NULL; |  | 32089 | PyObject* pyobj_detectedIds = NULL;
| 32138 | Mat detectedIds; |  | 32090 | Mat detectedIds;
| 32139 | PyObject* pyobj_objPoints = NULL; |  | 32091 | PyObject* pyobj_objPoints = NULL;
| 32140 | Mat objPoints; |  | 32092 | Mat objPoints;
| 32141 | PyObject* pyobj_imgPoints = NULL; |  | 32093 | PyObject* pyobj_imgPoints = NULL;
| 32142 | Mat imgPoints; |  | 32094 | Mat imgPoints;
| 32143 |  |  | 32095 |
| 32144 | const char* keywords[] = { "detectedCorners", "detectedIds", "objPoints", "imgPoints", NULL }; |  | 32096 | const char* keywords[] = { "detectedCorners", "detectedIds", "objPoints", "imgPoints", NULL };
| 32145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Board.matchImagePoints", (char**)keywords, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_objPoints, &pyobj_imgPoints) && |  | 32097 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Board.matchImagePoints", (char**)keywords, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_objPoints, &pyobj_imgPoints) &&
| 32146 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 0)) && |  | 32098 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 0)) &&
| 32147 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 0)) && |  | 32099 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 0)) &&
| 32148 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 1)) && |  | 32100 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 1)) &&
| 32149 | pyopencv_to_safe(pyobj_imgPoints, imgPoints, ArgInfo("imgPoints", 1)) ) |  | 32101 | pyopencv_to_safe(pyobj_imgPoints, imgPoints, ArgInfo("imgPoints", 1)) )
| 32150 | { |  | 32102 | {
| 32151 | ERRWRAP2(_self_->matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints)); |  | 32103 | ERRWRAP2(_self_->matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints));
| 32152 | return Py_BuildValue("(NN)", pyopencv_from(objPoints), pyopencv_from(imgPoints)); |  | 32104 | return Py_BuildValue("(NN)", pyopencv_from(objPoints), pyopencv_from(imgPoints));
| 32153 | } |  | 32105 | }
| 32154 |  |  | 32106 |
| 32155 |  |  | 32107 |
| 32156 | pyPopulateArgumentConversionErrors(); |  | 32108 | pyPopulateArgumentConversionErrors();
| 32157 | } |  | 32109 | }
| 32158 |  |  | 32110 |
| 32159 |  |  | 32111 |
| 32160 | { |  | 32112 | {
| 32161 | PyObject* pyobj_detectedCorners = NULL; |  | 32113 | PyObject* pyobj_detectedCorners = NULL;
| 32162 | vector_UMat detectedCorners; |  | 32114 | vector_UMat detectedCorners;
| 32163 | PyObject* pyobj_detectedIds = NULL; |  | 32115 | PyObject* pyobj_detectedIds = NULL;
| 32164 | UMat detectedIds; |  | 32116 | UMat detectedIds;
| 32165 | PyObject* pyobj_objPoints = NULL; |  | 32117 | PyObject* pyobj_objPoints = NULL;
| 32166 | UMat objPoints; |  | 32118 | UMat objPoints;
| 32167 | PyObject* pyobj_imgPoints = NULL; |  | 32119 | PyObject* pyobj_imgPoints = NULL;
| 32168 | UMat imgPoints; |  | 32120 | UMat imgPoints;
| 32169 |  |  | 32121 |
| 32170 | const char* keywords[] = { "detectedCorners", "detectedIds", "objPoints", "imgPoints", NULL }; |  | 32122 | const char* keywords[] = { "detectedCorners", "detectedIds", "objPoints", "imgPoints", NULL };
| 32171 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Board.matchImagePoints", (char**)keywords, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_objPoints, &pyobj_imgPoints) && |  | 32123 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Board.matchImagePoints", (char**)keywords, &pyobj_detectedCorners, &pyobj_detectedIds, &pyobj_objPoints, &pyobj_imgPoints) &&
| 32172 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 0)) && |  | 32124 | pyopencv_to_safe(pyobj_detectedCorners, detectedCorners, ArgInfo("detectedCorners", 0)) &&
| 32173 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 0)) && |  | 32125 | pyopencv_to_safe(pyobj_detectedIds, detectedIds, ArgInfo("detectedIds", 0)) &&
| 32174 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 1)) && |  | 32126 | pyopencv_to_safe(pyobj_objPoints, objPoints, ArgInfo("objPoints", 1)) &&
| 32175 | pyopencv_to_safe(pyobj_imgPoints, imgPoints, ArgInfo("imgPoints", 1)) ) |  | 32127 | pyopencv_to_safe(pyobj_imgPoints, imgPoints, ArgInfo("imgPoints", 1)) )
| 32176 | { |  | 32128 | {
| 32177 | ERRWRAP2(_self_->matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints)); |  | 32129 | ERRWRAP2(_self_->matchImagePoints(detectedCorners, detectedIds, objPoints, imgPoints));
| 32178 | return Py_BuildValue("(NN)", pyopencv_from(objPoints), pyopencv_from(imgPoints)); |  | 32130 | return Py_BuildValue("(NN)", pyopencv_from(objPoints), pyopencv_from(imgPoints));
| 32179 | } |  | 32131 | }
| 32180 |  |  | 32132 |
| 32181 |  |  | 32133 |
| 32182 | pyPopulateArgumentConversionErrors(); |  | 32134 | pyPopulateArgumentConversionErrors();
| 32183 | } |  | 32135 | }
| 32184 | pyRaiseCVOverloadException("matchImagePoints"); |  | 32136 | pyRaiseCVOverloadException("matchImagePoints");
| 32185 |  |  | 32137 |
| 32186 | return NULL; |  | 32138 | return NULL;
| 32187 | } |  | 32139 | }
| 32188 |  |  | 32140 |
| 32189 |  |  | 32141 |
| 32190 |  |  | 32142 |
| 32191 | // Tables (aruco_Board) |  | 32143 | // Tables (aruco_Board)
| 32192 |  |  | 32144 |
| 32193 | static PyGetSetDef pyopencv_aruco_Board_getseters[] = |  | 32145 | static PyGetSetDef pyopencv_aruco_Board_getseters[] =
| 32194 | { |  | 32146 | {
| 32195 | {NULL} /* Sentinel */ |  | 32147 | {NULL} /* Sentinel */
| 32196 | }; |  | 32148 | };
| 32197 |  |  | 32149 |
| 32198 | static PyMethodDef pyopencv_aruco_Board_methods[] = |  | 32150 | static PyMethodDef pyopencv_aruco_Board_methods[] =
| 32199 | { |  | 32151 | {
| 32200 | {"generateImage", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_generateImage, 0), "generateImage(outSize[, img[, marginSize[, borderBits]]]) -> img\n. @brief Draw a planar board\n. *\n. * @param outSize size of the output image in pixels.\n. * @param img output image with the board. The size of this image will be outSize\n. * and the board will be on the center, keeping the board proportions.\n. * @param marginSize minimum margins (in pixels) of the board in the output image\n. * @param borderBits width of the marker borders.\n. *\n. * This function return the image of the board, ready to be printed."}, |  | 32152 | {"generateImage", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_generateImage, 0), "generateImage(outSize[, img[, marginSize[, borderBits]]]) -> img\n. @brief Draw a planar board\n. *\n. * @param outSize size of the output image in pixels.\n. * @param img output image with the board. The size of this image will be outSize\n. * and the board will be on the center, keeping the board proportions.\n. * @param marginSize minimum margins (in pixels) of the board in the output image\n. * @param borderBits width of the marker borders.\n. *\n. * This function return the image of the board, ready to be printed."},
| 32201 | {"getDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getDictionary, 0), "getDictionary() -> retval\n. @brief return the Dictionary of markers employed for this board"}, |  | 32153 | {"getDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getDictionary, 0), "getDictionary() -> retval\n. @brief return the Dictionary of markers employed for this board"},
| 32202 | {"getIds", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getIds, 0), "getIds() -> retval\n. @brief vector of the identifiers of the markers in the board (should be the same size as objPoints)\n. * @return vector of the identifiers of the markers"}, |  | 32154 | {"getIds", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getIds, 0), "getIds() -> retval\n. @brief vector of the identifiers of the markers in the board (should be the same size as objPoints)\n. * @return vector of the identifiers of the markers"},
| 32203 | {"getObjPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getObjPoints, 0), "getObjPoints() -> retval\n. @brief return array of object points of all the marker corners in the board.\n. *\n. * Each marker include its 4 corners in this order:\n. * - objPoints[i][0] - left-top point of i-th marker\n. * - objPoints[i][1] - right-top point of i-th marker\n. * - objPoints[i][2] - right-bottom point of i-th marker\n. * - objPoints[i][3] - left-bottom point of i-th marker\n. *\n. * Markers are placed in a certain order - row by row, left to right in every row. For M markers, the size is Mx4."}, |  | 32155 | {"getObjPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getObjPoints, 0), "getObjPoints() -> retval\n. @brief return array of object points of all the marker corners in the board.\n. *\n. * Each marker include its 4 corners in this order:\n. * - objPoints[i][0] - left-top point of i-th marker\n. * - objPoints[i][1] - right-top point of i-th marker\n. * - objPoints[i][2] - right-bottom point of i-th marker\n. * - objPoints[i][3] - left-bottom point of i-th marker\n. *\n. * Markers are placed in a certain order - row by row, left to right in every row. For M markers, the size is Mx4."},
| 32204 | {"getRightBottomCorner", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getRightBottomCorner, 0), "getRightBottomCorner() -> retval\n. @brief get coordinate of the bottom right corner of the board, is set when calling the function create()"}, |  | 32156 | {"getRightBottomCorner", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_getRightBottomCorner, 0), "getRightBottomCorner() -> retval\n. @brief get coordinate of the bottom right corner of the board, is set when calling the function create()"},
| 32205 | {"matchImagePoints", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_matchImagePoints, 0), "matchImagePoints(detectedCorners, detectedIds[, objPoints[, imgPoints]]) -> objPoints, imgPoints\n. @brief Given a board configuration and a set of detected markers, returns the corresponding\n. * image points and object points, can be used in solvePnP()\n. *\n. * @param detectedCorners List of detected marker corners of the board.\n. * For cv::Board and cv::GridBoard the method expects std::vector<std::vector<Point2f>> or std::vector<Mat> with Aruco marker corners.\n. * For cv::CharucoBoard the method expects std::vector<Point2f> or Mat with ChAruco corners (chess board corners matched with Aruco markers).\n. *\n. * @param detectedIds List of identifiers for each marker or charuco corner.\n. * For any Board class the method expects std::vector<int> or Mat.\n. *\n. * @param objPoints Vector of marker points in the board coordinate space.\n. * For any Board class the method expects std::vector<cv::Point3f> objectPoints or cv::Mat\n. *\n. * @param imgPoints Vector of marker points in the image coordinate space.\n. * For any Board class the method expects std::vector<cv::Point2f> objectPoints or cv::Mat\n. *\n. * @sa solvePnP"}, |  | 32157 | {"matchImagePoints", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Board_matchImagePoints, 0), "matchImagePoints(detectedCorners, detectedIds[, objPoints[, imgPoints]]) -> objPoints, imgPoints\n. @brief Given a board configuration and a set of detected markers, returns the corresponding\n. * image points and object points, can be used in solvePnP()\n. *\n. * @param detectedCorners List of detected marker corners of the board.\n. * For cv::Board and cv::GridBoard the method expects std::vector<std::vector<Point2f>> or std::vector<Mat> with Aruco marker corners.\n. * For cv::CharucoBoard the method expects std::vector<Point2f> or Mat with ChAruco corners (chess board corners matched with Aruco markers).\n. *\n. * @param detectedIds List of identifiers for each marker or charuco corner.\n. * For any Board class the method expects std::vector<int> or Mat.\n. *\n. * @param objPoints Vector of marker points in the board coordinate space.\n. * For any Board class the method expects std::vector<cv::Point3f> objectPoints or cv::Mat\n. *\n. * @param imgPoints Vector of marker points in the image coordinate space.\n. * For any Board class the method expects std::vector<cv::Point2f> objectPoints or cv::Mat\n. *\n. * @sa solvePnP"},
| 32206 |  |  | 32158 |
| 32207 | {NULL, NULL} |  | 32159 | {NULL, NULL}
| 32208 | }; |  | 32160 | };
| 32209 |  |  | 32161 |
| 32210 | // Converter (aruco_Board) |  | 32162 | // Converter (aruco_Board)
| 32211 |  |  | 32163 |
| 32212 | template<> |  | 32164 | template<>
| 32213 | struct PyOpenCV_Converter< cv::aruco::Board > |  | 32165 | struct PyOpenCV_Converter< cv::aruco::Board >
| 32214 | { |  | 32166 | {
| 32215 | static PyObject* from(const cv::aruco::Board& r) |  | 32167 | static PyObject* from(const cv::aruco::Board& r)
| 32216 | { |  | 32168 | {
| 32217 | return pyopencv_aruco_Board_Instance(r); |  | 32169 | return pyopencv_aruco_Board_Instance(r);
| 32218 | } |  | 32170 | }
| 32219 | static bool to(PyObject* src, cv::aruco::Board& dst, const ArgInfo& info) |  | 32171 | static bool to(PyObject* src, cv::aruco::Board& dst, const ArgInfo& info)
| 32220 | { |  | 32172 | {
| 32221 | if(!src || src == Py_None) |  | 32173 | if(!src || src == Py_None)
| 32222 | return true; |  | 32174 | return true;
| 32223 | cv::aruco::Board * dst_; |  | 32175 | cv::aruco::Board * dst_;
| 32224 | if (pyopencv_aruco_Board_getp(src, dst_)) |  | 32176 | if (pyopencv_aruco_Board_getp(src, dst_))
| 32225 | { |  | 32177 | {
| 32226 | dst = *dst_; |  | 32178 | dst = *dst_;
| 32227 | return true; |  | 32179 | return true;
| 32228 | } |  | 32180 | }
| 32229 |  |  | 32181 |
| 32230 | failmsg("Expected cv::aruco::Board for argument '%s'", info.name); |  | 32182 | failmsg("Expected cv::aruco::Board for argument '%s'", info.name);
| 32231 | return false; |  | 32183 | return false;
| 32232 | } |  | 32184 | }
| 32233 | }; |  | 32185 | };
| 32234 |  |  | 32186 |
| 32235 | //================================================================================ |  | 32187 | //================================================================================
| 32236 | // aruco_CharucoBoard (Generic) |  | 32188 | // aruco_CharucoBoard (Generic)
| 32237 | //================================================================================ |  | 32189 | //================================================================================
| 32238 |  |  | 32190 |
| 32239 | // GetSet (aruco_CharucoBoard) |  | 32191 | // GetSet (aruco_CharucoBoard)
| 32240 |  |  | 32192 |
| 32241 |  |  | 32193 |
| 32242 |  |  | 32194 |
| 32243 | // Methods (aruco_CharucoBoard) |  | 32195 | // Methods (aruco_CharucoBoard)
| 32244 |  |  | 32196 |
| 32245 | static int pyopencv_cv_aruco_aruco_CharucoBoard_CharucoBoard(pyopencv_aruco_CharucoBoard_t* self, PyObject* py_args, PyObject* kw) |  | 32197 | static int pyopencv_cv_aruco_aruco_CharucoBoard_CharucoBoard(pyopencv_aruco_CharucoBoard_t* self, PyObject* py_args, PyObject* kw)
| 32246 | { |  | 32198 | {
| 32247 | using namespace cv::aruco; |  | 32199 | using namespace cv::aruco;
| 32248 |  |  | 32200 |
| 32249 | pyPrepareArgumentConversionErrorsStorage(2); |  | 32201 | pyPrepareArgumentConversionErrorsStorage(2);
| 32250 |  |  | 32202 |
| 32251 | { |  | 32203 | {
| 32252 | PyObject* pyobj_size = NULL; |  | 32204 | PyObject* pyobj_size = NULL;
| 32253 | Size size; |  | 32205 | Size size;
| 32254 | PyObject* pyobj_squareLength = NULL; |  | 32206 | PyObject* pyobj_squareLength = NULL;
| 32255 | float squareLength=0.f; |  | 32207 | float squareLength=0.f;
| 32256 | PyObject* pyobj_markerLength = NULL; |  | 32208 | PyObject* pyobj_markerLength = NULL;
| 32257 | float markerLength=0.f; |  | 32209 | float markerLength=0.f;
| 32258 | PyObject* pyobj_dictionary = NULL; |  | 32210 | PyObject* pyobj_dictionary = NULL;
| 32259 | Dictionary dictionary; |  | 32211 | Dictionary dictionary;
| 32260 | PyObject* pyobj_ids = NULL; |  | 32212 | PyObject* pyobj_ids = NULL;
| 32261 | Mat ids; |  | 32213 | Mat ids;
| 32262 |  |  | 32214 |
| 32263 | const char* keywords[] = { "size", "squareLength", "markerLength", "dictionary", "ids", NULL }; |  | 32215 | const char* keywords[] = { "size", "squareLength", "markerLength", "dictionary", "ids", NULL };
| 32264 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:CharucoBoard", (char**)keywords, &pyobj_size, &pyobj_squareLength, &pyobj_markerLength, &pyobj_dictionary, &pyobj_ids) && |  | 32216 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:CharucoBoard", (char**)keywords, &pyobj_size, &pyobj_squareLength, &pyobj_markerLength, &pyobj_dictionary, &pyobj_ids) &&
| 32265 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 32217 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 32266 | pyopencv_to_safe(pyobj_squareLength, squareLength, ArgInfo("squareLength", 0)) && |  | 32218 | pyopencv_to_safe(pyobj_squareLength, squareLength, ArgInfo("squareLength", 0)) &&
| 32267 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) && |  | 32219 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) &&
| 32268 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) && |  | 32220 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) &&
| 32269 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) ) |  | 32221 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) )
| 32270 | { |  | 32222 | {
| 32271 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::CharucoBoard(size, squareLength, markerLength, dictionary, ids)); |  | 32223 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::CharucoBoard(size, squareLength, markerLength, dictionary, ids));
| 32272 | return 0; |  | 32224 | return 0;
| 32273 | } |  | 32225 | }
| 32274 |  |  | 32226 |
| 32275 |  |  | 32227 |
| 32276 | pyPopulateArgumentConversionErrors(); |  | 32228 | pyPopulateArgumentConversionErrors();
| 32277 | } |  | 32229 | }
| 32278 |  |  | 32230 |
| 32279 |  |  | 32231 |
| 32280 | { |  | 32232 | {
| 32281 | PyObject* pyobj_size = NULL; |  | 32233 | PyObject* pyobj_size = NULL;
| 32282 | Size size; |  | 32234 | Size size;
| 32283 | PyObject* pyobj_squareLength = NULL; |  | 32235 | PyObject* pyobj_squareLength = NULL;
| 32284 | float squareLength=0.f; |  | 32236 | float squareLength=0.f;
| 32285 | PyObject* pyobj_markerLength = NULL; |  | 32237 | PyObject* pyobj_markerLength = NULL;
| 32286 | float markerLength=0.f; |  | 32238 | float markerLength=0.f;
| 32287 | PyObject* pyobj_dictionary = NULL; |  | 32239 | PyObject* pyobj_dictionary = NULL;
| 32288 | Dictionary dictionary; |  | 32240 | Dictionary dictionary;
| 32289 | PyObject* pyobj_ids = NULL; |  | 32241 | PyObject* pyobj_ids = NULL;
| 32290 | UMat ids; |  | 32242 | UMat ids;
| 32291 |  |  | 32243 |
| 32292 | const char* keywords[] = { "size", "squareLength", "markerLength", "dictionary", "ids", NULL }; |  | 32244 | const char* keywords[] = { "size", "squareLength", "markerLength", "dictionary", "ids", NULL };
| 32293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:CharucoBoard", (char**)keywords, &pyobj_size, &pyobj_squareLength, &pyobj_markerLength, &pyobj_dictionary, &pyobj_ids) && |  | 32245 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:CharucoBoard", (char**)keywords, &pyobj_size, &pyobj_squareLength, &pyobj_markerLength, &pyobj_dictionary, &pyobj_ids) &&
| 32294 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 32246 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 32295 | pyopencv_to_safe(pyobj_squareLength, squareLength, ArgInfo("squareLength", 0)) && |  | 32247 | pyopencv_to_safe(pyobj_squareLength, squareLength, ArgInfo("squareLength", 0)) &&
| 32296 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) && |  | 32248 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) &&
| 32297 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) && |  | 32249 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) &&
| 32298 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) ) |  | 32250 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) )
| 32299 | { |  | 32251 | {
| 32300 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::CharucoBoard(size, squareLength, markerLength, dictionary, ids)); |  | 32252 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::CharucoBoard(size, squareLength, markerLength, dictionary, ids));
| 32301 | return 0; |  | 32253 | return 0;
| 32302 | } |  | 32254 | }
| 32303 |  |  | 32255 |
| 32304 |  |  | 32256 |
| 32305 | pyPopulateArgumentConversionErrors(); |  | 32257 | pyPopulateArgumentConversionErrors();
| 32306 | } |  | 32258 | }
| 32307 | pyRaiseCVOverloadException("CharucoBoard"); |  | 32259 | pyRaiseCVOverloadException("CharucoBoard");
| 32308 |  |  | 32260 |
| 32309 | return -1; |  | 32261 | return -1;
| 32310 | } |  | 32262 | }
| 32311 |  |  | 32263 |
| 32312 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_checkCharucoCornersCollinear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32264 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_checkCharucoCornersCollinear(PyObject* self, PyObject* py_args, PyObject* kw)
| 32313 | { |  | 32265 | {
| 32314 | using namespace cv::aruco; |  | 32266 | using namespace cv::aruco;
| 32315 |  |  | 32267 |
| 32316 |  |  | 32268 |
| 32317 | cv::aruco::CharucoBoard * self1 = 0; |  | 32269 | cv::aruco::CharucoBoard * self1 = 0;
| 32318 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1)) |  | 32270 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1))
| 32319 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)"); |  | 32271 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)");
| 32320 | cv::aruco::CharucoBoard* _self_ = (self1); |  | 32272 | cv::aruco::CharucoBoard* _self_ = (self1);
| 32321 | pyPrepareArgumentConversionErrorsStorage(2); |  | 32273 | pyPrepareArgumentConversionErrorsStorage(2);
| 32322 |  |  | 32274 |
| 32323 | { |  | 32275 | {
| 32324 | PyObject* pyobj_charucoIds = NULL; |  | 32276 | PyObject* pyobj_charucoIds = NULL;
| 32325 | Mat charucoIds; |  | 32277 | Mat charucoIds;
| 32326 | bool retval; |  | 32278 | bool retval;
| 32327 |  |  | 32279 |
| 32328 | const char* keywords[] = { "charucoIds", NULL }; |  | 32280 | const char* keywords[] = { "charucoIds", NULL };
| 32329 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoBoard.checkCharucoCornersCollinear", (char**)keywords, &pyobj_charucoIds) && |  | 32281 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoBoard.checkCharucoCornersCollinear", (char**)keywords, &pyobj_charucoIds) &&
| 32330 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 0)) ) |  | 32282 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 0)) )
| 32331 | { |  | 32283 | {
| 32332 | ERRWRAP2(retval = _self_->checkCharucoCornersCollinear(charucoIds)); |  | 32284 | ERRWRAP2(retval = _self_->checkCharucoCornersCollinear(charucoIds));
| 32333 | return pyopencv_from(retval); |  | 32285 | return pyopencv_from(retval);
| 32334 | } |  | 32286 | }
| 32335 |  |  | 32287 |
| 32336 |  |  | 32288 |
| 32337 | pyPopulateArgumentConversionErrors(); |  | 32289 | pyPopulateArgumentConversionErrors();
| 32338 | } |  | 32290 | }
| 32339 |  |  | 32291 |
| 32340 |  |  | 32292 |
| 32341 | { |  | 32293 | {
| 32342 | PyObject* pyobj_charucoIds = NULL; |  | 32294 | PyObject* pyobj_charucoIds = NULL;
| 32343 | UMat charucoIds; |  | 32295 | UMat charucoIds;
| 32344 | bool retval; |  | 32296 | bool retval;
| 32345 |  |  | 32297 |
| 32346 | const char* keywords[] = { "charucoIds", NULL }; |  | 32298 | const char* keywords[] = { "charucoIds", NULL };
| 32347 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoBoard.checkCharucoCornersCollinear", (char**)keywords, &pyobj_charucoIds) && |  | 32299 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoBoard.checkCharucoCornersCollinear", (char**)keywords, &pyobj_charucoIds) &&
| 32348 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 0)) ) |  | 32300 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 0)) )
| 32349 | { |  | 32301 | {
| 32350 | ERRWRAP2(retval = _self_->checkCharucoCornersCollinear(charucoIds)); |  | 32302 | ERRWRAP2(retval = _self_->checkCharucoCornersCollinear(charucoIds));
| 32351 | return pyopencv_from(retval); |  | 32303 | return pyopencv_from(retval);
| 32352 | } |  | 32304 | }
| 32353 |  |  | 32305 |
| 32354 |  |  | 32306 |
| 32355 | pyPopulateArgumentConversionErrors(); |  | 32307 | pyPopulateArgumentConversionErrors();
| 32356 | } |  | 32308 | }
| 32357 | pyRaiseCVOverloadException("checkCharucoCornersCollinear"); |  | 32309 | pyRaiseCVOverloadException("checkCharucoCornersCollinear");
| 32358 |  |  | 32310 |
| 32359 | return NULL; |  | 32311 | return NULL;
| 32360 | } |  | 32312 | }
| 32361 |  |  | 32313 |
| 32362 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardCorners(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32314 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardCorners(PyObject* self, PyObject* py_args, PyObject* kw)
| 32363 | { |  | 32315 | {
| 32364 | using namespace cv::aruco; |  | 32316 | using namespace cv::aruco;
| 32365 |  |  | 32317 |
| 32366 |  |  | 32318 |
| 32367 | cv::aruco::CharucoBoard * self1 = 0; |  | 32319 | cv::aruco::CharucoBoard * self1 = 0;
| 32368 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1)) |  | 32320 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1))
| 32369 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)"); |  | 32321 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)");
| 32370 | cv::aruco::CharucoBoard* _self_ = (self1); |  | 32322 | cv::aruco::CharucoBoard* _self_ = (self1);
| 32371 | std::vector<Point3f> retval; |  | 32323 | std::vector<Point3f> retval;
| 32372 |  |  | 32324 |
| 32373 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32374 | { |  | 32326 | {
| 32375 | ERRWRAP2(retval = _self_->getChessboardCorners()); |  | 32327 | ERRWRAP2(retval = _self_->getChessboardCorners());
| 32376 | return pyopencv_from(retval); |  | 32328 | return pyopencv_from(retval);
| 32377 | } |  | 32329 | }
| 32378 |  |  | 32330 |
| 32379 | return NULL; |  | 32331 | return NULL;
| 32380 | } |  | 32332 | }
| 32381 |  |  | 32333 |
| 32382 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32334 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 32383 | { |  | 32335 | {
| 32384 | using namespace cv::aruco; |  | 32336 | using namespace cv::aruco;
| 32385 |  |  | 32337 |
| 32386 |  |  | 32338 |
| 32387 | cv::aruco::CharucoBoard * self1 = 0; |  | 32339 | cv::aruco::CharucoBoard * self1 = 0;
| 32388 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1)) |  | 32340 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1))
| 32389 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)"); |  | 32341 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)");
| 32390 | cv::aruco::CharucoBoard* _self_ = (self1); |  | 32342 | cv::aruco::CharucoBoard* _self_ = (self1);
| 32391 | Size retval; |  | 32343 | Size retval;
| 32392 |  |  | 32344 |
| 32393 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32345 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32394 | { |  | 32346 | {
| 32395 | ERRWRAP2(retval = _self_->getChessboardSize()); |  | 32347 | ERRWRAP2(retval = _self_->getChessboardSize());
| 32396 | return pyopencv_from(retval); |  | 32348 | return pyopencv_from(retval);
| 32397 | } |  | 32349 | }
| 32398 |  |  | 32350 |
| 32399 | return NULL; |  | 32351 | return NULL;
| 32400 | } |  | 32352 | }
| 32401 |  |  | 32353 |
| 32402 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getLegacyPattern(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32354 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getLegacyPattern(PyObject* self, PyObject* py_args, PyObject* kw)
| 32403 | { |  | 32355 | {
| 32404 | using namespace cv::aruco; |  | 32356 | using namespace cv::aruco;
| 32405 |  |  | 32357 |
| 32406 |  |  | 32358 |
| 32407 | cv::aruco::CharucoBoard * self1 = 0; |  | 32359 | cv::aruco::CharucoBoard * self1 = 0;
| 32408 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1)) |  | 32360 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1))
| 32409 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)"); |  | 32361 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)");
| 32410 | cv::aruco::CharucoBoard* _self_ = (self1); |  | 32362 | cv::aruco::CharucoBoard* _self_ = (self1);
| 32411 | bool retval; |  | 32363 | bool retval;
| 32412 |  |  | 32364 |
| 32413 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32365 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32414 | { |  | 32366 | {
| 32415 | ERRWRAP2(retval = _self_->getLegacyPattern()); |  | 32367 | ERRWRAP2(retval = _self_->getLegacyPattern());
| 32416 | return pyopencv_from(retval); |  | 32368 | return pyopencv_from(retval);
| 32417 | } |  | 32369 | }
| 32418 |  |  | 32370 |
| 32419 | return NULL; |  | 32371 | return NULL;
| 32420 | } |  | 32372 | }
| 32421 |  |  | 32373 |
| 32422 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getMarkerLength(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32374 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getMarkerLength(PyObject* self, PyObject* py_args, PyObject* kw)
| 32423 | { |  | 32375 | {
| 32424 | using namespace cv::aruco; |  | 32376 | using namespace cv::aruco;
| 32425 |  |  | 32377 |
| 32426 |  |  | 32378 |
| 32427 | cv::aruco::CharucoBoard * self1 = 0; |  | 32379 | cv::aruco::CharucoBoard * self1 = 0;
| 32428 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1)) |  | 32380 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1))
| 32429 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)"); |  | 32381 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)");
| 32430 | cv::aruco::CharucoBoard* _self_ = (self1); |  | 32382 | cv::aruco::CharucoBoard* _self_ = (self1);
| 32431 | float retval; |  | 32383 | float retval;
| 32432 |  |  | 32384 |
| 32433 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32385 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32434 | { |  | 32386 | {
| 32435 | ERRWRAP2(retval = _self_->getMarkerLength()); |  | 32387 | ERRWRAP2(retval = _self_->getMarkerLength());
| 32436 | return pyopencv_from(retval); |  | 32388 | return pyopencv_from(retval);
| 32437 | } |  | 32389 | }
| 32438 |  |  | 32390 |
| 32439 | return NULL; |  | 32391 | return NULL;
| 32440 | } |  | 32392 | }
| 32441 |  |  | 32393 |
| 32442 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getSquareLength(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32394 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_getSquareLength(PyObject* self, PyObject* py_args, PyObject* kw)
| 32443 | { |  | 32395 | {
| 32444 | using namespace cv::aruco; |  | 32396 | using namespace cv::aruco;
| 32445 |  |  | 32397 |
| 32446 |  |  | 32398 |
| 32447 | cv::aruco::CharucoBoard * self1 = 0; |  | 32399 | cv::aruco::CharucoBoard * self1 = 0;
| 32448 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1)) |  | 32400 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1))
| 32449 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)"); |  | 32401 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)");
| 32450 | cv::aruco::CharucoBoard* _self_ = (self1); |  | 32402 | cv::aruco::CharucoBoard* _self_ = (self1);
| 32451 | float retval; |  | 32403 | float retval;
| 32452 |  |  | 32404 |
| 32453 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32405 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32454 | { |  | 32406 | {
| 32455 | ERRWRAP2(retval = _self_->getSquareLength()); |  | 32407 | ERRWRAP2(retval = _self_->getSquareLength());
| 32456 | return pyopencv_from(retval); |  | 32408 | return pyopencv_from(retval);
| 32457 | } |  | 32409 | }
| 32458 |  |  | 32410 |
| 32459 | return NULL; |  | 32411 | return NULL;
| 32460 | } |  | 32412 | }
| 32461 |  |  | 32413 |
| 32462 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_setLegacyPattern(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32414 | static PyObject* pyopencv_cv_aruco_aruco_CharucoBoard_setLegacyPattern(PyObject* self, PyObject* py_args, PyObject* kw)
| 32463 | { |  | 32415 | {
| 32464 | using namespace cv::aruco; |  | 32416 | using namespace cv::aruco;
| 32465 |  |  | 32417 |
| 32466 |  |  | 32418 |
| 32467 | cv::aruco::CharucoBoard * self1 = 0; |  | 32419 | cv::aruco::CharucoBoard * self1 = 0;
| 32468 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1)) |  | 32420 | if (!pyopencv_aruco_CharucoBoard_getp(self, self1))
| 32469 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)"); |  | 32421 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoBoard' or its derivative)");
| 32470 | cv::aruco::CharucoBoard* _self_ = (self1); |  | 32422 | cv::aruco::CharucoBoard* _self_ = (self1);
| 32471 | PyObject* pyobj_legacyPattern = NULL; |  | 32423 | PyObject* pyobj_legacyPattern = NULL;
| 32472 | bool legacyPattern=0; |  | 32424 | bool legacyPattern=0;
| 32473 |  |  | 32425 |
| 32474 | const char* keywords[] = { "legacyPattern", NULL }; |  | 32426 | const char* keywords[] = { "legacyPattern", NULL };
| 32475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoBoard.setLegacyPattern", (char**)keywords, &pyobj_legacyPattern) && |  | 32427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoBoard.setLegacyPattern", (char**)keywords, &pyobj_legacyPattern) &&
| 32476 | pyopencv_to_safe(pyobj_legacyPattern, legacyPattern, ArgInfo("legacyPattern", 0)) ) |  | 32428 | pyopencv_to_safe(pyobj_legacyPattern, legacyPattern, ArgInfo("legacyPattern", 0)) )
| 32477 | { |  | 32429 | {
| 32478 | ERRWRAP2(_self_->setLegacyPattern(legacyPattern)); |  | 32430 | ERRWRAP2(_self_->setLegacyPattern(legacyPattern));
| 32479 | Py_RETURN_NONE; |  | 32431 | Py_RETURN_NONE;
| 32480 | } |  | 32432 | }
| 32481 |  |  | 32433 |
| 32482 | return NULL; |  | 32434 | return NULL;
| 32483 | } |  | 32435 | }
| 32484 |  |  | 32436 |
| 32485 |  |  | 32437 |
| 32486 |  |  | 32438 |
| 32487 | // Tables (aruco_CharucoBoard) |  | 32439 | // Tables (aruco_CharucoBoard)
| 32488 |  |  | 32440 |
| 32489 | static PyGetSetDef pyopencv_aruco_CharucoBoard_getseters[] = |  | 32441 | static PyGetSetDef pyopencv_aruco_CharucoBoard_getseters[] =
| 32490 | { |  | 32442 | {
| 32491 | {NULL} /* Sentinel */ |  | 32443 | {NULL} /* Sentinel */
| 32492 | }; |  | 32444 | };
| 32493 |  |  | 32445 |
| 32494 | static PyMethodDef pyopencv_aruco_CharucoBoard_methods[] = |  | 32446 | static PyMethodDef pyopencv_aruco_CharucoBoard_methods[] =
| 32495 | { |  | 32447 | {
| 32496 | {"checkCharucoCornersCollinear", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_checkCharucoCornersCollinear, 0), "checkCharucoCornersCollinear(charucoIds) -> retval\n. @brief check whether the ChArUco markers are collinear\n. *\n. * @param charucoIds list of identifiers for each corner in charucoCorners per frame.\n. * @return bool value, 1 (true) if detected corners form a line, 0 (false) if they do not.\n. * solvePnP, calibration functions will fail if the corners are collinear (true).\n. *\n. * The number of ids in charucoIDs should be <= the number of chessboard corners in the board.\n. * This functions checks whether the charuco corners are on a straight line (returns true, if so), or not (false).\n. * Axis parallel, as well as diagonal and other straight lines detected. Degenerate cases:\n. * for number of charucoIDs <= 2,the function returns true."}, |  | 32448 | {"checkCharucoCornersCollinear", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_checkCharucoCornersCollinear, 0), "checkCharucoCornersCollinear(charucoIds) -> retval\n. @brief check whether the ChArUco markers are collinear\n. *\n. * @param charucoIds list of identifiers for each corner in charucoCorners per frame.\n. * @return bool value, 1 (true) if detected corners form a line, 0 (false) if they do not.\n. * solvePnP, calibration functions will fail if the corners are collinear (true).\n. *\n. * The number of ids in charucoIDs should be <= the number of chessboard corners in the board.\n. * This functions checks whether the charuco corners are on a straight line (returns true, if so), or not (false).\n. * Axis parallel, as well as diagonal and other straight lines detected. Degenerate cases:\n. * for number of charucoIDs <= 2,the function returns true."},
| 32497 | {"getChessboardCorners", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardCorners, 0), "getChessboardCorners() -> retval\n. @brief get CharucoBoard::chessboardCorners"}, |  | 32449 | {"getChessboardCorners", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardCorners, 0), "getChessboardCorners() -> retval\n. @brief get CharucoBoard::chessboardCorners"},
| 32498 | {"getChessboardSize", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardSize, 0), "getChessboardSize() -> retval\n."}, |  | 32450 | {"getChessboardSize", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getChessboardSize, 0), "getChessboardSize() -> retval\n."},
| 32499 | {"getLegacyPattern", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getLegacyPattern, 0), "getLegacyPattern() -> retval\n."}, |  | 32451 | {"getLegacyPattern", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getLegacyPattern, 0), "getLegacyPattern() -> retval\n."},
| 32500 | {"getMarkerLength", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getMarkerLength, 0), "getMarkerLength() -> retval\n."}, |  | 32452 | {"getMarkerLength", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getMarkerLength, 0), "getMarkerLength() -> retval\n."},
| 32501 | {"getSquareLength", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getSquareLength, 0), "getSquareLength() -> retval\n."}, |  | 32453 | {"getSquareLength", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_getSquareLength, 0), "getSquareLength() -> retval\n."},
| 32502 | {"setLegacyPattern", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_setLegacyPattern, 0), "setLegacyPattern(legacyPattern) -> None\n. @brief set legacy chessboard pattern.\n. *\n. * Legacy setting creates chessboard patterns starting with a white box in the upper left corner\n. * if there is an even row count of chessboard boxes, otherwise it starts with a black box.\n. * This setting ensures compatibility to patterns created with OpenCV versions prior OpenCV 4.6.0.\n. * See https://github.com/opencv/opencv/issues/23152.\n. *\n. * Default value: false."}, |  | 32454 | {"setLegacyPattern", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoBoard_setLegacyPattern, 0), "setLegacyPattern(legacyPattern) -> None\n. @brief set legacy chessboard pattern.\n. *\n. * Legacy setting creates chessboard patterns starting with a white box in the upper left corner\n. * if there is an even row count of chessboard boxes, otherwise it starts with a black box.\n. * This setting ensures compatibility to patterns created with OpenCV versions prior OpenCV 4.6.0.\n. * See https://github.com/opencv/opencv/issues/23152.\n. *\n. * Default value: false."},
| 32503 |  |  | 32455 |
| 32504 | {NULL, NULL} |  | 32456 | {NULL, NULL}
| 32505 | }; |  | 32457 | };
| 32506 |  |  | 32458 |
| 32507 | // Converter (aruco_CharucoBoard) |  | 32459 | // Converter (aruco_CharucoBoard)
| 32508 |  |  | 32460 |
| 32509 | template<> |  | 32461 | template<>
| 32510 | struct PyOpenCV_Converter< cv::aruco::CharucoBoard > |  | 32462 | struct PyOpenCV_Converter< cv::aruco::CharucoBoard >
| 32511 | { |  | 32463 | {
| 32512 | static PyObject* from(const cv::aruco::CharucoBoard& r) |  | 32464 | static PyObject* from(const cv::aruco::CharucoBoard& r)
| 32513 | { |  | 32465 | {
| 32514 | return pyopencv_aruco_CharucoBoard_Instance(r); |  | 32466 | return pyopencv_aruco_CharucoBoard_Instance(r);
| 32515 | } |  | 32467 | }
| 32516 | static bool to(PyObject* src, cv::aruco::CharucoBoard& dst, const ArgInfo& info) |  | 32468 | static bool to(PyObject* src, cv::aruco::CharucoBoard& dst, const ArgInfo& info)
| 32517 | { |  | 32469 | {
| 32518 | if(!src || src == Py_None) |  | 32470 | if(!src || src == Py_None)
| 32519 | return true; |  | 32471 | return true;
| 32520 | cv::aruco::CharucoBoard * dst_; |  | 32472 | cv::aruco::CharucoBoard * dst_;
| 32521 | if (pyopencv_aruco_CharucoBoard_getp(src, dst_)) |  | 32473 | if (pyopencv_aruco_CharucoBoard_getp(src, dst_))
| 32522 | { |  | 32474 | {
| 32523 | dst = *dst_; |  | 32475 | dst = *dst_;
| 32524 | return true; |  | 32476 | return true;
| 32525 | } |  | 32477 | }
| 32526 |  |  | 32478 |
| 32527 | failmsg("Expected cv::aruco::CharucoBoard for argument '%s'", info.name); |  | 32479 | failmsg("Expected cv::aruco::CharucoBoard for argument '%s'", info.name);
| 32528 | return false; |  | 32480 | return false;
| 32529 | } |  | 32481 | }
| 32530 | }; |  | 32482 | };
| 32531 |  |  | 32483 |
| 32532 | //================================================================================ |  | 32484 | //================================================================================
| 32533 | // aruco_CharucoDetector (Generic) |  | 32485 | // aruco_CharucoDetector (Generic)
| 32534 | //================================================================================ |  | 32486 | //================================================================================
| 32535 |  |  | 32487 |
| 32536 | // GetSet (aruco_CharucoDetector) |  | 32488 | // GetSet (aruco_CharucoDetector)
| 32537 |  |  | 32489 |
| 32538 |  |  | 32490 |
| 32539 |  |  | 32491 |
| 32540 | // Methods (aruco_CharucoDetector) |  | 32492 | // Methods (aruco_CharucoDetector)
| 32541 |  |  | 32493 |
| 32542 | static int pyopencv_cv_aruco_aruco_CharucoDetector_CharucoDetector(pyopencv_aruco_CharucoDetector_t* self, PyObject* py_args, PyObject* kw) |  | 32494 | static int pyopencv_cv_aruco_aruco_CharucoDetector_CharucoDetector(pyopencv_aruco_CharucoDetector_t* self, PyObject* py_args, PyObject* kw)
| 32543 | { |  | 32495 | {
| 32544 | using namespace cv::aruco; |  | 32496 | using namespace cv::aruco;
| 32545 |  |  | 32497 |
| 32546 | PyObject* pyobj_board = NULL; |  | 32498 | PyObject* pyobj_board = NULL;
| 32547 | CharucoBoard board; |  | 32499 | CharucoBoard board;
| 32548 | PyObject* pyobj_charucoParams = NULL; |  | 32500 | PyObject* pyobj_charucoParams = NULL;
| 32549 | CharucoParameters charucoParams; |  | 32501 | CharucoParameters charucoParams;
| 32550 | PyObject* pyobj_detectorParams = NULL; |  | 32502 | PyObject* pyobj_detectorParams = NULL;
| 32551 | DetectorParameters detectorParams; |  | 32503 | DetectorParameters detectorParams;
| 32552 | PyObject* pyobj_refineParams = NULL; |  | 32504 | PyObject* pyobj_refineParams = NULL;
| 32553 | RefineParameters refineParams; |  | 32505 | RefineParameters refineParams;
| 32554 |  |  | 32506 |
| 32555 | const char* keywords[] = { "board", "charucoParams", "detectorParams", "refineParams", NULL }; |  | 32507 | const char* keywords[] = { "board", "charucoParams", "detectorParams", "refineParams", NULL };
| 32556 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:CharucoDetector", (char**)keywords, &pyobj_board, &pyobj_charucoParams, &pyobj_detectorParams, &pyobj_refineParams) && |  | 32508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:CharucoDetector", (char**)keywords, &pyobj_board, &pyobj_charucoParams, &pyobj_detectorParams, &pyobj_refineParams) &&
| 32557 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) && |  | 32509 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) &&
| 32558 | pyopencv_to_safe(pyobj_charucoParams, charucoParams, ArgInfo("charucoParams", 0)) && |  | 32510 | pyopencv_to_safe(pyobj_charucoParams, charucoParams, ArgInfo("charucoParams", 0)) &&
| 32559 | pyopencv_to_safe(pyobj_detectorParams, detectorParams, ArgInfo("detectorParams", 0)) && |  | 32511 | pyopencv_to_safe(pyobj_detectorParams, detectorParams, ArgInfo("detectorParams", 0)) &&
| 32560 | pyopencv_to_safe(pyobj_refineParams, refineParams, ArgInfo("refineParams", 0)) ) |  | 32512 | pyopencv_to_safe(pyobj_refineParams, refineParams, ArgInfo("refineParams", 0)) )
| 32561 | { |  | 32513 | {
| 32562 | new (&(self->v)) Ptr<cv::aruco::CharucoDetector>(); // init Ptr with placement new |  | 32514 | new (&(self->v)) Ptr<cv::aruco::CharucoDetector>(); // init Ptr with placement new
| 32563 | if(self) ERRWRAP2(self->v.reset(new cv::aruco::CharucoDetector(board, charucoParams, detectorParams, refineParams))); |  | 32515 | if(self) ERRWRAP2(self->v.reset(new cv::aruco::CharucoDetector(board, charucoParams, detectorParams, refineParams)));
| 32564 | return 0; |  | 32516 | return 0;
| 32565 | } |  | 32517 | }
| 32566 |  |  | 32518 |
| 32567 | return -1; |  | 32519 | return -1;
| 32568 | } |  | 32520 | }
| 32569 |  |  | 32521 |
| 32570 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_detectBoard(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32522 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_detectBoard(PyObject* self, PyObject* py_args, PyObject* kw)
| 32571 | { |  | 32523 | {
| 32572 | using namespace cv::aruco; |  | 32524 | using namespace cv::aruco;
| 32573 |  |  | 32525 |
| 32574 |  |  | 32526 |
| 32575 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32527 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32576 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32528 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32577 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32529 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32578 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32530 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32579 | pyPrepareArgumentConversionErrorsStorage(2); |  | 32531 | pyPrepareArgumentConversionErrorsStorage(2);
| 32580 |  |  | 32532 |
| 32581 | { |  | 32533 | {
| 32582 | PyObject* pyobj_image = NULL; |  | 32534 | PyObject* pyobj_image = NULL;
| 32583 | Mat image; |  | 32535 | Mat image;
| 32584 | PyObject* pyobj_charucoCorners = NULL; |  | 32536 | PyObject* pyobj_charucoCorners = NULL;
| 32585 | Mat charucoCorners; |  | 32537 | Mat charucoCorners;
| 32586 | PyObject* pyobj_charucoIds = NULL; |  | 32538 | PyObject* pyobj_charucoIds = NULL;
| 32587 | Mat charucoIds; |  | 32539 | Mat charucoIds;
| 32588 | PyObject* pyobj_markerCorners = NULL; |  | 32540 | PyObject* pyobj_markerCorners = NULL;
| 32589 | vector_Mat markerCorners; |  | 32541 | vector_Mat markerCorners;
| 32590 | PyObject* pyobj_markerIds = NULL; |  | 32542 | PyObject* pyobj_markerIds = NULL;
| 32591 | Mat markerIds; |  | 32543 | Mat markerIds;
| 32592 |  |  | 32544 |
| 32593 | const char* keywords[] = { "image", "charucoCorners", "charucoIds", "markerCorners", "markerIds", NULL }; |  | 32545 | const char* keywords[] = { "image", "charucoCorners", "charucoIds", "markerCorners", "markerIds", NULL };
| 32594 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectBoard", (char**)keywords, &pyobj_image, &pyobj_charucoCorners, &pyobj_charucoIds, &pyobj_markerCorners, &pyobj_markerIds) && |  | 32546 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectBoard", (char**)keywords, &pyobj_image, &pyobj_charucoCorners, &pyobj_charucoIds, &pyobj_markerCorners, &pyobj_markerIds) &&
| 32595 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 32547 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 32596 | pyopencv_to_safe(pyobj_charucoCorners, charucoCorners, ArgInfo("charucoCorners", 1)) && |  | 32548 | pyopencv_to_safe(pyobj_charucoCorners, charucoCorners, ArgInfo("charucoCorners", 1)) &&
| 32597 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 1)) && |  | 32549 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 1)) &&
| 32598 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) && |  | 32550 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) &&
| 32599 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) ) |  | 32551 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) )
| 32600 | { |  | 32552 | {
| 32601 | ERRWRAP2(_self_->detectBoard(image, charucoCorners, charucoIds, markerCorners, markerIds)); |  | 32553 | ERRWRAP2(_self_->detectBoard(image, charucoCorners, charucoIds, markerCorners, markerIds));
| 32602 | return Py_BuildValue("(NNNN)", pyopencv_from(charucoCorners), pyopencv_from(charucoIds), pyopencv_from(markerCorners), pyopencv_from(markerIds)); |  | 32554 | return Py_BuildValue("(NNNN)", pyopencv_from(charucoCorners), pyopencv_from(charucoIds), pyopencv_from(markerCorners), pyopencv_from(markerIds));
| 32603 | } |  | 32555 | }
| 32604 |  |  | 32556 |
| 32605 |  |  | 32557 |
| 32606 | pyPopulateArgumentConversionErrors(); |  | 32558 | pyPopulateArgumentConversionErrors();
| 32607 | } |  | 32559 | }
| 32608 |  |  | 32560 |
| 32609 |  |  | 32561 |
| 32610 | { |  | 32562 | {
| 32611 | PyObject* pyobj_image = NULL; |  | 32563 | PyObject* pyobj_image = NULL;
| 32612 | UMat image; |  | 32564 | UMat image;
| 32613 | PyObject* pyobj_charucoCorners = NULL; |  | 32565 | PyObject* pyobj_charucoCorners = NULL;
| 32614 | UMat charucoCorners; |  | 32566 | UMat charucoCorners;
| 32615 | PyObject* pyobj_charucoIds = NULL; |  | 32567 | PyObject* pyobj_charucoIds = NULL;
| 32616 | UMat charucoIds; |  | 32568 | UMat charucoIds;
| 32617 | PyObject* pyobj_markerCorners = NULL; |  | 32569 | PyObject* pyobj_markerCorners = NULL;
| 32618 | vector_UMat markerCorners; |  | 32570 | vector_UMat markerCorners;
| 32619 | PyObject* pyobj_markerIds = NULL; |  | 32571 | PyObject* pyobj_markerIds = NULL;
| 32620 | UMat markerIds; |  | 32572 | UMat markerIds;
| 32621 |  |  | 32573 |
| 32622 | const char* keywords[] = { "image", "charucoCorners", "charucoIds", "markerCorners", "markerIds", NULL }; |  | 32574 | const char* keywords[] = { "image", "charucoCorners", "charucoIds", "markerCorners", "markerIds", NULL };
| 32623 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectBoard", (char**)keywords, &pyobj_image, &pyobj_charucoCorners, &pyobj_charucoIds, &pyobj_markerCorners, &pyobj_markerIds) && |  | 32575 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectBoard", (char**)keywords, &pyobj_image, &pyobj_charucoCorners, &pyobj_charucoIds, &pyobj_markerCorners, &pyobj_markerIds) &&
| 32624 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 32576 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 32625 | pyopencv_to_safe(pyobj_charucoCorners, charucoCorners, ArgInfo("charucoCorners", 1)) && |  | 32577 | pyopencv_to_safe(pyobj_charucoCorners, charucoCorners, ArgInfo("charucoCorners", 1)) &&
| 32626 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 1)) && |  | 32578 | pyopencv_to_safe(pyobj_charucoIds, charucoIds, ArgInfo("charucoIds", 1)) &&
| 32627 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) && |  | 32579 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) &&
| 32628 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) ) |  | 32580 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) )
| 32629 | { |  | 32581 | {
| 32630 | ERRWRAP2(_self_->detectBoard(image, charucoCorners, charucoIds, markerCorners, markerIds)); |  | 32582 | ERRWRAP2(_self_->detectBoard(image, charucoCorners, charucoIds, markerCorners, markerIds));
| 32631 | return Py_BuildValue("(NNNN)", pyopencv_from(charucoCorners), pyopencv_from(charucoIds), pyopencv_from(markerCorners), pyopencv_from(markerIds)); |  | 32583 | return Py_BuildValue("(NNNN)", pyopencv_from(charucoCorners), pyopencv_from(charucoIds), pyopencv_from(markerCorners), pyopencv_from(markerIds));
| 32632 | } |  | 32584 | }
| 32633 |  |  | 32585 |
| 32634 |  |  | 32586 |
| 32635 | pyPopulateArgumentConversionErrors(); |  | 32587 | pyPopulateArgumentConversionErrors();
| 32636 | } |  | 32588 | }
| 32637 | pyRaiseCVOverloadException("detectBoard"); |  | 32589 | pyRaiseCVOverloadException("detectBoard");
| 32638 |  |  | 32590 |
| 32639 | return NULL; |  | 32591 | return NULL;
| 32640 | } |  | 32592 | }
| 32641 |  |  | 32593 |
| 32642 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_detectDiamonds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32594 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_detectDiamonds(PyObject* self, PyObject* py_args, PyObject* kw)
| 32643 | { |  | 32595 | {
| 32644 | using namespace cv::aruco; |  | 32596 | using namespace cv::aruco;
| 32645 |  |  | 32597 |
| 32646 |  |  | 32598 |
| 32647 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32599 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32648 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32600 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32649 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32601 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32650 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32602 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32651 | pyPrepareArgumentConversionErrorsStorage(2); |  | 32603 | pyPrepareArgumentConversionErrorsStorage(2);
| 32652 |  |  | 32604 |
| 32653 | { |  | 32605 | {
| 32654 | PyObject* pyobj_image = NULL; |  | 32606 | PyObject* pyobj_image = NULL;
| 32655 | Mat image; |  | 32607 | Mat image;
| 32656 | PyObject* pyobj_diamondCorners = NULL; |  | 32608 | PyObject* pyobj_diamondCorners = NULL;
| 32657 | vector_Mat diamondCorners; |  | 32609 | vector_Mat diamondCorners;
| 32658 | PyObject* pyobj_diamondIds = NULL; |  | 32610 | PyObject* pyobj_diamondIds = NULL;
| 32659 | Mat diamondIds; |  | 32611 | Mat diamondIds;
| 32660 | PyObject* pyobj_markerCorners = NULL; |  | 32612 | PyObject* pyobj_markerCorners = NULL;
| 32661 | vector_Mat markerCorners; |  | 32613 | vector_Mat markerCorners;
| 32662 | PyObject* pyobj_markerIds = NULL; |  | 32614 | PyObject* pyobj_markerIds = NULL;
| 32663 | Mat markerIds; |  | 32615 | Mat markerIds;
| 32664 |  |  | 32616 |
| 32665 | const char* keywords[] = { "image", "diamondCorners", "diamondIds", "markerCorners", "markerIds", NULL }; |  | 32617 | const char* keywords[] = { "image", "diamondCorners", "diamondIds", "markerCorners", "markerIds", NULL };
| 32666 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectDiamonds", (char**)keywords, &pyobj_image, &pyobj_diamondCorners, &pyobj_diamondIds, &pyobj_markerCorners, &pyobj_markerIds) && |  | 32618 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectDiamonds", (char**)keywords, &pyobj_image, &pyobj_diamondCorners, &pyobj_diamondIds, &pyobj_markerCorners, &pyobj_markerIds) &&
| 32667 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 32619 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 32668 | pyopencv_to_safe(pyobj_diamondCorners, diamondCorners, ArgInfo("diamondCorners", 1)) && |  | 32620 | pyopencv_to_safe(pyobj_diamondCorners, diamondCorners, ArgInfo("diamondCorners", 1)) &&
| 32669 | pyopencv_to_safe(pyobj_diamondIds, diamondIds, ArgInfo("diamondIds", 1)) && |  | 32621 | pyopencv_to_safe(pyobj_diamondIds, diamondIds, ArgInfo("diamondIds", 1)) &&
| 32670 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) && |  | 32622 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) &&
| 32671 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) ) |  | 32623 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) )
| 32672 | { |  | 32624 | {
| 32673 | ERRWRAP2(_self_->detectDiamonds(image, diamondCorners, diamondIds, markerCorners, markerIds)); |  | 32625 | ERRWRAP2(_self_->detectDiamonds(image, diamondCorners, diamondIds, markerCorners, markerIds));
| 32674 | return Py_BuildValue("(NNNN)", pyopencv_from(diamondCorners), pyopencv_from(diamondIds), pyopencv_from(markerCorners), pyopencv_from(markerIds)); |  | 32626 | return Py_BuildValue("(NNNN)", pyopencv_from(diamondCorners), pyopencv_from(diamondIds), pyopencv_from(markerCorners), pyopencv_from(markerIds));
| 32675 | } |  | 32627 | }
| 32676 |  |  | 32628 |
| 32677 |  |  | 32629 |
| 32678 | pyPopulateArgumentConversionErrors(); |  | 32630 | pyPopulateArgumentConversionErrors();
| 32679 | } |  | 32631 | }
| 32680 |  |  | 32632 |
| 32681 |  |  | 32633 |
| 32682 | { |  | 32634 | {
| 32683 | PyObject* pyobj_image = NULL; |  | 32635 | PyObject* pyobj_image = NULL;
| 32684 | UMat image; |  | 32636 | UMat image;
| 32685 | PyObject* pyobj_diamondCorners = NULL; |  | 32637 | PyObject* pyobj_diamondCorners = NULL;
| 32686 | vector_UMat diamondCorners; |  | 32638 | vector_UMat diamondCorners;
| 32687 | PyObject* pyobj_diamondIds = NULL; |  | 32639 | PyObject* pyobj_diamondIds = NULL;
| 32688 | UMat diamondIds; |  | 32640 | UMat diamondIds;
| 32689 | PyObject* pyobj_markerCorners = NULL; |  | 32641 | PyObject* pyobj_markerCorners = NULL;
| 32690 | vector_UMat markerCorners; |  | 32642 | vector_UMat markerCorners;
| 32691 | PyObject* pyobj_markerIds = NULL; |  | 32643 | PyObject* pyobj_markerIds = NULL;
| 32692 | UMat markerIds; |  | 32644 | UMat markerIds;
| 32693 |  |  | 32645 |
| 32694 | const char* keywords[] = { "image", "diamondCorners", "diamondIds", "markerCorners", "markerIds", NULL }; |  | 32646 | const char* keywords[] = { "image", "diamondCorners", "diamondIds", "markerCorners", "markerIds", NULL };
| 32695 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectDiamonds", (char**)keywords, &pyobj_image, &pyobj_diamondCorners, &pyobj_diamondIds, &pyobj_markerCorners, &pyobj_markerIds) && |  | 32647 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOO:aruco_CharucoDetector.detectDiamonds", (char**)keywords, &pyobj_image, &pyobj_diamondCorners, &pyobj_diamondIds, &pyobj_markerCorners, &pyobj_markerIds) &&
| 32696 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 32648 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 32697 | pyopencv_to_safe(pyobj_diamondCorners, diamondCorners, ArgInfo("diamondCorners", 1)) && |  | 32649 | pyopencv_to_safe(pyobj_diamondCorners, diamondCorners, ArgInfo("diamondCorners", 1)) &&
| 32698 | pyopencv_to_safe(pyobj_diamondIds, diamondIds, ArgInfo("diamondIds", 1)) && |  | 32650 | pyopencv_to_safe(pyobj_diamondIds, diamondIds, ArgInfo("diamondIds", 1)) &&
| 32699 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) && |  | 32651 | pyopencv_to_safe(pyobj_markerCorners, markerCorners, ArgInfo("markerCorners", 1)) &&
| 32700 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) ) |  | 32652 | pyopencv_to_safe(pyobj_markerIds, markerIds, ArgInfo("markerIds", 1)) )
| 32701 | { |  | 32653 | {
| 32702 | ERRWRAP2(_self_->detectDiamonds(image, diamondCorners, diamondIds, markerCorners, markerIds)); |  | 32654 | ERRWRAP2(_self_->detectDiamonds(image, diamondCorners, diamondIds, markerCorners, markerIds));
| 32703 | return Py_BuildValue("(NNNN)", pyopencv_from(diamondCorners), pyopencv_from(diamondIds), pyopencv_from(markerCorners), pyopencv_from(markerIds)); |  | 32655 | return Py_BuildValue("(NNNN)", pyopencv_from(diamondCorners), pyopencv_from(diamondIds), pyopencv_from(markerCorners), pyopencv_from(markerIds));
| 32704 | } |  | 32656 | }
| 32705 |  |  | 32657 |
| 32706 |  |  | 32658 |
| 32707 | pyPopulateArgumentConversionErrors(); |  | 32659 | pyPopulateArgumentConversionErrors();
| 32708 | } |  | 32660 | }
| 32709 | pyRaiseCVOverloadException("detectDiamonds"); |  | 32661 | pyRaiseCVOverloadException("detectDiamonds");
| 32710 |  |  | 32662 |
| 32711 | return NULL; |  | 32663 | return NULL;
| 32712 | } |  | 32664 | }
| 32713 |  |  | 32665 |
| 32714 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getBoard(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32666 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getBoard(PyObject* self, PyObject* py_args, PyObject* kw)
| 32715 | { |  | 32667 | {
| 32716 | using namespace cv::aruco; |  | 32668 | using namespace cv::aruco;
| 32717 |  |  | 32669 |
| 32718 |  |  | 32670 |
| 32719 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32671 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32720 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32672 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32721 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32673 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32722 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32674 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32723 | CharucoBoard retval; |  | 32675 | CharucoBoard retval;
| 32724 |  |  | 32676 |
| 32725 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32677 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32726 | { |  | 32678 | {
| 32727 | ERRWRAP2(retval = _self_->getBoard()); |  | 32679 | ERRWRAP2(retval = _self_->getBoard());
| 32728 | return pyopencv_from(retval); |  | 32680 | return pyopencv_from(retval);
| 32729 | } |  | 32681 | }
| 32730 |  |  | 32682 |
| 32731 | return NULL; |  | 32683 | return NULL;
| 32732 | } |  | 32684 | }
| 32733 |  |  | 32685 |
| 32734 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getCharucoParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32686 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getCharucoParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 32735 | { |  | 32687 | {
| 32736 | using namespace cv::aruco; |  | 32688 | using namespace cv::aruco;
| 32737 |  |  | 32689 |
| 32738 |  |  | 32690 |
| 32739 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32691 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32740 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32692 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32741 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32693 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32742 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32694 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32743 | CharucoParameters retval; |  | 32695 | CharucoParameters retval;
| 32744 |  |  | 32696 |
| 32745 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32697 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32746 | { |  | 32698 | {
| 32747 | ERRWRAP2(retval = _self_->getCharucoParameters()); |  | 32699 | ERRWRAP2(retval = _self_->getCharucoParameters());
| 32748 | return pyopencv_from(retval); |  | 32700 | return pyopencv_from(retval);
| 32749 | } |  | 32701 | }
| 32750 |  |  | 32702 |
| 32751 | return NULL; |  | 32703 | return NULL;
| 32752 | } |  | 32704 | }
| 32753 |  |  | 32705 |
| 32754 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32706 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 32755 | { |  | 32707 | {
| 32756 | using namespace cv::aruco; |  | 32708 | using namespace cv::aruco;
| 32757 |  |  | 32709 |
| 32758 |  |  | 32710 |
| 32759 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32711 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32760 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32712 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32761 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32713 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32762 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32714 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32763 | DetectorParameters retval; |  | 32715 | DetectorParameters retval;
| 32764 |  |  | 32716 |
| 32765 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32717 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32766 | { |  | 32718 | {
| 32767 | ERRWRAP2(retval = _self_->getDetectorParameters()); |  | 32719 | ERRWRAP2(retval = _self_->getDetectorParameters());
| 32768 | return pyopencv_from(retval); |  | 32720 | return pyopencv_from(retval);
| 32769 | } |  | 32721 | }
| 32770 |  |  | 32722 |
| 32771 | return NULL; |  | 32723 | return NULL;
| 32772 | } |  | 32724 | }
| 32773 |  |  | 32725 |
| 32774 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32726 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_getRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 32775 | { |  | 32727 | {
| 32776 | using namespace cv::aruco; |  | 32728 | using namespace cv::aruco;
| 32777 |  |  | 32729 |
| 32778 |  |  | 32730 |
| 32779 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32731 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32780 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32732 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32781 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32733 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32782 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32734 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32783 | RefineParameters retval; |  | 32735 | RefineParameters retval;
| 32784 |  |  | 32736 |
| 32785 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32737 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 32786 | { |  | 32738 | {
| 32787 | ERRWRAP2(retval = _self_->getRefineParameters()); |  | 32739 | ERRWRAP2(retval = _self_->getRefineParameters());
| 32788 | return pyopencv_from(retval); |  | 32740 | return pyopencv_from(retval);
| 32789 | } |  | 32741 | }
| 32790 |  |  | 32742 |
| 32791 | return NULL; |  | 32743 | return NULL;
| 32792 | } |  | 32744 | }
| 32793 |  |  | 32745 |
| 32794 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setBoard(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32746 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setBoard(PyObject* self, PyObject* py_args, PyObject* kw)
| 32795 | { |  | 32747 | {
| 32796 | using namespace cv::aruco; |  | 32748 | using namespace cv::aruco;
| 32797 |  |  | 32749 |
| 32798 |  |  | 32750 |
| 32799 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32751 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32800 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32752 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32801 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32753 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32802 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32754 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32803 | PyObject* pyobj_board = NULL; |  | 32755 | PyObject* pyobj_board = NULL;
| 32804 | CharucoBoard board; |  | 32756 | CharucoBoard board;
| 32805 |  |  | 32757 |
| 32806 | const char* keywords[] = { "board", NULL }; |  | 32758 | const char* keywords[] = { "board", NULL };
| 32807 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setBoard", (char**)keywords, &pyobj_board) && |  | 32759 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setBoard", (char**)keywords, &pyobj_board) &&
| 32808 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) ) |  | 32760 | pyopencv_to_safe(pyobj_board, board, ArgInfo("board", 0)) )
| 32809 | { |  | 32761 | {
| 32810 | ERRWRAP2(_self_->setBoard(board)); |  | 32762 | ERRWRAP2(_self_->setBoard(board));
| 32811 | Py_RETURN_NONE; |  | 32763 | Py_RETURN_NONE;
| 32812 | } |  | 32764 | }
| 32813 |  |  | 32765 |
| 32814 | return NULL; |  | 32766 | return NULL;
| 32815 | } |  | 32767 | }
| 32816 |  |  | 32768 |
| 32817 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setCharucoParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32769 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setCharucoParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 32818 | { |  | 32770 | {
| 32819 | using namespace cv::aruco; |  | 32771 | using namespace cv::aruco;
| 32820 |  |  | 32772 |
| 32821 |  |  | 32773 |
| 32822 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32774 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32823 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32775 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32824 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32776 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32825 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32777 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32826 | PyObject* pyobj_charucoParameters = NULL; |  | 32778 | PyObject* pyobj_charucoParameters = NULL;
| 32827 | CharucoParameters charucoParameters; |  | 32779 | CharucoParameters charucoParameters;
| 32828 |  |  | 32780 |
| 32829 | const char* keywords[] = { "charucoParameters", NULL }; |  | 32781 | const char* keywords[] = { "charucoParameters", NULL };
| 32830 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setCharucoParameters", (char**)keywords, &pyobj_charucoParameters) && |  | 32782 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setCharucoParameters", (char**)keywords, &pyobj_charucoParameters) &&
| 32831 | pyopencv_to_safe(pyobj_charucoParameters, charucoParameters, ArgInfo("charucoParameters", 0)) ) |  | 32783 | pyopencv_to_safe(pyobj_charucoParameters, charucoParameters, ArgInfo("charucoParameters", 0)) )
| 32832 | { |  | 32784 | {
| 32833 | ERRWRAP2(_self_->setCharucoParameters(charucoParameters)); |  | 32785 | ERRWRAP2(_self_->setCharucoParameters(charucoParameters));
| 32834 | Py_RETURN_NONE; |  | 32786 | Py_RETURN_NONE;
| 32835 | } |  | 32787 | }
| 32836 |  |  | 32788 |
| 32837 | return NULL; |  | 32789 | return NULL;
| 32838 | } |  | 32790 | }
| 32839 |  |  | 32791 |
| 32840 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32792 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 32841 | { |  | 32793 | {
| 32842 | using namespace cv::aruco; |  | 32794 | using namespace cv::aruco;
| 32843 |  |  | 32795 |
| 32844 |  |  | 32796 |
| 32845 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32797 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32846 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32798 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32847 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32799 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32848 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32800 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32849 | PyObject* pyobj_detectorParameters = NULL; |  | 32801 | PyObject* pyobj_detectorParameters = NULL;
| 32850 | DetectorParameters detectorParameters; |  | 32802 | DetectorParameters detectorParameters;
| 32851 |  |  | 32803 |
| 32852 | const char* keywords[] = { "detectorParameters", NULL }; |  | 32804 | const char* keywords[] = { "detectorParameters", NULL };
| 32853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setDetectorParameters", (char**)keywords, &pyobj_detectorParameters) && |  | 32805 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setDetectorParameters", (char**)keywords, &pyobj_detectorParameters) &&
| 32854 | pyopencv_to_safe(pyobj_detectorParameters, detectorParameters, ArgInfo("detectorParameters", 0)) ) |  | 32806 | pyopencv_to_safe(pyobj_detectorParameters, detectorParameters, ArgInfo("detectorParameters", 0)) )
| 32855 | { |  | 32807 | {
| 32856 | ERRWRAP2(_self_->setDetectorParameters(detectorParameters)); |  | 32808 | ERRWRAP2(_self_->setDetectorParameters(detectorParameters));
| 32857 | Py_RETURN_NONE; |  | 32809 | Py_RETURN_NONE;
| 32858 | } |  | 32810 | }
| 32859 |  |  | 32811 |
| 32860 | return NULL; |  | 32812 | return NULL;
| 32861 | } |  | 32813 | }
| 32862 |  |  | 32814 |
| 32863 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 32815 | static PyObject* pyopencv_cv_aruco_aruco_CharucoDetector_setRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 32864 | { |  | 32816 | {
| 32865 | using namespace cv::aruco; |  | 32817 | using namespace cv::aruco;
| 32866 |  |  | 32818 |
| 32867 |  |  | 32819 |
| 32868 | Ptr<cv::aruco::CharucoDetector> * self1 = 0; |  | 32820 | Ptr<cv::aruco::CharucoDetector> * self1 = 0;
| 32869 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1)) |  | 32821 | if (!pyopencv_aruco_CharucoDetector_getp(self, self1))
| 32870 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)"); |  | 32822 | return failmsgp("Incorrect type of self (must be 'aruco_CharucoDetector' or its derivative)");
| 32871 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1); |  | 32823 | Ptr<cv::aruco::CharucoDetector> _self_ = *(self1);
| 32872 | PyObject* pyobj_refineParameters = NULL; |  | 32824 | PyObject* pyobj_refineParameters = NULL;
| 32873 | RefineParameters refineParameters; |  | 32825 | RefineParameters refineParameters;
| 32874 |  |  | 32826 |
| 32875 | const char* keywords[] = { "refineParameters", NULL }; |  | 32827 | const char* keywords[] = { "refineParameters", NULL };
| 32876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setRefineParameters", (char**)keywords, &pyobj_refineParameters) && |  | 32828 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_CharucoDetector.setRefineParameters", (char**)keywords, &pyobj_refineParameters) &&
| 32877 | pyopencv_to_safe(pyobj_refineParameters, refineParameters, ArgInfo("refineParameters", 0)) ) |  | 32829 | pyopencv_to_safe(pyobj_refineParameters, refineParameters, ArgInfo("refineParameters", 0)) )
| 32878 | { |  | 32830 | {
| 32879 | ERRWRAP2(_self_->setRefineParameters(refineParameters)); |  | 32831 | ERRWRAP2(_self_->setRefineParameters(refineParameters));
| 32880 | Py_RETURN_NONE; |  | 32832 | Py_RETURN_NONE;
| 32881 | } |  | 32833 | }
| 32882 |  |  | 32834 |
| 32883 | return NULL; |  | 32835 | return NULL;
| 32884 | } |  | 32836 | }
| 32885 |  |  | 32837 |
| 32886 |  |  | 32838 |
| 32887 |  |  | 32839 |
| 32888 | // Tables (aruco_CharucoDetector) |  | 32840 | // Tables (aruco_CharucoDetector)
| 32889 |  |  | 32841 |
| 32890 | static PyGetSetDef pyopencv_aruco_CharucoDetector_getseters[] = |  | 32842 | static PyGetSetDef pyopencv_aruco_CharucoDetector_getseters[] =
| 32891 | { |  | 32843 | {
| 32892 | {NULL} /* Sentinel */ |  | 32844 | {NULL} /* Sentinel */
| 32893 | }; |  | 32845 | };
| 32894 |  |  | 32846 |
| 32895 | static PyMethodDef pyopencv_aruco_CharucoDetector_methods[] = |  | 32847 | static PyMethodDef pyopencv_aruco_CharucoDetector_methods[] =
| 32896 | { |  | 32848 | {
| 32897 | {"detectBoard", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_detectBoard, 0), "detectBoard(image[, charucoCorners[, charucoIds[, markerCorners[, markerIds]]]]) -> charucoCorners, charucoIds, markerCorners, markerIds\n. * @brief detect aruco markers and interpolate position of ChArUco board corners\n. * @param image input image necesary for corner refinement. Note that markers are not detected and\n. * should be sent in corners and ids parameters.\n. * @param charucoCorners interpolated chessboard corners.\n. * @param charucoIds interpolated chessboard corners identifiers.\n. * @param markerCorners vector of already detected markers corners. For each marker, its four\n. * corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the\n. * dimensions of this array should be Nx4. The order of the corners should be clockwise.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. * @param markerIds list of identifiers for each marker in corners.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. *\n. * This function receives the detected markers and returns the 2D position of the chessboard corners\n. * from a ChArUco board using the detected Aruco markers.\n. *\n. * If markerCorners and markerCorners are empty, the detectMarkers() will run and detect aruco markers and ids.\n. *\n. * If camera parameters are provided, the process is based in an approximated pose estimation, else it is based on local homography.\n. * Only visible corners are returned. For each corner, its corresponding identifier is also returned in charucoIds.\n. * @sa findChessboardCorners\n. * @note After OpenCV 4.6.0, there was an incompatible change in the ChArUco pattern generation algorithm for even row counts.\n. * Use cv::aruco::CharucoBoard::setLegacyPattern() to ensure compatibility with patterns created using OpenCV versions prior to 4.6.0.\n. * For more information, see the issue: https://github.com/opencv/opencv/issues/23152"}, |  | 32849 | {"detectBoard", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_detectBoard, 0), "detectBoard(image[, charucoCorners[, charucoIds[, markerCorners[, markerIds]]]]) -> charucoCorners, charucoIds, markerCorners, markerIds\n. * @brief detect aruco markers and interpolate position of ChArUco board corners\n. * @param image input image necesary for corner refinement. Note that markers are not detected and\n. * should be sent in corners and ids parameters.\n. * @param charucoCorners interpolated chessboard corners.\n. * @param charucoIds interpolated chessboard corners identifiers.\n. * @param markerCorners vector of already detected markers corners. For each marker, its four\n. * corners are provided, (e.g std::vector<std::vector<cv::Point2f> > ). For N detected markers, the\n. * dimensions of this array should be Nx4. The order of the corners should be clockwise.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. * @param markerIds list of identifiers for each marker in corners.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. *\n. * This function receives the detected markers and returns the 2D position of the chessboard corners\n. * from a ChArUco board using the detected Aruco markers.\n. *\n. * If markerCorners and markerCorners are empty, the detectMarkers() will run and detect aruco markers and ids.\n. *\n. * If camera parameters are provided, the process is based in an approximated pose estimation, else it is based on local homography.\n. * Only visible corners are returned. For each corner, its corresponding identifier is also returned in charucoIds.\n. * @sa findChessboardCorners\n. * @note After OpenCV 4.6.0, there was an incompatible change in the ChArUco pattern generation algorithm for even row counts.\n. * Use cv::aruco::CharucoBoard::setLegacyPattern() to ensure compatibility with patterns created using OpenCV versions prior to 4.6.0.\n. * For more information, see the issue: https://github.com/opencv/opencv/issues/23152"},
| 32898 | {"detectDiamonds", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_detectDiamonds, 0), "detectDiamonds(image[, diamondCorners[, diamondIds[, markerCorners[, markerIds]]]]) -> diamondCorners, diamondIds, markerCorners, markerIds\n. * @brief Detect ChArUco Diamond markers\n. *\n. * @param image input image necessary for corner subpixel.\n. * @param diamondCorners output list of detected diamond corners (4 corners per diamond). The order\n. * is the same than in marker corners: top left, top right, bottom right and bottom left. Similar\n. * format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ).\n. * @param diamondIds ids of the diamonds in diamondCorners. The id of each diamond is in fact of\n. * type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the\n. * diamond.\n. * @param markerCorners list of detected marker corners from detectMarkers function.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. * @param markerIds list of marker ids in markerCorners.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. *\n. * This function detects Diamond markers from the previous detected ArUco markers. The diamonds\n. * are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters\n. * are provided, the diamond search is based on reprojection. If not, diamond search is based on\n. * homography. Homography is faster than reprojection, but less accurate."}, |  | 32850 | {"detectDiamonds", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_detectDiamonds, 0), "detectDiamonds(image[, diamondCorners[, diamondIds[, markerCorners[, markerIds]]]]) -> diamondCorners, diamondIds, markerCorners, markerIds\n. * @brief Detect ChArUco Diamond markers\n. *\n. * @param image input image necessary for corner subpixel.\n. * @param diamondCorners output list of detected diamond corners (4 corners per diamond). The order\n. * is the same than in marker corners: top left, top right, bottom right and bottom left. Similar\n. * format than the corners returned by detectMarkers (e.g std::vector<std::vector<cv::Point2f> > ).\n. * @param diamondIds ids of the diamonds in diamondCorners. The id of each diamond is in fact of\n. * type Vec4i, so each diamond has 4 ids, which are the ids of the aruco markers composing the\n. * diamond.\n. * @param markerCorners list of detected marker corners from detectMarkers function.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. * @param markerIds list of marker ids in markerCorners.\n. * If markerCorners and markerCorners are empty, the function detect aruco markers and ids.\n. *\n. * This function detects Diamond markers from the previous detected ArUco markers. The diamonds\n. * are returned in the diamondCorners and diamondIds parameters. If camera calibration parameters\n. * are provided, the diamond search is based on reprojection. If not, diamond search is based on\n. * homography. Homography is faster than reprojection, but less accurate."},
| 32899 | {"getBoard", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getBoard, 0), "getBoard() -> retval\n."}, |  | 32851 | {"getBoard", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getBoard, 0), "getBoard() -> retval\n."},
| 32900 | {"getCharucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getCharucoParameters, 0), "getCharucoParameters() -> retval\n."}, |  | 32852 | {"getCharucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getCharucoParameters, 0), "getCharucoParameters() -> retval\n."},
| 32901 | {"getDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getDetectorParameters, 0), "getDetectorParameters() -> retval\n."}, |  | 32853 | {"getDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getDetectorParameters, 0), "getDetectorParameters() -> retval\n."},
| 32902 | {"getRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getRefineParameters, 0), "getRefineParameters() -> retval\n."}, |  | 32854 | {"getRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_getRefineParameters, 0), "getRefineParameters() -> retval\n."},
| 32903 | {"setBoard", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setBoard, 0), "setBoard(board) -> None\n."}, |  | 32855 | {"setBoard", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setBoard, 0), "setBoard(board) -> None\n."},
| 32904 | {"setCharucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setCharucoParameters, 0), "setCharucoParameters(charucoParameters) -> None\n."}, |  | 32856 | {"setCharucoParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setCharucoParameters, 0), "setCharucoParameters(charucoParameters) -> None\n."},
| 32905 | {"setDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setDetectorParameters, 0), "setDetectorParameters(detectorParameters) -> None\n."}, |  | 32857 | {"setDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setDetectorParameters, 0), "setDetectorParameters(detectorParameters) -> None\n."},
| 32906 | {"setRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setRefineParameters, 0), "setRefineParameters(refineParameters) -> None\n."}, |  | 32858 | {"setRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_CharucoDetector_setRefineParameters, 0), "setRefineParameters(refineParameters) -> None\n."},
| 32907 |  |  | 32859 |
| 32908 | {NULL, NULL} |  | 32860 | {NULL, NULL}
| 32909 | }; |  | 32861 | };
| 32910 |  |  | 32862 |
| 32911 | // Converter (aruco_CharucoDetector) |  | 32863 | // Converter (aruco_CharucoDetector)
| 32912 |  |  | 32864 |
| 32913 | template<> |  | 32865 | template<>
| 32914 | struct PyOpenCV_Converter< Ptr<cv::aruco::CharucoDetector> > |  | 32866 | struct PyOpenCV_Converter< Ptr<cv::aruco::CharucoDetector> >
| 32915 | { |  | 32867 | {
| 32916 | static PyObject* from(const Ptr<cv::aruco::CharucoDetector>& r) |  | 32868 | static PyObject* from(const Ptr<cv::aruco::CharucoDetector>& r)
| 32917 | { |  | 32869 | {
| 32918 | return pyopencv_aruco_CharucoDetector_Instance(r); |  | 32870 | return pyopencv_aruco_CharucoDetector_Instance(r);
| 32919 | } |  | 32871 | }
| 32920 | static bool to(PyObject* src, Ptr<cv::aruco::CharucoDetector>& dst, const ArgInfo& info) |  | 32872 | static bool to(PyObject* src, Ptr<cv::aruco::CharucoDetector>& dst, const ArgInfo& info)
| 32921 | { |  | 32873 | {
| 32922 | if(!src || src == Py_None) |  | 32874 | if(!src || src == Py_None)
| 32923 | return true; |  | 32875 | return true;
| 32924 | Ptr<cv::aruco::CharucoDetector> * dst_; |  | 32876 | Ptr<cv::aruco::CharucoDetector> * dst_;
| 32925 | if (pyopencv_aruco_CharucoDetector_getp(src, dst_)) |  | 32877 | if (pyopencv_aruco_CharucoDetector_getp(src, dst_))
| 32926 | { |  | 32878 | {
| 32927 | dst = *dst_; |  | 32879 | dst = *dst_;
| 32928 | return true; |  | 32880 | return true;
| 32929 | } |  | 32881 | }
| 32930 |  |  | 32882 |
| 32931 | failmsg("Expected Ptr<cv::aruco::CharucoDetector> for argument '%s'", info.name); |  | 32883 | failmsg("Expected Ptr<cv::aruco::CharucoDetector> for argument '%s'", info.name);
| 32932 | return false; |  | 32884 | return false;
| 32933 | } |  | 32885 | }
| 32934 | }; |  | 32886 | };
| 32935 |  |  | 32887 |
| 32936 | //================================================================================ |  | 32888 | //================================================================================
| 32937 | // aruco_CharucoParameters (Generic) |  | 32889 | // aruco_CharucoParameters (Generic)
| 32938 | //================================================================================ |  | 32890 | //================================================================================
| 32939 |  |  | 32891 |
| 32940 | // GetSet (aruco_CharucoParameters) |  | 32892 | // GetSet (aruco_CharucoParameters)
| 32941 |  |  | 32893 |
| 32942 |  |  | 32894 |
| 32943 | static PyObject* pyopencv_aruco_CharucoParameters_get_cameraMatrix(pyopencv_aruco_CharucoParameters_t* p, void *closure) |  | 32895 | static PyObject* pyopencv_aruco_CharucoParameters_get_cameraMatrix(pyopencv_aruco_CharucoParameters_t* p, void *closure)
| 32944 | { |  | 32896 | {
| 32945 | return pyopencv_from(p->v.cameraMatrix); |  | 32897 | return pyopencv_from(p->v.cameraMatrix);
| 32946 | } |  | 32898 | }
| 32947 |  |  | 32899 |
| 32948 | static int pyopencv_aruco_CharucoParameters_set_cameraMatrix(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure) |  | 32900 | static int pyopencv_aruco_CharucoParameters_set_cameraMatrix(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure)
| 32949 | { |  | 32901 | {
| 32950 | if (!value) |  | 32902 | if (!value)
| 32951 | { |  | 32903 | {
| 32952 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cameraMatrix attribute"); |  | 32904 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cameraMatrix attribute");
| 32953 | return -1; |  | 32905 | return -1;
| 32954 | } |  | 32906 | }
| 32955 | return pyopencv_to_safe(value, p->v.cameraMatrix, ArgInfo("value", 0)) ? 0 : -1; |  | 32907 | return pyopencv_to_safe(value, p->v.cameraMatrix, ArgInfo("value", 0)) ? 0 : -1;
| 32956 | } |  | 32908 | }
| 32957 |  |  | 32909 |
| 32958 | static PyObject* pyopencv_aruco_CharucoParameters_get_distCoeffs(pyopencv_aruco_CharucoParameters_t* p, void *closure) |  | 32910 | static PyObject* pyopencv_aruco_CharucoParameters_get_distCoeffs(pyopencv_aruco_CharucoParameters_t* p, void *closure)
| 32959 | { |  | 32911 | {
| 32960 | return pyopencv_from(p->v.distCoeffs); |  | 32912 | return pyopencv_from(p->v.distCoeffs);
| 32961 | } |  | 32913 | }
| 32962 |  |  | 32914 |
| 32963 | static int pyopencv_aruco_CharucoParameters_set_distCoeffs(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure) |  | 32915 | static int pyopencv_aruco_CharucoParameters_set_distCoeffs(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure)
| 32964 | { |  | 32916 | {
| 32965 | if (!value) |  | 32917 | if (!value)
| 32966 | { |  | 32918 | {
| 32967 | PyErr_SetString(PyExc_TypeError, "Cannot delete the distCoeffs attribute"); |  | 32919 | PyErr_SetString(PyExc_TypeError, "Cannot delete the distCoeffs attribute");
| 32968 | return -1; |  | 32920 | return -1;
| 32969 | } |  | 32921 | }
| 32970 | return pyopencv_to_safe(value, p->v.distCoeffs, ArgInfo("value", 0)) ? 0 : -1; |  | 32922 | return pyopencv_to_safe(value, p->v.distCoeffs, ArgInfo("value", 0)) ? 0 : -1;
| 32971 | } |  | 32923 | }
| 32972 |  |  | 32924 |
| 32973 | static PyObject* pyopencv_aruco_CharucoParameters_get_minMarkers(pyopencv_aruco_CharucoParameters_t* p, void *closure) |  | 32925 | static PyObject* pyopencv_aruco_CharucoParameters_get_minMarkers(pyopencv_aruco_CharucoParameters_t* p, void *closure)
| 32974 | { |  | 32926 | {
| 32975 | return pyopencv_from(p->v.minMarkers); |  | 32927 | return pyopencv_from(p->v.minMarkers);
| 32976 | } |  | 32928 | }
| 32977 |  |  | 32929 |
| 32978 | static int pyopencv_aruco_CharucoParameters_set_minMarkers(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure) |  | 32930 | static int pyopencv_aruco_CharucoParameters_set_minMarkers(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure)
| 32979 | { |  | 32931 | {
| 32980 | if (!value) |  | 32932 | if (!value)
| 32981 | { |  | 32933 | {
| 32982 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkers attribute"); |  | 32934 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkers attribute");
| 32983 | return -1; |  | 32935 | return -1;
| 32984 | } |  | 32936 | }
| 32985 | return pyopencv_to_safe(value, p->v.minMarkers, ArgInfo("value", 0)) ? 0 : -1; |  | 32937 | return pyopencv_to_safe(value, p->v.minMarkers, ArgInfo("value", 0)) ? 0 : -1;
| 32986 | } |  | 32938 | }
| 32987 |  |  | 32939 |
| 32988 | static PyObject* pyopencv_aruco_CharucoParameters_get_tryRefineMarkers(pyopencv_aruco_CharucoParameters_t* p, void *closure) |  | 32940 | static PyObject* pyopencv_aruco_CharucoParameters_get_tryRefineMarkers(pyopencv_aruco_CharucoParameters_t* p, void *closure)
| 32989 | { |  | 32941 | {
| 32990 | return pyopencv_from(p->v.tryRefineMarkers); |  | 32942 | return pyopencv_from(p->v.tryRefineMarkers);
| 32991 | } |  | 32943 | }
| 32992 |  |  | 32944 |
| 32993 | static int pyopencv_aruco_CharucoParameters_set_tryRefineMarkers(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure) |  | 32945 | static int pyopencv_aruco_CharucoParameters_set_tryRefineMarkers(pyopencv_aruco_CharucoParameters_t* p, PyObject *value, void *closure)
| 32994 | { |  | 32946 | {
| 32995 | if (!value) |  | 32947 | if (!value)
| 32996 | { |  | 32948 | {
| 32997 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tryRefineMarkers attribute"); |  | 32949 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tryRefineMarkers attribute");
| 32998 | return -1; |  | 32950 | return -1;
| 32999 | } |  | 32951 | }
| 33000 | return pyopencv_to_safe(value, p->v.tryRefineMarkers, ArgInfo("value", 0)) ? 0 : -1; |  | 32952 | return pyopencv_to_safe(value, p->v.tryRefineMarkers, ArgInfo("value", 0)) ? 0 : -1;
| 33001 | } |  | 32953 | }
| 33002 |  |  | 32954 |
| 33003 |  |  | 32955 |
| 33004 | // Methods (aruco_CharucoParameters) |  | 32956 | // Methods (aruco_CharucoParameters)
| 33005 |  |  | 32957 |
| 33006 | static int pyopencv_cv_aruco_aruco_CharucoParameters_CharucoParameters(pyopencv_aruco_CharucoParameters_t* self, PyObject* py_args, PyObject* kw) |  | 32958 | static int pyopencv_cv_aruco_aruco_CharucoParameters_CharucoParameters(pyopencv_aruco_CharucoParameters_t* self, PyObject* py_args, PyObject* kw)
| 33007 | { |  | 32959 | {
| 33008 | using namespace cv::aruco; |  | 32960 | using namespace cv::aruco;
| 33009 |  |  | 32961 |
| 33010 |  |  | 32962 |
| 33011 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 32963 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 33012 | { |  | 32964 | {
| 33013 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::CharucoParameters()); |  | 32965 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::CharucoParameters());
| 33014 | return 0; |  | 32966 | return 0;
| 33015 | } |  | 32967 | }
| 33016 |  |  | 32968 |
| 33017 | return -1; |  | 32969 | return -1;
| 33018 | } |  | 32970 | }
| 33019 |  |  | 32971 |
| 33020 |  |  | 32972 |
| 33021 |  |  | 32973 |
| 33022 | // Tables (aruco_CharucoParameters) |  | 32974 | // Tables (aruco_CharucoParameters)
| 33023 |  |  | 32975 |
| 33024 | static PyGetSetDef pyopencv_aruco_CharucoParameters_getseters[] = |  | 32976 | static PyGetSetDef pyopencv_aruco_CharucoParameters_getseters[] =
| 33025 | { |  | 32977 | {
| 33026 | {(char*)"cameraMatrix", (getter)pyopencv_aruco_CharucoParameters_get_cameraMatrix, (setter)pyopencv_aruco_CharucoParameters_set_cameraMatrix, (char*)"cameraMatrix", NULL}, |  | 32978 | {(char*)"cameraMatrix", (getter)pyopencv_aruco_CharucoParameters_get_cameraMatrix, (setter)pyopencv_aruco_CharucoParameters_set_cameraMatrix, (char*)"cameraMatrix", NULL},
| 33027 | {(char*)"distCoeffs", (getter)pyopencv_aruco_CharucoParameters_get_distCoeffs, (setter)pyopencv_aruco_CharucoParameters_set_distCoeffs, (char*)"distCoeffs", NULL}, |  | 32979 | {(char*)"distCoeffs", (getter)pyopencv_aruco_CharucoParameters_get_distCoeffs, (setter)pyopencv_aruco_CharucoParameters_set_distCoeffs, (char*)"distCoeffs", NULL},
| 33028 | {(char*)"minMarkers", (getter)pyopencv_aruco_CharucoParameters_get_minMarkers, (setter)pyopencv_aruco_CharucoParameters_set_minMarkers, (char*)"minMarkers", NULL}, |  | 32980 | {(char*)"minMarkers", (getter)pyopencv_aruco_CharucoParameters_get_minMarkers, (setter)pyopencv_aruco_CharucoParameters_set_minMarkers, (char*)"minMarkers", NULL},
| 33029 | {(char*)"tryRefineMarkers", (getter)pyopencv_aruco_CharucoParameters_get_tryRefineMarkers, (setter)pyopencv_aruco_CharucoParameters_set_tryRefineMarkers, (char*)"tryRefineMarkers", NULL}, |  | 32981 | {(char*)"tryRefineMarkers", (getter)pyopencv_aruco_CharucoParameters_get_tryRefineMarkers, (setter)pyopencv_aruco_CharucoParameters_set_tryRefineMarkers, (char*)"tryRefineMarkers", NULL},
| 33030 | {NULL} /* Sentinel */ |  | 32982 | {NULL} /* Sentinel */
| 33031 | }; |  | 32983 | };
| 33032 |  |  | 32984 |
| 33033 | static PyMethodDef pyopencv_aruco_CharucoParameters_methods[] = |  | 32985 | static PyMethodDef pyopencv_aruco_CharucoParameters_methods[] =
| 33034 | { |  | 32986 | {
| 33035 |  |  | 32987 |
| 33036 | {NULL, NULL} |  | 32988 | {NULL, NULL}
| 33037 | }; |  | 32989 | };
| 33038 |  |  | 32990 |
| 33039 | // Converter (aruco_CharucoParameters) |  | 32991 | // Converter (aruco_CharucoParameters)
| 33040 |  |  | 32992 |
| 33041 | template<> |  | 32993 | template<>
| 33042 | struct PyOpenCV_Converter< cv::aruco::CharucoParameters > |  | 32994 | struct PyOpenCV_Converter< cv::aruco::CharucoParameters >
| 33043 | { |  | 32995 | {
| 33044 | static PyObject* from(const cv::aruco::CharucoParameters& r) |  | 32996 | static PyObject* from(const cv::aruco::CharucoParameters& r)
| 33045 | { |  | 32997 | {
| 33046 | return pyopencv_aruco_CharucoParameters_Instance(r); |  | 32998 | return pyopencv_aruco_CharucoParameters_Instance(r);
| 33047 | } |  | 32999 | }
| 33048 | static bool to(PyObject* src, cv::aruco::CharucoParameters& dst, const ArgInfo& info) |  | 33000 | static bool to(PyObject* src, cv::aruco::CharucoParameters& dst, const ArgInfo& info)
| 33049 | { |  | 33001 | {
| 33050 | if(!src || src == Py_None) |  | 33002 | if(!src || src == Py_None)
| 33051 | return true; |  | 33003 | return true;
| 33052 | cv::aruco::CharucoParameters * dst_; |  | 33004 | cv::aruco::CharucoParameters * dst_;
| 33053 | if (pyopencv_aruco_CharucoParameters_getp(src, dst_)) |  | 33005 | if (pyopencv_aruco_CharucoParameters_getp(src, dst_))
| 33054 | { |  | 33006 | {
| 33055 | dst = *dst_; |  | 33007 | dst = *dst_;
| 33056 | return true; |  | 33008 | return true;
| 33057 | } |  | 33009 | }
| 33058 |  |  | 33010 |
| 33059 | failmsg("Expected cv::aruco::CharucoParameters for argument '%s'", info.name); |  | 33011 | failmsg("Expected cv::aruco::CharucoParameters for argument '%s'", info.name);
| 33060 | return false; |  | 33012 | return false;
| 33061 | } |  | 33013 | }
| 33062 | }; |  | 33014 | };
| 33063 |  |  | 33015 |
| 33064 | //================================================================================ |  | 33016 | //================================================================================
| 33065 | // aruco_DetectorParameters (Generic) |  | 33017 | // aruco_DetectorParameters (Generic)
| 33066 | //================================================================================ |  | 33018 | //================================================================================
| 33067 |  |  | 33019 |
| 33068 | // GetSet (aruco_DetectorParameters) |  | 33020 | // GetSet (aruco_DetectorParameters)
| 33069 |  |  | 33021 |
| 33070 |  |  | 33022 |
| 33071 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshConstant(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33023 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshConstant(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33072 | { |  | 33024 | {
| 33073 | return pyopencv_from(p->v.adaptiveThreshConstant); |  | 33025 | return pyopencv_from(p->v.adaptiveThreshConstant);
| 33074 | } |  | 33026 | }
| 33075 |  |  | 33027 |
| 33076 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshConstant(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33028 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshConstant(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33077 | { |  | 33029 | {
| 33078 | if (!value) |  | 33030 | if (!value)
| 33079 | { |  | 33031 | {
| 33080 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshConstant attribute"); |  | 33032 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshConstant attribute");
| 33081 | return -1; |  | 33033 | return -1;
| 33082 | } |  | 33034 | }
| 33083 | return pyopencv_to_safe(value, p->v.adaptiveThreshConstant, ArgInfo("value", 0)) ? 0 : -1; |  | 33035 | return pyopencv_to_safe(value, p->v.adaptiveThreshConstant, ArgInfo("value", 0)) ? 0 : -1;
| 33084 | } |  | 33036 | }
| 33085 |  |  | 33037 |
| 33086 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMax(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33038 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMax(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33087 | { |  | 33039 | {
| 33088 | return pyopencv_from(p->v.adaptiveThreshWinSizeMax); |  | 33040 | return pyopencv_from(p->v.adaptiveThreshWinSizeMax);
| 33089 | } |  | 33041 | }
| 33090 |  |  | 33042 |
| 33091 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMax(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33043 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMax(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33092 | { |  | 33044 | {
| 33093 | if (!value) |  | 33045 | if (!value)
| 33094 | { |  | 33046 | {
| 33095 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMax attribute"); |  | 33047 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMax attribute");
| 33096 | return -1; |  | 33048 | return -1;
| 33097 | } |  | 33049 | }
| 33098 | return pyopencv_to_safe(value, p->v.adaptiveThreshWinSizeMax, ArgInfo("value", 0)) ? 0 : -1; |  | 33050 | return pyopencv_to_safe(value, p->v.adaptiveThreshWinSizeMax, ArgInfo("value", 0)) ? 0 : -1;
| 33099 | } |  | 33051 | }
| 33100 |  |  | 33052 |
| 33101 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMin(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33053 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMin(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33102 | { |  | 33054 | {
| 33103 | return pyopencv_from(p->v.adaptiveThreshWinSizeMin); |  | 33055 | return pyopencv_from(p->v.adaptiveThreshWinSizeMin);
| 33104 | } |  | 33056 | }
| 33105 |  |  | 33057 |
| 33106 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMin(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33058 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMin(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33107 | { |  | 33059 | {
| 33108 | if (!value) |  | 33060 | if (!value)
| 33109 | { |  | 33061 | {
| 33110 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMin attribute"); |  | 33062 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMin attribute");
| 33111 | return -1; |  | 33063 | return -1;
| 33112 | } |  | 33064 | }
| 33113 | return pyopencv_to_safe(value, p->v.adaptiveThreshWinSizeMin, ArgInfo("value", 0)) ? 0 : -1; |  | 33065 | return pyopencv_to_safe(value, p->v.adaptiveThreshWinSizeMin, ArgInfo("value", 0)) ? 0 : -1;
| 33114 | } |  | 33066 | }
| 33115 |  |  | 33067 |
| 33116 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeStep(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33068 | static PyObject* pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeStep(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33117 | { |  | 33069 | {
| 33118 | return pyopencv_from(p->v.adaptiveThreshWinSizeStep); |  | 33070 | return pyopencv_from(p->v.adaptiveThreshWinSizeStep);
| 33119 | } |  | 33071 | }
| 33120 |  |  | 33072 |
| 33121 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeStep(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33073 | static int pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeStep(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33122 | { |  | 33074 | {
| 33123 | if (!value) |  | 33075 | if (!value)
| 33124 | { |  | 33076 | {
| 33125 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeStep attribute"); |  | 33077 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeStep attribute");
| 33126 | return -1; |  | 33078 | return -1;
| 33127 | } |  | 33079 | }
| 33128 | return pyopencv_to_safe(value, p->v.adaptiveThreshWinSizeStep, ArgInfo("value", 0)) ? 0 : -1; |  | 33080 | return pyopencv_to_safe(value, p->v.adaptiveThreshWinSizeStep, ArgInfo("value", 0)) ? 0 : -1;
| 33129 | } |  | 33081 | }
| 33130 |  |  | 33082 |
| 33131 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagCriticalRad(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33083 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagCriticalRad(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33132 | { |  | 33084 | {
| 33133 | return pyopencv_from(p->v.aprilTagCriticalRad); |  | 33085 | return pyopencv_from(p->v.aprilTagCriticalRad);
| 33134 | } |  | 33086 | }
| 33135 |  |  | 33087 |
| 33136 | static int pyopencv_aruco_DetectorParameters_set_aprilTagCriticalRad(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33088 | static int pyopencv_aruco_DetectorParameters_set_aprilTagCriticalRad(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33137 | { |  | 33089 | {
| 33138 | if (!value) |  | 33090 | if (!value)
| 33139 | { |  | 33091 | {
| 33140 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagCriticalRad attribute"); |  | 33092 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagCriticalRad attribute");
| 33141 | return -1; |  | 33093 | return -1;
| 33142 | } |  | 33094 | }
| 33143 | return pyopencv_to_safe(value, p->v.aprilTagCriticalRad, ArgInfo("value", 0)) ? 0 : -1; |  | 33095 | return pyopencv_to_safe(value, p->v.aprilTagCriticalRad, ArgInfo("value", 0)) ? 0 : -1;
| 33144 | } |  | 33096 | }
| 33145 |  |  | 33097 |
| 33146 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagDeglitch(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33098 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagDeglitch(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33147 | { |  | 33099 | {
| 33148 | return pyopencv_from(p->v.aprilTagDeglitch); |  | 33100 | return pyopencv_from(p->v.aprilTagDeglitch);
| 33149 | } |  | 33101 | }
| 33150 |  |  | 33102 |
| 33151 | static int pyopencv_aruco_DetectorParameters_set_aprilTagDeglitch(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33103 | static int pyopencv_aruco_DetectorParameters_set_aprilTagDeglitch(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33152 | { |  | 33104 | {
| 33153 | if (!value) |  | 33105 | if (!value)
| 33154 | { |  | 33106 | {
| 33155 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagDeglitch attribute"); |  | 33107 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagDeglitch attribute");
| 33156 | return -1; |  | 33108 | return -1;
| 33157 | } |  | 33109 | }
| 33158 | return pyopencv_to_safe(value, p->v.aprilTagDeglitch, ArgInfo("value", 0)) ? 0 : -1; |  | 33110 | return pyopencv_to_safe(value, p->v.aprilTagDeglitch, ArgInfo("value", 0)) ? 0 : -1;
| 33159 | } |  | 33111 | }
| 33160 |  |  | 33112 |
| 33161 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMaxLineFitMse(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33113 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMaxLineFitMse(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33162 | { |  | 33114 | {
| 33163 | return pyopencv_from(p->v.aprilTagMaxLineFitMse); |  | 33115 | return pyopencv_from(p->v.aprilTagMaxLineFitMse);
| 33164 | } |  | 33116 | }
| 33165 |  |  | 33117 |
| 33166 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMaxLineFitMse(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33118 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMaxLineFitMse(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33167 | { |  | 33119 | {
| 33168 | if (!value) |  | 33120 | if (!value)
| 33169 | { |  | 33121 | {
| 33170 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMaxLineFitMse attribute"); |  | 33122 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMaxLineFitMse attribute");
| 33171 | return -1; |  | 33123 | return -1;
| 33172 | } |  | 33124 | }
| 33173 | return pyopencv_to_safe(value, p->v.aprilTagMaxLineFitMse, ArgInfo("value", 0)) ? 0 : -1; |  | 33125 | return pyopencv_to_safe(value, p->v.aprilTagMaxLineFitMse, ArgInfo("value", 0)) ? 0 : -1;
| 33174 | } |  | 33126 | }
| 33175 |  |  | 33127 |
| 33176 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMaxNmaxima(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33128 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMaxNmaxima(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33177 | { |  | 33129 | {
| 33178 | return pyopencv_from(p->v.aprilTagMaxNmaxima); |  | 33130 | return pyopencv_from(p->v.aprilTagMaxNmaxima);
| 33179 | } |  | 33131 | }
| 33180 |  |  | 33132 |
| 33181 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMaxNmaxima(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33133 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMaxNmaxima(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33182 | { |  | 33134 | {
| 33183 | if (!value) |  | 33135 | if (!value)
| 33184 | { |  | 33136 | {
| 33185 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMaxNmaxima attribute"); |  | 33137 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMaxNmaxima attribute");
| 33186 | return -1; |  | 33138 | return -1;
| 33187 | } |  | 33139 | }
| 33188 | return pyopencv_to_safe(value, p->v.aprilTagMaxNmaxima, ArgInfo("value", 0)) ? 0 : -1; |  | 33140 | return pyopencv_to_safe(value, p->v.aprilTagMaxNmaxima, ArgInfo("value", 0)) ? 0 : -1;
| 33189 | } |  | 33141 | }
| 33190 |  |  | 33142 |
| 33191 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMinClusterPixels(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33143 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMinClusterPixels(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33192 | { |  | 33144 | {
| 33193 | return pyopencv_from(p->v.aprilTagMinClusterPixels); |  | 33145 | return pyopencv_from(p->v.aprilTagMinClusterPixels);
| 33194 | } |  | 33146 | }
| 33195 |  |  | 33147 |
| 33196 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMinClusterPixels(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33148 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMinClusterPixels(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33197 | { |  | 33149 | {
| 33198 | if (!value) |  | 33150 | if (!value)
| 33199 | { |  | 33151 | {
| 33200 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMinClusterPixels attribute"); |  | 33152 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMinClusterPixels attribute");
| 33201 | return -1; |  | 33153 | return -1;
| 33202 | } |  | 33154 | }
| 33203 | return pyopencv_to_safe(value, p->v.aprilTagMinClusterPixels, ArgInfo("value", 0)) ? 0 : -1; |  | 33155 | return pyopencv_to_safe(value, p->v.aprilTagMinClusterPixels, ArgInfo("value", 0)) ? 0 : -1;
| 33204 | } |  | 33156 | }
| 33205 |  |  | 33157 |
| 33206 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMinWhiteBlackDiff(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33158 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagMinWhiteBlackDiff(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33207 | { |  | 33159 | {
| 33208 | return pyopencv_from(p->v.aprilTagMinWhiteBlackDiff); |  | 33160 | return pyopencv_from(p->v.aprilTagMinWhiteBlackDiff);
| 33209 | } |  | 33161 | }
| 33210 |  |  | 33162 |
| 33211 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMinWhiteBlackDiff(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33163 | static int pyopencv_aruco_DetectorParameters_set_aprilTagMinWhiteBlackDiff(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33212 | { |  | 33164 | {
| 33213 | if (!value) |  | 33165 | if (!value)
| 33214 | { |  | 33166 | {
| 33215 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMinWhiteBlackDiff attribute"); |  | 33167 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagMinWhiteBlackDiff attribute");
| 33216 | return -1; |  | 33168 | return -1;
| 33217 | } |  | 33169 | }
| 33218 | return pyopencv_to_safe(value, p->v.aprilTagMinWhiteBlackDiff, ArgInfo("value", 0)) ? 0 : -1; |  | 33170 | return pyopencv_to_safe(value, p->v.aprilTagMinWhiteBlackDiff, ArgInfo("value", 0)) ? 0 : -1;
| 33219 | } |  | 33171 | }
| 33220 |  |  | 33172 |
| 33221 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagQuadDecimate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33173 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagQuadDecimate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33222 | { |  | 33174 | {
| 33223 | return pyopencv_from(p->v.aprilTagQuadDecimate); |  | 33175 | return pyopencv_from(p->v.aprilTagQuadDecimate);
| 33224 | } |  | 33176 | }
| 33225 |  |  | 33177 |
| 33226 | static int pyopencv_aruco_DetectorParameters_set_aprilTagQuadDecimate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33178 | static int pyopencv_aruco_DetectorParameters_set_aprilTagQuadDecimate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33227 | { |  | 33179 | {
| 33228 | if (!value) |  | 33180 | if (!value)
| 33229 | { |  | 33181 | {
| 33230 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagQuadDecimate attribute"); |  | 33182 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagQuadDecimate attribute");
| 33231 | return -1; |  | 33183 | return -1;
| 33232 | } |  | 33184 | }
| 33233 | return pyopencv_to_safe(value, p->v.aprilTagQuadDecimate, ArgInfo("value", 0)) ? 0 : -1; |  | 33185 | return pyopencv_to_safe(value, p->v.aprilTagQuadDecimate, ArgInfo("value", 0)) ? 0 : -1;
| 33234 | } |  | 33186 | }
| 33235 |  |  | 33187 |
| 33236 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagQuadSigma(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33188 | static PyObject* pyopencv_aruco_DetectorParameters_get_aprilTagQuadSigma(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33237 | { |  | 33189 | {
| 33238 | return pyopencv_from(p->v.aprilTagQuadSigma); |  | 33190 | return pyopencv_from(p->v.aprilTagQuadSigma);
| 33239 | } |  | 33191 | }
| 33240 |  |  | 33192 |
| 33241 | static int pyopencv_aruco_DetectorParameters_set_aprilTagQuadSigma(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33193 | static int pyopencv_aruco_DetectorParameters_set_aprilTagQuadSigma(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33242 | { |  | 33194 | {
| 33243 | if (!value) |  | 33195 | if (!value)
| 33244 | { |  | 33196 | {
| 33245 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagQuadSigma attribute"); |  | 33197 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aprilTagQuadSigma attribute");
| 33246 | return -1; |  | 33198 | return -1;
| 33247 | } |  | 33199 | }
| 33248 | return pyopencv_to_safe(value, p->v.aprilTagQuadSigma, ArgInfo("value", 0)) ? 0 : -1; |  | 33200 | return pyopencv_to_safe(value, p->v.aprilTagQuadSigma, ArgInfo("value", 0)) ? 0 : -1;
| 33249 | } |  | 33201 | }
| 33250 |  |  | 33202 |
| 33251 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementMaxIterations(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33203 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementMaxIterations(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33252 | { |  | 33204 | {
| 33253 | return pyopencv_from(p->v.cornerRefinementMaxIterations); |  | 33205 | return pyopencv_from(p->v.cornerRefinementMaxIterations);
| 33254 | } |  | 33206 | }
| 33255 |  |  | 33207 |
| 33256 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementMaxIterations(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33208 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementMaxIterations(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33257 | { |  | 33209 | {
| 33258 | if (!value) |  | 33210 | if (!value)
| 33259 | { |  | 33211 | {
| 33260 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementMaxIterations attribute"); |  | 33212 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementMaxIterations attribute");
| 33261 | return -1; |  | 33213 | return -1;
| 33262 | } |  | 33214 | }
| 33263 | return pyopencv_to_safe(value, p->v.cornerRefinementMaxIterations, ArgInfo("value", 0)) ? 0 : -1; |  | 33215 | return pyopencv_to_safe(value, p->v.cornerRefinementMaxIterations, ArgInfo("value", 0)) ? 0 : -1;
| 33264 | } |  | 33216 | }
| 33265 |  |  | 33217 |
| 33266 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementMethod(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33218 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementMethod(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33267 | { |  | 33219 | {
| 33268 | return pyopencv_from(p->v.cornerRefinementMethod); |  | 33220 | return pyopencv_from(p->v.cornerRefinementMethod);
| 33269 | } |  | 33221 | }
| 33270 |  |  | 33222 |
| 33271 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementMethod(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33223 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementMethod(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33272 | { |  | 33224 | {
| 33273 | if (!value) |  | 33225 | if (!value)
| 33274 | { |  | 33226 | {
| 33275 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementMethod attribute"); |  | 33227 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementMethod attribute");
| 33276 | return -1; |  | 33228 | return -1;
| 33277 | } |  | 33229 | }
| 33278 | return pyopencv_to_safe(value, p->v.cornerRefinementMethod, ArgInfo("value", 0)) ? 0 : -1; |  | 33230 | return pyopencv_to_safe(value, p->v.cornerRefinementMethod, ArgInfo("value", 0)) ? 0 : -1;
| 33279 | } |  | 33231 | }
| 33280 |  |  | 33232 |
| 33281 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementMinAccuracy(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33233 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementMinAccuracy(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33282 | { |  | 33234 | {
| 33283 | return pyopencv_from(p->v.cornerRefinementMinAccuracy); |  | 33235 | return pyopencv_from(p->v.cornerRefinementMinAccuracy);
| 33284 | } |  | 33236 | }
| 33285 |  |  | 33237 |
| 33286 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementMinAccuracy(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33238 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementMinAccuracy(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33287 | { |  | 33239 | {
| 33288 | if (!value) |  | 33240 | if (!value)
| 33289 | { |  | 33241 | {
| 33290 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementMinAccuracy attribute"); |  | 33242 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementMinAccuracy attribute");
| 33291 | return -1; |  | 33243 | return -1;
| 33292 | } |  | 33244 | }
| 33293 | return pyopencv_to_safe(value, p->v.cornerRefinementMinAccuracy, ArgInfo("value", 0)) ? 0 : -1; |  | 33245 | return pyopencv_to_safe(value, p->v.cornerRefinementMinAccuracy, ArgInfo("value", 0)) ? 0 : -1;
| 33294 | } |  | 33246 | }
| 33295 |  |  | 33247 |
| 33296 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementWinSize(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33248 | static PyObject* pyopencv_aruco_DetectorParameters_get_cornerRefinementWinSize(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33297 | { |  | 33249 | {
| 33298 | return pyopencv_from(p->v.cornerRefinementWinSize); |  | 33250 | return pyopencv_from(p->v.cornerRefinementWinSize);
| 33299 | } |  | 33251 | }
| 33300 |  |  | 33252 |
| 33301 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementWinSize(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33253 | static int pyopencv_aruco_DetectorParameters_set_cornerRefinementWinSize(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33302 | { |  | 33254 | {
| 33303 | if (!value) |  | 33255 | if (!value)
| 33304 | { |  | 33256 | {
| 33305 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementWinSize attribute"); |  | 33257 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cornerRefinementWinSize attribute");
| 33306 | return -1; |  | 33258 | return -1;
| 33307 | } |  | 33259 | }
| 33308 | return pyopencv_to_safe(value, p->v.cornerRefinementWinSize, ArgInfo("value", 0)) ? 0 : -1; |  | 33260 | return pyopencv_to_safe(value, p->v.cornerRefinementWinSize, ArgInfo("value", 0)) ? 0 : -1;
| 33309 | } |  | 33261 | }
| 33310 |  |  | 33262 |
| 33311 | static PyObject* pyopencv_aruco_DetectorParameters_get_detectInvertedMarker(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33263 | static PyObject* pyopencv_aruco_DetectorParameters_get_detectInvertedMarker(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33312 | { |  | 33264 | {
| 33313 | return pyopencv_from(p->v.detectInvertedMarker); |  | 33265 | return pyopencv_from(p->v.detectInvertedMarker);
| 33314 | } |  | 33266 | }
| 33315 |  |  | 33267 |
| 33316 | static int pyopencv_aruco_DetectorParameters_set_detectInvertedMarker(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33268 | static int pyopencv_aruco_DetectorParameters_set_detectInvertedMarker(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33317 | { |  | 33269 | {
| 33318 | if (!value) |  | 33270 | if (!value)
| 33319 | { |  | 33271 | {
| 33320 | PyErr_SetString(PyExc_TypeError, "Cannot delete the detectInvertedMarker attribute"); |  | 33272 | PyErr_SetString(PyExc_TypeError, "Cannot delete the detectInvertedMarker attribute");
| 33321 | return -1; |  | 33273 | return -1;
| 33322 | } |  | 33274 | }
| 33323 | return pyopencv_to_safe(value, p->v.detectInvertedMarker, ArgInfo("value", 0)) ? 0 : -1; |  | 33275 | return pyopencv_to_safe(value, p->v.detectInvertedMarker, ArgInfo("value", 0)) ? 0 : -1;
| 33324 | } |  | 33276 | }
| 33325 |  |  | 33277 |
| 33326 | static PyObject* pyopencv_aruco_DetectorParameters_get_errorCorrectionRate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33278 | static PyObject* pyopencv_aruco_DetectorParameters_get_errorCorrectionRate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33327 | { |  | 33279 | {
| 33328 | return pyopencv_from(p->v.errorCorrectionRate); |  | 33280 | return pyopencv_from(p->v.errorCorrectionRate);
| 33329 | } |  | 33281 | }
| 33330 |  |  | 33282 |
| 33331 | static int pyopencv_aruco_DetectorParameters_set_errorCorrectionRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33283 | static int pyopencv_aruco_DetectorParameters_set_errorCorrectionRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33332 | { |  | 33284 | {
| 33333 | if (!value) |  | 33285 | if (!value)
| 33334 | { |  | 33286 | {
| 33335 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCorrectionRate attribute"); |  | 33287 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCorrectionRate attribute");
| 33336 | return -1; |  | 33288 | return -1;
| 33337 | } |  | 33289 | }
| 33338 | return pyopencv_to_safe(value, p->v.errorCorrectionRate, ArgInfo("value", 0)) ? 0 : -1; |  | 33290 | return pyopencv_to_safe(value, p->v.errorCorrectionRate, ArgInfo("value", 0)) ? 0 : -1;
| 33339 | } |  | 33291 | }
| 33340 |  |  | 33292 |
| 33341 | static PyObject* pyopencv_aruco_DetectorParameters_get_markerBorderBits(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33293 | static PyObject* pyopencv_aruco_DetectorParameters_get_markerBorderBits(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33342 | { |  | 33294 | {
| 33343 | return pyopencv_from(p->v.markerBorderBits); |  | 33295 | return pyopencv_from(p->v.markerBorderBits);
| 33344 | } |  | 33296 | }
| 33345 |  |  | 33297 |
| 33346 | static int pyopencv_aruco_DetectorParameters_set_markerBorderBits(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33298 | static int pyopencv_aruco_DetectorParameters_set_markerBorderBits(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33347 | { |  | 33299 | {
| 33348 | if (!value) |  | 33300 | if (!value)
| 33349 | { |  | 33301 | {
| 33350 | PyErr_SetString(PyExc_TypeError, "Cannot delete the markerBorderBits attribute"); |  | 33302 | PyErr_SetString(PyExc_TypeError, "Cannot delete the markerBorderBits attribute");
| 33351 | return -1; |  | 33303 | return -1;
| 33352 | } |  | 33304 | }
| 33353 | return pyopencv_to_safe(value, p->v.markerBorderBits, ArgInfo("value", 0)) ? 0 : -1; |  | 33305 | return pyopencv_to_safe(value, p->v.markerBorderBits, ArgInfo("value", 0)) ? 0 : -1;
| 33354 | } |  | 33306 | }
| 33355 |  |  | 33307 |
| 33356 | static PyObject* pyopencv_aruco_DetectorParameters_get_maxErroneousBitsInBorderRate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33308 | static PyObject* pyopencv_aruco_DetectorParameters_get_maxErroneousBitsInBorderRate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33357 | { |  | 33309 | {
| 33358 | return pyopencv_from(p->v.maxErroneousBitsInBorderRate); |  | 33310 | return pyopencv_from(p->v.maxErroneousBitsInBorderRate);
| 33359 | } |  | 33311 | }
| 33360 |  |  | 33312 |
| 33361 | static int pyopencv_aruco_DetectorParameters_set_maxErroneousBitsInBorderRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33313 | static int pyopencv_aruco_DetectorParameters_set_maxErroneousBitsInBorderRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33362 | { |  | 33314 | {
| 33363 | if (!value) |  | 33315 | if (!value)
| 33364 | { |  | 33316 | {
| 33365 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxErroneousBitsInBorderRate attribute"); |  | 33317 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxErroneousBitsInBorderRate attribute");
| 33366 | return -1; |  | 33318 | return -1;
| 33367 | } |  | 33319 | }
| 33368 | return pyopencv_to_safe(value, p->v.maxErroneousBitsInBorderRate, ArgInfo("value", 0)) ? 0 : -1; |  | 33320 | return pyopencv_to_safe(value, p->v.maxErroneousBitsInBorderRate, ArgInfo("value", 0)) ? 0 : -1;
| 33369 | } |  | 33321 | }
| 33370 |  |  | 33322 |
| 33371 | static PyObject* pyopencv_aruco_DetectorParameters_get_maxMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33323 | static PyObject* pyopencv_aruco_DetectorParameters_get_maxMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33372 | { |  | 33324 | {
| 33373 | return pyopencv_from(p->v.maxMarkerPerimeterRate); |  | 33325 | return pyopencv_from(p->v.maxMarkerPerimeterRate);
| 33374 | } |  | 33326 | }
| 33375 |  |  | 33327 |
| 33376 | static int pyopencv_aruco_DetectorParameters_set_maxMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33328 | static int pyopencv_aruco_DetectorParameters_set_maxMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33377 | { |  | 33329 | {
| 33378 | if (!value) |  | 33330 | if (!value)
| 33379 | { |  | 33331 | {
| 33380 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxMarkerPerimeterRate attribute"); |  | 33332 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxMarkerPerimeterRate attribute");
| 33381 | return -1; |  | 33333 | return -1;
| 33382 | } |  | 33334 | }
| 33383 | return pyopencv_to_safe(value, p->v.maxMarkerPerimeterRate, ArgInfo("value", 0)) ? 0 : -1; |  | 33335 | return pyopencv_to_safe(value, p->v.maxMarkerPerimeterRate, ArgInfo("value", 0)) ? 0 : -1;
| 33384 | } |  | 33336 | }
| 33385 |  |  | 33337 |
| 33386 | static PyObject* pyopencv_aruco_DetectorParameters_get_minCornerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33338 | static PyObject* pyopencv_aruco_DetectorParameters_get_minCornerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33387 | { |  | 33339 | {
| 33388 | return pyopencv_from(p->v.minCornerDistanceRate); |  | 33340 | return pyopencv_from(p->v.minCornerDistanceRate);
| 33389 | } |  | 33341 | }
| 33390 |  |  | 33342 |
| 33391 | static int pyopencv_aruco_DetectorParameters_set_minCornerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33343 | static int pyopencv_aruco_DetectorParameters_set_minCornerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33392 | { |  | 33344 | {
| 33393 | if (!value) |  | 33345 | if (!value)
| 33394 | { |  | 33346 | {
| 33395 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minCornerDistanceRate attribute"); |  | 33347 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minCornerDistanceRate attribute");
| 33396 | return -1; |  | 33348 | return -1;
| 33397 | } |  | 33349 | }
| 33398 | return pyopencv_to_safe(value, p->v.minCornerDistanceRate, ArgInfo("value", 0)) ? 0 : -1; |  | 33350 | return pyopencv_to_safe(value, p->v.minCornerDistanceRate, ArgInfo("value", 0)) ? 0 : -1;
| 33399 | } |  | 33351 | }
| 33400 |  |  | 33352 |
| 33401 | static PyObject* pyopencv_aruco_DetectorParameters_get_minDistanceToBorder(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33353 | static PyObject* pyopencv_aruco_DetectorParameters_get_minDistanceToBorder(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33402 | { |  | 33354 | {
| 33403 | return pyopencv_from(p->v.minDistanceToBorder); |  | 33355 | return pyopencv_from(p->v.minDistanceToBorder);
| 33404 | } |  | 33356 | }
| 33405 |  |  | 33357 |
| 33406 | static int pyopencv_aruco_DetectorParameters_set_minDistanceToBorder(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33358 | static int pyopencv_aruco_DetectorParameters_set_minDistanceToBorder(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33407 | { |  | 33359 | {
| 33408 | if (!value) |  | 33360 | if (!value)
| 33409 | { |  | 33361 | {
| 33410 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDistanceToBorder attribute"); |  | 33362 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minDistanceToBorder attribute");
| 33411 | return -1; |  | 33363 | return -1;
| 33412 | } |  | 33364 | }
| 33413 | return pyopencv_to_safe(value, p->v.minDistanceToBorder, ArgInfo("value", 0)) ? 0 : -1; |  | 33365 | return pyopencv_to_safe(value, p->v.minDistanceToBorder, ArgInfo("value", 0)) ? 0 : -1;
| 33414 | } |  | 33366 | }
| 33415 |  |  | 33367 |
| 33416 | static PyObject* pyopencv_aruco_DetectorParameters_get_minGroupDistance(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33368 | static PyObject* pyopencv_aruco_DetectorParameters_get_minGroupDistance(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33417 | { |  | 33369 | {
| 33418 | return pyopencv_from(p->v.minGroupDistance); |  | 33370 | return pyopencv_from(p->v.minGroupDistance);
| 33419 | } |  | 33371 | }
| 33420 |  |  | 33372 |
| 33421 | static int pyopencv_aruco_DetectorParameters_set_minGroupDistance(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33373 | static int pyopencv_aruco_DetectorParameters_set_minGroupDistance(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33422 | { |  | 33374 | {
| 33423 | if (!value) |  | 33375 | if (!value)
| 33424 | { |  | 33376 | {
| 33425 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minGroupDistance attribute"); |  | 33377 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minGroupDistance attribute");
| 33426 | return -1; |  | 33378 | return -1;
| 33427 | } |  | 33379 | }
| 33428 | return pyopencv_to_safe(value, p->v.minGroupDistance, ArgInfo("value", 0)) ? 0 : -1; |  | 33380 | return pyopencv_to_safe(value, p->v.minGroupDistance, ArgInfo("value", 0)) ? 0 : -1;
| 33429 | } |  | 33381 | }
| 33430 |  |  | 33382 |
| 33431 | static PyObject* pyopencv_aruco_DetectorParameters_get_minMarkerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33383 | static PyObject* pyopencv_aruco_DetectorParameters_get_minMarkerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33432 | { |  | 33384 | {
| 33433 | return pyopencv_from(p->v.minMarkerDistanceRate); |  | 33385 | return pyopencv_from(p->v.minMarkerDistanceRate);
| 33434 | } |  | 33386 | }
| 33435 |  |  | 33387 |
| 33436 | static int pyopencv_aruco_DetectorParameters_set_minMarkerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33388 | static int pyopencv_aruco_DetectorParameters_set_minMarkerDistanceRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33437 | { |  | 33389 | {
| 33438 | if (!value) |  | 33390 | if (!value)
| 33439 | { |  | 33391 | {
| 33440 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkerDistanceRate attribute"); |  | 33392 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkerDistanceRate attribute");
| 33441 | return -1; |  | 33393 | return -1;
| 33442 | } |  | 33394 | }
| 33443 | return pyopencv_to_safe(value, p->v.minMarkerDistanceRate, ArgInfo("value", 0)) ? 0 : -1; |  | 33395 | return pyopencv_to_safe(value, p->v.minMarkerDistanceRate, ArgInfo("value", 0)) ? 0 : -1;
| 33444 | } |  | 33396 | }
| 33445 |  |  | 33397 |
| 33446 | static PyObject* pyopencv_aruco_DetectorParameters_get_minMarkerLengthRatioOriginalImg(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33398 | static PyObject* pyopencv_aruco_DetectorParameters_get_minMarkerLengthRatioOriginalImg(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33447 | { |  | 33399 | {
| 33448 | return pyopencv_from(p->v.minMarkerLengthRatioOriginalImg); |  | 33400 | return pyopencv_from(p->v.minMarkerLengthRatioOriginalImg);
| 33449 | } |  | 33401 | }
| 33450 |  |  | 33402 |
| 33451 | static int pyopencv_aruco_DetectorParameters_set_minMarkerLengthRatioOriginalImg(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33403 | static int pyopencv_aruco_DetectorParameters_set_minMarkerLengthRatioOriginalImg(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33452 | { |  | 33404 | {
| 33453 | if (!value) |  | 33405 | if (!value)
| 33454 | { |  | 33406 | {
| 33455 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkerLengthRatioOriginalImg attribute"); |  | 33407 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkerLengthRatioOriginalImg attribute");
| 33456 | return -1; |  | 33408 | return -1;
| 33457 | } |  | 33409 | }
| 33458 | return pyopencv_to_safe(value, p->v.minMarkerLengthRatioOriginalImg, ArgInfo("value", 0)) ? 0 : -1; |  | 33410 | return pyopencv_to_safe(value, p->v.minMarkerLengthRatioOriginalImg, ArgInfo("value", 0)) ? 0 : -1;
| 33459 | } |  | 33411 | }
| 33460 |  |  | 33412 |
| 33461 | static PyObject* pyopencv_aruco_DetectorParameters_get_minMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33413 | static PyObject* pyopencv_aruco_DetectorParameters_get_minMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33462 | { |  | 33414 | {
| 33463 | return pyopencv_from(p->v.minMarkerPerimeterRate); |  | 33415 | return pyopencv_from(p->v.minMarkerPerimeterRate);
| 33464 | } |  | 33416 | }
| 33465 |  |  | 33417 |
| 33466 | static int pyopencv_aruco_DetectorParameters_set_minMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33418 | static int pyopencv_aruco_DetectorParameters_set_minMarkerPerimeterRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33467 | { |  | 33419 | {
| 33468 | if (!value) |  | 33420 | if (!value)
| 33469 | { |  | 33421 | {
| 33470 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkerPerimeterRate attribute"); |  | 33422 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minMarkerPerimeterRate attribute");
| 33471 | return -1; |  | 33423 | return -1;
| 33472 | } |  | 33424 | }
| 33473 | return pyopencv_to_safe(value, p->v.minMarkerPerimeterRate, ArgInfo("value", 0)) ? 0 : -1; |  | 33425 | return pyopencv_to_safe(value, p->v.minMarkerPerimeterRate, ArgInfo("value", 0)) ? 0 : -1;
| 33474 | } |  | 33426 | }
| 33475 |  |  | 33427 |
| 33476 | static PyObject* pyopencv_aruco_DetectorParameters_get_minOtsuStdDev(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33428 | static PyObject* pyopencv_aruco_DetectorParameters_get_minOtsuStdDev(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33477 | { |  | 33429 | {
| 33478 | return pyopencv_from(p->v.minOtsuStdDev); |  | 33430 | return pyopencv_from(p->v.minOtsuStdDev);
| 33479 | } |  | 33431 | }
| 33480 |  |  | 33432 |
| 33481 | static int pyopencv_aruco_DetectorParameters_set_minOtsuStdDev(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33433 | static int pyopencv_aruco_DetectorParameters_set_minOtsuStdDev(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33482 | { |  | 33434 | {
| 33483 | if (!value) |  | 33435 | if (!value)
| 33484 | { |  | 33436 | {
| 33485 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minOtsuStdDev attribute"); |  | 33437 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minOtsuStdDev attribute");
| 33486 | return -1; |  | 33438 | return -1;
| 33487 | } |  | 33439 | }
| 33488 | return pyopencv_to_safe(value, p->v.minOtsuStdDev, ArgInfo("value", 0)) ? 0 : -1; |  | 33440 | return pyopencv_to_safe(value, p->v.minOtsuStdDev, ArgInfo("value", 0)) ? 0 : -1;
| 33489 | } |  | 33441 | }
| 33490 |  |  | 33442 |
| 33491 | static PyObject* pyopencv_aruco_DetectorParameters_get_minSideLengthCanonicalImg(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33443 | static PyObject* pyopencv_aruco_DetectorParameters_get_minSideLengthCanonicalImg(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33492 | { |  | 33444 | {
| 33493 | return pyopencv_from(p->v.minSideLengthCanonicalImg); |  | 33445 | return pyopencv_from(p->v.minSideLengthCanonicalImg);
| 33494 | } |  | 33446 | }
| 33495 |  |  | 33447 |
| 33496 | static int pyopencv_aruco_DetectorParameters_set_minSideLengthCanonicalImg(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33448 | static int pyopencv_aruco_DetectorParameters_set_minSideLengthCanonicalImg(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33497 | { |  | 33449 | {
| 33498 | if (!value) |  | 33450 | if (!value)
| 33499 | { |  | 33451 | {
| 33500 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minSideLengthCanonicalImg attribute"); |  | 33452 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minSideLengthCanonicalImg attribute");
| 33501 | return -1; |  | 33453 | return -1;
| 33502 | } |  | 33454 | }
| 33503 | return pyopencv_to_safe(value, p->v.minSideLengthCanonicalImg, ArgInfo("value", 0)) ? 0 : -1; |  | 33455 | return pyopencv_to_safe(value, p->v.minSideLengthCanonicalImg, ArgInfo("value", 0)) ? 0 : -1;
| 33504 | } |  | 33456 | }
| 33505 |  |  | 33457 |
| 33506 | static PyObject* pyopencv_aruco_DetectorParameters_get_perspectiveRemoveIgnoredMarginPerCell(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33458 | static PyObject* pyopencv_aruco_DetectorParameters_get_perspectiveRemoveIgnoredMarginPerCell(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33507 | { |  | 33459 | {
| 33508 | return pyopencv_from(p->v.perspectiveRemoveIgnoredMarginPerCell); |  | 33460 | return pyopencv_from(p->v.perspectiveRemoveIgnoredMarginPerCell);
| 33509 | } |  | 33461 | }
| 33510 |  |  | 33462 |
| 33511 | static int pyopencv_aruco_DetectorParameters_set_perspectiveRemoveIgnoredMarginPerCell(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33463 | static int pyopencv_aruco_DetectorParameters_set_perspectiveRemoveIgnoredMarginPerCell(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33512 | { |  | 33464 | {
| 33513 | if (!value) |  | 33465 | if (!value)
| 33514 | { |  | 33466 | {
| 33515 | PyErr_SetString(PyExc_TypeError, "Cannot delete the perspectiveRemoveIgnoredMarginPerCell attribute"); |  | 33467 | PyErr_SetString(PyExc_TypeError, "Cannot delete the perspectiveRemoveIgnoredMarginPerCell attribute");
| 33516 | return -1; |  | 33468 | return -1;
| 33517 | } |  | 33469 | }
| 33518 | return pyopencv_to_safe(value, p->v.perspectiveRemoveIgnoredMarginPerCell, ArgInfo("value", 0)) ? 0 : -1; |  | 33470 | return pyopencv_to_safe(value, p->v.perspectiveRemoveIgnoredMarginPerCell, ArgInfo("value", 0)) ? 0 : -1;
| 33519 | } |  | 33471 | }
| 33520 |  |  | 33472 |
| 33521 | static PyObject* pyopencv_aruco_DetectorParameters_get_perspectiveRemovePixelPerCell(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33473 | static PyObject* pyopencv_aruco_DetectorParameters_get_perspectiveRemovePixelPerCell(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33522 | { |  | 33474 | {
| 33523 | return pyopencv_from(p->v.perspectiveRemovePixelPerCell); |  | 33475 | return pyopencv_from(p->v.perspectiveRemovePixelPerCell);
| 33524 | } |  | 33476 | }
| 33525 |  |  | 33477 |
| 33526 | static int pyopencv_aruco_DetectorParameters_set_perspectiveRemovePixelPerCell(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33478 | static int pyopencv_aruco_DetectorParameters_set_perspectiveRemovePixelPerCell(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33527 | { |  | 33479 | {
| 33528 | if (!value) |  | 33480 | if (!value)
| 33529 | { |  | 33481 | {
| 33530 | PyErr_SetString(PyExc_TypeError, "Cannot delete the perspectiveRemovePixelPerCell attribute"); |  | 33482 | PyErr_SetString(PyExc_TypeError, "Cannot delete the perspectiveRemovePixelPerCell attribute");
| 33531 | return -1; |  | 33483 | return -1;
| 33532 | } |  | 33484 | }
| 33533 | return pyopencv_to_safe(value, p->v.perspectiveRemovePixelPerCell, ArgInfo("value", 0)) ? 0 : -1; |  | 33485 | return pyopencv_to_safe(value, p->v.perspectiveRemovePixelPerCell, ArgInfo("value", 0)) ? 0 : -1;
| 33534 | } |  | 33486 | }
| 33535 |  |  | 33487 |
| 33536 | static PyObject* pyopencv_aruco_DetectorParameters_get_polygonalApproxAccuracyRate(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33488 | static PyObject* pyopencv_aruco_DetectorParameters_get_polygonalApproxAccuracyRate(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33537 | { |  | 33489 | {
| 33538 | return pyopencv_from(p->v.polygonalApproxAccuracyRate); |  | 33490 | return pyopencv_from(p->v.polygonalApproxAccuracyRate);
| 33539 | } |  | 33491 | }
| 33540 |  |  | 33492 |
| 33541 | static int pyopencv_aruco_DetectorParameters_set_polygonalApproxAccuracyRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33493 | static int pyopencv_aruco_DetectorParameters_set_polygonalApproxAccuracyRate(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33542 | { |  | 33494 | {
| 33543 | if (!value) |  | 33495 | if (!value)
| 33544 | { |  | 33496 | {
| 33545 | PyErr_SetString(PyExc_TypeError, "Cannot delete the polygonalApproxAccuracyRate attribute"); |  | 33497 | PyErr_SetString(PyExc_TypeError, "Cannot delete the polygonalApproxAccuracyRate attribute");
| 33546 | return -1; |  | 33498 | return -1;
| 33547 | } |  | 33499 | }
| 33548 | return pyopencv_to_safe(value, p->v.polygonalApproxAccuracyRate, ArgInfo("value", 0)) ? 0 : -1; |  | 33500 | return pyopencv_to_safe(value, p->v.polygonalApproxAccuracyRate, ArgInfo("value", 0)) ? 0 : -1;
| 33549 | } |  | 33501 | }
| 33550 |  |  | 33502 |
| 33551 | static PyObject* pyopencv_aruco_DetectorParameters_get_relativeCornerRefinmentWinSize(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33503 | static PyObject* pyopencv_aruco_DetectorParameters_get_relativeCornerRefinmentWinSize(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33552 | { |  | 33504 | {
| 33553 | return pyopencv_from(p->v.relativeCornerRefinmentWinSize); |  | 33505 | return pyopencv_from(p->v.relativeCornerRefinmentWinSize);
| 33554 | } |  | 33506 | }
| 33555 |  |  | 33507 |
| 33556 | static int pyopencv_aruco_DetectorParameters_set_relativeCornerRefinmentWinSize(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33508 | static int pyopencv_aruco_DetectorParameters_set_relativeCornerRefinmentWinSize(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33557 | { |  | 33509 | {
| 33558 | if (!value) |  | 33510 | if (!value)
| 33559 | { |  | 33511 | {
| 33560 | PyErr_SetString(PyExc_TypeError, "Cannot delete the relativeCornerRefinmentWinSize attribute"); |  | 33512 | PyErr_SetString(PyExc_TypeError, "Cannot delete the relativeCornerRefinmentWinSize attribute");
| 33561 | return -1; |  | 33513 | return -1;
| 33562 | } |  | 33514 | }
| 33563 | return pyopencv_to_safe(value, p->v.relativeCornerRefinmentWinSize, ArgInfo("value", 0)) ? 0 : -1; |  | 33515 | return pyopencv_to_safe(value, p->v.relativeCornerRefinmentWinSize, ArgInfo("value", 0)) ? 0 : -1;
| 33564 | } |  | 33516 | }
| 33565 |  |  | 33517 |
| 33566 | static PyObject* pyopencv_aruco_DetectorParameters_get_useAruco3Detection(pyopencv_aruco_DetectorParameters_t* p, void *closure) |  | 33518 | static PyObject* pyopencv_aruco_DetectorParameters_get_useAruco3Detection(pyopencv_aruco_DetectorParameters_t* p, void *closure)
| 33567 | { |  | 33519 | {
| 33568 | return pyopencv_from(p->v.useAruco3Detection); |  | 33520 | return pyopencv_from(p->v.useAruco3Detection);
| 33569 | } |  | 33521 | }
| 33570 |  |  | 33522 |
| 33571 | static int pyopencv_aruco_DetectorParameters_set_useAruco3Detection(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure) |  | 33523 | static int pyopencv_aruco_DetectorParameters_set_useAruco3Detection(pyopencv_aruco_DetectorParameters_t* p, PyObject *value, void *closure)
| 33572 | { |  | 33524 | {
| 33573 | if (!value) |  | 33525 | if (!value)
| 33574 | { |  | 33526 | {
| 33575 | PyErr_SetString(PyExc_TypeError, "Cannot delete the useAruco3Detection attribute"); |  | 33527 | PyErr_SetString(PyExc_TypeError, "Cannot delete the useAruco3Detection attribute");
| 33576 | return -1; |  | 33528 | return -1;
| 33577 | } |  | 33529 | }
| 33578 | return pyopencv_to_safe(value, p->v.useAruco3Detection, ArgInfo("value", 0)) ? 0 : -1; |  | 33530 | return pyopencv_to_safe(value, p->v.useAruco3Detection, ArgInfo("value", 0)) ? 0 : -1;
| 33579 | } |  | 33531 | }
| 33580 |  |  | 33532 |
| 33581 |  |  | 33533 |
| 33582 | // Methods (aruco_DetectorParameters) |  | 33534 | // Methods (aruco_DetectorParameters)
| 33583 |  |  | 33535 |
| 33584 | static int pyopencv_cv_aruco_aruco_DetectorParameters_DetectorParameters(pyopencv_aruco_DetectorParameters_t* self, PyObject* py_args, PyObject* kw) |  | 33536 | static int pyopencv_cv_aruco_aruco_DetectorParameters_DetectorParameters(pyopencv_aruco_DetectorParameters_t* self, PyObject* py_args, PyObject* kw)
| 33585 | { |  | 33537 | {
| 33586 | using namespace cv::aruco; |  | 33538 | using namespace cv::aruco;
| 33587 |  |  | 33539 |
| 33588 |  |  | 33540 |
| 33589 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 33541 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 33590 | { |  | 33542 | {
| 33591 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::DetectorParameters()); |  | 33543 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::DetectorParameters());
| 33592 | return 0; |  | 33544 | return 0;
| 33593 | } |  | 33545 | }
| 33594 |  |  | 33546 |
| 33595 | return -1; |  | 33547 | return -1;
| 33596 | } |  | 33548 | }
| 33597 |  |  | 33549 |
| 33598 | static PyObject* pyopencv_cv_aruco_aruco_DetectorParameters_readDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33550 | static PyObject* pyopencv_cv_aruco_aruco_DetectorParameters_readDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 33599 | { |  | 33551 | {
| 33600 | using namespace cv::aruco; |  | 33552 | using namespace cv::aruco;
| 33601 |  |  | 33553 |
| 33602 |  |  | 33554 |
| 33603 | cv::aruco::DetectorParameters * self1 = 0; |  | 33555 | cv::aruco::DetectorParameters * self1 = 0;
| 33604 | if (!pyopencv_aruco_DetectorParameters_getp(self, self1)) |  | 33556 | if (!pyopencv_aruco_DetectorParameters_getp(self, self1))
| 33605 | return failmsgp("Incorrect type of self (must be 'aruco_DetectorParameters' or its derivative)"); |  | 33557 | return failmsgp("Incorrect type of self (must be 'aruco_DetectorParameters' or its derivative)");
| 33606 | cv::aruco::DetectorParameters* _self_ = (self1); |  | 33558 | cv::aruco::DetectorParameters* _self_ = (self1);
| 33607 | PyObject* pyobj_fn = NULL; |  | 33559 | PyObject* pyobj_fn = NULL;
| 33608 | cv::FileNode fn; |  | 33560 | cv::FileNode fn;
| 33609 | bool retval; |  | 33561 | bool retval;
| 33610 |  |  | 33562 |
| 33611 | const char* keywords[] = { "fn", NULL }; |  | 33563 | const char* keywords[] = { "fn", NULL };
| 33612 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_DetectorParameters.readDetectorParameters", (char**)keywords, &pyobj_fn) && |  | 33564 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_DetectorParameters.readDetectorParameters", (char**)keywords, &pyobj_fn) &&
| 33613 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 33565 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 33614 | { |  | 33566 | {
| 33615 | ERRWRAP2(retval = _self_->readDetectorParameters(fn)); |  | 33567 | ERRWRAP2(retval = _self_->readDetectorParameters(fn));
| 33616 | return pyopencv_from(retval); |  | 33568 | return pyopencv_from(retval);
| 33617 | } |  | 33569 | }
| 33618 |  |  | 33570 |
| 33619 | return NULL; |  | 33571 | return NULL;
| 33620 | } |  | 33572 | }
| 33621 |  |  | 33573 |
| 33622 | static PyObject* pyopencv_cv_aruco_aruco_DetectorParameters_writeDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33574 | static PyObject* pyopencv_cv_aruco_aruco_DetectorParameters_writeDetectorParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 33623 | { |  | 33575 | {
| 33624 | using namespace cv::aruco; |  | 33576 | using namespace cv::aruco;
| 33625 |  |  | 33577 |
| 33626 |  |  | 33578 |
| 33627 | cv::aruco::DetectorParameters * self1 = 0; |  | 33579 | cv::aruco::DetectorParameters * self1 = 0;
| 33628 | if (!pyopencv_aruco_DetectorParameters_getp(self, self1)) |  | 33580 | if (!pyopencv_aruco_DetectorParameters_getp(self, self1))
| 33629 | return failmsgp("Incorrect type of self (must be 'aruco_DetectorParameters' or its derivative)"); |  | 33581 | return failmsgp("Incorrect type of self (must be 'aruco_DetectorParameters' or its derivative)");
| 33630 | cv::aruco::DetectorParameters* _self_ = (self1); |  | 33582 | cv::aruco::DetectorParameters* _self_ = (self1);
| 33631 | PyObject* pyobj_fs = NULL; |  | 33583 | PyObject* pyobj_fs = NULL;
| 33632 | Ptr<cv::FileStorage> fs; |  | 33584 | Ptr<cv::FileStorage> fs;
| 33633 | PyObject* pyobj_name = NULL; |  | 33585 | PyObject* pyobj_name = NULL;
| 33634 | String name; |  | 33586 | String name;
| 33635 | bool retval; |  | 33587 | bool retval;
| 33636 |  |  | 33588 |
| 33637 | const char* keywords[] = { "fs", "name", NULL }; |  | 33589 | const char* keywords[] = { "fs", "name", NULL };
| 33638 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:aruco_DetectorParameters.writeDetectorParameters", (char**)keywords, &pyobj_fs, &pyobj_name) && |  | 33590 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:aruco_DetectorParameters.writeDetectorParameters", (char**)keywords, &pyobj_fs, &pyobj_name) &&
| 33639 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) && |  | 33591 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) &&
| 33640 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 33592 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 33641 | { |  | 33593 | {
| 33642 | ERRWRAP2(retval = _self_->writeDetectorParameters(*fs, name)); |  | 33594 | ERRWRAP2(retval = _self_->writeDetectorParameters(*fs, name));
| 33643 | return pyopencv_from(retval); |  | 33595 | return pyopencv_from(retval);
| 33644 | } |  | 33596 | }
| 33645 |  |  | 33597 |
| 33646 | return NULL; |  | 33598 | return NULL;
| 33647 | } |  | 33599 | }
| 33648 |  |  | 33600 |
| 33649 |  |  | 33601 |
| 33650 |  |  | 33602 |
| 33651 | // Tables (aruco_DetectorParameters) |  | 33603 | // Tables (aruco_DetectorParameters)
| 33652 |  |  | 33604 |
| 33653 | static PyGetSetDef pyopencv_aruco_DetectorParameters_getseters[] = |  | 33605 | static PyGetSetDef pyopencv_aruco_DetectorParameters_getseters[] =
| 33654 | { |  | 33606 | {
| 33655 | {(char*)"adaptiveThreshConstant", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshConstant, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshConstant, (char*)"adaptiveThreshConstant", NULL}, |  | 33607 | {(char*)"adaptiveThreshConstant", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshConstant, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshConstant, (char*)"adaptiveThreshConstant", NULL},
| 33656 | {(char*)"adaptiveThreshWinSizeMax", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMax, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMax, (char*)"adaptiveThreshWinSizeMax", NULL}, |  | 33608 | {(char*)"adaptiveThreshWinSizeMax", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMax, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMax, (char*)"adaptiveThreshWinSizeMax", NULL},
| 33657 | {(char*)"adaptiveThreshWinSizeMin", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMin, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMin, (char*)"adaptiveThreshWinSizeMin", NULL}, |  | 33609 | {(char*)"adaptiveThreshWinSizeMin", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeMin, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeMin, (char*)"adaptiveThreshWinSizeMin", NULL},
| 33658 | {(char*)"adaptiveThreshWinSizeStep", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeStep, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeStep, (char*)"adaptiveThreshWinSizeStep", NULL}, |  | 33610 | {(char*)"adaptiveThreshWinSizeStep", (getter)pyopencv_aruco_DetectorParameters_get_adaptiveThreshWinSizeStep, (setter)pyopencv_aruco_DetectorParameters_set_adaptiveThreshWinSizeStep, (char*)"adaptiveThreshWinSizeStep", NULL},
| 33659 | {(char*)"aprilTagCriticalRad", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagCriticalRad, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagCriticalRad, (char*)"aprilTagCriticalRad", NULL}, |  | 33611 | {(char*)"aprilTagCriticalRad", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagCriticalRad, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagCriticalRad, (char*)"aprilTagCriticalRad", NULL},
| 33660 | {(char*)"aprilTagDeglitch", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagDeglitch, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagDeglitch, (char*)"aprilTagDeglitch", NULL}, |  | 33612 | {(char*)"aprilTagDeglitch", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagDeglitch, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagDeglitch, (char*)"aprilTagDeglitch", NULL},
| 33661 | {(char*)"aprilTagMaxLineFitMse", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMaxLineFitMse, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMaxLineFitMse, (char*)"aprilTagMaxLineFitMse", NULL}, |  | 33613 | {(char*)"aprilTagMaxLineFitMse", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMaxLineFitMse, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMaxLineFitMse, (char*)"aprilTagMaxLineFitMse", NULL},
| 33662 | {(char*)"aprilTagMaxNmaxima", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMaxNmaxima, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMaxNmaxima, (char*)"aprilTagMaxNmaxima", NULL}, |  | 33614 | {(char*)"aprilTagMaxNmaxima", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMaxNmaxima, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMaxNmaxima, (char*)"aprilTagMaxNmaxima", NULL},
| 33663 | {(char*)"aprilTagMinClusterPixels", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMinClusterPixels, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMinClusterPixels, (char*)"aprilTagMinClusterPixels", NULL}, |  | 33615 | {(char*)"aprilTagMinClusterPixels", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMinClusterPixels, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMinClusterPixels, (char*)"aprilTagMinClusterPixels", NULL},
| 33664 | {(char*)"aprilTagMinWhiteBlackDiff", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMinWhiteBlackDiff, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMinWhiteBlackDiff, (char*)"aprilTagMinWhiteBlackDiff", NULL}, |  | 33616 | {(char*)"aprilTagMinWhiteBlackDiff", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagMinWhiteBlackDiff, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagMinWhiteBlackDiff, (char*)"aprilTagMinWhiteBlackDiff", NULL},
| 33665 | {(char*)"aprilTagQuadDecimate", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagQuadDecimate, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagQuadDecimate, (char*)"aprilTagQuadDecimate", NULL}, |  | 33617 | {(char*)"aprilTagQuadDecimate", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagQuadDecimate, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagQuadDecimate, (char*)"aprilTagQuadDecimate", NULL},
| 33666 | {(char*)"aprilTagQuadSigma", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagQuadSigma, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagQuadSigma, (char*)"aprilTagQuadSigma", NULL}, |  | 33618 | {(char*)"aprilTagQuadSigma", (getter)pyopencv_aruco_DetectorParameters_get_aprilTagQuadSigma, (setter)pyopencv_aruco_DetectorParameters_set_aprilTagQuadSigma, (char*)"aprilTagQuadSigma", NULL},
| 33667 | {(char*)"cornerRefinementMaxIterations", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementMaxIterations, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementMaxIterations, (char*)"cornerRefinementMaxIterations", NULL}, |  | 33619 | {(char*)"cornerRefinementMaxIterations", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementMaxIterations, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementMaxIterations, (char*)"cornerRefinementMaxIterations", NULL},
| 33668 | {(char*)"cornerRefinementMethod", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementMethod, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementMethod, (char*)"cornerRefinementMethod", NULL}, |  | 33620 | {(char*)"cornerRefinementMethod", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementMethod, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementMethod, (char*)"cornerRefinementMethod", NULL},
| 33669 | {(char*)"cornerRefinementMinAccuracy", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementMinAccuracy, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementMinAccuracy, (char*)"cornerRefinementMinAccuracy", NULL}, |  | 33621 | {(char*)"cornerRefinementMinAccuracy", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementMinAccuracy, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementMinAccuracy, (char*)"cornerRefinementMinAccuracy", NULL},
| 33670 | {(char*)"cornerRefinementWinSize", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementWinSize, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementWinSize, (char*)"cornerRefinementWinSize", NULL}, |  | 33622 | {(char*)"cornerRefinementWinSize", (getter)pyopencv_aruco_DetectorParameters_get_cornerRefinementWinSize, (setter)pyopencv_aruco_DetectorParameters_set_cornerRefinementWinSize, (char*)"cornerRefinementWinSize", NULL},
| 33671 | {(char*)"detectInvertedMarker", (getter)pyopencv_aruco_DetectorParameters_get_detectInvertedMarker, (setter)pyopencv_aruco_DetectorParameters_set_detectInvertedMarker, (char*)"detectInvertedMarker", NULL}, |  | 33623 | {(char*)"detectInvertedMarker", (getter)pyopencv_aruco_DetectorParameters_get_detectInvertedMarker, (setter)pyopencv_aruco_DetectorParameters_set_detectInvertedMarker, (char*)"detectInvertedMarker", NULL},
| 33672 | {(char*)"errorCorrectionRate", (getter)pyopencv_aruco_DetectorParameters_get_errorCorrectionRate, (setter)pyopencv_aruco_DetectorParameters_set_errorCorrectionRate, (char*)"errorCorrectionRate", NULL}, |  | 33624 | {(char*)"errorCorrectionRate", (getter)pyopencv_aruco_DetectorParameters_get_errorCorrectionRate, (setter)pyopencv_aruco_DetectorParameters_set_errorCorrectionRate, (char*)"errorCorrectionRate", NULL},
| 33673 | {(char*)"markerBorderBits", (getter)pyopencv_aruco_DetectorParameters_get_markerBorderBits, (setter)pyopencv_aruco_DetectorParameters_set_markerBorderBits, (char*)"markerBorderBits", NULL}, |  | 33625 | {(char*)"markerBorderBits", (getter)pyopencv_aruco_DetectorParameters_get_markerBorderBits, (setter)pyopencv_aruco_DetectorParameters_set_markerBorderBits, (char*)"markerBorderBits", NULL},
| 33674 | {(char*)"maxErroneousBitsInBorderRate", (getter)pyopencv_aruco_DetectorParameters_get_maxErroneousBitsInBorderRate, (setter)pyopencv_aruco_DetectorParameters_set_maxErroneousBitsInBorderRate, (char*)"maxErroneousBitsInBorderRate", NULL}, |  | 33626 | {(char*)"maxErroneousBitsInBorderRate", (getter)pyopencv_aruco_DetectorParameters_get_maxErroneousBitsInBorderRate, (setter)pyopencv_aruco_DetectorParameters_set_maxErroneousBitsInBorderRate, (char*)"maxErroneousBitsInBorderRate", NULL},
| 33675 | {(char*)"maxMarkerPerimeterRate", (getter)pyopencv_aruco_DetectorParameters_get_maxMarkerPerimeterRate, (setter)pyopencv_aruco_DetectorParameters_set_maxMarkerPerimeterRate, (char*)"maxMarkerPerimeterRate", NULL}, |  | 33627 | {(char*)"maxMarkerPerimeterRate", (getter)pyopencv_aruco_DetectorParameters_get_maxMarkerPerimeterRate, (setter)pyopencv_aruco_DetectorParameters_set_maxMarkerPerimeterRate, (char*)"maxMarkerPerimeterRate", NULL},
| 33676 | {(char*)"minCornerDistanceRate", (getter)pyopencv_aruco_DetectorParameters_get_minCornerDistanceRate, (setter)pyopencv_aruco_DetectorParameters_set_minCornerDistanceRate, (char*)"minCornerDistanceRate", NULL}, |  | 33628 | {(char*)"minCornerDistanceRate", (getter)pyopencv_aruco_DetectorParameters_get_minCornerDistanceRate, (setter)pyopencv_aruco_DetectorParameters_set_minCornerDistanceRate, (char*)"minCornerDistanceRate", NULL},
| 33677 | {(char*)"minDistanceToBorder", (getter)pyopencv_aruco_DetectorParameters_get_minDistanceToBorder, (setter)pyopencv_aruco_DetectorParameters_set_minDistanceToBorder, (char*)"minDistanceToBorder", NULL}, |  | 33629 | {(char*)"minDistanceToBorder", (getter)pyopencv_aruco_DetectorParameters_get_minDistanceToBorder, (setter)pyopencv_aruco_DetectorParameters_set_minDistanceToBorder, (char*)"minDistanceToBorder", NULL},
| 33678 | {(char*)"minGroupDistance", (getter)pyopencv_aruco_DetectorParameters_get_minGroupDistance, (setter)pyopencv_aruco_DetectorParameters_set_minGroupDistance, (char*)"minGroupDistance", NULL}, |  | 33630 | {(char*)"minGroupDistance", (getter)pyopencv_aruco_DetectorParameters_get_minGroupDistance, (setter)pyopencv_aruco_DetectorParameters_set_minGroupDistance, (char*)"minGroupDistance", NULL},
| 33679 | {(char*)"minMarkerDistanceRate", (getter)pyopencv_aruco_DetectorParameters_get_minMarkerDistanceRate, (setter)pyopencv_aruco_DetectorParameters_set_minMarkerDistanceRate, (char*)"minMarkerDistanceRate", NULL}, |  | 33631 | {(char*)"minMarkerDistanceRate", (getter)pyopencv_aruco_DetectorParameters_get_minMarkerDistanceRate, (setter)pyopencv_aruco_DetectorParameters_set_minMarkerDistanceRate, (char*)"minMarkerDistanceRate", NULL},
| 33680 | {(char*)"minMarkerLengthRatioOriginalImg", (getter)pyopencv_aruco_DetectorParameters_get_minMarkerLengthRatioOriginalImg, (setter)pyopencv_aruco_DetectorParameters_set_minMarkerLengthRatioOriginalImg, (char*)"minMarkerLengthRatioOriginalImg", NULL}, |  | 33632 | {(char*)"minMarkerLengthRatioOriginalImg", (getter)pyopencv_aruco_DetectorParameters_get_minMarkerLengthRatioOriginalImg, (setter)pyopencv_aruco_DetectorParameters_set_minMarkerLengthRatioOriginalImg, (char*)"minMarkerLengthRatioOriginalImg", NULL},
| 33681 | {(char*)"minMarkerPerimeterRate", (getter)pyopencv_aruco_DetectorParameters_get_minMarkerPerimeterRate, (setter)pyopencv_aruco_DetectorParameters_set_minMarkerPerimeterRate, (char*)"minMarkerPerimeterRate", NULL}, |  | 33633 | {(char*)"minMarkerPerimeterRate", (getter)pyopencv_aruco_DetectorParameters_get_minMarkerPerimeterRate, (setter)pyopencv_aruco_DetectorParameters_set_minMarkerPerimeterRate, (char*)"minMarkerPerimeterRate", NULL},
| 33682 | {(char*)"minOtsuStdDev", (getter)pyopencv_aruco_DetectorParameters_get_minOtsuStdDev, (setter)pyopencv_aruco_DetectorParameters_set_minOtsuStdDev, (char*)"minOtsuStdDev", NULL}, |  | 33634 | {(char*)"minOtsuStdDev", (getter)pyopencv_aruco_DetectorParameters_get_minOtsuStdDev, (setter)pyopencv_aruco_DetectorParameters_set_minOtsuStdDev, (char*)"minOtsuStdDev", NULL},
| 33683 | {(char*)"minSideLengthCanonicalImg", (getter)pyopencv_aruco_DetectorParameters_get_minSideLengthCanonicalImg, (setter)pyopencv_aruco_DetectorParameters_set_minSideLengthCanonicalImg, (char*)"minSideLengthCanonicalImg", NULL}, |  | 33635 | {(char*)"minSideLengthCanonicalImg", (getter)pyopencv_aruco_DetectorParameters_get_minSideLengthCanonicalImg, (setter)pyopencv_aruco_DetectorParameters_set_minSideLengthCanonicalImg, (char*)"minSideLengthCanonicalImg", NULL},
| 33684 | {(char*)"perspectiveRemoveIgnoredMarginPerCell", (getter)pyopencv_aruco_DetectorParameters_get_perspectiveRemoveIgnoredMarginPerCell, (setter)pyopencv_aruco_DetectorParameters_set_perspectiveRemoveIgnoredMarginPerCell, (char*)"perspectiveRemoveIgnoredMarginPerCell", NULL}, |  | 33636 | {(char*)"perspectiveRemoveIgnoredMarginPerCell", (getter)pyopencv_aruco_DetectorParameters_get_perspectiveRemoveIgnoredMarginPerCell, (setter)pyopencv_aruco_DetectorParameters_set_perspectiveRemoveIgnoredMarginPerCell, (char*)"perspectiveRemoveIgnoredMarginPerCell", NULL},
| 33685 | {(char*)"perspectiveRemovePixelPerCell", (getter)pyopencv_aruco_DetectorParameters_get_perspectiveRemovePixelPerCell, (setter)pyopencv_aruco_DetectorParameters_set_perspectiveRemovePixelPerCell, (char*)"perspectiveRemovePixelPerCell", NULL}, |  | 33637 | {(char*)"perspectiveRemovePixelPerCell", (getter)pyopencv_aruco_DetectorParameters_get_perspectiveRemovePixelPerCell, (setter)pyopencv_aruco_DetectorParameters_set_perspectiveRemovePixelPerCell, (char*)"perspectiveRemovePixelPerCell", NULL},
| 33686 | {(char*)"polygonalApproxAccuracyRate", (getter)pyopencv_aruco_DetectorParameters_get_polygonalApproxAccuracyRate, (setter)pyopencv_aruco_DetectorParameters_set_polygonalApproxAccuracyRate, (char*)"polygonalApproxAccuracyRate", NULL}, |  | 33638 | {(char*)"polygonalApproxAccuracyRate", (getter)pyopencv_aruco_DetectorParameters_get_polygonalApproxAccuracyRate, (setter)pyopencv_aruco_DetectorParameters_set_polygonalApproxAccuracyRate, (char*)"polygonalApproxAccuracyRate", NULL},
| 33687 | {(char*)"relativeCornerRefinmentWinSize", (getter)pyopencv_aruco_DetectorParameters_get_relativeCornerRefinmentWinSize, (setter)pyopencv_aruco_DetectorParameters_set_relativeCornerRefinmentWinSize, (char*)"relativeCornerRefinmentWinSize", NULL}, |  | 33639 | {(char*)"relativeCornerRefinmentWinSize", (getter)pyopencv_aruco_DetectorParameters_get_relativeCornerRefinmentWinSize, (setter)pyopencv_aruco_DetectorParameters_set_relativeCornerRefinmentWinSize, (char*)"relativeCornerRefinmentWinSize", NULL},
| 33688 | {(char*)"useAruco3Detection", (getter)pyopencv_aruco_DetectorParameters_get_useAruco3Detection, (setter)pyopencv_aruco_DetectorParameters_set_useAruco3Detection, (char*)"useAruco3Detection", NULL}, |  | 33640 | {(char*)"useAruco3Detection", (getter)pyopencv_aruco_DetectorParameters_get_useAruco3Detection, (setter)pyopencv_aruco_DetectorParameters_set_useAruco3Detection, (char*)"useAruco3Detection", NULL},
| 33689 | {NULL} /* Sentinel */ |  | 33641 | {NULL} /* Sentinel */
| 33690 | }; |  | 33642 | };
| 33691 |  |  | 33643 |
| 33692 | static PyMethodDef pyopencv_aruco_DetectorParameters_methods[] = |  | 33644 | static PyMethodDef pyopencv_aruco_DetectorParameters_methods[] =
| 33693 | { |  | 33645 | {
| 33694 | {"readDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_DetectorParameters_readDetectorParameters, 0), "readDetectorParameters(fn) -> retval\n. @brief Read a new set of DetectorParameters from FileNode (use FileStorage.root())."}, |  | 33646 | {"readDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_DetectorParameters_readDetectorParameters, 0), "readDetectorParameters(fn) -> retval\n. @brief Read a new set of DetectorParameters from FileNode (use FileStorage.root())."},
| 33695 | {"writeDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_DetectorParameters_writeDetectorParameters, 0), "writeDetectorParameters(fs[, name]) -> retval\n. @brief Write a set of DetectorParameters to FileStorage"}, |  | 33647 | {"writeDetectorParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_DetectorParameters_writeDetectorParameters, 0), "writeDetectorParameters(fs[, name]) -> retval\n. @brief Write a set of DetectorParameters to FileStorage"},
| 33696 |  |  | 33648 |
| 33697 | {NULL, NULL} |  | 33649 | {NULL, NULL}
| 33698 | }; |  | 33650 | };
| 33699 |  |  | 33651 |
| 33700 | // Converter (aruco_DetectorParameters) |  | 33652 | // Converter (aruco_DetectorParameters)
| 33701 |  |  | 33653 |
| 33702 | template<> |  | 33654 | template<>
| 33703 | struct PyOpenCV_Converter< cv::aruco::DetectorParameters > |  | 33655 | struct PyOpenCV_Converter< cv::aruco::DetectorParameters >
| 33704 | { |  | 33656 | {
| 33705 | static PyObject* from(const cv::aruco::DetectorParameters& r) |  | 33657 | static PyObject* from(const cv::aruco::DetectorParameters& r)
| 33706 | { |  | 33658 | {
| 33707 | return pyopencv_aruco_DetectorParameters_Instance(r); |  | 33659 | return pyopencv_aruco_DetectorParameters_Instance(r);
| 33708 | } |  | 33660 | }
| 33709 | static bool to(PyObject* src, cv::aruco::DetectorParameters& dst, const ArgInfo& info) |  | 33661 | static bool to(PyObject* src, cv::aruco::DetectorParameters& dst, const ArgInfo& info)
| 33710 | { |  | 33662 | {
| 33711 | if(!src || src == Py_None) |  | 33663 | if(!src || src == Py_None)
| 33712 | return true; |  | 33664 | return true;
| 33713 | cv::aruco::DetectorParameters * dst_; |  | 33665 | cv::aruco::DetectorParameters * dst_;
| 33714 | if (pyopencv_aruco_DetectorParameters_getp(src, dst_)) |  | 33666 | if (pyopencv_aruco_DetectorParameters_getp(src, dst_))
| 33715 | { |  | 33667 | {
| 33716 | dst = *dst_; |  | 33668 | dst = *dst_;
| 33717 | return true; |  | 33669 | return true;
| 33718 | } |  | 33670 | }
| 33719 |  |  | 33671 |
| 33720 | failmsg("Expected cv::aruco::DetectorParameters for argument '%s'", info.name); |  | 33672 | failmsg("Expected cv::aruco::DetectorParameters for argument '%s'", info.name);
| 33721 | return false; |  | 33673 | return false;
| 33722 | } |  | 33674 | }
| 33723 | }; |  | 33675 | };
| 33724 |  |  | 33676 |
| 33725 | //================================================================================ |  | 33677 | //================================================================================
| 33726 | // aruco_Dictionary (Generic) |  | 33678 | // aruco_Dictionary (Generic)
| 33727 | //================================================================================ |  | 33679 | //================================================================================
| 33728 |  |  | 33680 |
| 33729 | // GetSet (aruco_Dictionary) |  | 33681 | // GetSet (aruco_Dictionary)
| 33730 |  |  | 33682 |
| 33731 |  |  | 33683 |
| 33732 | static PyObject* pyopencv_aruco_Dictionary_get_bytesList(pyopencv_aruco_Dictionary_t* p, void *closure) |  | 33684 | static PyObject* pyopencv_aruco_Dictionary_get_bytesList(pyopencv_aruco_Dictionary_t* p, void *closure)
| 33733 | { |  | 33685 | {
| 33734 | return pyopencv_from(p->v.bytesList); |  | 33686 | return pyopencv_from(p->v.bytesList);
| 33735 | } |  | 33687 | }
| 33736 |  |  | 33688 |
| 33737 | static int pyopencv_aruco_Dictionary_set_bytesList(pyopencv_aruco_Dictionary_t* p, PyObject *value, void *closure) |  | 33689 | static int pyopencv_aruco_Dictionary_set_bytesList(pyopencv_aruco_Dictionary_t* p, PyObject *value, void *closure)
| 33738 | { |  | 33690 | {
| 33739 | if (!value) |  | 33691 | if (!value)
| 33740 | { |  | 33692 | {
| 33741 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bytesList attribute"); |  | 33693 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bytesList attribute");
| 33742 | return -1; |  | 33694 | return -1;
| 33743 | } |  | 33695 | }
| 33744 | return pyopencv_to_safe(value, p->v.bytesList, ArgInfo("value", 0)) ? 0 : -1; |  | 33696 | return pyopencv_to_safe(value, p->v.bytesList, ArgInfo("value", 0)) ? 0 : -1;
| 33745 | } |  | 33697 | }
| 33746 |  |  | 33698 |
| 33747 | static PyObject* pyopencv_aruco_Dictionary_get_markerSize(pyopencv_aruco_Dictionary_t* p, void *closure) |  | 33699 | static PyObject* pyopencv_aruco_Dictionary_get_markerSize(pyopencv_aruco_Dictionary_t* p, void *closure)
| 33748 | { |  | 33700 | {
| 33749 | return pyopencv_from(p->v.markerSize); |  | 33701 | return pyopencv_from(p->v.markerSize);
| 33750 | } |  | 33702 | }
| 33751 |  |  | 33703 |
| 33752 | static int pyopencv_aruco_Dictionary_set_markerSize(pyopencv_aruco_Dictionary_t* p, PyObject *value, void *closure) |  | 33704 | static int pyopencv_aruco_Dictionary_set_markerSize(pyopencv_aruco_Dictionary_t* p, PyObject *value, void *closure)
| 33753 | { |  | 33705 | {
| 33754 | if (!value) |  | 33706 | if (!value)
| 33755 | { |  | 33707 | {
| 33756 | PyErr_SetString(PyExc_TypeError, "Cannot delete the markerSize attribute"); |  | 33708 | PyErr_SetString(PyExc_TypeError, "Cannot delete the markerSize attribute");
| 33757 | return -1; |  | 33709 | return -1;
| 33758 | } |  | 33710 | }
| 33759 | return pyopencv_to_safe(value, p->v.markerSize, ArgInfo("value", 0)) ? 0 : -1; |  | 33711 | return pyopencv_to_safe(value, p->v.markerSize, ArgInfo("value", 0)) ? 0 : -1;
| 33760 | } |  | 33712 | }
| 33761 |  |  | 33713 |
| 33762 | static PyObject* pyopencv_aruco_Dictionary_get_maxCorrectionBits(pyopencv_aruco_Dictionary_t* p, void *closure) |  | 33714 | static PyObject* pyopencv_aruco_Dictionary_get_maxCorrectionBits(pyopencv_aruco_Dictionary_t* p, void *closure)
| 33763 | { |  | 33715 | {
| 33764 | return pyopencv_from(p->v.maxCorrectionBits); |  | 33716 | return pyopencv_from(p->v.maxCorrectionBits);
| 33765 | } |  | 33717 | }
| 33766 |  |  | 33718 |
| 33767 | static int pyopencv_aruco_Dictionary_set_maxCorrectionBits(pyopencv_aruco_Dictionary_t* p, PyObject *value, void *closure) |  | 33719 | static int pyopencv_aruco_Dictionary_set_maxCorrectionBits(pyopencv_aruco_Dictionary_t* p, PyObject *value, void *closure)
| 33768 | { |  | 33720 | {
| 33769 | if (!value) |  | 33721 | if (!value)
| 33770 | { |  | 33722 | {
| 33771 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxCorrectionBits attribute"); |  | 33723 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxCorrectionBits attribute");
| 33772 | return -1; |  | 33724 | return -1;
| 33773 | } |  | 33725 | }
| 33774 | return pyopencv_to_safe(value, p->v.maxCorrectionBits, ArgInfo("value", 0)) ? 0 : -1; |  | 33726 | return pyopencv_to_safe(value, p->v.maxCorrectionBits, ArgInfo("value", 0)) ? 0 : -1;
| 33775 | } |  | 33727 | }
| 33776 |  |  | 33728 |
| 33777 |  |  | 33729 |
| 33778 | // Methods (aruco_Dictionary) |  | 33730 | // Methods (aruco_Dictionary)
| 33779 |  |  | 33731 |
| 33780 | static int pyopencv_cv_aruco_aruco_Dictionary_Dictionary(pyopencv_aruco_Dictionary_t* self, PyObject* py_args, PyObject* kw) |  | 33732 | static int pyopencv_cv_aruco_aruco_Dictionary_Dictionary(pyopencv_aruco_Dictionary_t* self, PyObject* py_args, PyObject* kw)
| 33781 | { |  | 33733 | {
| 33782 | using namespace cv::aruco; |  | 33734 | using namespace cv::aruco;
| 33783 |  |  | 33735 |
| 33784 | pyPrepareArgumentConversionErrorsStorage(2); |  | 33736 | pyPrepareArgumentConversionErrorsStorage(2);
| 33785 |  |  | 33737 |
| 33786 | { |  | 33738 | {
| 33787 |  |  | 33739 |
| 33788 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 33740 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 33789 | { |  | 33741 | {
| 33790 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Dictionary()); |  | 33742 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Dictionary());
| 33791 | return 0; |  | 33743 | return 0;
| 33792 | } |  | 33744 | }
| 33793 |  |  | 33745 |
| 33794 |  |  | 33746 |
| 33795 | pyPopulateArgumentConversionErrors(); |  | 33747 | pyPopulateArgumentConversionErrors();
| 33796 | } |  | 33748 | }
| 33797 |  |  | 33749 |
| 33798 |  |  | 33750 |
| 33799 | { |  | 33751 | {
| 33800 | PyObject* pyobj_bytesList = NULL; |  | 33752 | PyObject* pyobj_bytesList = NULL;
| 33801 | Mat bytesList; |  | 33753 | Mat bytesList;
| 33802 | PyObject* pyobj__markerSize = NULL; |  | 33754 | PyObject* pyobj__markerSize = NULL;
| 33803 | int _markerSize=0; |  | 33755 | int _markerSize=0;
| 33804 | PyObject* pyobj_maxcorr = NULL; |  | 33756 | PyObject* pyobj_maxcorr = NULL;
| 33805 | int maxcorr=0; |  | 33757 | int maxcorr=0;
| 33806 |  |  | 33758 |
| 33807 | const char* keywords[] = { "bytesList", "_markerSize", "maxcorr", NULL }; |  | 33759 | const char* keywords[] = { "bytesList", "_markerSize", "maxcorr", NULL };
| 33808 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Dictionary", (char**)keywords, &pyobj_bytesList, &pyobj__markerSize, &pyobj_maxcorr) && |  | 33760 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Dictionary", (char**)keywords, &pyobj_bytesList, &pyobj__markerSize, &pyobj_maxcorr) &&
| 33809 | pyopencv_to_safe(pyobj_bytesList, bytesList, ArgInfo("bytesList", 0)) && |  | 33761 | pyopencv_to_safe(pyobj_bytesList, bytesList, ArgInfo("bytesList", 0)) &&
| 33810 | pyopencv_to_safe(pyobj__markerSize, _markerSize, ArgInfo("_markerSize", 0)) && |  | 33762 | pyopencv_to_safe(pyobj__markerSize, _markerSize, ArgInfo("_markerSize", 0)) &&
| 33811 | pyopencv_to_safe(pyobj_maxcorr, maxcorr, ArgInfo("maxcorr", 0)) ) |  | 33763 | pyopencv_to_safe(pyobj_maxcorr, maxcorr, ArgInfo("maxcorr", 0)) )
| 33812 | { |  | 33764 | {
| 33813 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Dictionary(bytesList, _markerSize, maxcorr)); |  | 33765 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::Dictionary(bytesList, _markerSize, maxcorr));
| 33814 | return 0; |  | 33766 | return 0;
| 33815 | } |  | 33767 | }
| 33816 |  |  | 33768 |
| 33817 |  |  | 33769 |
| 33818 | pyPopulateArgumentConversionErrors(); |  | 33770 | pyPopulateArgumentConversionErrors();
| 33819 | } |  | 33771 | }
| 33820 | pyRaiseCVOverloadException("Dictionary"); |  | 33772 | pyRaiseCVOverloadException("Dictionary");
| 33821 |  |  | 33773 |
| 33822 | return -1; |  | 33774 | return -1;
| 33823 | } |  | 33775 | }
| 33824 |  |  | 33776 |
| 33825 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_generateImageMarker(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33777 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_generateImageMarker(PyObject* self, PyObject* py_args, PyObject* kw)
| 33826 | { |  | 33778 | {
| 33827 | using namespace cv::aruco; |  | 33779 | using namespace cv::aruco;
| 33828 |  |  | 33780 |
| 33829 |  |  | 33781 |
| 33830 | cv::aruco::Dictionary * self1 = 0; |  | 33782 | cv::aruco::Dictionary * self1 = 0;
| 33831 | if (!pyopencv_aruco_Dictionary_getp(self, self1)) |  | 33783 | if (!pyopencv_aruco_Dictionary_getp(self, self1))
| 33832 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)"); |  | 33784 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)");
| 33833 | cv::aruco::Dictionary* _self_ = (self1); |  | 33785 | cv::aruco::Dictionary* _self_ = (self1);
| 33834 | pyPrepareArgumentConversionErrorsStorage(2); |  | 33786 | pyPrepareArgumentConversionErrorsStorage(2);
| 33835 |  |  | 33787 |
| 33836 | { |  | 33788 | {
| 33837 | PyObject* pyobj_id = NULL; |  | 33789 | PyObject* pyobj_id = NULL;
| 33838 | int id=0; |  | 33790 | int id=0;
| 33839 | PyObject* pyobj_sidePixels = NULL; |  | 33791 | PyObject* pyobj_sidePixels = NULL;
| 33840 | int sidePixels=0; |  | 33792 | int sidePixels=0;
| 33841 | PyObject* pyobj__img = NULL; |  | 33793 | PyObject* pyobj__img = NULL;
| 33842 | Mat _img; |  | 33794 | Mat _img;
| 33843 | PyObject* pyobj_borderBits = NULL; |  | 33795 | PyObject* pyobj_borderBits = NULL;
| 33844 | int borderBits=1; |  | 33796 | int borderBits=1;
| 33845 |  |  | 33797 |
| 33846 | const char* keywords[] = { "id", "sidePixels", "_img", "borderBits", NULL }; |  | 33798 | const char* keywords[] = { "id", "sidePixels", "_img", "borderBits", NULL };
| 33847 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Dictionary.generateImageMarker", (char**)keywords, &pyobj_id, &pyobj_sidePixels, &pyobj__img, &pyobj_borderBits) && |  | 33799 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Dictionary.generateImageMarker", (char**)keywords, &pyobj_id, &pyobj_sidePixels, &pyobj__img, &pyobj_borderBits) &&
| 33848 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) && |  | 33800 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) &&
| 33849 | pyopencv_to_safe(pyobj_sidePixels, sidePixels, ArgInfo("sidePixels", 0)) && |  | 33801 | pyopencv_to_safe(pyobj_sidePixels, sidePixels, ArgInfo("sidePixels", 0)) &&
| 33850 | pyopencv_to_safe(pyobj__img, _img, ArgInfo("_img", 1)) && |  | 33802 | pyopencv_to_safe(pyobj__img, _img, ArgInfo("_img", 1)) &&
| 33851 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) ) |  | 33803 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) )
| 33852 | { |  | 33804 | {
| 33853 | ERRWRAP2(_self_->generateImageMarker(id, sidePixels, _img, borderBits)); |  | 33805 | ERRWRAP2(_self_->generateImageMarker(id, sidePixels, _img, borderBits));
| 33854 | return pyopencv_from(_img); |  | 33806 | return pyopencv_from(_img);
| 33855 | } |  | 33807 | }
| 33856 |  |  | 33808 |
| 33857 |  |  | 33809 |
| 33858 | pyPopulateArgumentConversionErrors(); |  | 33810 | pyPopulateArgumentConversionErrors();
| 33859 | } |  | 33811 | }
| 33860 |  |  | 33812 |
| 33861 |  |  | 33813 |
| 33862 | { |  | 33814 | {
| 33863 | PyObject* pyobj_id = NULL; |  | 33815 | PyObject* pyobj_id = NULL;
| 33864 | int id=0; |  | 33816 | int id=0;
| 33865 | PyObject* pyobj_sidePixels = NULL; |  | 33817 | PyObject* pyobj_sidePixels = NULL;
| 33866 | int sidePixels=0; |  | 33818 | int sidePixels=0;
| 33867 | PyObject* pyobj__img = NULL; |  | 33819 | PyObject* pyobj__img = NULL;
| 33868 | UMat _img; |  | 33820 | UMat _img;
| 33869 | PyObject* pyobj_borderBits = NULL; |  | 33821 | PyObject* pyobj_borderBits = NULL;
| 33870 | int borderBits=1; |  | 33822 | int borderBits=1;
| 33871 |  |  | 33823 |
| 33872 | const char* keywords[] = { "id", "sidePixels", "_img", "borderBits", NULL }; |  | 33824 | const char* keywords[] = { "id", "sidePixels", "_img", "borderBits", NULL };
| 33873 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Dictionary.generateImageMarker", (char**)keywords, &pyobj_id, &pyobj_sidePixels, &pyobj__img, &pyobj_borderBits) && |  | 33825 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:aruco_Dictionary.generateImageMarker", (char**)keywords, &pyobj_id, &pyobj_sidePixels, &pyobj__img, &pyobj_borderBits) &&
| 33874 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) && |  | 33826 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) &&
| 33875 | pyopencv_to_safe(pyobj_sidePixels, sidePixels, ArgInfo("sidePixels", 0)) && |  | 33827 | pyopencv_to_safe(pyobj_sidePixels, sidePixels, ArgInfo("sidePixels", 0)) &&
| 33876 | pyopencv_to_safe(pyobj__img, _img, ArgInfo("_img", 1)) && |  | 33828 | pyopencv_to_safe(pyobj__img, _img, ArgInfo("_img", 1)) &&
| 33877 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) ) |  | 33829 | pyopencv_to_safe(pyobj_borderBits, borderBits, ArgInfo("borderBits", 0)) )
| 33878 | { |  | 33830 | {
| 33879 | ERRWRAP2(_self_->generateImageMarker(id, sidePixels, _img, borderBits)); |  | 33831 | ERRWRAP2(_self_->generateImageMarker(id, sidePixels, _img, borderBits));
| 33880 | return pyopencv_from(_img); |  | 33832 | return pyopencv_from(_img);
| 33881 | } |  | 33833 | }
| 33882 |  |  | 33834 |
| 33883 |  |  | 33835 |
| 33884 | pyPopulateArgumentConversionErrors(); |  | 33836 | pyPopulateArgumentConversionErrors();
| 33885 | } |  | 33837 | }
| 33886 | pyRaiseCVOverloadException("generateImageMarker"); |  | 33838 | pyRaiseCVOverloadException("generateImageMarker");
| 33887 |  |  | 33839 |
| 33888 | return NULL; |  | 33840 | return NULL;
| 33889 | } |  | 33841 | }
| 33890 |  |  | 33842 |
| 33891 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_getBitsFromByteList_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33843 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_getBitsFromByteList_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 33892 | { |  | 33844 | {
| 33893 | using namespace cv::aruco; |  | 33845 | using namespace cv::aruco;
| 33894 |  |  | 33846 |
| 33895 | PyObject* pyobj_byteList = NULL; |  | 33847 | PyObject* pyobj_byteList = NULL;
| 33896 | Mat byteList; |  | 33848 | Mat byteList;
| 33897 | PyObject* pyobj_markerSize = NULL; |  | 33849 | PyObject* pyobj_markerSize = NULL;
| 33898 | int markerSize=0; |  | 33850 | int markerSize=0;
| 33899 | Mat retval; |  | 33851 | Mat retval;
| 33900 |  |  | 33852 |
| 33901 | const char* keywords[] = { "byteList", "markerSize", NULL }; |  | 33853 | const char* keywords[] = { "byteList", "markerSize", NULL };
| 33902 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:aruco_Dictionary.getBitsFromByteList", (char**)keywords, &pyobj_byteList, &pyobj_markerSize) && |  | 33854 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:aruco_Dictionary.getBitsFromByteList", (char**)keywords, &pyobj_byteList, &pyobj_markerSize) &&
| 33903 | pyopencv_to_safe(pyobj_byteList, byteList, ArgInfo("byteList", 0)) && |  | 33855 | pyopencv_to_safe(pyobj_byteList, byteList, ArgInfo("byteList", 0)) &&
| 33904 | pyopencv_to_safe(pyobj_markerSize, markerSize, ArgInfo("markerSize", 0)) ) |  | 33856 | pyopencv_to_safe(pyobj_markerSize, markerSize, ArgInfo("markerSize", 0)) )
| 33905 | { |  | 33857 | {
| 33906 | ERRWRAP2(retval = cv::aruco::Dictionary::getBitsFromByteList(byteList, markerSize)); |  | 33858 | ERRWRAP2(retval = cv::aruco::Dictionary::getBitsFromByteList(byteList, markerSize));
| 33907 | return pyopencv_from(retval); |  | 33859 | return pyopencv_from(retval);
| 33908 | } |  | 33860 | }
| 33909 |  |  | 33861 |
| 33910 | return NULL; |  | 33862 | return NULL;
| 33911 | } |  | 33863 | }
| 33912 |  |  | 33864 |
| 33913 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_getByteListFromBits_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33865 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_getByteListFromBits_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 33914 | { |  | 33866 | {
| 33915 | using namespace cv::aruco; |  | 33867 | using namespace cv::aruco;
| 33916 |  |  | 33868 |
| 33917 | PyObject* pyobj_bits = NULL; |  | 33869 | PyObject* pyobj_bits = NULL;
| 33918 | Mat bits; |  | 33870 | Mat bits;
| 33919 | Mat retval; |  | 33871 | Mat retval;
| 33920 |  |  | 33872 |
| 33921 | const char* keywords[] = { "bits", NULL }; |  | 33873 | const char* keywords[] = { "bits", NULL };
| 33922 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_Dictionary.getByteListFromBits", (char**)keywords, &pyobj_bits) && |  | 33874 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_Dictionary.getByteListFromBits", (char**)keywords, &pyobj_bits) &&
| 33923 | pyopencv_to_safe(pyobj_bits, bits, ArgInfo("bits", 0)) ) |  | 33875 | pyopencv_to_safe(pyobj_bits, bits, ArgInfo("bits", 0)) )
| 33924 | { |  | 33876 | {
| 33925 | ERRWRAP2(retval = cv::aruco::Dictionary::getByteListFromBits(bits)); |  | 33877 | ERRWRAP2(retval = cv::aruco::Dictionary::getByteListFromBits(bits));
| 33926 | return pyopencv_from(retval); |  | 33878 | return pyopencv_from(retval);
| 33927 | } |  | 33879 | }
| 33928 |  |  | 33880 |
| 33929 | return NULL; |  | 33881 | return NULL;
| 33930 | } |  | 33882 | }
| 33931 |  |  | 33883 |
| 33932 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_getDistanceToId(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33884 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_getDistanceToId(PyObject* self, PyObject* py_args, PyObject* kw)
| 33933 | { |  | 33885 | {
| 33934 | using namespace cv::aruco; |  | 33886 | using namespace cv::aruco;
| 33935 |  |  | 33887 |
| 33936 |  |  | 33888 |
| 33937 | cv::aruco::Dictionary * self1 = 0; |  | 33889 | cv::aruco::Dictionary * self1 = 0;
| 33938 | if (!pyopencv_aruco_Dictionary_getp(self, self1)) |  | 33890 | if (!pyopencv_aruco_Dictionary_getp(self, self1))
| 33939 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)"); |  | 33891 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)");
| 33940 | cv::aruco::Dictionary* _self_ = (self1); |  | 33892 | cv::aruco::Dictionary* _self_ = (self1);
| 33941 | pyPrepareArgumentConversionErrorsStorage(2); |  | 33893 | pyPrepareArgumentConversionErrorsStorage(2);
| 33942 |  |  | 33894 |
| 33943 | { |  | 33895 | {
| 33944 | PyObject* pyobj_bits = NULL; |  | 33896 | PyObject* pyobj_bits = NULL;
| 33945 | Mat bits; |  | 33897 | Mat bits;
| 33946 | PyObject* pyobj_id = NULL; |  | 33898 | PyObject* pyobj_id = NULL;
| 33947 | int id=0; |  | 33899 | int id=0;
| 33948 | PyObject* pyobj_allRotations = NULL; |  | 33900 | PyObject* pyobj_allRotations = NULL;
| 33949 | bool allRotations=true; |  | 33901 | bool allRotations=true;
| 33950 | int retval; |  | 33902 | int retval;
| 33951 |  |  | 33903 |
| 33952 | const char* keywords[] = { "bits", "id", "allRotations", NULL }; |  | 33904 | const char* keywords[] = { "bits", "id", "allRotations", NULL };
| 33953 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:aruco_Dictionary.getDistanceToId", (char**)keywords, &pyobj_bits, &pyobj_id, &pyobj_allRotations) && |  | 33905 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:aruco_Dictionary.getDistanceToId", (char**)keywords, &pyobj_bits, &pyobj_id, &pyobj_allRotations) &&
| 33954 | pyopencv_to_safe(pyobj_bits, bits, ArgInfo("bits", 0)) && |  | 33906 | pyopencv_to_safe(pyobj_bits, bits, ArgInfo("bits", 0)) &&
| 33955 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) && |  | 33907 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) &&
| 33956 | pyopencv_to_safe(pyobj_allRotations, allRotations, ArgInfo("allRotations", 0)) ) |  | 33908 | pyopencv_to_safe(pyobj_allRotations, allRotations, ArgInfo("allRotations", 0)) )
| 33957 | { |  | 33909 | {
| 33958 | ERRWRAP2(retval = _self_->getDistanceToId(bits, id, allRotations)); |  | 33910 | ERRWRAP2(retval = _self_->getDistanceToId(bits, id, allRotations));
| 33959 | return pyopencv_from(retval); |  | 33911 | return pyopencv_from(retval);
| 33960 | } |  | 33912 | }
| 33961 |  |  | 33913 |
| 33962 |  |  | 33914 |
| 33963 | pyPopulateArgumentConversionErrors(); |  | 33915 | pyPopulateArgumentConversionErrors();
| 33964 | } |  | 33916 | }
| 33965 |  |  | 33917 |
| 33966 |  |  | 33918 |
| 33967 | { |  | 33919 | {
| 33968 | PyObject* pyobj_bits = NULL; |  | 33920 | PyObject* pyobj_bits = NULL;
| 33969 | UMat bits; |  | 33921 | UMat bits;
| 33970 | PyObject* pyobj_id = NULL; |  | 33922 | PyObject* pyobj_id = NULL;
| 33971 | int id=0; |  | 33923 | int id=0;
| 33972 | PyObject* pyobj_allRotations = NULL; |  | 33924 | PyObject* pyobj_allRotations = NULL;
| 33973 | bool allRotations=true; |  | 33925 | bool allRotations=true;
| 33974 | int retval; |  | 33926 | int retval;
| 33975 |  |  | 33927 |
| 33976 | const char* keywords[] = { "bits", "id", "allRotations", NULL }; |  | 33928 | const char* keywords[] = { "bits", "id", "allRotations", NULL };
| 33977 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:aruco_Dictionary.getDistanceToId", (char**)keywords, &pyobj_bits, &pyobj_id, &pyobj_allRotations) && |  | 33929 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:aruco_Dictionary.getDistanceToId", (char**)keywords, &pyobj_bits, &pyobj_id, &pyobj_allRotations) &&
| 33978 | pyopencv_to_safe(pyobj_bits, bits, ArgInfo("bits", 0)) && |  | 33930 | pyopencv_to_safe(pyobj_bits, bits, ArgInfo("bits", 0)) &&
| 33979 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) && |  | 33931 | pyopencv_to_safe(pyobj_id, id, ArgInfo("id", 0)) &&
| 33980 | pyopencv_to_safe(pyobj_allRotations, allRotations, ArgInfo("allRotations", 0)) ) |  | 33932 | pyopencv_to_safe(pyobj_allRotations, allRotations, ArgInfo("allRotations", 0)) )
| 33981 | { |  | 33933 | {
| 33982 | ERRWRAP2(retval = _self_->getDistanceToId(bits, id, allRotations)); |  | 33934 | ERRWRAP2(retval = _self_->getDistanceToId(bits, id, allRotations));
| 33983 | return pyopencv_from(retval); |  | 33935 | return pyopencv_from(retval);
| 33984 | } |  | 33936 | }
| 33985 |  |  | 33937 |
| 33986 |  |  | 33938 |
| 33987 | pyPopulateArgumentConversionErrors(); |  | 33939 | pyPopulateArgumentConversionErrors();
| 33988 | } |  | 33940 | }
| 33989 | pyRaiseCVOverloadException("getDistanceToId"); |  | 33941 | pyRaiseCVOverloadException("getDistanceToId");
| 33990 |  |  | 33942 |
| 33991 | return NULL; |  | 33943 | return NULL;
| 33992 | } |  | 33944 | }
| 33993 |  |  | 33945 |
| 33994 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_identify(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33946 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_identify(PyObject* self, PyObject* py_args, PyObject* kw)
| 33995 | { |  | 33947 | {
| 33996 | using namespace cv::aruco; |  | 33948 | using namespace cv::aruco;
| 33997 |  |  | 33949 |
| 33998 |  |  | 33950 |
| 33999 | cv::aruco::Dictionary * self1 = 0; |  | 33951 | cv::aruco::Dictionary * self1 = 0;
| 34000 | if (!pyopencv_aruco_Dictionary_getp(self, self1)) |  | 33952 | if (!pyopencv_aruco_Dictionary_getp(self, self1))
| 34001 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)"); |  | 33953 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)");
| 34002 | cv::aruco::Dictionary* _self_ = (self1); |  | 33954 | cv::aruco::Dictionary* _self_ = (self1);
| 34003 | PyObject* pyobj_onlyBits = NULL; |  | 33955 | PyObject* pyobj_onlyBits = NULL;
| 34004 | Mat onlyBits; |  | 33956 | Mat onlyBits;
| 34005 | int idx; |  | 33957 | int idx;
| 34006 | int rotation; |  | 33958 | int rotation;
| 34007 | PyObject* pyobj_maxCorrectionRate = NULL; |  | 33959 | PyObject* pyobj_maxCorrectionRate = NULL;
| 34008 | double maxCorrectionRate=0; |  | 33960 | double maxCorrectionRate=0;
| 34009 | bool retval; |  | 33961 | bool retval;
| 34010 |  |  | 33962 |
| 34011 | const char* keywords[] = { "onlyBits", "maxCorrectionRate", NULL }; |  | 33963 | const char* keywords[] = { "onlyBits", "maxCorrectionRate", NULL };
| 34012 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:aruco_Dictionary.identify", (char**)keywords, &pyobj_onlyBits, &pyobj_maxCorrectionRate) && |  | 33964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:aruco_Dictionary.identify", (char**)keywords, &pyobj_onlyBits, &pyobj_maxCorrectionRate) &&
| 34013 | pyopencv_to_safe(pyobj_onlyBits, onlyBits, ArgInfo("onlyBits", 0)) && |  | 33965 | pyopencv_to_safe(pyobj_onlyBits, onlyBits, ArgInfo("onlyBits", 0)) &&
| 34014 | pyopencv_to_safe(pyobj_maxCorrectionRate, maxCorrectionRate, ArgInfo("maxCorrectionRate", 0)) ) |  | 33966 | pyopencv_to_safe(pyobj_maxCorrectionRate, maxCorrectionRate, ArgInfo("maxCorrectionRate", 0)) )
| 34015 | { |  | 33967 | {
| 34016 | ERRWRAP2(retval = _self_->identify(onlyBits, idx, rotation, maxCorrectionRate)); |  | 33968 | ERRWRAP2(retval = _self_->identify(onlyBits, idx, rotation, maxCorrectionRate));
| 34017 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(idx), pyopencv_from(rotation)); |  | 33969 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(idx), pyopencv_from(rotation));
| 34018 | } |  | 33970 | }
| 34019 |  |  | 33971 |
| 34020 | return NULL; |  | 33972 | return NULL;
| 34021 | } |  | 33973 | }
| 34022 |  |  | 33974 |
| 34023 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_readDictionary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33975 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_readDictionary(PyObject* self, PyObject* py_args, PyObject* kw)
| 34024 | { |  | 33976 | {
| 34025 | using namespace cv::aruco; |  | 33977 | using namespace cv::aruco;
| 34026 |  |  | 33978 |
| 34027 |  |  | 33979 |
| 34028 | cv::aruco::Dictionary * self1 = 0; |  | 33980 | cv::aruco::Dictionary * self1 = 0;
| 34029 | if (!pyopencv_aruco_Dictionary_getp(self, self1)) |  | 33981 | if (!pyopencv_aruco_Dictionary_getp(self, self1))
| 34030 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)"); |  | 33982 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)");
| 34031 | cv::aruco::Dictionary* _self_ = (self1); |  | 33983 | cv::aruco::Dictionary* _self_ = (self1);
| 34032 | PyObject* pyobj_fn = NULL; |  | 33984 | PyObject* pyobj_fn = NULL;
| 34033 | cv::FileNode fn; |  | 33985 | cv::FileNode fn;
| 34034 | bool retval; |  | 33986 | bool retval;
| 34035 |  |  | 33987 |
| 34036 | const char* keywords[] = { "fn", NULL }; |  | 33988 | const char* keywords[] = { "fn", NULL };
| 34037 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_Dictionary.readDictionary", (char**)keywords, &pyobj_fn) && |  | 33989 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_Dictionary.readDictionary", (char**)keywords, &pyobj_fn) &&
| 34038 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 33990 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 34039 | { |  | 33991 | {
| 34040 | ERRWRAP2(retval = _self_->readDictionary(fn)); |  | 33992 | ERRWRAP2(retval = _self_->readDictionary(fn));
| 34041 | return pyopencv_from(retval); |  | 33993 | return pyopencv_from(retval);
| 34042 | } |  | 33994 | }
| 34043 |  |  | 33995 |
| 34044 | return NULL; |  | 33996 | return NULL;
| 34045 | } |  | 33997 | }
| 34046 |  |  | 33998 |
| 34047 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_writeDictionary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 33999 | static PyObject* pyopencv_cv_aruco_aruco_Dictionary_writeDictionary(PyObject* self, PyObject* py_args, PyObject* kw)
| 34048 | { |  | 34000 | {
| 34049 | using namespace cv::aruco; |  | 34001 | using namespace cv::aruco;
| 34050 |  |  | 34002 |
| 34051 |  |  | 34003 |
| 34052 | cv::aruco::Dictionary * self1 = 0; |  | 34004 | cv::aruco::Dictionary * self1 = 0;
| 34053 | if (!pyopencv_aruco_Dictionary_getp(self, self1)) |  | 34005 | if (!pyopencv_aruco_Dictionary_getp(self, self1))
| 34054 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)"); |  | 34006 | return failmsgp("Incorrect type of self (must be 'aruco_Dictionary' or its derivative)");
| 34055 | cv::aruco::Dictionary* _self_ = (self1); |  | 34007 | cv::aruco::Dictionary* _self_ = (self1);
| 34056 | PyObject* pyobj_fs = NULL; |  | 34008 | PyObject* pyobj_fs = NULL;
| 34057 | Ptr<cv::FileStorage> fs; |  | 34009 | Ptr<cv::FileStorage> fs;
| 34058 | PyObject* pyobj_name = NULL; |  | 34010 | PyObject* pyobj_name = NULL;
| 34059 | String name; |  | 34011 | String name;
| 34060 |  |  | 34012 |
| 34061 | const char* keywords[] = { "fs", "name", NULL }; |  | 34013 | const char* keywords[] = { "fs", "name", NULL };
| 34062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:aruco_Dictionary.writeDictionary", (char**)keywords, &pyobj_fs, &pyobj_name) && |  | 34014 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:aruco_Dictionary.writeDictionary", (char**)keywords, &pyobj_fs, &pyobj_name) &&
| 34063 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) && |  | 34015 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) &&
| 34064 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 34016 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 34065 | { |  | 34017 | {
| 34066 | ERRWRAP2(_self_->writeDictionary(*fs, name)); |  | 34018 | ERRWRAP2(_self_->writeDictionary(*fs, name));
| 34067 | Py_RETURN_NONE; |  | 34019 | Py_RETURN_NONE;
| 34068 | } |  | 34020 | }
| 34069 |  |  | 34021 |
| 34070 | return NULL; |  | 34022 | return NULL;
| 34071 | } |  | 34023 | }
| 34072 |  |  | 34024 |
| 34073 |  |  | 34025 |
| 34074 |  |  | 34026 |
| 34075 | // Tables (aruco_Dictionary) |  | 34027 | // Tables (aruco_Dictionary)
| 34076 |  |  | 34028 |
| 34077 | static PyGetSetDef pyopencv_aruco_Dictionary_getseters[] = |  | 34029 | static PyGetSetDef pyopencv_aruco_Dictionary_getseters[] =
| 34078 | { |  | 34030 | {
| 34079 | {(char*)"bytesList", (getter)pyopencv_aruco_Dictionary_get_bytesList, (setter)pyopencv_aruco_Dictionary_set_bytesList, (char*)"bytesList", NULL}, |  | 34031 | {(char*)"bytesList", (getter)pyopencv_aruco_Dictionary_get_bytesList, (setter)pyopencv_aruco_Dictionary_set_bytesList, (char*)"bytesList", NULL},
| 34080 | {(char*)"markerSize", (getter)pyopencv_aruco_Dictionary_get_markerSize, (setter)pyopencv_aruco_Dictionary_set_markerSize, (char*)"markerSize", NULL}, |  | 34032 | {(char*)"markerSize", (getter)pyopencv_aruco_Dictionary_get_markerSize, (setter)pyopencv_aruco_Dictionary_set_markerSize, (char*)"markerSize", NULL},
| 34081 | {(char*)"maxCorrectionBits", (getter)pyopencv_aruco_Dictionary_get_maxCorrectionBits, (setter)pyopencv_aruco_Dictionary_set_maxCorrectionBits, (char*)"maxCorrectionBits", NULL}, |  | 34033 | {(char*)"maxCorrectionBits", (getter)pyopencv_aruco_Dictionary_get_maxCorrectionBits, (setter)pyopencv_aruco_Dictionary_set_maxCorrectionBits, (char*)"maxCorrectionBits", NULL},
| 34082 | {NULL} /* Sentinel */ |  | 34034 | {NULL} /* Sentinel */
| 34083 | }; |  | 34035 | };
| 34084 |  |  | 34036 |
| 34085 | static PyMethodDef pyopencv_aruco_Dictionary_methods[] = |  | 34037 | static PyMethodDef pyopencv_aruco_Dictionary_methods[] =
| 34086 | { |  | 34038 | {
| 34087 | {"generateImageMarker", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_generateImageMarker, 0), "generateImageMarker(id, sidePixels[, _img[, borderBits]]) -> _img\n. @brief Generate a canonical marker image"}, |  | 34039 | {"generateImageMarker", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_generateImageMarker, 0), "generateImageMarker(id, sidePixels[, _img[, borderBits]]) -> _img\n. @brief Generate a canonical marker image"},
| 34088 | {"getBitsFromByteList", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_getBitsFromByteList_static, METH_STATIC), "getBitsFromByteList(byteList, markerSize) -> retval\n. @brief Transform list of bytes to matrix of bits"}, |  | 34040 | {"getBitsFromByteList", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_getBitsFromByteList_static, METH_STATIC), "getBitsFromByteList(byteList, markerSize) -> retval\n. @brief Transform list of bytes to matrix of bits"},
| 34089 | {"getByteListFromBits", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_getByteListFromBits_static, METH_STATIC), "getByteListFromBits(bits) -> retval\n. @brief Transform matrix of bits to list of bytes with 4 marker rotations"}, |  | 34041 | {"getByteListFromBits", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_getByteListFromBits_static, METH_STATIC), "getByteListFromBits(bits) -> retval\n. @brief Transform matrix of bits to list of bytes with 4 marker rotations"},
| 34090 | {"getDistanceToId", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_getDistanceToId, 0), "getDistanceToId(bits, id[, allRotations]) -> retval\n. @brief Returns Hamming distance of the input bits to the specific id.\n. *\n. * If `allRotations` flag is set, the four posible marker rotations are considered"}, |  | 34042 | {"getDistanceToId", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_getDistanceToId, 0), "getDistanceToId(bits, id[, allRotations]) -> retval\n. @brief Returns Hamming distance of the input bits to the specific id.\n. *\n. * If `allRotations` flag is set, the four posible marker rotations are considered"},
| 34091 | {"identify", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_identify, 0), "identify(onlyBits, maxCorrectionRate) -> retval, idx, rotation\n. @brief Given a matrix of bits. Returns whether if marker is identified or not.\n. *\n. * Returns reference to the marker id in the dictionary (if any) and its rotation."}, |  | 34043 | {"identify", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_identify, 0), "identify(onlyBits, maxCorrectionRate) -> retval, idx, rotation\n. @brief Given a matrix of bits. Returns whether if marker is identified or not.\n. *\n. * Returns reference to the marker id in the dictionary (if any) and its rotation."},
| 34092 | {"readDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_readDictionary, 0), "readDictionary(fn) -> retval\n. @brief Read a new dictionary from FileNode.\n. *\n. * Dictionary example in YAML format:\\n\n. * nmarkers: 35\\n\n. * markersize: 6\\n\n. * maxCorrectionBits: 5\\n\n. * marker_0: \"101011111011111001001001101100000000\"\\n\n. * ...\\n\n. * marker_34: \"011111010000111011111110110101100101\""}, |  | 34044 | {"readDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_readDictionary, 0), "readDictionary(fn) -> retval\n. @brief Read a new dictionary from FileNode.\n. *\n. * Dictionary example in YAML format:\\n\n. * nmarkers: 35\\n\n. * markersize: 6\\n\n. * maxCorrectionBits: 5\\n\n. * marker_0: \"101011111011111001001001101100000000\"\\n\n. * ...\\n\n. * marker_34: \"011111010000111011111110110101100101\""},
| 34093 | {"writeDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_writeDictionary, 0), "writeDictionary(fs[, name]) -> None\n. @brief Write a dictionary to FileStorage, format is the same as in readDictionary()."}, |  | 34045 | {"writeDictionary", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_Dictionary_writeDictionary, 0), "writeDictionary(fs[, name]) -> None\n. @brief Write a dictionary to FileStorage, format is the same as in readDictionary()."},
| 34094 |  |  | 34046 |
| 34095 | {NULL, NULL} |  | 34047 | {NULL, NULL}
| 34096 | }; |  | 34048 | };
| 34097 |  |  | 34049 |
| 34098 | // Converter (aruco_Dictionary) |  | 34050 | // Converter (aruco_Dictionary)
| 34099 |  |  | 34051 |
| 34100 | template<> |  | 34052 | template<>
| 34101 | struct PyOpenCV_Converter< cv::aruco::Dictionary > |  | 34053 | struct PyOpenCV_Converter< cv::aruco::Dictionary >
| 34102 | { |  | 34054 | {
| 34103 | static PyObject* from(const cv::aruco::Dictionary& r) |  | 34055 | static PyObject* from(const cv::aruco::Dictionary& r)
| 34104 | { |  | 34056 | {
| 34105 | return pyopencv_aruco_Dictionary_Instance(r); |  | 34057 | return pyopencv_aruco_Dictionary_Instance(r);
| 34106 | } |  | 34058 | }
| 34107 | static bool to(PyObject* src, cv::aruco::Dictionary& dst, const ArgInfo& info) |  | 34059 | static bool to(PyObject* src, cv::aruco::Dictionary& dst, const ArgInfo& info)
| 34108 | { |  | 34060 | {
| 34109 | if(!src || src == Py_None) |  | 34061 | if(!src || src == Py_None)
| 34110 | return true; |  | 34062 | return true;
| 34111 | cv::aruco::Dictionary * dst_; |  | 34063 | cv::aruco::Dictionary * dst_;
| 34112 | if (pyopencv_aruco_Dictionary_getp(src, dst_)) |  | 34064 | if (pyopencv_aruco_Dictionary_getp(src, dst_))
| 34113 | { |  | 34065 | {
| 34114 | dst = *dst_; |  | 34066 | dst = *dst_;
| 34115 | return true; |  | 34067 | return true;
| 34116 | } |  | 34068 | }
| 34117 |  |  | 34069 |
| 34118 | failmsg("Expected cv::aruco::Dictionary for argument '%s'", info.name); |  | 34070 | failmsg("Expected cv::aruco::Dictionary for argument '%s'", info.name);
| 34119 | return false; |  | 34071 | return false;
| 34120 | } |  | 34072 | }
| 34121 | }; |  | 34073 | };
| 34122 |  |  | 34074 |
| 34123 | //================================================================================ |  | 34075 | //================================================================================
| 34124 | // aruco_EstimateParameters (Generic) |  | 34076 | // aruco_EstimateParameters (Generic)
| 34125 | //================================================================================ |  | 34077 | //================================================================================
| 34126 |  |  | 34078 |
| 34127 | // GetSet (aruco_EstimateParameters) |  | 34079 | // GetSet (aruco_EstimateParameters)
| 34128 |  |  | 34080 |
| 34129 |  |  | 34081 |
| 34130 | static PyObject* pyopencv_aruco_EstimateParameters_get_pattern(pyopencv_aruco_EstimateParameters_t* p, void *closure) |  | 34082 | static PyObject* pyopencv_aruco_EstimateParameters_get_pattern(pyopencv_aruco_EstimateParameters_t* p, void *closure)
| 34131 | { |  | 34083 | {
| 34132 | return pyopencv_from(p->v.pattern); |  | 34084 | return pyopencv_from(p->v.pattern);
| 34133 | } |  | 34085 | }
| 34134 |  |  | 34086 |
| 34135 | static int pyopencv_aruco_EstimateParameters_set_pattern(pyopencv_aruco_EstimateParameters_t* p, PyObject *value, void *closure) |  | 34087 | static int pyopencv_aruco_EstimateParameters_set_pattern(pyopencv_aruco_EstimateParameters_t* p, PyObject *value, void *closure)
| 34136 | { |  | 34088 | {
| 34137 | if (!value) |  | 34089 | if (!value)
| 34138 | { |  | 34090 | {
| 34139 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pattern attribute"); |  | 34091 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pattern attribute");
| 34140 | return -1; |  | 34092 | return -1;
| 34141 | } |  | 34093 | }
| 34142 | return pyopencv_to_safe(value, p->v.pattern, ArgInfo("value", 0)) ? 0 : -1; |  | 34094 | return pyopencv_to_safe(value, p->v.pattern, ArgInfo("value", 0)) ? 0 : -1;
| 34143 | } |  | 34095 | }
| 34144 |  |  | 34096 |
| 34145 | static PyObject* pyopencv_aruco_EstimateParameters_get_solvePnPMethod(pyopencv_aruco_EstimateParameters_t* p, void *closure) |  | 34097 | static PyObject* pyopencv_aruco_EstimateParameters_get_solvePnPMethod(pyopencv_aruco_EstimateParameters_t* p, void *closure)
| 34146 | { |  | 34098 | {
| 34147 | return pyopencv_from(p->v.solvePnPMethod); |  | 34099 | return pyopencv_from(p->v.solvePnPMethod);
| 34148 | } |  | 34100 | }
| 34149 |  |  | 34101 |
| 34150 | static int pyopencv_aruco_EstimateParameters_set_solvePnPMethod(pyopencv_aruco_EstimateParameters_t* p, PyObject *value, void *closure) |  | 34102 | static int pyopencv_aruco_EstimateParameters_set_solvePnPMethod(pyopencv_aruco_EstimateParameters_t* p, PyObject *value, void *closure)
| 34151 | { |  | 34103 | {
| 34152 | if (!value) |  | 34104 | if (!value)
| 34153 | { |  | 34105 | {
| 34154 | PyErr_SetString(PyExc_TypeError, "Cannot delete the solvePnPMethod attribute"); |  | 34106 | PyErr_SetString(PyExc_TypeError, "Cannot delete the solvePnPMethod attribute");
| 34155 | return -1; |  | 34107 | return -1;
| 34156 | } |  | 34108 | }
| 34157 | return pyopencv_to_safe(value, p->v.solvePnPMethod, ArgInfo("value", 0)) ? 0 : -1; |  | 34109 | return pyopencv_to_safe(value, p->v.solvePnPMethod, ArgInfo("value", 0)) ? 0 : -1;
| 34158 | } |  | 34110 | }
| 34159 |  |  | 34111 |
| 34160 | static PyObject* pyopencv_aruco_EstimateParameters_get_useExtrinsicGuess(pyopencv_aruco_EstimateParameters_t* p, void *closure) |  | 34112 | static PyObject* pyopencv_aruco_EstimateParameters_get_useExtrinsicGuess(pyopencv_aruco_EstimateParameters_t* p, void *closure)
| 34161 | { |  | 34113 | {
| 34162 | return pyopencv_from(p->v.useExtrinsicGuess); |  | 34114 | return pyopencv_from(p->v.useExtrinsicGuess);
| 34163 | } |  | 34115 | }
| 34164 |  |  | 34116 |
| 34165 | static int pyopencv_aruco_EstimateParameters_set_useExtrinsicGuess(pyopencv_aruco_EstimateParameters_t* p, PyObject *value, void *closure) |  | 34117 | static int pyopencv_aruco_EstimateParameters_set_useExtrinsicGuess(pyopencv_aruco_EstimateParameters_t* p, PyObject *value, void *closure)
| 34166 | { |  | 34118 | {
| 34167 | if (!value) |  | 34119 | if (!value)
| 34168 | { |  | 34120 | {
| 34169 | PyErr_SetString(PyExc_TypeError, "Cannot delete the useExtrinsicGuess attribute"); |  | 34121 | PyErr_SetString(PyExc_TypeError, "Cannot delete the useExtrinsicGuess attribute");
| 34170 | return -1; |  | 34122 | return -1;
| 34171 | } |  | 34123 | }
| 34172 | return pyopencv_to_safe(value, p->v.useExtrinsicGuess, ArgInfo("value", 0)) ? 0 : -1; |  | 34124 | return pyopencv_to_safe(value, p->v.useExtrinsicGuess, ArgInfo("value", 0)) ? 0 : -1;
| 34173 | } |  | 34125 | }
| 34174 |  |  | 34126 |
| 34175 |  |  | 34127 |
| 34176 | // Methods (aruco_EstimateParameters) |  | 34128 | // Methods (aruco_EstimateParameters)
| 34177 |  |  | 34129 |
| 34178 | static int pyopencv_cv_aruco_aruco_EstimateParameters_EstimateParameters(pyopencv_aruco_EstimateParameters_t* self, PyObject* py_args, PyObject* kw) |  | 34130 | static int pyopencv_cv_aruco_aruco_EstimateParameters_EstimateParameters(pyopencv_aruco_EstimateParameters_t* self, PyObject* py_args, PyObject* kw)
| 34179 | { |  | 34131 | {
| 34180 | using namespace cv::aruco; |  | 34132 | using namespace cv::aruco;
| 34181 |  |  | 34133 |
| 34182 |  |  | 34134 |
| 34183 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34135 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34184 | { |  | 34136 | {
| 34185 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::EstimateParameters()); |  | 34137 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::EstimateParameters());
| 34186 | return 0; |  | 34138 | return 0;
| 34187 | } |  | 34139 | }
| 34188 |  |  | 34140 |
| 34189 | return -1; |  | 34141 | return -1;
| 34190 | } |  | 34142 | }
| 34191 |  |  | 34143 |
| 34192 |  |  | 34144 |
| 34193 |  |  | 34145 |
| 34194 | // Tables (aruco_EstimateParameters) |  | 34146 | // Tables (aruco_EstimateParameters)
| 34195 |  |  | 34147 |
| 34196 | static PyGetSetDef pyopencv_aruco_EstimateParameters_getseters[] = |  | 34148 | static PyGetSetDef pyopencv_aruco_EstimateParameters_getseters[] =
| 34197 | { |  | 34149 | {
| 34198 | {(char*)"pattern", (getter)pyopencv_aruco_EstimateParameters_get_pattern, (setter)pyopencv_aruco_EstimateParameters_set_pattern, (char*)"pattern", NULL}, |  | 34150 | {(char*)"pattern", (getter)pyopencv_aruco_EstimateParameters_get_pattern, (setter)pyopencv_aruco_EstimateParameters_set_pattern, (char*)"pattern", NULL},
| 34199 | {(char*)"solvePnPMethod", (getter)pyopencv_aruco_EstimateParameters_get_solvePnPMethod, (setter)pyopencv_aruco_EstimateParameters_set_solvePnPMethod, (char*)"solvePnPMethod", NULL}, |  | 34151 | {(char*)"solvePnPMethod", (getter)pyopencv_aruco_EstimateParameters_get_solvePnPMethod, (setter)pyopencv_aruco_EstimateParameters_set_solvePnPMethod, (char*)"solvePnPMethod", NULL},
| 34200 | {(char*)"useExtrinsicGuess", (getter)pyopencv_aruco_EstimateParameters_get_useExtrinsicGuess, (setter)pyopencv_aruco_EstimateParameters_set_useExtrinsicGuess, (char*)"useExtrinsicGuess", NULL}, |  | 34152 | {(char*)"useExtrinsicGuess", (getter)pyopencv_aruco_EstimateParameters_get_useExtrinsicGuess, (setter)pyopencv_aruco_EstimateParameters_set_useExtrinsicGuess, (char*)"useExtrinsicGuess", NULL},
| 34201 | {NULL} /* Sentinel */ |  | 34153 | {NULL} /* Sentinel */
| 34202 | }; |  | 34154 | };
| 34203 |  |  | 34155 |
| 34204 | static PyMethodDef pyopencv_aruco_EstimateParameters_methods[] = |  | 34156 | static PyMethodDef pyopencv_aruco_EstimateParameters_methods[] =
| 34205 | { |  | 34157 | {
| 34206 |  |  | 34158 |
| 34207 | {NULL, NULL} |  | 34159 | {NULL, NULL}
| 34208 | }; |  | 34160 | };
| 34209 |  |  | 34161 |
| 34210 | // Converter (aruco_EstimateParameters) |  | 34162 | // Converter (aruco_EstimateParameters)
| 34211 |  |  | 34163 |
| 34212 | template<> |  | 34164 | template<>
| 34213 | struct PyOpenCV_Converter< cv::aruco::EstimateParameters > |  | 34165 | struct PyOpenCV_Converter< cv::aruco::EstimateParameters >
| 34214 | { |  | 34166 | {
| 34215 | static PyObject* from(const cv::aruco::EstimateParameters& r) |  | 34167 | static PyObject* from(const cv::aruco::EstimateParameters& r)
| 34216 | { |  | 34168 | {
| 34217 | return pyopencv_aruco_EstimateParameters_Instance(r); |  | 34169 | return pyopencv_aruco_EstimateParameters_Instance(r);
| 34218 | } |  | 34170 | }
| 34219 | static bool to(PyObject* src, cv::aruco::EstimateParameters& dst, const ArgInfo& info) |  | 34171 | static bool to(PyObject* src, cv::aruco::EstimateParameters& dst, const ArgInfo& info)
| 34220 | { |  | 34172 | {
| 34221 | if(!src || src == Py_None) |  | 34173 | if(!src || src == Py_None)
| 34222 | return true; |  | 34174 | return true;
| 34223 | cv::aruco::EstimateParameters * dst_; |  | 34175 | cv::aruco::EstimateParameters * dst_;
| 34224 | if (pyopencv_aruco_EstimateParameters_getp(src, dst_)) |  | 34176 | if (pyopencv_aruco_EstimateParameters_getp(src, dst_))
| 34225 | { |  | 34177 | {
| 34226 | dst = *dst_; |  | 34178 | dst = *dst_;
| 34227 | return true; |  | 34179 | return true;
| 34228 | } |  | 34180 | }
| 34229 |  |  | 34181 |
| 34230 | failmsg("Expected cv::aruco::EstimateParameters for argument '%s'", info.name); |  | 34182 | failmsg("Expected cv::aruco::EstimateParameters for argument '%s'", info.name);
| 34231 | return false; |  | 34183 | return false;
| 34232 | } |  | 34184 | }
| 34233 | }; |  | 34185 | };
| 34234 |  |  | 34186 |
| 34235 | //================================================================================ |  | 34187 | //================================================================================
| 34236 | // aruco_GridBoard (Generic) |  | 34188 | // aruco_GridBoard (Generic)
| 34237 | //================================================================================ |  | 34189 | //================================================================================
| 34238 |  |  | 34190 |
| 34239 | // GetSet (aruco_GridBoard) |  | 34191 | // GetSet (aruco_GridBoard)
| 34240 |  |  | 34192 |
| 34241 |  |  | 34193 |
| 34242 |  |  | 34194 |
| 34243 | // Methods (aruco_GridBoard) |  | 34195 | // Methods (aruco_GridBoard)
| 34244 |  |  | 34196 |
| 34245 | static int pyopencv_cv_aruco_aruco_GridBoard_GridBoard(pyopencv_aruco_GridBoard_t* self, PyObject* py_args, PyObject* kw) |  | 34197 | static int pyopencv_cv_aruco_aruco_GridBoard_GridBoard(pyopencv_aruco_GridBoard_t* self, PyObject* py_args, PyObject* kw)
| 34246 | { |  | 34198 | {
| 34247 | using namespace cv::aruco; |  | 34199 | using namespace cv::aruco;
| 34248 |  |  | 34200 |
| 34249 | pyPrepareArgumentConversionErrorsStorage(2); |  | 34201 | pyPrepareArgumentConversionErrorsStorage(2);
| 34250 |  |  | 34202 |
| 34251 | { |  | 34203 | {
| 34252 | PyObject* pyobj_size = NULL; |  | 34204 | PyObject* pyobj_size = NULL;
| 34253 | Size size; |  | 34205 | Size size;
| 34254 | PyObject* pyobj_markerLength = NULL; |  | 34206 | PyObject* pyobj_markerLength = NULL;
| 34255 | float markerLength=0.f; |  | 34207 | float markerLength=0.f;
| 34256 | PyObject* pyobj_markerSeparation = NULL; |  | 34208 | PyObject* pyobj_markerSeparation = NULL;
| 34257 | float markerSeparation=0.f; |  | 34209 | float markerSeparation=0.f;
| 34258 | PyObject* pyobj_dictionary = NULL; |  | 34210 | PyObject* pyobj_dictionary = NULL;
| 34259 | Dictionary dictionary; |  | 34211 | Dictionary dictionary;
| 34260 | PyObject* pyobj_ids = NULL; |  | 34212 | PyObject* pyobj_ids = NULL;
| 34261 | Mat ids; |  | 34213 | Mat ids;
| 34262 |  |  | 34214 |
| 34263 | const char* keywords[] = { "size", "markerLength", "markerSeparation", "dictionary", "ids", NULL }; |  | 34215 | const char* keywords[] = { "size", "markerLength", "markerSeparation", "dictionary", "ids", NULL };
| 34264 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:GridBoard", (char**)keywords, &pyobj_size, &pyobj_markerLength, &pyobj_markerSeparation, &pyobj_dictionary, &pyobj_ids) && |  | 34216 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:GridBoard", (char**)keywords, &pyobj_size, &pyobj_markerLength, &pyobj_markerSeparation, &pyobj_dictionary, &pyobj_ids) &&
| 34265 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 34217 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 34266 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) && |  | 34218 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) &&
| 34267 | pyopencv_to_safe(pyobj_markerSeparation, markerSeparation, ArgInfo("markerSeparation", 0)) && |  | 34219 | pyopencv_to_safe(pyobj_markerSeparation, markerSeparation, ArgInfo("markerSeparation", 0)) &&
| 34268 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) && |  | 34220 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) &&
| 34269 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) ) |  | 34221 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) )
| 34270 | { |  | 34222 | {
| 34271 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::GridBoard(size, markerLength, markerSeparation, dictionary, ids)); |  | 34223 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::GridBoard(size, markerLength, markerSeparation, dictionary, ids));
| 34272 | return 0; |  | 34224 | return 0;
| 34273 | } |  | 34225 | }
| 34274 |  |  | 34226 |
| 34275 |  |  | 34227 |
| 34276 | pyPopulateArgumentConversionErrors(); |  | 34228 | pyPopulateArgumentConversionErrors();
| 34277 | } |  | 34229 | }
| 34278 |  |  | 34230 |
| 34279 |  |  | 34231 |
| 34280 | { |  | 34232 | {
| 34281 | PyObject* pyobj_size = NULL; |  | 34233 | PyObject* pyobj_size = NULL;
| 34282 | Size size; |  | 34234 | Size size;
| 34283 | PyObject* pyobj_markerLength = NULL; |  | 34235 | PyObject* pyobj_markerLength = NULL;
| 34284 | float markerLength=0.f; |  | 34236 | float markerLength=0.f;
| 34285 | PyObject* pyobj_markerSeparation = NULL; |  | 34237 | PyObject* pyobj_markerSeparation = NULL;
| 34286 | float markerSeparation=0.f; |  | 34238 | float markerSeparation=0.f;
| 34287 | PyObject* pyobj_dictionary = NULL; |  | 34239 | PyObject* pyobj_dictionary = NULL;
| 34288 | Dictionary dictionary; |  | 34240 | Dictionary dictionary;
| 34289 | PyObject* pyobj_ids = NULL; |  | 34241 | PyObject* pyobj_ids = NULL;
| 34290 | UMat ids; |  | 34242 | UMat ids;
| 34291 |  |  | 34243 |
| 34292 | const char* keywords[] = { "size", "markerLength", "markerSeparation", "dictionary", "ids", NULL }; |  | 34244 | const char* keywords[] = { "size", "markerLength", "markerSeparation", "dictionary", "ids", NULL };
| 34293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:GridBoard", (char**)keywords, &pyobj_size, &pyobj_markerLength, &pyobj_markerSeparation, &pyobj_dictionary, &pyobj_ids) && |  | 34245 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:GridBoard", (char**)keywords, &pyobj_size, &pyobj_markerLength, &pyobj_markerSeparation, &pyobj_dictionary, &pyobj_ids) &&
| 34294 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 34246 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 34295 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) && |  | 34247 | pyopencv_to_safe(pyobj_markerLength, markerLength, ArgInfo("markerLength", 0)) &&
| 34296 | pyopencv_to_safe(pyobj_markerSeparation, markerSeparation, ArgInfo("markerSeparation", 0)) && |  | 34248 | pyopencv_to_safe(pyobj_markerSeparation, markerSeparation, ArgInfo("markerSeparation", 0)) &&
| 34297 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) && |  | 34249 | pyopencv_to_safe(pyobj_dictionary, dictionary, ArgInfo("dictionary", 0)) &&
| 34298 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) ) |  | 34250 | pyopencv_to_safe(pyobj_ids, ids, ArgInfo("ids", 0)) )
| 34299 | { |  | 34251 | {
| 34300 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::GridBoard(size, markerLength, markerSeparation, dictionary, ids)); |  | 34252 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::GridBoard(size, markerLength, markerSeparation, dictionary, ids));
| 34301 | return 0; |  | 34253 | return 0;
| 34302 | } |  | 34254 | }
| 34303 |  |  | 34255 |
| 34304 |  |  | 34256 |
| 34305 | pyPopulateArgumentConversionErrors(); |  | 34257 | pyPopulateArgumentConversionErrors();
| 34306 | } |  | 34258 | }
| 34307 | pyRaiseCVOverloadException("GridBoard"); |  | 34259 | pyRaiseCVOverloadException("GridBoard");
| 34308 |  |  | 34260 |
| 34309 | return -1; |  | 34261 | return -1;
| 34310 | } |  | 34262 | }
| 34311 |  |  | 34263 |
| 34312 | static PyObject* pyopencv_cv_aruco_aruco_GridBoard_getGridSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34264 | static PyObject* pyopencv_cv_aruco_aruco_GridBoard_getGridSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 34313 | { |  | 34265 | {
| 34314 | using namespace cv::aruco; |  | 34266 | using namespace cv::aruco;
| 34315 |  |  | 34267 |
| 34316 |  |  | 34268 |
| 34317 | cv::aruco::GridBoard * self1 = 0; |  | 34269 | cv::aruco::GridBoard * self1 = 0;
| 34318 | if (!pyopencv_aruco_GridBoard_getp(self, self1)) |  | 34270 | if (!pyopencv_aruco_GridBoard_getp(self, self1))
| 34319 | return failmsgp("Incorrect type of self (must be 'aruco_GridBoard' or its derivative)"); |  | 34271 | return failmsgp("Incorrect type of self (must be 'aruco_GridBoard' or its derivative)");
| 34320 | cv::aruco::GridBoard* _self_ = (self1); |  | 34272 | cv::aruco::GridBoard* _self_ = (self1);
| 34321 | Size retval; |  | 34273 | Size retval;
| 34322 |  |  | 34274 |
| 34323 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34275 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34324 | { |  | 34276 | {
| 34325 | ERRWRAP2(retval = _self_->getGridSize()); |  | 34277 | ERRWRAP2(retval = _self_->getGridSize());
| 34326 | return pyopencv_from(retval); |  | 34278 | return pyopencv_from(retval);
| 34327 | } |  | 34279 | }
| 34328 |  |  | 34280 |
| 34329 | return NULL; |  | 34281 | return NULL;
| 34330 | } |  | 34282 | }
| 34331 |  |  | 34283 |
| 34332 | static PyObject* pyopencv_cv_aruco_aruco_GridBoard_getMarkerLength(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34284 | static PyObject* pyopencv_cv_aruco_aruco_GridBoard_getMarkerLength(PyObject* self, PyObject* py_args, PyObject* kw)
| 34333 | { |  | 34285 | {
| 34334 | using namespace cv::aruco; |  | 34286 | using namespace cv::aruco;
| 34335 |  |  | 34287 |
| 34336 |  |  | 34288 |
| 34337 | cv::aruco::GridBoard * self1 = 0; |  | 34289 | cv::aruco::GridBoard * self1 = 0;
| 34338 | if (!pyopencv_aruco_GridBoard_getp(self, self1)) |  | 34290 | if (!pyopencv_aruco_GridBoard_getp(self, self1))
| 34339 | return failmsgp("Incorrect type of self (must be 'aruco_GridBoard' or its derivative)"); |  | 34291 | return failmsgp("Incorrect type of self (must be 'aruco_GridBoard' or its derivative)");
| 34340 | cv::aruco::GridBoard* _self_ = (self1); |  | 34292 | cv::aruco::GridBoard* _self_ = (self1);
| 34341 | float retval; |  | 34293 | float retval;
| 34342 |  |  | 34294 |
| 34343 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34295 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34344 | { |  | 34296 | {
| 34345 | ERRWRAP2(retval = _self_->getMarkerLength()); |  | 34297 | ERRWRAP2(retval = _self_->getMarkerLength());
| 34346 | return pyopencv_from(retval); |  | 34298 | return pyopencv_from(retval);
| 34347 | } |  | 34299 | }
| 34348 |  |  | 34300 |
| 34349 | return NULL; |  | 34301 | return NULL;
| 34350 | } |  | 34302 | }
| 34351 |  |  | 34303 |
| 34352 | static PyObject* pyopencv_cv_aruco_aruco_GridBoard_getMarkerSeparation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34304 | static PyObject* pyopencv_cv_aruco_aruco_GridBoard_getMarkerSeparation(PyObject* self, PyObject* py_args, PyObject* kw)
| 34353 | { |  | 34305 | {
| 34354 | using namespace cv::aruco; |  | 34306 | using namespace cv::aruco;
| 34355 |  |  | 34307 |
| 34356 |  |  | 34308 |
| 34357 | cv::aruco::GridBoard * self1 = 0; |  | 34309 | cv::aruco::GridBoard * self1 = 0;
| 34358 | if (!pyopencv_aruco_GridBoard_getp(self, self1)) |  | 34310 | if (!pyopencv_aruco_GridBoard_getp(self, self1))
| 34359 | return failmsgp("Incorrect type of self (must be 'aruco_GridBoard' or its derivative)"); |  | 34311 | return failmsgp("Incorrect type of self (must be 'aruco_GridBoard' or its derivative)");
| 34360 | cv::aruco::GridBoard* _self_ = (self1); |  | 34312 | cv::aruco::GridBoard* _self_ = (self1);
| 34361 | float retval; |  | 34313 | float retval;
| 34362 |  |  | 34314 |
| 34363 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34315 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34364 | { |  | 34316 | {
| 34365 | ERRWRAP2(retval = _self_->getMarkerSeparation()); |  | 34317 | ERRWRAP2(retval = _self_->getMarkerSeparation());
| 34366 | return pyopencv_from(retval); |  | 34318 | return pyopencv_from(retval);
| 34367 | } |  | 34319 | }
| 34368 |  |  | 34320 |
| 34369 | return NULL; |  | 34321 | return NULL;
| 34370 | } |  | 34322 | }
| 34371 |  |  | 34323 |
| 34372 |  |  | 34324 |
| 34373 |  |  | 34325 |
| 34374 | // Tables (aruco_GridBoard) |  | 34326 | // Tables (aruco_GridBoard)
| 34375 |  |  | 34327 |
| 34376 | static PyGetSetDef pyopencv_aruco_GridBoard_getseters[] = |  | 34328 | static PyGetSetDef pyopencv_aruco_GridBoard_getseters[] =
| 34377 | { |  | 34329 | {
| 34378 | {NULL} /* Sentinel */ |  | 34330 | {NULL} /* Sentinel */
| 34379 | }; |  | 34331 | };
| 34380 |  |  | 34332 |
| 34381 | static PyMethodDef pyopencv_aruco_GridBoard_methods[] = |  | 34333 | static PyMethodDef pyopencv_aruco_GridBoard_methods[] =
| 34382 | { |  | 34334 | {
| 34383 | {"getGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_GridBoard_getGridSize, 0), "getGridSize() -> retval\n."}, |  | 34335 | {"getGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_GridBoard_getGridSize, 0), "getGridSize() -> retval\n."},
| 34384 | {"getMarkerLength", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_GridBoard_getMarkerLength, 0), "getMarkerLength() -> retval\n."}, |  | 34336 | {"getMarkerLength", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_GridBoard_getMarkerLength, 0), "getMarkerLength() -> retval\n."},
| 34385 | {"getMarkerSeparation", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_GridBoard_getMarkerSeparation, 0), "getMarkerSeparation() -> retval\n."}, |  | 34337 | {"getMarkerSeparation", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_GridBoard_getMarkerSeparation, 0), "getMarkerSeparation() -> retval\n."},
| 34386 |  |  | 34338 |
| 34387 | {NULL, NULL} |  | 34339 | {NULL, NULL}
| 34388 | }; |  | 34340 | };
| 34389 |  |  | 34341 |
| 34390 | // Converter (aruco_GridBoard) |  | 34342 | // Converter (aruco_GridBoard)
| 34391 |  |  | 34343 |
| 34392 | template<> |  | 34344 | template<>
| 34393 | struct PyOpenCV_Converter< cv::aruco::GridBoard > |  | 34345 | struct PyOpenCV_Converter< cv::aruco::GridBoard >
| 34394 | { |  | 34346 | {
| 34395 | static PyObject* from(const cv::aruco::GridBoard& r) |  | 34347 | static PyObject* from(const cv::aruco::GridBoard& r)
| 34396 | { |  | 34348 | {
| 34397 | return pyopencv_aruco_GridBoard_Instance(r); |  | 34349 | return pyopencv_aruco_GridBoard_Instance(r);
| 34398 | } |  | 34350 | }
| 34399 | static bool to(PyObject* src, cv::aruco::GridBoard& dst, const ArgInfo& info) |  | 34351 | static bool to(PyObject* src, cv::aruco::GridBoard& dst, const ArgInfo& info)
| 34400 | { |  | 34352 | {
| 34401 | if(!src || src == Py_None) |  | 34353 | if(!src || src == Py_None)
| 34402 | return true; |  | 34354 | return true;
| 34403 | cv::aruco::GridBoard * dst_; |  | 34355 | cv::aruco::GridBoard * dst_;
| 34404 | if (pyopencv_aruco_GridBoard_getp(src, dst_)) |  | 34356 | if (pyopencv_aruco_GridBoard_getp(src, dst_))
| 34405 | { |  | 34357 | {
| 34406 | dst = *dst_; |  | 34358 | dst = *dst_;
| 34407 | return true; |  | 34359 | return true;
| 34408 | } |  | 34360 | }
| 34409 |  |  | 34361 |
| 34410 | failmsg("Expected cv::aruco::GridBoard for argument '%s'", info.name); |  | 34362 | failmsg("Expected cv::aruco::GridBoard for argument '%s'", info.name);
| 34411 | return false; |  | 34363 | return false;
| 34412 | } |  | 34364 | }
| 34413 | }; |  | 34365 | };
| 34414 |  |  | 34366 |
| 34415 | //================================================================================ |  | 34367 | //================================================================================
| 34416 | // aruco_RefineParameters (Generic) |  | 34368 | // aruco_RefineParameters (Generic)
| 34417 | //================================================================================ |  | 34369 | //================================================================================
| 34418 |  |  | 34370 |
| 34419 | // GetSet (aruco_RefineParameters) |  | 34371 | // GetSet (aruco_RefineParameters)
| 34420 |  |  | 34372 |
| 34421 |  |  | 34373 |
| 34422 | static PyObject* pyopencv_aruco_RefineParameters_get_checkAllOrders(pyopencv_aruco_RefineParameters_t* p, void *closure) |  | 34374 | static PyObject* pyopencv_aruco_RefineParameters_get_checkAllOrders(pyopencv_aruco_RefineParameters_t* p, void *closure)
| 34423 | { |  | 34375 | {
| 34424 | return pyopencv_from(p->v.checkAllOrders); |  | 34376 | return pyopencv_from(p->v.checkAllOrders);
| 34425 | } |  | 34377 | }
| 34426 |  |  | 34378 |
| 34427 | static int pyopencv_aruco_RefineParameters_set_checkAllOrders(pyopencv_aruco_RefineParameters_t* p, PyObject *value, void *closure) |  | 34379 | static int pyopencv_aruco_RefineParameters_set_checkAllOrders(pyopencv_aruco_RefineParameters_t* p, PyObject *value, void *closure)
| 34428 | { |  | 34380 | {
| 34429 | if (!value) |  | 34381 | if (!value)
| 34430 | { |  | 34382 | {
| 34431 | PyErr_SetString(PyExc_TypeError, "Cannot delete the checkAllOrders attribute"); |  | 34383 | PyErr_SetString(PyExc_TypeError, "Cannot delete the checkAllOrders attribute");
| 34432 | return -1; |  | 34384 | return -1;
| 34433 | } |  | 34385 | }
| 34434 | return pyopencv_to_safe(value, p->v.checkAllOrders, ArgInfo("value", 0)) ? 0 : -1; |  | 34386 | return pyopencv_to_safe(value, p->v.checkAllOrders, ArgInfo("value", 0)) ? 0 : -1;
| 34435 | } |  | 34387 | }
| 34436 |  |  | 34388 |
| 34437 | static PyObject* pyopencv_aruco_RefineParameters_get_errorCorrectionRate(pyopencv_aruco_RefineParameters_t* p, void *closure) |  | 34389 | static PyObject* pyopencv_aruco_RefineParameters_get_errorCorrectionRate(pyopencv_aruco_RefineParameters_t* p, void *closure)
| 34438 | { |  | 34390 | {
| 34439 | return pyopencv_from(p->v.errorCorrectionRate); |  | 34391 | return pyopencv_from(p->v.errorCorrectionRate);
| 34440 | } |  | 34392 | }
| 34441 |  |  | 34393 |
| 34442 | static int pyopencv_aruco_RefineParameters_set_errorCorrectionRate(pyopencv_aruco_RefineParameters_t* p, PyObject *value, void *closure) |  | 34394 | static int pyopencv_aruco_RefineParameters_set_errorCorrectionRate(pyopencv_aruco_RefineParameters_t* p, PyObject *value, void *closure)
| 34443 | { |  | 34395 | {
| 34444 | if (!value) |  | 34396 | if (!value)
| 34445 | { |  | 34397 | {
| 34446 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCorrectionRate attribute"); |  | 34398 | PyErr_SetString(PyExc_TypeError, "Cannot delete the errorCorrectionRate attribute");
| 34447 | return -1; |  | 34399 | return -1;
| 34448 | } |  | 34400 | }
| 34449 | return pyopencv_to_safe(value, p->v.errorCorrectionRate, ArgInfo("value", 0)) ? 0 : -1; |  | 34401 | return pyopencv_to_safe(value, p->v.errorCorrectionRate, ArgInfo("value", 0)) ? 0 : -1;
| 34450 | } |  | 34402 | }
| 34451 |  |  | 34403 |
| 34452 | static PyObject* pyopencv_aruco_RefineParameters_get_minRepDistance(pyopencv_aruco_RefineParameters_t* p, void *closure) |  | 34404 | static PyObject* pyopencv_aruco_RefineParameters_get_minRepDistance(pyopencv_aruco_RefineParameters_t* p, void *closure)
| 34453 | { |  | 34405 | {
| 34454 | return pyopencv_from(p->v.minRepDistance); |  | 34406 | return pyopencv_from(p->v.minRepDistance);
| 34455 | } |  | 34407 | }
| 34456 |  |  | 34408 |
| 34457 | static int pyopencv_aruco_RefineParameters_set_minRepDistance(pyopencv_aruco_RefineParameters_t* p, PyObject *value, void *closure) |  | 34409 | static int pyopencv_aruco_RefineParameters_set_minRepDistance(pyopencv_aruco_RefineParameters_t* p, PyObject *value, void *closure)
| 34458 | { |  | 34410 | {
| 34459 | if (!value) |  | 34411 | if (!value)
| 34460 | { |  | 34412 | {
| 34461 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minRepDistance attribute"); |  | 34413 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minRepDistance attribute");
| 34462 | return -1; |  | 34414 | return -1;
| 34463 | } |  | 34415 | }
| 34464 | return pyopencv_to_safe(value, p->v.minRepDistance, ArgInfo("value", 0)) ? 0 : -1; |  | 34416 | return pyopencv_to_safe(value, p->v.minRepDistance, ArgInfo("value", 0)) ? 0 : -1;
| 34465 | } |  | 34417 | }
| 34466 |  |  | 34418 |
| 34467 |  |  | 34419 |
| 34468 | // Methods (aruco_RefineParameters) |  | 34420 | // Methods (aruco_RefineParameters)
| 34469 |  |  | 34421 |
| 34470 | static int pyopencv_cv_aruco_aruco_RefineParameters_RefineParameters(pyopencv_aruco_RefineParameters_t* self, PyObject* py_args, PyObject* kw) |  | 34422 | static int pyopencv_cv_aruco_aruco_RefineParameters_RefineParameters(pyopencv_aruco_RefineParameters_t* self, PyObject* py_args, PyObject* kw)
| 34471 | { |  | 34423 | {
| 34472 | using namespace cv::aruco; |  | 34424 | using namespace cv::aruco;
| 34473 |  |  | 34425 |
| 34474 | PyObject* pyobj_minRepDistance = NULL; |  | 34426 | PyObject* pyobj_minRepDistance = NULL;
| 34475 | float minRepDistance=10.f; |  | 34427 | float minRepDistance=10.f;
| 34476 | PyObject* pyobj_errorCorrectionRate = NULL; |  | 34428 | PyObject* pyobj_errorCorrectionRate = NULL;
| 34477 | float errorCorrectionRate=3.f; |  | 34429 | float errorCorrectionRate=3.f;
| 34478 | PyObject* pyobj_checkAllOrders = NULL; |  | 34430 | PyObject* pyobj_checkAllOrders = NULL;
| 34479 | bool checkAllOrders=true; |  | 34431 | bool checkAllOrders=true;
| 34480 |  |  | 34432 |
| 34481 | const char* keywords[] = { "minRepDistance", "errorCorrectionRate", "checkAllOrders", NULL }; |  | 34433 | const char* keywords[] = { "minRepDistance", "errorCorrectionRate", "checkAllOrders", NULL };
| 34482 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:RefineParameters", (char**)keywords, &pyobj_minRepDistance, &pyobj_errorCorrectionRate, &pyobj_checkAllOrders) && |  | 34434 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:RefineParameters", (char**)keywords, &pyobj_minRepDistance, &pyobj_errorCorrectionRate, &pyobj_checkAllOrders) &&
| 34483 | pyopencv_to_safe(pyobj_minRepDistance, minRepDistance, ArgInfo("minRepDistance", 0)) && |  | 34435 | pyopencv_to_safe(pyobj_minRepDistance, minRepDistance, ArgInfo("minRepDistance", 0)) &&
| 34484 | pyopencv_to_safe(pyobj_errorCorrectionRate, errorCorrectionRate, ArgInfo("errorCorrectionRate", 0)) && |  | 34436 | pyopencv_to_safe(pyobj_errorCorrectionRate, errorCorrectionRate, ArgInfo("errorCorrectionRate", 0)) &&
| 34485 | pyopencv_to_safe(pyobj_checkAllOrders, checkAllOrders, ArgInfo("checkAllOrders", 0)) ) |  | 34437 | pyopencv_to_safe(pyobj_checkAllOrders, checkAllOrders, ArgInfo("checkAllOrders", 0)) )
| 34486 | { |  | 34438 | {
| 34487 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::RefineParameters(minRepDistance, errorCorrectionRate, checkAllOrders)); |  | 34439 | if(self) ERRWRAP2(new (&(self->v)) cv::aruco::RefineParameters(minRepDistance, errorCorrectionRate, checkAllOrders));
| 34488 | return 0; |  | 34440 | return 0;
| 34489 | } |  | 34441 | }
| 34490 |  |  | 34442 |
| 34491 | return -1; |  | 34443 | return -1;
| 34492 | } |  | 34444 | }
| 34493 |  |  | 34445 |
| 34494 | static PyObject* pyopencv_cv_aruco_aruco_RefineParameters_readRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34446 | static PyObject* pyopencv_cv_aruco_aruco_RefineParameters_readRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 34495 | { |  | 34447 | {
| 34496 | using namespace cv::aruco; |  | 34448 | using namespace cv::aruco;
| 34497 |  |  | 34449 |
| 34498 |  |  | 34450 |
| 34499 | cv::aruco::RefineParameters * self1 = 0; |  | 34451 | cv::aruco::RefineParameters * self1 = 0;
| 34500 | if (!pyopencv_aruco_RefineParameters_getp(self, self1)) |  | 34452 | if (!pyopencv_aruco_RefineParameters_getp(self, self1))
| 34501 | return failmsgp("Incorrect type of self (must be 'aruco_RefineParameters' or its derivative)"); |  | 34453 | return failmsgp("Incorrect type of self (must be 'aruco_RefineParameters' or its derivative)");
| 34502 | cv::aruco::RefineParameters* _self_ = (self1); |  | 34454 | cv::aruco::RefineParameters* _self_ = (self1);
| 34503 | PyObject* pyobj_fn = NULL; |  | 34455 | PyObject* pyobj_fn = NULL;
| 34504 | cv::FileNode fn; |  | 34456 | cv::FileNode fn;
| 34505 | bool retval; |  | 34457 | bool retval;
| 34506 |  |  | 34458 |
| 34507 | const char* keywords[] = { "fn", NULL }; |  | 34459 | const char* keywords[] = { "fn", NULL };
| 34508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_RefineParameters.readRefineParameters", (char**)keywords, &pyobj_fn) && |  | 34460 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:aruco_RefineParameters.readRefineParameters", (char**)keywords, &pyobj_fn) &&
| 34509 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 34461 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 34510 | { |  | 34462 | {
| 34511 | ERRWRAP2(retval = _self_->readRefineParameters(fn)); |  | 34463 | ERRWRAP2(retval = _self_->readRefineParameters(fn));
| 34512 | return pyopencv_from(retval); |  | 34464 | return pyopencv_from(retval);
| 34513 | } |  | 34465 | }
| 34514 |  |  | 34466 |
| 34515 | return NULL; |  | 34467 | return NULL;
| 34516 | } |  | 34468 | }
| 34517 |  |  | 34469 |
| 34518 | static PyObject* pyopencv_cv_aruco_aruco_RefineParameters_writeRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34470 | static PyObject* pyopencv_cv_aruco_aruco_RefineParameters_writeRefineParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 34519 | { |  | 34471 | {
| 34520 | using namespace cv::aruco; |  | 34472 | using namespace cv::aruco;
| 34521 |  |  | 34473 |
| 34522 |  |  | 34474 |
| 34523 | cv::aruco::RefineParameters * self1 = 0; |  | 34475 | cv::aruco::RefineParameters * self1 = 0;
| 34524 | if (!pyopencv_aruco_RefineParameters_getp(self, self1)) |  | 34476 | if (!pyopencv_aruco_RefineParameters_getp(self, self1))
| 34525 | return failmsgp("Incorrect type of self (must be 'aruco_RefineParameters' or its derivative)"); |  | 34477 | return failmsgp("Incorrect type of self (must be 'aruco_RefineParameters' or its derivative)");
| 34526 | cv::aruco::RefineParameters* _self_ = (self1); |  | 34478 | cv::aruco::RefineParameters* _self_ = (self1);
| 34527 | PyObject* pyobj_fs = NULL; |  | 34479 | PyObject* pyobj_fs = NULL;
| 34528 | Ptr<cv::FileStorage> fs; |  | 34480 | Ptr<cv::FileStorage> fs;
| 34529 | PyObject* pyobj_name = NULL; |  | 34481 | PyObject* pyobj_name = NULL;
| 34530 | String name; |  | 34482 | String name;
| 34531 | bool retval; |  | 34483 | bool retval;
| 34532 |  |  | 34484 |
| 34533 | const char* keywords[] = { "fs", "name", NULL }; |  | 34485 | const char* keywords[] = { "fs", "name", NULL };
| 34534 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:aruco_RefineParameters.writeRefineParameters", (char**)keywords, &pyobj_fs, &pyobj_name) && |  | 34486 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:aruco_RefineParameters.writeRefineParameters", (char**)keywords, &pyobj_fs, &pyobj_name) &&
| 34535 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) && |  | 34487 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) &&
| 34536 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) ) |  | 34488 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) )
| 34537 | { |  | 34489 | {
| 34538 | ERRWRAP2(retval = _self_->writeRefineParameters(*fs, name)); |  | 34490 | ERRWRAP2(retval = _self_->writeRefineParameters(*fs, name));
| 34539 | return pyopencv_from(retval); |  | 34491 | return pyopencv_from(retval);
| 34540 | } |  | 34492 | }
| 34541 |  |  | 34493 |
| 34542 | return NULL; |  | 34494 | return NULL;
| 34543 | } |  | 34495 | }
| 34544 |  |  | 34496 |
| 34545 |  |  | 34497 |
| 34546 |  |  | 34498 |
| 34547 | // Tables (aruco_RefineParameters) |  | 34499 | // Tables (aruco_RefineParameters)
| 34548 |  |  | 34500 |
| 34549 | static PyGetSetDef pyopencv_aruco_RefineParameters_getseters[] = |  | 34501 | static PyGetSetDef pyopencv_aruco_RefineParameters_getseters[] =
| 34550 | { |  | 34502 | {
| 34551 | {(char*)"checkAllOrders", (getter)pyopencv_aruco_RefineParameters_get_checkAllOrders, (setter)pyopencv_aruco_RefineParameters_set_checkAllOrders, (char*)"checkAllOrders", NULL}, |  | 34503 | {(char*)"checkAllOrders", (getter)pyopencv_aruco_RefineParameters_get_checkAllOrders, (setter)pyopencv_aruco_RefineParameters_set_checkAllOrders, (char*)"checkAllOrders", NULL},
| 34552 | {(char*)"errorCorrectionRate", (getter)pyopencv_aruco_RefineParameters_get_errorCorrectionRate, (setter)pyopencv_aruco_RefineParameters_set_errorCorrectionRate, (char*)"errorCorrectionRate", NULL}, |  | 34504 | {(char*)"errorCorrectionRate", (getter)pyopencv_aruco_RefineParameters_get_errorCorrectionRate, (setter)pyopencv_aruco_RefineParameters_set_errorCorrectionRate, (char*)"errorCorrectionRate", NULL},
| 34553 | {(char*)"minRepDistance", (getter)pyopencv_aruco_RefineParameters_get_minRepDistance, (setter)pyopencv_aruco_RefineParameters_set_minRepDistance, (char*)"minRepDistance", NULL}, |  | 34505 | {(char*)"minRepDistance", (getter)pyopencv_aruco_RefineParameters_get_minRepDistance, (setter)pyopencv_aruco_RefineParameters_set_minRepDistance, (char*)"minRepDistance", NULL},
| 34554 | {NULL} /* Sentinel */ |  | 34506 | {NULL} /* Sentinel */
| 34555 | }; |  | 34507 | };
| 34556 |  |  | 34508 |
| 34557 | static PyMethodDef pyopencv_aruco_RefineParameters_methods[] = |  | 34509 | static PyMethodDef pyopencv_aruco_RefineParameters_methods[] =
| 34558 | { |  | 34510 | {
| 34559 | {"readRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_RefineParameters_readRefineParameters, 0), "readRefineParameters(fn) -> retval\n. @brief Read a new set of RefineParameters from FileNode (use FileStorage.root())."}, |  | 34511 | {"readRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_RefineParameters_readRefineParameters, 0), "readRefineParameters(fn) -> retval\n. @brief Read a new set of RefineParameters from FileNode (use FileStorage.root())."},
| 34560 | {"writeRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_RefineParameters_writeRefineParameters, 0), "writeRefineParameters(fs[, name]) -> retval\n. @brief Write a set of RefineParameters to FileStorage"}, |  | 34512 | {"writeRefineParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_aruco_aruco_RefineParameters_writeRefineParameters, 0), "writeRefineParameters(fs[, name]) -> retval\n. @brief Write a set of RefineParameters to FileStorage"},
| 34561 |  |  | 34513 |
| 34562 | {NULL, NULL} |  | 34514 | {NULL, NULL}
| 34563 | }; |  | 34515 | };
| 34564 |  |  | 34516 |
| 34565 | // Converter (aruco_RefineParameters) |  | 34517 | // Converter (aruco_RefineParameters)
| 34566 |  |  | 34518 |
| 34567 | template<> |  | 34519 | template<>
| 34568 | struct PyOpenCV_Converter< cv::aruco::RefineParameters > |  | 34520 | struct PyOpenCV_Converter< cv::aruco::RefineParameters >
| 34569 | { |  | 34521 | {
| 34570 | static PyObject* from(const cv::aruco::RefineParameters& r) |  | 34522 | static PyObject* from(const cv::aruco::RefineParameters& r)
| 34571 | { |  | 34523 | {
| 34572 | return pyopencv_aruco_RefineParameters_Instance(r); |  | 34524 | return pyopencv_aruco_RefineParameters_Instance(r);
| 34573 | } |  | 34525 | }
| 34574 | static bool to(PyObject* src, cv::aruco::RefineParameters& dst, const ArgInfo& info) |  | 34526 | static bool to(PyObject* src, cv::aruco::RefineParameters& dst, const ArgInfo& info)
| 34575 | { |  | 34527 | {
| 34576 | if(!src || src == Py_None) |  | 34528 | if(!src || src == Py_None)
| 34577 | return true; |  | 34529 | return true;
| 34578 | cv::aruco::RefineParameters * dst_; |  | 34530 | cv::aruco::RefineParameters * dst_;
| 34579 | if (pyopencv_aruco_RefineParameters_getp(src, dst_)) |  | 34531 | if (pyopencv_aruco_RefineParameters_getp(src, dst_))
| 34580 | { |  | 34532 | {
| 34581 | dst = *dst_; |  | 34533 | dst = *dst_;
| 34582 | return true; |  | 34534 | return true;
| 34583 | } |  | 34535 | }
| 34584 |  |  | 34536 |
| 34585 | failmsg("Expected cv::aruco::RefineParameters for argument '%s'", info.name); |  | 34537 | failmsg("Expected cv::aruco::RefineParameters for argument '%s'", info.name);
| 34586 | return false; |  | 34538 | return false;
| 34587 | } |  | 34539 | }
| 34588 | }; |  | 34540 | };
| 34589 |  |  | 34541 |
| 34590 | //================================================================================ |  | 34542 | //================================================================================
| 34591 | // barcode_BarcodeDetector (Generic) |  | 34543 | // barcode_BarcodeDetector (Generic)
| 34592 | //================================================================================ |  | 34544 | //================================================================================
| 34593 |  |  | 34545 |
| 34594 | // GetSet (barcode_BarcodeDetector) |  | 34546 | // GetSet (barcode_BarcodeDetector)
| 34595 |  |  | 34547 |
| 34596 |  |  | 34548 |
| 34597 |  |  | 34549 |
| 34598 | // Methods (barcode_BarcodeDetector) |  | 34550 | // Methods (barcode_BarcodeDetector)
| 34599 |  |  | 34551 |
| 34600 | static int pyopencv_cv_barcode_barcode_BarcodeDetector_BarcodeDetector(pyopencv_barcode_BarcodeDetector_t* self, PyObject* py_args, PyObject* kw) |  | 34552 | static int pyopencv_cv_barcode_barcode_BarcodeDetector_BarcodeDetector(pyopencv_barcode_BarcodeDetector_t* self, PyObject* py_args, PyObject* kw)
| 34601 | { |  | 34553 | {
| 34602 | using namespace cv::barcode; |  | 34554 | using namespace cv::barcode;
| 34603 |  |  | 34555 |
| 34604 | pyPrepareArgumentConversionErrorsStorage(2); |  | 34556 | pyPrepareArgumentConversionErrorsStorage(2);
| 34605 |  |  | 34557 |
| 34606 | { |  | 34558 | {
| 34607 |  |  | 34559 |
| 34608 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34560 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34609 | { |  | 34561 | {
| 34610 | if(self) ERRWRAP2(new (&(self->v)) cv::barcode::BarcodeDetector()); |  | 34562 | if(self) ERRWRAP2(new (&(self->v)) cv::barcode::BarcodeDetector());
| 34611 | return 0; |  | 34563 | return 0;
| 34612 | } |  | 34564 | }
| 34613 |  |  | 34565 |
| 34614 |  |  | 34566 |
| 34615 | pyPopulateArgumentConversionErrors(); |  | 34567 | pyPopulateArgumentConversionErrors();
| 34616 | } |  | 34568 | }
| 34617 |  |  | 34569 |
| 34618 |  |  | 34570 |
| 34619 | { |  | 34571 | {
| 34620 | PyObject* pyobj_prototxt_path = NULL; |  | 34572 | PyObject* pyobj_prototxt_path = NULL;
| 34621 | std::string prototxt_path; |  | 34573 | std::string prototxt_path;
| 34622 | PyObject* pyobj_model_path = NULL; |  | 34574 | PyObject* pyobj_model_path = NULL;
| 34623 | std::string model_path; |  | 34575 | std::string model_path;
| 34624 |  |  | 34576 |
| 34625 | const char* keywords[] = { "prototxt_path", "model_path", NULL }; |  | 34577 | const char* keywords[] = { "prototxt_path", "model_path", NULL };
| 34626 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:BarcodeDetector", (char**)keywords, &pyobj_prototxt_path, &pyobj_model_path) && |  | 34578 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:BarcodeDetector", (char**)keywords, &pyobj_prototxt_path, &pyobj_model_path) &&
| 34627 | pyopencv_to_safe(pyobj_prototxt_path, prototxt_path, ArgInfo("prototxt_path", 4)) && |  | 34579 | pyopencv_to_safe(pyobj_prototxt_path, prototxt_path, ArgInfo("prototxt_path", 4)) &&
| 34628 | pyopencv_to_safe(pyobj_model_path, model_path, ArgInfo("model_path", 4)) ) |  | 34580 | pyopencv_to_safe(pyobj_model_path, model_path, ArgInfo("model_path", 4)) )
| 34629 | { |  | 34581 | {
| 34630 | if(self) ERRWRAP2(new (&(self->v)) cv::barcode::BarcodeDetector(prototxt_path, model_path)); |  | 34582 | if(self) ERRWRAP2(new (&(self->v)) cv::barcode::BarcodeDetector(prototxt_path, model_path));
| 34631 | return 0; |  | 34583 | return 0;
| 34632 | } |  | 34584 | }
| 34633 |  |  | 34585 |
| 34634 |  |  | 34586 |
| 34635 | pyPopulateArgumentConversionErrors(); |  | 34587 | pyPopulateArgumentConversionErrors();
| 34636 | } |  | 34588 | }
| 34637 | pyRaiseCVOverloadException("BarcodeDetector"); |  | 34589 | pyRaiseCVOverloadException("BarcodeDetector");
| 34638 |  |  | 34590 |
| 34639 | return -1; |  | 34591 | return -1;
| 34640 | } |  | 34592 | }
| 34641 |  |  | 34593 |
| 34642 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_decodeWithType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34594 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_decodeWithType(PyObject* self, PyObject* py_args, PyObject* kw)
| 34643 | { |  | 34595 | {
| 34644 | using namespace cv::barcode; |  | 34596 | using namespace cv::barcode;
| 34645 |  |  | 34597 |
| 34646 |  |  | 34598 |
| 34647 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34599 | cv::barcode::BarcodeDetector * self1 = 0;
| 34648 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34600 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34649 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34601 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34650 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34602 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34651 | pyPrepareArgumentConversionErrorsStorage(2); |  | 34603 | pyPrepareArgumentConversionErrorsStorage(2);
| 34652 |  |  | 34604 |
| 34653 | { |  | 34605 | {
| 34654 | PyObject* pyobj_img = NULL; |  | 34606 | PyObject* pyobj_img = NULL;
| 34655 | Mat img; |  | 34607 | Mat img;
| 34656 | PyObject* pyobj_points = NULL; |  | 34608 | PyObject* pyobj_points = NULL;
| 34657 | Mat points; |  | 34609 | Mat points;
| 34658 | vector_string decoded_info; |  | 34610 | vector_string decoded_info;
| 34659 | vector_string decoded_type; |  | 34611 | vector_string decoded_type;
| 34660 | bool retval; |  | 34612 | bool retval;
| 34661 |  |  | 34613 |
| 34662 | const char* keywords[] = { "img", "points", NULL }; |  | 34614 | const char* keywords[] = { "img", "points", NULL };
| 34663 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:barcode_BarcodeDetector.decodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 34615 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:barcode_BarcodeDetector.decodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 34664 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 34616 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 34665 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) ) |  | 34617 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) )
| 34666 | { |  | 34618 | {
| 34667 | ERRWRAP2(retval = _self_->decodeWithType(img, points, decoded_info, decoded_type)); |  | 34619 | ERRWRAP2(retval = _self_->decodeWithType(img, points, decoded_info, decoded_type));
| 34668 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type)); |  | 34620 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type));
| 34669 | } |  | 34621 | }
| 34670 |  |  | 34622 |
| 34671 |  |  | 34623 |
| 34672 | pyPopulateArgumentConversionErrors(); |  | 34624 | pyPopulateArgumentConversionErrors();
| 34673 | } |  | 34625 | }
| 34674 |  |  | 34626 |
| 34675 |  |  | 34627 |
| 34676 | { |  | 34628 | {
| 34677 | PyObject* pyobj_img = NULL; |  | 34629 | PyObject* pyobj_img = NULL;
| 34678 | UMat img; |  | 34630 | UMat img;
| 34679 | PyObject* pyobj_points = NULL; |  | 34631 | PyObject* pyobj_points = NULL;
| 34680 | UMat points; |  | 34632 | UMat points;
| 34681 | vector_string decoded_info; |  | 34633 | vector_string decoded_info;
| 34682 | vector_string decoded_type; |  | 34634 | vector_string decoded_type;
| 34683 | bool retval; |  | 34635 | bool retval;
| 34684 |  |  | 34636 |
| 34685 | const char* keywords[] = { "img", "points", NULL }; |  | 34637 | const char* keywords[] = { "img", "points", NULL };
| 34686 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:barcode_BarcodeDetector.decodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 34638 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:barcode_BarcodeDetector.decodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 34687 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 34639 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 34688 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) ) |  | 34640 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) )
| 34689 | { |  | 34641 | {
| 34690 | ERRWRAP2(retval = _self_->decodeWithType(img, points, decoded_info, decoded_type)); |  | 34642 | ERRWRAP2(retval = _self_->decodeWithType(img, points, decoded_info, decoded_type));
| 34691 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type)); |  | 34643 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type));
| 34692 | } |  | 34644 | }
| 34693 |  |  | 34645 |
| 34694 |  |  | 34646 |
| 34695 | pyPopulateArgumentConversionErrors(); |  | 34647 | pyPopulateArgumentConversionErrors();
| 34696 | } |  | 34648 | }
| 34697 | pyRaiseCVOverloadException("decodeWithType"); |  | 34649 | pyRaiseCVOverloadException("decodeWithType");
| 34698 |  |  | 34650 |
| 34699 | return NULL; |  | 34651 | return NULL;
| 34700 | } |  | 34652 | }
| 34701 |  |  | 34653 |
| 34702 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_detectAndDecodeWithType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34654 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_detectAndDecodeWithType(PyObject* self, PyObject* py_args, PyObject* kw)
| 34703 | { |  | 34655 | {
| 34704 | using namespace cv::barcode; |  | 34656 | using namespace cv::barcode;
| 34705 |  |  | 34657 |
| 34706 |  |  | 34658 |
| 34707 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34659 | cv::barcode::BarcodeDetector * self1 = 0;
| 34708 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34660 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34709 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34661 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34710 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34662 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34711 | pyPrepareArgumentConversionErrorsStorage(2); |  | 34663 | pyPrepareArgumentConversionErrorsStorage(2);
| 34712 |  |  | 34664 |
| 34713 | { |  | 34665 | {
| 34714 | PyObject* pyobj_img = NULL; |  | 34666 | PyObject* pyobj_img = NULL;
| 34715 | Mat img; |  | 34667 | Mat img;
| 34716 | vector_string decoded_info; |  | 34668 | vector_string decoded_info;
| 34717 | vector_string decoded_type; |  | 34669 | vector_string decoded_type;
| 34718 | PyObject* pyobj_points = NULL; |  | 34670 | PyObject* pyobj_points = NULL;
| 34719 | Mat points; |  | 34671 | Mat points;
| 34720 | bool retval; |  | 34672 | bool retval;
| 34721 |  |  | 34673 |
| 34722 | const char* keywords[] = { "img", "points", NULL }; |  | 34674 | const char* keywords[] = { "img", "points", NULL };
| 34723 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:barcode_BarcodeDetector.detectAndDecodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 34675 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:barcode_BarcodeDetector.detectAndDecodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 34724 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 34676 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 34725 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 34677 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 34726 | { |  | 34678 | {
| 34727 | ERRWRAP2(retval = _self_->detectAndDecodeWithType(img, decoded_info, decoded_type, points)); |  | 34679 | ERRWRAP2(retval = _self_->detectAndDecodeWithType(img, decoded_info, decoded_type, points));
| 34728 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type), pyopencv_from(points)); |  | 34680 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type), pyopencv_from(points));
| 34729 | } |  | 34681 | }
| 34730 |  |  | 34682 |
| 34731 |  |  | 34683 |
| 34732 | pyPopulateArgumentConversionErrors(); |  | 34684 | pyPopulateArgumentConversionErrors();
| 34733 | } |  | 34685 | }
| 34734 |  |  | 34686 |
| 34735 |  |  | 34687 |
| 34736 | { |  | 34688 | {
| 34737 | PyObject* pyobj_img = NULL; |  | 34689 | PyObject* pyobj_img = NULL;
| 34738 | UMat img; |  | 34690 | UMat img;
| 34739 | vector_string decoded_info; |  | 34691 | vector_string decoded_info;
| 34740 | vector_string decoded_type; |  | 34692 | vector_string decoded_type;
| 34741 | PyObject* pyobj_points = NULL; |  | 34693 | PyObject* pyobj_points = NULL;
| 34742 | UMat points; |  | 34694 | UMat points;
| 34743 | bool retval; |  | 34695 | bool retval;
| 34744 |  |  | 34696 |
| 34745 | const char* keywords[] = { "img", "points", NULL }; |  | 34697 | const char* keywords[] = { "img", "points", NULL };
| 34746 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:barcode_BarcodeDetector.detectAndDecodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) && |  | 34698 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:barcode_BarcodeDetector.detectAndDecodeWithType", (char**)keywords, &pyobj_img, &pyobj_points) &&
| 34747 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 34699 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 34748 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 34700 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 34749 | { |  | 34701 | {
| 34750 | ERRWRAP2(retval = _self_->detectAndDecodeWithType(img, decoded_info, decoded_type, points)); |  | 34702 | ERRWRAP2(retval = _self_->detectAndDecodeWithType(img, decoded_info, decoded_type, points));
| 34751 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type), pyopencv_from(points)); |  | 34703 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(decoded_info), pyopencv_from(decoded_type), pyopencv_from(points));
| 34752 | } |  | 34704 | }
| 34753 |  |  | 34705 |
| 34754 |  |  | 34706 |
| 34755 | pyPopulateArgumentConversionErrors(); |  | 34707 | pyPopulateArgumentConversionErrors();
| 34756 | } |  | 34708 | }
| 34757 | pyRaiseCVOverloadException("detectAndDecodeWithType"); |  | 34709 | pyRaiseCVOverloadException("detectAndDecodeWithType");
| 34758 |  |  | 34710 |
| 34759 | return NULL; |  | 34711 | return NULL;
| 34760 | } |  | 34712 | }
| 34761 |  |  | 34713 |
| 34762 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_getDetectorScales(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34714 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_getDetectorScales(PyObject* self, PyObject* py_args, PyObject* kw)
| 34763 | { |  | 34715 | {
| 34764 | using namespace cv::barcode; |  | 34716 | using namespace cv::barcode;
| 34765 |  |  | 34717 |
| 34766 |  |  | 34718 |
| 34767 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34719 | cv::barcode::BarcodeDetector * self1 = 0;
| 34768 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34720 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34769 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34721 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34770 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34722 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34771 | vector_float sizes; |  | 34723 | vector_float sizes;
| 34772 |  |  | 34724 |
| 34773 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34725 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34774 | { |  | 34726 | {
| 34775 | ERRWRAP2(_self_->getDetectorScales(sizes)); |  | 34727 | ERRWRAP2(_self_->getDetectorScales(sizes));
| 34776 | return pyopencv_from(sizes); |  | 34728 | return pyopencv_from(sizes);
| 34777 | } |  | 34729 | }
| 34778 |  |  | 34730 |
| 34779 | return NULL; |  | 34731 | return NULL;
| 34780 | } |  | 34732 | }
| 34781 |  |  | 34733 |
| 34782 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_getDownsamplingThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34734 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_getDownsamplingThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 34783 | { |  | 34735 | {
| 34784 | using namespace cv::barcode; |  | 34736 | using namespace cv::barcode;
| 34785 |  |  | 34737 |
| 34786 |  |  | 34738 |
| 34787 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34739 | cv::barcode::BarcodeDetector * self1 = 0;
| 34788 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34740 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34789 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34741 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34790 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34742 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34791 | double retval; |  | 34743 | double retval;
| 34792 |  |  | 34744 |
| 34793 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34745 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34794 | { |  | 34746 | {
| 34795 | ERRWRAP2(retval = _self_->getDownsamplingThreshold()); |  | 34747 | ERRWRAP2(retval = _self_->getDownsamplingThreshold());
| 34796 | return pyopencv_from(retval); |  | 34748 | return pyopencv_from(retval);
| 34797 | } |  | 34749 | }
| 34798 |  |  | 34750 |
| 34799 | return NULL; |  | 34751 | return NULL;
| 34800 | } |  | 34752 | }
| 34801 |  |  | 34753 |
| 34802 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_getGradientThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34754 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_getGradientThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 34803 | { |  | 34755 | {
| 34804 | using namespace cv::barcode; |  | 34756 | using namespace cv::barcode;
| 34805 |  |  | 34757 |
| 34806 |  |  | 34758 |
| 34807 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34759 | cv::barcode::BarcodeDetector * self1 = 0;
| 34808 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34760 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34809 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34761 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34810 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34762 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34811 | double retval; |  | 34763 | double retval;
| 34812 |  |  | 34764 |
| 34813 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 34765 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 34814 | { |  | 34766 | {
| 34815 | ERRWRAP2(retval = _self_->getGradientThreshold()); |  | 34767 | ERRWRAP2(retval = _self_->getGradientThreshold());
| 34816 | return pyopencv_from(retval); |  | 34768 | return pyopencv_from(retval);
| 34817 | } |  | 34769 | }
| 34818 |  |  | 34770 |
| 34819 | return NULL; |  | 34771 | return NULL;
| 34820 | } |  | 34772 | }
| 34821 |  |  | 34773 |
| 34822 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_setDetectorScales(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34774 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_setDetectorScales(PyObject* self, PyObject* py_args, PyObject* kw)
| 34823 | { |  | 34775 | {
| 34824 | using namespace cv::barcode; |  | 34776 | using namespace cv::barcode;
| 34825 |  |  | 34777 |
| 34826 |  |  | 34778 |
| 34827 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34779 | cv::barcode::BarcodeDetector * self1 = 0;
| 34828 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34780 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34829 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34781 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34830 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34782 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34831 | PyObject* pyobj_sizes = NULL; |  | 34783 | PyObject* pyobj_sizes = NULL;
| 34832 | vector_float sizes; |  | 34784 | vector_float sizes;
| 34833 | BarcodeDetector retval; |  | 34785 | BarcodeDetector retval;
| 34834 |  |  | 34786 |
| 34835 | const char* keywords[] = { "sizes", NULL }; |  | 34787 | const char* keywords[] = { "sizes", NULL };
| 34836 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:barcode_BarcodeDetector.setDetectorScales", (char**)keywords, &pyobj_sizes) && |  | 34788 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:barcode_BarcodeDetector.setDetectorScales", (char**)keywords, &pyobj_sizes) &&
| 34837 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) ) |  | 34789 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) )
| 34838 | { |  | 34790 | {
| 34839 | ERRWRAP2(retval = _self_->setDetectorScales(sizes)); |  | 34791 | ERRWRAP2(retval = _self_->setDetectorScales(sizes));
| 34840 | return pyopencv_from(retval); |  | 34792 | return pyopencv_from(retval);
| 34841 | } |  | 34793 | }
| 34842 |  |  | 34794 |
| 34843 | return NULL; |  | 34795 | return NULL;
| 34844 | } |  | 34796 | }
| 34845 |  |  | 34797 |
| 34846 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_setDownsamplingThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34798 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_setDownsamplingThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 34847 | { |  | 34799 | {
| 34848 | using namespace cv::barcode; |  | 34800 | using namespace cv::barcode;
| 34849 |  |  | 34801 |
| 34850 |  |  | 34802 |
| 34851 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34803 | cv::barcode::BarcodeDetector * self1 = 0;
| 34852 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34804 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34853 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34805 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34854 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34806 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34855 | PyObject* pyobj_thresh = NULL; |  | 34807 | PyObject* pyobj_thresh = NULL;
| 34856 | double thresh=0; |  | 34808 | double thresh=0;
| 34857 | BarcodeDetector retval; |  | 34809 | BarcodeDetector retval;
| 34858 |  |  | 34810 |
| 34859 | const char* keywords[] = { "thresh", NULL }; |  | 34811 | const char* keywords[] = { "thresh", NULL };
| 34860 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:barcode_BarcodeDetector.setDownsamplingThreshold", (char**)keywords, &pyobj_thresh) && |  | 34812 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:barcode_BarcodeDetector.setDownsamplingThreshold", (char**)keywords, &pyobj_thresh) &&
| 34861 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) ) |  | 34813 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) )
| 34862 | { |  | 34814 | {
| 34863 | ERRWRAP2(retval = _self_->setDownsamplingThreshold(thresh)); |  | 34815 | ERRWRAP2(retval = _self_->setDownsamplingThreshold(thresh));
| 34864 | return pyopencv_from(retval); |  | 34816 | return pyopencv_from(retval);
| 34865 | } |  | 34817 | }
| 34866 |  |  | 34818 |
| 34867 | return NULL; |  | 34819 | return NULL;
| 34868 | } |  | 34820 | }
| 34869 |  |  | 34821 |
| 34870 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_setGradientThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34822 | static PyObject* pyopencv_cv_barcode_barcode_BarcodeDetector_setGradientThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 34871 | { |  | 34823 | {
| 34872 | using namespace cv::barcode; |  | 34824 | using namespace cv::barcode;
| 34873 |  |  | 34825 |
| 34874 |  |  | 34826 |
| 34875 | cv::barcode::BarcodeDetector * self1 = 0; |  | 34827 | cv::barcode::BarcodeDetector * self1 = 0;
| 34876 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1)) |  | 34828 | if (!pyopencv_barcode_BarcodeDetector_getp(self, self1))
| 34877 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)"); |  | 34829 | return failmsgp("Incorrect type of self (must be 'barcode_BarcodeDetector' or its derivative)");
| 34878 | cv::barcode::BarcodeDetector* _self_ = (self1); |  | 34830 | cv::barcode::BarcodeDetector* _self_ = (self1);
| 34879 | PyObject* pyobj_thresh = NULL; |  | 34831 | PyObject* pyobj_thresh = NULL;
| 34880 | double thresh=0; |  | 34832 | double thresh=0;
| 34881 | BarcodeDetector retval; |  | 34833 | BarcodeDetector retval;
| 34882 |  |  | 34834 |
| 34883 | const char* keywords[] = { "thresh", NULL }; |  | 34835 | const char* keywords[] = { "thresh", NULL };
| 34884 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:barcode_BarcodeDetector.setGradientThreshold", (char**)keywords, &pyobj_thresh) && |  | 34836 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:barcode_BarcodeDetector.setGradientThreshold", (char**)keywords, &pyobj_thresh) &&
| 34885 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) ) |  | 34837 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) )
| 34886 | { |  | 34838 | {
| 34887 | ERRWRAP2(retval = _self_->setGradientThreshold(thresh)); |  | 34839 | ERRWRAP2(retval = _self_->setGradientThreshold(thresh));
| 34888 | return pyopencv_from(retval); |  | 34840 | return pyopencv_from(retval);
| 34889 | } |  | 34841 | }
| 34890 |  |  | 34842 |
| 34891 | return NULL; |  | 34843 | return NULL;
| 34892 | } |  | 34844 | }
| 34893 |  |  | 34845 |
| 34894 |  |  | 34846 |
| 34895 |  |  | 34847 |
| 34896 | // Tables (barcode_BarcodeDetector) |  | 34848 | // Tables (barcode_BarcodeDetector)
| 34897 |  |  | 34849 |
| 34898 | static PyGetSetDef pyopencv_barcode_BarcodeDetector_getseters[] = |  | 34850 | static PyGetSetDef pyopencv_barcode_BarcodeDetector_getseters[] =
| 34899 | { |  | 34851 | {
| 34900 | {NULL} /* Sentinel */ |  | 34852 | {NULL} /* Sentinel */
| 34901 | }; |  | 34853 | };
| 34902 |  |  | 34854 |
| 34903 | static PyMethodDef pyopencv_barcode_BarcodeDetector_methods[] = |  | 34855 | static PyMethodDef pyopencv_barcode_BarcodeDetector_methods[] =
| 34904 | { |  | 34856 | {
| 34905 | {"decodeWithType", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_decodeWithType, 0), "decodeWithType(img, points) -> retval, decoded_info, decoded_type\n. @brief Decodes barcode in image once it's found by the detect() method.\n. *\n. * @param img grayscale or color (BGR) image containing bar code.\n. * @param points vector of rotated rectangle vertices found by detect() method (or some other algorithm).\n. * For N detected barcodes, the dimensions of this array should be [N][4].\n. * Order of four points in vector<Point2f> is bottomLeft, topLeft, topRight, bottomRight.\n. * @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.\n. * @param decoded_type vector strings, specifies the type of these barcodes\n. * @return true if at least one valid barcode have been found"}, |  | 34857 | {"decodeWithType", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_decodeWithType, 0), "decodeWithType(img, points) -> retval, decoded_info, decoded_type\n. @brief Decodes barcode in image once it's found by the detect() method.\n. *\n. * @param img grayscale or color (BGR) image containing bar code.\n. * @param points vector of rotated rectangle vertices found by detect() method (or some other algorithm).\n. * For N detected barcodes, the dimensions of this array should be [N][4].\n. * Order of four points in vector<Point2f> is bottomLeft, topLeft, topRight, bottomRight.\n. * @param decoded_info UTF8-encoded output vector of string or empty vector of string if the codes cannot be decoded.\n. * @param decoded_type vector strings, specifies the type of these barcodes\n. * @return true if at least one valid barcode have been found"},
| 34906 | {"detectAndDecodeWithType", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_detectAndDecodeWithType, 0), "detectAndDecodeWithType(img[, points]) -> retval, decoded_info, decoded_type, points\n. @brief Both detects and decodes barcode\n. \n. * @param img grayscale or color (BGR) image containing barcode.\n. * @param decoded_info UTF8-encoded output vector of string(s) or empty vector of string if the codes cannot be decoded.\n. * @param decoded_type vector of strings, specifies the type of these barcodes\n. * @param points optional output vector of vertices of the found barcode rectangle. Will be empty if not found.\n. * @return true if at least one valid barcode have been found"}, |  | 34858 | {"detectAndDecodeWithType", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_detectAndDecodeWithType, 0), "detectAndDecodeWithType(img[, points]) -> retval, decoded_info, decoded_type, points\n. @brief Both detects and decodes barcode\n. \n. * @param img grayscale or color (BGR) image containing barcode.\n. * @param decoded_info UTF8-encoded output vector of string(s) or empty vector of string if the codes cannot be decoded.\n. * @param decoded_type vector of strings, specifies the type of these barcodes\n. * @param points optional output vector of vertices of the found barcode rectangle. Will be empty if not found.\n. * @return true if at least one valid barcode have been found"},
| 34907 | {"getDetectorScales", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_getDetectorScales, 0), "getDetectorScales() -> sizes\n. @brief Returns detector box filter sizes.\n. *\n. * @param sizes output parameter for returning the sizes."}, |  | 34859 | {"getDetectorScales", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_getDetectorScales, 0), "getDetectorScales() -> sizes\n. @brief Returns detector box filter sizes.\n. *\n. * @param sizes output parameter for returning the sizes."},
| 34908 | {"getDownsamplingThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_getDownsamplingThreshold, 0), "getDownsamplingThreshold() -> retval\n. @brief Get detector downsampling threshold.\n. *\n. * @return detector downsampling threshold"}, |  | 34860 | {"getDownsamplingThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_getDownsamplingThreshold, 0), "getDownsamplingThreshold() -> retval\n. @brief Get detector downsampling threshold.\n. *\n. * @return detector downsampling threshold"},
| 34909 | {"getGradientThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_getGradientThreshold, 0), "getGradientThreshold() -> retval\n. @brief Get detector gradient magnitude threshold.\n. *\n. * @return detector gradient magnitude threshold."}, |  | 34861 | {"getGradientThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_getGradientThreshold, 0), "getGradientThreshold() -> retval\n. @brief Get detector gradient magnitude threshold.\n. *\n. * @return detector gradient magnitude threshold."},
| 34910 | {"setDetectorScales", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_setDetectorScales, 0), "setDetectorScales(sizes) -> retval\n. @brief Set detector box filter sizes.\n. *\n. * Adjusts the value and the number of box filters used in the detect step.\n. * The filter sizes directly correlate with the expected line widths for a barcode. Corresponds to expected barcode distance.\n. * If the downsampling limit is increased, filter sizes need to be adjusted in an inversely proportional way.\n. * @param sizes box filter sizes, relative to minimum dimension of the image (default [0.01, 0.03, 0.06, 0.08])"}, |  | 34862 | {"setDetectorScales", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_setDetectorScales, 0), "setDetectorScales(sizes) -> retval\n. @brief Set detector box filter sizes.\n. *\n. * Adjusts the value and the number of box filters used in the detect step.\n. * The filter sizes directly correlate with the expected line widths for a barcode. Corresponds to expected barcode distance.\n. * If the downsampling limit is increased, filter sizes need to be adjusted in an inversely proportional way.\n. * @param sizes box filter sizes, relative to minimum dimension of the image (default [0.01, 0.03, 0.06, 0.08])"},
| 34911 | {"setDownsamplingThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_setDownsamplingThreshold, 0), "setDownsamplingThreshold(thresh) -> retval\n. @brief Set detector downsampling threshold.\n. *\n. * By default, the detect method resizes the input image to this limit if the smallest image size is is greater than the threshold.\n. * Increasing this value can improve detection accuracy and the number of results at the expense of performance.\n. * Correlates with detector scales. Setting this to a large value will disable downsampling.\n. * @param thresh downsampling limit to apply (default 512)\n. * @see setDetectorScales"}, |  | 34863 | {"setDownsamplingThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_setDownsamplingThreshold, 0), "setDownsamplingThreshold(thresh) -> retval\n. @brief Set detector downsampling threshold.\n. *\n. * By default, the detect method resizes the input image to this limit if the smallest image size is is greater than the threshold.\n. * Increasing this value can improve detection accuracy and the number of results at the expense of performance.\n. * Correlates with detector scales. Setting this to a large value will disable downsampling.\n. * @param thresh downsampling limit to apply (default 512)\n. * @see setDetectorScales"},
| 34912 | {"setGradientThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_setGradientThreshold, 0), "setGradientThreshold(thresh) -> retval\n. @brief Set detector gradient magnitude threshold.\n. *\n. * Sets the coherence threshold for detected bounding boxes.\n. * Increasing this value will generate a closer fitted bounding box width and can reduce false-positives.\n. * Values between 16 and 1024 generally work, while too high of a value will remove valid detections.\n. * @param thresh gradient magnitude threshold (default 64)."}, |  | 34864 | {"setGradientThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_barcode_barcode_BarcodeDetector_setGradientThreshold, 0), "setGradientThreshold(thresh) -> retval\n. @brief Set detector gradient magnitude threshold.\n. *\n. * Sets the coherence threshold for detected bounding boxes.\n. * Increasing this value will generate a closer fitted bounding box width and can reduce false-positives.\n. * Values between 16 and 1024 generally work, while too high of a value will remove valid detections.\n. * @param thresh gradient magnitude threshold (default 64)."},
| 34913 |  |  | 34865 |
| 34914 | {NULL, NULL} |  | 34866 | {NULL, NULL}
| 34915 | }; |  | 34867 | };
| 34916 |  |  | 34868 |
| 34917 | // Converter (barcode_BarcodeDetector) |  | 34869 | // Converter (barcode_BarcodeDetector)
| 34918 |  |  | 34870 |
| 34919 | template<> |  | 34871 | template<>
| 34920 | struct PyOpenCV_Converter< cv::barcode::BarcodeDetector > |  | 34872 | struct PyOpenCV_Converter< cv::barcode::BarcodeDetector >
| 34921 | { |  | 34873 | {
| 34922 | static PyObject* from(const cv::barcode::BarcodeDetector& r) |  | 34874 | static PyObject* from(const cv::barcode::BarcodeDetector& r)
| 34923 | { |  | 34875 | {
| 34924 | return pyopencv_barcode_BarcodeDetector_Instance(r); |  | 34876 | return pyopencv_barcode_BarcodeDetector_Instance(r);
| 34925 | } |  | 34877 | }
| 34926 | static bool to(PyObject* src, cv::barcode::BarcodeDetector& dst, const ArgInfo& info) |  | 34878 | static bool to(PyObject* src, cv::barcode::BarcodeDetector& dst, const ArgInfo& info)
| 34927 | { |  | 34879 | {
| 34928 | if(!src || src == Py_None) |  | 34880 | if(!src || src == Py_None)
| 34929 | return true; |  | 34881 | return true;
| 34930 | cv::barcode::BarcodeDetector * dst_; |  | 34882 | cv::barcode::BarcodeDetector * dst_;
| 34931 | if (pyopencv_barcode_BarcodeDetector_getp(src, dst_)) |  | 34883 | if (pyopencv_barcode_BarcodeDetector_getp(src, dst_))
| 34932 | { |  | 34884 | {
| 34933 | dst = *dst_; |  | 34885 | dst = *dst_;
| 34934 | return true; |  | 34886 | return true;
| 34935 | } |  | 34887 | }
| 34936 |  |  | 34888 |
| 34937 | failmsg("Expected cv::barcode::BarcodeDetector for argument '%s'", info.name); |  | 34889 | failmsg("Expected cv::barcode::BarcodeDetector for argument '%s'", info.name);
| 34938 | return false; |  | 34890 | return false;
| 34939 | } |  | 34891 | }
| 34940 | }; |  | 34892 | };
| 34941 |  |  | 34893 |
| 34942 | //================================================================================ |  | 34894 | //================================================================================
| 34943 | // bgsegm_BackgroundSubtractorCNT (Generic) |  | 34895 | // bgsegm_BackgroundSubtractorCNT (Generic)
| 34944 | //================================================================================ |  | 34896 | //================================================================================
| 34945 |  |  | 34897 |
| 34946 | // GetSet (bgsegm_BackgroundSubtractorCNT) |  | 34898 | // GetSet (bgsegm_BackgroundSubtractorCNT)
| 34947 |  |  | 34899 |
| 34948 |  |  | 34900 |
| 34949 |  |  | 34901 |
| 34950 | // Methods (bgsegm_BackgroundSubtractorCNT) |  | 34902 | // Methods (bgsegm_BackgroundSubtractorCNT)
| 34951 |  |  | 34903 |
| 34952 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34904 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 34953 | { |  | 34905 | {
| 34954 | using namespace cv::bgsegm; |  | 34906 | using namespace cv::bgsegm;
| 34955 |  |  | 34907 |
| 34956 |  |  | 34908 |
| 34957 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 34909 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 34958 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 34910 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 34959 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 34911 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 34960 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 34912 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 34961 | pyPrepareArgumentConversionErrorsStorage(2); |  | 34913 | pyPrepareArgumentConversionErrorsStorage(2);
| 34962 |  |  | 34914 |
| 34963 | { |  | 34915 | {
| 34964 | PyObject* pyobj_image = NULL; |  | 34916 | PyObject* pyobj_image = NULL;
| 34965 | Mat image; |  | 34917 | Mat image;
| 34966 | PyObject* pyobj_fgmask = NULL; |  | 34918 | PyObject* pyobj_fgmask = NULL;
| 34967 | Mat fgmask; |  | 34919 | Mat fgmask;
| 34968 | PyObject* pyobj_learningRate = NULL; |  | 34920 | PyObject* pyobj_learningRate = NULL;
| 34969 | double learningRate=-1; |  | 34921 | double learningRate=-1;
| 34970 |  |  | 34922 |
| 34971 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 34923 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 34972 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorCNT.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 34924 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorCNT.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 34973 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 34925 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 34974 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 34926 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 34975 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 34927 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 34976 | { |  | 34928 | {
| 34977 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 34929 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 34978 | return pyopencv_from(fgmask); |  | 34930 | return pyopencv_from(fgmask);
| 34979 | } |  | 34931 | }
| 34980 |  |  | 34932 |
| 34981 |  |  | 34933 |
| 34982 | pyPopulateArgumentConversionErrors(); |  | 34934 | pyPopulateArgumentConversionErrors();
| 34983 | } |  | 34935 | }
| 34984 |  |  | 34936 |
| 34985 |  |  | 34937 |
| 34986 | { |  | 34938 | {
| 34987 | PyObject* pyobj_image = NULL; |  | 34939 | PyObject* pyobj_image = NULL;
| 34988 | UMat image; |  | 34940 | UMat image;
| 34989 | PyObject* pyobj_fgmask = NULL; |  | 34941 | PyObject* pyobj_fgmask = NULL;
| 34990 | UMat fgmask; |  | 34942 | UMat fgmask;
| 34991 | PyObject* pyobj_learningRate = NULL; |  | 34943 | PyObject* pyobj_learningRate = NULL;
| 34992 | double learningRate=-1; |  | 34944 | double learningRate=-1;
| 34993 |  |  | 34945 |
| 34994 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 34946 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 34995 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorCNT.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 34947 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorCNT.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 34996 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 34948 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 34997 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 34949 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 34998 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 34950 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 34999 | { |  | 34951 | {
| 35000 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 34952 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 35001 | return pyopencv_from(fgmask); |  | 34953 | return pyopencv_from(fgmask);
| 35002 | } |  | 34954 | }
| 35003 |  |  | 34955 |
| 35004 |  |  | 34956 |
| 35005 | pyPopulateArgumentConversionErrors(); |  | 34957 | pyPopulateArgumentConversionErrors();
| 35006 | } |  | 34958 | }
| 35007 | pyRaiseCVOverloadException("apply"); |  | 34959 | pyRaiseCVOverloadException("apply");
| 35008 |  |  | 34960 |
| 35009 | return NULL; |  | 34961 | return NULL;
| 35010 | } |  | 34962 | }
| 35011 |  |  | 34963 |
| 35012 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 34964 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 35013 | { |  | 34965 | {
| 35014 | using namespace cv::bgsegm; |  | 34966 | using namespace cv::bgsegm;
| 35015 |  |  | 34967 |
| 35016 |  |  | 34968 |
| 35017 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 34969 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35018 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 34970 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35019 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 34971 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35020 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 34972 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35021 | pyPrepareArgumentConversionErrorsStorage(2); |  | 34973 | pyPrepareArgumentConversionErrorsStorage(2);
| 35022 |  |  | 34974 |
| 35023 | { |  | 34975 | {
| 35024 | PyObject* pyobj_backgroundImage = NULL; |  | 34976 | PyObject* pyobj_backgroundImage = NULL;
| 35025 | Mat backgroundImage; |  | 34977 | Mat backgroundImage;
| 35026 |  |  | 34978 |
| 35027 | const char* keywords[] = { "backgroundImage", NULL }; |  | 34979 | const char* keywords[] = { "backgroundImage", NULL };
| 35028 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorCNT.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 34980 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorCNT.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 35029 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 34981 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 35030 | { |  | 34982 | {
| 35031 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 34983 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 35032 | return pyopencv_from(backgroundImage); |  | 34984 | return pyopencv_from(backgroundImage);
| 35033 | } |  | 34985 | }
| 35034 |  |  | 34986 |
| 35035 |  |  | 34987 |
| 35036 | pyPopulateArgumentConversionErrors(); |  | 34988 | pyPopulateArgumentConversionErrors();
| 35037 | } |  | 34989 | }
| 35038 |  |  | 34990 |
| 35039 |  |  | 34991 |
| 35040 | { |  | 34992 | {
| 35041 | PyObject* pyobj_backgroundImage = NULL; |  | 34993 | PyObject* pyobj_backgroundImage = NULL;
| 35042 | UMat backgroundImage; |  | 34994 | UMat backgroundImage;
| 35043 |  |  | 34995 |
| 35044 | const char* keywords[] = { "backgroundImage", NULL }; |  | 34996 | const char* keywords[] = { "backgroundImage", NULL };
| 35045 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorCNT.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 34997 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorCNT.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 35046 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 34998 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 35047 | { |  | 34999 | {
| 35048 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 35000 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 35049 | return pyopencv_from(backgroundImage); |  | 35001 | return pyopencv_from(backgroundImage);
| 35050 | } |  | 35002 | }
| 35051 |  |  | 35003 |
| 35052 |  |  | 35004 |
| 35053 | pyPopulateArgumentConversionErrors(); |  | 35005 | pyPopulateArgumentConversionErrors();
| 35054 | } |  | 35006 | }
| 35055 | pyRaiseCVOverloadException("getBackgroundImage"); |  | 35007 | pyRaiseCVOverloadException("getBackgroundImage");
| 35056 |  |  | 35008 |
| 35057 | return NULL; |  | 35009 | return NULL;
| 35058 | } |  | 35010 | }
| 35059 |  |  | 35011 |
| 35060 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getIsParallel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35012 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getIsParallel(PyObject* self, PyObject* py_args, PyObject* kw)
| 35061 | { |  | 35013 | {
| 35062 | using namespace cv::bgsegm; |  | 35014 | using namespace cv::bgsegm;
| 35063 |  |  | 35015 |
| 35064 |  |  | 35016 |
| 35065 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35017 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35066 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35018 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35067 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35019 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35068 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35020 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35069 | bool retval; |  | 35021 | bool retval;
| 35070 |  |  | 35022 |
| 35071 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35023 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35072 | { |  | 35024 | {
| 35073 | ERRWRAP2(retval = _self_->getIsParallel()); |  | 35025 | ERRWRAP2(retval = _self_->getIsParallel());
| 35074 | return pyopencv_from(retval); |  | 35026 | return pyopencv_from(retval);
| 35075 | } |  | 35027 | }
| 35076 |  |  | 35028 |
| 35077 | return NULL; |  | 35029 | return NULL;
| 35078 | } |  | 35030 | }
| 35079 |  |  | 35031 |
| 35080 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMaxPixelStability(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35032 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMaxPixelStability(PyObject* self, PyObject* py_args, PyObject* kw)
| 35081 | { |  | 35033 | {
| 35082 | using namespace cv::bgsegm; |  | 35034 | using namespace cv::bgsegm;
| 35083 |  |  | 35035 |
| 35084 |  |  | 35036 |
| 35085 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35037 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35086 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35038 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35087 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35039 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35088 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35040 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35089 | int retval; |  | 35041 | int retval;
| 35090 |  |  | 35042 |
| 35091 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35043 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35092 | { |  | 35044 | {
| 35093 | ERRWRAP2(retval = _self_->getMaxPixelStability()); |  | 35045 | ERRWRAP2(retval = _self_->getMaxPixelStability());
| 35094 | return pyopencv_from(retval); |  | 35046 | return pyopencv_from(retval);
| 35095 | } |  | 35047 | }
| 35096 |  |  | 35048 |
| 35097 | return NULL; |  | 35049 | return NULL;
| 35098 | } |  | 35050 | }
| 35099 |  |  | 35051 |
| 35100 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMinPixelStability(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35052 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMinPixelStability(PyObject* self, PyObject* py_args, PyObject* kw)
| 35101 | { |  | 35053 | {
| 35102 | using namespace cv::bgsegm; |  | 35054 | using namespace cv::bgsegm;
| 35103 |  |  | 35055 |
| 35104 |  |  | 35056 |
| 35105 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35057 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35106 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35058 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35107 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35059 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35108 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35060 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35109 | int retval; |  | 35061 | int retval;
| 35110 |  |  | 35062 |
| 35111 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35063 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35112 | { |  | 35064 | {
| 35113 | ERRWRAP2(retval = _self_->getMinPixelStability()); |  | 35065 | ERRWRAP2(retval = _self_->getMinPixelStability());
| 35114 | return pyopencv_from(retval); |  | 35066 | return pyopencv_from(retval);
| 35115 | } |  | 35067 | }
| 35116 |  |  | 35068 |
| 35117 | return NULL; |  | 35069 | return NULL;
| 35118 | } |  | 35070 | }
| 35119 |  |  | 35071 |
| 35120 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getUseHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35072 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getUseHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 35121 | { |  | 35073 | {
| 35122 | using namespace cv::bgsegm; |  | 35074 | using namespace cv::bgsegm;
| 35123 |  |  | 35075 |
| 35124 |  |  | 35076 |
| 35125 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35077 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35126 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35078 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35127 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35079 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35128 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35080 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35129 | bool retval; |  | 35081 | bool retval;
| 35130 |  |  | 35082 |
| 35131 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35083 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35132 | { |  | 35084 | {
| 35133 | ERRWRAP2(retval = _self_->getUseHistory()); |  | 35085 | ERRWRAP2(retval = _self_->getUseHistory());
| 35134 | return pyopencv_from(retval); |  | 35086 | return pyopencv_from(retval);
| 35135 | } |  | 35087 | }
| 35136 |  |  | 35088 |
| 35137 | return NULL; |  | 35089 | return NULL;
| 35138 | } |  | 35090 | }
| 35139 |  |  | 35091 |
| 35140 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setIsParallel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35092 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setIsParallel(PyObject* self, PyObject* py_args, PyObject* kw)
| 35141 | { |  | 35093 | {
| 35142 | using namespace cv::bgsegm; |  | 35094 | using namespace cv::bgsegm;
| 35143 |  |  | 35095 |
| 35144 |  |  | 35096 |
| 35145 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35097 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35146 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35098 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35147 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35099 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35148 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35100 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35149 | PyObject* pyobj_value = NULL; |  | 35101 | PyObject* pyobj_value = NULL;
| 35150 | bool value=0; |  | 35102 | bool value=0;
| 35151 |  |  | 35103 |
| 35152 | const char* keywords[] = { "value", NULL }; |  | 35104 | const char* keywords[] = { "value", NULL };
| 35153 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setIsParallel", (char**)keywords, &pyobj_value) && |  | 35105 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setIsParallel", (char**)keywords, &pyobj_value) &&
| 35154 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 35106 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 35155 | { |  | 35107 | {
| 35156 | ERRWRAP2(_self_->setIsParallel(value)); |  | 35108 | ERRWRAP2(_self_->setIsParallel(value));
| 35157 | Py_RETURN_NONE; |  | 35109 | Py_RETURN_NONE;
| 35158 | } |  | 35110 | }
| 35159 |  |  | 35111 |
| 35160 | return NULL; |  | 35112 | return NULL;
| 35161 | } |  | 35113 | }
| 35162 |  |  | 35114 |
| 35163 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMaxPixelStability(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35115 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMaxPixelStability(PyObject* self, PyObject* py_args, PyObject* kw)
| 35164 | { |  | 35116 | {
| 35165 | using namespace cv::bgsegm; |  | 35117 | using namespace cv::bgsegm;
| 35166 |  |  | 35118 |
| 35167 |  |  | 35119 |
| 35168 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35120 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35169 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35121 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35170 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35122 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35171 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35123 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35172 | PyObject* pyobj_value = NULL; |  | 35124 | PyObject* pyobj_value = NULL;
| 35173 | int value=0; |  | 35125 | int value=0;
| 35174 |  |  | 35126 |
| 35175 | const char* keywords[] = { "value", NULL }; |  | 35127 | const char* keywords[] = { "value", NULL };
| 35176 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setMaxPixelStability", (char**)keywords, &pyobj_value) && |  | 35128 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setMaxPixelStability", (char**)keywords, &pyobj_value) &&
| 35177 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 35129 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 35178 | { |  | 35130 | {
| 35179 | ERRWRAP2(_self_->setMaxPixelStability(value)); |  | 35131 | ERRWRAP2(_self_->setMaxPixelStability(value));
| 35180 | Py_RETURN_NONE; |  | 35132 | Py_RETURN_NONE;
| 35181 | } |  | 35133 | }
| 35182 |  |  | 35134 |
| 35183 | return NULL; |  | 35135 | return NULL;
| 35184 | } |  | 35136 | }
| 35185 |  |  | 35137 |
| 35186 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMinPixelStability(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35138 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMinPixelStability(PyObject* self, PyObject* py_args, PyObject* kw)
| 35187 | { |  | 35139 | {
| 35188 | using namespace cv::bgsegm; |  | 35140 | using namespace cv::bgsegm;
| 35189 |  |  | 35141 |
| 35190 |  |  | 35142 |
| 35191 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35143 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35192 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35144 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35193 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35145 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35194 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35146 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35195 | PyObject* pyobj_value = NULL; |  | 35147 | PyObject* pyobj_value = NULL;
| 35196 | int value=0; |  | 35148 | int value=0;
| 35197 |  |  | 35149 |
| 35198 | const char* keywords[] = { "value", NULL }; |  | 35150 | const char* keywords[] = { "value", NULL };
| 35199 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setMinPixelStability", (char**)keywords, &pyobj_value) && |  | 35151 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setMinPixelStability", (char**)keywords, &pyobj_value) &&
| 35200 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 35152 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 35201 | { |  | 35153 | {
| 35202 | ERRWRAP2(_self_->setMinPixelStability(value)); |  | 35154 | ERRWRAP2(_self_->setMinPixelStability(value));
| 35203 | Py_RETURN_NONE; |  | 35155 | Py_RETURN_NONE;
| 35204 | } |  | 35156 | }
| 35205 |  |  | 35157 |
| 35206 | return NULL; |  | 35158 | return NULL;
| 35207 | } |  | 35159 | }
| 35208 |  |  | 35160 |
| 35209 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setUseHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35161 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setUseHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 35210 | { |  | 35162 | {
| 35211 | using namespace cv::bgsegm; |  | 35163 | using namespace cv::bgsegm;
| 35212 |  |  | 35164 |
| 35213 |  |  | 35165 |
| 35214 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0; |  | 35166 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * self1 = 0;
| 35215 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1)) |  | 35167 | if (!pyopencv_bgsegm_BackgroundSubtractorCNT_getp(self, self1))
| 35216 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)"); |  | 35168 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorCNT' or its derivative)");
| 35217 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1); |  | 35169 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> _self_ = *(self1);
| 35218 | PyObject* pyobj_value = NULL; |  | 35170 | PyObject* pyobj_value = NULL;
| 35219 | bool value=0; |  | 35171 | bool value=0;
| 35220 |  |  | 35172 |
| 35221 | const char* keywords[] = { "value", NULL }; |  | 35173 | const char* keywords[] = { "value", NULL };
| 35222 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setUseHistory", (char**)keywords, &pyobj_value) && |  | 35174 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorCNT.setUseHistory", (char**)keywords, &pyobj_value) &&
| 35223 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 35175 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 35224 | { |  | 35176 | {
| 35225 | ERRWRAP2(_self_->setUseHistory(value)); |  | 35177 | ERRWRAP2(_self_->setUseHistory(value));
| 35226 | Py_RETURN_NONE; |  | 35178 | Py_RETURN_NONE;
| 35227 | } |  | 35179 | }
| 35228 |  |  | 35180 |
| 35229 | return NULL; |  | 35181 | return NULL;
| 35230 | } |  | 35182 | }
| 35231 |  |  | 35183 |
| 35232 |  |  | 35184 |
| 35233 |  |  | 35185 |
| 35234 | // Tables (bgsegm_BackgroundSubtractorCNT) |  | 35186 | // Tables (bgsegm_BackgroundSubtractorCNT)
| 35235 |  |  | 35187 |
| 35236 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorCNT_getseters[] = |  | 35188 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorCNT_getseters[] =
| 35237 | { |  | 35189 | {
| 35238 | {NULL} /* Sentinel */ |  | 35190 | {NULL} /* Sentinel */
| 35239 | }; |  | 35191 | };
| 35240 |  |  | 35192 |
| 35241 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorCNT_methods[] = |  | 35193 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorCNT_methods[] =
| 35242 | { |  | 35194 | {
| 35243 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n."}, |  | 35195 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n."},
| 35244 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."}, |  | 35196 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."},
| 35245 | {"getIsParallel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getIsParallel, 0), "getIsParallel() -> retval\n. @brief Returns if we're parallelizing the algorithm."}, |  | 35197 | {"getIsParallel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getIsParallel, 0), "getIsParallel() -> retval\n. @brief Returns if we're parallelizing the algorithm."},
| 35246 | {"getMaxPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMaxPixelStability, 0), "getMaxPixelStability() -> retval\n. @brief Returns maximum allowed credit for a pixel in history."}, |  | 35198 | {"getMaxPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMaxPixelStability, 0), "getMaxPixelStability() -> retval\n. @brief Returns maximum allowed credit for a pixel in history."},
| 35247 | {"getMinPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMinPixelStability, 0), "getMinPixelStability() -> retval\n. @brief Returns number of frames with same pixel color to consider stable."}, |  | 35199 | {"getMinPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getMinPixelStability, 0), "getMinPixelStability() -> retval\n. @brief Returns number of frames with same pixel color to consider stable."},
| 35248 | {"getUseHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getUseHistory, 0), "getUseHistory() -> retval\n. @brief Returns if we're giving a pixel credit for being stable for a long time."}, |  | 35200 | {"getUseHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_getUseHistory, 0), "getUseHistory() -> retval\n. @brief Returns if we're giving a pixel credit for being stable for a long time."},
| 35249 | {"setIsParallel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setIsParallel, 0), "setIsParallel(value) -> None\n. @brief Sets if we're parallelizing the algorithm."}, |  | 35201 | {"setIsParallel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setIsParallel, 0), "setIsParallel(value) -> None\n. @brief Sets if we're parallelizing the algorithm."},
| 35250 | {"setMaxPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMaxPixelStability, 0), "setMaxPixelStability(value) -> None\n. @brief Sets the maximum allowed credit for a pixel in history."}, |  | 35202 | {"setMaxPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMaxPixelStability, 0), "setMaxPixelStability(value) -> None\n. @brief Sets the maximum allowed credit for a pixel in history."},
| 35251 | {"setMinPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMinPixelStability, 0), "setMinPixelStability(value) -> None\n. @brief Sets the number of frames with same pixel color to consider stable."}, |  | 35203 | {"setMinPixelStability", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setMinPixelStability, 0), "setMinPixelStability(value) -> None\n. @brief Sets the number of frames with same pixel color to consider stable."},
| 35252 | {"setUseHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setUseHistory, 0), "setUseHistory(value) -> None\n. @brief Sets if we're giving a pixel credit for being stable for a long time."}, |  | 35204 | {"setUseHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorCNT_setUseHistory, 0), "setUseHistory(value) -> None\n. @brief Sets if we're giving a pixel credit for being stable for a long time."},
| 35253 |  |  | 35205 |
| 35254 | {NULL, NULL} |  | 35206 | {NULL, NULL}
| 35255 | }; |  | 35207 | };
| 35256 |  |  | 35208 |
| 35257 | // Converter (bgsegm_BackgroundSubtractorCNT) |  | 35209 | // Converter (bgsegm_BackgroundSubtractorCNT)
| 35258 |  |  | 35210 |
| 35259 | template<> |  | 35211 | template<>
| 35260 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorCNT> > |  | 35212 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorCNT> >
| 35261 | { |  | 35213 | {
| 35262 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorCNT>& r) |  | 35214 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorCNT>& r)
| 35263 | { |  | 35215 | {
| 35264 | return pyopencv_bgsegm_BackgroundSubtractorCNT_Instance(r); |  | 35216 | return pyopencv_bgsegm_BackgroundSubtractorCNT_Instance(r);
| 35265 | } |  | 35217 | }
| 35266 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorCNT>& dst, const ArgInfo& info) |  | 35218 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorCNT>& dst, const ArgInfo& info)
| 35267 | { |  | 35219 | {
| 35268 | if(!src || src == Py_None) |  | 35220 | if(!src || src == Py_None)
| 35269 | return true; |  | 35221 | return true;
| 35270 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * dst_; |  | 35222 | Ptr<cv::bgsegm::BackgroundSubtractorCNT> * dst_;
| 35271 | if (pyopencv_bgsegm_BackgroundSubtractorCNT_getp(src, dst_)) |  | 35223 | if (pyopencv_bgsegm_BackgroundSubtractorCNT_getp(src, dst_))
| 35272 | { |  | 35224 | {
| 35273 | dst = *dst_; |  | 35225 | dst = *dst_;
| 35274 | return true; |  | 35226 | return true;
| 35275 | } |  | 35227 | }
| 35276 |  |  | 35228 |
| 35277 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorCNT> for argument '%s'", info.name); |  | 35229 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorCNT> for argument '%s'", info.name);
| 35278 | return false; |  | 35230 | return false;
| 35279 | } |  | 35231 | }
| 35280 | }; |  | 35232 | };
| 35281 |  |  | 35233 |
| 35282 | //================================================================================ |  | 35234 | //================================================================================
| 35283 | // bgsegm_BackgroundSubtractorGMG (Generic) |  | 35235 | // bgsegm_BackgroundSubtractorGMG (Generic)
| 35284 | //================================================================================ |  | 35236 | //================================================================================
| 35285 |  |  | 35237 |
| 35286 | // GetSet (bgsegm_BackgroundSubtractorGMG) |  | 35238 | // GetSet (bgsegm_BackgroundSubtractorGMG)
| 35287 |  |  | 35239 |
| 35288 |  |  | 35240 |
| 35289 |  |  | 35241 |
| 35290 | // Methods (bgsegm_BackgroundSubtractorGMG) |  | 35242 | // Methods (bgsegm_BackgroundSubtractorGMG)
| 35291 |  |  | 35243 |
| 35292 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35244 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 35293 | { |  | 35245 | {
| 35294 | using namespace cv::bgsegm; |  | 35246 | using namespace cv::bgsegm;
| 35295 |  |  | 35247 |
| 35296 |  |  | 35248 |
| 35297 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35249 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35298 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35250 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35299 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35251 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35300 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35252 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35301 | pyPrepareArgumentConversionErrorsStorage(2); |  | 35253 | pyPrepareArgumentConversionErrorsStorage(2);
| 35302 |  |  | 35254 |
| 35303 | { |  | 35255 | {
| 35304 | PyObject* pyobj_image = NULL; |  | 35256 | PyObject* pyobj_image = NULL;
| 35305 | Mat image; |  | 35257 | Mat image;
| 35306 | PyObject* pyobj_fgmask = NULL; |  | 35258 | PyObject* pyobj_fgmask = NULL;
| 35307 | Mat fgmask; |  | 35259 | Mat fgmask;
| 35308 | PyObject* pyobj_learningRate = NULL; |  | 35260 | PyObject* pyobj_learningRate = NULL;
| 35309 | double learningRate=-1; |  | 35261 | double learningRate=-1;
| 35310 |  |  | 35262 |
| 35311 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 35263 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 35312 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGMG.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 35264 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGMG.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 35313 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 35265 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 35314 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 35266 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 35315 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 35267 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 35316 | { |  | 35268 | {
| 35317 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 35269 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 35318 | return pyopencv_from(fgmask); |  | 35270 | return pyopencv_from(fgmask);
| 35319 | } |  | 35271 | }
| 35320 |  |  | 35272 |
| 35321 |  |  | 35273 |
| 35322 | pyPopulateArgumentConversionErrors(); |  | 35274 | pyPopulateArgumentConversionErrors();
| 35323 | } |  | 35275 | }
| 35324 |  |  | 35276 |
| 35325 |  |  | 35277 |
| 35326 | { |  | 35278 | {
| 35327 | PyObject* pyobj_image = NULL; |  | 35279 | PyObject* pyobj_image = NULL;
| 35328 | UMat image; |  | 35280 | UMat image;
| 35329 | PyObject* pyobj_fgmask = NULL; |  | 35281 | PyObject* pyobj_fgmask = NULL;
| 35330 | UMat fgmask; |  | 35282 | UMat fgmask;
| 35331 | PyObject* pyobj_learningRate = NULL; |  | 35283 | PyObject* pyobj_learningRate = NULL;
| 35332 | double learningRate=-1; |  | 35284 | double learningRate=-1;
| 35333 |  |  | 35285 |
| 35334 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 35286 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 35335 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGMG.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 35287 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGMG.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 35336 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 35288 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 35337 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 35289 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 35338 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 35290 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 35339 | { |  | 35291 | {
| 35340 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 35292 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 35341 | return pyopencv_from(fgmask); |  | 35293 | return pyopencv_from(fgmask);
| 35342 | } |  | 35294 | }
| 35343 |  |  | 35295 |
| 35344 |  |  | 35296 |
| 35345 | pyPopulateArgumentConversionErrors(); |  | 35297 | pyPopulateArgumentConversionErrors();
| 35346 | } |  | 35298 | }
| 35347 | pyRaiseCVOverloadException("apply"); |  | 35299 | pyRaiseCVOverloadException("apply");
| 35348 |  |  | 35300 |
| 35349 | return NULL; |  | 35301 | return NULL;
| 35350 | } |  | 35302 | }
| 35351 |  |  | 35303 |
| 35352 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35304 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 35353 | { |  | 35305 | {
| 35354 | using namespace cv::bgsegm; |  | 35306 | using namespace cv::bgsegm;
| 35355 |  |  | 35307 |
| 35356 |  |  | 35308 |
| 35357 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35309 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35358 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35310 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35359 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35311 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35360 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35312 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35361 | pyPrepareArgumentConversionErrorsStorage(2); |  | 35313 | pyPrepareArgumentConversionErrorsStorage(2);
| 35362 |  |  | 35314 |
| 35363 | { |  | 35315 | {
| 35364 | PyObject* pyobj_backgroundImage = NULL; |  | 35316 | PyObject* pyobj_backgroundImage = NULL;
| 35365 | Mat backgroundImage; |  | 35317 | Mat backgroundImage;
| 35366 |  |  | 35318 |
| 35367 | const char* keywords[] = { "backgroundImage", NULL }; |  | 35319 | const char* keywords[] = { "backgroundImage", NULL };
| 35368 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGMG.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 35320 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGMG.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 35369 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 35321 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 35370 | { |  | 35322 | {
| 35371 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 35323 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 35372 | return pyopencv_from(backgroundImage); |  | 35324 | return pyopencv_from(backgroundImage);
| 35373 | } |  | 35325 | }
| 35374 |  |  | 35326 |
| 35375 |  |  | 35327 |
| 35376 | pyPopulateArgumentConversionErrors(); |  | 35328 | pyPopulateArgumentConversionErrors();
| 35377 | } |  | 35329 | }
| 35378 |  |  | 35330 |
| 35379 |  |  | 35331 |
| 35380 | { |  | 35332 | {
| 35381 | PyObject* pyobj_backgroundImage = NULL; |  | 35333 | PyObject* pyobj_backgroundImage = NULL;
| 35382 | UMat backgroundImage; |  | 35334 | UMat backgroundImage;
| 35383 |  |  | 35335 |
| 35384 | const char* keywords[] = { "backgroundImage", NULL }; |  | 35336 | const char* keywords[] = { "backgroundImage", NULL };
| 35385 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGMG.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 35337 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGMG.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 35386 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 35338 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 35387 | { |  | 35339 | {
| 35388 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 35340 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 35389 | return pyopencv_from(backgroundImage); |  | 35341 | return pyopencv_from(backgroundImage);
| 35390 | } |  | 35342 | }
| 35391 |  |  | 35343 |
| 35392 |  |  | 35344 |
| 35393 | pyPopulateArgumentConversionErrors(); |  | 35345 | pyPopulateArgumentConversionErrors();
| 35394 | } |  | 35346 | }
| 35395 | pyRaiseCVOverloadException("getBackgroundImage"); |  | 35347 | pyRaiseCVOverloadException("getBackgroundImage");
| 35396 |  |  | 35348 |
| 35397 | return NULL; |  | 35349 | return NULL;
| 35398 | } |  | 35350 | }
| 35399 |  |  | 35351 |
| 35400 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundPrior(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35352 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundPrior(PyObject* self, PyObject* py_args, PyObject* kw)
| 35401 | { |  | 35353 | {
| 35402 | using namespace cv::bgsegm; |  | 35354 | using namespace cv::bgsegm;
| 35403 |  |  | 35355 |
| 35404 |  |  | 35356 |
| 35405 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35357 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35406 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35358 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35407 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35359 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35408 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35360 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35409 | double retval; |  | 35361 | double retval;
| 35410 |  |  | 35362 |
| 35411 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35363 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35412 | { |  | 35364 | {
| 35413 | ERRWRAP2(retval = _self_->getBackgroundPrior()); |  | 35365 | ERRWRAP2(retval = _self_->getBackgroundPrior());
| 35414 | return pyopencv_from(retval); |  | 35366 | return pyopencv_from(retval);
| 35415 | } |  | 35367 | }
| 35416 |  |  | 35368 |
| 35417 | return NULL; |  | 35369 | return NULL;
| 35418 | } |  | 35370 | }
| 35419 |  |  | 35371 |
| 35420 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDecisionThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35372 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDecisionThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 35421 | { |  | 35373 | {
| 35422 | using namespace cv::bgsegm; |  | 35374 | using namespace cv::bgsegm;
| 35423 |  |  | 35375 |
| 35424 |  |  | 35376 |
| 35425 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35377 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35426 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35378 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35427 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35379 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35428 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35380 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35429 | double retval; |  | 35381 | double retval;
| 35430 |  |  | 35382 |
| 35431 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35383 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35432 | { |  | 35384 | {
| 35433 | ERRWRAP2(retval = _self_->getDecisionThreshold()); |  | 35385 | ERRWRAP2(retval = _self_->getDecisionThreshold());
| 35434 | return pyopencv_from(retval); |  | 35386 | return pyopencv_from(retval);
| 35435 | } |  | 35387 | }
| 35436 |  |  | 35388 |
| 35437 | return NULL; |  | 35389 | return NULL;
| 35438 | } |  | 35390 | }
| 35439 |  |  | 35391 |
| 35440 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDefaultLearningRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35392 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDefaultLearningRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 35441 | { |  | 35393 | {
| 35442 | using namespace cv::bgsegm; |  | 35394 | using namespace cv::bgsegm;
| 35443 |  |  | 35395 |
| 35444 |  |  | 35396 |
| 35445 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35397 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35446 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35398 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35447 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35399 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35448 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35400 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35449 | double retval; |  | 35401 | double retval;
| 35450 |  |  | 35402 |
| 35451 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35403 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35452 | { |  | 35404 | {
| 35453 | ERRWRAP2(retval = _self_->getDefaultLearningRate()); |  | 35405 | ERRWRAP2(retval = _self_->getDefaultLearningRate());
| 35454 | return pyopencv_from(retval); |  | 35406 | return pyopencv_from(retval);
| 35455 | } |  | 35407 | }
| 35456 |  |  | 35408 |
| 35457 | return NULL; |  | 35409 | return NULL;
| 35458 | } |  | 35410 | }
| 35459 |  |  | 35411 |
| 35460 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35412 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 35461 | { |  | 35413 | {
| 35462 | using namespace cv::bgsegm; |  | 35414 | using namespace cv::bgsegm;
| 35463 |  |  | 35415 |
| 35464 |  |  | 35416 |
| 35465 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35417 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35466 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35418 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35467 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35419 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35468 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35420 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35469 | int retval; |  | 35421 | int retval;
| 35470 |  |  | 35422 |
| 35471 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35423 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35472 | { |  | 35424 | {
| 35473 | ERRWRAP2(retval = _self_->getMaxFeatures()); |  | 35425 | ERRWRAP2(retval = _self_->getMaxFeatures());
| 35474 | return pyopencv_from(retval); |  | 35426 | return pyopencv_from(retval);
| 35475 | } |  | 35427 | }
| 35476 |  |  | 35428 |
| 35477 | return NULL; |  | 35429 | return NULL;
| 35478 | } |  | 35430 | }
| 35479 |  |  | 35431 |
| 35480 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxVal(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35432 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxVal(PyObject* self, PyObject* py_args, PyObject* kw)
| 35481 | { |  | 35433 | {
| 35482 | using namespace cv::bgsegm; |  | 35434 | using namespace cv::bgsegm;
| 35483 |  |  | 35435 |
| 35484 |  |  | 35436 |
| 35485 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35437 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35486 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35438 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35487 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35439 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35488 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35440 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35489 | double retval; |  | 35441 | double retval;
| 35490 |  |  | 35442 |
| 35491 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35443 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35492 | { |  | 35444 | {
| 35493 | ERRWRAP2(retval = _self_->getMaxVal()); |  | 35445 | ERRWRAP2(retval = _self_->getMaxVal());
| 35494 | return pyopencv_from(retval); |  | 35446 | return pyopencv_from(retval);
| 35495 | } |  | 35447 | }
| 35496 |  |  | 35448 |
| 35497 | return NULL; |  | 35449 | return NULL;
| 35498 | } |  | 35450 | }
| 35499 |  |  | 35451 |
| 35500 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMinVal(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35452 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMinVal(PyObject* self, PyObject* py_args, PyObject* kw)
| 35501 | { |  | 35453 | {
| 35502 | using namespace cv::bgsegm; |  | 35454 | using namespace cv::bgsegm;
| 35503 |  |  | 35455 |
| 35504 |  |  | 35456 |
| 35505 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35457 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35506 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35458 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35507 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35459 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35508 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35460 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35509 | double retval; |  | 35461 | double retval;
| 35510 |  |  | 35462 |
| 35511 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35463 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35512 | { |  | 35464 | {
| 35513 | ERRWRAP2(retval = _self_->getMinVal()); |  | 35465 | ERRWRAP2(retval = _self_->getMinVal());
| 35514 | return pyopencv_from(retval); |  | 35466 | return pyopencv_from(retval);
| 35515 | } |  | 35467 | }
| 35516 |  |  | 35468 |
| 35517 | return NULL; |  | 35469 | return NULL;
| 35518 | } |  | 35470 | }
| 35519 |  |  | 35471 |
| 35520 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getNumFrames(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35472 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getNumFrames(PyObject* self, PyObject* py_args, PyObject* kw)
| 35521 | { |  | 35473 | {
| 35522 | using namespace cv::bgsegm; |  | 35474 | using namespace cv::bgsegm;
| 35523 |  |  | 35475 |
| 35524 |  |  | 35476 |
| 35525 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35477 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35526 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35478 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35527 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35479 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35528 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35480 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35529 | int retval; |  | 35481 | int retval;
| 35530 |  |  | 35482 |
| 35531 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35483 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35532 | { |  | 35484 | {
| 35533 | ERRWRAP2(retval = _self_->getNumFrames()); |  | 35485 | ERRWRAP2(retval = _self_->getNumFrames());
| 35534 | return pyopencv_from(retval); |  | 35486 | return pyopencv_from(retval);
| 35535 | } |  | 35487 | }
| 35536 |  |  | 35488 |
| 35537 | return NULL; |  | 35489 | return NULL;
| 35538 | } |  | 35490 | }
| 35539 |  |  | 35491 |
| 35540 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getQuantizationLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35492 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getQuantizationLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 35541 | { |  | 35493 | {
| 35542 | using namespace cv::bgsegm; |  | 35494 | using namespace cv::bgsegm;
| 35543 |  |  | 35495 |
| 35544 |  |  | 35496 |
| 35545 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35497 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35546 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35498 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35547 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35499 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35548 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35500 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35549 | int retval; |  | 35501 | int retval;
| 35550 |  |  | 35502 |
| 35551 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35503 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35552 | { |  | 35504 | {
| 35553 | ERRWRAP2(retval = _self_->getQuantizationLevels()); |  | 35505 | ERRWRAP2(retval = _self_->getQuantizationLevels());
| 35554 | return pyopencv_from(retval); |  | 35506 | return pyopencv_from(retval);
| 35555 | } |  | 35507 | }
| 35556 |  |  | 35508 |
| 35557 | return NULL; |  | 35509 | return NULL;
| 35558 | } |  | 35510 | }
| 35559 |  |  | 35511 |
| 35560 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getSmoothingRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35512 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getSmoothingRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 35561 | { |  | 35513 | {
| 35562 | using namespace cv::bgsegm; |  | 35514 | using namespace cv::bgsegm;
| 35563 |  |  | 35515 |
| 35564 |  |  | 35516 |
| 35565 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35517 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35566 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35518 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35567 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35519 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35568 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35520 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35569 | int retval; |  | 35521 | int retval;
| 35570 |  |  | 35522 |
| 35571 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35523 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35572 | { |  | 35524 | {
| 35573 | ERRWRAP2(retval = _self_->getSmoothingRadius()); |  | 35525 | ERRWRAP2(retval = _self_->getSmoothingRadius());
| 35574 | return pyopencv_from(retval); |  | 35526 | return pyopencv_from(retval);
| 35575 | } |  | 35527 | }
| 35576 |  |  | 35528 |
| 35577 | return NULL; |  | 35529 | return NULL;
| 35578 | } |  | 35530 | }
| 35579 |  |  | 35531 |
| 35580 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getUpdateBackgroundModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35532 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getUpdateBackgroundModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 35581 | { |  | 35533 | {
| 35582 | using namespace cv::bgsegm; |  | 35534 | using namespace cv::bgsegm;
| 35583 |  |  | 35535 |
| 35584 |  |  | 35536 |
| 35585 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35537 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35586 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35538 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35587 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35539 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35588 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35540 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35589 | bool retval; |  | 35541 | bool retval;
| 35590 |  |  | 35542 |
| 35591 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 35543 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 35592 | { |  | 35544 | {
| 35593 | ERRWRAP2(retval = _self_->getUpdateBackgroundModel()); |  | 35545 | ERRWRAP2(retval = _self_->getUpdateBackgroundModel());
| 35594 | return pyopencv_from(retval); |  | 35546 | return pyopencv_from(retval);
| 35595 | } |  | 35547 | }
| 35596 |  |  | 35548 |
| 35597 | return NULL; |  | 35549 | return NULL;
| 35598 | } |  | 35550 | }
| 35599 |  |  | 35551 |
| 35600 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setBackgroundPrior(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35552 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setBackgroundPrior(PyObject* self, PyObject* py_args, PyObject* kw)
| 35601 | { |  | 35553 | {
| 35602 | using namespace cv::bgsegm; |  | 35554 | using namespace cv::bgsegm;
| 35603 |  |  | 35555 |
| 35604 |  |  | 35556 |
| 35605 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35557 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35606 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35558 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35607 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35559 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35608 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35560 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35609 | PyObject* pyobj_bgprior = NULL; |  | 35561 | PyObject* pyobj_bgprior = NULL;
| 35610 | double bgprior=0; |  | 35562 | double bgprior=0;
| 35611 |  |  | 35563 |
| 35612 | const char* keywords[] = { "bgprior", NULL }; |  | 35564 | const char* keywords[] = { "bgprior", NULL };
| 35613 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setBackgroundPrior", (char**)keywords, &pyobj_bgprior) && |  | 35565 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setBackgroundPrior", (char**)keywords, &pyobj_bgprior) &&
| 35614 | pyopencv_to_safe(pyobj_bgprior, bgprior, ArgInfo("bgprior", 0)) ) |  | 35566 | pyopencv_to_safe(pyobj_bgprior, bgprior, ArgInfo("bgprior", 0)) )
| 35615 | { |  | 35567 | {
| 35616 | ERRWRAP2(_self_->setBackgroundPrior(bgprior)); |  | 35568 | ERRWRAP2(_self_->setBackgroundPrior(bgprior));
| 35617 | Py_RETURN_NONE; |  | 35569 | Py_RETURN_NONE;
| 35618 | } |  | 35570 | }
| 35619 |  |  | 35571 |
| 35620 | return NULL; |  | 35572 | return NULL;
| 35621 | } |  | 35573 | }
| 35622 |  |  | 35574 |
| 35623 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDecisionThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35575 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDecisionThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 35624 | { |  | 35576 | {
| 35625 | using namespace cv::bgsegm; |  | 35577 | using namespace cv::bgsegm;
| 35626 |  |  | 35578 |
| 35627 |  |  | 35579 |
| 35628 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35580 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35629 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35581 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35630 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35582 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35631 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35583 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35632 | PyObject* pyobj_thresh = NULL; |  | 35584 | PyObject* pyobj_thresh = NULL;
| 35633 | double thresh=0; |  | 35585 | double thresh=0;
| 35634 |  |  | 35586 |
| 35635 | const char* keywords[] = { "thresh", NULL }; |  | 35587 | const char* keywords[] = { "thresh", NULL };
| 35636 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setDecisionThreshold", (char**)keywords, &pyobj_thresh) && |  | 35588 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setDecisionThreshold", (char**)keywords, &pyobj_thresh) &&
| 35637 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) ) |  | 35589 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) )
| 35638 | { |  | 35590 | {
| 35639 | ERRWRAP2(_self_->setDecisionThreshold(thresh)); |  | 35591 | ERRWRAP2(_self_->setDecisionThreshold(thresh));
| 35640 | Py_RETURN_NONE; |  | 35592 | Py_RETURN_NONE;
| 35641 | } |  | 35593 | }
| 35642 |  |  | 35594 |
| 35643 | return NULL; |  | 35595 | return NULL;
| 35644 | } |  | 35596 | }
| 35645 |  |  | 35597 |
| 35646 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDefaultLearningRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35598 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDefaultLearningRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 35647 | { |  | 35599 | {
| 35648 | using namespace cv::bgsegm; |  | 35600 | using namespace cv::bgsegm;
| 35649 |  |  | 35601 |
| 35650 |  |  | 35602 |
| 35651 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35603 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35652 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35604 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35653 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35605 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35654 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35606 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35655 | PyObject* pyobj_lr = NULL; |  | 35607 | PyObject* pyobj_lr = NULL;
| 35656 | double lr=0; |  | 35608 | double lr=0;
| 35657 |  |  | 35609 |
| 35658 | const char* keywords[] = { "lr", NULL }; |  | 35610 | const char* keywords[] = { "lr", NULL };
| 35659 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setDefaultLearningRate", (char**)keywords, &pyobj_lr) && |  | 35611 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setDefaultLearningRate", (char**)keywords, &pyobj_lr) &&
| 35660 | pyopencv_to_safe(pyobj_lr, lr, ArgInfo("lr", 0)) ) |  | 35612 | pyopencv_to_safe(pyobj_lr, lr, ArgInfo("lr", 0)) )
| 35661 | { |  | 35613 | {
| 35662 | ERRWRAP2(_self_->setDefaultLearningRate(lr)); |  | 35614 | ERRWRAP2(_self_->setDefaultLearningRate(lr));
| 35663 | Py_RETURN_NONE; |  | 35615 | Py_RETURN_NONE;
| 35664 | } |  | 35616 | }
| 35665 |  |  | 35617 |
| 35666 | return NULL; |  | 35618 | return NULL;
| 35667 | } |  | 35619 | }
| 35668 |  |  | 35620 |
| 35669 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35621 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 35670 | { |  | 35622 | {
| 35671 | using namespace cv::bgsegm; |  | 35623 | using namespace cv::bgsegm;
| 35672 |  |  | 35624 |
| 35673 |  |  | 35625 |
| 35674 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35626 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35675 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35627 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35676 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35628 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35677 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35629 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35678 | PyObject* pyobj_maxFeatures = NULL; |  | 35630 | PyObject* pyobj_maxFeatures = NULL;
| 35679 | int maxFeatures=0; |  | 35631 | int maxFeatures=0;
| 35680 |  |  | 35632 |
| 35681 | const char* keywords[] = { "maxFeatures", NULL }; |  | 35633 | const char* keywords[] = { "maxFeatures", NULL };
| 35682 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setMaxFeatures", (char**)keywords, &pyobj_maxFeatures) && |  | 35634 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setMaxFeatures", (char**)keywords, &pyobj_maxFeatures) &&
| 35683 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) ) |  | 35635 | pyopencv_to_safe(pyobj_maxFeatures, maxFeatures, ArgInfo("maxFeatures", 0)) )
| 35684 | { |  | 35636 | {
| 35685 | ERRWRAP2(_self_->setMaxFeatures(maxFeatures)); |  | 35637 | ERRWRAP2(_self_->setMaxFeatures(maxFeatures));
| 35686 | Py_RETURN_NONE; |  | 35638 | Py_RETURN_NONE;
| 35687 | } |  | 35639 | }
| 35688 |  |  | 35640 |
| 35689 | return NULL; |  | 35641 | return NULL;
| 35690 | } |  | 35642 | }
| 35691 |  |  | 35643 |
| 35692 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxVal(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35644 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxVal(PyObject* self, PyObject* py_args, PyObject* kw)
| 35693 | { |  | 35645 | {
| 35694 | using namespace cv::bgsegm; |  | 35646 | using namespace cv::bgsegm;
| 35695 |  |  | 35647 |
| 35696 |  |  | 35648 |
| 35697 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35649 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35698 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35650 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35699 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35651 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35700 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35652 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35701 | PyObject* pyobj_val = NULL; |  | 35653 | PyObject* pyobj_val = NULL;
| 35702 | double val=0; |  | 35654 | double val=0;
| 35703 |  |  | 35655 |
| 35704 | const char* keywords[] = { "val", NULL }; |  | 35656 | const char* keywords[] = { "val", NULL };
| 35705 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setMaxVal", (char**)keywords, &pyobj_val) && |  | 35657 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setMaxVal", (char**)keywords, &pyobj_val) &&
| 35706 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 35658 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 35707 | { |  | 35659 | {
| 35708 | ERRWRAP2(_self_->setMaxVal(val)); |  | 35660 | ERRWRAP2(_self_->setMaxVal(val));
| 35709 | Py_RETURN_NONE; |  | 35661 | Py_RETURN_NONE;
| 35710 | } |  | 35662 | }
| 35711 |  |  | 35663 |
| 35712 | return NULL; |  | 35664 | return NULL;
| 35713 | } |  | 35665 | }
| 35714 |  |  | 35666 |
| 35715 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMinVal(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35667 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMinVal(PyObject* self, PyObject* py_args, PyObject* kw)
| 35716 | { |  | 35668 | {
| 35717 | using namespace cv::bgsegm; |  | 35669 | using namespace cv::bgsegm;
| 35718 |  |  | 35670 |
| 35719 |  |  | 35671 |
| 35720 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35672 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35721 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35673 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35722 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35674 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35723 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35675 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35724 | PyObject* pyobj_val = NULL; |  | 35676 | PyObject* pyobj_val = NULL;
| 35725 | double val=0; |  | 35677 | double val=0;
| 35726 |  |  | 35678 |
| 35727 | const char* keywords[] = { "val", NULL }; |  | 35679 | const char* keywords[] = { "val", NULL };
| 35728 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setMinVal", (char**)keywords, &pyobj_val) && |  | 35680 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setMinVal", (char**)keywords, &pyobj_val) &&
| 35729 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 35681 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 35730 | { |  | 35682 | {
| 35731 | ERRWRAP2(_self_->setMinVal(val)); |  | 35683 | ERRWRAP2(_self_->setMinVal(val));
| 35732 | Py_RETURN_NONE; |  | 35684 | Py_RETURN_NONE;
| 35733 | } |  | 35685 | }
| 35734 |  |  | 35686 |
| 35735 | return NULL; |  | 35687 | return NULL;
| 35736 | } |  | 35688 | }
| 35737 |  |  | 35689 |
| 35738 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setNumFrames(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35690 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setNumFrames(PyObject* self, PyObject* py_args, PyObject* kw)
| 35739 | { |  | 35691 | {
| 35740 | using namespace cv::bgsegm; |  | 35692 | using namespace cv::bgsegm;
| 35741 |  |  | 35693 |
| 35742 |  |  | 35694 |
| 35743 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35695 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35744 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35696 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35745 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35697 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35746 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35698 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35747 | PyObject* pyobj_nframes = NULL; |  | 35699 | PyObject* pyobj_nframes = NULL;
| 35748 | int nframes=0; |  | 35700 | int nframes=0;
| 35749 |  |  | 35701 |
| 35750 | const char* keywords[] = { "nframes", NULL }; |  | 35702 | const char* keywords[] = { "nframes", NULL };
| 35751 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setNumFrames", (char**)keywords, &pyobj_nframes) && |  | 35703 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setNumFrames", (char**)keywords, &pyobj_nframes) &&
| 35752 | pyopencv_to_safe(pyobj_nframes, nframes, ArgInfo("nframes", 0)) ) |  | 35704 | pyopencv_to_safe(pyobj_nframes, nframes, ArgInfo("nframes", 0)) )
| 35753 | { |  | 35705 | {
| 35754 | ERRWRAP2(_self_->setNumFrames(nframes)); |  | 35706 | ERRWRAP2(_self_->setNumFrames(nframes));
| 35755 | Py_RETURN_NONE; |  | 35707 | Py_RETURN_NONE;
| 35756 | } |  | 35708 | }
| 35757 |  |  | 35709 |
| 35758 | return NULL; |  | 35710 | return NULL;
| 35759 | } |  | 35711 | }
| 35760 |  |  | 35712 |
| 35761 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setQuantizationLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35713 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setQuantizationLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 35762 | { |  | 35714 | {
| 35763 | using namespace cv::bgsegm; |  | 35715 | using namespace cv::bgsegm;
| 35764 |  |  | 35716 |
| 35765 |  |  | 35717 |
| 35766 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35718 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35767 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35719 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35768 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35720 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35769 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35721 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35770 | PyObject* pyobj_nlevels = NULL; |  | 35722 | PyObject* pyobj_nlevels = NULL;
| 35771 | int nlevels=0; |  | 35723 | int nlevels=0;
| 35772 |  |  | 35724 |
| 35773 | const char* keywords[] = { "nlevels", NULL }; |  | 35725 | const char* keywords[] = { "nlevels", NULL };
| 35774 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setQuantizationLevels", (char**)keywords, &pyobj_nlevels) && |  | 35726 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setQuantizationLevels", (char**)keywords, &pyobj_nlevels) &&
| 35775 | pyopencv_to_safe(pyobj_nlevels, nlevels, ArgInfo("nlevels", 0)) ) |  | 35727 | pyopencv_to_safe(pyobj_nlevels, nlevels, ArgInfo("nlevels", 0)) )
| 35776 | { |  | 35728 | {
| 35777 | ERRWRAP2(_self_->setQuantizationLevels(nlevels)); |  | 35729 | ERRWRAP2(_self_->setQuantizationLevels(nlevels));
| 35778 | Py_RETURN_NONE; |  | 35730 | Py_RETURN_NONE;
| 35779 | } |  | 35731 | }
| 35780 |  |  | 35732 |
| 35781 | return NULL; |  | 35733 | return NULL;
| 35782 | } |  | 35734 | }
| 35783 |  |  | 35735 |
| 35784 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setSmoothingRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35736 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setSmoothingRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 35785 | { |  | 35737 | {
| 35786 | using namespace cv::bgsegm; |  | 35738 | using namespace cv::bgsegm;
| 35787 |  |  | 35739 |
| 35788 |  |  | 35740 |
| 35789 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35741 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35790 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35742 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35791 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35743 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35792 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35744 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35793 | PyObject* pyobj_radius = NULL; |  | 35745 | PyObject* pyobj_radius = NULL;
| 35794 | int radius=0; |  | 35746 | int radius=0;
| 35795 |  |  | 35747 |
| 35796 | const char* keywords[] = { "radius", NULL }; |  | 35748 | const char* keywords[] = { "radius", NULL };
| 35797 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setSmoothingRadius", (char**)keywords, &pyobj_radius) && |  | 35749 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setSmoothingRadius", (char**)keywords, &pyobj_radius) &&
| 35798 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) ) |  | 35750 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) )
| 35799 | { |  | 35751 | {
| 35800 | ERRWRAP2(_self_->setSmoothingRadius(radius)); |  | 35752 | ERRWRAP2(_self_->setSmoothingRadius(radius));
| 35801 | Py_RETURN_NONE; |  | 35753 | Py_RETURN_NONE;
| 35802 | } |  | 35754 | }
| 35803 |  |  | 35755 |
| 35804 | return NULL; |  | 35756 | return NULL;
| 35805 | } |  | 35757 | }
| 35806 |  |  | 35758 |
| 35807 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setUpdateBackgroundModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35759 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setUpdateBackgroundModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 35808 | { |  | 35760 | {
| 35809 | using namespace cv::bgsegm; |  | 35761 | using namespace cv::bgsegm;
| 35810 |  |  | 35762 |
| 35811 |  |  | 35763 |
| 35812 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0; |  | 35764 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * self1 = 0;
| 35813 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1)) |  | 35765 | if (!pyopencv_bgsegm_BackgroundSubtractorGMG_getp(self, self1))
| 35814 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)"); |  | 35766 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGMG' or its derivative)");
| 35815 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1); |  | 35767 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> _self_ = *(self1);
| 35816 | PyObject* pyobj_update = NULL; |  | 35768 | PyObject* pyobj_update = NULL;
| 35817 | bool update=0; |  | 35769 | bool update=0;
| 35818 |  |  | 35770 |
| 35819 | const char* keywords[] = { "update", NULL }; |  | 35771 | const char* keywords[] = { "update", NULL };
| 35820 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setUpdateBackgroundModel", (char**)keywords, &pyobj_update) && |  | 35772 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorGMG.setUpdateBackgroundModel", (char**)keywords, &pyobj_update) &&
| 35821 | pyopencv_to_safe(pyobj_update, update, ArgInfo("update", 0)) ) |  | 35773 | pyopencv_to_safe(pyobj_update, update, ArgInfo("update", 0)) )
| 35822 | { |  | 35774 | {
| 35823 | ERRWRAP2(_self_->setUpdateBackgroundModel(update)); |  | 35775 | ERRWRAP2(_self_->setUpdateBackgroundModel(update));
| 35824 | Py_RETURN_NONE; |  | 35776 | Py_RETURN_NONE;
| 35825 | } |  | 35777 | }
| 35826 |  |  | 35778 |
| 35827 | return NULL; |  | 35779 | return NULL;
| 35828 | } |  | 35780 | }
| 35829 |  |  | 35781 |
| 35830 |  |  | 35782 |
| 35831 |  |  | 35783 |
| 35832 | // Tables (bgsegm_BackgroundSubtractorGMG) |  | 35784 | // Tables (bgsegm_BackgroundSubtractorGMG)
| 35833 |  |  | 35785 |
| 35834 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorGMG_getseters[] = |  | 35786 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorGMG_getseters[] =
| 35835 | { |  | 35787 | {
| 35836 | {NULL} /* Sentinel */ |  | 35788 | {NULL} /* Sentinel */
| 35837 | }; |  | 35789 | };
| 35838 |  |  | 35790 |
| 35839 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorGMG_methods[] = |  | 35791 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorGMG_methods[] =
| 35840 | { |  | 35792 | {
| 35841 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n. @brief Computes a foreground mask.\n. \n. @param image Next video frame of type CV_8UC(n),CV_8SC(n),CV_16UC(n),CV_16SC(n),CV_32SC(n),CV_32FC(n),CV_64FC(n), where n is 1,2,3,4.\n. @param fgmask The output foreground mask as an 8-bit binary image.\n. @param learningRate The value between 0 and 1 that indicates how fast the background model is\n. learnt. Negative parameter value makes the algorithm to use some automatically chosen learning\n. rate. 0 means that the background model is not updated at all, 1 means that the background model\n. is completely reinitialized from the last frame."}, |  | 35793 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n. @brief Computes a foreground mask.\n. \n. @param image Next video frame of type CV_8UC(n),CV_8SC(n),CV_16UC(n),CV_16SC(n),CV_32SC(n),CV_32FC(n),CV_64FC(n), where n is 1,2,3,4.\n. @param fgmask The output foreground mask as an 8-bit binary image.\n. @param learningRate The value between 0 and 1 that indicates how fast the background model is\n. learnt. Negative parameter value makes the algorithm to use some automatically chosen learning\n. rate. 0 means that the background model is not updated at all, 1 means that the background model\n. is completely reinitialized from the last frame."},
| 35842 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."}, |  | 35794 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."},
| 35843 | {"getBackgroundPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundPrior, 0), "getBackgroundPrior() -> retval\n. @brief Returns the prior probability that each individual pixel is a background pixel."}, |  | 35795 | {"getBackgroundPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getBackgroundPrior, 0), "getBackgroundPrior() -> retval\n. @brief Returns the prior probability that each individual pixel is a background pixel."},
| 35844 | {"getDecisionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDecisionThreshold, 0), "getDecisionThreshold() -> retval\n. @brief Returns the value of decision threshold.\n. \n. Decision value is the value above which pixel is determined to be FG."}, |  | 35796 | {"getDecisionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDecisionThreshold, 0), "getDecisionThreshold() -> retval\n. @brief Returns the value of decision threshold.\n. \n. Decision value is the value above which pixel is determined to be FG."},
| 35845 | {"getDefaultLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDefaultLearningRate, 0), "getDefaultLearningRate() -> retval\n. @brief Returns the learning rate of the algorithm.\n. \n. It lies between 0.0 and 1.0. It determines how quickly features are \"forgotten\" from\n. histograms."}, |  | 35797 | {"getDefaultLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getDefaultLearningRate, 0), "getDefaultLearningRate() -> retval\n. @brief Returns the learning rate of the algorithm.\n. \n. It lies between 0.0 and 1.0. It determines how quickly features are \"forgotten\" from\n. histograms."},
| 35846 | {"getMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxFeatures, 0), "getMaxFeatures() -> retval\n. @brief Returns total number of distinct colors to maintain in histogram."}, |  | 35798 | {"getMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxFeatures, 0), "getMaxFeatures() -> retval\n. @brief Returns total number of distinct colors to maintain in histogram."},
| 35847 | {"getMaxVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxVal, 0), "getMaxVal() -> retval\n. @brief Returns the maximum value taken on by pixels in image sequence. e.g. 1.0 or 255."}, |  | 35799 | {"getMaxVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMaxVal, 0), "getMaxVal() -> retval\n. @brief Returns the maximum value taken on by pixels in image sequence. e.g. 1.0 or 255."},
| 35848 | {"getMinVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMinVal, 0), "getMinVal() -> retval\n. @brief Returns the minimum value taken on by pixels in image sequence. Usually 0."}, |  | 35800 | {"getMinVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getMinVal, 0), "getMinVal() -> retval\n. @brief Returns the minimum value taken on by pixels in image sequence. Usually 0."},
| 35849 | {"getNumFrames", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getNumFrames, 0), "getNumFrames() -> retval\n. @brief Returns the number of frames used to initialize background model."}, |  | 35801 | {"getNumFrames", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getNumFrames, 0), "getNumFrames() -> retval\n. @brief Returns the number of frames used to initialize background model."},
| 35850 | {"getQuantizationLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getQuantizationLevels, 0), "getQuantizationLevels() -> retval\n. @brief Returns the parameter used for quantization of color-space.\n. \n. It is the number of discrete levels in each channel to be used in histograms."}, |  | 35802 | {"getQuantizationLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getQuantizationLevels, 0), "getQuantizationLevels() -> retval\n. @brief Returns the parameter used for quantization of color-space.\n. \n. It is the number of discrete levels in each channel to be used in histograms."},
| 35851 | {"getSmoothingRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getSmoothingRadius, 0), "getSmoothingRadius() -> retval\n. @brief Returns the kernel radius used for morphological operations"}, |  | 35803 | {"getSmoothingRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getSmoothingRadius, 0), "getSmoothingRadius() -> retval\n. @brief Returns the kernel radius used for morphological operations"},
| 35852 | {"getUpdateBackgroundModel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getUpdateBackgroundModel, 0), "getUpdateBackgroundModel() -> retval\n. @brief Returns the status of background model update"}, |  | 35804 | {"getUpdateBackgroundModel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_getUpdateBackgroundModel, 0), "getUpdateBackgroundModel() -> retval\n. @brief Returns the status of background model update"},
| 35853 | {"setBackgroundPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setBackgroundPrior, 0), "setBackgroundPrior(bgprior) -> None\n. @brief Sets the prior probability that each individual pixel is a background pixel."}, |  | 35805 | {"setBackgroundPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setBackgroundPrior, 0), "setBackgroundPrior(bgprior) -> None\n. @brief Sets the prior probability that each individual pixel is a background pixel."},
| 35854 | {"setDecisionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDecisionThreshold, 0), "setDecisionThreshold(thresh) -> None\n. @brief Sets the value of decision threshold."}, |  | 35806 | {"setDecisionThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDecisionThreshold, 0), "setDecisionThreshold(thresh) -> None\n. @brief Sets the value of decision threshold."},
| 35855 | {"setDefaultLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDefaultLearningRate, 0), "setDefaultLearningRate(lr) -> None\n. @brief Sets the learning rate of the algorithm."}, |  | 35807 | {"setDefaultLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setDefaultLearningRate, 0), "setDefaultLearningRate(lr) -> None\n. @brief Sets the learning rate of the algorithm."},
| 35856 | {"setMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxFeatures, 0), "setMaxFeatures(maxFeatures) -> None\n. @brief Sets total number of distinct colors to maintain in histogram."}, |  | 35808 | {"setMaxFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxFeatures, 0), "setMaxFeatures(maxFeatures) -> None\n. @brief Sets total number of distinct colors to maintain in histogram."},
| 35857 | {"setMaxVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxVal, 0), "setMaxVal(val) -> None\n. @brief Sets the maximum value taken on by pixels in image sequence."}, |  | 35809 | {"setMaxVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMaxVal, 0), "setMaxVal(val) -> None\n. @brief Sets the maximum value taken on by pixels in image sequence."},
| 35858 | {"setMinVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMinVal, 0), "setMinVal(val) -> None\n. @brief Sets the minimum value taken on by pixels in image sequence."}, |  | 35810 | {"setMinVal", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setMinVal, 0), "setMinVal(val) -> None\n. @brief Sets the minimum value taken on by pixels in image sequence."},
| 35859 | {"setNumFrames", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setNumFrames, 0), "setNumFrames(nframes) -> None\n. @brief Sets the number of frames used to initialize background model."}, |  | 35811 | {"setNumFrames", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setNumFrames, 0), "setNumFrames(nframes) -> None\n. @brief Sets the number of frames used to initialize background model."},
| 35860 | {"setQuantizationLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setQuantizationLevels, 0), "setQuantizationLevels(nlevels) -> None\n. @brief Sets the parameter used for quantization of color-space"}, |  | 35812 | {"setQuantizationLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setQuantizationLevels, 0), "setQuantizationLevels(nlevels) -> None\n. @brief Sets the parameter used for quantization of color-space"},
| 35861 | {"setSmoothingRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setSmoothingRadius, 0), "setSmoothingRadius(radius) -> None\n. @brief Sets the kernel radius used for morphological operations"}, |  | 35813 | {"setSmoothingRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setSmoothingRadius, 0), "setSmoothingRadius(radius) -> None\n. @brief Sets the kernel radius used for morphological operations"},
| 35862 | {"setUpdateBackgroundModel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setUpdateBackgroundModel, 0), "setUpdateBackgroundModel(update) -> None\n. @brief Sets the status of background model update"}, |  | 35814 | {"setUpdateBackgroundModel", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGMG_setUpdateBackgroundModel, 0), "setUpdateBackgroundModel(update) -> None\n. @brief Sets the status of background model update"},
| 35863 |  |  | 35815 |
| 35864 | {NULL, NULL} |  | 35816 | {NULL, NULL}
| 35865 | }; |  | 35817 | };
| 35866 |  |  | 35818 |
| 35867 | // Converter (bgsegm_BackgroundSubtractorGMG) |  | 35819 | // Converter (bgsegm_BackgroundSubtractorGMG)
| 35868 |  |  | 35820 |
| 35869 | template<> |  | 35821 | template<>
| 35870 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorGMG> > |  | 35822 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorGMG> >
| 35871 | { |  | 35823 | {
| 35872 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorGMG>& r) |  | 35824 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorGMG>& r)
| 35873 | { |  | 35825 | {
| 35874 | return pyopencv_bgsegm_BackgroundSubtractorGMG_Instance(r); |  | 35826 | return pyopencv_bgsegm_BackgroundSubtractorGMG_Instance(r);
| 35875 | } |  | 35827 | }
| 35876 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorGMG>& dst, const ArgInfo& info) |  | 35828 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorGMG>& dst, const ArgInfo& info)
| 35877 | { |  | 35829 | {
| 35878 | if(!src || src == Py_None) |  | 35830 | if(!src || src == Py_None)
| 35879 | return true; |  | 35831 | return true;
| 35880 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * dst_; |  | 35832 | Ptr<cv::bgsegm::BackgroundSubtractorGMG> * dst_;
| 35881 | if (pyopencv_bgsegm_BackgroundSubtractorGMG_getp(src, dst_)) |  | 35833 | if (pyopencv_bgsegm_BackgroundSubtractorGMG_getp(src, dst_))
| 35882 | { |  | 35834 | {
| 35883 | dst = *dst_; |  | 35835 | dst = *dst_;
| 35884 | return true; |  | 35836 | return true;
| 35885 | } |  | 35837 | }
| 35886 |  |  | 35838 |
| 35887 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorGMG> for argument '%s'", info.name); |  | 35839 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorGMG> for argument '%s'", info.name);
| 35888 | return false; |  | 35840 | return false;
| 35889 | } |  | 35841 | }
| 35890 | }; |  | 35842 | };
| 35891 |  |  | 35843 |
| 35892 | //================================================================================ |  | 35844 | //================================================================================
| 35893 | // bgsegm_BackgroundSubtractorGSOC (Generic) |  | 35845 | // bgsegm_BackgroundSubtractorGSOC (Generic)
| 35894 | //================================================================================ |  | 35846 | //================================================================================
| 35895 |  |  | 35847 |
| 35896 | // GetSet (bgsegm_BackgroundSubtractorGSOC) |  | 35848 | // GetSet (bgsegm_BackgroundSubtractorGSOC)
| 35897 |  |  | 35849 |
| 35898 |  |  | 35850 |
| 35899 |  |  | 35851 |
| 35900 | // Methods (bgsegm_BackgroundSubtractorGSOC) |  | 35852 | // Methods (bgsegm_BackgroundSubtractorGSOC)
| 35901 |  |  | 35853 |
| 35902 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35854 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 35903 | { |  | 35855 | {
| 35904 | using namespace cv::bgsegm; |  | 35856 | using namespace cv::bgsegm;
| 35905 |  |  | 35857 |
| 35906 |  |  | 35858 |
| 35907 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> * self1 = 0; |  | 35859 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> * self1 = 0;
| 35908 | if (!pyopencv_bgsegm_BackgroundSubtractorGSOC_getp(self, self1)) |  | 35860 | if (!pyopencv_bgsegm_BackgroundSubtractorGSOC_getp(self, self1))
| 35909 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGSOC' or its derivative)"); |  | 35861 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGSOC' or its derivative)");
| 35910 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> _self_ = *(self1); |  | 35862 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> _self_ = *(self1);
| 35911 | pyPrepareArgumentConversionErrorsStorage(2); |  | 35863 | pyPrepareArgumentConversionErrorsStorage(2);
| 35912 |  |  | 35864 |
| 35913 | { |  | 35865 | {
| 35914 | PyObject* pyobj_image = NULL; |  | 35866 | PyObject* pyobj_image = NULL;
| 35915 | Mat image; |  | 35867 | Mat image;
| 35916 | PyObject* pyobj_fgmask = NULL; |  | 35868 | PyObject* pyobj_fgmask = NULL;
| 35917 | Mat fgmask; |  | 35869 | Mat fgmask;
| 35918 | PyObject* pyobj_learningRate = NULL; |  | 35870 | PyObject* pyobj_learningRate = NULL;
| 35919 | double learningRate=-1; |  | 35871 | double learningRate=-1;
| 35920 |  |  | 35872 |
| 35921 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 35873 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 35922 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGSOC.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 35874 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGSOC.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 35923 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 35875 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 35924 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 35876 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 35925 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 35877 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 35926 | { |  | 35878 | {
| 35927 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 35879 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 35928 | return pyopencv_from(fgmask); |  | 35880 | return pyopencv_from(fgmask);
| 35929 | } |  | 35881 | }
| 35930 |  |  | 35882 |
| 35931 |  |  | 35883 |
| 35932 | pyPopulateArgumentConversionErrors(); |  | 35884 | pyPopulateArgumentConversionErrors();
| 35933 | } |  | 35885 | }
| 35934 |  |  | 35886 |
| 35935 |  |  | 35887 |
| 35936 | { |  | 35888 | {
| 35937 | PyObject* pyobj_image = NULL; |  | 35889 | PyObject* pyobj_image = NULL;
| 35938 | UMat image; |  | 35890 | UMat image;
| 35939 | PyObject* pyobj_fgmask = NULL; |  | 35891 | PyObject* pyobj_fgmask = NULL;
| 35940 | UMat fgmask; |  | 35892 | UMat fgmask;
| 35941 | PyObject* pyobj_learningRate = NULL; |  | 35893 | PyObject* pyobj_learningRate = NULL;
| 35942 | double learningRate=-1; |  | 35894 | double learningRate=-1;
| 35943 |  |  | 35895 |
| 35944 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 35896 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 35945 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGSOC.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 35897 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorGSOC.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 35946 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 35898 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 35947 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 35899 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 35948 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 35900 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 35949 | { |  | 35901 | {
| 35950 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 35902 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 35951 | return pyopencv_from(fgmask); |  | 35903 | return pyopencv_from(fgmask);
| 35952 | } |  | 35904 | }
| 35953 |  |  | 35905 |
| 35954 |  |  | 35906 |
| 35955 | pyPopulateArgumentConversionErrors(); |  | 35907 | pyPopulateArgumentConversionErrors();
| 35956 | } |  | 35908 | }
| 35957 | pyRaiseCVOverloadException("apply"); |  | 35909 | pyRaiseCVOverloadException("apply");
| 35958 |  |  | 35910 |
| 35959 | return NULL; |  | 35911 | return NULL;
| 35960 | } |  | 35912 | }
| 35961 |  |  | 35913 |
| 35962 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 35914 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 35963 | { |  | 35915 | {
| 35964 | using namespace cv::bgsegm; |  | 35916 | using namespace cv::bgsegm;
| 35965 |  |  | 35917 |
| 35966 |  |  | 35918 |
| 35967 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> * self1 = 0; |  | 35919 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> * self1 = 0;
| 35968 | if (!pyopencv_bgsegm_BackgroundSubtractorGSOC_getp(self, self1)) |  | 35920 | if (!pyopencv_bgsegm_BackgroundSubtractorGSOC_getp(self, self1))
| 35969 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGSOC' or its derivative)"); |  | 35921 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorGSOC' or its derivative)");
| 35970 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> _self_ = *(self1); |  | 35922 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> _self_ = *(self1);
| 35971 | pyPrepareArgumentConversionErrorsStorage(2); |  | 35923 | pyPrepareArgumentConversionErrorsStorage(2);
| 35972 |  |  | 35924 |
| 35973 | { |  | 35925 | {
| 35974 | PyObject* pyobj_backgroundImage = NULL; |  | 35926 | PyObject* pyobj_backgroundImage = NULL;
| 35975 | Mat backgroundImage; |  | 35927 | Mat backgroundImage;
| 35976 |  |  | 35928 |
| 35977 | const char* keywords[] = { "backgroundImage", NULL }; |  | 35929 | const char* keywords[] = { "backgroundImage", NULL };
| 35978 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGSOC.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 35930 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGSOC.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 35979 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 35931 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 35980 | { |  | 35932 | {
| 35981 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 35933 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 35982 | return pyopencv_from(backgroundImage); |  | 35934 | return pyopencv_from(backgroundImage);
| 35983 | } |  | 35935 | }
| 35984 |  |  | 35936 |
| 35985 |  |  | 35937 |
| 35986 | pyPopulateArgumentConversionErrors(); |  | 35938 | pyPopulateArgumentConversionErrors();
| 35987 | } |  | 35939 | }
| 35988 |  |  | 35940 |
| 35989 |  |  | 35941 |
| 35990 | { |  | 35942 | {
| 35991 | PyObject* pyobj_backgroundImage = NULL; |  | 35943 | PyObject* pyobj_backgroundImage = NULL;
| 35992 | UMat backgroundImage; |  | 35944 | UMat backgroundImage;
| 35993 |  |  | 35945 |
| 35994 | const char* keywords[] = { "backgroundImage", NULL }; |  | 35946 | const char* keywords[] = { "backgroundImage", NULL };
| 35995 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGSOC.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 35947 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorGSOC.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 35996 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 35948 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 35997 | { |  | 35949 | {
| 35998 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 35950 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 35999 | return pyopencv_from(backgroundImage); |  | 35951 | return pyopencv_from(backgroundImage);
| 36000 | } |  | 35952 | }
| 36001 |  |  | 35953 |
| 36002 |  |  | 35954 |
| 36003 | pyPopulateArgumentConversionErrors(); |  | 35955 | pyPopulateArgumentConversionErrors();
| 36004 | } |  | 35956 | }
| 36005 | pyRaiseCVOverloadException("getBackgroundImage"); |  | 35957 | pyRaiseCVOverloadException("getBackgroundImage");
| 36006 |  |  | 35958 |
| 36007 | return NULL; |  | 35959 | return NULL;
| 36008 | } |  | 35960 | }
| 36009 |  |  | 35961 |
| 36010 |  |  | 35962 |
| 36011 |  |  | 35963 |
| 36012 | // Tables (bgsegm_BackgroundSubtractorGSOC) |  | 35964 | // Tables (bgsegm_BackgroundSubtractorGSOC)
| 36013 |  |  | 35965 |
| 36014 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorGSOC_getseters[] = |  | 35966 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorGSOC_getseters[] =
| 36015 | { |  | 35967 | {
| 36016 | {NULL} /* Sentinel */ |  | 35968 | {NULL} /* Sentinel */
| 36017 | }; |  | 35969 | };
| 36018 |  |  | 35970 |
| 36019 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorGSOC_methods[] = |  | 35971 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorGSOC_methods[] =
| 36020 | { |  | 35972 | {
| 36021 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n."}, |  | 35973 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n."},
| 36022 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."}, |  | 35974 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorGSOC_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."},
| 36023 |  |  | 35975 |
| 36024 | {NULL, NULL} |  | 35976 | {NULL, NULL}
| 36025 | }; |  | 35977 | };
| 36026 |  |  | 35978 |
| 36027 | // Converter (bgsegm_BackgroundSubtractorGSOC) |  | 35979 | // Converter (bgsegm_BackgroundSubtractorGSOC)
| 36028 |  |  | 35980 |
| 36029 | template<> |  | 35981 | template<>
| 36030 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorGSOC> > |  | 35982 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorGSOC> >
| 36031 | { |  | 35983 | {
| 36032 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorGSOC>& r) |  | 35984 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorGSOC>& r)
| 36033 | { |  | 35985 | {
| 36034 | return pyopencv_bgsegm_BackgroundSubtractorGSOC_Instance(r); |  | 35986 | return pyopencv_bgsegm_BackgroundSubtractorGSOC_Instance(r);
| 36035 | } |  | 35987 | }
| 36036 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorGSOC>& dst, const ArgInfo& info) |  | 35988 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorGSOC>& dst, const ArgInfo& info)
| 36037 | { |  | 35989 | {
| 36038 | if(!src || src == Py_None) |  | 35990 | if(!src || src == Py_None)
| 36039 | return true; |  | 35991 | return true;
| 36040 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> * dst_; |  | 35992 | Ptr<cv::bgsegm::BackgroundSubtractorGSOC> * dst_;
| 36041 | if (pyopencv_bgsegm_BackgroundSubtractorGSOC_getp(src, dst_)) |  | 35993 | if (pyopencv_bgsegm_BackgroundSubtractorGSOC_getp(src, dst_))
| 36042 | { |  | 35994 | {
| 36043 | dst = *dst_; |  | 35995 | dst = *dst_;
| 36044 | return true; |  | 35996 | return true;
| 36045 | } |  | 35997 | }
| 36046 |  |  | 35998 |
| 36047 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorGSOC> for argument '%s'", info.name); |  | 35999 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorGSOC> for argument '%s'", info.name);
| 36048 | return false; |  | 36000 | return false;
| 36049 | } |  | 36001 | }
| 36050 | }; |  | 36002 | };
| 36051 |  |  | 36003 |
| 36052 | //================================================================================ |  | 36004 | //================================================================================
| 36053 | // bgsegm_BackgroundSubtractorLSBP (Generic) |  | 36005 | // bgsegm_BackgroundSubtractorLSBP (Generic)
| 36054 | //================================================================================ |  | 36006 | //================================================================================
| 36055 |  |  | 36007 |
| 36056 | // GetSet (bgsegm_BackgroundSubtractorLSBP) |  | 36008 | // GetSet (bgsegm_BackgroundSubtractorLSBP)
| 36057 |  |  | 36009 |
| 36058 |  |  | 36010 |
| 36059 |  |  | 36011 |
| 36060 | // Methods (bgsegm_BackgroundSubtractorLSBP) |  | 36012 | // Methods (bgsegm_BackgroundSubtractorLSBP)
| 36061 |  |  | 36013 |
| 36062 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36014 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 36063 | { |  | 36015 | {
| 36064 | using namespace cv::bgsegm; |  | 36016 | using namespace cv::bgsegm;
| 36065 |  |  | 36017 |
| 36066 |  |  | 36018 |
| 36067 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> * self1 = 0; |  | 36019 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> * self1 = 0;
| 36068 | if (!pyopencv_bgsegm_BackgroundSubtractorLSBP_getp(self, self1)) |  | 36020 | if (!pyopencv_bgsegm_BackgroundSubtractorLSBP_getp(self, self1))
| 36069 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorLSBP' or its derivative)"); |  | 36021 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorLSBP' or its derivative)");
| 36070 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> _self_ = *(self1); |  | 36022 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> _self_ = *(self1);
| 36071 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36023 | pyPrepareArgumentConversionErrorsStorage(2);
| 36072 |  |  | 36024 |
| 36073 | { |  | 36025 | {
| 36074 | PyObject* pyobj_image = NULL; |  | 36026 | PyObject* pyobj_image = NULL;
| 36075 | Mat image; |  | 36027 | Mat image;
| 36076 | PyObject* pyobj_fgmask = NULL; |  | 36028 | PyObject* pyobj_fgmask = NULL;
| 36077 | Mat fgmask; |  | 36029 | Mat fgmask;
| 36078 | PyObject* pyobj_learningRate = NULL; |  | 36030 | PyObject* pyobj_learningRate = NULL;
| 36079 | double learningRate=-1; |  | 36031 | double learningRate=-1;
| 36080 |  |  | 36032 |
| 36081 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 36033 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 36082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorLSBP.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 36034 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorLSBP.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 36083 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 36035 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 36084 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 36036 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 36085 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 36037 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 36086 | { |  | 36038 | {
| 36087 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 36039 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 36088 | return pyopencv_from(fgmask); |  | 36040 | return pyopencv_from(fgmask);
| 36089 | } |  | 36041 | }
| 36090 |  |  | 36042 |
| 36091 |  |  | 36043 |
| 36092 | pyPopulateArgumentConversionErrors(); |  | 36044 | pyPopulateArgumentConversionErrors();
| 36093 | } |  | 36045 | }
| 36094 |  |  | 36046 |
| 36095 |  |  | 36047 |
| 36096 | { |  | 36048 | {
| 36097 | PyObject* pyobj_image = NULL; |  | 36049 | PyObject* pyobj_image = NULL;
| 36098 | UMat image; |  | 36050 | UMat image;
| 36099 | PyObject* pyobj_fgmask = NULL; |  | 36051 | PyObject* pyobj_fgmask = NULL;
| 36100 | UMat fgmask; |  | 36052 | UMat fgmask;
| 36101 | PyObject* pyobj_learningRate = NULL; |  | 36053 | PyObject* pyobj_learningRate = NULL;
| 36102 | double learningRate=-1; |  | 36054 | double learningRate=-1;
| 36103 |  |  | 36055 |
| 36104 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL }; |  | 36056 | const char* keywords[] = { "image", "fgmask", "learningRate", NULL };
| 36105 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorLSBP.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) && |  | 36057 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:bgsegm_BackgroundSubtractorLSBP.apply", (char**)keywords, &pyobj_image, &pyobj_fgmask, &pyobj_learningRate) &&
| 36106 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 36058 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 36107 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) && |  | 36059 | pyopencv_to_safe(pyobj_fgmask, fgmask, ArgInfo("fgmask", 1)) &&
| 36108 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) ) |  | 36060 | pyopencv_to_safe(pyobj_learningRate, learningRate, ArgInfo("learningRate", 0)) )
| 36109 | { |  | 36061 | {
| 36110 | ERRWRAP2(_self_->apply(image, fgmask, learningRate)); |  | 36062 | ERRWRAP2(_self_->apply(image, fgmask, learningRate));
| 36111 | return pyopencv_from(fgmask); |  | 36063 | return pyopencv_from(fgmask);
| 36112 | } |  | 36064 | }
| 36113 |  |  | 36065 |
| 36114 |  |  | 36066 |
| 36115 | pyPopulateArgumentConversionErrors(); |  | 36067 | pyPopulateArgumentConversionErrors();
| 36116 | } |  | 36068 | }
| 36117 | pyRaiseCVOverloadException("apply"); |  | 36069 | pyRaiseCVOverloadException("apply");
| 36118 |  |  | 36070 |
| 36119 | return NULL; |  | 36071 | return NULL;
| 36120 | } |  | 36072 | }
| 36121 |  |  | 36073 |
| 36122 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36074 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_getBackgroundImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 36123 | { |  | 36075 | {
| 36124 | using namespace cv::bgsegm; |  | 36076 | using namespace cv::bgsegm;
| 36125 |  |  | 36077 |
| 36126 |  |  | 36078 |
| 36127 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> * self1 = 0; |  | 36079 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> * self1 = 0;
| 36128 | if (!pyopencv_bgsegm_BackgroundSubtractorLSBP_getp(self, self1)) |  | 36080 | if (!pyopencv_bgsegm_BackgroundSubtractorLSBP_getp(self, self1))
| 36129 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorLSBP' or its derivative)"); |  | 36081 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorLSBP' or its derivative)");
| 36130 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> _self_ = *(self1); |  | 36082 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> _self_ = *(self1);
| 36131 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36083 | pyPrepareArgumentConversionErrorsStorage(2);
| 36132 |  |  | 36084 |
| 36133 | { |  | 36085 | {
| 36134 | PyObject* pyobj_backgroundImage = NULL; |  | 36086 | PyObject* pyobj_backgroundImage = NULL;
| 36135 | Mat backgroundImage; |  | 36087 | Mat backgroundImage;
| 36136 |  |  | 36088 |
| 36137 | const char* keywords[] = { "backgroundImage", NULL }; |  | 36089 | const char* keywords[] = { "backgroundImage", NULL };
| 36138 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorLSBP.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 36090 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorLSBP.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 36139 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 36091 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 36140 | { |  | 36092 | {
| 36141 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 36093 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 36142 | return pyopencv_from(backgroundImage); |  | 36094 | return pyopencv_from(backgroundImage);
| 36143 | } |  | 36095 | }
| 36144 |  |  | 36096 |
| 36145 |  |  | 36097 |
| 36146 | pyPopulateArgumentConversionErrors(); |  | 36098 | pyPopulateArgumentConversionErrors();
| 36147 | } |  | 36099 | }
| 36148 |  |  | 36100 |
| 36149 |  |  | 36101 |
| 36150 | { |  | 36102 | {
| 36151 | PyObject* pyobj_backgroundImage = NULL; |  | 36103 | PyObject* pyobj_backgroundImage = NULL;
| 36152 | UMat backgroundImage; |  | 36104 | UMat backgroundImage;
| 36153 |  |  | 36105 |
| 36154 | const char* keywords[] = { "backgroundImage", NULL }; |  | 36106 | const char* keywords[] = { "backgroundImage", NULL };
| 36155 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorLSBP.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) && |  | 36107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bgsegm_BackgroundSubtractorLSBP.getBackgroundImage", (char**)keywords, &pyobj_backgroundImage) &&
| 36156 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) ) |  | 36108 | pyopencv_to_safe(pyobj_backgroundImage, backgroundImage, ArgInfo("backgroundImage", 1)) )
| 36157 | { |  | 36109 | {
| 36158 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage)); |  | 36110 | ERRWRAP2(_self_->getBackgroundImage(backgroundImage));
| 36159 | return pyopencv_from(backgroundImage); |  | 36111 | return pyopencv_from(backgroundImage);
| 36160 | } |  | 36112 | }
| 36161 |  |  | 36113 |
| 36162 |  |  | 36114 |
| 36163 | pyPopulateArgumentConversionErrors(); |  | 36115 | pyPopulateArgumentConversionErrors();
| 36164 | } |  | 36116 | }
| 36165 | pyRaiseCVOverloadException("getBackgroundImage"); |  | 36117 | pyRaiseCVOverloadException("getBackgroundImage");
| 36166 |  |  | 36118 |
| 36167 | return NULL; |  | 36119 | return NULL;
| 36168 | } |  | 36120 | }
| 36169 |  |  | 36121 |
| 36170 |  |  | 36122 |
| 36171 |  |  | 36123 |
| 36172 | // Tables (bgsegm_BackgroundSubtractorLSBP) |  | 36124 | // Tables (bgsegm_BackgroundSubtractorLSBP)
| 36173 |  |  | 36125 |
| 36174 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorLSBP_getseters[] = |  | 36126 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorLSBP_getseters[] =
| 36175 | { |  | 36127 | {
| 36176 | {NULL} /* Sentinel */ |  | 36128 | {NULL} /* Sentinel */
| 36177 | }; |  | 36129 | };
| 36178 |  |  | 36130 |
| 36179 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorLSBP_methods[] = |  | 36131 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorLSBP_methods[] =
| 36180 | { |  | 36132 | {
| 36181 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n."}, |  | 36133 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_apply, 0), "apply(image[, fgmask[, learningRate]]) -> fgmask\n."},
| 36182 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."}, |  | 36134 | {"getBackgroundImage", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorLSBP_getBackgroundImage, 0), "getBackgroundImage([, backgroundImage]) -> backgroundImage\n."},
| 36183 |  |  | 36135 |
| 36184 | {NULL, NULL} |  | 36136 | {NULL, NULL}
| 36185 | }; |  | 36137 | };
| 36186 |  |  | 36138 |
| 36187 | // Converter (bgsegm_BackgroundSubtractorLSBP) |  | 36139 | // Converter (bgsegm_BackgroundSubtractorLSBP)
| 36188 |  |  | 36140 |
| 36189 | template<> |  | 36141 | template<>
| 36190 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorLSBP> > |  | 36142 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorLSBP> >
| 36191 | { |  | 36143 | {
| 36192 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorLSBP>& r) |  | 36144 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorLSBP>& r)
| 36193 | { |  | 36145 | {
| 36194 | return pyopencv_bgsegm_BackgroundSubtractorLSBP_Instance(r); |  | 36146 | return pyopencv_bgsegm_BackgroundSubtractorLSBP_Instance(r);
| 36195 | } |  | 36147 | }
| 36196 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorLSBP>& dst, const ArgInfo& info) |  | 36148 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorLSBP>& dst, const ArgInfo& info)
| 36197 | { |  | 36149 | {
| 36198 | if(!src || src == Py_None) |  | 36150 | if(!src || src == Py_None)
| 36199 | return true; |  | 36151 | return true;
| 36200 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> * dst_; |  | 36152 | Ptr<cv::bgsegm::BackgroundSubtractorLSBP> * dst_;
| 36201 | if (pyopencv_bgsegm_BackgroundSubtractorLSBP_getp(src, dst_)) |  | 36153 | if (pyopencv_bgsegm_BackgroundSubtractorLSBP_getp(src, dst_))
| 36202 | { |  | 36154 | {
| 36203 | dst = *dst_; |  | 36155 | dst = *dst_;
| 36204 | return true; |  | 36156 | return true;
| 36205 | } |  | 36157 | }
| 36206 |  |  | 36158 |
| 36207 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorLSBP> for argument '%s'", info.name); |  | 36159 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorLSBP> for argument '%s'", info.name);
| 36208 | return false; |  | 36160 | return false;
| 36209 | } |  | 36161 | }
| 36210 | }; |  | 36162 | };
| 36211 |  |  | 36163 |
| 36212 | //================================================================================ |  | 36164 | //================================================================================
| 36213 | // bgsegm_BackgroundSubtractorLSBPDesc (Generic) |  | 36165 | // bgsegm_BackgroundSubtractorLSBPDesc (Generic)
| 36214 | //================================================================================ |  | 36166 | //================================================================================
| 36215 |  |  | 36167 |
| 36216 | // GetSet (bgsegm_BackgroundSubtractorLSBPDesc) |  | 36168 | // GetSet (bgsegm_BackgroundSubtractorLSBPDesc)
| 36217 |  |  | 36169 |
| 36218 |  |  | 36170 |
| 36219 |  |  | 36171 |
| 36220 | // Methods (bgsegm_BackgroundSubtractorLSBPDesc) |  | 36172 | // Methods (bgsegm_BackgroundSubtractorLSBPDesc)
| 36221 |  |  | 36173 |
| 36222 |  |  | 36174 |
| 36223 |  |  | 36175 |
| 36224 | // Tables (bgsegm_BackgroundSubtractorLSBPDesc) |  | 36176 | // Tables (bgsegm_BackgroundSubtractorLSBPDesc)
| 36225 |  |  | 36177 |
| 36226 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_getseters[] = |  | 36178 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_getseters[] =
| 36227 | { |  | 36179 | {
| 36228 | {NULL} /* Sentinel */ |  | 36180 | {NULL} /* Sentinel */
| 36229 | }; |  | 36181 | };
| 36230 |  |  | 36182 |
| 36231 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_methods[] = |  | 36183 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_methods[] =
| 36232 | { |  | 36184 | {
| 36233 |  |  | 36185 |
| 36234 | {NULL, NULL} |  | 36186 | {NULL, NULL}
| 36235 | }; |  | 36187 | };
| 36236 |  |  | 36188 |
| 36237 | // Converter (bgsegm_BackgroundSubtractorLSBPDesc) |  | 36189 | // Converter (bgsegm_BackgroundSubtractorLSBPDesc)
| 36238 |  |  | 36190 |
| 36239 | template<> |  | 36191 | template<>
| 36240 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc> > |  | 36192 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc> >
| 36241 | { |  | 36193 | {
| 36242 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc>& r) |  | 36194 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc>& r)
| 36243 | { |  | 36195 | {
| 36244 | return pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_Instance(r); |  | 36196 | return pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_Instance(r);
| 36245 | } |  | 36197 | }
| 36246 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc>& dst, const ArgInfo& info) |  | 36198 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc>& dst, const ArgInfo& info)
| 36247 | { |  | 36199 | {
| 36248 | if(!src || src == Py_None) |  | 36200 | if(!src || src == Py_None)
| 36249 | return true; |  | 36201 | return true;
| 36250 | Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc> * dst_; |  | 36202 | Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc> * dst_;
| 36251 | if (pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_getp(src, dst_)) |  | 36203 | if (pyopencv_bgsegm_BackgroundSubtractorLSBPDesc_getp(src, dst_))
| 36252 | { |  | 36204 | {
| 36253 | dst = *dst_; |  | 36205 | dst = *dst_;
| 36254 | return true; |  | 36206 | return true;
| 36255 | } |  | 36207 | }
| 36256 |  |  | 36208 |
| 36257 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc> for argument '%s'", info.name); |  | 36209 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorLSBPDesc> for argument '%s'", info.name);
| 36258 | return false; |  | 36210 | return false;
| 36259 | } |  | 36211 | }
| 36260 | }; |  | 36212 | };
| 36261 |  |  | 36213 |
| 36262 | //================================================================================ |  | 36214 | //================================================================================
| 36263 | // bgsegm_BackgroundSubtractorMOG (Generic) |  | 36215 | // bgsegm_BackgroundSubtractorMOG (Generic)
| 36264 | //================================================================================ |  | 36216 | //================================================================================
| 36265 |  |  | 36217 |
| 36266 | // GetSet (bgsegm_BackgroundSubtractorMOG) |  | 36218 | // GetSet (bgsegm_BackgroundSubtractorMOG)
| 36267 |  |  | 36219 |
| 36268 |  |  | 36220 |
| 36269 |  |  | 36221 |
| 36270 | // Methods (bgsegm_BackgroundSubtractorMOG) |  | 36222 | // Methods (bgsegm_BackgroundSubtractorMOG)
| 36271 |  |  | 36223 |
| 36272 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36224 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 36273 | { |  | 36225 | {
| 36274 | using namespace cv::bgsegm; |  | 36226 | using namespace cv::bgsegm;
| 36275 |  |  | 36227 |
| 36276 |  |  | 36228 |
| 36277 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36229 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36278 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36230 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36279 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36231 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36280 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36232 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36281 | double retval; |  | 36233 | double retval;
| 36282 |  |  | 36234 |
| 36283 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36235 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 36284 | { |  | 36236 | {
| 36285 | ERRWRAP2(retval = _self_->getBackgroundRatio()); |  | 36237 | ERRWRAP2(retval = _self_->getBackgroundRatio());
| 36286 | return pyopencv_from(retval); |  | 36238 | return pyopencv_from(retval);
| 36287 | } |  | 36239 | }
| 36288 |  |  | 36240 |
| 36289 | return NULL; |  | 36241 | return NULL;
| 36290 | } |  | 36242 | }
| 36291 |  |  | 36243 |
| 36292 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36244 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 36293 | { |  | 36245 | {
| 36294 | using namespace cv::bgsegm; |  | 36246 | using namespace cv::bgsegm;
| 36295 |  |  | 36247 |
| 36296 |  |  | 36248 |
| 36297 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36249 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36298 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36250 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36299 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36251 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36300 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36252 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36301 | int retval; |  | 36253 | int retval;
| 36302 |  |  | 36254 |
| 36303 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36255 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 36304 | { |  | 36256 | {
| 36305 | ERRWRAP2(retval = _self_->getHistory()); |  | 36257 | ERRWRAP2(retval = _self_->getHistory());
| 36306 | return pyopencv_from(retval); |  | 36258 | return pyopencv_from(retval);
| 36307 | } |  | 36259 | }
| 36308 |  |  | 36260 |
| 36309 | return NULL; |  | 36261 | return NULL;
| 36310 | } |  | 36262 | }
| 36311 |  |  | 36263 |
| 36312 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNMixtures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36264 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNMixtures(PyObject* self, PyObject* py_args, PyObject* kw)
| 36313 | { |  | 36265 | {
| 36314 | using namespace cv::bgsegm; |  | 36266 | using namespace cv::bgsegm;
| 36315 |  |  | 36267 |
| 36316 |  |  | 36268 |
| 36317 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36269 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36318 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36270 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36319 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36271 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36320 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36272 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36321 | int retval; |  | 36273 | int retval;
| 36322 |  |  | 36274 |
| 36323 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36275 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 36324 | { |  | 36276 | {
| 36325 | ERRWRAP2(retval = _self_->getNMixtures()); |  | 36277 | ERRWRAP2(retval = _self_->getNMixtures());
| 36326 | return pyopencv_from(retval); |  | 36278 | return pyopencv_from(retval);
| 36327 | } |  | 36279 | }
| 36328 |  |  | 36280 |
| 36329 | return NULL; |  | 36281 | return NULL;
| 36330 | } |  | 36282 | }
| 36331 |  |  | 36283 |
| 36332 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNoiseSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36284 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNoiseSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 36333 | { |  | 36285 | {
| 36334 | using namespace cv::bgsegm; |  | 36286 | using namespace cv::bgsegm;
| 36335 |  |  | 36287 |
| 36336 |  |  | 36288 |
| 36337 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36289 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36338 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36290 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36339 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36291 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36340 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36292 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36341 | double retval; |  | 36293 | double retval;
| 36342 |  |  | 36294 |
| 36343 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36295 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 36344 | { |  | 36296 | {
| 36345 | ERRWRAP2(retval = _self_->getNoiseSigma()); |  | 36297 | ERRWRAP2(retval = _self_->getNoiseSigma());
| 36346 | return pyopencv_from(retval); |  | 36298 | return pyopencv_from(retval);
| 36347 | } |  | 36299 | }
| 36348 |  |  | 36300 |
| 36349 | return NULL; |  | 36301 | return NULL;
| 36350 | } |  | 36302 | }
| 36351 |  |  | 36303 |
| 36352 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36304 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setBackgroundRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 36353 | { |  | 36305 | {
| 36354 | using namespace cv::bgsegm; |  | 36306 | using namespace cv::bgsegm;
| 36355 |  |  | 36307 |
| 36356 |  |  | 36308 |
| 36357 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36309 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36358 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36310 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36359 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36311 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36360 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36312 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36361 | PyObject* pyobj_backgroundRatio = NULL; |  | 36313 | PyObject* pyobj_backgroundRatio = NULL;
| 36362 | double backgroundRatio=0; |  | 36314 | double backgroundRatio=0;
| 36363 |  |  | 36315 |
| 36364 | const char* keywords[] = { "backgroundRatio", NULL }; |  | 36316 | const char* keywords[] = { "backgroundRatio", NULL };
| 36365 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setBackgroundRatio", (char**)keywords, &pyobj_backgroundRatio) && |  | 36317 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setBackgroundRatio", (char**)keywords, &pyobj_backgroundRatio) &&
| 36366 | pyopencv_to_safe(pyobj_backgroundRatio, backgroundRatio, ArgInfo("backgroundRatio", 0)) ) |  | 36318 | pyopencv_to_safe(pyobj_backgroundRatio, backgroundRatio, ArgInfo("backgroundRatio", 0)) )
| 36367 | { |  | 36319 | {
| 36368 | ERRWRAP2(_self_->setBackgroundRatio(backgroundRatio)); |  | 36320 | ERRWRAP2(_self_->setBackgroundRatio(backgroundRatio));
| 36369 | Py_RETURN_NONE; |  | 36321 | Py_RETURN_NONE;
| 36370 | } |  | 36322 | }
| 36371 |  |  | 36323 |
| 36372 | return NULL; |  | 36324 | return NULL;
| 36373 | } |  | 36325 | }
| 36374 |  |  | 36326 |
| 36375 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setHistory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36327 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setHistory(PyObject* self, PyObject* py_args, PyObject* kw)
| 36376 | { |  | 36328 | {
| 36377 | using namespace cv::bgsegm; |  | 36329 | using namespace cv::bgsegm;
| 36378 |  |  | 36330 |
| 36379 |  |  | 36331 |
| 36380 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36332 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36381 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36333 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36382 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36334 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36383 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36335 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36384 | PyObject* pyobj_nframes = NULL; |  | 36336 | PyObject* pyobj_nframes = NULL;
| 36385 | int nframes=0; |  | 36337 | int nframes=0;
| 36386 |  |  | 36338 |
| 36387 | const char* keywords[] = { "nframes", NULL }; |  | 36339 | const char* keywords[] = { "nframes", NULL };
| 36388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setHistory", (char**)keywords, &pyobj_nframes) && |  | 36340 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setHistory", (char**)keywords, &pyobj_nframes) &&
| 36389 | pyopencv_to_safe(pyobj_nframes, nframes, ArgInfo("nframes", 0)) ) |  | 36341 | pyopencv_to_safe(pyobj_nframes, nframes, ArgInfo("nframes", 0)) )
| 36390 | { |  | 36342 | {
| 36391 | ERRWRAP2(_self_->setHistory(nframes)); |  | 36343 | ERRWRAP2(_self_->setHistory(nframes));
| 36392 | Py_RETURN_NONE; |  | 36344 | Py_RETURN_NONE;
| 36393 | } |  | 36345 | }
| 36394 |  |  | 36346 |
| 36395 | return NULL; |  | 36347 | return NULL;
| 36396 | } |  | 36348 | }
| 36397 |  |  | 36349 |
| 36398 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNMixtures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36350 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNMixtures(PyObject* self, PyObject* py_args, PyObject* kw)
| 36399 | { |  | 36351 | {
| 36400 | using namespace cv::bgsegm; |  | 36352 | using namespace cv::bgsegm;
| 36401 |  |  | 36353 |
| 36402 |  |  | 36354 |
| 36403 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36355 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36404 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36356 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36405 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36357 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36406 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36358 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36407 | PyObject* pyobj_nmix = NULL; |  | 36359 | PyObject* pyobj_nmix = NULL;
| 36408 | int nmix=0; |  | 36360 | int nmix=0;
| 36409 |  |  | 36361 |
| 36410 | const char* keywords[] = { "nmix", NULL }; |  | 36362 | const char* keywords[] = { "nmix", NULL };
| 36411 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setNMixtures", (char**)keywords, &pyobj_nmix) && |  | 36363 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setNMixtures", (char**)keywords, &pyobj_nmix) &&
| 36412 | pyopencv_to_safe(pyobj_nmix, nmix, ArgInfo("nmix", 0)) ) |  | 36364 | pyopencv_to_safe(pyobj_nmix, nmix, ArgInfo("nmix", 0)) )
| 36413 | { |  | 36365 | {
| 36414 | ERRWRAP2(_self_->setNMixtures(nmix)); |  | 36366 | ERRWRAP2(_self_->setNMixtures(nmix));
| 36415 | Py_RETURN_NONE; |  | 36367 | Py_RETURN_NONE;
| 36416 | } |  | 36368 | }
| 36417 |  |  | 36369 |
| 36418 | return NULL; |  | 36370 | return NULL;
| 36419 | } |  | 36371 | }
| 36420 |  |  | 36372 |
| 36421 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNoiseSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36373 | static PyObject* pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNoiseSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 36422 | { |  | 36374 | {
| 36423 | using namespace cv::bgsegm; |  | 36375 | using namespace cv::bgsegm;
| 36424 |  |  | 36376 |
| 36425 |  |  | 36377 |
| 36426 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0; |  | 36378 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * self1 = 0;
| 36427 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1)) |  | 36379 | if (!pyopencv_bgsegm_BackgroundSubtractorMOG_getp(self, self1))
| 36428 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)"); |  | 36380 | return failmsgp("Incorrect type of self (must be 'bgsegm_BackgroundSubtractorMOG' or its derivative)");
| 36429 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1); |  | 36381 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> _self_ = *(self1);
| 36430 | PyObject* pyobj_noiseSigma = NULL; |  | 36382 | PyObject* pyobj_noiseSigma = NULL;
| 36431 | double noiseSigma=0; |  | 36383 | double noiseSigma=0;
| 36432 |  |  | 36384 |
| 36433 | const char* keywords[] = { "noiseSigma", NULL }; |  | 36385 | const char* keywords[] = { "noiseSigma", NULL };
| 36434 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setNoiseSigma", (char**)keywords, &pyobj_noiseSigma) && |  | 36386 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bgsegm_BackgroundSubtractorMOG.setNoiseSigma", (char**)keywords, &pyobj_noiseSigma) &&
| 36435 | pyopencv_to_safe(pyobj_noiseSigma, noiseSigma, ArgInfo("noiseSigma", 0)) ) |  | 36387 | pyopencv_to_safe(pyobj_noiseSigma, noiseSigma, ArgInfo("noiseSigma", 0)) )
| 36436 | { |  | 36388 | {
| 36437 | ERRWRAP2(_self_->setNoiseSigma(noiseSigma)); |  | 36389 | ERRWRAP2(_self_->setNoiseSigma(noiseSigma));
| 36438 | Py_RETURN_NONE; |  | 36390 | Py_RETURN_NONE;
| 36439 | } |  | 36391 | }
| 36440 |  |  | 36392 |
| 36441 | return NULL; |  | 36393 | return NULL;
| 36442 | } |  | 36394 | }
| 36443 |  |  | 36395 |
| 36444 |  |  | 36396 |
| 36445 |  |  | 36397 |
| 36446 | // Tables (bgsegm_BackgroundSubtractorMOG) |  | 36398 | // Tables (bgsegm_BackgroundSubtractorMOG)
| 36447 |  |  | 36399 |
| 36448 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorMOG_getseters[] = |  | 36400 | static PyGetSetDef pyopencv_bgsegm_BackgroundSubtractorMOG_getseters[] =
| 36449 | { |  | 36401 | {
| 36450 | {NULL} /* Sentinel */ |  | 36402 | {NULL} /* Sentinel */
| 36451 | }; |  | 36403 | };
| 36452 |  |  | 36404 |
| 36453 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorMOG_methods[] = |  | 36405 | static PyMethodDef pyopencv_bgsegm_BackgroundSubtractorMOG_methods[] =
| 36454 | { |  | 36406 | {
| 36455 | {"getBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getBackgroundRatio, 0), "getBackgroundRatio() -> retval\n."}, |  | 36407 | {"getBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getBackgroundRatio, 0), "getBackgroundRatio() -> retval\n."},
| 36456 | {"getHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getHistory, 0), "getHistory() -> retval\n."}, |  | 36408 | {"getHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getHistory, 0), "getHistory() -> retval\n."},
| 36457 | {"getNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNMixtures, 0), "getNMixtures() -> retval\n."}, |  | 36409 | {"getNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNMixtures, 0), "getNMixtures() -> retval\n."},
| 36458 | {"getNoiseSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNoiseSigma, 0), "getNoiseSigma() -> retval\n."}, |  | 36410 | {"getNoiseSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_getNoiseSigma, 0), "getNoiseSigma() -> retval\n."},
| 36459 | {"setBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setBackgroundRatio, 0), "setBackgroundRatio(backgroundRatio) -> None\n."}, |  | 36411 | {"setBackgroundRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setBackgroundRatio, 0), "setBackgroundRatio(backgroundRatio) -> None\n."},
| 36460 | {"setHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setHistory, 0), "setHistory(nframes) -> None\n."}, |  | 36412 | {"setHistory", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setHistory, 0), "setHistory(nframes) -> None\n."},
| 36461 | {"setNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNMixtures, 0), "setNMixtures(nmix) -> None\n."}, |  | 36413 | {"setNMixtures", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNMixtures, 0), "setNMixtures(nmix) -> None\n."},
| 36462 | {"setNoiseSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNoiseSigma, 0), "setNoiseSigma(noiseSigma) -> None\n."}, |  | 36414 | {"setNoiseSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_BackgroundSubtractorMOG_setNoiseSigma, 0), "setNoiseSigma(noiseSigma) -> None\n."},
| 36463 |  |  | 36415 |
| 36464 | {NULL, NULL} |  | 36416 | {NULL, NULL}
| 36465 | }; |  | 36417 | };
| 36466 |  |  | 36418 |
| 36467 | // Converter (bgsegm_BackgroundSubtractorMOG) |  | 36419 | // Converter (bgsegm_BackgroundSubtractorMOG)
| 36468 |  |  | 36420 |
| 36469 | template<> |  | 36421 | template<>
| 36470 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorMOG> > |  | 36422 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::BackgroundSubtractorMOG> >
| 36471 | { |  | 36423 | {
| 36472 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorMOG>& r) |  | 36424 | static PyObject* from(const Ptr<cv::bgsegm::BackgroundSubtractorMOG>& r)
| 36473 | { |  | 36425 | {
| 36474 | return pyopencv_bgsegm_BackgroundSubtractorMOG_Instance(r); |  | 36426 | return pyopencv_bgsegm_BackgroundSubtractorMOG_Instance(r);
| 36475 | } |  | 36427 | }
| 36476 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorMOG>& dst, const ArgInfo& info) |  | 36428 | static bool to(PyObject* src, Ptr<cv::bgsegm::BackgroundSubtractorMOG>& dst, const ArgInfo& info)
| 36477 | { |  | 36429 | {
| 36478 | if(!src || src == Py_None) |  | 36430 | if(!src || src == Py_None)
| 36479 | return true; |  | 36431 | return true;
| 36480 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * dst_; |  | 36432 | Ptr<cv::bgsegm::BackgroundSubtractorMOG> * dst_;
| 36481 | if (pyopencv_bgsegm_BackgroundSubtractorMOG_getp(src, dst_)) |  | 36433 | if (pyopencv_bgsegm_BackgroundSubtractorMOG_getp(src, dst_))
| 36482 | { |  | 36434 | {
| 36483 | dst = *dst_; |  | 36435 | dst = *dst_;
| 36484 | return true; |  | 36436 | return true;
| 36485 | } |  | 36437 | }
| 36486 |  |  | 36438 |
| 36487 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorMOG> for argument '%s'", info.name); |  | 36439 | failmsg("Expected Ptr<cv::bgsegm::BackgroundSubtractorMOG> for argument '%s'", info.name);
| 36488 | return false; |  | 36440 | return false;
| 36489 | } |  | 36441 | }
| 36490 | }; |  | 36442 | };
| 36491 |  |  | 36443 |
| 36492 | //================================================================================ |  | 36444 | //================================================================================
| 36493 | // bgsegm_SyntheticSequenceGenerator (Generic) |  | 36445 | // bgsegm_SyntheticSequenceGenerator (Generic)
| 36494 | //================================================================================ |  | 36446 | //================================================================================
| 36495 |  |  | 36447 |
| 36496 | // GetSet (bgsegm_SyntheticSequenceGenerator) |  | 36448 | // GetSet (bgsegm_SyntheticSequenceGenerator)
| 36497 |  |  | 36449 |
| 36498 |  |  | 36450 |
| 36499 |  |  | 36451 |
| 36500 | // Methods (bgsegm_SyntheticSequenceGenerator) |  | 36452 | // Methods (bgsegm_SyntheticSequenceGenerator)
| 36501 |  |  | 36453 |
| 36502 | static int pyopencv_cv_bgsegm_bgsegm_SyntheticSequenceGenerator_SyntheticSequenceGenerator(pyopencv_bgsegm_SyntheticSequenceGenerator_t* self, PyObject* py_args, PyObject* kw) |  | 36454 | static int pyopencv_cv_bgsegm_bgsegm_SyntheticSequenceGenerator_SyntheticSequenceGenerator(pyopencv_bgsegm_SyntheticSequenceGenerator_t* self, PyObject* py_args, PyObject* kw)
| 36503 | { |  | 36455 | {
| 36504 | using namespace cv::bgsegm; |  | 36456 | using namespace cv::bgsegm;
| 36505 |  |  | 36457 |
| 36506 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36458 | pyPrepareArgumentConversionErrorsStorage(2);
| 36507 |  |  | 36459 |
| 36508 | { |  | 36460 | {
| 36509 | PyObject* pyobj_background = NULL; |  | 36461 | PyObject* pyobj_background = NULL;
| 36510 | Mat background; |  | 36462 | Mat background;
| 36511 | PyObject* pyobj_object = NULL; |  | 36463 | PyObject* pyobj_object = NULL;
| 36512 | Mat object; |  | 36464 | Mat object;
| 36513 | PyObject* pyobj_amplitude = NULL; |  | 36465 | PyObject* pyobj_amplitude = NULL;
| 36514 | double amplitude=0; |  | 36466 | double amplitude=0;
| 36515 | PyObject* pyobj_wavelength = NULL; |  | 36467 | PyObject* pyobj_wavelength = NULL;
| 36516 | double wavelength=0; |  | 36468 | double wavelength=0;
| 36517 | PyObject* pyobj_wavespeed = NULL; |  | 36469 | PyObject* pyobj_wavespeed = NULL;
| 36518 | double wavespeed=0; |  | 36470 | double wavespeed=0;
| 36519 | PyObject* pyobj_objspeed = NULL; |  | 36471 | PyObject* pyobj_objspeed = NULL;
| 36520 | double objspeed=0; |  | 36472 | double objspeed=0;
| 36521 |  |  | 36473 |
| 36522 | const char* keywords[] = { "background", "object", "amplitude", "wavelength", "wavespeed", "objspeed", NULL }; |  | 36474 | const char* keywords[] = { "background", "object", "amplitude", "wavelength", "wavespeed", "objspeed", NULL };
| 36523 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:SyntheticSequenceGenerator", (char**)keywords, &pyobj_background, &pyobj_object, &pyobj_amplitude, &pyobj_wavelength, &pyobj_wavespeed, &pyobj_objspeed) && |  | 36475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:SyntheticSequenceGenerator", (char**)keywords, &pyobj_background, &pyobj_object, &pyobj_amplitude, &pyobj_wavelength, &pyobj_wavespeed, &pyobj_objspeed) &&
| 36524 | pyopencv_to_safe(pyobj_background, background, ArgInfo("background", 0)) && |  | 36476 | pyopencv_to_safe(pyobj_background, background, ArgInfo("background", 0)) &&
| 36525 | pyopencv_to_safe(pyobj_object, object, ArgInfo("object", 0)) && |  | 36477 | pyopencv_to_safe(pyobj_object, object, ArgInfo("object", 0)) &&
| 36526 | pyopencv_to_safe(pyobj_amplitude, amplitude, ArgInfo("amplitude", 0)) && |  | 36478 | pyopencv_to_safe(pyobj_amplitude, amplitude, ArgInfo("amplitude", 0)) &&
| 36527 | pyopencv_to_safe(pyobj_wavelength, wavelength, ArgInfo("wavelength", 0)) && |  | 36479 | pyopencv_to_safe(pyobj_wavelength, wavelength, ArgInfo("wavelength", 0)) &&
| 36528 | pyopencv_to_safe(pyobj_wavespeed, wavespeed, ArgInfo("wavespeed", 0)) && |  | 36480 | pyopencv_to_safe(pyobj_wavespeed, wavespeed, ArgInfo("wavespeed", 0)) &&
| 36529 | pyopencv_to_safe(pyobj_objspeed, objspeed, ArgInfo("objspeed", 0)) ) |  | 36481 | pyopencv_to_safe(pyobj_objspeed, objspeed, ArgInfo("objspeed", 0)) )
| 36530 | { |  | 36482 | {
| 36531 | new (&(self->v)) Ptr<cv::bgsegm::SyntheticSequenceGenerator>(); // init Ptr with placement new |  | 36483 | new (&(self->v)) Ptr<cv::bgsegm::SyntheticSequenceGenerator>(); // init Ptr with placement new
| 36532 | if(self) ERRWRAP2(self->v.reset(new cv::bgsegm::SyntheticSequenceGenerator(background, object, amplitude, wavelength, wavespeed, objspeed))); |  | 36484 | if(self) ERRWRAP2(self->v.reset(new cv::bgsegm::SyntheticSequenceGenerator(background, object, amplitude, wavelength, wavespeed, objspeed)));
| 36533 | return 0; |  | 36485 | return 0;
| 36534 | } |  | 36486 | }
| 36535 |  |  | 36487 |
| 36536 |  |  | 36488 |
| 36537 | pyPopulateArgumentConversionErrors(); |  | 36489 | pyPopulateArgumentConversionErrors();
| 36538 | } |  | 36490 | }
| 36539 |  |  | 36491 |
| 36540 |  |  | 36492 |
| 36541 | { |  | 36493 | {
| 36542 | PyObject* pyobj_background = NULL; |  | 36494 | PyObject* pyobj_background = NULL;
| 36543 | UMat background; |  | 36495 | UMat background;
| 36544 | PyObject* pyobj_object = NULL; |  | 36496 | PyObject* pyobj_object = NULL;
| 36545 | UMat object; |  | 36497 | UMat object;
| 36546 | PyObject* pyobj_amplitude = NULL; |  | 36498 | PyObject* pyobj_amplitude = NULL;
| 36547 | double amplitude=0; |  | 36499 | double amplitude=0;
| 36548 | PyObject* pyobj_wavelength = NULL; |  | 36500 | PyObject* pyobj_wavelength = NULL;
| 36549 | double wavelength=0; |  | 36501 | double wavelength=0;
| 36550 | PyObject* pyobj_wavespeed = NULL; |  | 36502 | PyObject* pyobj_wavespeed = NULL;
| 36551 | double wavespeed=0; |  | 36503 | double wavespeed=0;
| 36552 | PyObject* pyobj_objspeed = NULL; |  | 36504 | PyObject* pyobj_objspeed = NULL;
| 36553 | double objspeed=0; |  | 36505 | double objspeed=0;
| 36554 |  |  | 36506 |
| 36555 | const char* keywords[] = { "background", "object", "amplitude", "wavelength", "wavespeed", "objspeed", NULL }; |  | 36507 | const char* keywords[] = { "background", "object", "amplitude", "wavelength", "wavespeed", "objspeed", NULL };
| 36556 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:SyntheticSequenceGenerator", (char**)keywords, &pyobj_background, &pyobj_object, &pyobj_amplitude, &pyobj_wavelength, &pyobj_wavespeed, &pyobj_objspeed) && |  | 36508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:SyntheticSequenceGenerator", (char**)keywords, &pyobj_background, &pyobj_object, &pyobj_amplitude, &pyobj_wavelength, &pyobj_wavespeed, &pyobj_objspeed) &&
| 36557 | pyopencv_to_safe(pyobj_background, background, ArgInfo("background", 0)) && |  | 36509 | pyopencv_to_safe(pyobj_background, background, ArgInfo("background", 0)) &&
| 36558 | pyopencv_to_safe(pyobj_object, object, ArgInfo("object", 0)) && |  | 36510 | pyopencv_to_safe(pyobj_object, object, ArgInfo("object", 0)) &&
| 36559 | pyopencv_to_safe(pyobj_amplitude, amplitude, ArgInfo("amplitude", 0)) && |  | 36511 | pyopencv_to_safe(pyobj_amplitude, amplitude, ArgInfo("amplitude", 0)) &&
| 36560 | pyopencv_to_safe(pyobj_wavelength, wavelength, ArgInfo("wavelength", 0)) && |  | 36512 | pyopencv_to_safe(pyobj_wavelength, wavelength, ArgInfo("wavelength", 0)) &&
| 36561 | pyopencv_to_safe(pyobj_wavespeed, wavespeed, ArgInfo("wavespeed", 0)) && |  | 36513 | pyopencv_to_safe(pyobj_wavespeed, wavespeed, ArgInfo("wavespeed", 0)) &&
| 36562 | pyopencv_to_safe(pyobj_objspeed, objspeed, ArgInfo("objspeed", 0)) ) |  | 36514 | pyopencv_to_safe(pyobj_objspeed, objspeed, ArgInfo("objspeed", 0)) )
| 36563 | { |  | 36515 | {
| 36564 | new (&(self->v)) Ptr<cv::bgsegm::SyntheticSequenceGenerator>(); // init Ptr with placement new |  | 36516 | new (&(self->v)) Ptr<cv::bgsegm::SyntheticSequenceGenerator>(); // init Ptr with placement new
| 36565 | if(self) ERRWRAP2(self->v.reset(new cv::bgsegm::SyntheticSequenceGenerator(background, object, amplitude, wavelength, wavespeed, objspeed))); |  | 36517 | if(self) ERRWRAP2(self->v.reset(new cv::bgsegm::SyntheticSequenceGenerator(background, object, amplitude, wavelength, wavespeed, objspeed)));
| 36566 | return 0; |  | 36518 | return 0;
| 36567 | } |  | 36519 | }
| 36568 |  |  | 36520 |
| 36569 |  |  | 36521 |
| 36570 | pyPopulateArgumentConversionErrors(); |  | 36522 | pyPopulateArgumentConversionErrors();
| 36571 | } |  | 36523 | }
| 36572 | pyRaiseCVOverloadException("SyntheticSequenceGenerator"); |  | 36524 | pyRaiseCVOverloadException("SyntheticSequenceGenerator");
| 36573 |  |  | 36525 |
| 36574 | return -1; |  | 36526 | return -1;
| 36575 | } |  | 36527 | }
| 36576 |  |  | 36528 |
| 36577 | static PyObject* pyopencv_cv_bgsegm_bgsegm_SyntheticSequenceGenerator_getNextFrame(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36529 | static PyObject* pyopencv_cv_bgsegm_bgsegm_SyntheticSequenceGenerator_getNextFrame(PyObject* self, PyObject* py_args, PyObject* kw)
| 36578 | { |  | 36530 | {
| 36579 | using namespace cv::bgsegm; |  | 36531 | using namespace cv::bgsegm;
| 36580 |  |  | 36532 |
| 36581 |  |  | 36533 |
| 36582 | Ptr<cv::bgsegm::SyntheticSequenceGenerator> * self1 = 0; |  | 36534 | Ptr<cv::bgsegm::SyntheticSequenceGenerator> * self1 = 0;
| 36583 | if (!pyopencv_bgsegm_SyntheticSequenceGenerator_getp(self, self1)) |  | 36535 | if (!pyopencv_bgsegm_SyntheticSequenceGenerator_getp(self, self1))
| 36584 | return failmsgp("Incorrect type of self (must be 'bgsegm_SyntheticSequenceGenerator' or its derivative)"); |  | 36536 | return failmsgp("Incorrect type of self (must be 'bgsegm_SyntheticSequenceGenerator' or its derivative)");
| 36585 | Ptr<cv::bgsegm::SyntheticSequenceGenerator> _self_ = *(self1); |  | 36537 | Ptr<cv::bgsegm::SyntheticSequenceGenerator> _self_ = *(self1);
| 36586 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36538 | pyPrepareArgumentConversionErrorsStorage(2);
| 36587 |  |  | 36539 |
| 36588 | { |  | 36540 | {
| 36589 | PyObject* pyobj_frame = NULL; |  | 36541 | PyObject* pyobj_frame = NULL;
| 36590 | Mat frame; |  | 36542 | Mat frame;
| 36591 | PyObject* pyobj_gtMask = NULL; |  | 36543 | PyObject* pyobj_gtMask = NULL;
| 36592 | Mat gtMask; |  | 36544 | Mat gtMask;
| 36593 |  |  | 36545 |
| 36594 | const char* keywords[] = { "frame", "gtMask", NULL }; |  | 36546 | const char* keywords[] = { "frame", "gtMask", NULL };
| 36595 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bgsegm_SyntheticSequenceGenerator.getNextFrame", (char**)keywords, &pyobj_frame, &pyobj_gtMask) && |  | 36547 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bgsegm_SyntheticSequenceGenerator.getNextFrame", (char**)keywords, &pyobj_frame, &pyobj_gtMask) &&
| 36596 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 1)) && |  | 36548 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 1)) &&
| 36597 | pyopencv_to_safe(pyobj_gtMask, gtMask, ArgInfo("gtMask", 1)) ) |  | 36549 | pyopencv_to_safe(pyobj_gtMask, gtMask, ArgInfo("gtMask", 1)) )
| 36598 | { |  | 36550 | {
| 36599 | ERRWRAP2(_self_->getNextFrame(frame, gtMask)); |  | 36551 | ERRWRAP2(_self_->getNextFrame(frame, gtMask));
| 36600 | return Py_BuildValue("(NN)", pyopencv_from(frame), pyopencv_from(gtMask)); |  | 36552 | return Py_BuildValue("(NN)", pyopencv_from(frame), pyopencv_from(gtMask));
| 36601 | } |  | 36553 | }
| 36602 |  |  | 36554 |
| 36603 |  |  | 36555 |
| 36604 | pyPopulateArgumentConversionErrors(); |  | 36556 | pyPopulateArgumentConversionErrors();
| 36605 | } |  | 36557 | }
| 36606 |  |  | 36558 |
| 36607 |  |  | 36559 |
| 36608 | { |  | 36560 | {
| 36609 | PyObject* pyobj_frame = NULL; |  | 36561 | PyObject* pyobj_frame = NULL;
| 36610 | UMat frame; |  | 36562 | UMat frame;
| 36611 | PyObject* pyobj_gtMask = NULL; |  | 36563 | PyObject* pyobj_gtMask = NULL;
| 36612 | UMat gtMask; |  | 36564 | UMat gtMask;
| 36613 |  |  | 36565 |
| 36614 | const char* keywords[] = { "frame", "gtMask", NULL }; |  | 36566 | const char* keywords[] = { "frame", "gtMask", NULL };
| 36615 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bgsegm_SyntheticSequenceGenerator.getNextFrame", (char**)keywords, &pyobj_frame, &pyobj_gtMask) && |  | 36567 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bgsegm_SyntheticSequenceGenerator.getNextFrame", (char**)keywords, &pyobj_frame, &pyobj_gtMask) &&
| 36616 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 1)) && |  | 36568 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 1)) &&
| 36617 | pyopencv_to_safe(pyobj_gtMask, gtMask, ArgInfo("gtMask", 1)) ) |  | 36569 | pyopencv_to_safe(pyobj_gtMask, gtMask, ArgInfo("gtMask", 1)) )
| 36618 | { |  | 36570 | {
| 36619 | ERRWRAP2(_self_->getNextFrame(frame, gtMask)); |  | 36571 | ERRWRAP2(_self_->getNextFrame(frame, gtMask));
| 36620 | return Py_BuildValue("(NN)", pyopencv_from(frame), pyopencv_from(gtMask)); |  | 36572 | return Py_BuildValue("(NN)", pyopencv_from(frame), pyopencv_from(gtMask));
| 36621 | } |  | 36573 | }
| 36622 |  |  | 36574 |
| 36623 |  |  | 36575 |
| 36624 | pyPopulateArgumentConversionErrors(); |  | 36576 | pyPopulateArgumentConversionErrors();
| 36625 | } |  | 36577 | }
| 36626 | pyRaiseCVOverloadException("getNextFrame"); |  | 36578 | pyRaiseCVOverloadException("getNextFrame");
| 36627 |  |  | 36579 |
| 36628 | return NULL; |  | 36580 | return NULL;
| 36629 | } |  | 36581 | }
| 36630 |  |  | 36582 |
| 36631 |  |  | 36583 |
| 36632 |  |  | 36584 |
| 36633 | // Tables (bgsegm_SyntheticSequenceGenerator) |  | 36585 | // Tables (bgsegm_SyntheticSequenceGenerator)
| 36634 |  |  | 36586 |
| 36635 | static PyGetSetDef pyopencv_bgsegm_SyntheticSequenceGenerator_getseters[] = |  | 36587 | static PyGetSetDef pyopencv_bgsegm_SyntheticSequenceGenerator_getseters[] =
| 36636 | { |  | 36588 | {
| 36637 | {NULL} /* Sentinel */ |  | 36589 | {NULL} /* Sentinel */
| 36638 | }; |  | 36590 | };
| 36639 |  |  | 36591 |
| 36640 | static PyMethodDef pyopencv_bgsegm_SyntheticSequenceGenerator_methods[] = |  | 36592 | static PyMethodDef pyopencv_bgsegm_SyntheticSequenceGenerator_methods[] =
| 36641 | { |  | 36593 | {
| 36642 | {"getNextFrame", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_SyntheticSequenceGenerator_getNextFrame, 0), "getNextFrame([, frame[, gtMask]]) -> frame, gtMask\n. @brief Obtain the next frame in the sequence.\n. \n. @param frame Output frame.\n. @param gtMask Output ground-truth (reference) segmentation mask object/background."}, |  | 36594 | {"getNextFrame", CV_PY_FN_WITH_KW_(pyopencv_cv_bgsegm_bgsegm_SyntheticSequenceGenerator_getNextFrame, 0), "getNextFrame([, frame[, gtMask]]) -> frame, gtMask\n. @brief Obtain the next frame in the sequence.\n. \n. @param frame Output frame.\n. @param gtMask Output ground-truth (reference) segmentation mask object/background."},
| 36643 |  |  | 36595 |
| 36644 | {NULL, NULL} |  | 36596 | {NULL, NULL}
| 36645 | }; |  | 36597 | };
| 36646 |  |  | 36598 |
| 36647 | // Converter (bgsegm_SyntheticSequenceGenerator) |  | 36599 | // Converter (bgsegm_SyntheticSequenceGenerator)
| 36648 |  |  | 36600 |
| 36649 | template<> |  | 36601 | template<>
| 36650 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::SyntheticSequenceGenerator> > |  | 36602 | struct PyOpenCV_Converter< Ptr<cv::bgsegm::SyntheticSequenceGenerator> >
| 36651 | { |  | 36603 | {
| 36652 | static PyObject* from(const Ptr<cv::bgsegm::SyntheticSequenceGenerator>& r) |  | 36604 | static PyObject* from(const Ptr<cv::bgsegm::SyntheticSequenceGenerator>& r)
| 36653 | { |  | 36605 | {
| 36654 | return pyopencv_bgsegm_SyntheticSequenceGenerator_Instance(r); |  | 36606 | return pyopencv_bgsegm_SyntheticSequenceGenerator_Instance(r);
| 36655 | } |  | 36607 | }
| 36656 | static bool to(PyObject* src, Ptr<cv::bgsegm::SyntheticSequenceGenerator>& dst, const ArgInfo& info) |  | 36608 | static bool to(PyObject* src, Ptr<cv::bgsegm::SyntheticSequenceGenerator>& dst, const ArgInfo& info)
| 36657 | { |  | 36609 | {
| 36658 | if(!src || src == Py_None) |  | 36610 | if(!src || src == Py_None)
| 36659 | return true; |  | 36611 | return true;
| 36660 | Ptr<cv::bgsegm::SyntheticSequenceGenerator> * dst_; |  | 36612 | Ptr<cv::bgsegm::SyntheticSequenceGenerator> * dst_;
| 36661 | if (pyopencv_bgsegm_SyntheticSequenceGenerator_getp(src, dst_)) |  | 36613 | if (pyopencv_bgsegm_SyntheticSequenceGenerator_getp(src, dst_))
| 36662 | { |  | 36614 | {
| 36663 | dst = *dst_; |  | 36615 | dst = *dst_;
| 36664 | return true; |  | 36616 | return true;
| 36665 | } |  | 36617 | }
| 36666 |  |  | 36618 |
| 36667 | failmsg("Expected Ptr<cv::bgsegm::SyntheticSequenceGenerator> for argument '%s'", info.name); |  | 36619 | failmsg("Expected Ptr<cv::bgsegm::SyntheticSequenceGenerator> for argument '%s'", info.name);
| 36668 | return false; |  | 36620 | return false;
| 36669 | } |  | 36621 | }
| 36670 | }; |  | 36622 | };
| 36671 |  |  | 36623 |
| 36672 | //================================================================================ |  | 36624 | //================================================================================
| 36673 | // bioinspired_Retina (Generic) |  | 36625 | // bioinspired_Retina (Generic)
| 36674 | //================================================================================ |  | 36626 | //================================================================================
| 36675 |  |  | 36627 |
| 36676 | // GetSet (bioinspired_Retina) |  | 36628 | // GetSet (bioinspired_Retina)
| 36677 |  |  | 36629 |
| 36678 |  |  | 36630 |
| 36679 |  |  | 36631 |
| 36680 | // Methods (bioinspired_Retina) |  | 36632 | // Methods (bioinspired_Retina)
| 36681 |  |  | 36633 |
| 36682 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_activateContoursProcessing(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36634 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_activateContoursProcessing(PyObject* self, PyObject* py_args, PyObject* kw)
| 36683 | { |  | 36635 | {
| 36684 | using namespace cv::bioinspired; |  | 36636 | using namespace cv::bioinspired;
| 36685 |  |  | 36637 |
| 36686 |  |  | 36638 |
| 36687 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36639 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36688 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36640 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36689 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36641 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36690 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36642 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 36691 | PyObject* pyobj_activate = NULL; |  | 36643 | PyObject* pyobj_activate = NULL;
| 36692 | bool activate=0; |  | 36644 | bool activate=0;
| 36693 |  |  | 36645 |
| 36694 | const char* keywords[] = { "activate", NULL }; |  | 36646 | const char* keywords[] = { "activate", NULL };
| 36695 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.activateContoursProcessing", (char**)keywords, &pyobj_activate) && |  | 36647 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.activateContoursProcessing", (char**)keywords, &pyobj_activate) &&
| 36696 | pyopencv_to_safe(pyobj_activate, activate, ArgInfo("activate", 0)) ) |  | 36648 | pyopencv_to_safe(pyobj_activate, activate, ArgInfo("activate", 0)) )
| 36697 | { |  | 36649 | {
| 36698 | ERRWRAP2(_self_->activateContoursProcessing(activate)); |  | 36650 | ERRWRAP2(_self_->activateContoursProcessing(activate));
| 36699 | Py_RETURN_NONE; |  | 36651 | Py_RETURN_NONE;
| 36700 | } |  | 36652 | }
| 36701 |  |  | 36653 |
| 36702 | return NULL; |  | 36654 | return NULL;
| 36703 | } |  | 36655 | }
| 36704 |  |  | 36656 |
| 36705 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_activateMovingContoursProcessing(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36657 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_activateMovingContoursProcessing(PyObject* self, PyObject* py_args, PyObject* kw)
| 36706 | { |  | 36658 | {
| 36707 | using namespace cv::bioinspired; |  | 36659 | using namespace cv::bioinspired;
| 36708 |  |  | 36660 |
| 36709 |  |  | 36661 |
| 36710 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36662 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36711 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36663 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36712 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36664 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36713 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36665 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 36714 | PyObject* pyobj_activate = NULL; |  | 36666 | PyObject* pyobj_activate = NULL;
| 36715 | bool activate=0; |  | 36667 | bool activate=0;
| 36716 |  |  | 36668 |
| 36717 | const char* keywords[] = { "activate", NULL }; |  | 36669 | const char* keywords[] = { "activate", NULL };
| 36718 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.activateMovingContoursProcessing", (char**)keywords, &pyobj_activate) && |  | 36670 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.activateMovingContoursProcessing", (char**)keywords, &pyobj_activate) &&
| 36719 | pyopencv_to_safe(pyobj_activate, activate, ArgInfo("activate", 0)) ) |  | 36671 | pyopencv_to_safe(pyobj_activate, activate, ArgInfo("activate", 0)) )
| 36720 | { |  | 36672 | {
| 36721 | ERRWRAP2(_self_->activateMovingContoursProcessing(activate)); |  | 36673 | ERRWRAP2(_self_->activateMovingContoursProcessing(activate));
| 36722 | Py_RETURN_NONE; |  | 36674 | Py_RETURN_NONE;
| 36723 | } |  | 36675 | }
| 36724 |  |  | 36676 |
| 36725 | return NULL; |  | 36677 | return NULL;
| 36726 | } |  | 36678 | }
| 36727 |  |  | 36679 |
| 36728 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_applyFastToneMapping(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36680 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_applyFastToneMapping(PyObject* self, PyObject* py_args, PyObject* kw)
| 36729 | { |  | 36681 | {
| 36730 | using namespace cv::bioinspired; |  | 36682 | using namespace cv::bioinspired;
| 36731 |  |  | 36683 |
| 36732 |  |  | 36684 |
| 36733 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36685 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36734 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36686 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36735 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36687 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36736 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36688 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 36737 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36689 | pyPrepareArgumentConversionErrorsStorage(2);
| 36738 |  |  | 36690 |
| 36739 | { |  | 36691 | {
| 36740 | PyObject* pyobj_inputImage = NULL; |  | 36692 | PyObject* pyobj_inputImage = NULL;
| 36741 | Mat inputImage; |  | 36693 | Mat inputImage;
| 36742 | PyObject* pyobj_outputToneMappedImage = NULL; |  | 36694 | PyObject* pyobj_outputToneMappedImage = NULL;
| 36743 | Mat outputToneMappedImage; |  | 36695 | Mat outputToneMappedImage;
| 36744 |  |  | 36696 |
| 36745 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL }; |  | 36697 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL };
| 36746 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_Retina.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) && |  | 36698 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_Retina.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) &&
| 36747 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) && |  | 36699 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) &&
| 36748 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) ) |  | 36700 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) )
| 36749 | { |  | 36701 | {
| 36750 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage)); |  | 36702 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage));
| 36751 | return pyopencv_from(outputToneMappedImage); |  | 36703 | return pyopencv_from(outputToneMappedImage);
| 36752 | } |  | 36704 | }
| 36753 |  |  | 36705 |
| 36754 |  |  | 36706 |
| 36755 | pyPopulateArgumentConversionErrors(); |  | 36707 | pyPopulateArgumentConversionErrors();
| 36756 | } |  | 36708 | }
| 36757 |  |  | 36709 |
| 36758 |  |  | 36710 |
| 36759 | { |  | 36711 | {
| 36760 | PyObject* pyobj_inputImage = NULL; |  | 36712 | PyObject* pyobj_inputImage = NULL;
| 36761 | UMat inputImage; |  | 36713 | UMat inputImage;
| 36762 | PyObject* pyobj_outputToneMappedImage = NULL; |  | 36714 | PyObject* pyobj_outputToneMappedImage = NULL;
| 36763 | UMat outputToneMappedImage; |  | 36715 | UMat outputToneMappedImage;
| 36764 |  |  | 36716 |
| 36765 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL }; |  | 36717 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL };
| 36766 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_Retina.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) && |  | 36718 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_Retina.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) &&
| 36767 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) && |  | 36719 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) &&
| 36768 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) ) |  | 36720 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) )
| 36769 | { |  | 36721 | {
| 36770 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage)); |  | 36722 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage));
| 36771 | return pyopencv_from(outputToneMappedImage); |  | 36723 | return pyopencv_from(outputToneMappedImage);
| 36772 | } |  | 36724 | }
| 36773 |  |  | 36725 |
| 36774 |  |  | 36726 |
| 36775 | pyPopulateArgumentConversionErrors(); |  | 36727 | pyPopulateArgumentConversionErrors();
| 36776 | } |  | 36728 | }
| 36777 | pyRaiseCVOverloadException("applyFastToneMapping"); |  | 36729 | pyRaiseCVOverloadException("applyFastToneMapping");
| 36778 |  |  | 36730 |
| 36779 | return NULL; |  | 36731 | return NULL;
| 36780 | } |  | 36732 | }
| 36781 |  |  | 36733 |
| 36782 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_clearBuffers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36734 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_clearBuffers(PyObject* self, PyObject* py_args, PyObject* kw)
| 36783 | { |  | 36735 | {
| 36784 | using namespace cv::bioinspired; |  | 36736 | using namespace cv::bioinspired;
| 36785 |  |  | 36737 |
| 36786 |  |  | 36738 |
| 36787 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36739 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36788 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36740 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36789 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36741 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36790 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36742 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 36791 |  |  | 36743 |
| 36792 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36744 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 36793 | { |  | 36745 | {
| 36794 | ERRWRAP2(_self_->clearBuffers()); |  | 36746 | ERRWRAP2(_self_->clearBuffers());
| 36795 | Py_RETURN_NONE; |  | 36747 | Py_RETURN_NONE;
| 36796 | } |  | 36748 | }
| 36797 |  |  | 36749 |
| 36798 | return NULL; |  | 36750 | return NULL;
| 36799 | } |  | 36751 | }
| 36800 |  |  | 36752 |
| 36801 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36753 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 36802 | { |  | 36754 | {
| 36803 | using namespace cv::bioinspired; |  | 36755 | using namespace cv::bioinspired;
| 36804 |  |  | 36756 |
| 36805 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36757 | pyPrepareArgumentConversionErrorsStorage(2);
| 36806 |  |  | 36758 |
| 36807 | { |  | 36759 | {
| 36808 | PyObject* pyobj_inputSize = NULL; |  | 36760 | PyObject* pyobj_inputSize = NULL;
| 36809 | Size inputSize; |  | 36761 | Size inputSize;
| 36810 | Ptr<Retina> retval; |  | 36762 | Ptr<Retina> retval;
| 36811 |  |  | 36763 |
| 36812 | const char* keywords[] = { "inputSize", NULL }; |  | 36764 | const char* keywords[] = { "inputSize", NULL };
| 36813 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.create", (char**)keywords, &pyobj_inputSize) && |  | 36765 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.create", (char**)keywords, &pyobj_inputSize) &&
| 36814 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) ) |  | 36766 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) )
| 36815 | { |  | 36767 | {
| 36816 | ERRWRAP2(retval = cv::bioinspired::Retina::create(inputSize)); |  | 36768 | ERRWRAP2(retval = cv::bioinspired::Retina::create(inputSize));
| 36817 | return pyopencv_from(retval); |  | 36769 | return pyopencv_from(retval);
| 36818 | } |  | 36770 | }
| 36819 |  |  | 36771 |
| 36820 |  |  | 36772 |
| 36821 | pyPopulateArgumentConversionErrors(); |  | 36773 | pyPopulateArgumentConversionErrors();
| 36822 | } |  | 36774 | }
| 36823 |  |  | 36775 |
| 36824 |  |  | 36776 |
| 36825 | { |  | 36777 | {
| 36826 | PyObject* pyobj_inputSize = NULL; |  | 36778 | PyObject* pyobj_inputSize = NULL;
| 36827 | Size inputSize; |  | 36779 | Size inputSize;
| 36828 | PyObject* pyobj_colorMode = NULL; |  | 36780 | PyObject* pyobj_colorMode = NULL;
| 36829 | bool colorMode=0; |  | 36781 | bool colorMode=0;
| 36830 | PyObject* pyobj_colorSamplingMethod = NULL; |  | 36782 | PyObject* pyobj_colorSamplingMethod = NULL;
| 36831 | int colorSamplingMethod=RETINA_COLOR_BAYER; |  | 36783 | int colorSamplingMethod=RETINA_COLOR_BAYER;
| 36832 | PyObject* pyobj_useRetinaLogSampling = NULL; |  | 36784 | PyObject* pyobj_useRetinaLogSampling = NULL;
| 36833 | bool useRetinaLogSampling=false; |  | 36785 | bool useRetinaLogSampling=false;
| 36834 | PyObject* pyobj_reductionFactor = NULL; |  | 36786 | PyObject* pyobj_reductionFactor = NULL;
| 36835 | float reductionFactor=1.0f; |  | 36787 | float reductionFactor=1.0f;
| 36836 | PyObject* pyobj_samplingStrength = NULL; |  | 36788 | PyObject* pyobj_samplingStrength = NULL;
| 36837 | float samplingStrength=10.0f; |  | 36789 | float samplingStrength=10.0f;
| 36838 | Ptr<Retina> retval; |  | 36790 | Ptr<Retina> retval;
| 36839 |  |  | 36791 |
| 36840 | const char* keywords[] = { "inputSize", "colorMode", "colorSamplingMethod", "useRetinaLogSampling", "reductionFactor", "samplingStrength", NULL }; |  | 36792 | const char* keywords[] = { "inputSize", "colorMode", "colorSamplingMethod", "useRetinaLogSampling", "reductionFactor", "samplingStrength", NULL };
| 36841 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOO:bioinspired_Retina.create", (char**)keywords, &pyobj_inputSize, &pyobj_colorMode, &pyobj_colorSamplingMethod, &pyobj_useRetinaLogSampling, &pyobj_reductionFactor, &pyobj_samplingStrength) && |  | 36793 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOO:bioinspired_Retina.create", (char**)keywords, &pyobj_inputSize, &pyobj_colorMode, &pyobj_colorSamplingMethod, &pyobj_useRetinaLogSampling, &pyobj_reductionFactor, &pyobj_samplingStrength) &&
| 36842 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) && |  | 36794 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) &&
| 36843 | pyopencv_to_safe(pyobj_colorMode, colorMode, ArgInfo("colorMode", 0)) && |  | 36795 | pyopencv_to_safe(pyobj_colorMode, colorMode, ArgInfo("colorMode", 0)) &&
| 36844 | pyopencv_to_safe(pyobj_colorSamplingMethod, colorSamplingMethod, ArgInfo("colorSamplingMethod", 0)) && |  | 36796 | pyopencv_to_safe(pyobj_colorSamplingMethod, colorSamplingMethod, ArgInfo("colorSamplingMethod", 0)) &&
| 36845 | pyopencv_to_safe(pyobj_useRetinaLogSampling, useRetinaLogSampling, ArgInfo("useRetinaLogSampling", 0)) && |  | 36797 | pyopencv_to_safe(pyobj_useRetinaLogSampling, useRetinaLogSampling, ArgInfo("useRetinaLogSampling", 0)) &&
| 36846 | pyopencv_to_safe(pyobj_reductionFactor, reductionFactor, ArgInfo("reductionFactor", 0)) && |  | 36798 | pyopencv_to_safe(pyobj_reductionFactor, reductionFactor, ArgInfo("reductionFactor", 0)) &&
| 36847 | pyopencv_to_safe(pyobj_samplingStrength, samplingStrength, ArgInfo("samplingStrength", 0)) ) |  | 36799 | pyopencv_to_safe(pyobj_samplingStrength, samplingStrength, ArgInfo("samplingStrength", 0)) )
| 36848 | { |  | 36800 | {
| 36849 | ERRWRAP2(retval = cv::bioinspired::Retina::create(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrength)); |  | 36801 | ERRWRAP2(retval = cv::bioinspired::Retina::create(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrength));
| 36850 | return pyopencv_from(retval); |  | 36802 | return pyopencv_from(retval);
| 36851 | } |  | 36803 | }
| 36852 |  |  | 36804 |
| 36853 |  |  | 36805 |
| 36854 | pyPopulateArgumentConversionErrors(); |  | 36806 | pyPopulateArgumentConversionErrors();
| 36855 | } |  | 36807 | }
| 36856 | pyRaiseCVOverloadException("create"); |  | 36808 | pyRaiseCVOverloadException("create");
| 36857 |  |  | 36809 |
| 36858 | return NULL; |  | 36810 | return NULL;
| 36859 | } |  | 36811 | }
| 36860 |  |  | 36812 |
| 36861 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getInputSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36813 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getInputSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 36862 | { |  | 36814 | {
| 36863 | using namespace cv::bioinspired; |  | 36815 | using namespace cv::bioinspired;
| 36864 |  |  | 36816 |
| 36865 |  |  | 36817 |
| 36866 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36818 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36867 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36819 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36868 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36820 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36869 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36821 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 36870 | Size retval; |  | 36822 | Size retval;
| 36871 |  |  | 36823 |
| 36872 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36824 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 36873 | { |  | 36825 | {
| 36874 | ERRWRAP2(retval = _self_->getInputSize()); |  | 36826 | ERRWRAP2(retval = _self_->getInputSize());
| 36875 | return pyopencv_from(retval); |  | 36827 | return pyopencv_from(retval);
| 36876 | } |  | 36828 | }
| 36877 |  |  | 36829 |
| 36878 | return NULL; |  | 36830 | return NULL;
| 36879 | } |  | 36831 | }
| 36880 |  |  | 36832 |
| 36881 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getMagno(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36833 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getMagno(PyObject* self, PyObject* py_args, PyObject* kw)
| 36882 | { |  | 36834 | {
| 36883 | using namespace cv::bioinspired; |  | 36835 | using namespace cv::bioinspired;
| 36884 |  |  | 36836 |
| 36885 |  |  | 36837 |
| 36886 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36838 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36887 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36839 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36888 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36840 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36889 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36841 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 36890 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36842 | pyPrepareArgumentConversionErrorsStorage(2);
| 36891 |  |  | 36843 |
| 36892 | { |  | 36844 | {
| 36893 | PyObject* pyobj_retinaOutput_magno = NULL; |  | 36845 | PyObject* pyobj_retinaOutput_magno = NULL;
| 36894 | Mat retinaOutput_magno; |  | 36846 | Mat retinaOutput_magno;
| 36895 |  |  | 36847 |
| 36896 | const char* keywords[] = { "retinaOutput_magno", NULL }; |  | 36848 | const char* keywords[] = { "retinaOutput_magno", NULL };
| 36897 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagno", (char**)keywords, &pyobj_retinaOutput_magno) && |  | 36849 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagno", (char**)keywords, &pyobj_retinaOutput_magno) &&
| 36898 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) ) |  | 36850 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) )
| 36899 | { |  | 36851 | {
| 36900 | ERRWRAP2(_self_->getMagno(retinaOutput_magno)); |  | 36852 | ERRWRAP2(_self_->getMagno(retinaOutput_magno));
| 36901 | return pyopencv_from(retinaOutput_magno); |  | 36853 | return pyopencv_from(retinaOutput_magno);
| 36902 | } |  | 36854 | }
| 36903 |  |  | 36855 |
| 36904 |  |  | 36856 |
| 36905 | pyPopulateArgumentConversionErrors(); |  | 36857 | pyPopulateArgumentConversionErrors();
| 36906 | } |  | 36858 | }
| 36907 |  |  | 36859 |
| 36908 |  |  | 36860 |
| 36909 | { |  | 36861 | {
| 36910 | PyObject* pyobj_retinaOutput_magno = NULL; |  | 36862 | PyObject* pyobj_retinaOutput_magno = NULL;
| 36911 | UMat retinaOutput_magno; |  | 36863 | UMat retinaOutput_magno;
| 36912 |  |  | 36864 |
| 36913 | const char* keywords[] = { "retinaOutput_magno", NULL }; |  | 36865 | const char* keywords[] = { "retinaOutput_magno", NULL };
| 36914 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagno", (char**)keywords, &pyobj_retinaOutput_magno) && |  | 36866 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagno", (char**)keywords, &pyobj_retinaOutput_magno) &&
| 36915 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) ) |  | 36867 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) )
| 36916 | { |  | 36868 | {
| 36917 | ERRWRAP2(_self_->getMagno(retinaOutput_magno)); |  | 36869 | ERRWRAP2(_self_->getMagno(retinaOutput_magno));
| 36918 | return pyopencv_from(retinaOutput_magno); |  | 36870 | return pyopencv_from(retinaOutput_magno);
| 36919 | } |  | 36871 | }
| 36920 |  |  | 36872 |
| 36921 |  |  | 36873 |
| 36922 | pyPopulateArgumentConversionErrors(); |  | 36874 | pyPopulateArgumentConversionErrors();
| 36923 | } |  | 36875 | }
| 36924 | pyRaiseCVOverloadException("getMagno"); |  | 36876 | pyRaiseCVOverloadException("getMagno");
| 36925 |  |  | 36877 |
| 36926 | return NULL; |  | 36878 | return NULL;
| 36927 | } |  | 36879 | }
| 36928 |  |  | 36880 |
| 36929 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getMagnoRAW(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36881 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getMagnoRAW(PyObject* self, PyObject* py_args, PyObject* kw)
| 36930 | { |  | 36882 | {
| 36931 | using namespace cv::bioinspired; |  | 36883 | using namespace cv::bioinspired;
| 36932 |  |  | 36884 |
| 36933 |  |  | 36885 |
| 36934 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36886 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36935 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36887 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36936 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36888 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36937 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36889 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 36938 | pyPrepareArgumentConversionErrorsStorage(3); |  | 36890 | pyPrepareArgumentConversionErrorsStorage(3);
| 36939 |  |  | 36891 |
| 36940 | { |  | 36892 | {
| 36941 | PyObject* pyobj_retinaOutput_magno = NULL; |  | 36893 | PyObject* pyobj_retinaOutput_magno = NULL;
| 36942 | Mat retinaOutput_magno; |  | 36894 | Mat retinaOutput_magno;
| 36943 |  |  | 36895 |
| 36944 | const char* keywords[] = { "retinaOutput_magno", NULL }; |  | 36896 | const char* keywords[] = { "retinaOutput_magno", NULL };
| 36945 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagnoRAW", (char**)keywords, &pyobj_retinaOutput_magno) && |  | 36897 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagnoRAW", (char**)keywords, &pyobj_retinaOutput_magno) &&
| 36946 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) ) |  | 36898 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) )
| 36947 | { |  | 36899 | {
| 36948 | ERRWRAP2(_self_->getMagnoRAW(retinaOutput_magno)); |  | 36900 | ERRWRAP2(_self_->getMagnoRAW(retinaOutput_magno));
| 36949 | return pyopencv_from(retinaOutput_magno); |  | 36901 | return pyopencv_from(retinaOutput_magno);
| 36950 | } |  | 36902 | }
| 36951 |  |  | 36903 |
| 36952 |  |  | 36904 |
| 36953 | pyPopulateArgumentConversionErrors(); |  | 36905 | pyPopulateArgumentConversionErrors();
| 36954 | } |  | 36906 | }
| 36955 |  |  | 36907 |
| 36956 |  |  | 36908 |
| 36957 | { |  | 36909 | {
| 36958 | Mat retval; |  | 36910 | Mat retval;
| 36959 |  |  | 36911 |
| 36960 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36912 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 36961 | { |  | 36913 | {
| 36962 | ERRWRAP2(retval = _self_->getMagnoRAW()); |  | 36914 | ERRWRAP2(retval = _self_->getMagnoRAW());
| 36963 | return pyopencv_from(retval); |  | 36915 | return pyopencv_from(retval);
| 36964 | } |  | 36916 | }
| 36965 |  |  | 36917 |
| 36966 |  |  | 36918 |
| 36967 | pyPopulateArgumentConversionErrors(); |  | 36919 | pyPopulateArgumentConversionErrors();
| 36968 | } |  | 36920 | }
| 36969 |  |  | 36921 |
| 36970 |  |  | 36922 |
| 36971 | { |  | 36923 | {
| 36972 | PyObject* pyobj_retinaOutput_magno = NULL; |  | 36924 | PyObject* pyobj_retinaOutput_magno = NULL;
| 36973 | UMat retinaOutput_magno; |  | 36925 | UMat retinaOutput_magno;
| 36974 |  |  | 36926 |
| 36975 | const char* keywords[] = { "retinaOutput_magno", NULL }; |  | 36927 | const char* keywords[] = { "retinaOutput_magno", NULL };
| 36976 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagnoRAW", (char**)keywords, &pyobj_retinaOutput_magno) && |  | 36928 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getMagnoRAW", (char**)keywords, &pyobj_retinaOutput_magno) &&
| 36977 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) ) |  | 36929 | pyopencv_to_safe(pyobj_retinaOutput_magno, retinaOutput_magno, ArgInfo("retinaOutput_magno", 1)) )
| 36978 | { |  | 36930 | {
| 36979 | ERRWRAP2(_self_->getMagnoRAW(retinaOutput_magno)); |  | 36931 | ERRWRAP2(_self_->getMagnoRAW(retinaOutput_magno));
| 36980 | return pyopencv_from(retinaOutput_magno); |  | 36932 | return pyopencv_from(retinaOutput_magno);
| 36981 | } |  | 36933 | }
| 36982 |  |  | 36934 |
| 36983 |  |  | 36935 |
| 36984 | pyPopulateArgumentConversionErrors(); |  | 36936 | pyPopulateArgumentConversionErrors();
| 36985 | } |  | 36937 | }
| 36986 | pyRaiseCVOverloadException("getMagnoRAW"); |  | 36938 | pyRaiseCVOverloadException("getMagnoRAW");
| 36987 |  |  | 36939 |
| 36988 | return NULL; |  | 36940 | return NULL;
| 36989 | } |  | 36941 | }
| 36990 |  |  | 36942 |
| 36991 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getOutputSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36943 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getOutputSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 36992 | { |  | 36944 | {
| 36993 | using namespace cv::bioinspired; |  | 36945 | using namespace cv::bioinspired;
| 36994 |  |  | 36946 |
| 36995 |  |  | 36947 |
| 36996 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36948 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 36997 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36949 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 36998 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36950 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 36999 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36951 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37000 | Size retval; |  | 36952 | Size retval;
| 37001 |  |  | 36953 |
| 37002 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 36954 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37003 | { |  | 36955 | {
| 37004 | ERRWRAP2(retval = _self_->getOutputSize()); |  | 36956 | ERRWRAP2(retval = _self_->getOutputSize());
| 37005 | return pyopencv_from(retval); |  | 36957 | return pyopencv_from(retval);
| 37006 | } |  | 36958 | }
| 37007 |  |  | 36959 |
| 37008 | return NULL; |  | 36960 | return NULL;
| 37009 | } |  | 36961 | }
| 37010 |  |  | 36962 |
| 37011 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getParvo(PyObject* self, PyObject* py_args, PyObject* kw) |  | 36963 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getParvo(PyObject* self, PyObject* py_args, PyObject* kw)
| 37012 | { |  | 36964 | {
| 37013 | using namespace cv::bioinspired; |  | 36965 | using namespace cv::bioinspired;
| 37014 |  |  | 36966 |
| 37015 |  |  | 36967 |
| 37016 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 36968 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37017 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 36969 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37018 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 36970 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37019 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 36971 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37020 | pyPrepareArgumentConversionErrorsStorage(2); |  | 36972 | pyPrepareArgumentConversionErrorsStorage(2);
| 37021 |  |  | 36973 |
| 37022 | { |  | 36974 | {
| 37023 | PyObject* pyobj_retinaOutput_parvo = NULL; |  | 36975 | PyObject* pyobj_retinaOutput_parvo = NULL;
| 37024 | Mat retinaOutput_parvo; |  | 36976 | Mat retinaOutput_parvo;
| 37025 |  |  | 36977 |
| 37026 | const char* keywords[] = { "retinaOutput_parvo", NULL }; |  | 36978 | const char* keywords[] = { "retinaOutput_parvo", NULL };
| 37027 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvo", (char**)keywords, &pyobj_retinaOutput_parvo) && |  | 36979 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvo", (char**)keywords, &pyobj_retinaOutput_parvo) &&
| 37028 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) ) |  | 36980 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) )
| 37029 | { |  | 36981 | {
| 37030 | ERRWRAP2(_self_->getParvo(retinaOutput_parvo)); |  | 36982 | ERRWRAP2(_self_->getParvo(retinaOutput_parvo));
| 37031 | return pyopencv_from(retinaOutput_parvo); |  | 36983 | return pyopencv_from(retinaOutput_parvo);
| 37032 | } |  | 36984 | }
| 37033 |  |  | 36985 |
| 37034 |  |  | 36986 |
| 37035 | pyPopulateArgumentConversionErrors(); |  | 36987 | pyPopulateArgumentConversionErrors();
| 37036 | } |  | 36988 | }
| 37037 |  |  | 36989 |
| 37038 |  |  | 36990 |
| 37039 | { |  | 36991 | {
| 37040 | PyObject* pyobj_retinaOutput_parvo = NULL; |  | 36992 | PyObject* pyobj_retinaOutput_parvo = NULL;
| 37041 | UMat retinaOutput_parvo; |  | 36993 | UMat retinaOutput_parvo;
| 37042 |  |  | 36994 |
| 37043 | const char* keywords[] = { "retinaOutput_parvo", NULL }; |  | 36995 | const char* keywords[] = { "retinaOutput_parvo", NULL };
| 37044 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvo", (char**)keywords, &pyobj_retinaOutput_parvo) && |  | 36996 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvo", (char**)keywords, &pyobj_retinaOutput_parvo) &&
| 37045 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) ) |  | 36997 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) )
| 37046 | { |  | 36998 | {
| 37047 | ERRWRAP2(_self_->getParvo(retinaOutput_parvo)); |  | 36999 | ERRWRAP2(_self_->getParvo(retinaOutput_parvo));
| 37048 | return pyopencv_from(retinaOutput_parvo); |  | 37000 | return pyopencv_from(retinaOutput_parvo);
| 37049 | } |  | 37001 | }
| 37050 |  |  | 37002 |
| 37051 |  |  | 37003 |
| 37052 | pyPopulateArgumentConversionErrors(); |  | 37004 | pyPopulateArgumentConversionErrors();
| 37053 | } |  | 37005 | }
| 37054 | pyRaiseCVOverloadException("getParvo"); |  | 37006 | pyRaiseCVOverloadException("getParvo");
| 37055 |  |  | 37007 |
| 37056 | return NULL; |  | 37008 | return NULL;
| 37057 | } |  | 37009 | }
| 37058 |  |  | 37010 |
| 37059 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getParvoRAW(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37011 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_getParvoRAW(PyObject* self, PyObject* py_args, PyObject* kw)
| 37060 | { |  | 37012 | {
| 37061 | using namespace cv::bioinspired; |  | 37013 | using namespace cv::bioinspired;
| 37062 |  |  | 37014 |
| 37063 |  |  | 37015 |
| 37064 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37016 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37065 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37017 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37066 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37018 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37067 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37019 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37068 | pyPrepareArgumentConversionErrorsStorage(3); |  | 37020 | pyPrepareArgumentConversionErrorsStorage(3);
| 37069 |  |  | 37021 |
| 37070 | { |  | 37022 | {
| 37071 | PyObject* pyobj_retinaOutput_parvo = NULL; |  | 37023 | PyObject* pyobj_retinaOutput_parvo = NULL;
| 37072 | Mat retinaOutput_parvo; |  | 37024 | Mat retinaOutput_parvo;
| 37073 |  |  | 37025 |
| 37074 | const char* keywords[] = { "retinaOutput_parvo", NULL }; |  | 37026 | const char* keywords[] = { "retinaOutput_parvo", NULL };
| 37075 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvoRAW", (char**)keywords, &pyobj_retinaOutput_parvo) && |  | 37027 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvoRAW", (char**)keywords, &pyobj_retinaOutput_parvo) &&
| 37076 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) ) |  | 37028 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) )
| 37077 | { |  | 37029 | {
| 37078 | ERRWRAP2(_self_->getParvoRAW(retinaOutput_parvo)); |  | 37030 | ERRWRAP2(_self_->getParvoRAW(retinaOutput_parvo));
| 37079 | return pyopencv_from(retinaOutput_parvo); |  | 37031 | return pyopencv_from(retinaOutput_parvo);
| 37080 | } |  | 37032 | }
| 37081 |  |  | 37033 |
| 37082 |  |  | 37034 |
| 37083 | pyPopulateArgumentConversionErrors(); |  | 37035 | pyPopulateArgumentConversionErrors();
| 37084 | } |  | 37036 | }
| 37085 |  |  | 37037 |
| 37086 |  |  | 37038 |
| 37087 | { |  | 37039 | {
| 37088 | Mat retval; |  | 37040 | Mat retval;
| 37089 |  |  | 37041 |
| 37090 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37042 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37091 | { |  | 37043 | {
| 37092 | ERRWRAP2(retval = _self_->getParvoRAW()); |  | 37044 | ERRWRAP2(retval = _self_->getParvoRAW());
| 37093 | return pyopencv_from(retval); |  | 37045 | return pyopencv_from(retval);
| 37094 | } |  | 37046 | }
| 37095 |  |  | 37047 |
| 37096 |  |  | 37048 |
| 37097 | pyPopulateArgumentConversionErrors(); |  | 37049 | pyPopulateArgumentConversionErrors();
| 37098 | } |  | 37050 | }
| 37099 |  |  | 37051 |
| 37100 |  |  | 37052 |
| 37101 | { |  | 37053 | {
| 37102 | PyObject* pyobj_retinaOutput_parvo = NULL; |  | 37054 | PyObject* pyobj_retinaOutput_parvo = NULL;
| 37103 | UMat retinaOutput_parvo; |  | 37055 | UMat retinaOutput_parvo;
| 37104 |  |  | 37056 |
| 37105 | const char* keywords[] = { "retinaOutput_parvo", NULL }; |  | 37057 | const char* keywords[] = { "retinaOutput_parvo", NULL };
| 37106 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvoRAW", (char**)keywords, &pyobj_retinaOutput_parvo) && |  | 37058 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_Retina.getParvoRAW", (char**)keywords, &pyobj_retinaOutput_parvo) &&
| 37107 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) ) |  | 37059 | pyopencv_to_safe(pyobj_retinaOutput_parvo, retinaOutput_parvo, ArgInfo("retinaOutput_parvo", 1)) )
| 37108 | { |  | 37060 | {
| 37109 | ERRWRAP2(_self_->getParvoRAW(retinaOutput_parvo)); |  | 37061 | ERRWRAP2(_self_->getParvoRAW(retinaOutput_parvo));
| 37110 | return pyopencv_from(retinaOutput_parvo); |  | 37062 | return pyopencv_from(retinaOutput_parvo);
| 37111 | } |  | 37063 | }
| 37112 |  |  | 37064 |
| 37113 |  |  | 37065 |
| 37114 | pyPopulateArgumentConversionErrors(); |  | 37066 | pyPopulateArgumentConversionErrors();
| 37115 | } |  | 37067 | }
| 37116 | pyRaiseCVOverloadException("getParvoRAW"); |  | 37068 | pyRaiseCVOverloadException("getParvoRAW");
| 37117 |  |  | 37069 |
| 37118 | return NULL; |  | 37070 | return NULL;
| 37119 | } |  | 37071 | }
| 37120 |  |  | 37072 |
| 37121 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_printSetup(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37073 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_printSetup(PyObject* self, PyObject* py_args, PyObject* kw)
| 37122 | { |  | 37074 | {
| 37123 | using namespace cv::bioinspired; |  | 37075 | using namespace cv::bioinspired;
| 37124 |  |  | 37076 |
| 37125 |  |  | 37077 |
| 37126 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37078 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37127 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37079 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37128 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37080 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37129 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37081 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37130 | String retval; |  | 37082 | String retval;
| 37131 |  |  | 37083 |
| 37132 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37084 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37133 | { |  | 37085 | {
| 37134 | ERRWRAP2(retval = _self_->printSetup()); |  | 37086 | ERRWRAP2(retval = _self_->printSetup());
| 37135 | return pyopencv_from(retval); |  | 37087 | return pyopencv_from(retval);
| 37136 | } |  | 37088 | }
| 37137 |  |  | 37089 |
| 37138 | return NULL; |  | 37090 | return NULL;
| 37139 | } |  | 37091 | }
| 37140 |  |  | 37092 |
| 37141 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_run(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37093 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_run(PyObject* self, PyObject* py_args, PyObject* kw)
| 37142 | { |  | 37094 | {
| 37143 | using namespace cv::bioinspired; |  | 37095 | using namespace cv::bioinspired;
| 37144 |  |  | 37096 |
| 37145 |  |  | 37097 |
| 37146 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37098 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37147 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37099 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37148 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37100 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37149 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37101 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37150 | pyPrepareArgumentConversionErrorsStorage(2); |  | 37102 | pyPrepareArgumentConversionErrorsStorage(2);
| 37151 |  |  | 37103 |
| 37152 | { |  | 37104 | {
| 37153 | PyObject* pyobj_inputImage = NULL; |  | 37105 | PyObject* pyobj_inputImage = NULL;
| 37154 | Mat inputImage; |  | 37106 | Mat inputImage;
| 37155 |  |  | 37107 |
| 37156 | const char* keywords[] = { "inputImage", NULL }; |  | 37108 | const char* keywords[] = { "inputImage", NULL };
| 37157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.run", (char**)keywords, &pyobj_inputImage) && |  | 37109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.run", (char**)keywords, &pyobj_inputImage) &&
| 37158 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) ) |  | 37110 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) )
| 37159 | { |  | 37111 | {
| 37160 | ERRWRAP2(_self_->run(inputImage)); |  | 37112 | ERRWRAP2(_self_->run(inputImage));
| 37161 | Py_RETURN_NONE; |  | 37113 | Py_RETURN_NONE;
| 37162 | } |  | 37114 | }
| 37163 |  |  | 37115 |
| 37164 |  |  | 37116 |
| 37165 | pyPopulateArgumentConversionErrors(); |  | 37117 | pyPopulateArgumentConversionErrors();
| 37166 | } |  | 37118 | }
| 37167 |  |  | 37119 |
| 37168 |  |  | 37120 |
| 37169 | { |  | 37121 | {
| 37170 | PyObject* pyobj_inputImage = NULL; |  | 37122 | PyObject* pyobj_inputImage = NULL;
| 37171 | UMat inputImage; |  | 37123 | UMat inputImage;
| 37172 |  |  | 37124 |
| 37173 | const char* keywords[] = { "inputImage", NULL }; |  | 37125 | const char* keywords[] = { "inputImage", NULL };
| 37174 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.run", (char**)keywords, &pyobj_inputImage) && |  | 37126 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.run", (char**)keywords, &pyobj_inputImage) &&
| 37175 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) ) |  | 37127 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) )
| 37176 | { |  | 37128 | {
| 37177 | ERRWRAP2(_self_->run(inputImage)); |  | 37129 | ERRWRAP2(_self_->run(inputImage));
| 37178 | Py_RETURN_NONE; |  | 37130 | Py_RETURN_NONE;
| 37179 | } |  | 37131 | }
| 37180 |  |  | 37132 |
| 37181 |  |  | 37133 |
| 37182 | pyPopulateArgumentConversionErrors(); |  | 37134 | pyPopulateArgumentConversionErrors();
| 37183 | } |  | 37135 | }
| 37184 | pyRaiseCVOverloadException("run"); |  | 37136 | pyRaiseCVOverloadException("run");
| 37185 |  |  | 37137 |
| 37186 | return NULL; |  | 37138 | return NULL;
| 37187 | } |  | 37139 | }
| 37188 |  |  | 37140 |
| 37189 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setColorSaturation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37141 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setColorSaturation(PyObject* self, PyObject* py_args, PyObject* kw)
| 37190 | { |  | 37142 | {
| 37191 | using namespace cv::bioinspired; |  | 37143 | using namespace cv::bioinspired;
| 37192 |  |  | 37144 |
| 37193 |  |  | 37145 |
| 37194 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37146 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37195 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37147 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37196 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37148 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37197 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37149 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37198 | PyObject* pyobj_saturateColors = NULL; |  | 37150 | PyObject* pyobj_saturateColors = NULL;
| 37199 | bool saturateColors=true; |  | 37151 | bool saturateColors=true;
| 37200 | PyObject* pyobj_colorSaturationValue = NULL; |  | 37152 | PyObject* pyobj_colorSaturationValue = NULL;
| 37201 | float colorSaturationValue=4.0f; |  | 37153 | float colorSaturationValue=4.0f;
| 37202 |  |  | 37154 |
| 37203 | const char* keywords[] = { "saturateColors", "colorSaturationValue", NULL }; |  | 37155 | const char* keywords[] = { "saturateColors", "colorSaturationValue", NULL };
| 37204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bioinspired_Retina.setColorSaturation", (char**)keywords, &pyobj_saturateColors, &pyobj_colorSaturationValue) && |  | 37156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bioinspired_Retina.setColorSaturation", (char**)keywords, &pyobj_saturateColors, &pyobj_colorSaturationValue) &&
| 37205 | pyopencv_to_safe(pyobj_saturateColors, saturateColors, ArgInfo("saturateColors", 0)) && |  | 37157 | pyopencv_to_safe(pyobj_saturateColors, saturateColors, ArgInfo("saturateColors", 0)) &&
| 37206 | pyopencv_to_safe(pyobj_colorSaturationValue, colorSaturationValue, ArgInfo("colorSaturationValue", 0)) ) |  | 37158 | pyopencv_to_safe(pyobj_colorSaturationValue, colorSaturationValue, ArgInfo("colorSaturationValue", 0)) )
| 37207 | { |  | 37159 | {
| 37208 | ERRWRAP2(_self_->setColorSaturation(saturateColors, colorSaturationValue)); |  | 37160 | ERRWRAP2(_self_->setColorSaturation(saturateColors, colorSaturationValue));
| 37209 | Py_RETURN_NONE; |  | 37161 | Py_RETURN_NONE;
| 37210 | } |  | 37162 | }
| 37211 |  |  | 37163 |
| 37212 | return NULL; |  | 37164 | return NULL;
| 37213 | } |  | 37165 | }
| 37214 |  |  | 37166 |
| 37215 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setup(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37167 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setup(PyObject* self, PyObject* py_args, PyObject* kw)
| 37216 | { |  | 37168 | {
| 37217 | using namespace cv::bioinspired; |  | 37169 | using namespace cv::bioinspired;
| 37218 |  |  | 37170 |
| 37219 |  |  | 37171 |
| 37220 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37172 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37221 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37173 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37222 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37174 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37223 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37175 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37224 | PyObject* pyobj_retinaParameterFile = NULL; |  | 37176 | PyObject* pyobj_retinaParameterFile = NULL;
| 37225 | String retinaParameterFile=""; |  | 37177 | String retinaParameterFile="";
| 37226 | PyObject* pyobj_applyDefaultSetupOnFailure = NULL; |  | 37178 | PyObject* pyobj_applyDefaultSetupOnFailure = NULL;
| 37227 | bool applyDefaultSetupOnFailure=true; |  | 37179 | bool applyDefaultSetupOnFailure=true;
| 37228 |  |  | 37180 |
| 37229 | const char* keywords[] = { "retinaParameterFile", "applyDefaultSetupOnFailure", NULL }; |  | 37181 | const char* keywords[] = { "retinaParameterFile", "applyDefaultSetupOnFailure", NULL };
| 37230 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bioinspired_Retina.setup", (char**)keywords, &pyobj_retinaParameterFile, &pyobj_applyDefaultSetupOnFailure) && |  | 37182 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bioinspired_Retina.setup", (char**)keywords, &pyobj_retinaParameterFile, &pyobj_applyDefaultSetupOnFailure) &&
| 37231 | pyopencv_to_safe(pyobj_retinaParameterFile, retinaParameterFile, ArgInfo("retinaParameterFile", 0)) && |  | 37183 | pyopencv_to_safe(pyobj_retinaParameterFile, retinaParameterFile, ArgInfo("retinaParameterFile", 0)) &&
| 37232 | pyopencv_to_safe(pyobj_applyDefaultSetupOnFailure, applyDefaultSetupOnFailure, ArgInfo("applyDefaultSetupOnFailure", 0)) ) |  | 37184 | pyopencv_to_safe(pyobj_applyDefaultSetupOnFailure, applyDefaultSetupOnFailure, ArgInfo("applyDefaultSetupOnFailure", 0)) )
| 37233 | { |  | 37185 | {
| 37234 | ERRWRAP2(_self_->setup(retinaParameterFile, applyDefaultSetupOnFailure)); |  | 37186 | ERRWRAP2(_self_->setup(retinaParameterFile, applyDefaultSetupOnFailure));
| 37235 | Py_RETURN_NONE; |  | 37187 | Py_RETURN_NONE;
| 37236 | } |  | 37188 | }
| 37237 |  |  | 37189 |
| 37238 | return NULL; |  | 37190 | return NULL;
| 37239 | } |  | 37191 | }
| 37240 |  |  | 37192 |
| 37241 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setupIPLMagnoChannel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37193 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setupIPLMagnoChannel(PyObject* self, PyObject* py_args, PyObject* kw)
| 37242 | { |  | 37194 | {
| 37243 | using namespace cv::bioinspired; |  | 37195 | using namespace cv::bioinspired;
| 37244 |  |  | 37196 |
| 37245 |  |  | 37197 |
| 37246 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37198 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37247 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37199 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37248 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37200 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37249 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37201 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37250 | PyObject* pyobj_normaliseOutput = NULL; |  | 37202 | PyObject* pyobj_normaliseOutput = NULL;
| 37251 | bool normaliseOutput=true; |  | 37203 | bool normaliseOutput=true;
| 37252 | PyObject* pyobj_parasolCells_beta = NULL; |  | 37204 | PyObject* pyobj_parasolCells_beta = NULL;
| 37253 | float parasolCells_beta=0.f; |  | 37205 | float parasolCells_beta=0.f;
| 37254 | PyObject* pyobj_parasolCells_tau = NULL; |  | 37206 | PyObject* pyobj_parasolCells_tau = NULL;
| 37255 | float parasolCells_tau=0.f; |  | 37207 | float parasolCells_tau=0.f;
| 37256 | PyObject* pyobj_parasolCells_k = NULL; |  | 37208 | PyObject* pyobj_parasolCells_k = NULL;
| 37257 | float parasolCells_k=7.f; |  | 37209 | float parasolCells_k=7.f;
| 37258 | PyObject* pyobj_amacrinCellsTemporalCutFrequency = NULL; |  | 37210 | PyObject* pyobj_amacrinCellsTemporalCutFrequency = NULL;
| 37259 | float amacrinCellsTemporalCutFrequency=1.2f; |  | 37211 | float amacrinCellsTemporalCutFrequency=1.2f;
| 37260 | PyObject* pyobj_V0CompressionParameter = NULL; |  | 37212 | PyObject* pyobj_V0CompressionParameter = NULL;
| 37261 | float V0CompressionParameter=0.95f; |  | 37213 | float V0CompressionParameter=0.95f;
| 37262 | PyObject* pyobj_localAdaptintegration_tau = NULL; |  | 37214 | PyObject* pyobj_localAdaptintegration_tau = NULL;
| 37263 | float localAdaptintegration_tau=0.f; |  | 37215 | float localAdaptintegration_tau=0.f;
| 37264 | PyObject* pyobj_localAdaptintegration_k = NULL; |  | 37216 | PyObject* pyobj_localAdaptintegration_k = NULL;
| 37265 | float localAdaptintegration_k=7.f; |  | 37217 | float localAdaptintegration_k=7.f;
| 37266 |  |  | 37218 |
| 37267 | const char* keywords[] = { "normaliseOutput", "parasolCells_beta", "parasolCells_tau", "parasolCells_k", "amacrinCellsTemporalCutFrequency", "V0CompressionParameter", "localAdaptintegration_tau", "localAdaptintegration_k", NULL }; |  | 37219 | const char* keywords[] = { "normaliseOutput", "parasolCells_beta", "parasolCells_tau", "parasolCells_k", "amacrinCellsTemporalCutFrequency", "V0CompressionParameter", "localAdaptintegration_tau", "localAdaptintegration_k", NULL };
| 37268 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:bioinspired_Retina.setupIPLMagnoChannel", (char**)keywords, &pyobj_normaliseOutput, &pyobj_parasolCells_beta, &pyobj_parasolCells_tau, &pyobj_parasolCells_k, &pyobj_amacrinCellsTemporalCutFrequency, &pyobj_V0CompressionParameter, &pyobj_localAdaptintegration_tau, &pyobj_localAdaptintegration_k) && |  | 37220 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:bioinspired_Retina.setupIPLMagnoChannel", (char**)keywords, &pyobj_normaliseOutput, &pyobj_parasolCells_beta, &pyobj_parasolCells_tau, &pyobj_parasolCells_k, &pyobj_amacrinCellsTemporalCutFrequency, &pyobj_V0CompressionParameter, &pyobj_localAdaptintegration_tau, &pyobj_localAdaptintegration_k) &&
| 37269 | pyopencv_to_safe(pyobj_normaliseOutput, normaliseOutput, ArgInfo("normaliseOutput", 0)) && |  | 37221 | pyopencv_to_safe(pyobj_normaliseOutput, normaliseOutput, ArgInfo("normaliseOutput", 0)) &&
| 37270 | pyopencv_to_safe(pyobj_parasolCells_beta, parasolCells_beta, ArgInfo("parasolCells_beta", 0)) && |  | 37222 | pyopencv_to_safe(pyobj_parasolCells_beta, parasolCells_beta, ArgInfo("parasolCells_beta", 0)) &&
| 37271 | pyopencv_to_safe(pyobj_parasolCells_tau, parasolCells_tau, ArgInfo("parasolCells_tau", 0)) && |  | 37223 | pyopencv_to_safe(pyobj_parasolCells_tau, parasolCells_tau, ArgInfo("parasolCells_tau", 0)) &&
| 37272 | pyopencv_to_safe(pyobj_parasolCells_k, parasolCells_k, ArgInfo("parasolCells_k", 0)) && |  | 37224 | pyopencv_to_safe(pyobj_parasolCells_k, parasolCells_k, ArgInfo("parasolCells_k", 0)) &&
| 37273 | pyopencv_to_safe(pyobj_amacrinCellsTemporalCutFrequency, amacrinCellsTemporalCutFrequency, ArgInfo("amacrinCellsTemporalCutFrequency", 0)) && |  | 37225 | pyopencv_to_safe(pyobj_amacrinCellsTemporalCutFrequency, amacrinCellsTemporalCutFrequency, ArgInfo("amacrinCellsTemporalCutFrequency", 0)) &&
| 37274 | pyopencv_to_safe(pyobj_V0CompressionParameter, V0CompressionParameter, ArgInfo("V0CompressionParameter", 0)) && |  | 37226 | pyopencv_to_safe(pyobj_V0CompressionParameter, V0CompressionParameter, ArgInfo("V0CompressionParameter", 0)) &&
| 37275 | pyopencv_to_safe(pyobj_localAdaptintegration_tau, localAdaptintegration_tau, ArgInfo("localAdaptintegration_tau", 0)) && |  | 37227 | pyopencv_to_safe(pyobj_localAdaptintegration_tau, localAdaptintegration_tau, ArgInfo("localAdaptintegration_tau", 0)) &&
| 37276 | pyopencv_to_safe(pyobj_localAdaptintegration_k, localAdaptintegration_k, ArgInfo("localAdaptintegration_k", 0)) ) |  | 37228 | pyopencv_to_safe(pyobj_localAdaptintegration_k, localAdaptintegration_k, ArgInfo("localAdaptintegration_k", 0)) )
| 37277 | { |  | 37229 | {
| 37278 | ERRWRAP2(_self_->setupIPLMagnoChannel(normaliseOutput, parasolCells_beta, parasolCells_tau, parasolCells_k, amacrinCellsTemporalCutFrequency, V0CompressionParameter, localAdaptintegration_tau, localAdaptintegration_k)); |  | 37230 | ERRWRAP2(_self_->setupIPLMagnoChannel(normaliseOutput, parasolCells_beta, parasolCells_tau, parasolCells_k, amacrinCellsTemporalCutFrequency, V0CompressionParameter, localAdaptintegration_tau, localAdaptintegration_k));
| 37279 | Py_RETURN_NONE; |  | 37231 | Py_RETURN_NONE;
| 37280 | } |  | 37232 | }
| 37281 |  |  | 37233 |
| 37282 | return NULL; |  | 37234 | return NULL;
| 37283 | } |  | 37235 | }
| 37284 |  |  | 37236 |
| 37285 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setupOPLandIPLParvoChannel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37237 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_setupOPLandIPLParvoChannel(PyObject* self, PyObject* py_args, PyObject* kw)
| 37286 | { |  | 37238 | {
| 37287 | using namespace cv::bioinspired; |  | 37239 | using namespace cv::bioinspired;
| 37288 |  |  | 37240 |
| 37289 |  |  | 37241 |
| 37290 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37242 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37291 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37243 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37292 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37244 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37293 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37245 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37294 | PyObject* pyobj_colorMode = NULL; |  | 37246 | PyObject* pyobj_colorMode = NULL;
| 37295 | bool colorMode=true; |  | 37247 | bool colorMode=true;
| 37296 | PyObject* pyobj_normaliseOutput = NULL; |  | 37248 | PyObject* pyobj_normaliseOutput = NULL;
| 37297 | bool normaliseOutput=true; |  | 37249 | bool normaliseOutput=true;
| 37298 | PyObject* pyobj_photoreceptorsLocalAdaptationSensitivity = NULL; |  | 37250 | PyObject* pyobj_photoreceptorsLocalAdaptationSensitivity = NULL;
| 37299 | float photoreceptorsLocalAdaptationSensitivity=0.7f; |  | 37251 | float photoreceptorsLocalAdaptationSensitivity=0.7f;
| 37300 | PyObject* pyobj_photoreceptorsTemporalConstant = NULL; |  | 37252 | PyObject* pyobj_photoreceptorsTemporalConstant = NULL;
| 37301 | float photoreceptorsTemporalConstant=0.5f; |  | 37253 | float photoreceptorsTemporalConstant=0.5f;
| 37302 | PyObject* pyobj_photoreceptorsSpatialConstant = NULL; |  | 37254 | PyObject* pyobj_photoreceptorsSpatialConstant = NULL;
| 37303 | float photoreceptorsSpatialConstant=0.53f; |  | 37255 | float photoreceptorsSpatialConstant=0.53f;
| 37304 | PyObject* pyobj_horizontalCellsGain = NULL; |  | 37256 | PyObject* pyobj_horizontalCellsGain = NULL;
| 37305 | float horizontalCellsGain=0.f; |  | 37257 | float horizontalCellsGain=0.f;
| 37306 | PyObject* pyobj_HcellsTemporalConstant = NULL; |  | 37258 | PyObject* pyobj_HcellsTemporalConstant = NULL;
| 37307 | float HcellsTemporalConstant=1.f; |  | 37259 | float HcellsTemporalConstant=1.f;
| 37308 | PyObject* pyobj_HcellsSpatialConstant = NULL; |  | 37260 | PyObject* pyobj_HcellsSpatialConstant = NULL;
| 37309 | float HcellsSpatialConstant=7.f; |  | 37261 | float HcellsSpatialConstant=7.f;
| 37310 | PyObject* pyobj_ganglionCellsSensitivity = NULL; |  | 37262 | PyObject* pyobj_ganglionCellsSensitivity = NULL;
| 37311 | float ganglionCellsSensitivity=0.7f; |  | 37263 | float ganglionCellsSensitivity=0.7f;
| 37312 |  |  | 37264 |
| 37313 | const char* keywords[] = { "colorMode", "normaliseOutput", "photoreceptorsLocalAdaptationSensitivity", "photoreceptorsTemporalConstant", "photoreceptorsSpatialConstant", "horizontalCellsGain", "HcellsTemporalConstant", "HcellsSpatialConstant", "ganglionCellsSensitivity", NULL }; |  | 37265 | const char* keywords[] = { "colorMode", "normaliseOutput", "photoreceptorsLocalAdaptationSensitivity", "photoreceptorsTemporalConstant", "photoreceptorsSpatialConstant", "horizontalCellsGain", "HcellsTemporalConstant", "HcellsSpatialConstant", "ganglionCellsSensitivity", NULL };
| 37314 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOO:bioinspired_Retina.setupOPLandIPLParvoChannel", (char**)keywords, &pyobj_colorMode, &pyobj_normaliseOutput, &pyobj_photoreceptorsLocalAdaptationSensitivity, &pyobj_photoreceptorsTemporalConstant, &pyobj_photoreceptorsSpatialConstant, &pyobj_horizontalCellsGain, &pyobj_HcellsTemporalConstant, &pyobj_HcellsSpatialConstant, &pyobj_ganglionCellsSensitivity) && |  | 37266 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOO:bioinspired_Retina.setupOPLandIPLParvoChannel", (char**)keywords, &pyobj_colorMode, &pyobj_normaliseOutput, &pyobj_photoreceptorsLocalAdaptationSensitivity, &pyobj_photoreceptorsTemporalConstant, &pyobj_photoreceptorsSpatialConstant, &pyobj_horizontalCellsGain, &pyobj_HcellsTemporalConstant, &pyobj_HcellsSpatialConstant, &pyobj_ganglionCellsSensitivity) &&
| 37315 | pyopencv_to_safe(pyobj_colorMode, colorMode, ArgInfo("colorMode", 0)) && |  | 37267 | pyopencv_to_safe(pyobj_colorMode, colorMode, ArgInfo("colorMode", 0)) &&
| 37316 | pyopencv_to_safe(pyobj_normaliseOutput, normaliseOutput, ArgInfo("normaliseOutput", 0)) && |  | 37268 | pyopencv_to_safe(pyobj_normaliseOutput, normaliseOutput, ArgInfo("normaliseOutput", 0)) &&
| 37317 | pyopencv_to_safe(pyobj_photoreceptorsLocalAdaptationSensitivity, photoreceptorsLocalAdaptationSensitivity, ArgInfo("photoreceptorsLocalAdaptationSensitivity", 0)) && |  | 37269 | pyopencv_to_safe(pyobj_photoreceptorsLocalAdaptationSensitivity, photoreceptorsLocalAdaptationSensitivity, ArgInfo("photoreceptorsLocalAdaptationSensitivity", 0)) &&
| 37318 | pyopencv_to_safe(pyobj_photoreceptorsTemporalConstant, photoreceptorsTemporalConstant, ArgInfo("photoreceptorsTemporalConstant", 0)) && |  | 37270 | pyopencv_to_safe(pyobj_photoreceptorsTemporalConstant, photoreceptorsTemporalConstant, ArgInfo("photoreceptorsTemporalConstant", 0)) &&
| 37319 | pyopencv_to_safe(pyobj_photoreceptorsSpatialConstant, photoreceptorsSpatialConstant, ArgInfo("photoreceptorsSpatialConstant", 0)) && |  | 37271 | pyopencv_to_safe(pyobj_photoreceptorsSpatialConstant, photoreceptorsSpatialConstant, ArgInfo("photoreceptorsSpatialConstant", 0)) &&
| 37320 | pyopencv_to_safe(pyobj_horizontalCellsGain, horizontalCellsGain, ArgInfo("horizontalCellsGain", 0)) && |  | 37272 | pyopencv_to_safe(pyobj_horizontalCellsGain, horizontalCellsGain, ArgInfo("horizontalCellsGain", 0)) &&
| 37321 | pyopencv_to_safe(pyobj_HcellsTemporalConstant, HcellsTemporalConstant, ArgInfo("HcellsTemporalConstant", 0)) && |  | 37273 | pyopencv_to_safe(pyobj_HcellsTemporalConstant, HcellsTemporalConstant, ArgInfo("HcellsTemporalConstant", 0)) &&
| 37322 | pyopencv_to_safe(pyobj_HcellsSpatialConstant, HcellsSpatialConstant, ArgInfo("HcellsSpatialConstant", 0)) && |  | 37274 | pyopencv_to_safe(pyobj_HcellsSpatialConstant, HcellsSpatialConstant, ArgInfo("HcellsSpatialConstant", 0)) &&
| 37323 | pyopencv_to_safe(pyobj_ganglionCellsSensitivity, ganglionCellsSensitivity, ArgInfo("ganglionCellsSensitivity", 0)) ) |  | 37275 | pyopencv_to_safe(pyobj_ganglionCellsSensitivity, ganglionCellsSensitivity, ArgInfo("ganglionCellsSensitivity", 0)) )
| 37324 | { |  | 37276 | {
| 37325 | ERRWRAP2(_self_->setupOPLandIPLParvoChannel(colorMode, normaliseOutput, photoreceptorsLocalAdaptationSensitivity, photoreceptorsTemporalConstant, photoreceptorsSpatialConstant, horizontalCellsGain, HcellsTemporalConstant, HcellsSpatialConstant, ganglionCellsSensitivity)); |  | 37277 | ERRWRAP2(_self_->setupOPLandIPLParvoChannel(colorMode, normaliseOutput, photoreceptorsLocalAdaptationSensitivity, photoreceptorsTemporalConstant, photoreceptorsSpatialConstant, horizontalCellsGain, HcellsTemporalConstant, HcellsSpatialConstant, ganglionCellsSensitivity));
| 37326 | Py_RETURN_NONE; |  | 37278 | Py_RETURN_NONE;
| 37327 | } |  | 37279 | }
| 37328 |  |  | 37280 |
| 37329 | return NULL; |  | 37281 | return NULL;
| 37330 | } |  | 37282 | }
| 37331 |  |  | 37283 |
| 37332 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37284 | static PyObject* pyopencv_cv_bioinspired_bioinspired_Retina_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 37333 | { |  | 37285 | {
| 37334 | using namespace cv::bioinspired; |  | 37286 | using namespace cv::bioinspired;
| 37335 |  |  | 37287 |
| 37336 |  |  | 37288 |
| 37337 | Ptr<cv::bioinspired::Retina> * self1 = 0; |  | 37289 | Ptr<cv::bioinspired::Retina> * self1 = 0;
| 37338 | if (!pyopencv_bioinspired_Retina_getp(self, self1)) |  | 37290 | if (!pyopencv_bioinspired_Retina_getp(self, self1))
| 37339 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)"); |  | 37291 | return failmsgp("Incorrect type of self (must be 'bioinspired_Retina' or its derivative)");
| 37340 | Ptr<cv::bioinspired::Retina> _self_ = *(self1); |  | 37292 | Ptr<cv::bioinspired::Retina> _self_ = *(self1);
| 37341 | PyObject* pyobj_fs = NULL; |  | 37293 | PyObject* pyobj_fs = NULL;
| 37342 | String fs; |  | 37294 | String fs;
| 37343 |  |  | 37295 |
| 37344 | const char* keywords[] = { "fs", NULL }; |  | 37296 | const char* keywords[] = { "fs", NULL };
| 37345 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.write", (char**)keywords, &pyobj_fs) && |  | 37297 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_Retina.write", (char**)keywords, &pyobj_fs) &&
| 37346 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) ) |  | 37298 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) )
| 37347 | { |  | 37299 | {
| 37348 | ERRWRAP2(_self_->write(fs)); |  | 37300 | ERRWRAP2(_self_->write(fs));
| 37349 | Py_RETURN_NONE; |  | 37301 | Py_RETURN_NONE;
| 37350 | } |  | 37302 | }
| 37351 |  |  | 37303 |
| 37352 | return NULL; |  | 37304 | return NULL;
| 37353 | } |  | 37305 | }
| 37354 |  |  | 37306 |
| 37355 |  |  | 37307 |
| 37356 |  |  | 37308 |
| 37357 | // Tables (bioinspired_Retina) |  | 37309 | // Tables (bioinspired_Retina)
| 37358 |  |  | 37310 |
| 37359 | static PyGetSetDef pyopencv_bioinspired_Retina_getseters[] = |  | 37311 | static PyGetSetDef pyopencv_bioinspired_Retina_getseters[] =
| 37360 | { |  | 37312 | {
| 37361 | {NULL} /* Sentinel */ |  | 37313 | {NULL} /* Sentinel */
| 37362 | }; |  | 37314 | };
| 37363 |  |  | 37315 |
| 37364 | static PyMethodDef pyopencv_bioinspired_Retina_methods[] = |  | 37316 | static PyMethodDef pyopencv_bioinspired_Retina_methods[] =
| 37365 | { |  | 37317 | {
| 37366 | {"activateContoursProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_activateContoursProcessing, 0), "activateContoursProcessing(activate) -> None\n. @brief Activate/desactivate the Parvocellular pathway processing (contours information extraction), by\n. default, it is activated\n. @param activate true if Parvocellular (contours information extraction) output should be\n. activated, false if not... if activated, the Parvocellular output can be retrieved using the\n. Retina::getParvo methods"}, |  | 37318 | {"activateContoursProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_activateContoursProcessing, 0), "activateContoursProcessing(activate) -> None\n. @brief Activate/desactivate the Parvocellular pathway processing (contours information extraction), by\n. default, it is activated\n. @param activate true if Parvocellular (contours information extraction) output should be\n. activated, false if not... if activated, the Parvocellular output can be retrieved using the\n. Retina::getParvo methods"},
| 37367 | {"activateMovingContoursProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_activateMovingContoursProcessing, 0), "activateMovingContoursProcessing(activate) -> None\n. @brief Activate/desactivate the Magnocellular pathway processing (motion information extraction), by\n. default, it is activated\n. @param activate true if Magnocellular output should be activated, false if not... if activated,\n. the Magnocellular output can be retrieved using the **getMagno** methods"}, |  | 37319 | {"activateMovingContoursProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_activateMovingContoursProcessing, 0), "activateMovingContoursProcessing(activate) -> None\n. @brief Activate/desactivate the Magnocellular pathway processing (motion information extraction), by\n. default, it is activated\n. @param activate true if Magnocellular output should be activated, false if not... if activated,\n. the Magnocellular output can be retrieved using the **getMagno** methods"},
| 37368 | {"applyFastToneMapping", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_applyFastToneMapping, 0), "applyFastToneMapping(inputImage[, outputToneMappedImage]) -> outputToneMappedImage\n. @brief Method which processes an image in the aim to correct its luminance correct\n. backlight problems, enhance details in shadows.\n. \n. This method is designed to perform High Dynamic Range image tone mapping (compress \\>8bit/pixel\n. images to 8bit/pixel). This is a simplified version of the Retina Parvocellular model\n. (simplified version of the run/getParvo methods call) since it does not include the\n. spatio-temporal filter modelling the Outer Plexiform Layer of the retina that performs spectral\n. whitening and many other stuff. However, it works great for tone mapping and in a faster way.\n. \n. Check the demos and experiments section to see examples and the way to perform tone mapping\n. using the original retina model and the method.\n. \n. @param inputImage the input image to process (should be coded in float format : CV_32F,\n. CV_32FC1, CV_32F_C3, CV_32F_C4, the 4th channel won't be considered).\n. @param outputToneMappedImage the output 8bit/channel tone mapped image (CV_8U or CV_8UC3 format)."}, |  | 37320 | {"applyFastToneMapping", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_applyFastToneMapping, 0), "applyFastToneMapping(inputImage[, outputToneMappedImage]) -> outputToneMappedImage\n. @brief Method which processes an image in the aim to correct its luminance correct\n. backlight problems, enhance details in shadows.\n. \n. This method is designed to perform High Dynamic Range image tone mapping (compress \\>8bit/pixel\n. images to 8bit/pixel). This is a simplified version of the Retina Parvocellular model\n. (simplified version of the run/getParvo methods call) since it does not include the\n. spatio-temporal filter modelling the Outer Plexiform Layer of the retina that performs spectral\n. whitening and many other stuff. However, it works great for tone mapping and in a faster way.\n. \n. Check the demos and experiments section to see examples and the way to perform tone mapping\n. using the original retina model and the method.\n. \n. @param inputImage the input image to process (should be coded in float format : CV_32F,\n. CV_32FC1, CV_32F_C3, CV_32F_C4, the 4th channel won't be considered).\n. @param outputToneMappedImage the output 8bit/channel tone mapped image (CV_8U or CV_8UC3 format)."},
| 37369 | {"clearBuffers", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_clearBuffers, 0), "clearBuffers() -> None\n. @brief Clears all retina buffers\n. \n. (equivalent to opening the eyes after a long period of eye close ;o) whatchout the temporal\n. transition occuring just after this method call."}, |  | 37321 | {"clearBuffers", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_clearBuffers, 0), "clearBuffers() -> None\n. @brief Clears all retina buffers\n. \n. (equivalent to opening the eyes after a long period of eye close ;o) whatchout the temporal\n. transition occuring just after this method call."},
| 37370 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_create_static, METH_STATIC), "create(inputSize) -> retval\n. @overload\n\n\n\ncreate(inputSize, colorMode[, colorSamplingMethod[, useRetinaLogSampling[, reductionFactor[, samplingStrength]]]]) -> retval\n. @brief Constructors from standardized interfaces : retreive a smart pointer to a Retina instance\n. \n. @param inputSize the input frame size\n. @param colorMode the chosen processing mode : with or without color processing\n. @param colorSamplingMethod specifies which kind of color sampling will be used :\n. - cv::bioinspired::RETINA_COLOR_RANDOM: each pixel position is either R, G or B in a random choice\n. - cv::bioinspired::RETINA_COLOR_DIAGONAL: color sampling is RGBRGBRGB..., line 2 BRGBRGBRG..., line 3, GBRGBRGBR...\n. - cv::bioinspired::RETINA_COLOR_BAYER: standard bayer sampling\n. @param useRetinaLogSampling activate retina log sampling, if true, the 2 following parameters can\n. be used\n. @param reductionFactor only usefull if param useRetinaLogSampling=true, specifies the reduction\n. factor of the output frame (as the center (fovea) is high resolution and corners can be\n. underscaled, then a reduction of the output is allowed without precision leak\n. @param samplingStrength only usefull if param useRetinaLogSampling=true, specifies the strength of\n. the log scale that is applied"}, |  | 37322 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_create_static, METH_STATIC), "create(inputSize) -> retval\n. @overload\n\n\n\ncreate(inputSize, colorMode[, colorSamplingMethod[, useRetinaLogSampling[, reductionFactor[, samplingStrength]]]]) -> retval\n. @brief Constructors from standardized interfaces : retreive a smart pointer to a Retina instance\n. \n. @param inputSize the input frame size\n. @param colorMode the chosen processing mode : with or without color processing\n. @param colorSamplingMethod specifies which kind of color sampling will be used :\n. - cv::bioinspired::RETINA_COLOR_RANDOM: each pixel position is either R, G or B in a random choice\n. - cv::bioinspired::RETINA_COLOR_DIAGONAL: color sampling is RGBRGBRGB..., line 2 BRGBRGBRG..., line 3, GBRGBRGBR...\n. - cv::bioinspired::RETINA_COLOR_BAYER: standard bayer sampling\n. @param useRetinaLogSampling activate retina log sampling, if true, the 2 following parameters can\n. be used\n. @param reductionFactor only usefull if param useRetinaLogSampling=true, specifies the reduction\n. factor of the output frame (as the center (fovea) is high resolution and corners can be\n. underscaled, then a reduction of the output is allowed without precision leak\n. @param samplingStrength only usefull if param useRetinaLogSampling=true, specifies the strength of\n. the log scale that is applied"},
| 37371 | {"getInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getInputSize, 0), "getInputSize() -> retval\n. @brief Retreive retina input buffer size\n. @return the retina input buffer size"}, |  | 37323 | {"getInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getInputSize, 0), "getInputSize() -> retval\n. @brief Retreive retina input buffer size\n. @return the retina input buffer size"},
| 37372 | {"getMagno", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getMagno, 0), "getMagno([, retinaOutput_magno]) -> retinaOutput_magno\n. @brief Accessor of the motion channel of the retina (models peripheral vision).\n. \n. Warning, getMagnoRAW methods return buffers that are not rescaled within range [0;255] while\n. the non RAW method allows a normalized matrix to be retrieved.\n. @param retinaOutput_magno the output buffer (reallocated if necessary), format can be :\n. - a Mat, this output is rescaled for standard 8bits image processing use in OpenCV\n. - RAW methods actually return a 1D matrix (encoding is M1, M2,... Mn), this output is the\n. original retina filter model output, without any quantification or rescaling.\n. @see getMagnoRAW"}, |  | 37324 | {"getMagno", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getMagno, 0), "getMagno([, retinaOutput_magno]) -> retinaOutput_magno\n. @brief Accessor of the motion channel of the retina (models peripheral vision).\n. \n. Warning, getMagnoRAW methods return buffers that are not rescaled within range [0;255] while\n. the non RAW method allows a normalized matrix to be retrieved.\n. @param retinaOutput_magno the output buffer (reallocated if necessary), format can be :\n. - a Mat, this output is rescaled for standard 8bits image processing use in OpenCV\n. - RAW methods actually return a 1D matrix (encoding is M1, M2,... Mn), this output is the\n. original retina filter model output, without any quantification or rescaling.\n. @see getMagnoRAW"},
| 37373 | {"getMagnoRAW", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getMagnoRAW, 0), "getMagnoRAW([, retinaOutput_magno]) -> retinaOutput_magno\n. @brief Accessor of the motion channel of the retina (models peripheral vision).\n. @see getMagno\n\n\n\ngetMagnoRAW() -> retval\n. @overload"}, |  | 37325 | {"getMagnoRAW", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getMagnoRAW, 0), "getMagnoRAW([, retinaOutput_magno]) -> retinaOutput_magno\n. @brief Accessor of the motion channel of the retina (models peripheral vision).\n. @see getMagno\n\n\n\ngetMagnoRAW() -> retval\n. @overload"},
| 37374 | {"getOutputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getOutputSize, 0), "getOutputSize() -> retval\n. @brief Retreive retina output buffer size that can be different from the input if a spatial log\n. transformation is applied\n. @return the retina output buffer size"}, |  | 37326 | {"getOutputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getOutputSize, 0), "getOutputSize() -> retval\n. @brief Retreive retina output buffer size that can be different from the input if a spatial log\n. transformation is applied\n. @return the retina output buffer size"},
| 37375 | {"getParvo", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getParvo, 0), "getParvo([, retinaOutput_parvo]) -> retinaOutput_parvo\n. @brief Accessor of the details channel of the retina (models foveal vision).\n. \n. Warning, getParvoRAW methods return buffers that are not rescaled within range [0;255] while\n. the non RAW method allows a normalized matrix to be retrieved.\n. \n. @param retinaOutput_parvo the output buffer (reallocated if necessary), format can be :\n. - a Mat, this output is rescaled for standard 8bits image processing use in OpenCV\n. - RAW methods actually return a 1D matrix (encoding is R1, R2, ... Rn, G1, G2, ..., Gn, B1,\n. B2, ...Bn), this output is the original retina filter model output, without any\n. quantification or rescaling.\n. @see getParvoRAW"}, |  | 37327 | {"getParvo", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getParvo, 0), "getParvo([, retinaOutput_parvo]) -> retinaOutput_parvo\n. @brief Accessor of the details channel of the retina (models foveal vision).\n. \n. Warning, getParvoRAW methods return buffers that are not rescaled within range [0;255] while\n. the non RAW method allows a normalized matrix to be retrieved.\n. \n. @param retinaOutput_parvo the output buffer (reallocated if necessary), format can be :\n. - a Mat, this output is rescaled for standard 8bits image processing use in OpenCV\n. - RAW methods actually return a 1D matrix (encoding is R1, R2, ... Rn, G1, G2, ..., Gn, B1,\n. B2, ...Bn), this output is the original retina filter model output, without any\n. quantification or rescaling.\n. @see getParvoRAW"},
| 37376 | {"getParvoRAW", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getParvoRAW, 0), "getParvoRAW([, retinaOutput_parvo]) -> retinaOutput_parvo\n. @brief Accessor of the details channel of the retina (models foveal vision).\n. @see getParvo\n\n\n\ngetParvoRAW() -> retval\n. @overload"}, |  | 37328 | {"getParvoRAW", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_getParvoRAW, 0), "getParvoRAW([, retinaOutput_parvo]) -> retinaOutput_parvo\n. @brief Accessor of the details channel of the retina (models foveal vision).\n. @see getParvo\n\n\n\ngetParvoRAW() -> retval\n. @overload"},
| 37377 | {"printSetup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_printSetup, 0), "printSetup() -> retval\n. @brief Outputs a string showing the used parameters setup\n. @return a string which contains formated parameters information"}, |  | 37329 | {"printSetup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_printSetup, 0), "printSetup() -> retval\n. @brief Outputs a string showing the used parameters setup\n. @return a string which contains formated parameters information"},
| 37378 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_run, 0), "run(inputImage) -> None\n. @brief Method which allows retina to be applied on an input image,\n. \n. after run, encapsulated retina module is ready to deliver its outputs using dedicated\n. acccessors, see getParvo and getMagno methods\n. @param inputImage the input Mat image to be processed, can be gray level or BGR coded in any\n. format (from 8bit to 16bits)"}, |  | 37330 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_run, 0), "run(inputImage) -> None\n. @brief Method which allows retina to be applied on an input image,\n. \n. after run, encapsulated retina module is ready to deliver its outputs using dedicated\n. acccessors, see getParvo and getMagno methods\n. @param inputImage the input Mat image to be processed, can be gray level or BGR coded in any\n. format (from 8bit to 16bits)"},
| 37379 | {"setColorSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setColorSaturation, 0), "setColorSaturation([, saturateColors[, colorSaturationValue]]) -> None\n. @brief Activate color saturation as the final step of the color demultiplexing process -\\> this\n. saturation is a sigmoide function applied to each channel of the demultiplexed image.\n. @param saturateColors boolean that activates color saturation (if true) or desactivate (if false)\n. @param colorSaturationValue the saturation factor : a simple factor applied on the chrominance\n. buffers"}, |  | 37331 | {"setColorSaturation", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setColorSaturation, 0), "setColorSaturation([, saturateColors[, colorSaturationValue]]) -> None\n. @brief Activate color saturation as the final step of the color demultiplexing process -\\> this\n. saturation is a sigmoide function applied to each channel of the demultiplexed image.\n. @param saturateColors boolean that activates color saturation (if true) or desactivate (if false)\n. @param colorSaturationValue the saturation factor : a simple factor applied on the chrominance\n. buffers"},
| 37380 | {"setup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setup, 0), "setup([, retinaParameterFile[, applyDefaultSetupOnFailure]]) -> None\n. @brief Try to open an XML retina parameters file to adjust current retina instance setup\n. \n. - if the xml file does not exist, then default setup is applied\n. - warning, Exceptions are thrown if read XML file is not valid\n. @param retinaParameterFile the parameters filename\n. @param applyDefaultSetupOnFailure set to true if an error must be thrown on error\n. \n. You can retrieve the current parameters structure using the method Retina::getParameters and update\n. it before running method Retina::setup."}, |  | 37332 | {"setup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setup, 0), "setup([, retinaParameterFile[, applyDefaultSetupOnFailure]]) -> None\n. @brief Try to open an XML retina parameters file to adjust current retina instance setup\n. \n. - if the xml file does not exist, then default setup is applied\n. - warning, Exceptions are thrown if read XML file is not valid\n. @param retinaParameterFile the parameters filename\n. @param applyDefaultSetupOnFailure set to true if an error must be thrown on error\n. \n. You can retrieve the current parameters structure using the method Retina::getParameters and update\n. it before running method Retina::setup."},
| 37381 | {"setupIPLMagnoChannel", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setupIPLMagnoChannel, 0), "setupIPLMagnoChannel([, normaliseOutput[, parasolCells_beta[, parasolCells_tau[, parasolCells_k[, amacrinCellsTemporalCutFrequency[, V0CompressionParameter[, localAdaptintegration_tau[, localAdaptintegration_k]]]]]]]]) -> None\n. @brief Set parameters values for the Inner Plexiform Layer (IPL) magnocellular channel\n. \n. this channel processes signals output from OPL processing stage in peripheral vision, it allows\n. motion information enhancement. It is decorrelated from the details channel. See reference\n. papers for more details.\n. \n. @param normaliseOutput specifies if (true) output is rescaled between 0 and 255 of not (false)\n. @param parasolCells_beta the low pass filter gain used for local contrast adaptation at the\n. IPL level of the retina (for ganglion cells local adaptation), typical value is 0\n. @param parasolCells_tau the low pass filter time constant used for local contrast adaptation\n. at the IPL level of the retina (for ganglion cells local adaptation), unit is frame, typical\n. value is 0 (immediate response)\n. @param parasolCells_k the low pass filter spatial constant used for local contrast adaptation\n. at the IPL level of the retina (for ganglion cells local adaptation), unit is pixels, typical\n. value is 5\n. @param amacrinCellsTemporalCutFrequency the time constant of the first order high pass fiter of\n. the magnocellular way (motion information channel), unit is frames, typical value is 1.2\n. @param V0CompressionParameter the compression strengh of the ganglion cells local adaptation\n. output, set a value between 0.6 and 1 for best results, a high value increases more the low\n. value sensitivity... and the output saturates faster, recommended value: 0.95\n. @param localAdaptintegration_tau specifies the temporal constant of the low pas filter\n. involved in the computation of the local \"motion mean\" for the local adaptation computation\n. @param localAdaptintegration_k specifies the spatial constant of the low pas filter involved\n. in the computation of the local \"motion mean\" for the local adaptation computation"}, |  | 37333 | {"setupIPLMagnoChannel", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setupIPLMagnoChannel, 0), "setupIPLMagnoChannel([, normaliseOutput[, parasolCells_beta[, parasolCells_tau[, parasolCells_k[, amacrinCellsTemporalCutFrequency[, V0CompressionParameter[, localAdaptintegration_tau[, localAdaptintegration_k]]]]]]]]) -> None\n. @brief Set parameters values for the Inner Plexiform Layer (IPL) magnocellular channel\n. \n. this channel processes signals output from OPL processing stage in peripheral vision, it allows\n. motion information enhancement. It is decorrelated from the details channel. See reference\n. papers for more details.\n. \n. @param normaliseOutput specifies if (true) output is rescaled between 0 and 255 of not (false)\n. @param parasolCells_beta the low pass filter gain used for local contrast adaptation at the\n. IPL level of the retina (for ganglion cells local adaptation), typical value is 0\n. @param parasolCells_tau the low pass filter time constant used for local contrast adaptation\n. at the IPL level of the retina (for ganglion cells local adaptation), unit is frame, typical\n. value is 0 (immediate response)\n. @param parasolCells_k the low pass filter spatial constant used for local contrast adaptation\n. at the IPL level of the retina (for ganglion cells local adaptation), unit is pixels, typical\n. value is 5\n. @param amacrinCellsTemporalCutFrequency the time constant of the first order high pass fiter of\n. the magnocellular way (motion information channel), unit is frames, typical value is 1.2\n. @param V0CompressionParameter the compression strengh of the ganglion cells local adaptation\n. output, set a value between 0.6 and 1 for best results, a high value increases more the low\n. value sensitivity... and the output saturates faster, recommended value: 0.95\n. @param localAdaptintegration_tau specifies the temporal constant of the low pas filter\n. involved in the computation of the local \"motion mean\" for the local adaptation computation\n. @param localAdaptintegration_k specifies the spatial constant of the low pas filter involved\n. in the computation of the local \"motion mean\" for the local adaptation computation"},
| 37382 | {"setupOPLandIPLParvoChannel", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setupOPLandIPLParvoChannel, 0), "setupOPLandIPLParvoChannel([, colorMode[, normaliseOutput[, photoreceptorsLocalAdaptationSensitivity[, photoreceptorsTemporalConstant[, photoreceptorsSpatialConstant[, horizontalCellsGain[, HcellsTemporalConstant[, HcellsSpatialConstant[, ganglionCellsSensitivity]]]]]]]]]) -> None\n. @brief Setup the OPL and IPL parvo channels (see biologocal model)\n. \n. OPL is referred as Outer Plexiform Layer of the retina, it allows the spatio-temporal filtering\n. which withens the spectrum and reduces spatio-temporal noise while attenuating global luminance\n. (low frequency energy) IPL parvo is the OPL next processing stage, it refers to a part of the\n. Inner Plexiform layer of the retina, it allows high contours sensitivity in foveal vision. See\n. reference papers for more informations.\n. for more informations, please have a look at the paper Benoit A., Caplier A., Durette B., Herault, J., \"USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING\", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011\n. @param colorMode specifies if (true) color is processed of not (false) to then processing gray\n. level image\n. @param normaliseOutput specifies if (true) output is rescaled between 0 and 255 of not (false)\n. @param photoreceptorsLocalAdaptationSensitivity the photoreceptors sensitivity renage is 0-1\n. (more log compression effect when value increases)\n. @param photoreceptorsTemporalConstant the time constant of the first order low pass filter of\n. the photoreceptors, use it to cut high temporal frequencies (noise or fast motion), unit is\n. frames, typical value is 1 frame\n. @param photoreceptorsSpatialConstant the spatial constant of the first order low pass filter of\n. the photoreceptors, use it to cut high spatial frequencies (noise or thick contours), unit is\n. pixels, typical value is 1 pixel\n. @param horizontalCellsGain gain of the horizontal cells network, if 0, then the mean value of\n. the output is zero, if the parameter is near 1, then, the luminance is not filtered and is\n. still reachable at the output, typicall value is 0\n. @param HcellsTemporalConstant the time constant of the first order low pass filter of the\n. horizontal cells, use it to cut low temporal frequencies (local luminance variations), unit is\n. frames, typical value is 1 frame, as the photoreceptors\n. @param HcellsSpatialConstant the spatial constant of the first order low pass filter of the\n. horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels,\n. typical value is 5 pixel, this value is also used for local contrast computing when computing\n. the local contrast adaptation at the ganglion cells level (Inner Plexiform Layer parvocellular\n. channel model)\n. @param ganglionCellsSensitivity the compression strengh of the ganglion cells local adaptation\n. output, set a value between 0.6 and 1 for best results, a high value increases more the low\n. value sensitivity... and the output saturates faster, recommended value: 0.7"}, |  | 37334 | {"setupOPLandIPLParvoChannel", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_setupOPLandIPLParvoChannel, 0), "setupOPLandIPLParvoChannel([, colorMode[, normaliseOutput[, photoreceptorsLocalAdaptationSensitivity[, photoreceptorsTemporalConstant[, photoreceptorsSpatialConstant[, horizontalCellsGain[, HcellsTemporalConstant[, HcellsSpatialConstant[, ganglionCellsSensitivity]]]]]]]]]) -> None\n. @brief Setup the OPL and IPL parvo channels (see biologocal model)\n. \n. OPL is referred as Outer Plexiform Layer of the retina, it allows the spatio-temporal filtering\n. which withens the spectrum and reduces spatio-temporal noise while attenuating global luminance\n. (low frequency energy) IPL parvo is the OPL next processing stage, it refers to a part of the\n. Inner Plexiform layer of the retina, it allows high contours sensitivity in foveal vision. See\n. reference papers for more informations.\n. for more informations, please have a look at the paper Benoit A., Caplier A., Durette B., Herault, J., \"USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING\", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011\n. @param colorMode specifies if (true) color is processed of not (false) to then processing gray\n. level image\n. @param normaliseOutput specifies if (true) output is rescaled between 0 and 255 of not (false)\n. @param photoreceptorsLocalAdaptationSensitivity the photoreceptors sensitivity renage is 0-1\n. (more log compression effect when value increases)\n. @param photoreceptorsTemporalConstant the time constant of the first order low pass filter of\n. the photoreceptors, use it to cut high temporal frequencies (noise or fast motion), unit is\n. frames, typical value is 1 frame\n. @param photoreceptorsSpatialConstant the spatial constant of the first order low pass filter of\n. the photoreceptors, use it to cut high spatial frequencies (noise or thick contours), unit is\n. pixels, typical value is 1 pixel\n. @param horizontalCellsGain gain of the horizontal cells network, if 0, then the mean value of\n. the output is zero, if the parameter is near 1, then, the luminance is not filtered and is\n. still reachable at the output, typicall value is 0\n. @param HcellsTemporalConstant the time constant of the first order low pass filter of the\n. horizontal cells, use it to cut low temporal frequencies (local luminance variations), unit is\n. frames, typical value is 1 frame, as the photoreceptors\n. @param HcellsSpatialConstant the spatial constant of the first order low pass filter of the\n. horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels,\n. typical value is 5 pixel, this value is also used for local contrast computing when computing\n. the local contrast adaptation at the ganglion cells level (Inner Plexiform Layer parvocellular\n. channel model)\n. @param ganglionCellsSensitivity the compression strengh of the ganglion cells local adaptation\n. output, set a value between 0.6 and 1 for best results, a high value increases more the low\n. value sensitivity... and the output saturates faster, recommended value: 0.7"},
| 37383 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_write, 0), "write(fs) -> None\n. @brief Write xml/yml formated parameters information\n. @param fs the filename of the xml file that will be open and writen with formatted parameters\n. information"}, |  | 37335 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_Retina_write, 0), "write(fs) -> None\n. @brief Write xml/yml formated parameters information\n. @param fs the filename of the xml file that will be open and writen with formatted parameters\n. information"},
| 37384 |  |  | 37336 |
| 37385 | {NULL, NULL} |  | 37337 | {NULL, NULL}
| 37386 | }; |  | 37338 | };
| 37387 |  |  | 37339 |
| 37388 | // Converter (bioinspired_Retina) |  | 37340 | // Converter (bioinspired_Retina)
| 37389 |  |  | 37341 |
| 37390 | template<> |  | 37342 | template<>
| 37391 | struct PyOpenCV_Converter< Ptr<cv::bioinspired::Retina> > |  | 37343 | struct PyOpenCV_Converter< Ptr<cv::bioinspired::Retina> >
| 37392 | { |  | 37344 | {
| 37393 | static PyObject* from(const Ptr<cv::bioinspired::Retina>& r) |  | 37345 | static PyObject* from(const Ptr<cv::bioinspired::Retina>& r)
| 37394 | { |  | 37346 | {
| 37395 | return pyopencv_bioinspired_Retina_Instance(r); |  | 37347 | return pyopencv_bioinspired_Retina_Instance(r);
| 37396 | } |  | 37348 | }
| 37397 | static bool to(PyObject* src, Ptr<cv::bioinspired::Retina>& dst, const ArgInfo& info) |  | 37349 | static bool to(PyObject* src, Ptr<cv::bioinspired::Retina>& dst, const ArgInfo& info)
| 37398 | { |  | 37350 | {
| 37399 | if(!src || src == Py_None) |  | 37351 | if(!src || src == Py_None)
| 37400 | return true; |  | 37352 | return true;
| 37401 | Ptr<cv::bioinspired::Retina> * dst_; |  | 37353 | Ptr<cv::bioinspired::Retina> * dst_;
| 37402 | if (pyopencv_bioinspired_Retina_getp(src, dst_)) |  | 37354 | if (pyopencv_bioinspired_Retina_getp(src, dst_))
| 37403 | { |  | 37355 | {
| 37404 | dst = *dst_; |  | 37356 | dst = *dst_;
| 37405 | return true; |  | 37357 | return true;
| 37406 | } |  | 37358 | }
| 37407 |  |  | 37359 |
| 37408 | failmsg("Expected Ptr<cv::bioinspired::Retina> for argument '%s'", info.name); |  | 37360 | failmsg("Expected Ptr<cv::bioinspired::Retina> for argument '%s'", info.name);
| 37409 | return false; |  | 37361 | return false;
| 37410 | } |  | 37362 | }
| 37411 | }; |  | 37363 | };
| 37412 |  |  | 37364 |
| 37413 | //================================================================================ |  | 37365 | //================================================================================
| 37414 | // bioinspired_RetinaFastToneMapping (Generic) |  | 37366 | // bioinspired_RetinaFastToneMapping (Generic)
| 37415 | //================================================================================ |  | 37367 | //================================================================================
| 37416 |  |  | 37368 |
| 37417 | // GetSet (bioinspired_RetinaFastToneMapping) |  | 37369 | // GetSet (bioinspired_RetinaFastToneMapping)
| 37418 |  |  | 37370 |
| 37419 |  |  | 37371 |
| 37420 |  |  | 37372 |
| 37421 | // Methods (bioinspired_RetinaFastToneMapping) |  | 37373 | // Methods (bioinspired_RetinaFastToneMapping)
| 37422 |  |  | 37374 |
| 37423 | static PyObject* pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_applyFastToneMapping(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37375 | static PyObject* pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_applyFastToneMapping(PyObject* self, PyObject* py_args, PyObject* kw)
| 37424 | { |  | 37376 | {
| 37425 | using namespace cv::bioinspired; |  | 37377 | using namespace cv::bioinspired;
| 37426 |  |  | 37378 |
| 37427 |  |  | 37379 |
| 37428 | Ptr<cv::bioinspired::RetinaFastToneMapping> * self1 = 0; |  | 37380 | Ptr<cv::bioinspired::RetinaFastToneMapping> * self1 = 0;
| 37429 | if (!pyopencv_bioinspired_RetinaFastToneMapping_getp(self, self1)) |  | 37381 | if (!pyopencv_bioinspired_RetinaFastToneMapping_getp(self, self1))
| 37430 | return failmsgp("Incorrect type of self (must be 'bioinspired_RetinaFastToneMapping' or its derivative)"); |  | 37382 | return failmsgp("Incorrect type of self (must be 'bioinspired_RetinaFastToneMapping' or its derivative)");
| 37431 | Ptr<cv::bioinspired::RetinaFastToneMapping> _self_ = *(self1); |  | 37383 | Ptr<cv::bioinspired::RetinaFastToneMapping> _self_ = *(self1);
| 37432 | pyPrepareArgumentConversionErrorsStorage(2); |  | 37384 | pyPrepareArgumentConversionErrorsStorage(2);
| 37433 |  |  | 37385 |
| 37434 | { |  | 37386 | {
| 37435 | PyObject* pyobj_inputImage = NULL; |  | 37387 | PyObject* pyobj_inputImage = NULL;
| 37436 | Mat inputImage; |  | 37388 | Mat inputImage;
| 37437 | PyObject* pyobj_outputToneMappedImage = NULL; |  | 37389 | PyObject* pyobj_outputToneMappedImage = NULL;
| 37438 | Mat outputToneMappedImage; |  | 37390 | Mat outputToneMappedImage;
| 37439 |  |  | 37391 |
| 37440 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL }; |  | 37392 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL };
| 37441 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_RetinaFastToneMapping.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) && |  | 37393 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_RetinaFastToneMapping.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) &&
| 37442 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) && |  | 37394 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) &&
| 37443 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) ) |  | 37395 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) )
| 37444 | { |  | 37396 | {
| 37445 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage)); |  | 37397 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage));
| 37446 | return pyopencv_from(outputToneMappedImage); |  | 37398 | return pyopencv_from(outputToneMappedImage);
| 37447 | } |  | 37399 | }
| 37448 |  |  | 37400 |
| 37449 |  |  | 37401 |
| 37450 | pyPopulateArgumentConversionErrors(); |  | 37402 | pyPopulateArgumentConversionErrors();
| 37451 | } |  | 37403 | }
| 37452 |  |  | 37404 |
| 37453 |  |  | 37405 |
| 37454 | { |  | 37406 | {
| 37455 | PyObject* pyobj_inputImage = NULL; |  | 37407 | PyObject* pyobj_inputImage = NULL;
| 37456 | UMat inputImage; |  | 37408 | UMat inputImage;
| 37457 | PyObject* pyobj_outputToneMappedImage = NULL; |  | 37409 | PyObject* pyobj_outputToneMappedImage = NULL;
| 37458 | UMat outputToneMappedImage; |  | 37410 | UMat outputToneMappedImage;
| 37459 |  |  | 37411 |
| 37460 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL }; |  | 37412 | const char* keywords[] = { "inputImage", "outputToneMappedImage", NULL };
| 37461 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_RetinaFastToneMapping.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) && |  | 37413 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_RetinaFastToneMapping.applyFastToneMapping", (char**)keywords, &pyobj_inputImage, &pyobj_outputToneMappedImage) &&
| 37462 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) && |  | 37414 | pyopencv_to_safe(pyobj_inputImage, inputImage, ArgInfo("inputImage", 0)) &&
| 37463 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) ) |  | 37415 | pyopencv_to_safe(pyobj_outputToneMappedImage, outputToneMappedImage, ArgInfo("outputToneMappedImage", 1)) )
| 37464 | { |  | 37416 | {
| 37465 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage)); |  | 37417 | ERRWRAP2(_self_->applyFastToneMapping(inputImage, outputToneMappedImage));
| 37466 | return pyopencv_from(outputToneMappedImage); |  | 37418 | return pyopencv_from(outputToneMappedImage);
| 37467 | } |  | 37419 | }
| 37468 |  |  | 37420 |
| 37469 |  |  | 37421 |
| 37470 | pyPopulateArgumentConversionErrors(); |  | 37422 | pyPopulateArgumentConversionErrors();
| 37471 | } |  | 37423 | }
| 37472 | pyRaiseCVOverloadException("applyFastToneMapping"); |  | 37424 | pyRaiseCVOverloadException("applyFastToneMapping");
| 37473 |  |  | 37425 |
| 37474 | return NULL; |  | 37426 | return NULL;
| 37475 | } |  | 37427 | }
| 37476 |  |  | 37428 |
| 37477 | static PyObject* pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37429 | static PyObject* pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 37478 | { |  | 37430 | {
| 37479 | using namespace cv::bioinspired; |  | 37431 | using namespace cv::bioinspired;
| 37480 |  |  | 37432 |
| 37481 | PyObject* pyobj_inputSize = NULL; |  | 37433 | PyObject* pyobj_inputSize = NULL;
| 37482 | Size inputSize; |  | 37434 | Size inputSize;
| 37483 | Ptr<RetinaFastToneMapping> retval; |  | 37435 | Ptr<RetinaFastToneMapping> retval;
| 37484 |  |  | 37436 |
| 37485 | const char* keywords[] = { "inputSize", NULL }; |  | 37437 | const char* keywords[] = { "inputSize", NULL };
| 37486 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_RetinaFastToneMapping.create", (char**)keywords, &pyobj_inputSize) && |  | 37438 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_RetinaFastToneMapping.create", (char**)keywords, &pyobj_inputSize) &&
| 37487 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) ) |  | 37439 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) )
| 37488 | { |  | 37440 | {
| 37489 | ERRWRAP2(retval = cv::bioinspired::RetinaFastToneMapping::create(inputSize)); |  | 37441 | ERRWRAP2(retval = cv::bioinspired::RetinaFastToneMapping::create(inputSize));
| 37490 | return pyopencv_from(retval); |  | 37442 | return pyopencv_from(retval);
| 37491 | } |  | 37443 | }
| 37492 |  |  | 37444 |
| 37493 | return NULL; |  | 37445 | return NULL;
| 37494 | } |  | 37446 | }
| 37495 |  |  | 37447 |
| 37496 | static PyObject* pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_setup(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37448 | static PyObject* pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_setup(PyObject* self, PyObject* py_args, PyObject* kw)
| 37497 | { |  | 37449 | {
| 37498 | using namespace cv::bioinspired; |  | 37450 | using namespace cv::bioinspired;
| 37499 |  |  | 37451 |
| 37500 |  |  | 37452 |
| 37501 | Ptr<cv::bioinspired::RetinaFastToneMapping> * self1 = 0; |  | 37453 | Ptr<cv::bioinspired::RetinaFastToneMapping> * self1 = 0;
| 37502 | if (!pyopencv_bioinspired_RetinaFastToneMapping_getp(self, self1)) |  | 37454 | if (!pyopencv_bioinspired_RetinaFastToneMapping_getp(self, self1))
| 37503 | return failmsgp("Incorrect type of self (must be 'bioinspired_RetinaFastToneMapping' or its derivative)"); |  | 37455 | return failmsgp("Incorrect type of self (must be 'bioinspired_RetinaFastToneMapping' or its derivative)");
| 37504 | Ptr<cv::bioinspired::RetinaFastToneMapping> _self_ = *(self1); |  | 37456 | Ptr<cv::bioinspired::RetinaFastToneMapping> _self_ = *(self1);
| 37505 | PyObject* pyobj_photoreceptorsNeighborhoodRadius = NULL; |  | 37457 | PyObject* pyobj_photoreceptorsNeighborhoodRadius = NULL;
| 37506 | float photoreceptorsNeighborhoodRadius=3.f; |  | 37458 | float photoreceptorsNeighborhoodRadius=3.f;
| 37507 | PyObject* pyobj_ganglioncellsNeighborhoodRadius = NULL; |  | 37459 | PyObject* pyobj_ganglioncellsNeighborhoodRadius = NULL;
| 37508 | float ganglioncellsNeighborhoodRadius=1.f; |  | 37460 | float ganglioncellsNeighborhoodRadius=1.f;
| 37509 | PyObject* pyobj_meanLuminanceModulatorK = NULL; |  | 37461 | PyObject* pyobj_meanLuminanceModulatorK = NULL;
| 37510 | float meanLuminanceModulatorK=1.f; |  | 37462 | float meanLuminanceModulatorK=1.f;
| 37511 |  |  | 37463 |
| 37512 | const char* keywords[] = { "photoreceptorsNeighborhoodRadius", "ganglioncellsNeighborhoodRadius", "meanLuminanceModulatorK", NULL }; |  | 37464 | const char* keywords[] = { "photoreceptorsNeighborhoodRadius", "ganglioncellsNeighborhoodRadius", "meanLuminanceModulatorK", NULL };
| 37513 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:bioinspired_RetinaFastToneMapping.setup", (char**)keywords, &pyobj_photoreceptorsNeighborhoodRadius, &pyobj_ganglioncellsNeighborhoodRadius, &pyobj_meanLuminanceModulatorK) && |  | 37465 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:bioinspired_RetinaFastToneMapping.setup", (char**)keywords, &pyobj_photoreceptorsNeighborhoodRadius, &pyobj_ganglioncellsNeighborhoodRadius, &pyobj_meanLuminanceModulatorK) &&
| 37514 | pyopencv_to_safe(pyobj_photoreceptorsNeighborhoodRadius, photoreceptorsNeighborhoodRadius, ArgInfo("photoreceptorsNeighborhoodRadius", 0)) && |  | 37466 | pyopencv_to_safe(pyobj_photoreceptorsNeighborhoodRadius, photoreceptorsNeighborhoodRadius, ArgInfo("photoreceptorsNeighborhoodRadius", 0)) &&
| 37515 | pyopencv_to_safe(pyobj_ganglioncellsNeighborhoodRadius, ganglioncellsNeighborhoodRadius, ArgInfo("ganglioncellsNeighborhoodRadius", 0)) && |  | 37467 | pyopencv_to_safe(pyobj_ganglioncellsNeighborhoodRadius, ganglioncellsNeighborhoodRadius, ArgInfo("ganglioncellsNeighborhoodRadius", 0)) &&
| 37516 | pyopencv_to_safe(pyobj_meanLuminanceModulatorK, meanLuminanceModulatorK, ArgInfo("meanLuminanceModulatorK", 0)) ) |  | 37468 | pyopencv_to_safe(pyobj_meanLuminanceModulatorK, meanLuminanceModulatorK, ArgInfo("meanLuminanceModulatorK", 0)) )
| 37517 | { |  | 37469 | {
| 37518 | ERRWRAP2(_self_->setup(photoreceptorsNeighborhoodRadius, ganglioncellsNeighborhoodRadius, meanLuminanceModulatorK)); |  | 37470 | ERRWRAP2(_self_->setup(photoreceptorsNeighborhoodRadius, ganglioncellsNeighborhoodRadius, meanLuminanceModulatorK));
| 37519 | Py_RETURN_NONE; |  | 37471 | Py_RETURN_NONE;
| 37520 | } |  | 37472 | }
| 37521 |  |  | 37473 |
| 37522 | return NULL; |  | 37474 | return NULL;
| 37523 | } |  | 37475 | }
| 37524 |  |  | 37476 |
| 37525 |  |  | 37477 |
| 37526 |  |  | 37478 |
| 37527 | // Tables (bioinspired_RetinaFastToneMapping) |  | 37479 | // Tables (bioinspired_RetinaFastToneMapping)
| 37528 |  |  | 37480 |
| 37529 | static PyGetSetDef pyopencv_bioinspired_RetinaFastToneMapping_getseters[] = |  | 37481 | static PyGetSetDef pyopencv_bioinspired_RetinaFastToneMapping_getseters[] =
| 37530 | { |  | 37482 | {
| 37531 | {NULL} /* Sentinel */ |  | 37483 | {NULL} /* Sentinel */
| 37532 | }; |  | 37484 | };
| 37533 |  |  | 37485 |
| 37534 | static PyMethodDef pyopencv_bioinspired_RetinaFastToneMapping_methods[] = |  | 37486 | static PyMethodDef pyopencv_bioinspired_RetinaFastToneMapping_methods[] =
| 37535 | { |  | 37487 | {
| 37536 | {"applyFastToneMapping", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_applyFastToneMapping, 0), "applyFastToneMapping(inputImage[, outputToneMappedImage]) -> outputToneMappedImage\n. @brief applies a luminance correction (initially High Dynamic Range (HDR) tone mapping)\n. \n. using only the 2 local adaptation stages of the retina parvocellular channel : photoreceptors\n. level and ganlion cells level. Spatio temporal filtering is applied but limited to temporal\n. smoothing and eventually high frequencies attenuation. This is a lighter method than the one\n. available using the regular retina::run method. It is then faster but it does not include\n. complete temporal filtering nor retina spectral whitening. Then, it can have a more limited\n. effect on images with a very high dynamic range. This is an adptation of the original still\n. image HDR tone mapping algorithm of David Alleyson, Sabine Susstruck and Laurence Meylan's\n. work, please cite: -> Meylan L., Alleysson D., and Susstrunk S., A Model of Retinal Local\n. Adaptation for the Tone Mapping of Color Filter Array Images, Journal of Optical Society of\n. America, A, Vol. 24, N 9, September, 1st, 2007, pp. 2807-2816\n. \n. @param inputImage the input image to process RGB or gray levels\n. @param outputToneMappedImage the output tone mapped image"}, |  | 37488 | {"applyFastToneMapping", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_applyFastToneMapping, 0), "applyFastToneMapping(inputImage[, outputToneMappedImage]) -> outputToneMappedImage\n. @brief applies a luminance correction (initially High Dynamic Range (HDR) tone mapping)\n. \n. using only the 2 local adaptation stages of the retina parvocellular channel : photoreceptors\n. level and ganlion cells level. Spatio temporal filtering is applied but limited to temporal\n. smoothing and eventually high frequencies attenuation. This is a lighter method than the one\n. available using the regular retina::run method. It is then faster but it does not include\n. complete temporal filtering nor retina spectral whitening. Then, it can have a more limited\n. effect on images with a very high dynamic range. This is an adptation of the original still\n. image HDR tone mapping algorithm of David Alleyson, Sabine Susstruck and Laurence Meylan's\n. work, please cite: -> Meylan L., Alleysson D., and Susstrunk S., A Model of Retinal Local\n. Adaptation for the Tone Mapping of Color Filter Array Images, Journal of Optical Society of\n. America, A, Vol. 24, N 9, September, 1st, 2007, pp. 2807-2816\n. \n. @param inputImage the input image to process RGB or gray levels\n. @param outputToneMappedImage the output tone mapped image"},
| 37537 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_create_static, METH_STATIC), "create(inputSize) -> retval\n."}, |  | 37489 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_create_static, METH_STATIC), "create(inputSize) -> retval\n."},
| 37538 | {"setup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_setup, 0), "setup([, photoreceptorsNeighborhoodRadius[, ganglioncellsNeighborhoodRadius[, meanLuminanceModulatorK]]]) -> None\n. @brief updates tone mapping behaviors by adjusing the local luminance computation area\n. \n. @param photoreceptorsNeighborhoodRadius the first stage local adaptation area\n. @param ganglioncellsNeighborhoodRadius the second stage local adaptation area\n. @param meanLuminanceModulatorK the factor applied to modulate the meanLuminance information\n. (default is 1, see reference paper)"}, |  | 37490 | {"setup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_RetinaFastToneMapping_setup, 0), "setup([, photoreceptorsNeighborhoodRadius[, ganglioncellsNeighborhoodRadius[, meanLuminanceModulatorK]]]) -> None\n. @brief updates tone mapping behaviors by adjusing the local luminance computation area\n. \n. @param photoreceptorsNeighborhoodRadius the first stage local adaptation area\n. @param ganglioncellsNeighborhoodRadius the second stage local adaptation area\n. @param meanLuminanceModulatorK the factor applied to modulate the meanLuminance information\n. (default is 1, see reference paper)"},
| 37539 |  |  | 37491 |
| 37540 | {NULL, NULL} |  | 37492 | {NULL, NULL}
| 37541 | }; |  | 37493 | };
| 37542 |  |  | 37494 |
| 37543 | // Converter (bioinspired_RetinaFastToneMapping) |  | 37495 | // Converter (bioinspired_RetinaFastToneMapping)
| 37544 |  |  | 37496 |
| 37545 | template<> |  | 37497 | template<>
| 37546 | struct PyOpenCV_Converter< Ptr<cv::bioinspired::RetinaFastToneMapping> > |  | 37498 | struct PyOpenCV_Converter< Ptr<cv::bioinspired::RetinaFastToneMapping> >
| 37547 | { |  | 37499 | {
| 37548 | static PyObject* from(const Ptr<cv::bioinspired::RetinaFastToneMapping>& r) |  | 37500 | static PyObject* from(const Ptr<cv::bioinspired::RetinaFastToneMapping>& r)
| 37549 | { |  | 37501 | {
| 37550 | return pyopencv_bioinspired_RetinaFastToneMapping_Instance(r); |  | 37502 | return pyopencv_bioinspired_RetinaFastToneMapping_Instance(r);
| 37551 | } |  | 37503 | }
| 37552 | static bool to(PyObject* src, Ptr<cv::bioinspired::RetinaFastToneMapping>& dst, const ArgInfo& info) |  | 37504 | static bool to(PyObject* src, Ptr<cv::bioinspired::RetinaFastToneMapping>& dst, const ArgInfo& info)
| 37553 | { |  | 37505 | {
| 37554 | if(!src || src == Py_None) |  | 37506 | if(!src || src == Py_None)
| 37555 | return true; |  | 37507 | return true;
| 37556 | Ptr<cv::bioinspired::RetinaFastToneMapping> * dst_; |  | 37508 | Ptr<cv::bioinspired::RetinaFastToneMapping> * dst_;
| 37557 | if (pyopencv_bioinspired_RetinaFastToneMapping_getp(src, dst_)) |  | 37509 | if (pyopencv_bioinspired_RetinaFastToneMapping_getp(src, dst_))
| 37558 | { |  | 37510 | {
| 37559 | dst = *dst_; |  | 37511 | dst = *dst_;
| 37560 | return true; |  | 37512 | return true;
| 37561 | } |  | 37513 | }
| 37562 |  |  | 37514 |
| 37563 | failmsg("Expected Ptr<cv::bioinspired::RetinaFastToneMapping> for argument '%s'", info.name); |  | 37515 | failmsg("Expected Ptr<cv::bioinspired::RetinaFastToneMapping> for argument '%s'", info.name);
| 37564 | return false; |  | 37516 | return false;
| 37565 | } |  | 37517 | }
| 37566 | }; |  | 37518 | };
| 37567 |  |  | 37519 |
| 37568 | //================================================================================ |  | 37520 | //================================================================================
| 37569 | // bioinspired_TransientAreasSegmentationModule (Generic) |  | 37521 | // bioinspired_TransientAreasSegmentationModule (Generic)
| 37570 | //================================================================================ |  | 37522 | //================================================================================
| 37571 |  |  | 37523 |
| 37572 | // GetSet (bioinspired_TransientAreasSegmentationModule) |  | 37524 | // GetSet (bioinspired_TransientAreasSegmentationModule)
| 37573 |  |  | 37525 |
| 37574 |  |  | 37526 |
| 37575 |  |  | 37527 |
| 37576 | // Methods (bioinspired_TransientAreasSegmentationModule) |  | 37528 | // Methods (bioinspired_TransientAreasSegmentationModule)
| 37577 |  |  | 37529 |
| 37578 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_clearAllBuffers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37530 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_clearAllBuffers(PyObject* self, PyObject* py_args, PyObject* kw)
| 37579 | { |  | 37531 | {
| 37580 | using namespace cv::bioinspired; |  | 37532 | using namespace cv::bioinspired;
| 37581 |  |  | 37533 |
| 37582 |  |  | 37534 |
| 37583 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0; |  | 37535 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0;
| 37584 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1)) |  | 37536 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1))
| 37585 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)"); |  | 37537 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)");
| 37586 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1); |  | 37538 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1);
| 37587 |  |  | 37539 |
| 37588 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37540 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37589 | { |  | 37541 | {
| 37590 | ERRWRAP2(_self_->clearAllBuffers()); |  | 37542 | ERRWRAP2(_self_->clearAllBuffers());
| 37591 | Py_RETURN_NONE; |  | 37543 | Py_RETURN_NONE;
| 37592 | } |  | 37544 | }
| 37593 |  |  | 37545 |
| 37594 | return NULL; |  | 37546 | return NULL;
| 37595 | } |  | 37547 | }
| 37596 |  |  | 37548 |
| 37597 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37549 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 37598 | { |  | 37550 | {
| 37599 | using namespace cv::bioinspired; |  | 37551 | using namespace cv::bioinspired;
| 37600 |  |  | 37552 |
| 37601 | PyObject* pyobj_inputSize = NULL; |  | 37553 | PyObject* pyobj_inputSize = NULL;
| 37602 | Size inputSize; |  | 37554 | Size inputSize;
| 37603 | Ptr<TransientAreasSegmentationModule> retval; |  | 37555 | Ptr<TransientAreasSegmentationModule> retval;
| 37604 |  |  | 37556 |
| 37605 | const char* keywords[] = { "inputSize", NULL }; |  | 37557 | const char* keywords[] = { "inputSize", NULL };
| 37606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_TransientAreasSegmentationModule.create", (char**)keywords, &pyobj_inputSize) && |  | 37558 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_TransientAreasSegmentationModule.create", (char**)keywords, &pyobj_inputSize) &&
| 37607 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) ) |  | 37559 | pyopencv_to_safe(pyobj_inputSize, inputSize, ArgInfo("inputSize", 0)) )
| 37608 | { |  | 37560 | {
| 37609 | ERRWRAP2(retval = cv::bioinspired::TransientAreasSegmentationModule::create(inputSize)); |  | 37561 | ERRWRAP2(retval = cv::bioinspired::TransientAreasSegmentationModule::create(inputSize));
| 37610 | return pyopencv_from(retval); |  | 37562 | return pyopencv_from(retval);
| 37611 | } |  | 37563 | }
| 37612 |  |  | 37564 |
| 37613 | return NULL; |  | 37565 | return NULL;
| 37614 | } |  | 37566 | }
| 37615 |  |  | 37567 |
| 37616 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSegmentationPicture(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37568 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSegmentationPicture(PyObject* self, PyObject* py_args, PyObject* kw)
| 37617 | { |  | 37569 | {
| 37618 | using namespace cv::bioinspired; |  | 37570 | using namespace cv::bioinspired;
| 37619 |  |  | 37571 |
| 37620 |  |  | 37572 |
| 37621 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0; |  | 37573 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0;
| 37622 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1)) |  | 37574 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1))
| 37623 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)"); |  | 37575 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)");
| 37624 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1); |  | 37576 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1);
| 37625 | pyPrepareArgumentConversionErrorsStorage(2); |  | 37577 | pyPrepareArgumentConversionErrorsStorage(2);
| 37626 |  |  | 37578 |
| 37627 | { |  | 37579 | {
| 37628 | PyObject* pyobj_transientAreas = NULL; |  | 37580 | PyObject* pyobj_transientAreas = NULL;
| 37629 | Mat transientAreas; |  | 37581 | Mat transientAreas;
| 37630 |  |  | 37582 |
| 37631 | const char* keywords[] = { "transientAreas", NULL }; |  | 37583 | const char* keywords[] = { "transientAreas", NULL };
| 37632 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_TransientAreasSegmentationModule.getSegmentationPicture", (char**)keywords, &pyobj_transientAreas) && |  | 37584 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_TransientAreasSegmentationModule.getSegmentationPicture", (char**)keywords, &pyobj_transientAreas) &&
| 37633 | pyopencv_to_safe(pyobj_transientAreas, transientAreas, ArgInfo("transientAreas", 1)) ) |  | 37585 | pyopencv_to_safe(pyobj_transientAreas, transientAreas, ArgInfo("transientAreas", 1)) )
| 37634 | { |  | 37586 | {
| 37635 | ERRWRAP2(_self_->getSegmentationPicture(transientAreas)); |  | 37587 | ERRWRAP2(_self_->getSegmentationPicture(transientAreas));
| 37636 | return pyopencv_from(transientAreas); |  | 37588 | return pyopencv_from(transientAreas);
| 37637 | } |  | 37589 | }
| 37638 |  |  | 37590 |
| 37639 |  |  | 37591 |
| 37640 | pyPopulateArgumentConversionErrors(); |  | 37592 | pyPopulateArgumentConversionErrors();
| 37641 | } |  | 37593 | }
| 37642 |  |  | 37594 |
| 37643 |  |  | 37595 |
| 37644 | { |  | 37596 | {
| 37645 | PyObject* pyobj_transientAreas = NULL; |  | 37597 | PyObject* pyobj_transientAreas = NULL;
| 37646 | UMat transientAreas; |  | 37598 | UMat transientAreas;
| 37647 |  |  | 37599 |
| 37648 | const char* keywords[] = { "transientAreas", NULL }; |  | 37600 | const char* keywords[] = { "transientAreas", NULL };
| 37649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_TransientAreasSegmentationModule.getSegmentationPicture", (char**)keywords, &pyobj_transientAreas) && |  | 37601 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:bioinspired_TransientAreasSegmentationModule.getSegmentationPicture", (char**)keywords, &pyobj_transientAreas) &&
| 37650 | pyopencv_to_safe(pyobj_transientAreas, transientAreas, ArgInfo("transientAreas", 1)) ) |  | 37602 | pyopencv_to_safe(pyobj_transientAreas, transientAreas, ArgInfo("transientAreas", 1)) )
| 37651 | { |  | 37603 | {
| 37652 | ERRWRAP2(_self_->getSegmentationPicture(transientAreas)); |  | 37604 | ERRWRAP2(_self_->getSegmentationPicture(transientAreas));
| 37653 | return pyopencv_from(transientAreas); |  | 37605 | return pyopencv_from(transientAreas);
| 37654 | } |  | 37606 | }
| 37655 |  |  | 37607 |
| 37656 |  |  | 37608 |
| 37657 | pyPopulateArgumentConversionErrors(); |  | 37609 | pyPopulateArgumentConversionErrors();
| 37658 | } |  | 37610 | }
| 37659 | pyRaiseCVOverloadException("getSegmentationPicture"); |  | 37611 | pyRaiseCVOverloadException("getSegmentationPicture");
| 37660 |  |  | 37612 |
| 37661 | return NULL; |  | 37613 | return NULL;
| 37662 | } |  | 37614 | }
| 37663 |  |  | 37615 |
| 37664 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37616 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 37665 | { |  | 37617 | {
| 37666 | using namespace cv::bioinspired; |  | 37618 | using namespace cv::bioinspired;
| 37667 |  |  | 37619 |
| 37668 |  |  | 37620 |
| 37669 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0; |  | 37621 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0;
| 37670 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1)) |  | 37622 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1))
| 37671 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)"); |  | 37623 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)");
| 37672 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1); |  | 37624 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1);
| 37673 | Size retval; |  | 37625 | Size retval;
| 37674 |  |  | 37626 |
| 37675 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37627 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37676 | { |  | 37628 | {
| 37677 | ERRWRAP2(retval = _self_->getSize()); |  | 37629 | ERRWRAP2(retval = _self_->getSize());
| 37678 | return pyopencv_from(retval); |  | 37630 | return pyopencv_from(retval);
| 37679 | } |  | 37631 | }
| 37680 |  |  | 37632 |
| 37681 | return NULL; |  | 37633 | return NULL;
| 37682 | } |  | 37634 | }
| 37683 |  |  | 37635 |
| 37684 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_printSetup(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37636 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_printSetup(PyObject* self, PyObject* py_args, PyObject* kw)
| 37685 | { |  | 37637 | {
| 37686 | using namespace cv::bioinspired; |  | 37638 | using namespace cv::bioinspired;
| 37687 |  |  | 37639 |
| 37688 |  |  | 37640 |
| 37689 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0; |  | 37641 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0;
| 37690 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1)) |  | 37642 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1))
| 37691 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)"); |  | 37643 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)");
| 37692 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1); |  | 37644 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1);
| 37693 | String retval; |  | 37645 | String retval;
| 37694 |  |  | 37646 |
| 37695 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37647 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37696 | { |  | 37648 | {
| 37697 | ERRWRAP2(retval = _self_->printSetup()); |  | 37649 | ERRWRAP2(retval = _self_->printSetup());
| 37698 | return pyopencv_from(retval); |  | 37650 | return pyopencv_from(retval);
| 37699 | } |  | 37651 | }
| 37700 |  |  | 37652 |
| 37701 | return NULL; |  | 37653 | return NULL;
| 37702 | } |  | 37654 | }
| 37703 |  |  | 37655 |
| 37704 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_run(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37656 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_run(PyObject* self, PyObject* py_args, PyObject* kw)
| 37705 | { |  | 37657 | {
| 37706 | using namespace cv::bioinspired; |  | 37658 | using namespace cv::bioinspired;
| 37707 |  |  | 37659 |
| 37708 |  |  | 37660 |
| 37709 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0; |  | 37661 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0;
| 37710 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1)) |  | 37662 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1))
| 37711 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)"); |  | 37663 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)");
| 37712 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1); |  | 37664 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1);
| 37713 | pyPrepareArgumentConversionErrorsStorage(2); |  | 37665 | pyPrepareArgumentConversionErrorsStorage(2);
| 37714 |  |  | 37666 |
| 37715 | { |  | 37667 | {
| 37716 | PyObject* pyobj_inputToSegment = NULL; |  | 37668 | PyObject* pyobj_inputToSegment = NULL;
| 37717 | Mat inputToSegment; |  | 37669 | Mat inputToSegment;
| 37718 | PyObject* pyobj_channelIndex = NULL; |  | 37670 | PyObject* pyobj_channelIndex = NULL;
| 37719 | int channelIndex=0; |  | 37671 | int channelIndex=0;
| 37720 |  |  | 37672 |
| 37721 | const char* keywords[] = { "inputToSegment", "channelIndex", NULL }; |  | 37673 | const char* keywords[] = { "inputToSegment", "channelIndex", NULL };
| 37722 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_TransientAreasSegmentationModule.run", (char**)keywords, &pyobj_inputToSegment, &pyobj_channelIndex) && |  | 37674 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_TransientAreasSegmentationModule.run", (char**)keywords, &pyobj_inputToSegment, &pyobj_channelIndex) &&
| 37723 | pyopencv_to_safe(pyobj_inputToSegment, inputToSegment, ArgInfo("inputToSegment", 0)) && |  | 37675 | pyopencv_to_safe(pyobj_inputToSegment, inputToSegment, ArgInfo("inputToSegment", 0)) &&
| 37724 | pyopencv_to_safe(pyobj_channelIndex, channelIndex, ArgInfo("channelIndex", 0)) ) |  | 37676 | pyopencv_to_safe(pyobj_channelIndex, channelIndex, ArgInfo("channelIndex", 0)) )
| 37725 | { |  | 37677 | {
| 37726 | ERRWRAP2(_self_->run(inputToSegment, channelIndex)); |  | 37678 | ERRWRAP2(_self_->run(inputToSegment, channelIndex));
| 37727 | Py_RETURN_NONE; |  | 37679 | Py_RETURN_NONE;
| 37728 | } |  | 37680 | }
| 37729 |  |  | 37681 |
| 37730 |  |  | 37682 |
| 37731 | pyPopulateArgumentConversionErrors(); |  | 37683 | pyPopulateArgumentConversionErrors();
| 37732 | } |  | 37684 | }
| 37733 |  |  | 37685 |
| 37734 |  |  | 37686 |
| 37735 | { |  | 37687 | {
| 37736 | PyObject* pyobj_inputToSegment = NULL; |  | 37688 | PyObject* pyobj_inputToSegment = NULL;
| 37737 | UMat inputToSegment; |  | 37689 | UMat inputToSegment;
| 37738 | PyObject* pyobj_channelIndex = NULL; |  | 37690 | PyObject* pyobj_channelIndex = NULL;
| 37739 | int channelIndex=0; |  | 37691 | int channelIndex=0;
| 37740 |  |  | 37692 |
| 37741 | const char* keywords[] = { "inputToSegment", "channelIndex", NULL }; |  | 37693 | const char* keywords[] = { "inputToSegment", "channelIndex", NULL };
| 37742 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_TransientAreasSegmentationModule.run", (char**)keywords, &pyobj_inputToSegment, &pyobj_channelIndex) && |  | 37694 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:bioinspired_TransientAreasSegmentationModule.run", (char**)keywords, &pyobj_inputToSegment, &pyobj_channelIndex) &&
| 37743 | pyopencv_to_safe(pyobj_inputToSegment, inputToSegment, ArgInfo("inputToSegment", 0)) && |  | 37695 | pyopencv_to_safe(pyobj_inputToSegment, inputToSegment, ArgInfo("inputToSegment", 0)) &&
| 37744 | pyopencv_to_safe(pyobj_channelIndex, channelIndex, ArgInfo("channelIndex", 0)) ) |  | 37696 | pyopencv_to_safe(pyobj_channelIndex, channelIndex, ArgInfo("channelIndex", 0)) )
| 37745 | { |  | 37697 | {
| 37746 | ERRWRAP2(_self_->run(inputToSegment, channelIndex)); |  | 37698 | ERRWRAP2(_self_->run(inputToSegment, channelIndex));
| 37747 | Py_RETURN_NONE; |  | 37699 | Py_RETURN_NONE;
| 37748 | } |  | 37700 | }
| 37749 |  |  | 37701 |
| 37750 |  |  | 37702 |
| 37751 | pyPopulateArgumentConversionErrors(); |  | 37703 | pyPopulateArgumentConversionErrors();
| 37752 | } |  | 37704 | }
| 37753 | pyRaiseCVOverloadException("run"); |  | 37705 | pyRaiseCVOverloadException("run");
| 37754 |  |  | 37706 |
| 37755 | return NULL; |  | 37707 | return NULL;
| 37756 | } |  | 37708 | }
| 37757 |  |  | 37709 |
| 37758 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_setup(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37710 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_setup(PyObject* self, PyObject* py_args, PyObject* kw)
| 37759 | { |  | 37711 | {
| 37760 | using namespace cv::bioinspired; |  | 37712 | using namespace cv::bioinspired;
| 37761 |  |  | 37713 |
| 37762 |  |  | 37714 |
| 37763 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0; |  | 37715 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0;
| 37764 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1)) |  | 37716 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1))
| 37765 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)"); |  | 37717 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)");
| 37766 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1); |  | 37718 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1);
| 37767 | PyObject* pyobj_segmentationParameterFile = NULL; |  | 37719 | PyObject* pyobj_segmentationParameterFile = NULL;
| 37768 | String segmentationParameterFile=""; |  | 37720 | String segmentationParameterFile="";
| 37769 | PyObject* pyobj_applyDefaultSetupOnFailure = NULL; |  | 37721 | PyObject* pyobj_applyDefaultSetupOnFailure = NULL;
| 37770 | bool applyDefaultSetupOnFailure=true; |  | 37722 | bool applyDefaultSetupOnFailure=true;
| 37771 |  |  | 37723 |
| 37772 | const char* keywords[] = { "segmentationParameterFile", "applyDefaultSetupOnFailure", NULL }; |  | 37724 | const char* keywords[] = { "segmentationParameterFile", "applyDefaultSetupOnFailure", NULL };
| 37773 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bioinspired_TransientAreasSegmentationModule.setup", (char**)keywords, &pyobj_segmentationParameterFile, &pyobj_applyDefaultSetupOnFailure) && |  | 37725 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:bioinspired_TransientAreasSegmentationModule.setup", (char**)keywords, &pyobj_segmentationParameterFile, &pyobj_applyDefaultSetupOnFailure) &&
| 37774 | pyopencv_to_safe(pyobj_segmentationParameterFile, segmentationParameterFile, ArgInfo("segmentationParameterFile", 0)) && |  | 37726 | pyopencv_to_safe(pyobj_segmentationParameterFile, segmentationParameterFile, ArgInfo("segmentationParameterFile", 0)) &&
| 37775 | pyopencv_to_safe(pyobj_applyDefaultSetupOnFailure, applyDefaultSetupOnFailure, ArgInfo("applyDefaultSetupOnFailure", 0)) ) |  | 37727 | pyopencv_to_safe(pyobj_applyDefaultSetupOnFailure, applyDefaultSetupOnFailure, ArgInfo("applyDefaultSetupOnFailure", 0)) )
| 37776 | { |  | 37728 | {
| 37777 | ERRWRAP2(_self_->setup(segmentationParameterFile, applyDefaultSetupOnFailure)); |  | 37729 | ERRWRAP2(_self_->setup(segmentationParameterFile, applyDefaultSetupOnFailure));
| 37778 | Py_RETURN_NONE; |  | 37730 | Py_RETURN_NONE;
| 37779 | } |  | 37731 | }
| 37780 |  |  | 37732 |
| 37781 | return NULL; |  | 37733 | return NULL;
| 37782 | } |  | 37734 | }
| 37783 |  |  | 37735 |
| 37784 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37736 | static PyObject* pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 37785 | { |  | 37737 | {
| 37786 | using namespace cv::bioinspired; |  | 37738 | using namespace cv::bioinspired;
| 37787 |  |  | 37739 |
| 37788 |  |  | 37740 |
| 37789 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0; |  | 37741 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * self1 = 0;
| 37790 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1)) |  | 37742 | if (!pyopencv_bioinspired_TransientAreasSegmentationModule_getp(self, self1))
| 37791 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)"); |  | 37743 | return failmsgp("Incorrect type of self (must be 'bioinspired_TransientAreasSegmentationModule' or its derivative)");
| 37792 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1); |  | 37744 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> _self_ = *(self1);
| 37793 | PyObject* pyobj_fs = NULL; |  | 37745 | PyObject* pyobj_fs = NULL;
| 37794 | String fs; |  | 37746 | String fs;
| 37795 |  |  | 37747 |
| 37796 | const char* keywords[] = { "fs", NULL }; |  | 37748 | const char* keywords[] = { "fs", NULL };
| 37797 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_TransientAreasSegmentationModule.write", (char**)keywords, &pyobj_fs) && |  | 37749 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:bioinspired_TransientAreasSegmentationModule.write", (char**)keywords, &pyobj_fs) &&
| 37798 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) ) |  | 37750 | pyopencv_to_safe(pyobj_fs, fs, ArgInfo("fs", 0)) )
| 37799 | { |  | 37751 | {
| 37800 | ERRWRAP2(_self_->write(fs)); |  | 37752 | ERRWRAP2(_self_->write(fs));
| 37801 | Py_RETURN_NONE; |  | 37753 | Py_RETURN_NONE;
| 37802 | } |  | 37754 | }
| 37803 |  |  | 37755 |
| 37804 | return NULL; |  | 37756 | return NULL;
| 37805 | } |  | 37757 | }
| 37806 |  |  | 37758 |
| 37807 |  |  | 37759 |
| 37808 |  |  | 37760 |
| 37809 | // Tables (bioinspired_TransientAreasSegmentationModule) |  | 37761 | // Tables (bioinspired_TransientAreasSegmentationModule)
| 37810 |  |  | 37762 |
| 37811 | static PyGetSetDef pyopencv_bioinspired_TransientAreasSegmentationModule_getseters[] = |  | 37763 | static PyGetSetDef pyopencv_bioinspired_TransientAreasSegmentationModule_getseters[] =
| 37812 | { |  | 37764 | {
| 37813 | {NULL} /* Sentinel */ |  | 37765 | {NULL} /* Sentinel */
| 37814 | }; |  | 37766 | };
| 37815 |  |  | 37767 |
| 37816 | static PyMethodDef pyopencv_bioinspired_TransientAreasSegmentationModule_methods[] = |  | 37768 | static PyMethodDef pyopencv_bioinspired_TransientAreasSegmentationModule_methods[] =
| 37817 | { |  | 37769 | {
| 37818 | {"clearAllBuffers", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_clearAllBuffers, 0), "clearAllBuffers() -> None\n. @brief cleans all the buffers of the instance"}, |  | 37770 | {"clearAllBuffers", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_clearAllBuffers, 0), "clearAllBuffers() -> None\n. @brief cleans all the buffers of the instance"},
| 37819 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_create_static, METH_STATIC), "create(inputSize) -> retval\n. @brief allocator\n. @param inputSize : size of the images input to segment (output will be the same size)"}, |  | 37771 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_create_static, METH_STATIC), "create(inputSize) -> retval\n. @brief allocator\n. @param inputSize : size of the images input to segment (output will be the same size)"},
| 37820 | {"getSegmentationPicture", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSegmentationPicture, 0), "getSegmentationPicture([, transientAreas]) -> transientAreas\n. @brief access function\n. return the last segmentation result: a boolean picture which is resampled between 0 and 255 for a display purpose"}, |  | 37772 | {"getSegmentationPicture", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSegmentationPicture, 0), "getSegmentationPicture([, transientAreas]) -> transientAreas\n. @brief access function\n. return the last segmentation result: a boolean picture which is resampled between 0 and 255 for a display purpose"},
| 37821 | {"getSize", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSize, 0), "getSize() -> retval\n. @brief return the sze of the manage input and output images"}, |  | 37773 | {"getSize", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_getSize, 0), "getSize() -> retval\n. @brief return the sze of the manage input and output images"},
| 37822 | {"printSetup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_printSetup, 0), "printSetup() -> retval\n. @brief parameters setup display method\n. @return a string which contains formatted parameters information"}, |  | 37774 | {"printSetup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_printSetup, 0), "printSetup() -> retval\n. @brief parameters setup display method\n. @return a string which contains formatted parameters information"},
| 37823 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_run, 0), "run(inputToSegment[, channelIndex]) -> None\n. @brief main processing method, get result using methods getSegmentationPicture()\n. @param inputToSegment : the image to process, it must match the instance buffer size !\n. @param channelIndex : the channel to process in case of multichannel images"}, |  | 37775 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_run, 0), "run(inputToSegment[, channelIndex]) -> None\n. @brief main processing method, get result using methods getSegmentationPicture()\n. @param inputToSegment : the image to process, it must match the instance buffer size !\n. @param channelIndex : the channel to process in case of multichannel images"},
| 37824 | {"setup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_setup, 0), "setup([, segmentationParameterFile[, applyDefaultSetupOnFailure]]) -> None\n. @brief try to open an XML segmentation parameters file to adjust current segmentation instance setup\n. \n. - if the xml file does not exist, then default setup is applied\n. - warning, Exceptions are thrown if read XML file is not valid\n. @param segmentationParameterFile : the parameters filename\n. @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error"}, |  | 37776 | {"setup", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_setup, 0), "setup([, segmentationParameterFile[, applyDefaultSetupOnFailure]]) -> None\n. @brief try to open an XML segmentation parameters file to adjust current segmentation instance setup\n. \n. - if the xml file does not exist, then default setup is applied\n. - warning, Exceptions are thrown if read XML file is not valid\n. @param segmentationParameterFile : the parameters filename\n. @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error"},
| 37825 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_write, 0), "write(fs) -> None\n. @brief write xml/yml formated parameters information\n. @param fs : the filename of the xml file that will be open and writen with formatted parameters information"}, |  | 37777 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_bioinspired_bioinspired_TransientAreasSegmentationModule_write, 0), "write(fs) -> None\n. @brief write xml/yml formated parameters information\n. @param fs : the filename of the xml file that will be open and writen with formatted parameters information"},
| 37826 |  |  | 37778 |
| 37827 | {NULL, NULL} |  | 37779 | {NULL, NULL}
| 37828 | }; |  | 37780 | };
| 37829 |  |  | 37781 |
| 37830 | // Converter (bioinspired_TransientAreasSegmentationModule) |  | 37782 | // Converter (bioinspired_TransientAreasSegmentationModule)
| 37831 |  |  | 37783 |
| 37832 | template<> |  | 37784 | template<>
| 37833 | struct PyOpenCV_Converter< Ptr<cv::bioinspired::TransientAreasSegmentationModule> > |  | 37785 | struct PyOpenCV_Converter< Ptr<cv::bioinspired::TransientAreasSegmentationModule> >
| 37834 | { |  | 37786 | {
| 37835 | static PyObject* from(const Ptr<cv::bioinspired::TransientAreasSegmentationModule>& r) |  | 37787 | static PyObject* from(const Ptr<cv::bioinspired::TransientAreasSegmentationModule>& r)
| 37836 | { |  | 37788 | {
| 37837 | return pyopencv_bioinspired_TransientAreasSegmentationModule_Instance(r); |  | 37789 | return pyopencv_bioinspired_TransientAreasSegmentationModule_Instance(r);
| 37838 | } |  | 37790 | }
| 37839 | static bool to(PyObject* src, Ptr<cv::bioinspired::TransientAreasSegmentationModule>& dst, const ArgInfo& info) |  | 37791 | static bool to(PyObject* src, Ptr<cv::bioinspired::TransientAreasSegmentationModule>& dst, const ArgInfo& info)
| 37840 | { |  | 37792 | {
| 37841 | if(!src || src == Py_None) |  | 37793 | if(!src || src == Py_None)
| 37842 | return true; |  | 37794 | return true;
| 37843 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * dst_; |  | 37795 | Ptr<cv::bioinspired::TransientAreasSegmentationModule> * dst_;
| 37844 | if (pyopencv_bioinspired_TransientAreasSegmentationModule_getp(src, dst_)) |  | 37796 | if (pyopencv_bioinspired_TransientAreasSegmentationModule_getp(src, dst_))
| 37845 | { |  | 37797 | {
| 37846 | dst = *dst_; |  | 37798 | dst = *dst_;
| 37847 | return true; |  | 37799 | return true;
| 37848 | } |  | 37800 | }
| 37849 |  |  | 37801 |
| 37850 | failmsg("Expected Ptr<cv::bioinspired::TransientAreasSegmentationModule> for argument '%s'", info.name); |  | 37802 | failmsg("Expected Ptr<cv::bioinspired::TransientAreasSegmentationModule> for argument '%s'", info.name);
| 37851 | return false; |  | 37803 | return false;
| 37852 | } |  | 37804 | }
| 37853 | }; |  | 37805 | };
| 37854 |  |  | 37806 |
| 37855 | //================================================================================ |  | 37807 | //================================================================================
| 37856 | // ccm_ColorCorrectionModel (Generic) |  | 37808 | // ccm_ColorCorrectionModel (Generic)
| 37857 | //================================================================================ |  | 37809 | //================================================================================
| 37858 |  |  | 37810 |
| 37859 | // GetSet (ccm_ColorCorrectionModel) |  | 37811 | // GetSet (ccm_ColorCorrectionModel)
| 37860 |  |  | 37812 |
| 37861 |  |  | 37813 |
| 37862 |  |  | 37814 |
| 37863 | // Methods (ccm_ColorCorrectionModel) |  | 37815 | // Methods (ccm_ColorCorrectionModel)
| 37864 |  |  | 37816 |
| 37865 | static int pyopencv_cv_ccm_ccm_ColorCorrectionModel_ColorCorrectionModel(pyopencv_ccm_ColorCorrectionModel_t* self, PyObject* py_args, PyObject* kw) |  | 37817 | static int pyopencv_cv_ccm_ccm_ColorCorrectionModel_ColorCorrectionModel(pyopencv_ccm_ColorCorrectionModel_t* self, PyObject* py_args, PyObject* kw)
| 37866 | { |  | 37818 | {
| 37867 | using namespace cv::ccm; |  | 37819 | using namespace cv::ccm;
| 37868 |  |  | 37820 |
| 37869 | pyPrepareArgumentConversionErrorsStorage(3); |  | 37821 | pyPrepareArgumentConversionErrorsStorage(3);
| 37870 |  |  | 37822 |
| 37871 | { |  | 37823 | {
| 37872 | PyObject* pyobj_src = NULL; |  | 37824 | PyObject* pyobj_src = NULL;
| 37873 | Mat src; |  | 37825 | Mat src;
| 37874 | PyObject* pyobj_constcolor = NULL; |  | 37826 | PyObject* pyobj_constcolor = NULL;
| 37875 | CONST_COLOR constcolor=static_cast<CONST_COLOR>(0); |  | 37827 | CONST_COLOR constcolor=static_cast<CONST_COLOR>(0);
| 37876 |  |  | 37828 |
| 37877 | const char* keywords[] = { "src", "constcolor", NULL }; |  | 37829 | const char* keywords[] = { "src", "constcolor", NULL };
| 37878 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ColorCorrectionModel", (char**)keywords, &pyobj_src, &pyobj_constcolor) && |  | 37830 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ColorCorrectionModel", (char**)keywords, &pyobj_src, &pyobj_constcolor) &&
| 37879 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 37831 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 37880 | pyopencv_to_safe(pyobj_constcolor, constcolor, ArgInfo("constcolor", 0)) ) |  | 37832 | pyopencv_to_safe(pyobj_constcolor, constcolor, ArgInfo("constcolor", 0)) )
| 37881 | { |  | 37833 | {
| 37882 | new (&(self->v)) Ptr<cv::ccm::ColorCorrectionModel>(); // init Ptr with placement new |  | 37834 | new (&(self->v)) Ptr<cv::ccm::ColorCorrectionModel>(); // init Ptr with placement new
| 37883 | if(self) ERRWRAP2(self->v.reset(new cv::ccm::ColorCorrectionModel(src, constcolor))); |  | 37835 | if(self) ERRWRAP2(self->v.reset(new cv::ccm::ColorCorrectionModel(src, constcolor)));
| 37884 | return 0; |  | 37836 | return 0;
| 37885 | } |  | 37837 | }
| 37886 |  |  | 37838 |
| 37887 |  |  | 37839 |
| 37888 | pyPopulateArgumentConversionErrors(); |  | 37840 | pyPopulateArgumentConversionErrors();
| 37889 | } |  | 37841 | }
| 37890 |  |  | 37842 |
| 37891 |  |  | 37843 |
| 37892 | { |  | 37844 | {
| 37893 | PyObject* pyobj_src = NULL; |  | 37845 | PyObject* pyobj_src = NULL;
| 37894 | Mat src; |  | 37846 | Mat src;
| 37895 | PyObject* pyobj_colors = NULL; |  | 37847 | PyObject* pyobj_colors = NULL;
| 37896 | Mat colors; |  | 37848 | Mat colors;
| 37897 | PyObject* pyobj_ref_cs = NULL; |  | 37849 | PyObject* pyobj_ref_cs = NULL;
| 37898 | COLOR_SPACE ref_cs=static_cast<COLOR_SPACE>(0); |  | 37850 | COLOR_SPACE ref_cs=static_cast<COLOR_SPACE>(0);
| 37899 |  |  | 37851 |
| 37900 | const char* keywords[] = { "src", "colors", "ref_cs", NULL }; |  | 37852 | const char* keywords[] = { "src", "colors", "ref_cs", NULL };
| 37901 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ColorCorrectionModel", (char**)keywords, &pyobj_src, &pyobj_colors, &pyobj_ref_cs) && |  | 37853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ColorCorrectionModel", (char**)keywords, &pyobj_src, &pyobj_colors, &pyobj_ref_cs) &&
| 37902 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 37854 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 37903 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 0)) && |  | 37855 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 0)) &&
| 37904 | pyopencv_to_safe(pyobj_ref_cs, ref_cs, ArgInfo("ref_cs", 0)) ) |  | 37856 | pyopencv_to_safe(pyobj_ref_cs, ref_cs, ArgInfo("ref_cs", 0)) )
| 37905 | { |  | 37857 | {
| 37906 | new (&(self->v)) Ptr<cv::ccm::ColorCorrectionModel>(); // init Ptr with placement new |  | 37858 | new (&(self->v)) Ptr<cv::ccm::ColorCorrectionModel>(); // init Ptr with placement new
| 37907 | if(self) ERRWRAP2(self->v.reset(new cv::ccm::ColorCorrectionModel(src, colors, ref_cs))); |  | 37859 | if(self) ERRWRAP2(self->v.reset(new cv::ccm::ColorCorrectionModel(src, colors, ref_cs)));
| 37908 | return 0; |  | 37860 | return 0;
| 37909 | } |  | 37861 | }
| 37910 |  |  | 37862 |
| 37911 |  |  | 37863 |
| 37912 | pyPopulateArgumentConversionErrors(); |  | 37864 | pyPopulateArgumentConversionErrors();
| 37913 | } |  | 37865 | }
| 37914 |  |  | 37866 |
| 37915 |  |  | 37867 |
| 37916 | { |  | 37868 | {
| 37917 | PyObject* pyobj_src = NULL; |  | 37869 | PyObject* pyobj_src = NULL;
| 37918 | Mat src; |  | 37870 | Mat src;
| 37919 | PyObject* pyobj_colors = NULL; |  | 37871 | PyObject* pyobj_colors = NULL;
| 37920 | Mat colors; |  | 37872 | Mat colors;
| 37921 | PyObject* pyobj_ref_cs = NULL; |  | 37873 | PyObject* pyobj_ref_cs = NULL;
| 37922 | COLOR_SPACE ref_cs=static_cast<COLOR_SPACE>(0); |  | 37874 | COLOR_SPACE ref_cs=static_cast<COLOR_SPACE>(0);
| 37923 | PyObject* pyobj_colored = NULL; |  | 37875 | PyObject* pyobj_colored = NULL;
| 37924 | Mat colored; |  | 37876 | Mat colored;
| 37925 |  |  | 37877 |
| 37926 | const char* keywords[] = { "src", "colors", "ref_cs", "colored", NULL }; |  | 37878 | const char* keywords[] = { "src", "colors", "ref_cs", "colored", NULL };
| 37927 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:ColorCorrectionModel", (char**)keywords, &pyobj_src, &pyobj_colors, &pyobj_ref_cs, &pyobj_colored) && |  | 37879 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:ColorCorrectionModel", (char**)keywords, &pyobj_src, &pyobj_colors, &pyobj_ref_cs, &pyobj_colored) &&
| 37928 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 37880 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 37929 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 0)) && |  | 37881 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 0)) &&
| 37930 | pyopencv_to_safe(pyobj_ref_cs, ref_cs, ArgInfo("ref_cs", 0)) && |  | 37882 | pyopencv_to_safe(pyobj_ref_cs, ref_cs, ArgInfo("ref_cs", 0)) &&
| 37931 | pyopencv_to_safe(pyobj_colored, colored, ArgInfo("colored", 0)) ) |  | 37883 | pyopencv_to_safe(pyobj_colored, colored, ArgInfo("colored", 0)) )
| 37932 | { |  | 37884 | {
| 37933 | new (&(self->v)) Ptr<cv::ccm::ColorCorrectionModel>(); // init Ptr with placement new |  | 37885 | new (&(self->v)) Ptr<cv::ccm::ColorCorrectionModel>(); // init Ptr with placement new
| 37934 | if(self) ERRWRAP2(self->v.reset(new cv::ccm::ColorCorrectionModel(src, colors, ref_cs, colored))); |  | 37886 | if(self) ERRWRAP2(self->v.reset(new cv::ccm::ColorCorrectionModel(src, colors, ref_cs, colored)));
| 37935 | return 0; |  | 37887 | return 0;
| 37936 | } |  | 37888 | }
| 37937 |  |  | 37889 |
| 37938 |  |  | 37890 |
| 37939 | pyPopulateArgumentConversionErrors(); |  | 37891 | pyPopulateArgumentConversionErrors();
| 37940 | } |  | 37892 | }
| 37941 | pyRaiseCVOverloadException("ColorCorrectionModel"); |  | 37893 | pyRaiseCVOverloadException("ColorCorrectionModel");
| 37942 |  |  | 37894 |
| 37943 | return -1; |  | 37895 | return -1;
| 37944 | } |  | 37896 | }
| 37945 |  |  | 37897 |
| 37946 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getCCM(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37898 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getCCM(PyObject* self, PyObject* py_args, PyObject* kw)
| 37947 | { |  | 37899 | {
| 37948 | using namespace cv::ccm; |  | 37900 | using namespace cv::ccm;
| 37949 |  |  | 37901 |
| 37950 |  |  | 37902 |
| 37951 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 37903 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 37952 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 37904 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 37953 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 37905 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 37954 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 37906 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 37955 | Mat retval; |  | 37907 | Mat retval;
| 37956 |  |  | 37908 |
| 37957 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37909 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37958 | { |  | 37910 | {
| 37959 | ERRWRAP2(retval = _self_->getCCM()); |  | 37911 | ERRWRAP2(retval = _self_->getCCM());
| 37960 | return pyopencv_from(retval); |  | 37912 | return pyopencv_from(retval);
| 37961 | } |  | 37913 | }
| 37962 |  |  | 37914 |
| 37963 | return NULL; |  | 37915 | return NULL;
| 37964 | } |  | 37916 | }
| 37965 |  |  | 37917 |
| 37966 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getLoss(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37918 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getLoss(PyObject* self, PyObject* py_args, PyObject* kw)
| 37967 | { |  | 37919 | {
| 37968 | using namespace cv::ccm; |  | 37920 | using namespace cv::ccm;
| 37969 |  |  | 37921 |
| 37970 |  |  | 37922 |
| 37971 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 37923 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 37972 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 37924 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 37973 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 37925 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 37974 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 37926 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 37975 | double retval; |  | 37927 | double retval;
| 37976 |  |  | 37928 |
| 37977 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37929 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37978 | { |  | 37930 | {
| 37979 | ERRWRAP2(retval = _self_->getLoss()); |  | 37931 | ERRWRAP2(retval = _self_->getLoss());
| 37980 | return pyopencv_from(retval); |  | 37932 | return pyopencv_from(retval);
| 37981 | } |  | 37933 | }
| 37982 |  |  | 37934 |
| 37983 | return NULL; |  | 37935 | return NULL;
| 37984 | } |  | 37936 | }
| 37985 |  |  | 37937 |
| 37986 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getMask(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37938 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getMask(PyObject* self, PyObject* py_args, PyObject* kw)
| 37987 | { |  | 37939 | {
| 37988 | using namespace cv::ccm; |  | 37940 | using namespace cv::ccm;
| 37989 |  |  | 37941 |
| 37990 |  |  | 37942 |
| 37991 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 37943 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 37992 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 37944 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 37993 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 37945 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 37994 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 37946 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 37995 | Mat retval; |  | 37947 | Mat retval;
| 37996 |  |  | 37948 |
| 37997 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37949 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 37998 | { |  | 37950 | {
| 37999 | ERRWRAP2(retval = _self_->getMask()); |  | 37951 | ERRWRAP2(retval = _self_->getMask());
| 38000 | return pyopencv_from(retval); |  | 37952 | return pyopencv_from(retval);
| 38001 | } |  | 37953 | }
| 38002 |  |  | 37954 |
| 38003 | return NULL; |  | 37955 | return NULL;
| 38004 | } |  | 37956 | }
| 38005 |  |  | 37957 |
| 38006 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37958 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_getWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 38007 | { |  | 37959 | {
| 38008 | using namespace cv::ccm; |  | 37960 | using namespace cv::ccm;
| 38009 |  |  | 37961 |
| 38010 |  |  | 37962 |
| 38011 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 37963 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38012 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 37964 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38013 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 37965 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38014 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 37966 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38015 | Mat retval; |  | 37967 | Mat retval;
| 38016 |  |  | 37968 |
| 38017 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37969 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 38018 | { |  | 37970 | {
| 38019 | ERRWRAP2(retval = _self_->getWeights()); |  | 37971 | ERRWRAP2(retval = _self_->getWeights());
| 38020 | return pyopencv_from(retval); |  | 37972 | return pyopencv_from(retval);
| 38021 | } |  | 37973 | }
| 38022 |  |  | 37974 |
| 38023 | return NULL; |  | 37975 | return NULL;
| 38024 | } |  | 37976 | }
| 38025 |  |  | 37977 |
| 38026 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_dst_rgbl(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37978 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_dst_rgbl(PyObject* self, PyObject* py_args, PyObject* kw)
| 38027 | { |  | 37979 | {
| 38028 | using namespace cv::ccm; |  | 37980 | using namespace cv::ccm;
| 38029 |  |  | 37981 |
| 38030 |  |  | 37982 |
| 38031 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 37983 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38032 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 37984 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38033 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 37985 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38034 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 37986 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38035 | Mat retval; |  | 37987 | Mat retval;
| 38036 |  |  | 37988 |
| 38037 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 37989 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 38038 | { |  | 37990 | {
| 38039 | ERRWRAP2(retval = _self_->get_dst_rgbl()); |  | 37991 | ERRWRAP2(retval = _self_->get_dst_rgbl());
| 38040 | return pyopencv_from(retval); |  | 37992 | return pyopencv_from(retval);
| 38041 | } |  | 37993 | }
| 38042 |  |  | 37994 |
| 38043 | return NULL; |  | 37995 | return NULL;
| 38044 | } |  | 37996 | }
| 38045 |  |  | 37997 |
| 38046 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_src_rgbl(PyObject* self, PyObject* py_args, PyObject* kw) |  | 37998 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_src_rgbl(PyObject* self, PyObject* py_args, PyObject* kw)
| 38047 | { |  | 37999 | {
| 38048 | using namespace cv::ccm; |  | 38000 | using namespace cv::ccm;
| 38049 |  |  | 38001 |
| 38050 |  |  | 38002 |
| 38051 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38003 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38052 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38004 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38053 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38005 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38054 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38006 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38055 | Mat retval; |  | 38007 | Mat retval;
| 38056 |  |  | 38008 |
| 38057 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 38009 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 38058 | { |  | 38010 | {
| 38059 | ERRWRAP2(retval = _self_->get_src_rgbl()); |  | 38011 | ERRWRAP2(retval = _self_->get_src_rgbl());
| 38060 | return pyopencv_from(retval); |  | 38012 | return pyopencv_from(retval);
| 38061 | } |  | 38013 | }
| 38062 |  |  | 38014 |
| 38063 | return NULL; |  | 38015 | return NULL;
| 38064 | } |  | 38016 | }
| 38065 |  |  | 38017 |
| 38066 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_infer(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38018 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_infer(PyObject* self, PyObject* py_args, PyObject* kw)
| 38067 | { |  | 38019 | {
| 38068 | using namespace cv::ccm; |  | 38020 | using namespace cv::ccm;
| 38069 |  |  | 38021 |
| 38070 |  |  | 38022 |
| 38071 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38023 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38072 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38024 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38073 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38025 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38074 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38026 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38075 | PyObject* pyobj_img = NULL; |  | 38027 | PyObject* pyobj_img = NULL;
| 38076 | Mat img; |  | 38028 | Mat img;
| 38077 | PyObject* pyobj_islinear = NULL; |  | 38029 | PyObject* pyobj_islinear = NULL;
| 38078 | bool islinear=false; |  | 38030 | bool islinear=false;
| 38079 | Mat retval; |  | 38031 | Mat retval;
| 38080 |  |  | 38032 |
| 38081 | const char* keywords[] = { "img", "islinear", NULL }; |  | 38033 | const char* keywords[] = { "img", "islinear", NULL };
| 38082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ccm_ColorCorrectionModel.infer", (char**)keywords, &pyobj_img, &pyobj_islinear) && |  | 38034 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ccm_ColorCorrectionModel.infer", (char**)keywords, &pyobj_img, &pyobj_islinear) &&
| 38083 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 38035 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 38084 | pyopencv_to_safe(pyobj_islinear, islinear, ArgInfo("islinear", 0)) ) |  | 38036 | pyopencv_to_safe(pyobj_islinear, islinear, ArgInfo("islinear", 0)) )
| 38085 | { |  | 38037 | {
| 38086 | ERRWRAP2(retval = _self_->infer(img, islinear)); |  | 38038 | ERRWRAP2(retval = _self_->infer(img, islinear));
| 38087 | return pyopencv_from(retval); |  | 38039 | return pyopencv_from(retval);
| 38088 | } |  | 38040 | }
| 38089 |  |  | 38041 |
| 38090 | return NULL; |  | 38042 | return NULL;
| 38091 | } |  | 38043 | }
| 38092 |  |  | 38044 |
| 38093 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_run(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38045 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_run(PyObject* self, PyObject* py_args, PyObject* kw)
| 38094 | { |  | 38046 | {
| 38095 | using namespace cv::ccm; |  | 38047 | using namespace cv::ccm;
| 38096 |  |  | 38048 |
| 38097 |  |  | 38049 |
| 38098 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38050 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38099 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38051 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38100 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38052 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38101 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38053 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38102 |  |  | 38054 |
| 38103 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 38055 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 38104 | { |  | 38056 | {
| 38105 | ERRWRAP2(_self_->run()); |  | 38057 | ERRWRAP2(_self_->run());
| 38106 | Py_RETURN_NONE; |  | 38058 | Py_RETURN_NONE;
| 38107 | } |  | 38059 | }
| 38108 |  |  | 38060 |
| 38109 | return NULL; |  | 38061 | return NULL;
| 38110 | } |  | 38062 | }
| 38111 |  |  | 38063 |
| 38112 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setCCM_TYPE(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38064 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setCCM_TYPE(PyObject* self, PyObject* py_args, PyObject* kw)
| 38113 | { |  | 38065 | {
| 38114 | using namespace cv::ccm; |  | 38066 | using namespace cv::ccm;
| 38115 |  |  | 38067 |
| 38116 |  |  | 38068 |
| 38117 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38069 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38118 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38070 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38119 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38071 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38120 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38072 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38121 | PyObject* pyobj_ccm_type = NULL; |  | 38073 | PyObject* pyobj_ccm_type = NULL;
| 38122 | CCM_TYPE ccm_type=static_cast<CCM_TYPE>(0); |  | 38074 | CCM_TYPE ccm_type=static_cast<CCM_TYPE>(0);
| 38123 |  |  | 38075 |
| 38124 | const char* keywords[] = { "ccm_type", NULL }; |  | 38076 | const char* keywords[] = { "ccm_type", NULL };
| 38125 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setCCM_TYPE", (char**)keywords, &pyobj_ccm_type) && |  | 38077 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setCCM_TYPE", (char**)keywords, &pyobj_ccm_type) &&
| 38126 | pyopencv_to_safe(pyobj_ccm_type, ccm_type, ArgInfo("ccm_type", 0)) ) |  | 38078 | pyopencv_to_safe(pyobj_ccm_type, ccm_type, ArgInfo("ccm_type", 0)) )
| 38127 | { |  | 38079 | {
| 38128 | ERRWRAP2(_self_->setCCM_TYPE(ccm_type)); |  | 38080 | ERRWRAP2(_self_->setCCM_TYPE(ccm_type));
| 38129 | Py_RETURN_NONE; |  | 38081 | Py_RETURN_NONE;
| 38130 | } |  | 38082 | }
| 38131 |  |  | 38083 |
| 38132 | return NULL; |  | 38084 | return NULL;
| 38133 | } |  | 38085 | }
| 38134 |  |  | 38086 |
| 38135 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setColorSpace(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38087 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setColorSpace(PyObject* self, PyObject* py_args, PyObject* kw)
| 38136 | { |  | 38088 | {
| 38137 | using namespace cv::ccm; |  | 38089 | using namespace cv::ccm;
| 38138 |  |  | 38090 |
| 38139 |  |  | 38091 |
| 38140 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38092 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38141 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38093 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38142 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38094 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38143 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38095 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38144 | PyObject* pyobj_cs = NULL; |  | 38096 | PyObject* pyobj_cs = NULL;
| 38145 | COLOR_SPACE cs=static_cast<COLOR_SPACE>(0); |  | 38097 | COLOR_SPACE cs=static_cast<COLOR_SPACE>(0);
| 38146 |  |  | 38098 |
| 38147 | const char* keywords[] = { "cs", NULL }; |  | 38099 | const char* keywords[] = { "cs", NULL };
| 38148 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setColorSpace", (char**)keywords, &pyobj_cs) && |  | 38100 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setColorSpace", (char**)keywords, &pyobj_cs) &&
| 38149 | pyopencv_to_safe(pyobj_cs, cs, ArgInfo("cs", 0)) ) |  | 38101 | pyopencv_to_safe(pyobj_cs, cs, ArgInfo("cs", 0)) )
| 38150 | { |  | 38102 | {
| 38151 | ERRWRAP2(_self_->setColorSpace(cs)); |  | 38103 | ERRWRAP2(_self_->setColorSpace(cs));
| 38152 | Py_RETURN_NONE; |  | 38104 | Py_RETURN_NONE;
| 38153 | } |  | 38105 | }
| 38154 |  |  | 38106 |
| 38155 | return NULL; |  | 38107 | return NULL;
| 38156 | } |  | 38108 | }
| 38157 |  |  | 38109 |
| 38158 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setDistance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38110 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setDistance(PyObject* self, PyObject* py_args, PyObject* kw)
| 38159 | { |  | 38111 | {
| 38160 | using namespace cv::ccm; |  | 38112 | using namespace cv::ccm;
| 38161 |  |  | 38113 |
| 38162 |  |  | 38114 |
| 38163 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38115 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38164 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38116 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38165 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38117 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38166 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38118 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38167 | PyObject* pyobj_distance = NULL; |  | 38119 | PyObject* pyobj_distance = NULL;
| 38168 | DISTANCE_TYPE distance=static_cast<DISTANCE_TYPE>(0); |  | 38120 | DISTANCE_TYPE distance=static_cast<DISTANCE_TYPE>(0);
| 38169 |  |  | 38121 |
| 38170 | const char* keywords[] = { "distance", NULL }; |  | 38122 | const char* keywords[] = { "distance", NULL };
| 38171 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setDistance", (char**)keywords, &pyobj_distance) && |  | 38123 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setDistance", (char**)keywords, &pyobj_distance) &&
| 38172 | pyopencv_to_safe(pyobj_distance, distance, ArgInfo("distance", 0)) ) |  | 38124 | pyopencv_to_safe(pyobj_distance, distance, ArgInfo("distance", 0)) )
| 38173 | { |  | 38125 | {
| 38174 | ERRWRAP2(_self_->setDistance(distance)); |  | 38126 | ERRWRAP2(_self_->setDistance(distance));
| 38175 | Py_RETURN_NONE; |  | 38127 | Py_RETURN_NONE;
| 38176 | } |  | 38128 | }
| 38177 |  |  | 38129 |
| 38178 | return NULL; |  | 38130 | return NULL;
| 38179 | } |  | 38131 | }
| 38180 |  |  | 38132 |
| 38181 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38133 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 38182 | { |  | 38134 | {
| 38183 | using namespace cv::ccm; |  | 38135 | using namespace cv::ccm;
| 38184 |  |  | 38136 |
| 38185 |  |  | 38137 |
| 38186 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38138 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38187 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38139 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38188 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38140 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38189 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38141 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38190 | PyObject* pyobj_epsilon = NULL; |  | 38142 | PyObject* pyobj_epsilon = NULL;
| 38191 | double epsilon=0; |  | 38143 | double epsilon=0;
| 38192 |  |  | 38144 |
| 38193 | const char* keywords[] = { "epsilon", NULL }; |  | 38145 | const char* keywords[] = { "epsilon", NULL };
| 38194 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setEpsilon", (char**)keywords, &pyobj_epsilon) && |  | 38146 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setEpsilon", (char**)keywords, &pyobj_epsilon) &&
| 38195 | pyopencv_to_safe(pyobj_epsilon, epsilon, ArgInfo("epsilon", 0)) ) |  | 38147 | pyopencv_to_safe(pyobj_epsilon, epsilon, ArgInfo("epsilon", 0)) )
| 38196 | { |  | 38148 | {
| 38197 | ERRWRAP2(_self_->setEpsilon(epsilon)); |  | 38149 | ERRWRAP2(_self_->setEpsilon(epsilon));
| 38198 | Py_RETURN_NONE; |  | 38150 | Py_RETURN_NONE;
| 38199 | } |  | 38151 | }
| 38200 |  |  | 38152 |
| 38201 | return NULL; |  | 38153 | return NULL;
| 38202 | } |  | 38154 | }
| 38203 |  |  | 38155 |
| 38204 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setInitialMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38156 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setInitialMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 38205 | { |  | 38157 | {
| 38206 | using namespace cv::ccm; |  | 38158 | using namespace cv::ccm;
| 38207 |  |  | 38159 |
| 38208 |  |  | 38160 |
| 38209 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38161 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38210 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38162 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38211 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38163 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38212 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38164 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38213 | PyObject* pyobj_initial_method_type = NULL; |  | 38165 | PyObject* pyobj_initial_method_type = NULL;
| 38214 | INITIAL_METHOD_TYPE initial_method_type=static_cast<INITIAL_METHOD_TYPE>(0); |  | 38166 | INITIAL_METHOD_TYPE initial_method_type=static_cast<INITIAL_METHOD_TYPE>(0);
| 38215 |  |  | 38167 |
| 38216 | const char* keywords[] = { "initial_method_type", NULL }; |  | 38168 | const char* keywords[] = { "initial_method_type", NULL };
| 38217 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setInitialMethod", (char**)keywords, &pyobj_initial_method_type) && |  | 38169 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setInitialMethod", (char**)keywords, &pyobj_initial_method_type) &&
| 38218 | pyopencv_to_safe(pyobj_initial_method_type, initial_method_type, ArgInfo("initial_method_type", 0)) ) |  | 38170 | pyopencv_to_safe(pyobj_initial_method_type, initial_method_type, ArgInfo("initial_method_type", 0)) )
| 38219 | { |  | 38171 | {
| 38220 | ERRWRAP2(_self_->setInitialMethod(initial_method_type)); |  | 38172 | ERRWRAP2(_self_->setInitialMethod(initial_method_type));
| 38221 | Py_RETURN_NONE; |  | 38173 | Py_RETURN_NONE;
| 38222 | } |  | 38174 | }
| 38223 |  |  | 38175 |
| 38224 | return NULL; |  | 38176 | return NULL;
| 38225 | } |  | 38177 | }
| 38226 |  |  | 38178 |
| 38227 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38179 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinear(PyObject* self, PyObject* py_args, PyObject* kw)
| 38228 | { |  | 38180 | {
| 38229 | using namespace cv::ccm; |  | 38181 | using namespace cv::ccm;
| 38230 |  |  | 38182 |
| 38231 |  |  | 38183 |
| 38232 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38184 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38233 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38185 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38234 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38186 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38235 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38187 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38236 | PyObject* pyobj_linear_type = NULL; |  | 38188 | PyObject* pyobj_linear_type = NULL;
| 38237 | LINEAR_TYPE linear_type=static_cast<LINEAR_TYPE>(0); |  | 38189 | LINEAR_TYPE linear_type=static_cast<LINEAR_TYPE>(0);
| 38238 |  |  | 38190 |
| 38239 | const char* keywords[] = { "linear_type", NULL }; |  | 38191 | const char* keywords[] = { "linear_type", NULL };
| 38240 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setLinear", (char**)keywords, &pyobj_linear_type) && |  | 38192 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setLinear", (char**)keywords, &pyobj_linear_type) &&
| 38241 | pyopencv_to_safe(pyobj_linear_type, linear_type, ArgInfo("linear_type", 0)) ) |  | 38193 | pyopencv_to_safe(pyobj_linear_type, linear_type, ArgInfo("linear_type", 0)) )
| 38242 | { |  | 38194 | {
| 38243 | ERRWRAP2(_self_->setLinear(linear_type)); |  | 38195 | ERRWRAP2(_self_->setLinear(linear_type));
| 38244 | Py_RETURN_NONE; |  | 38196 | Py_RETURN_NONE;
| 38245 | } |  | 38197 | }
| 38246 |  |  | 38198 |
| 38247 | return NULL; |  | 38199 | return NULL;
| 38248 | } |  | 38200 | }
| 38249 |  |  | 38201 |
| 38250 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearDegree(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38202 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearDegree(PyObject* self, PyObject* py_args, PyObject* kw)
| 38251 | { |  | 38203 | {
| 38252 | using namespace cv::ccm; |  | 38204 | using namespace cv::ccm;
| 38253 |  |  | 38205 |
| 38254 |  |  | 38206 |
| 38255 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38207 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38256 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38208 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38257 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38209 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38258 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38210 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38259 | PyObject* pyobj_deg = NULL; |  | 38211 | PyObject* pyobj_deg = NULL;
| 38260 | int deg=0; |  | 38212 | int deg=0;
| 38261 |  |  | 38213 |
| 38262 | const char* keywords[] = { "deg", NULL }; |  | 38214 | const char* keywords[] = { "deg", NULL };
| 38263 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setLinearDegree", (char**)keywords, &pyobj_deg) && |  | 38215 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setLinearDegree", (char**)keywords, &pyobj_deg) &&
| 38264 | pyopencv_to_safe(pyobj_deg, deg, ArgInfo("deg", 0)) ) |  | 38216 | pyopencv_to_safe(pyobj_deg, deg, ArgInfo("deg", 0)) )
| 38265 | { |  | 38217 | {
| 38266 | ERRWRAP2(_self_->setLinearDegree(deg)); |  | 38218 | ERRWRAP2(_self_->setLinearDegree(deg));
| 38267 | Py_RETURN_NONE; |  | 38219 | Py_RETURN_NONE;
| 38268 | } |  | 38220 | }
| 38269 |  |  | 38221 |
| 38270 | return NULL; |  | 38222 | return NULL;
| 38271 | } |  | 38223 | }
| 38272 |  |  | 38224 |
| 38273 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38225 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 38274 | { |  | 38226 | {
| 38275 | using namespace cv::ccm; |  | 38227 | using namespace cv::ccm;
| 38276 |  |  | 38228 |
| 38277 |  |  | 38229 |
| 38278 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38230 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38279 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38231 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38280 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38232 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38281 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38233 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38282 | PyObject* pyobj_gamma = NULL; |  | 38234 | PyObject* pyobj_gamma = NULL;
| 38283 | double gamma=0; |  | 38235 | double gamma=0;
| 38284 |  |  | 38236 |
| 38285 | const char* keywords[] = { "gamma", NULL }; |  | 38237 | const char* keywords[] = { "gamma", NULL };
| 38286 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setLinearGamma", (char**)keywords, &pyobj_gamma) && |  | 38238 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setLinearGamma", (char**)keywords, &pyobj_gamma) &&
| 38287 | pyopencv_to_safe(pyobj_gamma, gamma, ArgInfo("gamma", 0)) ) |  | 38239 | pyopencv_to_safe(pyobj_gamma, gamma, ArgInfo("gamma", 0)) )
| 38288 | { |  | 38240 | {
| 38289 | ERRWRAP2(_self_->setLinearGamma(gamma)); |  | 38241 | ERRWRAP2(_self_->setLinearGamma(gamma));
| 38290 | Py_RETURN_NONE; |  | 38242 | Py_RETURN_NONE;
| 38291 | } |  | 38243 | }
| 38292 |  |  | 38244 |
| 38293 | return NULL; |  | 38245 | return NULL;
| 38294 | } |  | 38246 | }
| 38295 |  |  | 38247 |
| 38296 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setMaxCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38248 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setMaxCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 38297 | { |  | 38249 | {
| 38298 | using namespace cv::ccm; |  | 38250 | using namespace cv::ccm;
| 38299 |  |  | 38251 |
| 38300 |  |  | 38252 |
| 38301 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38253 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38302 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38254 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38303 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38255 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38304 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38256 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38305 | PyObject* pyobj_max_count = NULL; |  | 38257 | PyObject* pyobj_max_count = NULL;
| 38306 | int max_count=0; |  | 38258 | int max_count=0;
| 38307 |  |  | 38259 |
| 38308 | const char* keywords[] = { "max_count", NULL }; |  | 38260 | const char* keywords[] = { "max_count", NULL };
| 38309 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setMaxCount", (char**)keywords, &pyobj_max_count) && |  | 38261 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setMaxCount", (char**)keywords, &pyobj_max_count) &&
| 38310 | pyopencv_to_safe(pyobj_max_count, max_count, ArgInfo("max_count", 0)) ) |  | 38262 | pyopencv_to_safe(pyobj_max_count, max_count, ArgInfo("max_count", 0)) )
| 38311 | { |  | 38263 | {
| 38312 | ERRWRAP2(_self_->setMaxCount(max_count)); |  | 38264 | ERRWRAP2(_self_->setMaxCount(max_count));
| 38313 | Py_RETURN_NONE; |  | 38265 | Py_RETURN_NONE;
| 38314 | } |  | 38266 | }
| 38315 |  |  | 38267 |
| 38316 | return NULL; |  | 38268 | return NULL;
| 38317 | } |  | 38269 | }
| 38318 |  |  | 38270 |
| 38319 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setSaturatedThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38271 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setSaturatedThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 38320 | { |  | 38272 | {
| 38321 | using namespace cv::ccm; |  | 38273 | using namespace cv::ccm;
| 38322 |  |  | 38274 |
| 38323 |  |  | 38275 |
| 38324 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38276 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38325 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38277 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38326 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38278 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38327 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38279 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38328 | PyObject* pyobj_lower = NULL; |  | 38280 | PyObject* pyobj_lower = NULL;
| 38329 | double lower=0; |  | 38281 | double lower=0;
| 38330 | PyObject* pyobj_upper = NULL; |  | 38282 | PyObject* pyobj_upper = NULL;
| 38331 | double upper=0; |  | 38283 | double upper=0;
| 38332 |  |  | 38284 |
| 38333 | const char* keywords[] = { "lower", "upper", NULL }; |  | 38285 | const char* keywords[] = { "lower", "upper", NULL };
| 38334 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ccm_ColorCorrectionModel.setSaturatedThreshold", (char**)keywords, &pyobj_lower, &pyobj_upper) && |  | 38286 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ccm_ColorCorrectionModel.setSaturatedThreshold", (char**)keywords, &pyobj_lower, &pyobj_upper) &&
| 38335 | pyopencv_to_safe(pyobj_lower, lower, ArgInfo("lower", 0)) && |  | 38287 | pyopencv_to_safe(pyobj_lower, lower, ArgInfo("lower", 0)) &&
| 38336 | pyopencv_to_safe(pyobj_upper, upper, ArgInfo("upper", 0)) ) |  | 38288 | pyopencv_to_safe(pyobj_upper, upper, ArgInfo("upper", 0)) )
| 38337 | { |  | 38289 | {
| 38338 | ERRWRAP2(_self_->setSaturatedThreshold(lower, upper)); |  | 38290 | ERRWRAP2(_self_->setSaturatedThreshold(lower, upper));
| 38339 | Py_RETURN_NONE; |  | 38291 | Py_RETURN_NONE;
| 38340 | } |  | 38292 | }
| 38341 |  |  | 38293 |
| 38342 | return NULL; |  | 38294 | return NULL;
| 38343 | } |  | 38295 | }
| 38344 |  |  | 38296 |
| 38345 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightCoeff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38297 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightCoeff(PyObject* self, PyObject* py_args, PyObject* kw)
| 38346 | { |  | 38298 | {
| 38347 | using namespace cv::ccm; |  | 38299 | using namespace cv::ccm;
| 38348 |  |  | 38300 |
| 38349 |  |  | 38301 |
| 38350 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38302 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38351 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38303 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38352 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38304 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38353 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38305 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38354 | PyObject* pyobj_weights_coeff = NULL; |  | 38306 | PyObject* pyobj_weights_coeff = NULL;
| 38355 | double weights_coeff=0; |  | 38307 | double weights_coeff=0;
| 38356 |  |  | 38308 |
| 38357 | const char* keywords[] = { "weights_coeff", NULL }; |  | 38309 | const char* keywords[] = { "weights_coeff", NULL };
| 38358 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setWeightCoeff", (char**)keywords, &pyobj_weights_coeff) && |  | 38310 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setWeightCoeff", (char**)keywords, &pyobj_weights_coeff) &&
| 38359 | pyopencv_to_safe(pyobj_weights_coeff, weights_coeff, ArgInfo("weights_coeff", 0)) ) |  | 38311 | pyopencv_to_safe(pyobj_weights_coeff, weights_coeff, ArgInfo("weights_coeff", 0)) )
| 38360 | { |  | 38312 | {
| 38361 | ERRWRAP2(_self_->setWeightCoeff(weights_coeff)); |  | 38313 | ERRWRAP2(_self_->setWeightCoeff(weights_coeff));
| 38362 | Py_RETURN_NONE; |  | 38314 | Py_RETURN_NONE;
| 38363 | } |  | 38315 | }
| 38364 |  |  | 38316 |
| 38365 | return NULL; |  | 38317 | return NULL;
| 38366 | } |  | 38318 | }
| 38367 |  |  | 38319 |
| 38368 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightsList(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38320 | static PyObject* pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightsList(PyObject* self, PyObject* py_args, PyObject* kw)
| 38369 | { |  | 38321 | {
| 38370 | using namespace cv::ccm; |  | 38322 | using namespace cv::ccm;
| 38371 |  |  | 38323 |
| 38372 |  |  | 38324 |
| 38373 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0; |  | 38325 | Ptr<cv::ccm::ColorCorrectionModel> * self1 = 0;
| 38374 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1)) |  | 38326 | if (!pyopencv_ccm_ColorCorrectionModel_getp(self, self1))
| 38375 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)"); |  | 38327 | return failmsgp("Incorrect type of self (must be 'ccm_ColorCorrectionModel' or its derivative)");
| 38376 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1); |  | 38328 | Ptr<cv::ccm::ColorCorrectionModel> _self_ = *(self1);
| 38377 | PyObject* pyobj_weights_list = NULL; |  | 38329 | PyObject* pyobj_weights_list = NULL;
| 38378 | Mat weights_list; |  | 38330 | Mat weights_list;
| 38379 |  |  | 38331 |
| 38380 | const char* keywords[] = { "weights_list", NULL }; |  | 38332 | const char* keywords[] = { "weights_list", NULL };
| 38381 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setWeightsList", (char**)keywords, &pyobj_weights_list) && |  | 38333 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ccm_ColorCorrectionModel.setWeightsList", (char**)keywords, &pyobj_weights_list) &&
| 38382 | pyopencv_to_safe(pyobj_weights_list, weights_list, ArgInfo("weights_list", 0)) ) |  | 38334 | pyopencv_to_safe(pyobj_weights_list, weights_list, ArgInfo("weights_list", 0)) )
| 38383 | { |  | 38335 | {
| 38384 | ERRWRAP2(_self_->setWeightsList(weights_list)); |  | 38336 | ERRWRAP2(_self_->setWeightsList(weights_list));
| 38385 | Py_RETURN_NONE; |  | 38337 | Py_RETURN_NONE;
| 38386 | } |  | 38338 | }
| 38387 |  |  | 38339 |
| 38388 | return NULL; |  | 38340 | return NULL;
| 38389 | } |  | 38341 | }
| 38390 |  |  | 38342 |
| 38391 |  |  | 38343 |
| 38392 |  |  | 38344 |
| 38393 | // Tables (ccm_ColorCorrectionModel) |  | 38345 | // Tables (ccm_ColorCorrectionModel)
| 38394 |  |  | 38346 |
| 38395 | static PyGetSetDef pyopencv_ccm_ColorCorrectionModel_getseters[] = |  | 38347 | static PyGetSetDef pyopencv_ccm_ColorCorrectionModel_getseters[] =
| 38396 | { |  | 38348 | {
| 38397 | {NULL} /* Sentinel */ |  | 38349 | {NULL} /* Sentinel */
| 38398 | }; |  | 38350 | };
| 38399 |  |  | 38351 |
| 38400 | static PyMethodDef pyopencv_ccm_ColorCorrectionModel_methods[] = |  | 38352 | static PyMethodDef pyopencv_ccm_ColorCorrectionModel_methods[] =
| 38401 | { |  | 38353 | {
| 38402 | {"getCCM", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getCCM, 0), "getCCM() -> retval\n."}, |  | 38354 | {"getCCM", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getCCM, 0), "getCCM() -> retval\n."},
| 38403 | {"getLoss", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getLoss, 0), "getLoss() -> retval\n."}, |  | 38355 | {"getLoss", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getLoss, 0), "getLoss() -> retval\n."},
| 38404 | {"getMask", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getMask, 0), "getMask() -> retval\n."}, |  | 38356 | {"getMask", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getMask, 0), "getMask() -> retval\n."},
| 38405 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getWeights, 0), "getWeights() -> retval\n."}, |  | 38357 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_getWeights, 0), "getWeights() -> retval\n."},
| 38406 | {"get_dst_rgbl", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_dst_rgbl, 0), "get_dst_rgbl() -> retval\n."}, |  | 38358 | {"get_dst_rgbl", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_dst_rgbl, 0), "get_dst_rgbl() -> retval\n."},
| 38407 | {"get_src_rgbl", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_src_rgbl, 0), "get_src_rgbl() -> retval\n."}, |  | 38359 | {"get_src_rgbl", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_get_src_rgbl, 0), "get_src_rgbl() -> retval\n."},
| 38408 | {"infer", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_infer, 0), "infer(img[, islinear]) -> retval\n. @brief Infer using fitting ccm.\n. @param img the input image.\n. @param islinear default false.\n. @return the output array."}, |  | 38360 | {"infer", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_infer, 0), "infer(img[, islinear]) -> retval\n. @brief Infer using fitting ccm.\n. @param img the input image.\n. @param islinear default false.\n. @return the output array."},
| 38409 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_run, 0), "run() -> None\n. @brief make color correction"}, |  | 38361 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_run, 0), "run() -> None\n. @brief make color correction"},
| 38410 | {"setCCM_TYPE", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setCCM_TYPE, 0), "setCCM_TYPE(ccm_type) -> None\n. @brief set ccm_type\n. @param ccm_type the shape of color correction matrix(CCM);\\n\n. default: @ref CCM_3x3"}, |  | 38362 | {"setCCM_TYPE", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setCCM_TYPE, 0), "setCCM_TYPE(ccm_type) -> None\n. @brief set ccm_type\n. @param ccm_type the shape of color correction matrix(CCM);\\n\n. default: @ref CCM_3x3"},
| 38411 | {"setColorSpace", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setColorSpace, 0), "setColorSpace(cs) -> None\n. @brief set ColorSpace\n. @note It should be some RGB color space;\n. Supported list of color cards:\n. - @ref COLOR_SPACE_sRGB\n. - @ref COLOR_SPACE_AdobeRGB\n. - @ref COLOR_SPACE_WideGamutRGB\n. - @ref COLOR_SPACE_ProPhotoRGB\n. - @ref COLOR_SPACE_DCI_P3_RGB\n. - @ref COLOR_SPACE_AppleRGB\n. - @ref COLOR_SPACE_REC_709_RGB\n. - @ref COLOR_SPACE_REC_2020_RGB\n. @param cs the absolute color space that detected colors convert to;\\n\n. default: @ref COLOR_SPACE_sRGB"}, |  | 38363 | {"setColorSpace", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setColorSpace, 0), "setColorSpace(cs) -> None\n. @brief set ColorSpace\n. @note It should be some RGB color space;\n. Supported list of color cards:\n. - @ref COLOR_SPACE_sRGB\n. - @ref COLOR_SPACE_AdobeRGB\n. - @ref COLOR_SPACE_WideGamutRGB\n. - @ref COLOR_SPACE_ProPhotoRGB\n. - @ref COLOR_SPACE_DCI_P3_RGB\n. - @ref COLOR_SPACE_AppleRGB\n. - @ref COLOR_SPACE_REC_709_RGB\n. - @ref COLOR_SPACE_REC_2020_RGB\n. @param cs the absolute color space that detected colors convert to;\\n\n. default: @ref COLOR_SPACE_sRGB"},
| 38412 | {"setDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setDistance, 0), "setDistance(distance) -> None\n. @brief set Distance\n. @param distance the type of color distance;\\n\n. default: @ref DISTANCE_CIE2000"}, |  | 38364 | {"setDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setDistance, 0), "setDistance(distance) -> None\n. @brief set Distance\n. @param distance the type of color distance;\\n\n. default: @ref DISTANCE_CIE2000"},
| 38413 | {"setEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setEpsilon, 0), "setEpsilon(epsilon) -> None\n. @brief set Epsilon\n. @param epsilon used in MinProblemSolver-DownhillSolver;\\n\n. Terminal criteria to the algorithm;\\n\n. default: 1e-4;"}, |  | 38365 | {"setEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setEpsilon, 0), "setEpsilon(epsilon) -> None\n. @brief set Epsilon\n. @param epsilon used in MinProblemSolver-DownhillSolver;\\n\n. Terminal criteria to the algorithm;\\n\n. default: 1e-4;"},
| 38414 | {"setInitialMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setInitialMethod, 0), "setInitialMethod(initial_method_type) -> None\n. @brief set InitialMethod\n. @param initial_method_type the method of calculating CCM initial value;\\n\n. default: INITIAL_METHOD_LEAST_SQUARE"}, |  | 38366 | {"setInitialMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setInitialMethod, 0), "setInitialMethod(initial_method_type) -> None\n. @brief set InitialMethod\n. @param initial_method_type the method of calculating CCM initial value;\\n\n. default: INITIAL_METHOD_LEAST_SQUARE"},
| 38415 | {"setLinear", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinear, 0), "setLinear(linear_type) -> None\n. @brief set Linear\n. @param linear_type the method of linearization;\\n\n. default: @ref LINEARIZATION_GAMMA"}, |  | 38367 | {"setLinear", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinear, 0), "setLinear(linear_type) -> None\n. @brief set Linear\n. @param linear_type the method of linearization;\\n\n. default: @ref LINEARIZATION_GAMMA"},
| 38416 | {"setLinearDegree", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearDegree, 0), "setLinearDegree(deg) -> None\n. @brief set degree\n. @note only valid when linear is set to\n. - @ref LINEARIZATION_COLORPOLYFIT\n. - @ref LINEARIZATION_GRAYPOLYFIT\n. - @ref LINEARIZATION_COLORLOGPOLYFIT\n. - @ref LINEARIZATION_GRAYLOGPOLYFIT\n. \n. @param deg the degree of linearization polynomial;\\n\n. default: 3"}, |  | 38368 | {"setLinearDegree", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearDegree, 0), "setLinearDegree(deg) -> None\n. @brief set degree\n. @note only valid when linear is set to\n. - @ref LINEARIZATION_COLORPOLYFIT\n. - @ref LINEARIZATION_GRAYPOLYFIT\n. - @ref LINEARIZATION_COLORLOGPOLYFIT\n. - @ref LINEARIZATION_GRAYLOGPOLYFIT\n. \n. @param deg the degree of linearization polynomial;\\n\n. default: 3"},
| 38417 | {"setLinearGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearGamma, 0), "setLinearGamma(gamma) -> None\n. @brief set Gamma\n. \n. @note only valid when linear is set to \"gamma\";\\n\n. \n. @param gamma the gamma value of gamma correction;\\n\n. default: 2.2;"}, |  | 38369 | {"setLinearGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setLinearGamma, 0), "setLinearGamma(gamma) -> None\n. @brief set Gamma\n. \n. @note only valid when linear is set to \"gamma\";\\n\n. \n. @param gamma the gamma value of gamma correction;\\n\n. default: 2.2;"},
| 38418 | {"setMaxCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setMaxCount, 0), "setMaxCount(max_count) -> None\n. @brief set MaxCount\n. @param max_count used in MinProblemSolver-DownhillSolver;\\n\n. Terminal criteria to the algorithm;\\n\n. default: 5000;"}, |  | 38370 | {"setMaxCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setMaxCount, 0), "setMaxCount(max_count) -> None\n. @brief set MaxCount\n. @param max_count used in MinProblemSolver-DownhillSolver;\\n\n. Terminal criteria to the algorithm;\\n\n. default: 5000;"},
| 38419 | {"setSaturatedThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setSaturatedThreshold, 0), "setSaturatedThreshold(lower, upper) -> None\n. @brief set SaturatedThreshold.\n. The colors in the closed interval [lower, upper] are reserved to participate\n. in the calculation of the loss function and initialization parameters\n. @param lower the lower threshold to determine saturation;\\n\n. default: 0;\n. @param upper the upper threshold to determine saturation;\\n\n. default: 0"}, |  | 38371 | {"setSaturatedThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setSaturatedThreshold, 0), "setSaturatedThreshold(lower, upper) -> None\n. @brief set SaturatedThreshold.\n. The colors in the closed interval [lower, upper] are reserved to participate\n. in the calculation of the loss function and initialization parameters\n. @param lower the lower threshold to determine saturation;\\n\n. default: 0;\n. @param upper the upper threshold to determine saturation;\\n\n. default: 0"},
| 38420 | {"setWeightCoeff", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightCoeff, 0), "setWeightCoeff(weights_coeff) -> None\n. @brief set WeightCoeff\n. @param weights_coeff the exponent number of L* component of the reference color in CIE Lab color space;\\n\n. default: 0"}, |  | 38372 | {"setWeightCoeff", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightCoeff, 0), "setWeightCoeff(weights_coeff) -> None\n. @brief set WeightCoeff\n. @param weights_coeff the exponent number of L* component of the reference color in CIE Lab color space;\\n\n. default: 0"},
| 38421 | {"setWeightsList", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightsList, 0), "setWeightsList(weights_list) -> None\n. @brief set WeightsList\n. @param weights_list the list of weight of each color;\\n\n. default: empty array"}, |  | 38373 | {"setWeightsList", CV_PY_FN_WITH_KW_(pyopencv_cv_ccm_ccm_ColorCorrectionModel_setWeightsList, 0), "setWeightsList(weights_list) -> None\n. @brief set WeightsList\n. @param weights_list the list of weight of each color;\\n\n. default: empty array"},
| 38422 |  |  | 38374 |
| 38423 | {NULL, NULL} |  | 38375 | {NULL, NULL}
| 38424 | }; |  | 38376 | };
| 38425 |  |  | 38377 |
| 38426 | // Converter (ccm_ColorCorrectionModel) |  | 38378 | // Converter (ccm_ColorCorrectionModel)
| 38427 |  |  | 38379 |
| 38428 | template<> |  | 38380 | template<>
| 38429 | struct PyOpenCV_Converter< Ptr<cv::ccm::ColorCorrectionModel> > |  | 38381 | struct PyOpenCV_Converter< Ptr<cv::ccm::ColorCorrectionModel> >
| 38430 | { |  | 38382 | {
| 38431 | static PyObject* from(const Ptr<cv::ccm::ColorCorrectionModel>& r) |  | 38383 | static PyObject* from(const Ptr<cv::ccm::ColorCorrectionModel>& r)
| 38432 | { |  | 38384 | {
| 38433 | return pyopencv_ccm_ColorCorrectionModel_Instance(r); |  | 38385 | return pyopencv_ccm_ColorCorrectionModel_Instance(r);
| 38434 | } |  | 38386 | }
| 38435 | static bool to(PyObject* src, Ptr<cv::ccm::ColorCorrectionModel>& dst, const ArgInfo& info) |  | 38387 | static bool to(PyObject* src, Ptr<cv::ccm::ColorCorrectionModel>& dst, const ArgInfo& info)
| 38436 | { |  | 38388 | {
| 38437 | if(!src || src == Py_None) |  | 38389 | if(!src || src == Py_None)
| 38438 | return true; |  | 38390 | return true;
| 38439 | Ptr<cv::ccm::ColorCorrectionModel> * dst_; |  | 38391 | Ptr<cv::ccm::ColorCorrectionModel> * dst_;
| 38440 | if (pyopencv_ccm_ColorCorrectionModel_getp(src, dst_)) |  | 38392 | if (pyopencv_ccm_ColorCorrectionModel_getp(src, dst_))
| 38441 | { |  | 38393 | {
| 38442 | dst = *dst_; |  | 38394 | dst = *dst_;
| 38443 | return true; |  | 38395 | return true;
| 38444 | } |  | 38396 | }
| 38445 |  |  | 38397 |
| 38446 | failmsg("Expected Ptr<cv::ccm::ColorCorrectionModel> for argument '%s'", info.name); |  | 38398 | failmsg("Expected Ptr<cv::ccm::ColorCorrectionModel> for argument '%s'", info.name);
| 38447 | return false; |  | 38399 | return false;
| 38448 | } |  | 38400 | }
| 38449 | }; |  | 38401 | };
| 38450 |  |  | 38402 |
| 38451 | //================================================================================ |  | 38403 | //================================================================================
| 38452 | // colored_kinfu_ColoredKinFu (Generic) |  | 38404 | // colored_kinfu_ColoredKinFu (Generic)
| 38453 | //================================================================================ |  | 38405 | //================================================================================
| 38454 |  |  | 38406 |
| 38455 | // GetSet (colored_kinfu_ColoredKinFu) |  | 38407 | // GetSet (colored_kinfu_ColoredKinFu)
| 38456 |  |  | 38408 |
| 38457 |  |  | 38409 |
| 38458 |  |  | 38410 |
| 38459 | // Methods (colored_kinfu_ColoredKinFu) |  | 38411 | // Methods (colored_kinfu_ColoredKinFu)
| 38460 |  |  | 38412 |
| 38461 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38413 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 38462 | { |  | 38414 | {
| 38463 | using namespace cv::colored_kinfu; |  | 38415 | using namespace cv::colored_kinfu;
| 38464 |  |  | 38416 |
| 38465 | PyObject* pyobj__params = NULL; |  | 38417 | PyObject* pyobj__params = NULL;
| 38466 | Ptr<Params> _params; |  | 38418 | Ptr<Params> _params;
| 38467 | Ptr<ColoredKinFu> retval; |  | 38419 | Ptr<ColoredKinFu> retval;
| 38468 |  |  | 38420 |
| 38469 | const char* keywords[] = { "_params", NULL }; |  | 38421 | const char* keywords[] = { "_params", NULL };
| 38470 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_ColoredKinFu.create", (char**)keywords, &pyobj__params) && |  | 38422 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_ColoredKinFu.create", (char**)keywords, &pyobj__params) &&
| 38471 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) ) |  | 38423 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) )
| 38472 | { |  | 38424 | {
| 38473 | ERRWRAP2(retval = cv::colored_kinfu::ColoredKinFu::create(_params)); |  | 38425 | ERRWRAP2(retval = cv::colored_kinfu::ColoredKinFu::create(_params));
| 38474 | return pyopencv_from(retval); |  | 38426 | return pyopencv_from(retval);
| 38475 | } |  | 38427 | }
| 38476 |  |  | 38428 |
| 38477 | return NULL; |  | 38429 | return NULL;
| 38478 | } |  | 38430 | }
| 38479 |  |  | 38431 |
| 38480 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38432 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw)
| 38481 | { |  | 38433 | {
| 38482 | using namespace cv::colored_kinfu; |  | 38434 | using namespace cv::colored_kinfu;
| 38483 |  |  | 38435 |
| 38484 |  |  | 38436 |
| 38485 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0; |  | 38437 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0;
| 38486 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1)) |  | 38438 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1))
| 38487 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)"); |  | 38439 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)");
| 38488 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1); |  | 38440 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1);
| 38489 | pyPrepareArgumentConversionErrorsStorage(2); |  | 38441 | pyPrepareArgumentConversionErrorsStorage(2);
| 38490 |  |  | 38442 |
| 38491 | { |  | 38443 | {
| 38492 | PyObject* pyobj_points = NULL; |  | 38444 | PyObject* pyobj_points = NULL;
| 38493 | Mat points; |  | 38445 | Mat points;
| 38494 | PyObject* pyobj_normals = NULL; |  | 38446 | PyObject* pyobj_normals = NULL;
| 38495 | Mat normals; |  | 38447 | Mat normals;
| 38496 | PyObject* pyobj_colors = NULL; |  | 38448 | PyObject* pyobj_colors = NULL;
| 38497 | Mat colors; |  | 38449 | Mat colors;
| 38498 |  |  | 38450 |
| 38499 | const char* keywords[] = { "points", "normals", "colors", NULL }; |  | 38451 | const char* keywords[] = { "points", "normals", "colors", NULL };
| 38500 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:colored_kinfu_ColoredKinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals, &pyobj_colors) && |  | 38452 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:colored_kinfu_ColoredKinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals, &pyobj_colors) &&
| 38501 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 38453 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 38502 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) && |  | 38454 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) &&
| 38503 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 1)) ) |  | 38455 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 1)) )
| 38504 | { |  | 38456 | {
| 38505 | ERRWRAP2(_self_->getCloud(points, normals, colors)); |  | 38457 | ERRWRAP2(_self_->getCloud(points, normals, colors));
| 38506 | return Py_BuildValue("(NNN)", pyopencv_from(points), pyopencv_from(normals), pyopencv_from(colors)); |  | 38458 | return Py_BuildValue("(NNN)", pyopencv_from(points), pyopencv_from(normals), pyopencv_from(colors));
| 38507 | } |  | 38459 | }
| 38508 |  |  | 38460 |
| 38509 |  |  | 38461 |
| 38510 | pyPopulateArgumentConversionErrors(); |  | 38462 | pyPopulateArgumentConversionErrors();
| 38511 | } |  | 38463 | }
| 38512 |  |  | 38464 |
| 38513 |  |  | 38465 |
| 38514 | { |  | 38466 | {
| 38515 | PyObject* pyobj_points = NULL; |  | 38467 | PyObject* pyobj_points = NULL;
| 38516 | UMat points; |  | 38468 | UMat points;
| 38517 | PyObject* pyobj_normals = NULL; |  | 38469 | PyObject* pyobj_normals = NULL;
| 38518 | UMat normals; |  | 38470 | UMat normals;
| 38519 | PyObject* pyobj_colors = NULL; |  | 38471 | PyObject* pyobj_colors = NULL;
| 38520 | UMat colors; |  | 38472 | UMat colors;
| 38521 |  |  | 38473 |
| 38522 | const char* keywords[] = { "points", "normals", "colors", NULL }; |  | 38474 | const char* keywords[] = { "points", "normals", "colors", NULL };
| 38523 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:colored_kinfu_ColoredKinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals, &pyobj_colors) && |  | 38475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:colored_kinfu_ColoredKinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals, &pyobj_colors) &&
| 38524 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 38476 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 38525 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) && |  | 38477 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) &&
| 38526 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 1)) ) |  | 38478 | pyopencv_to_safe(pyobj_colors, colors, ArgInfo("colors", 1)) )
| 38527 | { |  | 38479 | {
| 38528 | ERRWRAP2(_self_->getCloud(points, normals, colors)); |  | 38480 | ERRWRAP2(_self_->getCloud(points, normals, colors));
| 38529 | return Py_BuildValue("(NNN)", pyopencv_from(points), pyopencv_from(normals), pyopencv_from(colors)); |  | 38481 | return Py_BuildValue("(NNN)", pyopencv_from(points), pyopencv_from(normals), pyopencv_from(colors));
| 38530 | } |  | 38482 | }
| 38531 |  |  | 38483 |
| 38532 |  |  | 38484 |
| 38533 | pyPopulateArgumentConversionErrors(); |  | 38485 | pyPopulateArgumentConversionErrors();
| 38534 | } |  | 38486 | }
| 38535 | pyRaiseCVOverloadException("getCloud"); |  | 38487 | pyRaiseCVOverloadException("getCloud");
| 38536 |  |  | 38488 |
| 38537 | return NULL; |  | 38489 | return NULL;
| 38538 | } |  | 38490 | }
| 38539 |  |  | 38491 |
| 38540 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38492 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw)
| 38541 | { |  | 38493 | {
| 38542 | using namespace cv::colored_kinfu; |  | 38494 | using namespace cv::colored_kinfu;
| 38543 |  |  | 38495 |
| 38544 |  |  | 38496 |
| 38545 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0; |  | 38497 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0;
| 38546 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1)) |  | 38498 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1))
| 38547 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)"); |  | 38499 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)");
| 38548 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1); |  | 38500 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1);
| 38549 | pyPrepareArgumentConversionErrorsStorage(2); |  | 38501 | pyPrepareArgumentConversionErrorsStorage(2);
| 38550 |  |  | 38502 |
| 38551 | { |  | 38503 | {
| 38552 | PyObject* pyobj_points = NULL; |  | 38504 | PyObject* pyobj_points = NULL;
| 38553 | Mat points; |  | 38505 | Mat points;
| 38554 | PyObject* pyobj_normals = NULL; |  | 38506 | PyObject* pyobj_normals = NULL;
| 38555 | Mat normals; |  | 38507 | Mat normals;
| 38556 |  |  | 38508 |
| 38557 | const char* keywords[] = { "points", "normals", NULL }; |  | 38509 | const char* keywords[] = { "points", "normals", NULL };
| 38558 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 38510 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 38559 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 38511 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 38560 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 38512 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 38561 | { |  | 38513 | {
| 38562 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 38514 | ERRWRAP2(_self_->getNormals(points, normals));
| 38563 | return pyopencv_from(normals); |  | 38515 | return pyopencv_from(normals);
| 38564 | } |  | 38516 | }
| 38565 |  |  | 38517 |
| 38566 |  |  | 38518 |
| 38567 | pyPopulateArgumentConversionErrors(); |  | 38519 | pyPopulateArgumentConversionErrors();
| 38568 | } |  | 38520 | }
| 38569 |  |  | 38521 |
| 38570 |  |  | 38522 |
| 38571 | { |  | 38523 | {
| 38572 | PyObject* pyobj_points = NULL; |  | 38524 | PyObject* pyobj_points = NULL;
| 38573 | UMat points; |  | 38525 | UMat points;
| 38574 | PyObject* pyobj_normals = NULL; |  | 38526 | PyObject* pyobj_normals = NULL;
| 38575 | UMat normals; |  | 38527 | UMat normals;
| 38576 |  |  | 38528 |
| 38577 | const char* keywords[] = { "points", "normals", NULL }; |  | 38529 | const char* keywords[] = { "points", "normals", NULL };
| 38578 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 38530 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 38579 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 38531 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 38580 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 38532 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 38581 | { |  | 38533 | {
| 38582 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 38534 | ERRWRAP2(_self_->getNormals(points, normals));
| 38583 | return pyopencv_from(normals); |  | 38535 | return pyopencv_from(normals);
| 38584 | } |  | 38536 | }
| 38585 |  |  | 38537 |
| 38586 |  |  | 38538 |
| 38587 | pyPopulateArgumentConversionErrors(); |  | 38539 | pyPopulateArgumentConversionErrors();
| 38588 | } |  | 38540 | }
| 38589 | pyRaiseCVOverloadException("getNormals"); |  | 38541 | pyRaiseCVOverloadException("getNormals");
| 38590 |  |  | 38542 |
| 38591 | return NULL; |  | 38543 | return NULL;
| 38592 | } |  | 38544 | }
| 38593 |  |  | 38545 |
| 38594 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38546 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 38595 | { |  | 38547 | {
| 38596 | using namespace cv::colored_kinfu; |  | 38548 | using namespace cv::colored_kinfu;
| 38597 |  |  | 38549 |
| 38598 |  |  | 38550 |
| 38599 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0; |  | 38551 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0;
| 38600 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1)) |  | 38552 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1))
| 38601 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)"); |  | 38553 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)");
| 38602 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1); |  | 38554 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1);
| 38603 | pyPrepareArgumentConversionErrorsStorage(2); |  | 38555 | pyPrepareArgumentConversionErrorsStorage(2);
| 38604 |  |  | 38556 |
| 38605 | { |  | 38557 | {
| 38606 | PyObject* pyobj_points = NULL; |  | 38558 | PyObject* pyobj_points = NULL;
| 38607 | Mat points; |  | 38559 | Mat points;
| 38608 |  |  | 38560 |
| 38609 | const char* keywords[] = { "points", NULL }; |  | 38561 | const char* keywords[] = { "points", NULL };
| 38610 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.getPoints", (char**)keywords, &pyobj_points) && |  | 38562 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.getPoints", (char**)keywords, &pyobj_points) &&
| 38611 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 38563 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 38612 | { |  | 38564 | {
| 38613 | ERRWRAP2(_self_->getPoints(points)); |  | 38565 | ERRWRAP2(_self_->getPoints(points));
| 38614 | return pyopencv_from(points); |  | 38566 | return pyopencv_from(points);
| 38615 | } |  | 38567 | }
| 38616 |  |  | 38568 |
| 38617 |  |  | 38569 |
| 38618 | pyPopulateArgumentConversionErrors(); |  | 38570 | pyPopulateArgumentConversionErrors();
| 38619 | } |  | 38571 | }
| 38620 |  |  | 38572 |
| 38621 |  |  | 38573 |
| 38622 | { |  | 38574 | {
| 38623 | PyObject* pyobj_points = NULL; |  | 38575 | PyObject* pyobj_points = NULL;
| 38624 | UMat points; |  | 38576 | UMat points;
| 38625 |  |  | 38577 |
| 38626 | const char* keywords[] = { "points", NULL }; |  | 38578 | const char* keywords[] = { "points", NULL };
| 38627 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.getPoints", (char**)keywords, &pyobj_points) && |  | 38579 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.getPoints", (char**)keywords, &pyobj_points) &&
| 38628 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 38580 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 38629 | { |  | 38581 | {
| 38630 | ERRWRAP2(_self_->getPoints(points)); |  | 38582 | ERRWRAP2(_self_->getPoints(points));
| 38631 | return pyopencv_from(points); |  | 38583 | return pyopencv_from(points);
| 38632 | } |  | 38584 | }
| 38633 |  |  | 38585 |
| 38634 |  |  | 38586 |
| 38635 | pyPopulateArgumentConversionErrors(); |  | 38587 | pyPopulateArgumentConversionErrors();
| 38636 | } |  | 38588 | }
| 38637 | pyRaiseCVOverloadException("getPoints"); |  | 38589 | pyRaiseCVOverloadException("getPoints");
| 38638 |  |  | 38590 |
| 38639 | return NULL; |  | 38591 | return NULL;
| 38640 | } |  | 38592 | }
| 38641 |  |  | 38593 |
| 38642 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_render(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38594 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_render(PyObject* self, PyObject* py_args, PyObject* kw)
| 38643 | { |  | 38595 | {
| 38644 | using namespace cv::colored_kinfu; |  | 38596 | using namespace cv::colored_kinfu;
| 38645 |  |  | 38597 |
| 38646 |  |  | 38598 |
| 38647 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0; |  | 38599 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0;
| 38648 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1)) |  | 38600 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1))
| 38649 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)"); |  | 38601 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)");
| 38650 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1); |  | 38602 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1);
| 38651 | pyPrepareArgumentConversionErrorsStorage(4); |  | 38603 | pyPrepareArgumentConversionErrorsStorage(4);
| 38652 |  |  | 38604 |
| 38653 | { |  | 38605 | {
| 38654 | PyObject* pyobj_image = NULL; |  | 38606 | PyObject* pyobj_image = NULL;
| 38655 | Mat image; |  | 38607 | Mat image;
| 38656 |  |  | 38608 |
| 38657 | const char* keywords[] = { "image", NULL }; |  | 38609 | const char* keywords[] = { "image", NULL };
| 38658 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_image) && |  | 38610 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_image) &&
| 38659 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 38611 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 38660 | { |  | 38612 | {
| 38661 | ERRWRAP2(_self_->render(image)); |  | 38613 | ERRWRAP2(_self_->render(image));
| 38662 | return pyopencv_from(image); |  | 38614 | return pyopencv_from(image);
| 38663 | } |  | 38615 | }
| 38664 |  |  | 38616 |
| 38665 |  |  | 38617 |
| 38666 | pyPopulateArgumentConversionErrors(); |  | 38618 | pyPopulateArgumentConversionErrors();
| 38667 | } |  | 38619 | }
| 38668 |  |  | 38620 |
| 38669 |  |  | 38621 |
| 38670 | { |  | 38622 | {
| 38671 | PyObject* pyobj_image = NULL; |  | 38623 | PyObject* pyobj_image = NULL;
| 38672 | Mat image; |  | 38624 | Mat image;
| 38673 | PyObject* pyobj_cameraPose = NULL; |  | 38625 | PyObject* pyobj_cameraPose = NULL;
| 38674 | Matx44f cameraPose; |  | 38626 | Matx44f cameraPose;
| 38675 |  |  | 38627 |
| 38676 | const char* keywords[] = { "cameraPose", "image", NULL }; |  | 38628 | const char* keywords[] = { "cameraPose", "image", NULL };
| 38677 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) && |  | 38629 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) &&
| 38678 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 38630 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 38679 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 38631 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 38680 | { |  | 38632 | {
| 38681 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 38633 | ERRWRAP2(_self_->render(image, cameraPose));
| 38682 | return pyopencv_from(image); |  | 38634 | return pyopencv_from(image);
| 38683 | } |  | 38635 | }
| 38684 |  |  | 38636 |
| 38685 |  |  | 38637 |
| 38686 | pyPopulateArgumentConversionErrors(); |  | 38638 | pyPopulateArgumentConversionErrors();
| 38687 | } |  | 38639 | }
| 38688 |  |  | 38640 |
| 38689 |  |  | 38641 |
| 38690 | { |  | 38642 | {
| 38691 | PyObject* pyobj_image = NULL; |  | 38643 | PyObject* pyobj_image = NULL;
| 38692 | UMat image; |  | 38644 | UMat image;
| 38693 |  |  | 38645 |
| 38694 | const char* keywords[] = { "image", NULL }; |  | 38646 | const char* keywords[] = { "image", NULL };
| 38695 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_image) && |  | 38647 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_image) &&
| 38696 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 38648 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 38697 | { |  | 38649 | {
| 38698 | ERRWRAP2(_self_->render(image)); |  | 38650 | ERRWRAP2(_self_->render(image));
| 38699 | return pyopencv_from(image); |  | 38651 | return pyopencv_from(image);
| 38700 | } |  | 38652 | }
| 38701 |  |  | 38653 |
| 38702 |  |  | 38654 |
| 38703 | pyPopulateArgumentConversionErrors(); |  | 38655 | pyPopulateArgumentConversionErrors();
| 38704 | } |  | 38656 | }
| 38705 |  |  | 38657 |
| 38706 |  |  | 38658 |
| 38707 | { |  | 38659 | {
| 38708 | PyObject* pyobj_image = NULL; |  | 38660 | PyObject* pyobj_image = NULL;
| 38709 | UMat image; |  | 38661 | UMat image;
| 38710 | PyObject* pyobj_cameraPose = NULL; |  | 38662 | PyObject* pyobj_cameraPose = NULL;
| 38711 | Matx44f cameraPose; |  | 38663 | Matx44f cameraPose;
| 38712 |  |  | 38664 |
| 38713 | const char* keywords[] = { "cameraPose", "image", NULL }; |  | 38665 | const char* keywords[] = { "cameraPose", "image", NULL };
| 38714 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) && |  | 38666 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:colored_kinfu_ColoredKinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) &&
| 38715 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 38667 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 38716 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 38668 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 38717 | { |  | 38669 | {
| 38718 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 38670 | ERRWRAP2(_self_->render(image, cameraPose));
| 38719 | return pyopencv_from(image); |  | 38671 | return pyopencv_from(image);
| 38720 | } |  | 38672 | }
| 38721 |  |  | 38673 |
| 38722 |  |  | 38674 |
| 38723 | pyPopulateArgumentConversionErrors(); |  | 38675 | pyPopulateArgumentConversionErrors();
| 38724 | } |  | 38676 | }
| 38725 | pyRaiseCVOverloadException("render"); |  | 38677 | pyRaiseCVOverloadException("render");
| 38726 |  |  | 38678 |
| 38727 | return NULL; |  | 38679 | return NULL;
| 38728 | } |  | 38680 | }
| 38729 |  |  | 38681 |
| 38730 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_reset(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38682 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_reset(PyObject* self, PyObject* py_args, PyObject* kw)
| 38731 | { |  | 38683 | {
| 38732 | using namespace cv::colored_kinfu; |  | 38684 | using namespace cv::colored_kinfu;
| 38733 |  |  | 38685 |
| 38734 |  |  | 38686 |
| 38735 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0; |  | 38687 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0;
| 38736 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1)) |  | 38688 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1))
| 38737 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)"); |  | 38689 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)");
| 38738 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1); |  | 38690 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1);
| 38739 |  |  | 38691 |
| 38740 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 38692 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 38741 | { |  | 38693 | {
| 38742 | ERRWRAP2(_self_->reset()); |  | 38694 | ERRWRAP2(_self_->reset());
| 38743 | Py_RETURN_NONE; |  | 38695 | Py_RETURN_NONE;
| 38744 | } |  | 38696 | }
| 38745 |  |  | 38697 |
| 38746 | return NULL; |  | 38698 | return NULL;
| 38747 | } |  | 38699 | }
| 38748 |  |  | 38700 |
| 38749 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 38701 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 38750 | { |  | 38702 | {
| 38751 | using namespace cv::colored_kinfu; |  | 38703 | using namespace cv::colored_kinfu;
| 38752 |  |  | 38704 |
| 38753 |  |  | 38705 |
| 38754 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0; |  | 38706 | Ptr<cv::colored_kinfu::ColoredKinFu> * self1 = 0;
| 38755 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1)) |  | 38707 | if (!pyopencv_colored_kinfu_ColoredKinFu_getp(self, self1))
| 38756 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)"); |  | 38708 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_ColoredKinFu' or its derivative)");
| 38757 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1); |  | 38709 | Ptr<cv::colored_kinfu::ColoredKinFu> _self_ = *(self1);
| 38758 | pyPrepareArgumentConversionErrorsStorage(2); |  | 38710 | pyPrepareArgumentConversionErrorsStorage(2);
| 38759 |  |  | 38711 |
| 38760 | { |  | 38712 | {
| 38761 | PyObject* pyobj_depth = NULL; |  | 38713 | PyObject* pyobj_depth = NULL;
| 38762 | Mat depth; |  | 38714 | Mat depth;
| 38763 | PyObject* pyobj_rgb = NULL; |  | 38715 | PyObject* pyobj_rgb = NULL;
| 38764 | Mat rgb; |  | 38716 | Mat rgb;
| 38765 | bool retval; |  | 38717 | bool retval;
| 38766 |  |  | 38718 |
| 38767 | const char* keywords[] = { "depth", "rgb", NULL }; |  | 38719 | const char* keywords[] = { "depth", "rgb", NULL };
| 38768 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:colored_kinfu_ColoredKinFu.update", (char**)keywords, &pyobj_depth, &pyobj_rgb) && |  | 38720 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:colored_kinfu_ColoredKinFu.update", (char**)keywords, &pyobj_depth, &pyobj_rgb) &&
| 38769 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) && |  | 38721 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) &&
| 38770 | pyopencv_to_safe(pyobj_rgb, rgb, ArgInfo("rgb", 0)) ) |  | 38722 | pyopencv_to_safe(pyobj_rgb, rgb, ArgInfo("rgb", 0)) )
| 38771 | { |  | 38723 | {
| 38772 | ERRWRAP2(retval = _self_->update(depth, rgb)); |  | 38724 | ERRWRAP2(retval = _self_->update(depth, rgb));
| 38773 | return pyopencv_from(retval); |  | 38725 | return pyopencv_from(retval);
| 38774 | } |  | 38726 | }
| 38775 |  |  | 38727 |
| 38776 |  |  | 38728 |
| 38777 | pyPopulateArgumentConversionErrors(); |  | 38729 | pyPopulateArgumentConversionErrors();
| 38778 | } |  | 38730 | }
| 38779 |  |  | 38731 |
| 38780 |  |  | 38732 |
| 38781 | { |  | 38733 | {
| 38782 | PyObject* pyobj_depth = NULL; |  | 38734 | PyObject* pyobj_depth = NULL;
| 38783 | UMat depth; |  | 38735 | UMat depth;
| 38784 | PyObject* pyobj_rgb = NULL; |  | 38736 | PyObject* pyobj_rgb = NULL;
| 38785 | UMat rgb; |  | 38737 | UMat rgb;
| 38786 | bool retval; |  | 38738 | bool retval;
| 38787 |  |  | 38739 |
| 38788 | const char* keywords[] = { "depth", "rgb", NULL }; |  | 38740 | const char* keywords[] = { "depth", "rgb", NULL };
| 38789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:colored_kinfu_ColoredKinFu.update", (char**)keywords, &pyobj_depth, &pyobj_rgb) && |  | 38741 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:colored_kinfu_ColoredKinFu.update", (char**)keywords, &pyobj_depth, &pyobj_rgb) &&
| 38790 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) && |  | 38742 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) &&
| 38791 | pyopencv_to_safe(pyobj_rgb, rgb, ArgInfo("rgb", 0)) ) |  | 38743 | pyopencv_to_safe(pyobj_rgb, rgb, ArgInfo("rgb", 0)) )
| 38792 | { |  | 38744 | {
| 38793 | ERRWRAP2(retval = _self_->update(depth, rgb)); |  | 38745 | ERRWRAP2(retval = _self_->update(depth, rgb));
| 38794 | return pyopencv_from(retval); |  | 38746 | return pyopencv_from(retval);
| 38795 | } |  | 38747 | }
| 38796 |  |  | 38748 |
| 38797 |  |  | 38749 |
| 38798 | pyPopulateArgumentConversionErrors(); |  | 38750 | pyPopulateArgumentConversionErrors();
| 38799 | } |  | 38751 | }
| 38800 | pyRaiseCVOverloadException("update"); |  | 38752 | pyRaiseCVOverloadException("update");
| 38801 |  |  | 38753 |
| 38802 | return NULL; |  | 38754 | return NULL;
| 38803 | } |  | 38755 | }
| 38804 |  |  | 38756 |
| 38805 |  |  | 38757 |
| 38806 |  |  | 38758 |
| 38807 | // Tables (colored_kinfu_ColoredKinFu) |  | 38759 | // Tables (colored_kinfu_ColoredKinFu)
| 38808 |  |  | 38760 |
| 38809 | static PyGetSetDef pyopencv_colored_kinfu_ColoredKinFu_getseters[] = |  | 38761 | static PyGetSetDef pyopencv_colored_kinfu_ColoredKinFu_getseters[] =
| 38810 | { |  | 38762 | {
| 38811 | {NULL} /* Sentinel */ |  | 38763 | {NULL} /* Sentinel */
| 38812 | }; |  | 38764 | };
| 38813 |  |  | 38765 |
| 38814 | static PyMethodDef pyopencv_colored_kinfu_ColoredKinFu_methods[] = |  | 38766 | static PyMethodDef pyopencv_colored_kinfu_ColoredKinFu_methods[] =
| 38815 | { |  | 38767 | {
| 38816 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_create_static, METH_STATIC), "create(_params) -> retval\n."}, |  | 38768 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_create_static, METH_STATIC), "create(_params) -> retval\n."},
| 38817 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getCloud, 0), "getCloud([, points[, normals[, colors]]]) -> points, normals, colors\n. @brief Gets points, normals and colors of current 3d mesh\n. \n. The order of normals corresponds to order of points.\n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors\n. @param normals vector of normals which are 4-float vectors\n. @param colors vector of colors which are 4-float vectors"}, |  | 38769 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getCloud, 0), "getCloud([, points[, normals[, colors]]]) -> points, normals, colors\n. @brief Gets points, normals and colors of current 3d mesh\n. \n. The order of normals corresponds to order of points.\n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors\n. @param normals vector of normals which are 4-float vectors\n. @param colors vector of colors which are 4-float vectors"},
| 38818 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getNormals, 0), "getNormals(points[, normals]) -> normals\n. @brief Calculates normals for given points\n. @param points input vector of points which are 4-float vectors\n. @param normals output vector of corresponding normals which are 4-float vectors"}, |  | 38770 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getNormals, 0), "getNormals(points[, normals]) -> normals\n. @brief Calculates normals for given points\n. @param points input vector of points which are 4-float vectors\n. @param normals output vector of corresponding normals which are 4-float vectors"},
| 38819 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getPoints, 0), "getPoints([, points]) -> points\n. @brief Gets points of current 3d mesh\n. \n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors"}, |  | 38771 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_getPoints, 0), "getPoints([, points]) -> points\n. @brief Gets points of current 3d mesh\n. \n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors"},
| 38820 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_render, 0), "render([, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n\n\n\nrender(cameraPose[, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n. @param cameraPose pose of camera to render from. If empty then render from current pose\n. which is a last frame camera pose."}, |  | 38772 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_render, 0), "render([, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n\n\n\nrender(cameraPose[, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n. @param cameraPose pose of camera to render from. If empty then render from current pose\n. which is a last frame camera pose."},
| 38821 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_reset, 0), "reset() -> None\n. @brief Resets the algorithm\n. \n. Clears current model and resets a pose."}, |  | 38773 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_reset, 0), "reset() -> None\n. @brief Resets the algorithm\n. \n. Clears current model and resets a pose."},
| 38822 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_update, 0), "update(depth, rgb) -> retval\n. @brief Process next depth frame\n. @param depth input Mat of depth frame\n. @param rgb input Mat of rgb (colored) frame\n. \n. @return true if succeeded to align new frame with current scene, false if opposite"}, |  | 38774 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_ColoredKinFu_update, 0), "update(depth, rgb) -> retval\n. @brief Process next depth frame\n. @param depth input Mat of depth frame\n. @param rgb input Mat of rgb (colored) frame\n. \n. @return true if succeeded to align new frame with current scene, false if opposite"},
| 38823 |  |  | 38775 |
| 38824 | {NULL, NULL} |  | 38776 | {NULL, NULL}
| 38825 | }; |  | 38777 | };
| 38826 |  |  | 38778 |
| 38827 | // Converter (colored_kinfu_ColoredKinFu) |  | 38779 | // Converter (colored_kinfu_ColoredKinFu)
| 38828 |  |  | 38780 |
| 38829 | template<> |  | 38781 | template<>
| 38830 | struct PyOpenCV_Converter< Ptr<cv::colored_kinfu::ColoredKinFu> > |  | 38782 | struct PyOpenCV_Converter< Ptr<cv::colored_kinfu::ColoredKinFu> >
| 38831 | { |  | 38783 | {
| 38832 | static PyObject* from(const Ptr<cv::colored_kinfu::ColoredKinFu>& r) |  | 38784 | static PyObject* from(const Ptr<cv::colored_kinfu::ColoredKinFu>& r)
| 38833 | { |  | 38785 | {
| 38834 | return pyopencv_colored_kinfu_ColoredKinFu_Instance(r); |  | 38786 | return pyopencv_colored_kinfu_ColoredKinFu_Instance(r);
| 38835 | } |  | 38787 | }
| 38836 | static bool to(PyObject* src, Ptr<cv::colored_kinfu::ColoredKinFu>& dst, const ArgInfo& info) |  | 38788 | static bool to(PyObject* src, Ptr<cv::colored_kinfu::ColoredKinFu>& dst, const ArgInfo& info)
| 38837 | { |  | 38789 | {
| 38838 | if(!src || src == Py_None) |  | 38790 | if(!src || src == Py_None)
| 38839 | return true; |  | 38791 | return true;
| 38840 | Ptr<cv::colored_kinfu::ColoredKinFu> * dst_; |  | 38792 | Ptr<cv::colored_kinfu::ColoredKinFu> * dst_;
| 38841 | if (pyopencv_colored_kinfu_ColoredKinFu_getp(src, dst_)) |  | 38793 | if (pyopencv_colored_kinfu_ColoredKinFu_getp(src, dst_))
| 38842 | { |  | 38794 | {
| 38843 | dst = *dst_; |  | 38795 | dst = *dst_;
| 38844 | return true; |  | 38796 | return true;
| 38845 | } |  | 38797 | }
| 38846 |  |  | 38798 |
| 38847 | failmsg("Expected Ptr<cv::colored_kinfu::ColoredKinFu> for argument '%s'", info.name); |  | 38799 | failmsg("Expected Ptr<cv::colored_kinfu::ColoredKinFu> for argument '%s'", info.name);
| 38848 | return false; |  | 38800 | return false;
| 38849 | } |  | 38801 | }
| 38850 | }; |  | 38802 | };
| 38851 |  |  | 38803 |
| 38852 | //================================================================================ |  | 38804 | //================================================================================
| 38853 | // colored_kinfu_Params (Generic) |  | 38805 | // colored_kinfu_Params (Generic)
| 38854 | //================================================================================ |  | 38806 | //================================================================================
| 38855 |  |  | 38807 |
| 38856 | // GetSet (colored_kinfu_Params) |  | 38808 | // GetSet (colored_kinfu_Params)
| 38857 |  |  | 38809 |
| 38858 |  |  | 38810 |
| 38859 | static PyObject* pyopencv_colored_kinfu_Params_get_bilateral_kernel_size(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38811 | static PyObject* pyopencv_colored_kinfu_Params_get_bilateral_kernel_size(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38860 | { |  | 38812 | {
| 38861 | return pyopencv_from(p->v->bilateral_kernel_size); |  | 38813 | return pyopencv_from(p->v->bilateral_kernel_size);
| 38862 | } |  | 38814 | }
| 38863 |  |  | 38815 |
| 38864 | static int pyopencv_colored_kinfu_Params_set_bilateral_kernel_size(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38816 | static int pyopencv_colored_kinfu_Params_set_bilateral_kernel_size(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38865 | { |  | 38817 | {
| 38866 | if (!value) |  | 38818 | if (!value)
| 38867 | { |  | 38819 | {
| 38868 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_kernel_size attribute"); |  | 38820 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_kernel_size attribute");
| 38869 | return -1; |  | 38821 | return -1;
| 38870 | } |  | 38822 | }
| 38871 | return pyopencv_to_safe(value, p->v->bilateral_kernel_size, ArgInfo("value", 0)) ? 0 : -1; |  | 38823 | return pyopencv_to_safe(value, p->v->bilateral_kernel_size, ArgInfo("value", 0)) ? 0 : -1;
| 38872 | } |  | 38824 | }
| 38873 |  |  | 38825 |
| 38874 | static PyObject* pyopencv_colored_kinfu_Params_get_bilateral_sigma_depth(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38826 | static PyObject* pyopencv_colored_kinfu_Params_get_bilateral_sigma_depth(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38875 | { |  | 38827 | {
| 38876 | return pyopencv_from(p->v->bilateral_sigma_depth); |  | 38828 | return pyopencv_from(p->v->bilateral_sigma_depth);
| 38877 | } |  | 38829 | }
| 38878 |  |  | 38830 |
| 38879 | static int pyopencv_colored_kinfu_Params_set_bilateral_sigma_depth(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38831 | static int pyopencv_colored_kinfu_Params_set_bilateral_sigma_depth(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38880 | { |  | 38832 | {
| 38881 | if (!value) |  | 38833 | if (!value)
| 38882 | { |  | 38834 | {
| 38883 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_depth attribute"); |  | 38835 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_depth attribute");
| 38884 | return -1; |  | 38836 | return -1;
| 38885 | } |  | 38837 | }
| 38886 | return pyopencv_to_safe(value, p->v->bilateral_sigma_depth, ArgInfo("value", 0)) ? 0 : -1; |  | 38838 | return pyopencv_to_safe(value, p->v->bilateral_sigma_depth, ArgInfo("value", 0)) ? 0 : -1;
| 38887 | } |  | 38839 | }
| 38888 |  |  | 38840 |
| 38889 | static PyObject* pyopencv_colored_kinfu_Params_get_bilateral_sigma_spatial(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38841 | static PyObject* pyopencv_colored_kinfu_Params_get_bilateral_sigma_spatial(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38890 | { |  | 38842 | {
| 38891 | return pyopencv_from(p->v->bilateral_sigma_spatial); |  | 38843 | return pyopencv_from(p->v->bilateral_sigma_spatial);
| 38892 | } |  | 38844 | }
| 38893 |  |  | 38845 |
| 38894 | static int pyopencv_colored_kinfu_Params_set_bilateral_sigma_spatial(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38846 | static int pyopencv_colored_kinfu_Params_set_bilateral_sigma_spatial(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38895 | { |  | 38847 | {
| 38896 | if (!value) |  | 38848 | if (!value)
| 38897 | { |  | 38849 | {
| 38898 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_spatial attribute"); |  | 38850 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_spatial attribute");
| 38899 | return -1; |  | 38851 | return -1;
| 38900 | } |  | 38852 | }
| 38901 | return pyopencv_to_safe(value, p->v->bilateral_sigma_spatial, ArgInfo("value", 0)) ? 0 : -1; |  | 38853 | return pyopencv_to_safe(value, p->v->bilateral_sigma_spatial, ArgInfo("value", 0)) ? 0 : -1;
| 38902 | } |  | 38854 | }
| 38903 |  |  | 38855 |
| 38904 | static PyObject* pyopencv_colored_kinfu_Params_get_depthFactor(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38856 | static PyObject* pyopencv_colored_kinfu_Params_get_depthFactor(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38905 | { |  | 38857 | {
| 38906 | return pyopencv_from(p->v->depthFactor); |  | 38858 | return pyopencv_from(p->v->depthFactor);
| 38907 | } |  | 38859 | }
| 38908 |  |  | 38860 |
| 38909 | static int pyopencv_colored_kinfu_Params_set_depthFactor(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38861 | static int pyopencv_colored_kinfu_Params_set_depthFactor(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38910 | { |  | 38862 | {
| 38911 | if (!value) |  | 38863 | if (!value)
| 38912 | { |  | 38864 | {
| 38913 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthFactor attribute"); |  | 38865 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthFactor attribute");
| 38914 | return -1; |  | 38866 | return -1;
| 38915 | } |  | 38867 | }
| 38916 | return pyopencv_to_safe(value, p->v->depthFactor, ArgInfo("value", 0)) ? 0 : -1; |  | 38868 | return pyopencv_to_safe(value, p->v->depthFactor, ArgInfo("value", 0)) ? 0 : -1;
| 38917 | } |  | 38869 | }
| 38918 |  |  | 38870 |
| 38919 | static PyObject* pyopencv_colored_kinfu_Params_get_frameSize(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38871 | static PyObject* pyopencv_colored_kinfu_Params_get_frameSize(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38920 | { |  | 38872 | {
| 38921 | return pyopencv_from(p->v->frameSize); |  | 38873 | return pyopencv_from(p->v->frameSize);
| 38922 | } |  | 38874 | }
| 38923 |  |  | 38875 |
| 38924 | static int pyopencv_colored_kinfu_Params_set_frameSize(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38876 | static int pyopencv_colored_kinfu_Params_set_frameSize(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38925 | { |  | 38877 | {
| 38926 | if (!value) |  | 38878 | if (!value)
| 38927 | { |  | 38879 | {
| 38928 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frameSize attribute"); |  | 38880 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frameSize attribute");
| 38929 | return -1; |  | 38881 | return -1;
| 38930 | } |  | 38882 | }
| 38931 | return pyopencv_to_safe(value, p->v->frameSize, ArgInfo("value", 0)) ? 0 : -1; |  | 38883 | return pyopencv_to_safe(value, p->v->frameSize, ArgInfo("value", 0)) ? 0 : -1;
| 38932 | } |  | 38884 | }
| 38933 |  |  | 38885 |
| 38934 | static PyObject* pyopencv_colored_kinfu_Params_get_icpAngleThresh(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38886 | static PyObject* pyopencv_colored_kinfu_Params_get_icpAngleThresh(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38935 | { |  | 38887 | {
| 38936 | return pyopencv_from(p->v->icpAngleThresh); |  | 38888 | return pyopencv_from(p->v->icpAngleThresh);
| 38937 | } |  | 38889 | }
| 38938 |  |  | 38890 |
| 38939 | static int pyopencv_colored_kinfu_Params_set_icpAngleThresh(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38891 | static int pyopencv_colored_kinfu_Params_set_icpAngleThresh(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38940 | { |  | 38892 | {
| 38941 | if (!value) |  | 38893 | if (!value)
| 38942 | { |  | 38894 | {
| 38943 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpAngleThresh attribute"); |  | 38895 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpAngleThresh attribute");
| 38944 | return -1; |  | 38896 | return -1;
| 38945 | } |  | 38897 | }
| 38946 | return pyopencv_to_safe(value, p->v->icpAngleThresh, ArgInfo("value", 0)) ? 0 : -1; |  | 38898 | return pyopencv_to_safe(value, p->v->icpAngleThresh, ArgInfo("value", 0)) ? 0 : -1;
| 38947 | } |  | 38899 | }
| 38948 |  |  | 38900 |
| 38949 | static PyObject* pyopencv_colored_kinfu_Params_get_icpDistThresh(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38901 | static PyObject* pyopencv_colored_kinfu_Params_get_icpDistThresh(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38950 | { |  | 38902 | {
| 38951 | return pyopencv_from(p->v->icpDistThresh); |  | 38903 | return pyopencv_from(p->v->icpDistThresh);
| 38952 | } |  | 38904 | }
| 38953 |  |  | 38905 |
| 38954 | static int pyopencv_colored_kinfu_Params_set_icpDistThresh(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38906 | static int pyopencv_colored_kinfu_Params_set_icpDistThresh(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38955 | { |  | 38907 | {
| 38956 | if (!value) |  | 38908 | if (!value)
| 38957 | { |  | 38909 | {
| 38958 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpDistThresh attribute"); |  | 38910 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpDistThresh attribute");
| 38959 | return -1; |  | 38911 | return -1;
| 38960 | } |  | 38912 | }
| 38961 | return pyopencv_to_safe(value, p->v->icpDistThresh, ArgInfo("value", 0)) ? 0 : -1; |  | 38913 | return pyopencv_to_safe(value, p->v->icpDistThresh, ArgInfo("value", 0)) ? 0 : -1;
| 38962 | } |  | 38914 | }
| 38963 |  |  | 38915 |
| 38964 | static PyObject* pyopencv_colored_kinfu_Params_get_icpIterations(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38916 | static PyObject* pyopencv_colored_kinfu_Params_get_icpIterations(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38965 | { |  | 38917 | {
| 38966 | return pyopencv_from(p->v->icpIterations); |  | 38918 | return pyopencv_from(p->v->icpIterations);
| 38967 | } |  | 38919 | }
| 38968 |  |  | 38920 |
| 38969 | static int pyopencv_colored_kinfu_Params_set_icpIterations(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38921 | static int pyopencv_colored_kinfu_Params_set_icpIterations(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38970 | { |  | 38922 | {
| 38971 | if (!value) |  | 38923 | if (!value)
| 38972 | { |  | 38924 | {
| 38973 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpIterations attribute"); |  | 38925 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpIterations attribute");
| 38974 | return -1; |  | 38926 | return -1;
| 38975 | } |  | 38927 | }
| 38976 | return pyopencv_to_safe(value, p->v->icpIterations, ArgInfo("value", 0)) ? 0 : -1; |  | 38928 | return pyopencv_to_safe(value, p->v->icpIterations, ArgInfo("value", 0)) ? 0 : -1;
| 38977 | } |  | 38929 | }
| 38978 |  |  | 38930 |
| 38979 | static PyObject* pyopencv_colored_kinfu_Params_get_intr(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38931 | static PyObject* pyopencv_colored_kinfu_Params_get_intr(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38980 | { |  | 38932 | {
| 38981 | return pyopencv_from(p->v->intr); |  | 38933 | return pyopencv_from(p->v->intr);
| 38982 | } |  | 38934 | }
| 38983 |  |  | 38935 |
| 38984 | static int pyopencv_colored_kinfu_Params_set_intr(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38936 | static int pyopencv_colored_kinfu_Params_set_intr(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 38985 | { |  | 38937 | {
| 38986 | if (!value) |  | 38938 | if (!value)
| 38987 | { |  | 38939 | {
| 38988 | PyErr_SetString(PyExc_TypeError, "Cannot delete the intr attribute"); |  | 38940 | PyErr_SetString(PyExc_TypeError, "Cannot delete the intr attribute");
| 38989 | return -1; |  | 38941 | return -1;
| 38990 | } |  | 38942 | }
| 38991 | return pyopencv_to_safe(value, p->v->intr, ArgInfo("value", 0)) ? 0 : -1; |  | 38943 | return pyopencv_to_safe(value, p->v->intr, ArgInfo("value", 0)) ? 0 : -1;
| 38992 | } |  | 38944 | }
| 38993 |  |  | 38945 |
| 38994 | static PyObject* pyopencv_colored_kinfu_Params_get_lightPose(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38946 | static PyObject* pyopencv_colored_kinfu_Params_get_lightPose(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 38995 | { |  | 38947 | {
| 38996 | return pyopencv_from(p->v->lightPose); |  | 38948 | return pyopencv_from(p->v->lightPose);
| 38997 | } |  | 38949 | }
| 38998 |  |  | 38950 |
| 38999 | static int pyopencv_colored_kinfu_Params_set_lightPose(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38951 | static int pyopencv_colored_kinfu_Params_set_lightPose(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39000 | { |  | 38952 | {
| 39001 | if (!value) |  | 38953 | if (!value)
| 39002 | { |  | 38954 | {
| 39003 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lightPose attribute"); |  | 38955 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lightPose attribute");
| 39004 | return -1; |  | 38956 | return -1;
| 39005 | } |  | 38957 | }
| 39006 | return pyopencv_to_safe(value, p->v->lightPose, ArgInfo("value", 0)) ? 0 : -1; |  | 38958 | return pyopencv_to_safe(value, p->v->lightPose, ArgInfo("value", 0)) ? 0 : -1;
| 39007 | } |  | 38959 | }
| 39008 |  |  | 38960 |
| 39009 | static PyObject* pyopencv_colored_kinfu_Params_get_pyramidLevels(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38961 | static PyObject* pyopencv_colored_kinfu_Params_get_pyramidLevels(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39010 | { |  | 38962 | {
| 39011 | return pyopencv_from(p->v->pyramidLevels); |  | 38963 | return pyopencv_from(p->v->pyramidLevels);
| 39012 | } |  | 38964 | }
| 39013 |  |  | 38965 |
| 39014 | static int pyopencv_colored_kinfu_Params_set_pyramidLevels(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38966 | static int pyopencv_colored_kinfu_Params_set_pyramidLevels(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39015 | { |  | 38967 | {
| 39016 | if (!value) |  | 38968 | if (!value)
| 39017 | { |  | 38969 | {
| 39018 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pyramidLevels attribute"); |  | 38970 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pyramidLevels attribute");
| 39019 | return -1; |  | 38971 | return -1;
| 39020 | } |  | 38972 | }
| 39021 | return pyopencv_to_safe(value, p->v->pyramidLevels, ArgInfo("value", 0)) ? 0 : -1; |  | 38973 | return pyopencv_to_safe(value, p->v->pyramidLevels, ArgInfo("value", 0)) ? 0 : -1;
| 39022 | } |  | 38974 | }
| 39023 |  |  | 38975 |
| 39024 | static PyObject* pyopencv_colored_kinfu_Params_get_raycast_step_factor(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38976 | static PyObject* pyopencv_colored_kinfu_Params_get_raycast_step_factor(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39025 | { |  | 38977 | {
| 39026 | return pyopencv_from(p->v->raycast_step_factor); |  | 38978 | return pyopencv_from(p->v->raycast_step_factor);
| 39027 | } |  | 38979 | }
| 39028 |  |  | 38980 |
| 39029 | static int pyopencv_colored_kinfu_Params_set_raycast_step_factor(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38981 | static int pyopencv_colored_kinfu_Params_set_raycast_step_factor(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39030 | { |  | 38982 | {
| 39031 | if (!value) |  | 38983 | if (!value)
| 39032 | { |  | 38984 | {
| 39033 | PyErr_SetString(PyExc_TypeError, "Cannot delete the raycast_step_factor attribute"); |  | 38985 | PyErr_SetString(PyExc_TypeError, "Cannot delete the raycast_step_factor attribute");
| 39034 | return -1; |  | 38986 | return -1;
| 39035 | } |  | 38987 | }
| 39036 | return pyopencv_to_safe(value, p->v->raycast_step_factor, ArgInfo("value", 0)) ? 0 : -1; |  | 38988 | return pyopencv_to_safe(value, p->v->raycast_step_factor, ArgInfo("value", 0)) ? 0 : -1;
| 39037 | } |  | 38989 | }
| 39038 |  |  | 38990 |
| 39039 | static PyObject* pyopencv_colored_kinfu_Params_get_rgb_frameSize(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 38991 | static PyObject* pyopencv_colored_kinfu_Params_get_rgb_frameSize(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39040 | { |  | 38992 | {
| 39041 | return pyopencv_from(p->v->rgb_frameSize); |  | 38993 | return pyopencv_from(p->v->rgb_frameSize);
| 39042 | } |  | 38994 | }
| 39043 |  |  | 38995 |
| 39044 | static int pyopencv_colored_kinfu_Params_set_rgb_frameSize(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 38996 | static int pyopencv_colored_kinfu_Params_set_rgb_frameSize(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39045 | { |  | 38997 | {
| 39046 | if (!value) |  | 38998 | if (!value)
| 39047 | { |  | 38999 | {
| 39048 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_frameSize attribute"); |  | 39000 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_frameSize attribute");
| 39049 | return -1; |  | 39001 | return -1;
| 39050 | } |  | 39002 | }
| 39051 | return pyopencv_to_safe(value, p->v->rgb_frameSize, ArgInfo("value", 0)) ? 0 : -1; |  | 39003 | return pyopencv_to_safe(value, p->v->rgb_frameSize, ArgInfo("value", 0)) ? 0 : -1;
| 39052 | } |  | 39004 | }
| 39053 |  |  | 39005 |
| 39054 | static PyObject* pyopencv_colored_kinfu_Params_get_rgb_intr(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39006 | static PyObject* pyopencv_colored_kinfu_Params_get_rgb_intr(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39055 | { |  | 39007 | {
| 39056 | return pyopencv_from(p->v->rgb_intr); |  | 39008 | return pyopencv_from(p->v->rgb_intr);
| 39057 | } |  | 39009 | }
| 39058 |  |  | 39010 |
| 39059 | static int pyopencv_colored_kinfu_Params_set_rgb_intr(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39011 | static int pyopencv_colored_kinfu_Params_set_rgb_intr(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39060 | { |  | 39012 | {
| 39061 | if (!value) |  | 39013 | if (!value)
| 39062 | { |  | 39014 | {
| 39063 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_intr attribute"); |  | 39015 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_intr attribute");
| 39064 | return -1; |  | 39016 | return -1;
| 39065 | } |  | 39017 | }
| 39066 | return pyopencv_to_safe(value, p->v->rgb_intr, ArgInfo("value", 0)) ? 0 : -1; |  | 39018 | return pyopencv_to_safe(value, p->v->rgb_intr, ArgInfo("value", 0)) ? 0 : -1;
| 39067 | } |  | 39019 | }
| 39068 |  |  | 39020 |
| 39069 | static PyObject* pyopencv_colored_kinfu_Params_get_truncateThreshold(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39021 | static PyObject* pyopencv_colored_kinfu_Params_get_truncateThreshold(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39070 | { |  | 39022 | {
| 39071 | return pyopencv_from(p->v->truncateThreshold); |  | 39023 | return pyopencv_from(p->v->truncateThreshold);
| 39072 | } |  | 39024 | }
| 39073 |  |  | 39025 |
| 39074 | static int pyopencv_colored_kinfu_Params_set_truncateThreshold(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39026 | static int pyopencv_colored_kinfu_Params_set_truncateThreshold(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39075 | { |  | 39027 | {
| 39076 | if (!value) |  | 39028 | if (!value)
| 39077 | { |  | 39029 | {
| 39078 | PyErr_SetString(PyExc_TypeError, "Cannot delete the truncateThreshold attribute"); |  | 39030 | PyErr_SetString(PyExc_TypeError, "Cannot delete the truncateThreshold attribute");
| 39079 | return -1; |  | 39031 | return -1;
| 39080 | } |  | 39032 | }
| 39081 | return pyopencv_to_safe(value, p->v->truncateThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 39033 | return pyopencv_to_safe(value, p->v->truncateThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 39082 | } |  | 39034 | }
| 39083 |  |  | 39035 |
| 39084 | static PyObject* pyopencv_colored_kinfu_Params_get_tsdf_max_weight(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39036 | static PyObject* pyopencv_colored_kinfu_Params_get_tsdf_max_weight(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39085 | { |  | 39037 | {
| 39086 | return pyopencv_from(p->v->tsdf_max_weight); |  | 39038 | return pyopencv_from(p->v->tsdf_max_weight);
| 39087 | } |  | 39039 | }
| 39088 |  |  | 39040 |
| 39089 | static int pyopencv_colored_kinfu_Params_set_tsdf_max_weight(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39041 | static int pyopencv_colored_kinfu_Params_set_tsdf_max_weight(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39090 | { |  | 39042 | {
| 39091 | if (!value) |  | 39043 | if (!value)
| 39092 | { |  | 39044 | {
| 39093 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_max_weight attribute"); |  | 39045 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_max_weight attribute");
| 39094 | return -1; |  | 39046 | return -1;
| 39095 | } |  | 39047 | }
| 39096 | return pyopencv_to_safe(value, p->v->tsdf_max_weight, ArgInfo("value", 0)) ? 0 : -1; |  | 39048 | return pyopencv_to_safe(value, p->v->tsdf_max_weight, ArgInfo("value", 0)) ? 0 : -1;
| 39097 | } |  | 39049 | }
| 39098 |  |  | 39050 |
| 39099 | static PyObject* pyopencv_colored_kinfu_Params_get_tsdf_min_camera_movement(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39051 | static PyObject* pyopencv_colored_kinfu_Params_get_tsdf_min_camera_movement(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39100 | { |  | 39052 | {
| 39101 | return pyopencv_from(p->v->tsdf_min_camera_movement); |  | 39053 | return pyopencv_from(p->v->tsdf_min_camera_movement);
| 39102 | } |  | 39054 | }
| 39103 |  |  | 39055 |
| 39104 | static int pyopencv_colored_kinfu_Params_set_tsdf_min_camera_movement(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39056 | static int pyopencv_colored_kinfu_Params_set_tsdf_min_camera_movement(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39105 | { |  | 39057 | {
| 39106 | if (!value) |  | 39058 | if (!value)
| 39107 | { |  | 39059 | {
| 39108 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_min_camera_movement attribute"); |  | 39060 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_min_camera_movement attribute");
| 39109 | return -1; |  | 39061 | return -1;
| 39110 | } |  | 39062 | }
| 39111 | return pyopencv_to_safe(value, p->v->tsdf_min_camera_movement, ArgInfo("value", 0)) ? 0 : -1; |  | 39063 | return pyopencv_to_safe(value, p->v->tsdf_min_camera_movement, ArgInfo("value", 0)) ? 0 : -1;
| 39112 | } |  | 39064 | }
| 39113 |  |  | 39065 |
| 39114 | static PyObject* pyopencv_colored_kinfu_Params_get_tsdf_trunc_dist(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39066 | static PyObject* pyopencv_colored_kinfu_Params_get_tsdf_trunc_dist(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39115 | { |  | 39067 | {
| 39116 | return pyopencv_from(p->v->tsdf_trunc_dist); |  | 39068 | return pyopencv_from(p->v->tsdf_trunc_dist);
| 39117 | } |  | 39069 | }
| 39118 |  |  | 39070 |
| 39119 | static int pyopencv_colored_kinfu_Params_set_tsdf_trunc_dist(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39071 | static int pyopencv_colored_kinfu_Params_set_tsdf_trunc_dist(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39120 | { |  | 39072 | {
| 39121 | if (!value) |  | 39073 | if (!value)
| 39122 | { |  | 39074 | {
| 39123 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_trunc_dist attribute"); |  | 39075 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_trunc_dist attribute");
| 39124 | return -1; |  | 39076 | return -1;
| 39125 | } |  | 39077 | }
| 39126 | return pyopencv_to_safe(value, p->v->tsdf_trunc_dist, ArgInfo("value", 0)) ? 0 : -1; |  | 39078 | return pyopencv_to_safe(value, p->v->tsdf_trunc_dist, ArgInfo("value", 0)) ? 0 : -1;
| 39127 | } |  | 39079 | }
| 39128 |  |  | 39080 |
| 39129 | static PyObject* pyopencv_colored_kinfu_Params_get_volumeDims(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39081 | static PyObject* pyopencv_colored_kinfu_Params_get_volumeDims(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39130 | { |  | 39082 | {
| 39131 | return pyopencv_from(p->v->volumeDims); |  | 39083 | return pyopencv_from(p->v->volumeDims);
| 39132 | } |  | 39084 | }
| 39133 |  |  | 39085 |
| 39134 | static int pyopencv_colored_kinfu_Params_set_volumeDims(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39086 | static int pyopencv_colored_kinfu_Params_set_volumeDims(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39135 | { |  | 39087 | {
| 39136 | if (!value) |  | 39088 | if (!value)
| 39137 | { |  | 39089 | {
| 39138 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeDims attribute"); |  | 39090 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeDims attribute");
| 39139 | return -1; |  | 39091 | return -1;
| 39140 | } |  | 39092 | }
| 39141 | return pyopencv_to_safe(value, p->v->volumeDims, ArgInfo("value", 0)) ? 0 : -1; |  | 39093 | return pyopencv_to_safe(value, p->v->volumeDims, ArgInfo("value", 0)) ? 0 : -1;
| 39142 | } |  | 39094 | }
| 39143 |  |  | 39095 |
| 39144 | static PyObject* pyopencv_colored_kinfu_Params_get_volumeType(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39096 | static PyObject* pyopencv_colored_kinfu_Params_get_volumeType(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39145 | { |  | 39097 | {
| 39146 | return pyopencv_from(p->v->volumeType); |  | 39098 | return pyopencv_from(p->v->volumeType);
| 39147 | } |  | 39099 | }
| 39148 |  |  | 39100 |
| 39149 | static int pyopencv_colored_kinfu_Params_set_volumeType(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39101 | static int pyopencv_colored_kinfu_Params_set_volumeType(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39150 | { |  | 39102 | {
| 39151 | if (!value) |  | 39103 | if (!value)
| 39152 | { |  | 39104 | {
| 39153 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeType attribute"); |  | 39105 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeType attribute");
| 39154 | return -1; |  | 39106 | return -1;
| 39155 | } |  | 39107 | }
| 39156 | return pyopencv_to_safe(value, p->v->volumeType, ArgInfo("value", 0)) ? 0 : -1; |  | 39108 | return pyopencv_to_safe(value, p->v->volumeType, ArgInfo("value", 0)) ? 0 : -1;
| 39157 | } |  | 39109 | }
| 39158 |  |  | 39110 |
| 39159 | static PyObject* pyopencv_colored_kinfu_Params_get_voxelSize(pyopencv_colored_kinfu_Params_t* p, void *closure) |  | 39111 | static PyObject* pyopencv_colored_kinfu_Params_get_voxelSize(pyopencv_colored_kinfu_Params_t* p, void *closure)
| 39160 | { |  | 39112 | {
| 39161 | return pyopencv_from(p->v->voxelSize); |  | 39113 | return pyopencv_from(p->v->voxelSize);
| 39162 | } |  | 39114 | }
| 39163 |  |  | 39115 |
| 39164 | static int pyopencv_colored_kinfu_Params_set_voxelSize(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure) |  | 39116 | static int pyopencv_colored_kinfu_Params_set_voxelSize(pyopencv_colored_kinfu_Params_t* p, PyObject *value, void *closure)
| 39165 | { |  | 39117 | {
| 39166 | if (!value) |  | 39118 | if (!value)
| 39167 | { |  | 39119 | {
| 39168 | PyErr_SetString(PyExc_TypeError, "Cannot delete the voxelSize attribute"); |  | 39120 | PyErr_SetString(PyExc_TypeError, "Cannot delete the voxelSize attribute");
| 39169 | return -1; |  | 39121 | return -1;
| 39170 | } |  | 39122 | }
| 39171 | return pyopencv_to_safe(value, p->v->voxelSize, ArgInfo("value", 0)) ? 0 : -1; |  | 39123 | return pyopencv_to_safe(value, p->v->voxelSize, ArgInfo("value", 0)) ? 0 : -1;
| 39172 | } |  | 39124 | }
| 39173 |  |  | 39125 |
| 39174 |  |  | 39126 |
| 39175 | // Methods (colored_kinfu_Params) |  | 39127 | // Methods (colored_kinfu_Params)
| 39176 |  |  | 39128 |
| 39177 | static int pyopencv_cv_colored_kinfu_colored_kinfu_Params_Params(pyopencv_colored_kinfu_Params_t* self, PyObject* py_args, PyObject* kw) |  | 39129 | static int pyopencv_cv_colored_kinfu_colored_kinfu_Params_Params(pyopencv_colored_kinfu_Params_t* self, PyObject* py_args, PyObject* kw)
| 39178 | { |  | 39130 | {
| 39179 | using namespace cv::colored_kinfu; |  | 39131 | using namespace cv::colored_kinfu;
| 39180 |  |  | 39132 |
| 39181 | pyPrepareArgumentConversionErrorsStorage(3); |  | 39133 | pyPrepareArgumentConversionErrorsStorage(3);
| 39182 |  |  | 39134 |
| 39183 | { |  | 39135 | {
| 39184 |  |  | 39136 |
| 39185 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39137 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39186 | { |  | 39138 | {
| 39187 | new (&(self->v)) Ptr<cv::colored_kinfu::Params>(); // init Ptr with placement new |  | 39139 | new (&(self->v)) Ptr<cv::colored_kinfu::Params>(); // init Ptr with placement new
| 39188 | if(self) ERRWRAP2(self->v.reset(new cv::colored_kinfu::Params())); |  | 39140 | if(self) ERRWRAP2(self->v.reset(new cv::colored_kinfu::Params()));
| 39189 | return 0; |  | 39141 | return 0;
| 39190 | } |  | 39142 | }
| 39191 |  |  | 39143 |
| 39192 |  |  | 39144 |
| 39193 | pyPopulateArgumentConversionErrors(); |  | 39145 | pyPopulateArgumentConversionErrors();
| 39194 | } |  | 39146 | }
| 39195 |  |  | 39147 |
| 39196 |  |  | 39148 |
| 39197 | { |  | 39149 | {
| 39198 | PyObject* pyobj_volumeInitialPoseRot = NULL; |  | 39150 | PyObject* pyobj_volumeInitialPoseRot = NULL;
| 39199 | Matx33f volumeInitialPoseRot; |  | 39151 | Matx33f volumeInitialPoseRot;
| 39200 | PyObject* pyobj_volumeInitialPoseTransl = NULL; |  | 39152 | PyObject* pyobj_volumeInitialPoseTransl = NULL;
| 39201 | Vec3f volumeInitialPoseTransl; |  | 39153 | Vec3f volumeInitialPoseTransl;
| 39202 |  |  | 39154 |
| 39203 | const char* keywords[] = { "volumeInitialPoseRot", "volumeInitialPoseTransl", NULL }; |  | 39155 | const char* keywords[] = { "volumeInitialPoseRot", "volumeInitialPoseTransl", NULL };
| 39204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Params", (char**)keywords, &pyobj_volumeInitialPoseRot, &pyobj_volumeInitialPoseTransl) && |  | 39156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Params", (char**)keywords, &pyobj_volumeInitialPoseRot, &pyobj_volumeInitialPoseTransl) &&
| 39205 | pyopencv_to_safe(pyobj_volumeInitialPoseRot, volumeInitialPoseRot, ArgInfo("volumeInitialPoseRot", 0)) && |  | 39157 | pyopencv_to_safe(pyobj_volumeInitialPoseRot, volumeInitialPoseRot, ArgInfo("volumeInitialPoseRot", 0)) &&
| 39206 | pyopencv_to_safe(pyobj_volumeInitialPoseTransl, volumeInitialPoseTransl, ArgInfo("volumeInitialPoseTransl", 0)) ) |  | 39158 | pyopencv_to_safe(pyobj_volumeInitialPoseTransl, volumeInitialPoseTransl, ArgInfo("volumeInitialPoseTransl", 0)) )
| 39207 | { |  | 39159 | {
| 39208 | new (&(self->v)) Ptr<cv::colored_kinfu::Params>(); // init Ptr with placement new |  | 39160 | new (&(self->v)) Ptr<cv::colored_kinfu::Params>(); // init Ptr with placement new
| 39209 | if(self) ERRWRAP2(self->v.reset(new cv::colored_kinfu::Params(volumeInitialPoseRot, volumeInitialPoseTransl))); |  | 39161 | if(self) ERRWRAP2(self->v.reset(new cv::colored_kinfu::Params(volumeInitialPoseRot, volumeInitialPoseTransl)));
| 39210 | return 0; |  | 39162 | return 0;
| 39211 | } |  | 39163 | }
| 39212 |  |  | 39164 |
| 39213 |  |  | 39165 |
| 39214 | pyPopulateArgumentConversionErrors(); |  | 39166 | pyPopulateArgumentConversionErrors();
| 39215 | } |  | 39167 | }
| 39216 |  |  | 39168 |
| 39217 |  |  | 39169 |
| 39218 | { |  | 39170 | {
| 39219 | PyObject* pyobj_volumeInitialPose = NULL; |  | 39171 | PyObject* pyobj_volumeInitialPose = NULL;
| 39220 | Matx44f volumeInitialPose; |  | 39172 | Matx44f volumeInitialPose;
| 39221 |  |  | 39173 |
| 39222 | const char* keywords[] = { "volumeInitialPose", NULL }; |  | 39174 | const char* keywords[] = { "volumeInitialPose", NULL };
| 39223 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Params", (char**)keywords, &pyobj_volumeInitialPose) && |  | 39175 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Params", (char**)keywords, &pyobj_volumeInitialPose) &&
| 39224 | pyopencv_to_safe(pyobj_volumeInitialPose, volumeInitialPose, ArgInfo("volumeInitialPose", 0)) ) |  | 39176 | pyopencv_to_safe(pyobj_volumeInitialPose, volumeInitialPose, ArgInfo("volumeInitialPose", 0)) )
| 39225 | { |  | 39177 | {
| 39226 | new (&(self->v)) Ptr<cv::colored_kinfu::Params>(); // init Ptr with placement new |  | 39178 | new (&(self->v)) Ptr<cv::colored_kinfu::Params>(); // init Ptr with placement new
| 39227 | if(self) ERRWRAP2(self->v.reset(new cv::colored_kinfu::Params(volumeInitialPose))); |  | 39179 | if(self) ERRWRAP2(self->v.reset(new cv::colored_kinfu::Params(volumeInitialPose)));
| 39228 | return 0; |  | 39180 | return 0;
| 39229 | } |  | 39181 | }
| 39230 |  |  | 39182 |
| 39231 |  |  | 39183 |
| 39232 | pyPopulateArgumentConversionErrors(); |  | 39184 | pyPopulateArgumentConversionErrors();
| 39233 | } |  | 39185 | }
| 39234 | pyRaiseCVOverloadException("Params"); |  | 39186 | pyRaiseCVOverloadException("Params");
| 39235 |  |  | 39187 |
| 39236 | return -1; |  | 39188 | return -1;
| 39237 | } |  | 39189 | }
| 39238 |  |  | 39190 |
| 39239 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39191 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 39240 | { |  | 39192 | {
| 39241 | using namespace cv::colored_kinfu; |  | 39193 | using namespace cv::colored_kinfu;
| 39242 |  |  | 39194 |
| 39243 | Ptr<Params> retval; |  | 39195 | Ptr<Params> retval;
| 39244 |  |  | 39196 |
| 39245 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39197 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39246 | { |  | 39198 | {
| 39247 | ERRWRAP2(retval = cv::colored_kinfu::Params::coarseParams()); |  | 39199 | ERRWRAP2(retval = cv::colored_kinfu::Params::coarseParams());
| 39248 | return pyopencv_from(retval); |  | 39200 | return pyopencv_from(retval);
| 39249 | } |  | 39201 | }
| 39250 |  |  | 39202 |
| 39251 | return NULL; |  | 39203 | return NULL;
| 39252 | } |  | 39204 | }
| 39253 |  |  | 39205 |
| 39254 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_coloredTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39206 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_coloredTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 39255 | { |  | 39207 | {
| 39256 | using namespace cv::colored_kinfu; |  | 39208 | using namespace cv::colored_kinfu;
| 39257 |  |  | 39209 |
| 39258 | PyObject* pyobj_isCoarse = NULL; |  | 39210 | PyObject* pyobj_isCoarse = NULL;
| 39259 | bool isCoarse=0; |  | 39211 | bool isCoarse=0;
| 39260 | Ptr<Params> retval; |  | 39212 | Ptr<Params> retval;
| 39261 |  |  | 39213 |
| 39262 | const char* keywords[] = { "isCoarse", NULL }; |  | 39214 | const char* keywords[] = { "isCoarse", NULL };
| 39263 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_Params.coloredTSDFParams", (char**)keywords, &pyobj_isCoarse) && |  | 39215 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_Params.coloredTSDFParams", (char**)keywords, &pyobj_isCoarse) &&
| 39264 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) ) |  | 39216 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) )
| 39265 | { |  | 39217 | {
| 39266 | ERRWRAP2(retval = cv::colored_kinfu::Params::coloredTSDFParams(isCoarse)); |  | 39218 | ERRWRAP2(retval = cv::colored_kinfu::Params::coloredTSDFParams(isCoarse));
| 39267 | return pyopencv_from(retval); |  | 39219 | return pyopencv_from(retval);
| 39268 | } |  | 39220 | }
| 39269 |  |  | 39221 |
| 39270 | return NULL; |  | 39222 | return NULL;
| 39271 | } |  | 39223 | }
| 39272 |  |  | 39224 |
| 39273 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39225 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 39274 | { |  | 39226 | {
| 39275 | using namespace cv::colored_kinfu; |  | 39227 | using namespace cv::colored_kinfu;
| 39276 |  |  | 39228 |
| 39277 | Ptr<Params> retval; |  | 39229 | Ptr<Params> retval;
| 39278 |  |  | 39230 |
| 39279 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39231 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39280 | { |  | 39232 | {
| 39281 | ERRWRAP2(retval = cv::colored_kinfu::Params::defaultParams()); |  | 39233 | ERRWRAP2(retval = cv::colored_kinfu::Params::defaultParams());
| 39282 | return pyopencv_from(retval); |  | 39234 | return pyopencv_from(retval);
| 39283 | } |  | 39235 | }
| 39284 |  |  | 39236 |
| 39285 | return NULL; |  | 39237 | return NULL;
| 39286 | } |  | 39238 | }
| 39287 |  |  | 39239 |
| 39288 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_hashTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39240 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_hashTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 39289 | { |  | 39241 | {
| 39290 | using namespace cv::colored_kinfu; |  | 39242 | using namespace cv::colored_kinfu;
| 39291 |  |  | 39243 |
| 39292 | PyObject* pyobj_isCoarse = NULL; |  | 39244 | PyObject* pyobj_isCoarse = NULL;
| 39293 | bool isCoarse=0; |  | 39245 | bool isCoarse=0;
| 39294 | Ptr<Params> retval; |  | 39246 | Ptr<Params> retval;
| 39295 |  |  | 39247 |
| 39296 | const char* keywords[] = { "isCoarse", NULL }; |  | 39248 | const char* keywords[] = { "isCoarse", NULL };
| 39297 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_Params.hashTSDFParams", (char**)keywords, &pyobj_isCoarse) && |  | 39249 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_Params.hashTSDFParams", (char**)keywords, &pyobj_isCoarse) &&
| 39298 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) ) |  | 39250 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) )
| 39299 | { |  | 39251 | {
| 39300 | ERRWRAP2(retval = cv::colored_kinfu::Params::hashTSDFParams(isCoarse)); |  | 39252 | ERRWRAP2(retval = cv::colored_kinfu::Params::hashTSDFParams(isCoarse));
| 39301 | return pyopencv_from(retval); |  | 39253 | return pyopencv_from(retval);
| 39302 | } |  | 39254 | }
| 39303 |  |  | 39255 |
| 39304 | return NULL; |  | 39256 | return NULL;
| 39305 | } |  | 39257 | }
| 39306 |  |  | 39258 |
| 39307 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_setInitialVolumePose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39259 | static PyObject* pyopencv_cv_colored_kinfu_colored_kinfu_Params_setInitialVolumePose(PyObject* self, PyObject* py_args, PyObject* kw)
| 39308 | { |  | 39260 | {
| 39309 | using namespace cv::colored_kinfu; |  | 39261 | using namespace cv::colored_kinfu;
| 39310 |  |  | 39262 |
| 39311 |  |  | 39263 |
| 39312 | Ptr<cv::colored_kinfu::Params> * self1 = 0; |  | 39264 | Ptr<cv::colored_kinfu::Params> * self1 = 0;
| 39313 | if (!pyopencv_colored_kinfu_Params_getp(self, self1)) |  | 39265 | if (!pyopencv_colored_kinfu_Params_getp(self, self1))
| 39314 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_Params' or its derivative)"); |  | 39266 | return failmsgp("Incorrect type of self (must be 'colored_kinfu_Params' or its derivative)");
| 39315 | Ptr<cv::colored_kinfu::Params> _self_ = *(self1); |  | 39267 | Ptr<cv::colored_kinfu::Params> _self_ = *(self1);
| 39316 | pyPrepareArgumentConversionErrorsStorage(2); |  | 39268 | pyPrepareArgumentConversionErrorsStorage(2);
| 39317 |  |  | 39269 |
| 39318 | { |  | 39270 | {
| 39319 | PyObject* pyobj_R = NULL; |  | 39271 | PyObject* pyobj_R = NULL;
| 39320 | Matx33f R; |  | 39272 | Matx33f R;
| 39321 | PyObject* pyobj_t = NULL; |  | 39273 | PyObject* pyobj_t = NULL;
| 39322 | Vec3f t; |  | 39274 | Vec3f t;
| 39323 |  |  | 39275 |
| 39324 | const char* keywords[] = { "R", "t", NULL }; |  | 39276 | const char* keywords[] = { "R", "t", NULL };
| 39325 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:colored_kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_R, &pyobj_t) && |  | 39277 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:colored_kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_R, &pyobj_t) &&
| 39326 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 39278 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 39327 | pyopencv_to_safe(pyobj_t, t, ArgInfo("t", 0)) ) |  | 39279 | pyopencv_to_safe(pyobj_t, t, ArgInfo("t", 0)) )
| 39328 | { |  | 39280 | {
| 39329 | ERRWRAP2(_self_->setInitialVolumePose(R, t)); |  | 39281 | ERRWRAP2(_self_->setInitialVolumePose(R, t));
| 39330 | Py_RETURN_NONE; |  | 39282 | Py_RETURN_NONE;
| 39331 | } |  | 39283 | }
| 39332 |  |  | 39284 |
| 39333 |  |  | 39285 |
| 39334 | pyPopulateArgumentConversionErrors(); |  | 39286 | pyPopulateArgumentConversionErrors();
| 39335 | } |  | 39287 | }
| 39336 |  |  | 39288 |
| 39337 |  |  | 39289 |
| 39338 | { |  | 39290 | {
| 39339 | PyObject* pyobj_homogen_tf = NULL; |  | 39291 | PyObject* pyobj_homogen_tf = NULL;
| 39340 | Matx44f homogen_tf; |  | 39292 | Matx44f homogen_tf;
| 39341 |  |  | 39293 |
| 39342 | const char* keywords[] = { "homogen_tf", NULL }; |  | 39294 | const char* keywords[] = { "homogen_tf", NULL };
| 39343 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_homogen_tf) && |  | 39295 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:colored_kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_homogen_tf) &&
| 39344 | pyopencv_to_safe(pyobj_homogen_tf, homogen_tf, ArgInfo("homogen_tf", 0)) ) |  | 39296 | pyopencv_to_safe(pyobj_homogen_tf, homogen_tf, ArgInfo("homogen_tf", 0)) )
| 39345 | { |  | 39297 | {
| 39346 | ERRWRAP2(_self_->setInitialVolumePose(homogen_tf)); |  | 39298 | ERRWRAP2(_self_->setInitialVolumePose(homogen_tf));
| 39347 | Py_RETURN_NONE; |  | 39299 | Py_RETURN_NONE;
| 39348 | } |  | 39300 | }
| 39349 |  |  | 39301 |
| 39350 |  |  | 39302 |
| 39351 | pyPopulateArgumentConversionErrors(); |  | 39303 | pyPopulateArgumentConversionErrors();
| 39352 | } |  | 39304 | }
| 39353 | pyRaiseCVOverloadException("setInitialVolumePose"); |  | 39305 | pyRaiseCVOverloadException("setInitialVolumePose");
| 39354 |  |  | 39306 |
| 39355 | return NULL; |  | 39307 | return NULL;
| 39356 | } |  | 39308 | }
| 39357 |  |  | 39309 |
| 39358 |  |  | 39310 |
| 39359 |  |  | 39311 |
| 39360 | // Tables (colored_kinfu_Params) |  | 39312 | // Tables (colored_kinfu_Params)
| 39361 |  |  | 39313 |
| 39362 | static PyGetSetDef pyopencv_colored_kinfu_Params_getseters[] = |  | 39314 | static PyGetSetDef pyopencv_colored_kinfu_Params_getseters[] =
| 39363 | { |  | 39315 | {
| 39364 | {(char*)"bilateral_kernel_size", (getter)pyopencv_colored_kinfu_Params_get_bilateral_kernel_size, (setter)pyopencv_colored_kinfu_Params_set_bilateral_kernel_size, (char*)"bilateral_kernel_size", NULL}, |  | 39316 | {(char*)"bilateral_kernel_size", (getter)pyopencv_colored_kinfu_Params_get_bilateral_kernel_size, (setter)pyopencv_colored_kinfu_Params_set_bilateral_kernel_size, (char*)"bilateral_kernel_size", NULL},
| 39365 | {(char*)"bilateral_sigma_depth", (getter)pyopencv_colored_kinfu_Params_get_bilateral_sigma_depth, (setter)pyopencv_colored_kinfu_Params_set_bilateral_sigma_depth, (char*)"bilateral_sigma_depth", NULL}, |  | 39317 | {(char*)"bilateral_sigma_depth", (getter)pyopencv_colored_kinfu_Params_get_bilateral_sigma_depth, (setter)pyopencv_colored_kinfu_Params_set_bilateral_sigma_depth, (char*)"bilateral_sigma_depth", NULL},
| 39366 | {(char*)"bilateral_sigma_spatial", (getter)pyopencv_colored_kinfu_Params_get_bilateral_sigma_spatial, (setter)pyopencv_colored_kinfu_Params_set_bilateral_sigma_spatial, (char*)"bilateral_sigma_spatial", NULL}, |  | 39318 | {(char*)"bilateral_sigma_spatial", (getter)pyopencv_colored_kinfu_Params_get_bilateral_sigma_spatial, (setter)pyopencv_colored_kinfu_Params_set_bilateral_sigma_spatial, (char*)"bilateral_sigma_spatial", NULL},
| 39367 | {(char*)"depthFactor", (getter)pyopencv_colored_kinfu_Params_get_depthFactor, (setter)pyopencv_colored_kinfu_Params_set_depthFactor, (char*)"depthFactor", NULL}, |  | 39319 | {(char*)"depthFactor", (getter)pyopencv_colored_kinfu_Params_get_depthFactor, (setter)pyopencv_colored_kinfu_Params_set_depthFactor, (char*)"depthFactor", NULL},
| 39368 | {(char*)"frameSize", (getter)pyopencv_colored_kinfu_Params_get_frameSize, (setter)pyopencv_colored_kinfu_Params_set_frameSize, (char*)"frameSize", NULL}, |  | 39320 | {(char*)"frameSize", (getter)pyopencv_colored_kinfu_Params_get_frameSize, (setter)pyopencv_colored_kinfu_Params_set_frameSize, (char*)"frameSize", NULL},
| 39369 | {(char*)"icpAngleThresh", (getter)pyopencv_colored_kinfu_Params_get_icpAngleThresh, (setter)pyopencv_colored_kinfu_Params_set_icpAngleThresh, (char*)"icpAngleThresh", NULL}, |  | 39321 | {(char*)"icpAngleThresh", (getter)pyopencv_colored_kinfu_Params_get_icpAngleThresh, (setter)pyopencv_colored_kinfu_Params_set_icpAngleThresh, (char*)"icpAngleThresh", NULL},
| 39370 | {(char*)"icpDistThresh", (getter)pyopencv_colored_kinfu_Params_get_icpDistThresh, (setter)pyopencv_colored_kinfu_Params_set_icpDistThresh, (char*)"icpDistThresh", NULL}, |  | 39322 | {(char*)"icpDistThresh", (getter)pyopencv_colored_kinfu_Params_get_icpDistThresh, (setter)pyopencv_colored_kinfu_Params_set_icpDistThresh, (char*)"icpDistThresh", NULL},
| 39371 | {(char*)"icpIterations", (getter)pyopencv_colored_kinfu_Params_get_icpIterations, (setter)pyopencv_colored_kinfu_Params_set_icpIterations, (char*)"icpIterations", NULL}, |  | 39323 | {(char*)"icpIterations", (getter)pyopencv_colored_kinfu_Params_get_icpIterations, (setter)pyopencv_colored_kinfu_Params_set_icpIterations, (char*)"icpIterations", NULL},
| 39372 | {(char*)"intr", (getter)pyopencv_colored_kinfu_Params_get_intr, (setter)pyopencv_colored_kinfu_Params_set_intr, (char*)"intr", NULL}, |  | 39324 | {(char*)"intr", (getter)pyopencv_colored_kinfu_Params_get_intr, (setter)pyopencv_colored_kinfu_Params_set_intr, (char*)"intr", NULL},
| 39373 | {(char*)"lightPose", (getter)pyopencv_colored_kinfu_Params_get_lightPose, (setter)pyopencv_colored_kinfu_Params_set_lightPose, (char*)"lightPose", NULL}, |  | 39325 | {(char*)"lightPose", (getter)pyopencv_colored_kinfu_Params_get_lightPose, (setter)pyopencv_colored_kinfu_Params_set_lightPose, (char*)"lightPose", NULL},
| 39374 | {(char*)"pyramidLevels", (getter)pyopencv_colored_kinfu_Params_get_pyramidLevels, (setter)pyopencv_colored_kinfu_Params_set_pyramidLevels, (char*)"pyramidLevels", NULL}, |  | 39326 | {(char*)"pyramidLevels", (getter)pyopencv_colored_kinfu_Params_get_pyramidLevels, (setter)pyopencv_colored_kinfu_Params_set_pyramidLevels, (char*)"pyramidLevels", NULL},
| 39375 | {(char*)"raycast_step_factor", (getter)pyopencv_colored_kinfu_Params_get_raycast_step_factor, (setter)pyopencv_colored_kinfu_Params_set_raycast_step_factor, (char*)"raycast_step_factor", NULL}, |  | 39327 | {(char*)"raycast_step_factor", (getter)pyopencv_colored_kinfu_Params_get_raycast_step_factor, (setter)pyopencv_colored_kinfu_Params_set_raycast_step_factor, (char*)"raycast_step_factor", NULL},
| 39376 | {(char*)"rgb_frameSize", (getter)pyopencv_colored_kinfu_Params_get_rgb_frameSize, (setter)pyopencv_colored_kinfu_Params_set_rgb_frameSize, (char*)"rgb_frameSize", NULL}, |  | 39328 | {(char*)"rgb_frameSize", (getter)pyopencv_colored_kinfu_Params_get_rgb_frameSize, (setter)pyopencv_colored_kinfu_Params_set_rgb_frameSize, (char*)"rgb_frameSize", NULL},
| 39377 | {(char*)"rgb_intr", (getter)pyopencv_colored_kinfu_Params_get_rgb_intr, (setter)pyopencv_colored_kinfu_Params_set_rgb_intr, (char*)"rgb_intr", NULL}, |  | 39329 | {(char*)"rgb_intr", (getter)pyopencv_colored_kinfu_Params_get_rgb_intr, (setter)pyopencv_colored_kinfu_Params_set_rgb_intr, (char*)"rgb_intr", NULL},
| 39378 | {(char*)"truncateThreshold", (getter)pyopencv_colored_kinfu_Params_get_truncateThreshold, (setter)pyopencv_colored_kinfu_Params_set_truncateThreshold, (char*)"truncateThreshold", NULL}, |  | 39330 | {(char*)"truncateThreshold", (getter)pyopencv_colored_kinfu_Params_get_truncateThreshold, (setter)pyopencv_colored_kinfu_Params_set_truncateThreshold, (char*)"truncateThreshold", NULL},
| 39379 | {(char*)"tsdf_max_weight", (getter)pyopencv_colored_kinfu_Params_get_tsdf_max_weight, (setter)pyopencv_colored_kinfu_Params_set_tsdf_max_weight, (char*)"tsdf_max_weight", NULL}, |  | 39331 | {(char*)"tsdf_max_weight", (getter)pyopencv_colored_kinfu_Params_get_tsdf_max_weight, (setter)pyopencv_colored_kinfu_Params_set_tsdf_max_weight, (char*)"tsdf_max_weight", NULL},
| 39380 | {(char*)"tsdf_min_camera_movement", (getter)pyopencv_colored_kinfu_Params_get_tsdf_min_camera_movement, (setter)pyopencv_colored_kinfu_Params_set_tsdf_min_camera_movement, (char*)"tsdf_min_camera_movement", NULL}, |  | 39332 | {(char*)"tsdf_min_camera_movement", (getter)pyopencv_colored_kinfu_Params_get_tsdf_min_camera_movement, (setter)pyopencv_colored_kinfu_Params_set_tsdf_min_camera_movement, (char*)"tsdf_min_camera_movement", NULL},
| 39381 | {(char*)"tsdf_trunc_dist", (getter)pyopencv_colored_kinfu_Params_get_tsdf_trunc_dist, (setter)pyopencv_colored_kinfu_Params_set_tsdf_trunc_dist, (char*)"tsdf_trunc_dist", NULL}, |  | 39333 | {(char*)"tsdf_trunc_dist", (getter)pyopencv_colored_kinfu_Params_get_tsdf_trunc_dist, (setter)pyopencv_colored_kinfu_Params_set_tsdf_trunc_dist, (char*)"tsdf_trunc_dist", NULL},
| 39382 | {(char*)"volumeDims", (getter)pyopencv_colored_kinfu_Params_get_volumeDims, (setter)pyopencv_colored_kinfu_Params_set_volumeDims, (char*)"volumeDims", NULL}, |  | 39334 | {(char*)"volumeDims", (getter)pyopencv_colored_kinfu_Params_get_volumeDims, (setter)pyopencv_colored_kinfu_Params_set_volumeDims, (char*)"volumeDims", NULL},
| 39383 | {(char*)"volumeType", (getter)pyopencv_colored_kinfu_Params_get_volumeType, (setter)pyopencv_colored_kinfu_Params_set_volumeType, (char*)"volumeType", NULL}, |  | 39335 | {(char*)"volumeType", (getter)pyopencv_colored_kinfu_Params_get_volumeType, (setter)pyopencv_colored_kinfu_Params_set_volumeType, (char*)"volumeType", NULL},
| 39384 | {(char*)"voxelSize", (getter)pyopencv_colored_kinfu_Params_get_voxelSize, (setter)pyopencv_colored_kinfu_Params_set_voxelSize, (char*)"voxelSize", NULL}, |  | 39336 | {(char*)"voxelSize", (getter)pyopencv_colored_kinfu_Params_get_voxelSize, (setter)pyopencv_colored_kinfu_Params_set_voxelSize, (char*)"voxelSize", NULL},
| 39385 | {NULL} /* Sentinel */ |  | 39337 | {NULL} /* Sentinel */
| 39386 | }; |  | 39338 | };
| 39387 |  |  | 39339 |
| 39388 | static PyMethodDef pyopencv_colored_kinfu_Params_methods[] = |  | 39340 | static PyMethodDef pyopencv_colored_kinfu_Params_methods[] =
| 39389 | { |  | 39341 | {
| 39390 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_coarseParams_static, METH_STATIC), "coarseParams() -> retval\n. @brief Coarse parameters\n. A set of parameters which provides better speed, can fail to match frames\n. in case of rapid sensor motion."}, |  | 39342 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_coarseParams_static, METH_STATIC), "coarseParams() -> retval\n. @brief Coarse parameters\n. A set of parameters which provides better speed, can fail to match frames\n. in case of rapid sensor motion."},
| 39391 | {"coloredTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_coloredTSDFParams_static, METH_STATIC), "coloredTSDFParams(isCoarse) -> retval\n. @brief ColoredTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"}, |  | 39343 | {"coloredTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_coloredTSDFParams_static, METH_STATIC), "coloredTSDFParams(isCoarse) -> retval\n. @brief ColoredTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"},
| 39392 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_defaultParams_static, METH_STATIC), "defaultParams() -> retval\n. * @brief Default parameters\n. * A set of parameters which provides better model quality, can be very slow."}, |  | 39344 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_defaultParams_static, METH_STATIC), "defaultParams() -> retval\n. * @brief Default parameters\n. * A set of parameters which provides better model quality, can be very slow."},
| 39393 | {"hashTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_hashTSDFParams_static, METH_STATIC), "hashTSDFParams(isCoarse) -> retval\n. @brief HashTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"}, |  | 39345 | {"hashTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_hashTSDFParams_static, METH_STATIC), "hashTSDFParams(isCoarse) -> retval\n. @brief HashTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"},
| 39394 | {"setInitialVolumePose", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_setInitialVolumePose, 0), "setInitialVolumePose(R, t) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param R rotation matrix\n. * @param t translation vector\n\n\n\nsetInitialVolumePose(homogen_tf) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param homogen_tf 4 by 4 Homogeneous Transform matrix to set the intial pose of TSDF volume"}, |  | 39346 | {"setInitialVolumePose", CV_PY_FN_WITH_KW_(pyopencv_cv_colored_kinfu_colored_kinfu_Params_setInitialVolumePose, 0), "setInitialVolumePose(R, t) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param R rotation matrix\n. * @param t translation vector\n\n\n\nsetInitialVolumePose(homogen_tf) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param homogen_tf 4 by 4 Homogeneous Transform matrix to set the intial pose of TSDF volume"},
| 39395 |  |  | 39347 |
| 39396 | {NULL, NULL} |  | 39348 | {NULL, NULL}
| 39397 | }; |  | 39349 | };
| 39398 |  |  | 39350 |
| 39399 | // Converter (colored_kinfu_Params) |  | 39351 | // Converter (colored_kinfu_Params)
| 39400 |  |  | 39352 |
| 39401 | template<> |  | 39353 | template<>
| 39402 | struct PyOpenCV_Converter< Ptr<cv::colored_kinfu::Params> > |  | 39354 | struct PyOpenCV_Converter< Ptr<cv::colored_kinfu::Params> >
| 39403 | { |  | 39355 | {
| 39404 | static PyObject* from(const Ptr<cv::colored_kinfu::Params>& r) |  | 39356 | static PyObject* from(const Ptr<cv::colored_kinfu::Params>& r)
| 39405 | { |  | 39357 | {
| 39406 | return pyopencv_colored_kinfu_Params_Instance(r); |  | 39358 | return pyopencv_colored_kinfu_Params_Instance(r);
| 39407 | } |  | 39359 | }
| 39408 | static bool to(PyObject* src, Ptr<cv::colored_kinfu::Params>& dst, const ArgInfo& info) |  | 39360 | static bool to(PyObject* src, Ptr<cv::colored_kinfu::Params>& dst, const ArgInfo& info)
| 39409 | { |  | 39361 | {
| 39410 | if(!src || src == Py_None) |  | 39362 | if(!src || src == Py_None)
| 39411 | return true; |  | 39363 | return true;
| 39412 | Ptr<cv::colored_kinfu::Params> * dst_; |  | 39364 | Ptr<cv::colored_kinfu::Params> * dst_;
| 39413 | if (pyopencv_colored_kinfu_Params_getp(src, dst_)) |  | 39365 | if (pyopencv_colored_kinfu_Params_getp(src, dst_))
| 39414 | { |  | 39366 | {
| 39415 | dst = *dst_; |  | 39367 | dst = *dst_;
| 39416 | return true; |  | 39368 | return true;
| 39417 | } |  | 39369 | }
| 39418 |  |  | 39370 |
| 39419 | failmsg("Expected Ptr<cv::colored_kinfu::Params> for argument '%s'", info.name); |  | 39371 | failmsg("Expected Ptr<cv::colored_kinfu::Params> for argument '%s'", info.name);
| 39420 | return false; |  | 39372 | return false;
| 39421 | } |  | 39373 | }
| 39422 | }; |  | 39374 | };
| 39423 |  |  | 39375 |
| 39424 | //================================================================================ |  | 39376 | //================================================================================
| 39425 | // cuda_BufferPool (Generic) |  | 39377 | // cuda_BufferPool (Generic)
| 39426 | //================================================================================ |  | 39378 | //================================================================================
| 39427 |  |  | 39379 |
| 39428 | // GetSet (cuda_BufferPool) |  | 39380 | // GetSet (cuda_BufferPool)
| 39429 |  |  | 39381 |
| 39430 |  |  | 39382 |
| 39431 |  |  | 39383 |
| 39432 | // Methods (cuda_BufferPool) |  | 39384 | // Methods (cuda_BufferPool)
| 39433 |  |  | 39385 |
| 39434 | static int pyopencv_cv_cuda_cuda_BufferPool_BufferPool(pyopencv_cuda_BufferPool_t* self, PyObject* py_args, PyObject* kw) |  | 39386 | static int pyopencv_cv_cuda_cuda_BufferPool_BufferPool(pyopencv_cuda_BufferPool_t* self, PyObject* py_args, PyObject* kw)
| 39435 | { |  | 39387 | {
| 39436 | using namespace cv::cuda; |  | 39388 | using namespace cv::cuda;
| 39437 |  |  | 39389 |
| 39438 | PyObject* pyobj_stream = NULL; |  | 39390 | PyObject* pyobj_stream = NULL;
| 39439 | Stream stream=Stream::Null(); |  | 39391 | Stream stream=Stream::Null();
| 39440 |  |  | 39392 |
| 39441 | const char* keywords[] = { "stream", NULL }; |  | 39393 | const char* keywords[] = { "stream", NULL };
| 39442 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BufferPool", (char**)keywords, &pyobj_stream) && |  | 39394 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:BufferPool", (char**)keywords, &pyobj_stream) &&
| 39443 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 39395 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 39444 | { |  | 39396 | {
| 39445 | new (&(self->v)) Ptr<cv::cuda::BufferPool>(); // init Ptr with placement new |  | 39397 | new (&(self->v)) Ptr<cv::cuda::BufferPool>(); // init Ptr with placement new
| 39446 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::BufferPool(stream))); |  | 39398 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::BufferPool(stream)));
| 39447 | return 0; |  | 39399 | return 0;
| 39448 | } |  | 39400 | }
| 39449 |  |  | 39401 |
| 39450 | return -1; |  | 39402 | return -1;
| 39451 | } |  | 39403 | }
| 39452 |  |  | 39404 |
| 39453 | static PyObject* pyopencv_cv_cuda_cuda_BufferPool_getAllocator(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39405 | static PyObject* pyopencv_cv_cuda_cuda_BufferPool_getAllocator(PyObject* self, PyObject* py_args, PyObject* kw)
| 39454 | { |  | 39406 | {
| 39455 | using namespace cv::cuda; |  | 39407 | using namespace cv::cuda;
| 39456 |  |  | 39408 |
| 39457 |  |  | 39409 |
| 39458 | Ptr<cv::cuda::BufferPool> * self1 = 0; |  | 39410 | Ptr<cv::cuda::BufferPool> * self1 = 0;
| 39459 | if (!pyopencv_cuda_BufferPool_getp(self, self1)) |  | 39411 | if (!pyopencv_cuda_BufferPool_getp(self, self1))
| 39460 | return failmsgp("Incorrect type of self (must be 'cuda_BufferPool' or its derivative)"); |  | 39412 | return failmsgp("Incorrect type of self (must be 'cuda_BufferPool' or its derivative)");
| 39461 | Ptr<cv::cuda::BufferPool> _self_ = *(self1); |  | 39413 | Ptr<cv::cuda::BufferPool> _self_ = *(self1);
| 39462 | Ptr<GpuMat::Allocator> retval; |  | 39414 | Ptr<GpuMat::Allocator> retval;
| 39463 |  |  | 39415 |
| 39464 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39416 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39465 | { |  | 39417 | {
| 39466 | ERRWRAP2(retval = _self_->getAllocator()); |  | 39418 | ERRWRAP2(retval = _self_->getAllocator());
| 39467 | return pyopencv_from(retval); |  | 39419 | return pyopencv_from(retval);
| 39468 | } |  | 39420 | }
| 39469 |  |  | 39421 |
| 39470 | return NULL; |  | 39422 | return NULL;
| 39471 | } |  | 39423 | }
| 39472 |  |  | 39424 |
| 39473 | static PyObject* pyopencv_cv_cuda_cuda_BufferPool_getBuffer(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39425 | static PyObject* pyopencv_cv_cuda_cuda_BufferPool_getBuffer(PyObject* self, PyObject* py_args, PyObject* kw)
| 39474 | { |  | 39426 | {
| 39475 | using namespace cv::cuda; |  | 39427 | using namespace cv::cuda;
| 39476 |  |  | 39428 |
| 39477 |  |  | 39429 |
| 39478 | Ptr<cv::cuda::BufferPool> * self1 = 0; |  | 39430 | Ptr<cv::cuda::BufferPool> * self1 = 0;
| 39479 | if (!pyopencv_cuda_BufferPool_getp(self, self1)) |  | 39431 | if (!pyopencv_cuda_BufferPool_getp(self, self1))
| 39480 | return failmsgp("Incorrect type of self (must be 'cuda_BufferPool' or its derivative)"); |  | 39432 | return failmsgp("Incorrect type of self (must be 'cuda_BufferPool' or its derivative)");
| 39481 | Ptr<cv::cuda::BufferPool> _self_ = *(self1); |  | 39433 | Ptr<cv::cuda::BufferPool> _self_ = *(self1);
| 39482 | pyPrepareArgumentConversionErrorsStorage(2); |  | 39434 | pyPrepareArgumentConversionErrorsStorage(2);
| 39483 |  |  | 39435 |
| 39484 | { |  | 39436 | {
| 39485 | PyObject* pyobj_rows = NULL; |  | 39437 | PyObject* pyobj_rows = NULL;
| 39486 | int rows=0; |  | 39438 | int rows=0;
| 39487 | PyObject* pyobj_cols = NULL; |  | 39439 | PyObject* pyobj_cols = NULL;
| 39488 | int cols=0; |  | 39440 | int cols=0;
| 39489 | PyObject* pyobj_type = NULL; |  | 39441 | PyObject* pyobj_type = NULL;
| 39490 | int type=0; |  | 39442 | int type=0;
| 39491 | GpuMat retval; |  | 39443 | GpuMat retval;
| 39492 |  |  | 39444 |
| 39493 | const char* keywords[] = { "rows", "cols", "type", NULL }; |  | 39445 | const char* keywords[] = { "rows", "cols", "type", NULL };
| 39494 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_BufferPool.getBuffer", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type) && |  | 39446 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_BufferPool.getBuffer", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type) &&
| 39495 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 39447 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 39496 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 39448 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 39497 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 39449 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 39498 | { |  | 39450 | {
| 39499 | ERRWRAP2(retval = _self_->getBuffer(rows, cols, type)); |  | 39451 | ERRWRAP2(retval = _self_->getBuffer(rows, cols, type));
| 39500 | return pyopencv_from(retval); |  | 39452 | return pyopencv_from(retval);
| 39501 | } |  | 39453 | }
| 39502 |  |  | 39454 |
| 39503 |  |  | 39455 |
| 39504 | pyPopulateArgumentConversionErrors(); |  | 39456 | pyPopulateArgumentConversionErrors();
| 39505 | } |  | 39457 | }
| 39506 |  |  | 39458 |
| 39507 |  |  | 39459 |
| 39508 | { |  | 39460 | {
| 39509 | PyObject* pyobj_size = NULL; |  | 39461 | PyObject* pyobj_size = NULL;
| 39510 | Size size; |  | 39462 | Size size;
| 39511 | PyObject* pyobj_type = NULL; |  | 39463 | PyObject* pyobj_type = NULL;
| 39512 | int type=0; |  | 39464 | int type=0;
| 39513 | GpuMat retval; |  | 39465 | GpuMat retval;
| 39514 |  |  | 39466 |
| 39515 | const char* keywords[] = { "size", "type", NULL }; |  | 39467 | const char* keywords[] = { "size", "type", NULL };
| 39516 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_BufferPool.getBuffer", (char**)keywords, &pyobj_size, &pyobj_type) && |  | 39468 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_BufferPool.getBuffer", (char**)keywords, &pyobj_size, &pyobj_type) &&
| 39517 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 39469 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 39518 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 39470 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 39519 | { |  | 39471 | {
| 39520 | ERRWRAP2(retval = _self_->getBuffer(size, type)); |  | 39472 | ERRWRAP2(retval = _self_->getBuffer(size, type));
| 39521 | return pyopencv_from(retval); |  | 39473 | return pyopencv_from(retval);
| 39522 | } |  | 39474 | }
| 39523 |  |  | 39475 |
| 39524 |  |  | 39476 |
| 39525 | pyPopulateArgumentConversionErrors(); |  | 39477 | pyPopulateArgumentConversionErrors();
| 39526 | } |  | 39478 | }
| 39527 | pyRaiseCVOverloadException("getBuffer"); |  | 39479 | pyRaiseCVOverloadException("getBuffer");
| 39528 |  |  | 39480 |
| 39529 | return NULL; |  | 39481 | return NULL;
| 39530 | } |  | 39482 | }
| 39531 |  |  | 39483 |
| 39532 |  |  | 39484 |
| 39533 |  |  | 39485 |
| 39534 | // Tables (cuda_BufferPool) |  | 39486 | // Tables (cuda_BufferPool)
| 39535 |  |  | 39487 |
| 39536 | static PyGetSetDef pyopencv_cuda_BufferPool_getseters[] = |  | 39488 | static PyGetSetDef pyopencv_cuda_BufferPool_getseters[] =
| 39537 | { |  | 39489 | {
| 39538 | {NULL} /* Sentinel */ |  | 39490 | {NULL} /* Sentinel */
| 39539 | }; |  | 39491 | };
| 39540 |  |  | 39492 |
| 39541 | static PyMethodDef pyopencv_cuda_BufferPool_methods[] = |  | 39493 | static PyMethodDef pyopencv_cuda_BufferPool_methods[] =
| 39542 | { |  | 39494 | {
| 39543 | {"getAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_BufferPool_getAllocator, 0), "getAllocator() -> retval\n."}, |  | 39495 | {"getAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_BufferPool_getAllocator, 0), "getAllocator() -> retval\n."},
| 39544 | {"getBuffer", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_BufferPool_getBuffer, 0), "getBuffer(rows, cols, type) -> retval\n. \n\n\n\ngetBuffer(size, type) -> retval\n."}, |  | 39496 | {"getBuffer", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_BufferPool_getBuffer, 0), "getBuffer(rows, cols, type) -> retval\n. \n\n\n\ngetBuffer(size, type) -> retval\n."},
| 39545 |  |  | 39497 |
| 39546 | {NULL, NULL} |  | 39498 | {NULL, NULL}
| 39547 | }; |  | 39499 | };
| 39548 |  |  | 39500 |
| 39549 | // Converter (cuda_BufferPool) |  | 39501 | // Converter (cuda_BufferPool)
| 39550 |  |  | 39502 |
| 39551 | template<> |  | 39503 | template<>
| 39552 | struct PyOpenCV_Converter< Ptr<cv::cuda::BufferPool> > |  | 39504 | struct PyOpenCV_Converter< Ptr<cv::cuda::BufferPool> >
| 39553 | { |  | 39505 | {
| 39554 | static PyObject* from(const Ptr<cv::cuda::BufferPool>& r) |  | 39506 | static PyObject* from(const Ptr<cv::cuda::BufferPool>& r)
| 39555 | { |  | 39507 | {
| 39556 | return pyopencv_cuda_BufferPool_Instance(r); |  | 39508 | return pyopencv_cuda_BufferPool_Instance(r);
| 39557 | } |  | 39509 | }
| 39558 | static bool to(PyObject* src, Ptr<cv::cuda::BufferPool>& dst, const ArgInfo& info) |  | 39510 | static bool to(PyObject* src, Ptr<cv::cuda::BufferPool>& dst, const ArgInfo& info)
| 39559 | { |  | 39511 | {
| 39560 | if(!src || src == Py_None) |  | 39512 | if(!src || src == Py_None)
| 39561 | return true; |  | 39513 | return true;
| 39562 | Ptr<cv::cuda::BufferPool> * dst_; |  | 39514 | Ptr<cv::cuda::BufferPool> * dst_;
| 39563 | if (pyopencv_cuda_BufferPool_getp(src, dst_)) |  | 39515 | if (pyopencv_cuda_BufferPool_getp(src, dst_))
| 39564 | { |  | 39516 | {
| 39565 | dst = *dst_; |  | 39517 | dst = *dst_;
| 39566 | return true; |  | 39518 | return true;
| 39567 | } |  | 39519 | }
| 39568 |  |  | 39520 |
| 39569 | failmsg("Expected Ptr<cv::cuda::BufferPool> for argument '%s'", info.name); |  | 39521 | failmsg("Expected Ptr<cv::cuda::BufferPool> for argument '%s'", info.name);
| 39570 | return false; |  | 39522 | return false;
| 39571 | } |  | 39523 | }
| 39572 | }; |  | 39524 | };
| 39573 |  |  | 39525 |
| 39574 | //================================================================================ |  | 39526 | //================================================================================
| 39575 | // cuda_DeviceInfo (Generic) |  | 39527 | // cuda_DeviceInfo (Generic)
| 39576 | //================================================================================ |  | 39528 | //================================================================================
| 39577 |  |  | 39529 |
| 39578 | // GetSet (cuda_DeviceInfo) |  | 39530 | // GetSet (cuda_DeviceInfo)
| 39579 |  |  | 39531 |
| 39580 |  |  | 39532 |
| 39581 |  |  | 39533 |
| 39582 | // Methods (cuda_DeviceInfo) |  | 39534 | // Methods (cuda_DeviceInfo)
| 39583 |  |  | 39535 |
| 39584 | static int pyopencv_cv_cuda_cuda_DeviceInfo_DeviceInfo(pyopencv_cuda_DeviceInfo_t* self, PyObject* py_args, PyObject* kw) |  | 39536 | static int pyopencv_cv_cuda_cuda_DeviceInfo_DeviceInfo(pyopencv_cuda_DeviceInfo_t* self, PyObject* py_args, PyObject* kw)
| 39585 | { |  | 39537 | {
| 39586 | using namespace cv::cuda; |  | 39538 | using namespace cv::cuda;
| 39587 |  |  | 39539 |
| 39588 | pyPrepareArgumentConversionErrorsStorage(2); |  | 39540 | pyPrepareArgumentConversionErrorsStorage(2);
| 39589 |  |  | 39541 |
| 39590 | { |  | 39542 | {
| 39591 |  |  | 39543 |
| 39592 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39544 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39593 | { |  | 39545 | {
| 39594 | new (&(self->v)) Ptr<cv::cuda::DeviceInfo>(); // init Ptr with placement new |  | 39546 | new (&(self->v)) Ptr<cv::cuda::DeviceInfo>(); // init Ptr with placement new
| 39595 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::DeviceInfo())); |  | 39547 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::DeviceInfo()));
| 39596 | return 0; |  | 39548 | return 0;
| 39597 | } |  | 39549 | }
| 39598 |  |  | 39550 |
| 39599 |  |  | 39551 |
| 39600 | pyPopulateArgumentConversionErrors(); |  | 39552 | pyPopulateArgumentConversionErrors();
| 39601 | } |  | 39553 | }
| 39602 |  |  | 39554 |
| 39603 |  |  | 39555 |
| 39604 | { |  | 39556 | {
| 39605 | PyObject* pyobj_device_id = NULL; |  | 39557 | PyObject* pyobj_device_id = NULL;
| 39606 | int device_id=0; |  | 39558 | int device_id=0;
| 39607 |  |  | 39559 |
| 39608 | const char* keywords[] = { "device_id", NULL }; |  | 39560 | const char* keywords[] = { "device_id", NULL };
| 39609 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DeviceInfo", (char**)keywords, &pyobj_device_id) && |  | 39561 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DeviceInfo", (char**)keywords, &pyobj_device_id) &&
| 39610 | pyopencv_to_safe(pyobj_device_id, device_id, ArgInfo("device_id", 0)) ) |  | 39562 | pyopencv_to_safe(pyobj_device_id, device_id, ArgInfo("device_id", 0)) )
| 39611 | { |  | 39563 | {
| 39612 | new (&(self->v)) Ptr<cv::cuda::DeviceInfo>(); // init Ptr with placement new |  | 39564 | new (&(self->v)) Ptr<cv::cuda::DeviceInfo>(); // init Ptr with placement new
| 39613 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::DeviceInfo(device_id))); |  | 39565 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::DeviceInfo(device_id)));
| 39614 | return 0; |  | 39566 | return 0;
| 39615 | } |  | 39567 | }
| 39616 |  |  | 39568 |
| 39617 |  |  | 39569 |
| 39618 | pyPopulateArgumentConversionErrors(); |  | 39570 | pyPopulateArgumentConversionErrors();
| 39619 | } |  | 39571 | }
| 39620 | pyRaiseCVOverloadException("DeviceInfo"); |  | 39572 | pyRaiseCVOverloadException("DeviceInfo");
| 39621 |  |  | 39573 |
| 39622 | return -1; |  | 39574 | return -1;
| 39623 | } |  | 39575 | }
| 39624 |  |  | 39576 |
| 39625 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_ECCEnabled(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39577 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_ECCEnabled(PyObject* self, PyObject* py_args, PyObject* kw)
| 39626 | { |  | 39578 | {
| 39627 | using namespace cv::cuda; |  | 39579 | using namespace cv::cuda;
| 39628 |  |  | 39580 |
| 39629 |  |  | 39581 |
| 39630 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39582 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39631 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39583 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39632 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39584 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39633 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39585 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39634 | bool retval; |  | 39586 | bool retval;
| 39635 |  |  | 39587 |
| 39636 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39588 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39637 | { |  | 39589 | {
| 39638 | ERRWRAP2(retval = _self_->ECCEnabled()); |  | 39590 | ERRWRAP2(retval = _self_->ECCEnabled());
| 39639 | return pyopencv_from(retval); |  | 39591 | return pyopencv_from(retval);
| 39640 | } |  | 39592 | }
| 39641 |  |  | 39593 |
| 39642 | return NULL; |  | 39594 | return NULL;
| 39643 | } |  | 39595 | }
| 39644 |  |  | 39596 |
| 39645 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_asyncEngineCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39597 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_asyncEngineCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 39646 | { |  | 39598 | {
| 39647 | using namespace cv::cuda; |  | 39599 | using namespace cv::cuda;
| 39648 |  |  | 39600 |
| 39649 |  |  | 39601 |
| 39650 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39602 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39651 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39603 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39652 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39604 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39653 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39605 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39654 | int retval; |  | 39606 | int retval;
| 39655 |  |  | 39607 |
| 39656 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39608 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39657 | { |  | 39609 | {
| 39658 | ERRWRAP2(retval = _self_->asyncEngineCount()); |  | 39610 | ERRWRAP2(retval = _self_->asyncEngineCount());
| 39659 | return pyopencv_from(retval); |  | 39611 | return pyopencv_from(retval);
| 39660 | } |  | 39612 | }
| 39661 |  |  | 39613 |
| 39662 | return NULL; |  | 39614 | return NULL;
| 39663 | } |  | 39615 | }
| 39664 |  |  | 39616 |
| 39665 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_canMapHostMemory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39617 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_canMapHostMemory(PyObject* self, PyObject* py_args, PyObject* kw)
| 39666 | { |  | 39618 | {
| 39667 | using namespace cv::cuda; |  | 39619 | using namespace cv::cuda;
| 39668 |  |  | 39620 |
| 39669 |  |  | 39621 |
| 39670 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39622 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39671 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39623 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39672 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39624 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39673 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39625 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39674 | bool retval; |  | 39626 | bool retval;
| 39675 |  |  | 39627 |
| 39676 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39628 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39677 | { |  | 39629 | {
| 39678 | ERRWRAP2(retval = _self_->canMapHostMemory()); |  | 39630 | ERRWRAP2(retval = _self_->canMapHostMemory());
| 39679 | return pyopencv_from(retval); |  | 39631 | return pyopencv_from(retval);
| 39680 | } |  | 39632 | }
| 39681 |  |  | 39633 |
| 39682 | return NULL; |  | 39634 | return NULL;
| 39683 | } |  | 39635 | }
| 39684 |  |  | 39636 |
| 39685 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_clockRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39637 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_clockRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 39686 | { |  | 39638 | {
| 39687 | using namespace cv::cuda; |  | 39639 | using namespace cv::cuda;
| 39688 |  |  | 39640 |
| 39689 |  |  | 39641 |
| 39690 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39642 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39691 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39643 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39692 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39644 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39693 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39645 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39694 | int retval; |  | 39646 | int retval;
| 39695 |  |  | 39647 |
| 39696 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39648 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39697 | { |  | 39649 | {
| 39698 | ERRWRAP2(retval = _self_->clockRate()); |  | 39650 | ERRWRAP2(retval = _self_->clockRate());
| 39699 | return pyopencv_from(retval); |  | 39651 | return pyopencv_from(retval);
| 39700 | } |  | 39652 | }
| 39701 |  |  | 39653 |
| 39702 | return NULL; |  | 39654 | return NULL;
| 39703 | } |  | 39655 | }
| 39704 |  |  | 39656 |
| 39705 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_computeMode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39657 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_computeMode(PyObject* self, PyObject* py_args, PyObject* kw)
| 39706 | { |  | 39658 | {
| 39707 | using namespace cv::cuda; |  | 39659 | using namespace cv::cuda;
| 39708 |  |  | 39660 |
| 39709 |  |  | 39661 |
| 39710 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39662 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39711 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39663 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39712 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39664 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39713 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39665 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39714 | DeviceInfo::ComputeMode retval; |  | 39666 | DeviceInfo::ComputeMode retval;
| 39715 |  |  | 39667 |
| 39716 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39668 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39717 | { |  | 39669 | {
| 39718 | ERRWRAP2(retval = _self_->computeMode()); |  | 39670 | ERRWRAP2(retval = _self_->computeMode());
| 39719 | return pyopencv_from(retval); |  | 39671 | return pyopencv_from(retval);
| 39720 | } |  | 39672 | }
| 39721 |  |  | 39673 |
| 39722 | return NULL; |  | 39674 | return NULL;
| 39723 | } |  | 39675 | }
| 39724 |  |  | 39676 |
| 39725 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_concurrentKernels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39677 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_concurrentKernels(PyObject* self, PyObject* py_args, PyObject* kw)
| 39726 | { |  | 39678 | {
| 39727 | using namespace cv::cuda; |  | 39679 | using namespace cv::cuda;
| 39728 |  |  | 39680 |
| 39729 |  |  | 39681 |
| 39730 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39682 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39731 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39683 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39732 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39684 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39733 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39685 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39734 | bool retval; |  | 39686 | bool retval;
| 39735 |  |  | 39687 |
| 39736 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39688 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39737 | { |  | 39689 | {
| 39738 | ERRWRAP2(retval = _self_->concurrentKernels()); |  | 39690 | ERRWRAP2(retval = _self_->concurrentKernels());
| 39739 | return pyopencv_from(retval); |  | 39691 | return pyopencv_from(retval);
| 39740 | } |  | 39692 | }
| 39741 |  |  | 39693 |
| 39742 | return NULL; |  | 39694 | return NULL;
| 39743 | } |  | 39695 | }
| 39744 |  |  | 39696 |
| 39745 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_deviceID(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39697 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_deviceID(PyObject* self, PyObject* py_args, PyObject* kw)
| 39746 | { |  | 39698 | {
| 39747 | using namespace cv::cuda; |  | 39699 | using namespace cv::cuda;
| 39748 |  |  | 39700 |
| 39749 |  |  | 39701 |
| 39750 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39702 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39751 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39703 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39752 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39704 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39753 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39705 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39754 | int retval; |  | 39706 | int retval;
| 39755 |  |  | 39707 |
| 39756 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39708 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39757 | { |  | 39709 | {
| 39758 | ERRWRAP2(retval = _self_->deviceID()); |  | 39710 | ERRWRAP2(retval = _self_->deviceID());
| 39759 | return pyopencv_from(retval); |  | 39711 | return pyopencv_from(retval);
| 39760 | } |  | 39712 | }
| 39761 |  |  | 39713 |
| 39762 | return NULL; |  | 39714 | return NULL;
| 39763 | } |  | 39715 | }
| 39764 |  |  | 39716 |
| 39765 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_freeMemory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39717 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_freeMemory(PyObject* self, PyObject* py_args, PyObject* kw)
| 39766 | { |  | 39718 | {
| 39767 | using namespace cv::cuda; |  | 39719 | using namespace cv::cuda;
| 39768 |  |  | 39720 |
| 39769 |  |  | 39721 |
| 39770 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39722 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39771 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39723 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39772 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39724 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39773 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39725 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39774 | size_t retval; |  | 39726 | size_t retval;
| 39775 |  |  | 39727 |
| 39776 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39728 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39777 | { |  | 39729 | {
| 39778 | ERRWRAP2(retval = _self_->freeMemory()); |  | 39730 | ERRWRAP2(retval = _self_->freeMemory());
| 39779 | return pyopencv_from(retval); |  | 39731 | return pyopencv_from(retval);
| 39780 | } |  | 39732 | }
| 39781 |  |  | 39733 |
| 39782 | return NULL; |  | 39734 | return NULL;
| 39783 | } |  | 39735 | }
| 39784 |  |  | 39736 |
| 39785 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_integrated(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39737 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_integrated(PyObject* self, PyObject* py_args, PyObject* kw)
| 39786 | { |  | 39738 | {
| 39787 | using namespace cv::cuda; |  | 39739 | using namespace cv::cuda;
| 39788 |  |  | 39740 |
| 39789 |  |  | 39741 |
| 39790 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39742 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39791 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39743 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39792 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39744 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39793 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39745 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39794 | bool retval; |  | 39746 | bool retval;
| 39795 |  |  | 39747 |
| 39796 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39748 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39797 | { |  | 39749 | {
| 39798 | ERRWRAP2(retval = _self_->integrated()); |  | 39750 | ERRWRAP2(retval = _self_->integrated());
| 39799 | return pyopencv_from(retval); |  | 39751 | return pyopencv_from(retval);
| 39800 | } |  | 39752 | }
| 39801 |  |  | 39753 |
| 39802 | return NULL; |  | 39754 | return NULL;
| 39803 | } |  | 39755 | }
| 39804 |  |  | 39756 |
| 39805 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_isCompatible(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39757 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_isCompatible(PyObject* self, PyObject* py_args, PyObject* kw)
| 39806 | { |  | 39758 | {
| 39807 | using namespace cv::cuda; |  | 39759 | using namespace cv::cuda;
| 39808 |  |  | 39760 |
| 39809 |  |  | 39761 |
| 39810 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39762 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39811 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39763 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39812 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39764 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39813 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39765 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39814 | bool retval; |  | 39766 | bool retval;
| 39815 |  |  | 39767 |
| 39816 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39768 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39817 | { |  | 39769 | {
| 39818 | ERRWRAP2(retval = _self_->isCompatible()); |  | 39770 | ERRWRAP2(retval = _self_->isCompatible());
| 39819 | return pyopencv_from(retval); |  | 39771 | return pyopencv_from(retval);
| 39820 | } |  | 39772 | }
| 39821 |  |  | 39773 |
| 39822 | return NULL; |  | 39774 | return NULL;
| 39823 | } |  | 39775 | }
| 39824 |  |  | 39776 |
| 39825 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_kernelExecTimeoutEnabled(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39777 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_kernelExecTimeoutEnabled(PyObject* self, PyObject* py_args, PyObject* kw)
| 39826 | { |  | 39778 | {
| 39827 | using namespace cv::cuda; |  | 39779 | using namespace cv::cuda;
| 39828 |  |  | 39780 |
| 39829 |  |  | 39781 |
| 39830 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39782 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39831 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39783 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39832 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39784 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39833 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39785 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39834 | bool retval; |  | 39786 | bool retval;
| 39835 |  |  | 39787 |
| 39836 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39788 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39837 | { |  | 39789 | {
| 39838 | ERRWRAP2(retval = _self_->kernelExecTimeoutEnabled()); |  | 39790 | ERRWRAP2(retval = _self_->kernelExecTimeoutEnabled());
| 39839 | return pyopencv_from(retval); |  | 39791 | return pyopencv_from(retval);
| 39840 | } |  | 39792 | }
| 39841 |  |  | 39793 |
| 39842 | return NULL; |  | 39794 | return NULL;
| 39843 | } |  | 39795 | }
| 39844 |  |  | 39796 |
| 39845 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_l2CacheSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39797 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_l2CacheSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 39846 | { |  | 39798 | {
| 39847 | using namespace cv::cuda; |  | 39799 | using namespace cv::cuda;
| 39848 |  |  | 39800 |
| 39849 |  |  | 39801 |
| 39850 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39802 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39851 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39803 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39852 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39804 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39853 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39805 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39854 | int retval; |  | 39806 | int retval;
| 39855 |  |  | 39807 |
| 39856 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39808 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39857 | { |  | 39809 | {
| 39858 | ERRWRAP2(retval = _self_->l2CacheSize()); |  | 39810 | ERRWRAP2(retval = _self_->l2CacheSize());
| 39859 | return pyopencv_from(retval); |  | 39811 | return pyopencv_from(retval);
| 39860 | } |  | 39812 | }
| 39861 |  |  | 39813 |
| 39862 | return NULL; |  | 39814 | return NULL;
| 39863 | } |  | 39815 | }
| 39864 |  |  | 39816 |
| 39865 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_majorVersion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39817 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_majorVersion(PyObject* self, PyObject* py_args, PyObject* kw)
| 39866 | { |  | 39818 | {
| 39867 | using namespace cv::cuda; |  | 39819 | using namespace cv::cuda;
| 39868 |  |  | 39820 |
| 39869 |  |  | 39821 |
| 39870 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39822 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39871 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39823 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39872 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39824 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39873 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39825 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39874 | int retval; |  | 39826 | int retval;
| 39875 |  |  | 39827 |
| 39876 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39828 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39877 | { |  | 39829 | {
| 39878 | ERRWRAP2(retval = _self_->majorVersion()); |  | 39830 | ERRWRAP2(retval = _self_->majorVersion());
| 39879 | return pyopencv_from(retval); |  | 39831 | return pyopencv_from(retval);
| 39880 | } |  | 39832 | }
| 39881 |  |  | 39833 |
| 39882 | return NULL; |  | 39834 | return NULL;
| 39883 | } |  | 39835 | }
| 39884 |  |  | 39836 |
| 39885 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxGridSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39837 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxGridSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 39886 | { |  | 39838 | {
| 39887 | using namespace cv::cuda; |  | 39839 | using namespace cv::cuda;
| 39888 |  |  | 39840 |
| 39889 |  |  | 39841 |
| 39890 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39842 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39891 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39843 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39892 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39844 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39893 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39845 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39894 | Vec3i retval; |  | 39846 | Vec3i retval;
| 39895 |  |  | 39847 |
| 39896 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39848 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39897 | { |  | 39849 | {
| 39898 | ERRWRAP2(retval = _self_->maxGridSize()); |  | 39850 | ERRWRAP2(retval = _self_->maxGridSize());
| 39899 | return pyopencv_from(retval); |  | 39851 | return pyopencv_from(retval);
| 39900 | } |  | 39852 | }
| 39901 |  |  | 39853 |
| 39902 | return NULL; |  | 39854 | return NULL;
| 39903 | } |  | 39855 | }
| 39904 |  |  | 39856 |
| 39905 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1D(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39857 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1D(PyObject* self, PyObject* py_args, PyObject* kw)
| 39906 | { |  | 39858 | {
| 39907 | using namespace cv::cuda; |  | 39859 | using namespace cv::cuda;
| 39908 |  |  | 39860 |
| 39909 |  |  | 39861 |
| 39910 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39862 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39911 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39863 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39912 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39864 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39913 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39865 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39914 | int retval; |  | 39866 | int retval;
| 39915 |  |  | 39867 |
| 39916 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39868 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39917 | { |  | 39869 | {
| 39918 | ERRWRAP2(retval = _self_->maxSurface1D()); |  | 39870 | ERRWRAP2(retval = _self_->maxSurface1D());
| 39919 | return pyopencv_from(retval); |  | 39871 | return pyopencv_from(retval);
| 39920 | } |  | 39872 | }
| 39921 |  |  | 39873 |
| 39922 | return NULL; |  | 39874 | return NULL;
| 39923 | } |  | 39875 | }
| 39924 |  |  | 39876 |
| 39925 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1DLayered(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39877 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1DLayered(PyObject* self, PyObject* py_args, PyObject* kw)
| 39926 | { |  | 39878 | {
| 39927 | using namespace cv::cuda; |  | 39879 | using namespace cv::cuda;
| 39928 |  |  | 39880 |
| 39929 |  |  | 39881 |
| 39930 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39882 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39931 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39883 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39932 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39884 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39933 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39885 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39934 | Vec2i retval; |  | 39886 | Vec2i retval;
| 39935 |  |  | 39887 |
| 39936 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39888 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39937 | { |  | 39889 | {
| 39938 | ERRWRAP2(retval = _self_->maxSurface1DLayered()); |  | 39890 | ERRWRAP2(retval = _self_->maxSurface1DLayered());
| 39939 | return pyopencv_from(retval); |  | 39891 | return pyopencv_from(retval);
| 39940 | } |  | 39892 | }
| 39941 |  |  | 39893 |
| 39942 | return NULL; |  | 39894 | return NULL;
| 39943 | } |  | 39895 | }
| 39944 |  |  | 39896 |
| 39945 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2D(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39897 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2D(PyObject* self, PyObject* py_args, PyObject* kw)
| 39946 | { |  | 39898 | {
| 39947 | using namespace cv::cuda; |  | 39899 | using namespace cv::cuda;
| 39948 |  |  | 39900 |
| 39949 |  |  | 39901 |
| 39950 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39902 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39951 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39903 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39952 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39904 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39953 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39905 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39954 | Vec2i retval; |  | 39906 | Vec2i retval;
| 39955 |  |  | 39907 |
| 39956 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39908 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39957 | { |  | 39909 | {
| 39958 | ERRWRAP2(retval = _self_->maxSurface2D()); |  | 39910 | ERRWRAP2(retval = _self_->maxSurface2D());
| 39959 | return pyopencv_from(retval); |  | 39911 | return pyopencv_from(retval);
| 39960 | } |  | 39912 | }
| 39961 |  |  | 39913 |
| 39962 | return NULL; |  | 39914 | return NULL;
| 39963 | } |  | 39915 | }
| 39964 |  |  | 39916 |
| 39965 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2DLayered(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39917 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2DLayered(PyObject* self, PyObject* py_args, PyObject* kw)
| 39966 | { |  | 39918 | {
| 39967 | using namespace cv::cuda; |  | 39919 | using namespace cv::cuda;
| 39968 |  |  | 39920 |
| 39969 |  |  | 39921 |
| 39970 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39922 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39971 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39923 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39972 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39924 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39973 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39925 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39974 | Vec3i retval; |  | 39926 | Vec3i retval;
| 39975 |  |  | 39927 |
| 39976 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39928 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39977 | { |  | 39929 | {
| 39978 | ERRWRAP2(retval = _self_->maxSurface2DLayered()); |  | 39930 | ERRWRAP2(retval = _self_->maxSurface2DLayered());
| 39979 | return pyopencv_from(retval); |  | 39931 | return pyopencv_from(retval);
| 39980 | } |  | 39932 | }
| 39981 |  |  | 39933 |
| 39982 | return NULL; |  | 39934 | return NULL;
| 39983 | } |  | 39935 | }
| 39984 |  |  | 39936 |
| 39985 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface3D(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39937 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface3D(PyObject* self, PyObject* py_args, PyObject* kw)
| 39986 | { |  | 39938 | {
| 39987 | using namespace cv::cuda; |  | 39939 | using namespace cv::cuda;
| 39988 |  |  | 39940 |
| 39989 |  |  | 39941 |
| 39990 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39942 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 39991 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39943 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 39992 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39944 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 39993 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39945 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 39994 | Vec3i retval; |  | 39946 | Vec3i retval;
| 39995 |  |  | 39947 |
| 39996 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39948 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 39997 | { |  | 39949 | {
| 39998 | ERRWRAP2(retval = _self_->maxSurface3D()); |  | 39950 | ERRWRAP2(retval = _self_->maxSurface3D());
| 39999 | return pyopencv_from(retval); |  | 39951 | return pyopencv_from(retval);
| 40000 | } |  | 39952 | }
| 40001 |  |  | 39953 |
| 40002 | return NULL; |  | 39954 | return NULL;
| 40003 | } |  | 39955 | }
| 40004 |  |  | 39956 |
| 40005 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39957 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemap(PyObject* self, PyObject* py_args, PyObject* kw)
| 40006 | { |  | 39958 | {
| 40007 | using namespace cv::cuda; |  | 39959 | using namespace cv::cuda;
| 40008 |  |  | 39960 |
| 40009 |  |  | 39961 |
| 40010 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39962 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40011 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39963 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40012 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39964 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40013 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39965 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40014 | int retval; |  | 39966 | int retval;
| 40015 |  |  | 39967 |
| 40016 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39968 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40017 | { |  | 39969 | {
| 40018 | ERRWRAP2(retval = _self_->maxSurfaceCubemap()); |  | 39970 | ERRWRAP2(retval = _self_->maxSurfaceCubemap());
| 40019 | return pyopencv_from(retval); |  | 39971 | return pyopencv_from(retval);
| 40020 | } |  | 39972 | }
| 40021 |  |  | 39973 |
| 40022 | return NULL; |  | 39974 | return NULL;
| 40023 | } |  | 39975 | }
| 40024 |  |  | 39976 |
| 40025 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemapLayered(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39977 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemapLayered(PyObject* self, PyObject* py_args, PyObject* kw)
| 40026 | { |  | 39978 | {
| 40027 | using namespace cv::cuda; |  | 39979 | using namespace cv::cuda;
| 40028 |  |  | 39980 |
| 40029 |  |  | 39981 |
| 40030 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 39982 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40031 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 39983 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40032 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 39984 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40033 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 39985 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40034 | Vec2i retval; |  | 39986 | Vec2i retval;
| 40035 |  |  | 39987 |
| 40036 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 39988 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40037 | { |  | 39989 | {
| 40038 | ERRWRAP2(retval = _self_->maxSurfaceCubemapLayered()); |  | 39990 | ERRWRAP2(retval = _self_->maxSurfaceCubemapLayered());
| 40039 | return pyopencv_from(retval); |  | 39991 | return pyopencv_from(retval);
| 40040 | } |  | 39992 | }
| 40041 |  |  | 39993 |
| 40042 | return NULL; |  | 39994 | return NULL;
| 40043 | } |  | 39995 | }
| 40044 |  |  | 39996 |
| 40045 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1D(PyObject* self, PyObject* py_args, PyObject* kw) |  | 39997 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1D(PyObject* self, PyObject* py_args, PyObject* kw)
| 40046 | { |  | 39998 | {
| 40047 | using namespace cv::cuda; |  | 39999 | using namespace cv::cuda;
| 40048 |  |  | 40000 |
| 40049 |  |  | 40001 |
| 40050 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40002 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40051 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40003 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40052 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40004 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40053 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40005 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40054 | int retval; |  | 40006 | int retval;
| 40055 |  |  | 40007 |
| 40056 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40008 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40057 | { |  | 40009 | {
| 40058 | ERRWRAP2(retval = _self_->maxTexture1D()); |  | 40010 | ERRWRAP2(retval = _self_->maxTexture1D());
| 40059 | return pyopencv_from(retval); |  | 40011 | return pyopencv_from(retval);
| 40060 | } |  | 40012 | }
| 40061 |  |  | 40013 |
| 40062 | return NULL; |  | 40014 | return NULL;
| 40063 | } |  | 40015 | }
| 40064 |  |  | 40016 |
| 40065 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLayered(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40017 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLayered(PyObject* self, PyObject* py_args, PyObject* kw)
| 40066 | { |  | 40018 | {
| 40067 | using namespace cv::cuda; |  | 40019 | using namespace cv::cuda;
| 40068 |  |  | 40020 |
| 40069 |  |  | 40021 |
| 40070 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40022 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40071 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40023 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40072 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40024 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40073 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40025 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40074 | Vec2i retval; |  | 40026 | Vec2i retval;
| 40075 |  |  | 40027 |
| 40076 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40028 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40077 | { |  | 40029 | {
| 40078 | ERRWRAP2(retval = _self_->maxTexture1DLayered()); |  | 40030 | ERRWRAP2(retval = _self_->maxTexture1DLayered());
| 40079 | return pyopencv_from(retval); |  | 40031 | return pyopencv_from(retval);
| 40080 | } |  | 40032 | }
| 40081 |  |  | 40033 |
| 40082 | return NULL; |  | 40034 | return NULL;
| 40083 | } |  | 40035 | }
| 40084 |  |  | 40036 |
| 40085 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLinear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40037 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLinear(PyObject* self, PyObject* py_args, PyObject* kw)
| 40086 | { |  | 40038 | {
| 40087 | using namespace cv::cuda; |  | 40039 | using namespace cv::cuda;
| 40088 |  |  | 40040 |
| 40089 |  |  | 40041 |
| 40090 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40042 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40091 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40043 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40092 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40044 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40093 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40045 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40094 | int retval; |  | 40046 | int retval;
| 40095 |  |  | 40047 |
| 40096 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40048 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40097 | { |  | 40049 | {
| 40098 | ERRWRAP2(retval = _self_->maxTexture1DLinear()); |  | 40050 | ERRWRAP2(retval = _self_->maxTexture1DLinear());
| 40099 | return pyopencv_from(retval); |  | 40051 | return pyopencv_from(retval);
| 40100 | } |  | 40052 | }
| 40101 |  |  | 40053 |
| 40102 | return NULL; |  | 40054 | return NULL;
| 40103 | } |  | 40055 | }
| 40104 |  |  | 40056 |
| 40105 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DMipmap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40057 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DMipmap(PyObject* self, PyObject* py_args, PyObject* kw)
| 40106 | { |  | 40058 | {
| 40107 | using namespace cv::cuda; |  | 40059 | using namespace cv::cuda;
| 40108 |  |  | 40060 |
| 40109 |  |  | 40061 |
| 40110 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40062 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40111 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40063 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40112 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40064 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40113 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40065 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40114 | int retval; |  | 40066 | int retval;
| 40115 |  |  | 40067 |
| 40116 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40068 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40117 | { |  | 40069 | {
| 40118 | ERRWRAP2(retval = _self_->maxTexture1DMipmap()); |  | 40070 | ERRWRAP2(retval = _self_->maxTexture1DMipmap());
| 40119 | return pyopencv_from(retval); |  | 40071 | return pyopencv_from(retval);
| 40120 | } |  | 40072 | }
| 40121 |  |  | 40073 |
| 40122 | return NULL; |  | 40074 | return NULL;
| 40123 | } |  | 40075 | }
| 40124 |  |  | 40076 |
| 40125 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2D(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40077 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2D(PyObject* self, PyObject* py_args, PyObject* kw)
| 40126 | { |  | 40078 | {
| 40127 | using namespace cv::cuda; |  | 40079 | using namespace cv::cuda;
| 40128 |  |  | 40080 |
| 40129 |  |  | 40081 |
| 40130 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40082 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40131 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40083 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40132 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40084 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40133 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40085 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40134 | Vec2i retval; |  | 40086 | Vec2i retval;
| 40135 |  |  | 40087 |
| 40136 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40088 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40137 | { |  | 40089 | {
| 40138 | ERRWRAP2(retval = _self_->maxTexture2D()); |  | 40090 | ERRWRAP2(retval = _self_->maxTexture2D());
| 40139 | return pyopencv_from(retval); |  | 40091 | return pyopencv_from(retval);
| 40140 | } |  | 40092 | }
| 40141 |  |  | 40093 |
| 40142 | return NULL; |  | 40094 | return NULL;
| 40143 | } |  | 40095 | }
| 40144 |  |  | 40096 |
| 40145 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DGather(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40097 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DGather(PyObject* self, PyObject* py_args, PyObject* kw)
| 40146 | { |  | 40098 | {
| 40147 | using namespace cv::cuda; |  | 40099 | using namespace cv::cuda;
| 40148 |  |  | 40100 |
| 40149 |  |  | 40101 |
| 40150 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40102 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40151 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40103 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40152 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40104 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40153 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40105 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40154 | Vec2i retval; |  | 40106 | Vec2i retval;
| 40155 |  |  | 40107 |
| 40156 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40108 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40157 | { |  | 40109 | {
| 40158 | ERRWRAP2(retval = _self_->maxTexture2DGather()); |  | 40110 | ERRWRAP2(retval = _self_->maxTexture2DGather());
| 40159 | return pyopencv_from(retval); |  | 40111 | return pyopencv_from(retval);
| 40160 | } |  | 40112 | }
| 40161 |  |  | 40113 |
| 40162 | return NULL; |  | 40114 | return NULL;
| 40163 | } |  | 40115 | }
| 40164 |  |  | 40116 |
| 40165 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLayered(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40117 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLayered(PyObject* self, PyObject* py_args, PyObject* kw)
| 40166 | { |  | 40118 | {
| 40167 | using namespace cv::cuda; |  | 40119 | using namespace cv::cuda;
| 40168 |  |  | 40120 |
| 40169 |  |  | 40121 |
| 40170 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40122 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40171 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40123 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40172 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40124 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40173 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40125 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40174 | Vec3i retval; |  | 40126 | Vec3i retval;
| 40175 |  |  | 40127 |
| 40176 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40128 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40177 | { |  | 40129 | {
| 40178 | ERRWRAP2(retval = _self_->maxTexture2DLayered()); |  | 40130 | ERRWRAP2(retval = _self_->maxTexture2DLayered());
| 40179 | return pyopencv_from(retval); |  | 40131 | return pyopencv_from(retval);
| 40180 | } |  | 40132 | }
| 40181 |  |  | 40133 |
| 40182 | return NULL; |  | 40134 | return NULL;
| 40183 | } |  | 40135 | }
| 40184 |  |  | 40136 |
| 40185 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLinear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40137 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLinear(PyObject* self, PyObject* py_args, PyObject* kw)
| 40186 | { |  | 40138 | {
| 40187 | using namespace cv::cuda; |  | 40139 | using namespace cv::cuda;
| 40188 |  |  | 40140 |
| 40189 |  |  | 40141 |
| 40190 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40142 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40191 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40143 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40192 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40144 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40193 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40145 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40194 | Vec3i retval; |  | 40146 | Vec3i retval;
| 40195 |  |  | 40147 |
| 40196 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40148 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40197 | { |  | 40149 | {
| 40198 | ERRWRAP2(retval = _self_->maxTexture2DLinear()); |  | 40150 | ERRWRAP2(retval = _self_->maxTexture2DLinear());
| 40199 | return pyopencv_from(retval); |  | 40151 | return pyopencv_from(retval);
| 40200 | } |  | 40152 | }
| 40201 |  |  | 40153 |
| 40202 | return NULL; |  | 40154 | return NULL;
| 40203 | } |  | 40155 | }
| 40204 |  |  | 40156 |
| 40205 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DMipmap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40157 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DMipmap(PyObject* self, PyObject* py_args, PyObject* kw)
| 40206 | { |  | 40158 | {
| 40207 | using namespace cv::cuda; |  | 40159 | using namespace cv::cuda;
| 40208 |  |  | 40160 |
| 40209 |  |  | 40161 |
| 40210 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40162 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40211 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40163 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40212 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40164 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40213 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40165 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40214 | Vec2i retval; |  | 40166 | Vec2i retval;
| 40215 |  |  | 40167 |
| 40216 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40168 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40217 | { |  | 40169 | {
| 40218 | ERRWRAP2(retval = _self_->maxTexture2DMipmap()); |  | 40170 | ERRWRAP2(retval = _self_->maxTexture2DMipmap());
| 40219 | return pyopencv_from(retval); |  | 40171 | return pyopencv_from(retval);
| 40220 | } |  | 40172 | }
| 40221 |  |  | 40173 |
| 40222 | return NULL; |  | 40174 | return NULL;
| 40223 | } |  | 40175 | }
| 40224 |  |  | 40176 |
| 40225 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture3D(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40177 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture3D(PyObject* self, PyObject* py_args, PyObject* kw)
| 40226 | { |  | 40178 | {
| 40227 | using namespace cv::cuda; |  | 40179 | using namespace cv::cuda;
| 40228 |  |  | 40180 |
| 40229 |  |  | 40181 |
| 40230 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40182 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40231 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40183 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40232 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40184 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40233 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40185 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40234 | Vec3i retval; |  | 40186 | Vec3i retval;
| 40235 |  |  | 40187 |
| 40236 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40188 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40237 | { |  | 40189 | {
| 40238 | ERRWRAP2(retval = _self_->maxTexture3D()); |  | 40190 | ERRWRAP2(retval = _self_->maxTexture3D());
| 40239 | return pyopencv_from(retval); |  | 40191 | return pyopencv_from(retval);
| 40240 | } |  | 40192 | }
| 40241 |  |  | 40193 |
| 40242 | return NULL; |  | 40194 | return NULL;
| 40243 | } |  | 40195 | }
| 40244 |  |  | 40196 |
| 40245 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40197 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemap(PyObject* self, PyObject* py_args, PyObject* kw)
| 40246 | { |  | 40198 | {
| 40247 | using namespace cv::cuda; |  | 40199 | using namespace cv::cuda;
| 40248 |  |  | 40200 |
| 40249 |  |  | 40201 |
| 40250 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40202 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40251 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40203 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40252 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40204 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40253 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40205 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40254 | int retval; |  | 40206 | int retval;
| 40255 |  |  | 40207 |
| 40256 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40208 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40257 | { |  | 40209 | {
| 40258 | ERRWRAP2(retval = _self_->maxTextureCubemap()); |  | 40210 | ERRWRAP2(retval = _self_->maxTextureCubemap());
| 40259 | return pyopencv_from(retval); |  | 40211 | return pyopencv_from(retval);
| 40260 | } |  | 40212 | }
| 40261 |  |  | 40213 |
| 40262 | return NULL; |  | 40214 | return NULL;
| 40263 | } |  | 40215 | }
| 40264 |  |  | 40216 |
| 40265 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemapLayered(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40217 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemapLayered(PyObject* self, PyObject* py_args, PyObject* kw)
| 40266 | { |  | 40218 | {
| 40267 | using namespace cv::cuda; |  | 40219 | using namespace cv::cuda;
| 40268 |  |  | 40220 |
| 40269 |  |  | 40221 |
| 40270 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40222 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40271 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40223 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40272 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40224 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40273 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40225 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40274 | Vec2i retval; |  | 40226 | Vec2i retval;
| 40275 |  |  | 40227 |
| 40276 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40228 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40277 | { |  | 40229 | {
| 40278 | ERRWRAP2(retval = _self_->maxTextureCubemapLayered()); |  | 40230 | ERRWRAP2(retval = _self_->maxTextureCubemapLayered());
| 40279 | return pyopencv_from(retval); |  | 40231 | return pyopencv_from(retval);
| 40280 | } |  | 40232 | }
| 40281 |  |  | 40233 |
| 40282 | return NULL; |  | 40234 | return NULL;
| 40283 | } |  | 40235 | }
| 40284 |  |  | 40236 |
| 40285 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsDim(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40237 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsDim(PyObject* self, PyObject* py_args, PyObject* kw)
| 40286 | { |  | 40238 | {
| 40287 | using namespace cv::cuda; |  | 40239 | using namespace cv::cuda;
| 40288 |  |  | 40240 |
| 40289 |  |  | 40241 |
| 40290 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40242 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40291 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40243 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40292 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40244 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40293 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40245 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40294 | Vec3i retval; |  | 40246 | Vec3i retval;
| 40295 |  |  | 40247 |
| 40296 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40248 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40297 | { |  | 40249 | {
| 40298 | ERRWRAP2(retval = _self_->maxThreadsDim()); |  | 40250 | ERRWRAP2(retval = _self_->maxThreadsDim());
| 40299 | return pyopencv_from(retval); |  | 40251 | return pyopencv_from(retval);
| 40300 | } |  | 40252 | }
| 40301 |  |  | 40253 |
| 40302 | return NULL; |  | 40254 | return NULL;
| 40303 | } |  | 40255 | }
| 40304 |  |  | 40256 |
| 40305 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerBlock(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40257 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerBlock(PyObject* self, PyObject* py_args, PyObject* kw)
| 40306 | { |  | 40258 | {
| 40307 | using namespace cv::cuda; |  | 40259 | using namespace cv::cuda;
| 40308 |  |  | 40260 |
| 40309 |  |  | 40261 |
| 40310 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40262 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40311 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40263 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40312 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40264 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40313 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40265 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40314 | int retval; |  | 40266 | int retval;
| 40315 |  |  | 40267 |
| 40316 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40268 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40317 | { |  | 40269 | {
| 40318 | ERRWRAP2(retval = _self_->maxThreadsPerBlock()); |  | 40270 | ERRWRAP2(retval = _self_->maxThreadsPerBlock());
| 40319 | return pyopencv_from(retval); |  | 40271 | return pyopencv_from(retval);
| 40320 | } |  | 40272 | }
| 40321 |  |  | 40273 |
| 40322 | return NULL; |  | 40274 | return NULL;
| 40323 | } |  | 40275 | }
| 40324 |  |  | 40276 |
| 40325 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerMultiProcessor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40277 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerMultiProcessor(PyObject* self, PyObject* py_args, PyObject* kw)
| 40326 | { |  | 40278 | {
| 40327 | using namespace cv::cuda; |  | 40279 | using namespace cv::cuda;
| 40328 |  |  | 40280 |
| 40329 |  |  | 40281 |
| 40330 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40282 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40331 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40283 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40332 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40284 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40333 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40285 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40334 | int retval; |  | 40286 | int retval;
| 40335 |  |  | 40287 |
| 40336 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40288 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40337 | { |  | 40289 | {
| 40338 | ERRWRAP2(retval = _self_->maxThreadsPerMultiProcessor()); |  | 40290 | ERRWRAP2(retval = _self_->maxThreadsPerMultiProcessor());
| 40339 | return pyopencv_from(retval); |  | 40291 | return pyopencv_from(retval);
| 40340 | } |  | 40292 | }
| 40341 |  |  | 40293 |
| 40342 | return NULL; |  | 40294 | return NULL;
| 40343 | } |  | 40295 | }
| 40344 |  |  | 40296 |
| 40345 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_memPitch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40297 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_memPitch(PyObject* self, PyObject* py_args, PyObject* kw)
| 40346 | { |  | 40298 | {
| 40347 | using namespace cv::cuda; |  | 40299 | using namespace cv::cuda;
| 40348 |  |  | 40300 |
| 40349 |  |  | 40301 |
| 40350 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40302 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40351 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40303 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40352 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40304 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40353 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40305 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40354 | size_t retval; |  | 40306 | size_t retval;
| 40355 |  |  | 40307 |
| 40356 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40308 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40357 | { |  | 40309 | {
| 40358 | ERRWRAP2(retval = _self_->memPitch()); |  | 40310 | ERRWRAP2(retval = _self_->memPitch());
| 40359 | return pyopencv_from(retval); |  | 40311 | return pyopencv_from(retval);
| 40360 | } |  | 40312 | }
| 40361 |  |  | 40313 |
| 40362 | return NULL; |  | 40314 | return NULL;
| 40363 | } |  | 40315 | }
| 40364 |  |  | 40316 |
| 40365 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_memoryBusWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40317 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_memoryBusWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 40366 | { |  | 40318 | {
| 40367 | using namespace cv::cuda; |  | 40319 | using namespace cv::cuda;
| 40368 |  |  | 40320 |
| 40369 |  |  | 40321 |
| 40370 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40322 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40371 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40323 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40372 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40324 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40373 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40325 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40374 | int retval; |  | 40326 | int retval;
| 40375 |  |  | 40327 |
| 40376 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40328 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40377 | { |  | 40329 | {
| 40378 | ERRWRAP2(retval = _self_->memoryBusWidth()); |  | 40330 | ERRWRAP2(retval = _self_->memoryBusWidth());
| 40379 | return pyopencv_from(retval); |  | 40331 | return pyopencv_from(retval);
| 40380 | } |  | 40332 | }
| 40381 |  |  | 40333 |
| 40382 | return NULL; |  | 40334 | return NULL;
| 40383 | } |  | 40335 | }
| 40384 |  |  | 40336 |
| 40385 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_memoryClockRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40337 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_memoryClockRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 40386 | { |  | 40338 | {
| 40387 | using namespace cv::cuda; |  | 40339 | using namespace cv::cuda;
| 40388 |  |  | 40340 |
| 40389 |  |  | 40341 |
| 40390 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40342 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40391 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40343 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40392 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40344 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40393 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40345 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40394 | int retval; |  | 40346 | int retval;
| 40395 |  |  | 40347 |
| 40396 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40348 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40397 | { |  | 40349 | {
| 40398 | ERRWRAP2(retval = _self_->memoryClockRate()); |  | 40350 | ERRWRAP2(retval = _self_->memoryClockRate());
| 40399 | return pyopencv_from(retval); |  | 40351 | return pyopencv_from(retval);
| 40400 | } |  | 40352 | }
| 40401 |  |  | 40353 |
| 40402 | return NULL; |  | 40354 | return NULL;
| 40403 | } |  | 40355 | }
| 40404 |  |  | 40356 |
| 40405 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_minorVersion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40357 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_minorVersion(PyObject* self, PyObject* py_args, PyObject* kw)
| 40406 | { |  | 40358 | {
| 40407 | using namespace cv::cuda; |  | 40359 | using namespace cv::cuda;
| 40408 |  |  | 40360 |
| 40409 |  |  | 40361 |
| 40410 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40362 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40411 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40363 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40412 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40364 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40413 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40365 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40414 | int retval; |  | 40366 | int retval;
| 40415 |  |  | 40367 |
| 40416 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40368 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40417 | { |  | 40369 | {
| 40418 | ERRWRAP2(retval = _self_->minorVersion()); |  | 40370 | ERRWRAP2(retval = _self_->minorVersion());
| 40419 | return pyopencv_from(retval); |  | 40371 | return pyopencv_from(retval);
| 40420 | } |  | 40372 | }
| 40421 |  |  | 40373 |
| 40422 | return NULL; |  | 40374 | return NULL;
| 40423 | } |  | 40375 | }
| 40424 |  |  | 40376 |
| 40425 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_multiProcessorCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40377 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_multiProcessorCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 40426 | { |  | 40378 | {
| 40427 | using namespace cv::cuda; |  | 40379 | using namespace cv::cuda;
| 40428 |  |  | 40380 |
| 40429 |  |  | 40381 |
| 40430 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40382 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40431 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40383 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40432 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40384 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40433 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40385 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40434 | int retval; |  | 40386 | int retval;
| 40435 |  |  | 40387 |
| 40436 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40388 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40437 | { |  | 40389 | {
| 40438 | ERRWRAP2(retval = _self_->multiProcessorCount()); |  | 40390 | ERRWRAP2(retval = _self_->multiProcessorCount());
| 40439 | return pyopencv_from(retval); |  | 40391 | return pyopencv_from(retval);
| 40440 | } |  | 40392 | }
| 40441 |  |  | 40393 |
| 40442 | return NULL; |  | 40394 | return NULL;
| 40443 | } |  | 40395 | }
| 40444 |  |  | 40396 |
| 40445 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_pciBusID(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40397 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_pciBusID(PyObject* self, PyObject* py_args, PyObject* kw)
| 40446 | { |  | 40398 | {
| 40447 | using namespace cv::cuda; |  | 40399 | using namespace cv::cuda;
| 40448 |  |  | 40400 |
| 40449 |  |  | 40401 |
| 40450 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40402 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40451 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40403 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40452 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40404 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40453 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40405 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40454 | int retval; |  | 40406 | int retval;
| 40455 |  |  | 40407 |
| 40456 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40408 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40457 | { |  | 40409 | {
| 40458 | ERRWRAP2(retval = _self_->pciBusID()); |  | 40410 | ERRWRAP2(retval = _self_->pciBusID());
| 40459 | return pyopencv_from(retval); |  | 40411 | return pyopencv_from(retval);
| 40460 | } |  | 40412 | }
| 40461 |  |  | 40413 |
| 40462 | return NULL; |  | 40414 | return NULL;
| 40463 | } |  | 40415 | }
| 40464 |  |  | 40416 |
| 40465 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_pciDeviceID(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40417 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_pciDeviceID(PyObject* self, PyObject* py_args, PyObject* kw)
| 40466 | { |  | 40418 | {
| 40467 | using namespace cv::cuda; |  | 40419 | using namespace cv::cuda;
| 40468 |  |  | 40420 |
| 40469 |  |  | 40421 |
| 40470 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40422 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40471 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40423 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40472 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40424 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40473 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40425 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40474 | int retval; |  | 40426 | int retval;
| 40475 |  |  | 40427 |
| 40476 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40428 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40477 | { |  | 40429 | {
| 40478 | ERRWRAP2(retval = _self_->pciDeviceID()); |  | 40430 | ERRWRAP2(retval = _self_->pciDeviceID());
| 40479 | return pyopencv_from(retval); |  | 40431 | return pyopencv_from(retval);
| 40480 | } |  | 40432 | }
| 40481 |  |  | 40433 |
| 40482 | return NULL; |  | 40434 | return NULL;
| 40483 | } |  | 40435 | }
| 40484 |  |  | 40436 |
| 40485 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_pciDomainID(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40437 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_pciDomainID(PyObject* self, PyObject* py_args, PyObject* kw)
| 40486 | { |  | 40438 | {
| 40487 | using namespace cv::cuda; |  | 40439 | using namespace cv::cuda;
| 40488 |  |  | 40440 |
| 40489 |  |  | 40441 |
| 40490 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40442 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40491 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40443 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40492 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40444 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40493 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40445 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40494 | int retval; |  | 40446 | int retval;
| 40495 |  |  | 40447 |
| 40496 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40448 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40497 | { |  | 40449 | {
| 40498 | ERRWRAP2(retval = _self_->pciDomainID()); |  | 40450 | ERRWRAP2(retval = _self_->pciDomainID());
| 40499 | return pyopencv_from(retval); |  | 40451 | return pyopencv_from(retval);
| 40500 | } |  | 40452 | }
| 40501 |  |  | 40453 |
| 40502 | return NULL; |  | 40454 | return NULL;
| 40503 | } |  | 40455 | }
| 40504 |  |  | 40456 |
| 40505 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_queryMemory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40457 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_queryMemory(PyObject* self, PyObject* py_args, PyObject* kw)
| 40506 | { |  | 40458 | {
| 40507 | using namespace cv::cuda; |  | 40459 | using namespace cv::cuda;
| 40508 |  |  | 40460 |
| 40509 |  |  | 40461 |
| 40510 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40462 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40511 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40463 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40512 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40464 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40513 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40465 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40514 | PyObject* pyobj_totalMemory = NULL; |  | 40466 | PyObject* pyobj_totalMemory = NULL;
| 40515 | size_t totalMemory=0; |  | 40467 | size_t totalMemory=0;
| 40516 | PyObject* pyobj_freeMemory = NULL; |  | 40468 | PyObject* pyobj_freeMemory = NULL;
| 40517 | size_t freeMemory=0; |  | 40469 | size_t freeMemory=0;
| 40518 |  |  | 40470 |
| 40519 | const char* keywords[] = { "totalMemory", "freeMemory", NULL }; |  | 40471 | const char* keywords[] = { "totalMemory", "freeMemory", NULL };
| 40520 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_DeviceInfo.queryMemory", (char**)keywords, &pyobj_totalMemory, &pyobj_freeMemory) && |  | 40472 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_DeviceInfo.queryMemory", (char**)keywords, &pyobj_totalMemory, &pyobj_freeMemory) &&
| 40521 | pyopencv_to_safe(pyobj_totalMemory, totalMemory, ArgInfo("totalMemory", 0)) && |  | 40473 | pyopencv_to_safe(pyobj_totalMemory, totalMemory, ArgInfo("totalMemory", 0)) &&
| 40522 | pyopencv_to_safe(pyobj_freeMemory, freeMemory, ArgInfo("freeMemory", 0)) ) |  | 40474 | pyopencv_to_safe(pyobj_freeMemory, freeMemory, ArgInfo("freeMemory", 0)) )
| 40523 | { |  | 40475 | {
| 40524 | ERRWRAP2(_self_->queryMemory(totalMemory, freeMemory)); |  | 40476 | ERRWRAP2(_self_->queryMemory(totalMemory, freeMemory));
| 40525 | Py_RETURN_NONE; |  | 40477 | Py_RETURN_NONE;
| 40526 | } |  | 40478 | }
| 40527 |  |  | 40479 |
| 40528 | return NULL; |  | 40480 | return NULL;
| 40529 | } |  | 40481 | }
| 40530 |  |  | 40482 |
| 40531 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_regsPerBlock(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40483 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_regsPerBlock(PyObject* self, PyObject* py_args, PyObject* kw)
| 40532 | { |  | 40484 | {
| 40533 | using namespace cv::cuda; |  | 40485 | using namespace cv::cuda;
| 40534 |  |  | 40486 |
| 40535 |  |  | 40487 |
| 40536 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40488 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40537 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40489 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40538 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40490 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40539 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40491 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40540 | int retval; |  | 40492 | int retval;
| 40541 |  |  | 40493 |
| 40542 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40494 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40543 | { |  | 40495 | {
| 40544 | ERRWRAP2(retval = _self_->regsPerBlock()); |  | 40496 | ERRWRAP2(retval = _self_->regsPerBlock());
| 40545 | return pyopencv_from(retval); |  | 40497 | return pyopencv_from(retval);
| 40546 | } |  | 40498 | }
| 40547 |  |  | 40499 |
| 40548 | return NULL; |  | 40500 | return NULL;
| 40549 | } |  | 40501 | }
| 40550 |  |  | 40502 |
| 40551 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_sharedMemPerBlock(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40503 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_sharedMemPerBlock(PyObject* self, PyObject* py_args, PyObject* kw)
| 40552 | { |  | 40504 | {
| 40553 | using namespace cv::cuda; |  | 40505 | using namespace cv::cuda;
| 40554 |  |  | 40506 |
| 40555 |  |  | 40507 |
| 40556 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40508 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40557 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40509 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40558 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40510 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40559 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40511 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40560 | size_t retval; |  | 40512 | size_t retval;
| 40561 |  |  | 40513 |
| 40562 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40514 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40563 | { |  | 40515 | {
| 40564 | ERRWRAP2(retval = _self_->sharedMemPerBlock()); |  | 40516 | ERRWRAP2(retval = _self_->sharedMemPerBlock());
| 40565 | return pyopencv_from(retval); |  | 40517 | return pyopencv_from(retval);
| 40566 | } |  | 40518 | }
| 40567 |  |  | 40519 |
| 40568 | return NULL; |  | 40520 | return NULL;
| 40569 | } |  | 40521 | }
| 40570 |  |  | 40522 |
| 40571 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_surfaceAlignment(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40523 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_surfaceAlignment(PyObject* self, PyObject* py_args, PyObject* kw)
| 40572 | { |  | 40524 | {
| 40573 | using namespace cv::cuda; |  | 40525 | using namespace cv::cuda;
| 40574 |  |  | 40526 |
| 40575 |  |  | 40527 |
| 40576 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40528 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40577 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40529 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40578 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40530 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40579 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40531 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40580 | size_t retval; |  | 40532 | size_t retval;
| 40581 |  |  | 40533 |
| 40582 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40534 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40583 | { |  | 40535 | {
| 40584 | ERRWRAP2(retval = _self_->surfaceAlignment()); |  | 40536 | ERRWRAP2(retval = _self_->surfaceAlignment());
| 40585 | return pyopencv_from(retval); |  | 40537 | return pyopencv_from(retval);
| 40586 | } |  | 40538 | }
| 40587 |  |  | 40539 |
| 40588 | return NULL; |  | 40540 | return NULL;
| 40589 | } |  | 40541 | }
| 40590 |  |  | 40542 |
| 40591 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_tccDriver(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40543 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_tccDriver(PyObject* self, PyObject* py_args, PyObject* kw)
| 40592 | { |  | 40544 | {
| 40593 | using namespace cv::cuda; |  | 40545 | using namespace cv::cuda;
| 40594 |  |  | 40546 |
| 40595 |  |  | 40547 |
| 40596 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40548 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40597 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40549 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40598 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40550 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40599 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40551 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40600 | bool retval; |  | 40552 | bool retval;
| 40601 |  |  | 40553 |
| 40602 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40554 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40603 | { |  | 40555 | {
| 40604 | ERRWRAP2(retval = _self_->tccDriver()); |  | 40556 | ERRWRAP2(retval = _self_->tccDriver());
| 40605 | return pyopencv_from(retval); |  | 40557 | return pyopencv_from(retval);
| 40606 | } |  | 40558 | }
| 40607 |  |  | 40559 |
| 40608 | return NULL; |  | 40560 | return NULL;
| 40609 | } |  | 40561 | }
| 40610 |  |  | 40562 |
| 40611 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_textureAlignment(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40563 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_textureAlignment(PyObject* self, PyObject* py_args, PyObject* kw)
| 40612 | { |  | 40564 | {
| 40613 | using namespace cv::cuda; |  | 40565 | using namespace cv::cuda;
| 40614 |  |  | 40566 |
| 40615 |  |  | 40567 |
| 40616 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40568 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40617 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40569 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40618 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40570 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40619 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40571 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40620 | size_t retval; |  | 40572 | size_t retval;
| 40621 |  |  | 40573 |
| 40622 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40574 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40623 | { |  | 40575 | {
| 40624 | ERRWRAP2(retval = _self_->textureAlignment()); |  | 40576 | ERRWRAP2(retval = _self_->textureAlignment());
| 40625 | return pyopencv_from(retval); |  | 40577 | return pyopencv_from(retval);
| 40626 | } |  | 40578 | }
| 40627 |  |  | 40579 |
| 40628 | return NULL; |  | 40580 | return NULL;
| 40629 | } |  | 40581 | }
| 40630 |  |  | 40582 |
| 40631 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_texturePitchAlignment(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40583 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_texturePitchAlignment(PyObject* self, PyObject* py_args, PyObject* kw)
| 40632 | { |  | 40584 | {
| 40633 | using namespace cv::cuda; |  | 40585 | using namespace cv::cuda;
| 40634 |  |  | 40586 |
| 40635 |  |  | 40587 |
| 40636 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40588 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40637 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40589 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40638 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40590 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40639 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40591 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40640 | size_t retval; |  | 40592 | size_t retval;
| 40641 |  |  | 40593 |
| 40642 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40594 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40643 | { |  | 40595 | {
| 40644 | ERRWRAP2(retval = _self_->texturePitchAlignment()); |  | 40596 | ERRWRAP2(retval = _self_->texturePitchAlignment());
| 40645 | return pyopencv_from(retval); |  | 40597 | return pyopencv_from(retval);
| 40646 | } |  | 40598 | }
| 40647 |  |  | 40599 |
| 40648 | return NULL; |  | 40600 | return NULL;
| 40649 | } |  | 40601 | }
| 40650 |  |  | 40602 |
| 40651 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_totalConstMem(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40603 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_totalConstMem(PyObject* self, PyObject* py_args, PyObject* kw)
| 40652 | { |  | 40604 | {
| 40653 | using namespace cv::cuda; |  | 40605 | using namespace cv::cuda;
| 40654 |  |  | 40606 |
| 40655 |  |  | 40607 |
| 40656 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40608 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40657 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40609 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40658 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40610 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40659 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40611 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40660 | size_t retval; |  | 40612 | size_t retval;
| 40661 |  |  | 40613 |
| 40662 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40614 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40663 | { |  | 40615 | {
| 40664 | ERRWRAP2(retval = _self_->totalConstMem()); |  | 40616 | ERRWRAP2(retval = _self_->totalConstMem());
| 40665 | return pyopencv_from(retval); |  | 40617 | return pyopencv_from(retval);
| 40666 | } |  | 40618 | }
| 40667 |  |  | 40619 |
| 40668 | return NULL; |  | 40620 | return NULL;
| 40669 | } |  | 40621 | }
| 40670 |  |  | 40622 |
| 40671 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_totalGlobalMem(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40623 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_totalGlobalMem(PyObject* self, PyObject* py_args, PyObject* kw)
| 40672 | { |  | 40624 | {
| 40673 | using namespace cv::cuda; |  | 40625 | using namespace cv::cuda;
| 40674 |  |  | 40626 |
| 40675 |  |  | 40627 |
| 40676 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40628 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40677 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40629 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40678 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40630 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40679 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40631 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40680 | size_t retval; |  | 40632 | size_t retval;
| 40681 |  |  | 40633 |
| 40682 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40634 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40683 | { |  | 40635 | {
| 40684 | ERRWRAP2(retval = _self_->totalGlobalMem()); |  | 40636 | ERRWRAP2(retval = _self_->totalGlobalMem());
| 40685 | return pyopencv_from(retval); |  | 40637 | return pyopencv_from(retval);
| 40686 | } |  | 40638 | }
| 40687 |  |  | 40639 |
| 40688 | return NULL; |  | 40640 | return NULL;
| 40689 | } |  | 40641 | }
| 40690 |  |  | 40642 |
| 40691 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_totalMemory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40643 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_totalMemory(PyObject* self, PyObject* py_args, PyObject* kw)
| 40692 | { |  | 40644 | {
| 40693 | using namespace cv::cuda; |  | 40645 | using namespace cv::cuda;
| 40694 |  |  | 40646 |
| 40695 |  |  | 40647 |
| 40696 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40648 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40697 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40649 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40698 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40650 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40699 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40651 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40700 | size_t retval; |  | 40652 | size_t retval;
| 40701 |  |  | 40653 |
| 40702 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40654 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40703 | { |  | 40655 | {
| 40704 | ERRWRAP2(retval = _self_->totalMemory()); |  | 40656 | ERRWRAP2(retval = _self_->totalMemory());
| 40705 | return pyopencv_from(retval); |  | 40657 | return pyopencv_from(retval);
| 40706 | } |  | 40658 | }
| 40707 |  |  | 40659 |
| 40708 | return NULL; |  | 40660 | return NULL;
| 40709 | } |  | 40661 | }
| 40710 |  |  | 40662 |
| 40711 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_unifiedAddressing(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40663 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_unifiedAddressing(PyObject* self, PyObject* py_args, PyObject* kw)
| 40712 | { |  | 40664 | {
| 40713 | using namespace cv::cuda; |  | 40665 | using namespace cv::cuda;
| 40714 |  |  | 40666 |
| 40715 |  |  | 40667 |
| 40716 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40668 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40717 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40669 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40718 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40670 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40719 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40671 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40720 | bool retval; |  | 40672 | bool retval;
| 40721 |  |  | 40673 |
| 40722 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40674 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40723 | { |  | 40675 | {
| 40724 | ERRWRAP2(retval = _self_->unifiedAddressing()); |  | 40676 | ERRWRAP2(retval = _self_->unifiedAddressing());
| 40725 | return pyopencv_from(retval); |  | 40677 | return pyopencv_from(retval);
| 40726 | } |  | 40678 | }
| 40727 |  |  | 40679 |
| 40728 | return NULL; |  | 40680 | return NULL;
| 40729 | } |  | 40681 | }
| 40730 |  |  | 40682 |
| 40731 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_warpSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40683 | static PyObject* pyopencv_cv_cuda_cuda_DeviceInfo_warpSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 40732 | { |  | 40684 | {
| 40733 | using namespace cv::cuda; |  | 40685 | using namespace cv::cuda;
| 40734 |  |  | 40686 |
| 40735 |  |  | 40687 |
| 40736 | Ptr<cv::cuda::DeviceInfo> * self1 = 0; |  | 40688 | Ptr<cv::cuda::DeviceInfo> * self1 = 0;
| 40737 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1)) |  | 40689 | if (!pyopencv_cuda_DeviceInfo_getp(self, self1))
| 40738 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)"); |  | 40690 | return failmsgp("Incorrect type of self (must be 'cuda_DeviceInfo' or its derivative)");
| 40739 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1); |  | 40691 | Ptr<cv::cuda::DeviceInfo> _self_ = *(self1);
| 40740 | int retval; |  | 40692 | int retval;
| 40741 |  |  | 40693 |
| 40742 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40694 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40743 | { |  | 40695 | {
| 40744 | ERRWRAP2(retval = _self_->warpSize()); |  | 40696 | ERRWRAP2(retval = _self_->warpSize());
| 40745 | return pyopencv_from(retval); |  | 40697 | return pyopencv_from(retval);
| 40746 | } |  | 40698 | }
| 40747 |  |  | 40699 |
| 40748 | return NULL; |  | 40700 | return NULL;
| 40749 | } |  | 40701 | }
| 40750 |  |  | 40702 |
| 40751 |  |  | 40703 |
| 40752 |  |  | 40704 |
| 40753 | // Tables (cuda_DeviceInfo) |  | 40705 | // Tables (cuda_DeviceInfo)
| 40754 |  |  | 40706 |
| 40755 | static PyGetSetDef pyopencv_cuda_DeviceInfo_getseters[] = |  | 40707 | static PyGetSetDef pyopencv_cuda_DeviceInfo_getseters[] =
| 40756 | { |  | 40708 | {
| 40757 | {NULL} /* Sentinel */ |  | 40709 | {NULL} /* Sentinel */
| 40758 | }; |  | 40710 | };
| 40759 |  |  | 40711 |
| 40760 | static PyMethodDef pyopencv_cuda_DeviceInfo_methods[] = |  | 40712 | static PyMethodDef pyopencv_cuda_DeviceInfo_methods[] =
| 40761 | { |  | 40713 | {
| 40762 | {"ECCEnabled", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_ECCEnabled, 0), "ECCEnabled() -> retval\n."}, |  | 40714 | {"ECCEnabled", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_ECCEnabled, 0), "ECCEnabled() -> retval\n."},
| 40763 | {"asyncEngineCount", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_asyncEngineCount, 0), "asyncEngineCount() -> retval\n."}, |  | 40715 | {"asyncEngineCount", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_asyncEngineCount, 0), "asyncEngineCount() -> retval\n."},
| 40764 | {"canMapHostMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_canMapHostMemory, 0), "canMapHostMemory() -> retval\n."}, |  | 40716 | {"canMapHostMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_canMapHostMemory, 0), "canMapHostMemory() -> retval\n."},
| 40765 | {"clockRate", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_clockRate, 0), "clockRate() -> retval\n."}, |  | 40717 | {"clockRate", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_clockRate, 0), "clockRate() -> retval\n."},
| 40766 | {"computeMode", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_computeMode, 0), "computeMode() -> retval\n."}, |  | 40718 | {"computeMode", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_computeMode, 0), "computeMode() -> retval\n."},
| 40767 | {"concurrentKernels", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_concurrentKernels, 0), "concurrentKernels() -> retval\n."}, |  | 40719 | {"concurrentKernels", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_concurrentKernels, 0), "concurrentKernels() -> retval\n."},
| 40768 | {"deviceID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_deviceID, 0), "deviceID() -> retval\n. @brief Returns system index of the CUDA device starting with 0."}, |  | 40720 | {"deviceID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_deviceID, 0), "deviceID() -> retval\n. @brief Returns system index of the CUDA device starting with 0."},
| 40769 | {"freeMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_freeMemory, 0), "freeMemory() -> retval\n."}, |  | 40721 | {"freeMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_freeMemory, 0), "freeMemory() -> retval\n."},
| 40770 | {"integrated", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_integrated, 0), "integrated() -> retval\n."}, |  | 40722 | {"integrated", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_integrated, 0), "integrated() -> retval\n."},
| 40771 | {"isCompatible", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_isCompatible, 0), "isCompatible() -> retval\n. @brief Checks the CUDA module and device compatibility.\n. \n. This function returns true if the CUDA module can be run on the specified device. Otherwise, it\n. returns false ."}, |  | 40723 | {"isCompatible", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_isCompatible, 0), "isCompatible() -> retval\n. @brief Checks the CUDA module and device compatibility.\n. \n. This function returns true if the CUDA module can be run on the specified device. Otherwise, it\n. returns false ."},
| 40772 | {"kernelExecTimeoutEnabled", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_kernelExecTimeoutEnabled, 0), "kernelExecTimeoutEnabled() -> retval\n."}, |  | 40724 | {"kernelExecTimeoutEnabled", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_kernelExecTimeoutEnabled, 0), "kernelExecTimeoutEnabled() -> retval\n."},
| 40773 | {"l2CacheSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_l2CacheSize, 0), "l2CacheSize() -> retval\n."}, |  | 40725 | {"l2CacheSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_l2CacheSize, 0), "l2CacheSize() -> retval\n."},
| 40774 | {"majorVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_majorVersion, 0), "majorVersion() -> retval\n."}, |  | 40726 | {"majorVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_majorVersion, 0), "majorVersion() -> retval\n."},
| 40775 | {"maxGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxGridSize, 0), "maxGridSize() -> retval\n."}, |  | 40727 | {"maxGridSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxGridSize, 0), "maxGridSize() -> retval\n."},
| 40776 | {"maxSurface1D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1D, 0), "maxSurface1D() -> retval\n."}, |  | 40728 | {"maxSurface1D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1D, 0), "maxSurface1D() -> retval\n."},
| 40777 | {"maxSurface1DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1DLayered, 0), "maxSurface1DLayered() -> retval\n."}, |  | 40729 | {"maxSurface1DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface1DLayered, 0), "maxSurface1DLayered() -> retval\n."},
| 40778 | {"maxSurface2D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2D, 0), "maxSurface2D() -> retval\n."}, |  | 40730 | {"maxSurface2D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2D, 0), "maxSurface2D() -> retval\n."},
| 40779 | {"maxSurface2DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2DLayered, 0), "maxSurface2DLayered() -> retval\n."}, |  | 40731 | {"maxSurface2DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface2DLayered, 0), "maxSurface2DLayered() -> retval\n."},
| 40780 | {"maxSurface3D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface3D, 0), "maxSurface3D() -> retval\n."}, |  | 40732 | {"maxSurface3D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurface3D, 0), "maxSurface3D() -> retval\n."},
| 40781 | {"maxSurfaceCubemap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemap, 0), "maxSurfaceCubemap() -> retval\n."}, |  | 40733 | {"maxSurfaceCubemap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemap, 0), "maxSurfaceCubemap() -> retval\n."},
| 40782 | {"maxSurfaceCubemapLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemapLayered, 0), "maxSurfaceCubemapLayered() -> retval\n."}, |  | 40734 | {"maxSurfaceCubemapLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxSurfaceCubemapLayered, 0), "maxSurfaceCubemapLayered() -> retval\n."},
| 40783 | {"maxTexture1D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1D, 0), "maxTexture1D() -> retval\n."}, |  | 40735 | {"maxTexture1D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1D, 0), "maxTexture1D() -> retval\n."},
| 40784 | {"maxTexture1DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLayered, 0), "maxTexture1DLayered() -> retval\n."}, |  | 40736 | {"maxTexture1DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLayered, 0), "maxTexture1DLayered() -> retval\n."},
| 40785 | {"maxTexture1DLinear", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLinear, 0), "maxTexture1DLinear() -> retval\n."}, |  | 40737 | {"maxTexture1DLinear", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DLinear, 0), "maxTexture1DLinear() -> retval\n."},
| 40786 | {"maxTexture1DMipmap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DMipmap, 0), "maxTexture1DMipmap() -> retval\n."}, |  | 40738 | {"maxTexture1DMipmap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture1DMipmap, 0), "maxTexture1DMipmap() -> retval\n."},
| 40787 | {"maxTexture2D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2D, 0), "maxTexture2D() -> retval\n."}, |  | 40739 | {"maxTexture2D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2D, 0), "maxTexture2D() -> retval\n."},
| 40788 | {"maxTexture2DGather", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DGather, 0), "maxTexture2DGather() -> retval\n."}, |  | 40740 | {"maxTexture2DGather", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DGather, 0), "maxTexture2DGather() -> retval\n."},
| 40789 | {"maxTexture2DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLayered, 0), "maxTexture2DLayered() -> retval\n."}, |  | 40741 | {"maxTexture2DLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLayered, 0), "maxTexture2DLayered() -> retval\n."},
| 40790 | {"maxTexture2DLinear", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLinear, 0), "maxTexture2DLinear() -> retval\n."}, |  | 40742 | {"maxTexture2DLinear", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DLinear, 0), "maxTexture2DLinear() -> retval\n."},
| 40791 | {"maxTexture2DMipmap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DMipmap, 0), "maxTexture2DMipmap() -> retval\n."}, |  | 40743 | {"maxTexture2DMipmap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture2DMipmap, 0), "maxTexture2DMipmap() -> retval\n."},
| 40792 | {"maxTexture3D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture3D, 0), "maxTexture3D() -> retval\n."}, |  | 40744 | {"maxTexture3D", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTexture3D, 0), "maxTexture3D() -> retval\n."},
| 40793 | {"maxTextureCubemap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemap, 0), "maxTextureCubemap() -> retval\n."}, |  | 40745 | {"maxTextureCubemap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemap, 0), "maxTextureCubemap() -> retval\n."},
| 40794 | {"maxTextureCubemapLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemapLayered, 0), "maxTextureCubemapLayered() -> retval\n."}, |  | 40746 | {"maxTextureCubemapLayered", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxTextureCubemapLayered, 0), "maxTextureCubemapLayered() -> retval\n."},
| 40795 | {"maxThreadsDim", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsDim, 0), "maxThreadsDim() -> retval\n."}, |  | 40747 | {"maxThreadsDim", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsDim, 0), "maxThreadsDim() -> retval\n."},
| 40796 | {"maxThreadsPerBlock", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerBlock, 0), "maxThreadsPerBlock() -> retval\n."}, |  | 40748 | {"maxThreadsPerBlock", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerBlock, 0), "maxThreadsPerBlock() -> retval\n."},
| 40797 | {"maxThreadsPerMultiProcessor", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerMultiProcessor, 0), "maxThreadsPerMultiProcessor() -> retval\n."}, |  | 40749 | {"maxThreadsPerMultiProcessor", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_maxThreadsPerMultiProcessor, 0), "maxThreadsPerMultiProcessor() -> retval\n."},
| 40798 | {"memPitch", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_memPitch, 0), "memPitch() -> retval\n."}, |  | 40750 | {"memPitch", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_memPitch, 0), "memPitch() -> retval\n."},
| 40799 | {"memoryBusWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_memoryBusWidth, 0), "memoryBusWidth() -> retval\n."}, |  | 40751 | {"memoryBusWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_memoryBusWidth, 0), "memoryBusWidth() -> retval\n."},
| 40800 | {"memoryClockRate", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_memoryClockRate, 0), "memoryClockRate() -> retval\n."}, |  | 40752 | {"memoryClockRate", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_memoryClockRate, 0), "memoryClockRate() -> retval\n."},
| 40801 | {"minorVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_minorVersion, 0), "minorVersion() -> retval\n."}, |  | 40753 | {"minorVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_minorVersion, 0), "minorVersion() -> retval\n."},
| 40802 | {"multiProcessorCount", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_multiProcessorCount, 0), "multiProcessorCount() -> retval\n."}, |  | 40754 | {"multiProcessorCount", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_multiProcessorCount, 0), "multiProcessorCount() -> retval\n."},
| 40803 | {"pciBusID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_pciBusID, 0), "pciBusID() -> retval\n."}, |  | 40755 | {"pciBusID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_pciBusID, 0), "pciBusID() -> retval\n."},
| 40804 | {"pciDeviceID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_pciDeviceID, 0), "pciDeviceID() -> retval\n."}, |  | 40756 | {"pciDeviceID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_pciDeviceID, 0), "pciDeviceID() -> retval\n."},
| 40805 | {"pciDomainID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_pciDomainID, 0), "pciDomainID() -> retval\n."}, |  | 40757 | {"pciDomainID", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_pciDomainID, 0), "pciDomainID() -> retval\n."},
| 40806 | {"queryMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_queryMemory, 0), "queryMemory(totalMemory, freeMemory) -> None\n."}, |  | 40758 | {"queryMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_queryMemory, 0), "queryMemory(totalMemory, freeMemory) -> None\n."},
| 40807 | {"regsPerBlock", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_regsPerBlock, 0), "regsPerBlock() -> retval\n."}, |  | 40759 | {"regsPerBlock", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_regsPerBlock, 0), "regsPerBlock() -> retval\n."},
| 40808 | {"sharedMemPerBlock", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_sharedMemPerBlock, 0), "sharedMemPerBlock() -> retval\n."}, |  | 40760 | {"sharedMemPerBlock", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_sharedMemPerBlock, 0), "sharedMemPerBlock() -> retval\n."},
| 40809 | {"surfaceAlignment", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_surfaceAlignment, 0), "surfaceAlignment() -> retval\n."}, |  | 40761 | {"surfaceAlignment", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_surfaceAlignment, 0), "surfaceAlignment() -> retval\n."},
| 40810 | {"tccDriver", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_tccDriver, 0), "tccDriver() -> retval\n."}, |  | 40762 | {"tccDriver", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_tccDriver, 0), "tccDriver() -> retval\n."},
| 40811 | {"textureAlignment", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_textureAlignment, 0), "textureAlignment() -> retval\n."}, |  | 40763 | {"textureAlignment", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_textureAlignment, 0), "textureAlignment() -> retval\n."},
| 40812 | {"texturePitchAlignment", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_texturePitchAlignment, 0), "texturePitchAlignment() -> retval\n."}, |  | 40764 | {"texturePitchAlignment", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_texturePitchAlignment, 0), "texturePitchAlignment() -> retval\n."},
| 40813 | {"totalConstMem", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_totalConstMem, 0), "totalConstMem() -> retval\n."}, |  | 40765 | {"totalConstMem", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_totalConstMem, 0), "totalConstMem() -> retval\n."},
| 40814 | {"totalGlobalMem", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_totalGlobalMem, 0), "totalGlobalMem() -> retval\n."}, |  | 40766 | {"totalGlobalMem", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_totalGlobalMem, 0), "totalGlobalMem() -> retval\n."},
| 40815 | {"totalMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_totalMemory, 0), "totalMemory() -> retval\n."}, |  | 40767 | {"totalMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_totalMemory, 0), "totalMemory() -> retval\n."},
| 40816 | {"unifiedAddressing", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_unifiedAddressing, 0), "unifiedAddressing() -> retval\n."}, |  | 40768 | {"unifiedAddressing", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_unifiedAddressing, 0), "unifiedAddressing() -> retval\n."},
| 40817 | {"warpSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_warpSize, 0), "warpSize() -> retval\n."}, |  | 40769 | {"warpSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_DeviceInfo_warpSize, 0), "warpSize() -> retval\n."},
| 40818 |  |  | 40770 |
| 40819 | {NULL, NULL} |  | 40771 | {NULL, NULL}
| 40820 | }; |  | 40772 | };
| 40821 |  |  | 40773 |
| 40822 | // Converter (cuda_DeviceInfo) |  | 40774 | // Converter (cuda_DeviceInfo)
| 40823 |  |  | 40775 |
| 40824 | template<> |  | 40776 | template<>
| 40825 | struct PyOpenCV_Converter< Ptr<cv::cuda::DeviceInfo> > |  | 40777 | struct PyOpenCV_Converter< Ptr<cv::cuda::DeviceInfo> >
| 40826 | { |  | 40778 | {
| 40827 | static PyObject* from(const Ptr<cv::cuda::DeviceInfo>& r) |  | 40779 | static PyObject* from(const Ptr<cv::cuda::DeviceInfo>& r)
| 40828 | { |  | 40780 | {
| 40829 | return pyopencv_cuda_DeviceInfo_Instance(r); |  | 40781 | return pyopencv_cuda_DeviceInfo_Instance(r);
| 40830 | } |  | 40782 | }
| 40831 | static bool to(PyObject* src, Ptr<cv::cuda::DeviceInfo>& dst, const ArgInfo& info) |  | 40783 | static bool to(PyObject* src, Ptr<cv::cuda::DeviceInfo>& dst, const ArgInfo& info)
| 40832 | { |  | 40784 | {
| 40833 | if(!src || src == Py_None) |  | 40785 | if(!src || src == Py_None)
| 40834 | return true; |  | 40786 | return true;
| 40835 | Ptr<cv::cuda::DeviceInfo> * dst_; |  | 40787 | Ptr<cv::cuda::DeviceInfo> * dst_;
| 40836 | if (pyopencv_cuda_DeviceInfo_getp(src, dst_)) |  | 40788 | if (pyopencv_cuda_DeviceInfo_getp(src, dst_))
| 40837 | { |  | 40789 | {
| 40838 | dst = *dst_; |  | 40790 | dst = *dst_;
| 40839 | return true; |  | 40791 | return true;
| 40840 | } |  | 40792 | }
| 40841 |  |  | 40793 |
| 40842 | failmsg("Expected Ptr<cv::cuda::DeviceInfo> for argument '%s'", info.name); |  | 40794 | failmsg("Expected Ptr<cv::cuda::DeviceInfo> for argument '%s'", info.name);
| 40843 | return false; |  | 40795 | return false;
| 40844 | } |  | 40796 | }
| 40845 | }; |  | 40797 | };
| 40846 |  |  | 40798 |
| 40847 | //================================================================================ |  | 40799 | //================================================================================
| 40848 | // cuda_Event (Generic) |  | 40800 | // cuda_Event (Generic)
| 40849 | //================================================================================ |  | 40801 | //================================================================================
| 40850 |  |  | 40802 |
| 40851 | // GetSet (cuda_Event) |  | 40803 | // GetSet (cuda_Event)
| 40852 |  |  | 40804 |
| 40853 |  |  | 40805 |
| 40854 |  |  | 40806 |
| 40855 | // Methods (cuda_Event) |  | 40807 | // Methods (cuda_Event)
| 40856 |  |  | 40808 |
| 40857 | static int pyopencv_cv_cuda_cuda_Event_Event(pyopencv_cuda_Event_t* self, PyObject* py_args, PyObject* kw) |  | 40809 | static int pyopencv_cv_cuda_cuda_Event_Event(pyopencv_cuda_Event_t* self, PyObject* py_args, PyObject* kw)
| 40858 | { |  | 40810 | {
| 40859 | using namespace cv::cuda; |  | 40811 | using namespace cv::cuda;
| 40860 |  |  | 40812 |
| 40861 | PyObject* pyobj_flags = NULL; |  | 40813 | PyObject* pyobj_flags = NULL;
| 40862 | Event_CreateFlags flags=Event::CreateFlags::DEFAULT; |  | 40814 | Event_CreateFlags flags=Event::CreateFlags::DEFAULT;
| 40863 |  |  | 40815 |
| 40864 | const char* keywords[] = { "flags", NULL }; |  | 40816 | const char* keywords[] = { "flags", NULL };
| 40865 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Event", (char**)keywords, &pyobj_flags) && |  | 40817 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:Event", (char**)keywords, &pyobj_flags) &&
| 40866 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 40818 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 40867 | { |  | 40819 | {
| 40868 | new (&(self->v)) Ptr<cv::cuda::Event>(); // init Ptr with placement new |  | 40820 | new (&(self->v)) Ptr<cv::cuda::Event>(); // init Ptr with placement new
| 40869 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Event(flags))); |  | 40821 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Event(flags)));
| 40870 | return 0; |  | 40822 | return 0;
| 40871 | } |  | 40823 | }
| 40872 |  |  | 40824 |
| 40873 | return -1; |  | 40825 | return -1;
| 40874 | } |  | 40826 | }
| 40875 |  |  | 40827 |
| 40876 | static PyObject* pyopencv_cv_cuda_cuda_Event_elapsedTime_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40828 | static PyObject* pyopencv_cv_cuda_cuda_Event_elapsedTime_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 40877 | { |  | 40829 | {
| 40878 | using namespace cv::cuda; |  | 40830 | using namespace cv::cuda;
| 40879 |  |  | 40831 |
| 40880 | PyObject* pyobj_start = NULL; |  | 40832 | PyObject* pyobj_start = NULL;
| 40881 | Event start; |  | 40833 | Event start;
| 40882 | PyObject* pyobj_end = NULL; |  | 40834 | PyObject* pyobj_end = NULL;
| 40883 | Event end; |  | 40835 | Event end;
| 40884 | float retval; |  | 40836 | float retval;
| 40885 |  |  | 40837 |
| 40886 | const char* keywords[] = { "start", "end", NULL }; |  | 40838 | const char* keywords[] = { "start", "end", NULL };
| 40887 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_Event.elapsedTime", (char**)keywords, &pyobj_start, &pyobj_end) && |  | 40839 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_Event.elapsedTime", (char**)keywords, &pyobj_start, &pyobj_end) &&
| 40888 | pyopencv_to_safe(pyobj_start, start, ArgInfo("start", 0)) && |  | 40840 | pyopencv_to_safe(pyobj_start, start, ArgInfo("start", 0)) &&
| 40889 | pyopencv_to_safe(pyobj_end, end, ArgInfo("end", 0)) ) |  | 40841 | pyopencv_to_safe(pyobj_end, end, ArgInfo("end", 0)) )
| 40890 | { |  | 40842 | {
| 40891 | ERRWRAP2(retval = cv::cuda::Event::elapsedTime(start, end)); |  | 40843 | ERRWRAP2(retval = cv::cuda::Event::elapsedTime(start, end));
| 40892 | return pyopencv_from(retval); |  | 40844 | return pyopencv_from(retval);
| 40893 | } |  | 40845 | }
| 40894 |  |  | 40846 |
| 40895 | return NULL; |  | 40847 | return NULL;
| 40896 | } |  | 40848 | }
| 40897 |  |  | 40849 |
| 40898 | static PyObject* pyopencv_cv_cuda_cuda_Event_queryIfComplete(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40850 | static PyObject* pyopencv_cv_cuda_cuda_Event_queryIfComplete(PyObject* self, PyObject* py_args, PyObject* kw)
| 40899 | { |  | 40851 | {
| 40900 | using namespace cv::cuda; |  | 40852 | using namespace cv::cuda;
| 40901 |  |  | 40853 |
| 40902 |  |  | 40854 |
| 40903 | Ptr<cv::cuda::Event> * self1 = 0; |  | 40855 | Ptr<cv::cuda::Event> * self1 = 0;
| 40904 | if (!pyopencv_cuda_Event_getp(self, self1)) |  | 40856 | if (!pyopencv_cuda_Event_getp(self, self1))
| 40905 | return failmsgp("Incorrect type of self (must be 'cuda_Event' or its derivative)"); |  | 40857 | return failmsgp("Incorrect type of self (must be 'cuda_Event' or its derivative)");
| 40906 | Ptr<cv::cuda::Event> _self_ = *(self1); |  | 40858 | Ptr<cv::cuda::Event> _self_ = *(self1);
| 40907 | bool retval; |  | 40859 | bool retval;
| 40908 |  |  | 40860 |
| 40909 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40861 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40910 | { |  | 40862 | {
| 40911 | ERRWRAP2(retval = _self_->queryIfComplete()); |  | 40863 | ERRWRAP2(retval = _self_->queryIfComplete());
| 40912 | return pyopencv_from(retval); |  | 40864 | return pyopencv_from(retval);
| 40913 | } |  | 40865 | }
| 40914 |  |  | 40866 |
| 40915 | return NULL; |  | 40867 | return NULL;
| 40916 | } |  | 40868 | }
| 40917 |  |  | 40869 |
| 40918 | static PyObject* pyopencv_cv_cuda_cuda_Event_record(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40870 | static PyObject* pyopencv_cv_cuda_cuda_Event_record(PyObject* self, PyObject* py_args, PyObject* kw)
| 40919 | { |  | 40871 | {
| 40920 | using namespace cv::cuda; |  | 40872 | using namespace cv::cuda;
| 40921 |  |  | 40873 |
| 40922 |  |  | 40874 |
| 40923 | Ptr<cv::cuda::Event> * self1 = 0; |  | 40875 | Ptr<cv::cuda::Event> * self1 = 0;
| 40924 | if (!pyopencv_cuda_Event_getp(self, self1)) |  | 40876 | if (!pyopencv_cuda_Event_getp(self, self1))
| 40925 | return failmsgp("Incorrect type of self (must be 'cuda_Event' or its derivative)"); |  | 40877 | return failmsgp("Incorrect type of self (must be 'cuda_Event' or its derivative)");
| 40926 | Ptr<cv::cuda::Event> _self_ = *(self1); |  | 40878 | Ptr<cv::cuda::Event> _self_ = *(self1);
| 40927 | PyObject* pyobj_stream = NULL; |  | 40879 | PyObject* pyobj_stream = NULL;
| 40928 | Stream stream=Stream::Null(); |  | 40880 | Stream stream=Stream::Null();
| 40929 |  |  | 40881 |
| 40930 | const char* keywords[] = { "stream", NULL }; |  | 40882 | const char* keywords[] = { "stream", NULL };
| 40931 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_Event.record", (char**)keywords, &pyobj_stream) && |  | 40883 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_Event.record", (char**)keywords, &pyobj_stream) &&
| 40932 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 40884 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 40933 | { |  | 40885 | {
| 40934 | ERRWRAP2(_self_->record(stream)); |  | 40886 | ERRWRAP2(_self_->record(stream));
| 40935 | Py_RETURN_NONE; |  | 40887 | Py_RETURN_NONE;
| 40936 | } |  | 40888 | }
| 40937 |  |  | 40889 |
| 40938 | return NULL; |  | 40890 | return NULL;
| 40939 | } |  | 40891 | }
| 40940 |  |  | 40892 |
| 40941 | static PyObject* pyopencv_cv_cuda_cuda_Event_waitForCompletion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 40893 | static PyObject* pyopencv_cv_cuda_cuda_Event_waitForCompletion(PyObject* self, PyObject* py_args, PyObject* kw)
| 40942 | { |  | 40894 | {
| 40943 | using namespace cv::cuda; |  | 40895 | using namespace cv::cuda;
| 40944 |  |  | 40896 |
| 40945 |  |  | 40897 |
| 40946 | Ptr<cv::cuda::Event> * self1 = 0; |  | 40898 | Ptr<cv::cuda::Event> * self1 = 0;
| 40947 | if (!pyopencv_cuda_Event_getp(self, self1)) |  | 40899 | if (!pyopencv_cuda_Event_getp(self, self1))
| 40948 | return failmsgp("Incorrect type of self (must be 'cuda_Event' or its derivative)"); |  | 40900 | return failmsgp("Incorrect type of self (must be 'cuda_Event' or its derivative)");
| 40949 | Ptr<cv::cuda::Event> _self_ = *(self1); |  | 40901 | Ptr<cv::cuda::Event> _self_ = *(self1);
| 40950 |  |  | 40902 |
| 40951 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 40903 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 40952 | { |  | 40904 | {
| 40953 | ERRWRAP2(_self_->waitForCompletion()); |  | 40905 | ERRWRAP2(_self_->waitForCompletion());
| 40954 | Py_RETURN_NONE; |  | 40906 | Py_RETURN_NONE;
| 40955 | } |  | 40907 | }
| 40956 |  |  | 40908 |
| 40957 | return NULL; |  | 40909 | return NULL;
| 40958 | } |  | 40910 | }
| 40959 |  |  | 40911 |
| 40960 |  |  | 40912 |
| 40961 |  |  | 40913 |
| 40962 | // Tables (cuda_Event) |  | 40914 | // Tables (cuda_Event)
| 40963 |  |  | 40915 |
| 40964 | static PyGetSetDef pyopencv_cuda_Event_getseters[] = |  | 40916 | static PyGetSetDef pyopencv_cuda_Event_getseters[] =
| 40965 | { |  | 40917 | {
| 40966 | {NULL} /* Sentinel */ |  | 40918 | {NULL} /* Sentinel */
| 40967 | }; |  | 40919 | };
| 40968 |  |  | 40920 |
| 40969 | static PyMethodDef pyopencv_cuda_Event_methods[] = |  | 40921 | static PyMethodDef pyopencv_cuda_Event_methods[] =
| 40970 | { |  | 40922 | {
| 40971 | {"elapsedTime", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_elapsedTime_static, METH_STATIC), "elapsedTime(start, end) -> retval\n."}, |  | 40923 | {"elapsedTime", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_elapsedTime_static, METH_STATIC), "elapsedTime(start, end) -> retval\n."},
| 40972 | {"queryIfComplete", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_queryIfComplete, 0), "queryIfComplete() -> retval\n."}, |  | 40924 | {"queryIfComplete", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_queryIfComplete, 0), "queryIfComplete() -> retval\n."},
| 40973 | {"record", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_record, 0), "record([, stream]) -> None\n."}, |  | 40925 | {"record", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_record, 0), "record([, stream]) -> None\n."},
| 40974 | {"waitForCompletion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_waitForCompletion, 0), "waitForCompletion() -> None\n."}, |  | 40926 | {"waitForCompletion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Event_waitForCompletion, 0), "waitForCompletion() -> None\n."},
| 40975 |  |  | 40927 |
| 40976 | {NULL, NULL} |  | 40928 | {NULL, NULL}
| 40977 | }; |  | 40929 | };
| 40978 |  |  | 40930 |
| 40979 | // Converter (cuda_Event) |  | 40931 | // Converter (cuda_Event)
| 40980 |  |  | 40932 |
| 40981 | template<> |  | 40933 | template<>
| 40982 | struct PyOpenCV_Converter< Ptr<cv::cuda::Event> > |  | 40934 | struct PyOpenCV_Converter< Ptr<cv::cuda::Event> >
| 40983 | { |  | 40935 | {
| 40984 | static PyObject* from(const Ptr<cv::cuda::Event>& r) |  | 40936 | static PyObject* from(const Ptr<cv::cuda::Event>& r)
| 40985 | { |  | 40937 | {
| 40986 | return pyopencv_cuda_Event_Instance(r); |  | 40938 | return pyopencv_cuda_Event_Instance(r);
| 40987 | } |  | 40939 | }
| 40988 | static bool to(PyObject* src, Ptr<cv::cuda::Event>& dst, const ArgInfo& info) |  | 40940 | static bool to(PyObject* src, Ptr<cv::cuda::Event>& dst, const ArgInfo& info)
| 40989 | { |  | 40941 | {
| 40990 | if(!src || src == Py_None) |  | 40942 | if(!src || src == Py_None)
| 40991 | return true; |  | 40943 | return true;
| 40992 | Ptr<cv::cuda::Event> * dst_; |  | 40944 | Ptr<cv::cuda::Event> * dst_;
| 40993 | if (pyopencv_cuda_Event_getp(src, dst_)) |  | 40945 | if (pyopencv_cuda_Event_getp(src, dst_))
| 40994 | { |  | 40946 | {
| 40995 | dst = *dst_; |  | 40947 | dst = *dst_;
| 40996 | return true; |  | 40948 | return true;
| 40997 | } |  | 40949 | }
| 40998 |  |  | 40950 |
| 40999 | failmsg("Expected Ptr<cv::cuda::Event> for argument '%s'", info.name); |  | 40951 | failmsg("Expected Ptr<cv::cuda::Event> for argument '%s'", info.name);
| 41000 | return false; |  | 40952 | return false;
| 41001 | } |  | 40953 | }
| 41002 | }; |  | 40954 | };
| 41003 |  |  | 40955 |
| 41004 | //================================================================================ |  | 40956 | //================================================================================
| 41005 | // cuda_GpuData (Generic) |  | 40957 | // cuda_GpuData (Generic)
| 41006 | //================================================================================ |  | 40958 | //================================================================================
| 41007 |  |  | 40959 |
| 41008 | // GetSet (cuda_GpuData) |  | 40960 | // GetSet (cuda_GpuData)
| 41009 |  |  | 40961 |
| 41010 |  |  | 40962 |
| 41011 |  |  | 40963 |
| 41012 | // Methods (cuda_GpuData) |  | 40964 | // Methods (cuda_GpuData)
| 41013 |  |  | 40965 |
| 41014 |  |  | 40966 |
| 41015 |  |  | 40967 |
| 41016 | // Tables (cuda_GpuData) |  | 40968 | // Tables (cuda_GpuData)
| 41017 |  |  | 40969 |
| 41018 | static PyGetSetDef pyopencv_cuda_GpuData_getseters[] = |  | 40970 | static PyGetSetDef pyopencv_cuda_GpuData_getseters[] =
| 41019 | { |  | 40971 | {
| 41020 | {NULL} /* Sentinel */ |  | 40972 | {NULL} /* Sentinel */
| 41021 | }; |  | 40973 | };
| 41022 |  |  | 40974 |
| 41023 | static PyMethodDef pyopencv_cuda_GpuData_methods[] = |  | 40975 | static PyMethodDef pyopencv_cuda_GpuData_methods[] =
| 41024 | { |  | 40976 | {
| 41025 |  |  | 40977 |
| 41026 | {NULL, NULL} |  | 40978 | {NULL, NULL}
| 41027 | }; |  | 40979 | };
| 41028 |  |  | 40980 |
| 41029 | // Converter (cuda_GpuData) |  | 40981 | // Converter (cuda_GpuData)
| 41030 |  |  | 40982 |
| 41031 | template<> |  | 40983 | template<>
| 41032 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuData> > |  | 40984 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuData> >
| 41033 | { |  | 40985 | {
| 41034 | static PyObject* from(const Ptr<cv::cuda::GpuData>& r) |  | 40986 | static PyObject* from(const Ptr<cv::cuda::GpuData>& r)
| 41035 | { |  | 40987 | {
| 41036 | return pyopencv_cuda_GpuData_Instance(r); |  | 40988 | return pyopencv_cuda_GpuData_Instance(r);
| 41037 | } |  | 40989 | }
| 41038 | static bool to(PyObject* src, Ptr<cv::cuda::GpuData>& dst, const ArgInfo& info) |  | 40990 | static bool to(PyObject* src, Ptr<cv::cuda::GpuData>& dst, const ArgInfo& info)
| 41039 | { |  | 40991 | {
| 41040 | if(!src || src == Py_None) |  | 40992 | if(!src || src == Py_None)
| 41041 | return true; |  | 40993 | return true;
| 41042 | Ptr<cv::cuda::GpuData> * dst_; |  | 40994 | Ptr<cv::cuda::GpuData> * dst_;
| 41043 | if (pyopencv_cuda_GpuData_getp(src, dst_)) |  | 40995 | if (pyopencv_cuda_GpuData_getp(src, dst_))
| 41044 | { |  | 40996 | {
| 41045 | dst = *dst_; |  | 40997 | dst = *dst_;
| 41046 | return true; |  | 40998 | return true;
| 41047 | } |  | 40999 | }
| 41048 |  |  | 41000 |
| 41049 | failmsg("Expected Ptr<cv::cuda::GpuData> for argument '%s'", info.name); |  | 41001 | failmsg("Expected Ptr<cv::cuda::GpuData> for argument '%s'", info.name);
| 41050 | return false; |  | 41002 | return false;
| 41051 | } |  | 41003 | }
| 41052 | }; |  | 41004 | };
| 41053 |  |  | 41005 |
| 41054 | //================================================================================ |  | 41006 | //================================================================================
| 41055 | // cuda_GpuMat (Generic) |  | 41007 | // cuda_GpuMat (Generic)
| 41056 | //================================================================================ |  | 41008 | //================================================================================
| 41057 |  |  | 41009 |
| 41058 | // GetSet (cuda_GpuMat) |  | 41010 | // GetSet (cuda_GpuMat)
| 41059 |  |  | 41011 |
| 41060 |  |  | 41012 |
| 41061 | static PyObject* pyopencv_cuda_GpuMat_get_step(pyopencv_cuda_GpuMat_t* p, void *closure) |  | 41013 | static PyObject* pyopencv_cuda_GpuMat_get_step(pyopencv_cuda_GpuMat_t* p, void *closure)
| 41062 | { |  | 41014 | {
| 41063 | return pyopencv_from(p->v->step); |  | 41015 | return pyopencv_from(p->v->step);
| 41064 | } |  | 41016 | }
| 41065 |  |  | 41017 |
| 41066 |  |  | 41018 |
| 41067 | // Methods (cuda_GpuMat) |  | 41019 | // Methods (cuda_GpuMat)
| 41068 |  |  | 41020 |
| 41069 | static int pyopencv_cv_cuda_cuda_GpuMat_GpuMat(pyopencv_cuda_GpuMat_t* self, PyObject* py_args, PyObject* kw) |  | 41021 | static int pyopencv_cv_cuda_cuda_GpuMat_GpuMat(pyopencv_cuda_GpuMat_t* self, PyObject* py_args, PyObject* kw)
| 41070 | { |  | 41022 | {
| 41071 | using namespace cv::cuda; |  | 41023 | using namespace cv::cuda;
| 41072 |  |  | 41024 |
| 41073 | pyPrepareArgumentConversionErrorsStorage(11); |  | 41025 | pyPrepareArgumentConversionErrorsStorage(11);
| 41074 |  |  | 41026 |
| 41075 | { |  | 41027 | {
| 41076 | PyObject* pyobj_allocator = NULL; |  | 41028 | PyObject* pyobj_allocator = NULL;
| 41077 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41029 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41078 |  |  | 41030 |
| 41079 | const char* keywords[] = { "allocator", NULL }; |  | 41031 | const char* keywords[] = { "allocator", NULL };
| 41080 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:GpuMat", (char**)keywords, &pyobj_allocator) && |  | 41032 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:GpuMat", (char**)keywords, &pyobj_allocator) &&
| 41081 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41033 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41082 | { |  | 41034 | {
| 41083 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41035 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41084 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(allocator))); |  | 41036 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(allocator)));
| 41085 | return 0; |  | 41037 | return 0;
| 41086 | } |  | 41038 | }
| 41087 |  |  | 41039 |
| 41088 |  |  | 41040 |
| 41089 | pyPopulateArgumentConversionErrors(); |  | 41041 | pyPopulateArgumentConversionErrors();
| 41090 | } |  | 41042 | }
| 41091 |  |  | 41043 |
| 41092 |  |  | 41044 |
| 41093 | { |  | 41045 | {
| 41094 | PyObject* pyobj_rows = NULL; |  | 41046 | PyObject* pyobj_rows = NULL;
| 41095 | int rows=0; |  | 41047 | int rows=0;
| 41096 | PyObject* pyobj_cols = NULL; |  | 41048 | PyObject* pyobj_cols = NULL;
| 41097 | int cols=0; |  | 41049 | int cols=0;
| 41098 | PyObject* pyobj_type = NULL; |  | 41050 | PyObject* pyobj_type = NULL;
| 41099 | int type=0; |  | 41051 | int type=0;
| 41100 | PyObject* pyobj_allocator = NULL; |  | 41052 | PyObject* pyobj_allocator = NULL;
| 41101 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41053 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41102 |  |  | 41054 |
| 41103 | const char* keywords[] = { "rows", "cols", "type", "allocator", NULL }; |  | 41055 | const char* keywords[] = { "rows", "cols", "type", "allocator", NULL };
| 41104 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GpuMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_allocator) && |  | 41056 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GpuMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_allocator) &&
| 41105 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 41057 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 41106 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 41058 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 41107 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 41059 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 41108 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41060 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41109 | { |  | 41061 | {
| 41110 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41062 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41111 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(rows, cols, type, allocator))); |  | 41063 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(rows, cols, type, allocator)));
| 41112 | return 0; |  | 41064 | return 0;
| 41113 | } |  | 41065 | }
| 41114 |  |  | 41066 |
| 41115 |  |  | 41067 |
| 41116 | pyPopulateArgumentConversionErrors(); |  | 41068 | pyPopulateArgumentConversionErrors();
| 41117 | } |  | 41069 | }
| 41118 |  |  | 41070 |
| 41119 |  |  | 41071 |
| 41120 | { |  | 41072 | {
| 41121 | PyObject* pyobj_size = NULL; |  | 41073 | PyObject* pyobj_size = NULL;
| 41122 | Size size; |  | 41074 | Size size;
| 41123 | PyObject* pyobj_type = NULL; |  | 41075 | PyObject* pyobj_type = NULL;
| 41124 | int type=0; |  | 41076 | int type=0;
| 41125 | PyObject* pyobj_allocator = NULL; |  | 41077 | PyObject* pyobj_allocator = NULL;
| 41126 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41078 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41127 |  |  | 41079 |
| 41128 | const char* keywords[] = { "size", "type", "allocator", NULL }; |  | 41080 | const char* keywords[] = { "size", "type", "allocator", NULL };
| 41129 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GpuMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_allocator) && |  | 41081 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:GpuMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_allocator) &&
| 41130 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 41082 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 41131 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 41083 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 41132 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41084 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41133 | { |  | 41085 | {
| 41134 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41086 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41135 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(size, type, allocator))); |  | 41087 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(size, type, allocator)));
| 41136 | return 0; |  | 41088 | return 0;
| 41137 | } |  | 41089 | }
| 41138 |  |  | 41090 |
| 41139 |  |  | 41091 |
| 41140 | pyPopulateArgumentConversionErrors(); |  | 41092 | pyPopulateArgumentConversionErrors();
| 41141 | } |  | 41093 | }
| 41142 |  |  | 41094 |
| 41143 |  |  | 41095 |
| 41144 | { |  | 41096 | {
| 41145 | PyObject* pyobj_rows = NULL; |  | 41097 | PyObject* pyobj_rows = NULL;
| 41146 | int rows=0; |  | 41098 | int rows=0;
| 41147 | PyObject* pyobj_cols = NULL; |  | 41099 | PyObject* pyobj_cols = NULL;
| 41148 | int cols=0; |  | 41100 | int cols=0;
| 41149 | PyObject* pyobj_type = NULL; |  | 41101 | PyObject* pyobj_type = NULL;
| 41150 | int type=0; |  | 41102 | int type=0;
| 41151 | PyObject* pyobj_s = NULL; |  | 41103 | PyObject* pyobj_s = NULL;
| 41152 | Scalar s; |  | 41104 | Scalar s;
| 41153 | PyObject* pyobj_allocator = NULL; |  | 41105 | PyObject* pyobj_allocator = NULL;
| 41154 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41106 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41155 |  |  | 41107 |
| 41156 | const char* keywords[] = { "rows", "cols", "type", "s", "allocator", NULL }; |  | 41108 | const char* keywords[] = { "rows", "cols", "type", "s", "allocator", NULL };
| 41157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:GpuMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_s, &pyobj_allocator) && |  | 41109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:GpuMat", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_s, &pyobj_allocator) &&
| 41158 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 41110 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 41159 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 41111 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 41160 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 41112 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 41161 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 41113 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 41162 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41114 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41163 | { |  | 41115 | {
| 41164 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41116 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41165 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(rows, cols, type, s, allocator))); |  | 41117 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(rows, cols, type, s, allocator)));
| 41166 | return 0; |  | 41118 | return 0;
| 41167 | } |  | 41119 | }
| 41168 |  |  | 41120 |
| 41169 |  |  | 41121 |
| 41170 | pyPopulateArgumentConversionErrors(); |  | 41122 | pyPopulateArgumentConversionErrors();
| 41171 | } |  | 41123 | }
| 41172 |  |  | 41124 |
| 41173 |  |  | 41125 |
| 41174 | { |  | 41126 | {
| 41175 | PyObject* pyobj_size = NULL; |  | 41127 | PyObject* pyobj_size = NULL;
| 41176 | Size size; |  | 41128 | Size size;
| 41177 | PyObject* pyobj_type = NULL; |  | 41129 | PyObject* pyobj_type = NULL;
| 41178 | int type=0; |  | 41130 | int type=0;
| 41179 | PyObject* pyobj_s = NULL; |  | 41131 | PyObject* pyobj_s = NULL;
| 41180 | Scalar s; |  | 41132 | Scalar s;
| 41181 | PyObject* pyobj_allocator = NULL; |  | 41133 | PyObject* pyobj_allocator = NULL;
| 41182 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41134 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41183 |  |  | 41135 |
| 41184 | const char* keywords[] = { "size", "type", "s", "allocator", NULL }; |  | 41136 | const char* keywords[] = { "size", "type", "s", "allocator", NULL };
| 41185 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GpuMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_s, &pyobj_allocator) && |  | 41137 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:GpuMat", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_s, &pyobj_allocator) &&
| 41186 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 41138 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 41187 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 41139 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 41188 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 41140 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 41189 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41141 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41190 | { |  | 41142 | {
| 41191 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41143 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41192 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(size, type, s, allocator))); |  | 41144 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(size, type, s, allocator)));
| 41193 | return 0; |  | 41145 | return 0;
| 41194 | } |  | 41146 | }
| 41195 |  |  | 41147 |
| 41196 |  |  | 41148 |
| 41197 | pyPopulateArgumentConversionErrors(); |  | 41149 | pyPopulateArgumentConversionErrors();
| 41198 | } |  | 41150 | }
| 41199 |  |  | 41151 |
| 41200 |  |  | 41152 |
| 41201 | { |  | 41153 | {
| 41202 | PyObject* pyobj_m = NULL; |  | 41154 | PyObject* pyobj_m = NULL;
| 41203 | GpuMat m; |  | 41155 | GpuMat m;
| 41204 |  |  | 41156 |
| 41205 | const char* keywords[] = { "m", NULL }; |  | 41157 | const char* keywords[] = { "m", NULL };
| 41206 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GpuMat", (char**)keywords, &pyobj_m) && |  | 41158 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GpuMat", (char**)keywords, &pyobj_m) &&
| 41207 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) ) |  | 41159 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) )
| 41208 | { |  | 41160 | {
| 41209 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41161 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41210 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(m))); |  | 41162 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(m)));
| 41211 | return 0; |  | 41163 | return 0;
| 41212 | } |  | 41164 | }
| 41213 |  |  | 41165 |
| 41214 |  |  | 41166 |
| 41215 | pyPopulateArgumentConversionErrors(); |  | 41167 | pyPopulateArgumentConversionErrors();
| 41216 | } |  | 41168 | }
| 41217 |  |  | 41169 |
| 41218 |  |  | 41170 |
| 41219 | { |  | 41171 | {
| 41220 | PyObject* pyobj_m = NULL; |  | 41172 | PyObject* pyobj_m = NULL;
| 41221 | GpuMat m; |  | 41173 | GpuMat m;
| 41222 | PyObject* pyobj_rowRange = NULL; |  | 41174 | PyObject* pyobj_rowRange = NULL;
| 41223 | Range rowRange; |  | 41175 | Range rowRange;
| 41224 | PyObject* pyobj_colRange = NULL; |  | 41176 | PyObject* pyobj_colRange = NULL;
| 41225 | Range colRange; |  | 41177 | Range colRange;
| 41226 |  |  | 41178 |
| 41227 | const char* keywords[] = { "m", "rowRange", "colRange", NULL }; |  | 41179 | const char* keywords[] = { "m", "rowRange", "colRange", NULL };
| 41228 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:GpuMat", (char**)keywords, &pyobj_m, &pyobj_rowRange, &pyobj_colRange) && |  | 41180 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:GpuMat", (char**)keywords, &pyobj_m, &pyobj_rowRange, &pyobj_colRange) &&
| 41229 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) && |  | 41181 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) &&
| 41230 | pyopencv_to_safe(pyobj_rowRange, rowRange, ArgInfo("rowRange", 0)) && |  | 41182 | pyopencv_to_safe(pyobj_rowRange, rowRange, ArgInfo("rowRange", 0)) &&
| 41231 | pyopencv_to_safe(pyobj_colRange, colRange, ArgInfo("colRange", 0)) ) |  | 41183 | pyopencv_to_safe(pyobj_colRange, colRange, ArgInfo("colRange", 0)) )
| 41232 | { |  | 41184 | {
| 41233 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41185 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41234 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(m, rowRange, colRange))); |  | 41186 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(m, rowRange, colRange)));
| 41235 | return 0; |  | 41187 | return 0;
| 41236 | } |  | 41188 | }
| 41237 |  |  | 41189 |
| 41238 |  |  | 41190 |
| 41239 | pyPopulateArgumentConversionErrors(); |  | 41191 | pyPopulateArgumentConversionErrors();
| 41240 | } |  | 41192 | }
| 41241 |  |  | 41193 |
| 41242 |  |  | 41194 |
| 41243 | { |  | 41195 | {
| 41244 | PyObject* pyobj_m = NULL; |  | 41196 | PyObject* pyobj_m = NULL;
| 41245 | GpuMat m; |  | 41197 | GpuMat m;
| 41246 | PyObject* pyobj_roi = NULL; |  | 41198 | PyObject* pyobj_roi = NULL;
| 41247 | Rect roi; |  | 41199 | Rect roi;
| 41248 |  |  | 41200 |
| 41249 | const char* keywords[] = { "m", "roi", NULL }; |  | 41201 | const char* keywords[] = { "m", "roi", NULL };
| 41250 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GpuMat", (char**)keywords, &pyobj_m, &pyobj_roi) && |  | 41202 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:GpuMat", (char**)keywords, &pyobj_m, &pyobj_roi) &&
| 41251 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) && |  | 41203 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) &&
| 41252 | pyopencv_to_safe(pyobj_roi, roi, ArgInfo("roi", 0)) ) |  | 41204 | pyopencv_to_safe(pyobj_roi, roi, ArgInfo("roi", 0)) )
| 41253 | { |  | 41205 | {
| 41254 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41206 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41255 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(m, roi))); |  | 41207 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(m, roi)));
| 41256 | return 0; |  | 41208 | return 0;
| 41257 | } |  | 41209 | }
| 41258 |  |  | 41210 |
| 41259 |  |  | 41211 |
| 41260 | pyPopulateArgumentConversionErrors(); |  | 41212 | pyPopulateArgumentConversionErrors();
| 41261 | } |  | 41213 | }
| 41262 |  |  | 41214 |
| 41263 |  |  | 41215 |
| 41264 | { |  | 41216 | {
| 41265 | PyObject* pyobj_arr = NULL; |  | 41217 | PyObject* pyobj_arr = NULL;
| 41266 | Mat arr; |  | 41218 | Mat arr;
| 41267 | PyObject* pyobj_allocator = NULL; |  | 41219 | PyObject* pyobj_allocator = NULL;
| 41268 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41220 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41269 |  |  | 41221 |
| 41270 | const char* keywords[] = { "arr", "allocator", NULL }; |  | 41222 | const char* keywords[] = { "arr", "allocator", NULL };
| 41271 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GpuMat", (char**)keywords, &pyobj_arr, &pyobj_allocator) && |  | 41223 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GpuMat", (char**)keywords, &pyobj_arr, &pyobj_allocator) &&
| 41272 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 41224 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 41273 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41225 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41274 | { |  | 41226 | {
| 41275 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41227 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41276 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(arr, allocator))); |  | 41228 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(arr, allocator)));
| 41277 | return 0; |  | 41229 | return 0;
| 41278 | } |  | 41230 | }
| 41279 |  |  | 41231 |
| 41280 |  |  | 41232 |
| 41281 | pyPopulateArgumentConversionErrors(); |  | 41233 | pyPopulateArgumentConversionErrors();
| 41282 | } |  | 41234 | }
| 41283 |  |  | 41235 |
| 41284 |  |  | 41236 |
| 41285 | { |  | 41237 | {
| 41286 | PyObject* pyobj_arr = NULL; |  | 41238 | PyObject* pyobj_arr = NULL;
| 41287 | cuda::GpuMat arr; |  | 41239 | cuda::GpuMat arr;
| 41288 | PyObject* pyobj_allocator = NULL; |  | 41240 | PyObject* pyobj_allocator = NULL;
| 41289 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41241 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41290 |  |  | 41242 |
| 41291 | const char* keywords[] = { "arr", "allocator", NULL }; |  | 41243 | const char* keywords[] = { "arr", "allocator", NULL };
| 41292 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GpuMat", (char**)keywords, &pyobj_arr, &pyobj_allocator) && |  | 41244 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GpuMat", (char**)keywords, &pyobj_arr, &pyobj_allocator) &&
| 41293 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 41245 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 41294 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41246 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41295 | { |  | 41247 | {
| 41296 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41248 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41297 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(arr, allocator))); |  | 41249 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(arr, allocator)));
| 41298 | return 0; |  | 41250 | return 0;
| 41299 | } |  | 41251 | }
| 41300 |  |  | 41252 |
| 41301 |  |  | 41253 |
| 41302 | pyPopulateArgumentConversionErrors(); |  | 41254 | pyPopulateArgumentConversionErrors();
| 41303 | } |  | 41255 | }
| 41304 |  |  | 41256 |
| 41305 |  |  | 41257 |
| 41306 | { |  | 41258 | {
| 41307 | PyObject* pyobj_arr = NULL; |  | 41259 | PyObject* pyobj_arr = NULL;
| 41308 | UMat arr; |  | 41260 | UMat arr;
| 41309 | PyObject* pyobj_allocator = NULL; |  | 41261 | PyObject* pyobj_allocator = NULL;
| 41310 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator(); |  | 41262 | GpuMat_Allocator* allocator=GpuMat::defaultAllocator();
| 41311 |  |  | 41263 |
| 41312 | const char* keywords[] = { "arr", "allocator", NULL }; |  | 41264 | const char* keywords[] = { "arr", "allocator", NULL };
| 41313 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GpuMat", (char**)keywords, &pyobj_arr, &pyobj_allocator) && |  | 41265 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:GpuMat", (char**)keywords, &pyobj_arr, &pyobj_allocator) &&
| 41314 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 41266 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 41315 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 41267 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 41316 | { |  | 41268 | {
| 41317 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new |  | 41269 | new (&(self->v)) Ptr<cv::cuda::GpuMat>(); // init Ptr with placement new
| 41318 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(arr, allocator))); |  | 41270 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::GpuMat(arr, allocator)));
| 41319 | return 0; |  | 41271 | return 0;
| 41320 | } |  | 41272 | }
| 41321 |  |  | 41273 |
| 41322 |  |  | 41274 |
| 41323 | pyPopulateArgumentConversionErrors(); |  | 41275 | pyPopulateArgumentConversionErrors();
| 41324 | } |  | 41276 | }
| 41325 | pyRaiseCVOverloadException("GpuMat"); |  | 41277 | pyRaiseCVOverloadException("GpuMat");
| 41326 |  |  | 41278 |
| 41327 | return -1; |  | 41279 | return -1;
| 41328 | } |  | 41280 | }
| 41329 |  |  | 41281 |
| 41330 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_adjustROI(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41282 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_adjustROI(PyObject* self, PyObject* py_args, PyObject* kw)
| 41331 | { |  | 41283 | {
| 41332 | using namespace cv::cuda; |  | 41284 | using namespace cv::cuda;
| 41333 |  |  | 41285 |
| 41334 |  |  | 41286 |
| 41335 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41287 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41336 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41288 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41337 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41289 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41338 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41290 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41339 | PyObject* pyobj_dtop = NULL; |  | 41291 | PyObject* pyobj_dtop = NULL;
| 41340 | int dtop=0; |  | 41292 | int dtop=0;
| 41341 | PyObject* pyobj_dbottom = NULL; |  | 41293 | PyObject* pyobj_dbottom = NULL;
| 41342 | int dbottom=0; |  | 41294 | int dbottom=0;
| 41343 | PyObject* pyobj_dleft = NULL; |  | 41295 | PyObject* pyobj_dleft = NULL;
| 41344 | int dleft=0; |  | 41296 | int dleft=0;
| 41345 | PyObject* pyobj_dright = NULL; |  | 41297 | PyObject* pyobj_dright = NULL;
| 41346 | int dright=0; |  | 41298 | int dright=0;
| 41347 | GpuMat retval; |  | 41299 | GpuMat retval;
| 41348 |  |  | 41300 |
| 41349 | const char* keywords[] = { "dtop", "dbottom", "dleft", "dright", NULL }; |  | 41301 | const char* keywords[] = { "dtop", "dbottom", "dleft", "dright", NULL };
| 41350 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:cuda_GpuMat.adjustROI", (char**)keywords, &pyobj_dtop, &pyobj_dbottom, &pyobj_dleft, &pyobj_dright) && |  | 41302 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:cuda_GpuMat.adjustROI", (char**)keywords, &pyobj_dtop, &pyobj_dbottom, &pyobj_dleft, &pyobj_dright) &&
| 41351 | pyopencv_to_safe(pyobj_dtop, dtop, ArgInfo("dtop", 0)) && |  | 41303 | pyopencv_to_safe(pyobj_dtop, dtop, ArgInfo("dtop", 0)) &&
| 41352 | pyopencv_to_safe(pyobj_dbottom, dbottom, ArgInfo("dbottom", 0)) && |  | 41304 | pyopencv_to_safe(pyobj_dbottom, dbottom, ArgInfo("dbottom", 0)) &&
| 41353 | pyopencv_to_safe(pyobj_dleft, dleft, ArgInfo("dleft", 0)) && |  | 41305 | pyopencv_to_safe(pyobj_dleft, dleft, ArgInfo("dleft", 0)) &&
| 41354 | pyopencv_to_safe(pyobj_dright, dright, ArgInfo("dright", 0)) ) |  | 41306 | pyopencv_to_safe(pyobj_dright, dright, ArgInfo("dright", 0)) )
| 41355 | { |  | 41307 | {
| 41356 | ERRWRAP2(retval = _self_->adjustROI(dtop, dbottom, dleft, dright)); |  | 41308 | ERRWRAP2(retval = _self_->adjustROI(dtop, dbottom, dleft, dright));
| 41357 | return pyopencv_from(retval); |  | 41309 | return pyopencv_from(retval);
| 41358 | } |  | 41310 | }
| 41359 |  |  | 41311 |
| 41360 | return NULL; |  | 41312 | return NULL;
| 41361 | } |  | 41313 | }
| 41362 |  |  | 41314 |
| 41363 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_assignTo(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41315 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_assignTo(PyObject* self, PyObject* py_args, PyObject* kw)
| 41364 | { |  | 41316 | {
| 41365 | using namespace cv::cuda; |  | 41317 | using namespace cv::cuda;
| 41366 |  |  | 41318 |
| 41367 |  |  | 41319 |
| 41368 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41320 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41369 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41321 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41370 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41322 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41371 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41323 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41372 | PyObject* pyobj_m = NULL; |  | 41324 | PyObject* pyobj_m = NULL;
| 41373 | GpuMat m; |  | 41325 | GpuMat m;
| 41374 | PyObject* pyobj_type = NULL; |  | 41326 | PyObject* pyobj_type = NULL;
| 41375 | int type=-1; |  | 41327 | int type=-1;
| 41376 |  |  | 41328 |
| 41377 | const char* keywords[] = { "m", "type", NULL }; |  | 41329 | const char* keywords[] = { "m", "type", NULL };
| 41378 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.assignTo", (char**)keywords, &pyobj_m, &pyobj_type) && |  | 41330 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.assignTo", (char**)keywords, &pyobj_m, &pyobj_type) &&
| 41379 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) && |  | 41331 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) &&
| 41380 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 41332 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 41381 | { |  | 41333 | {
| 41382 | ERRWRAP2(_self_->assignTo(m, type)); |  | 41334 | ERRWRAP2(_self_->assignTo(m, type));
| 41383 | Py_RETURN_NONE; |  | 41335 | Py_RETURN_NONE;
| 41384 | } |  | 41336 | }
| 41385 |  |  | 41337 |
| 41386 | return NULL; |  | 41338 | return NULL;
| 41387 | } |  | 41339 | }
| 41388 |  |  | 41340 |
| 41389 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_channels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41341 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_channels(PyObject* self, PyObject* py_args, PyObject* kw)
| 41390 | { |  | 41342 | {
| 41391 | using namespace cv::cuda; |  | 41343 | using namespace cv::cuda;
| 41392 |  |  | 41344 |
| 41393 |  |  | 41345 |
| 41394 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41346 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41395 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41347 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41396 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41348 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41397 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41349 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41398 | int retval; |  | 41350 | int retval;
| 41399 |  |  | 41351 |
| 41400 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41352 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41401 | { |  | 41353 | {
| 41402 | ERRWRAP2(retval = _self_->channels()); |  | 41354 | ERRWRAP2(retval = _self_->channels());
| 41403 | return pyopencv_from(retval); |  | 41355 | return pyopencv_from(retval);
| 41404 | } |  | 41356 | }
| 41405 |  |  | 41357 |
| 41406 | return NULL; |  | 41358 | return NULL;
| 41407 | } |  | 41359 | }
| 41408 |  |  | 41360 |
| 41409 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_clone(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41361 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_clone(PyObject* self, PyObject* py_args, PyObject* kw)
| 41410 | { |  | 41362 | {
| 41411 | using namespace cv::cuda; |  | 41363 | using namespace cv::cuda;
| 41412 |  |  | 41364 |
| 41413 |  |  | 41365 |
| 41414 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41366 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41415 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41367 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41416 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41368 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41417 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41369 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41418 | GpuMat retval; |  | 41370 | GpuMat retval;
| 41419 |  |  | 41371 |
| 41420 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41372 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41421 | { |  | 41373 | {
| 41422 | ERRWRAP2(retval = _self_->clone()); |  | 41374 | ERRWRAP2(retval = _self_->clone());
| 41423 | return pyopencv_from(retval); |  | 41375 | return pyopencv_from(retval);
| 41424 | } |  | 41376 | }
| 41425 |  |  | 41377 |
| 41426 | return NULL; |  | 41378 | return NULL;
| 41427 | } |  | 41379 | }
| 41428 |  |  | 41380 |
| 41429 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_col(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41381 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_col(PyObject* self, PyObject* py_args, PyObject* kw)
| 41430 | { |  | 41382 | {
| 41431 | using namespace cv::cuda; |  | 41383 | using namespace cv::cuda;
| 41432 |  |  | 41384 |
| 41433 |  |  | 41385 |
| 41434 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41386 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41435 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41387 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41436 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41388 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41437 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41389 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41438 | PyObject* pyobj_x = NULL; |  | 41390 | PyObject* pyobj_x = NULL;
| 41439 | int x=0; |  | 41391 | int x=0;
| 41440 | GpuMat retval; |  | 41392 | GpuMat retval;
| 41441 |  |  | 41393 |
| 41442 | const char* keywords[] = { "x", NULL }; |  | 41394 | const char* keywords[] = { "x", NULL };
| 41443 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.col", (char**)keywords, &pyobj_x) && |  | 41395 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.col", (char**)keywords, &pyobj_x) &&
| 41444 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) ) |  | 41396 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) )
| 41445 | { |  | 41397 | {
| 41446 | ERRWRAP2(retval = _self_->col(x)); |  | 41398 | ERRWRAP2(retval = _self_->col(x));
| 41447 | return pyopencv_from(retval); |  | 41399 | return pyopencv_from(retval);
| 41448 | } |  | 41400 | }
| 41449 |  |  | 41401 |
| 41450 | return NULL; |  | 41402 | return NULL;
| 41451 | } |  | 41403 | }
| 41452 |  |  | 41404 |
| 41453 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_colRange(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41405 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_colRange(PyObject* self, PyObject* py_args, PyObject* kw)
| 41454 | { |  | 41406 | {
| 41455 | using namespace cv::cuda; |  | 41407 | using namespace cv::cuda;
| 41456 |  |  | 41408 |
| 41457 |  |  | 41409 |
| 41458 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41410 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41459 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41411 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41460 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41412 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41461 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41413 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41462 | pyPrepareArgumentConversionErrorsStorage(2); |  | 41414 | pyPrepareArgumentConversionErrorsStorage(2);
| 41463 |  |  | 41415 |
| 41464 | { |  | 41416 | {
| 41465 | PyObject* pyobj_startcol = NULL; |  | 41417 | PyObject* pyobj_startcol = NULL;
| 41466 | int startcol=0; |  | 41418 | int startcol=0;
| 41467 | PyObject* pyobj_endcol = NULL; |  | 41419 | PyObject* pyobj_endcol = NULL;
| 41468 | int endcol=0; |  | 41420 | int endcol=0;
| 41469 | GpuMat retval; |  | 41421 | GpuMat retval;
| 41470 |  |  | 41422 |
| 41471 | const char* keywords[] = { "startcol", "endcol", NULL }; |  | 41423 | const char* keywords[] = { "startcol", "endcol", NULL };
| 41472 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.colRange", (char**)keywords, &pyobj_startcol, &pyobj_endcol) && |  | 41424 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.colRange", (char**)keywords, &pyobj_startcol, &pyobj_endcol) &&
| 41473 | pyopencv_to_safe(pyobj_startcol, startcol, ArgInfo("startcol", 0)) && |  | 41425 | pyopencv_to_safe(pyobj_startcol, startcol, ArgInfo("startcol", 0)) &&
| 41474 | pyopencv_to_safe(pyobj_endcol, endcol, ArgInfo("endcol", 0)) ) |  | 41426 | pyopencv_to_safe(pyobj_endcol, endcol, ArgInfo("endcol", 0)) )
| 41475 | { |  | 41427 | {
| 41476 | ERRWRAP2(retval = _self_->colRange(startcol, endcol)); |  | 41428 | ERRWRAP2(retval = _self_->colRange(startcol, endcol));
| 41477 | return pyopencv_from(retval); |  | 41429 | return pyopencv_from(retval);
| 41478 | } |  | 41430 | }
| 41479 |  |  | 41431 |
| 41480 |  |  | 41432 |
| 41481 | pyPopulateArgumentConversionErrors(); |  | 41433 | pyPopulateArgumentConversionErrors();
| 41482 | } |  | 41434 | }
| 41483 |  |  | 41435 |
| 41484 |  |  | 41436 |
| 41485 | { |  | 41437 | {
| 41486 | PyObject* pyobj_r = NULL; |  | 41438 | PyObject* pyobj_r = NULL;
| 41487 | Range r; |  | 41439 | Range r;
| 41488 | GpuMat retval; |  | 41440 | GpuMat retval;
| 41489 |  |  | 41441 |
| 41490 | const char* keywords[] = { "r", NULL }; |  | 41442 | const char* keywords[] = { "r", NULL };
| 41491 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.colRange", (char**)keywords, &pyobj_r) && |  | 41443 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.colRange", (char**)keywords, &pyobj_r) &&
| 41492 | pyopencv_to_safe(pyobj_r, r, ArgInfo("r", 0)) ) |  | 41444 | pyopencv_to_safe(pyobj_r, r, ArgInfo("r", 0)) )
| 41493 | { |  | 41445 | {
| 41494 | ERRWRAP2(retval = _self_->colRange(r)); |  | 41446 | ERRWRAP2(retval = _self_->colRange(r));
| 41495 | return pyopencv_from(retval); |  | 41447 | return pyopencv_from(retval);
| 41496 | } |  | 41448 | }
| 41497 |  |  | 41449 |
| 41498 |  |  | 41450 |
| 41499 | pyPopulateArgumentConversionErrors(); |  | 41451 | pyPopulateArgumentConversionErrors();
| 41500 | } |  | 41452 | }
| 41501 | pyRaiseCVOverloadException("colRange"); |  | 41453 | pyRaiseCVOverloadException("colRange");
| 41502 |  |  | 41454 |
| 41503 | return NULL; |  | 41455 | return NULL;
| 41504 | } |  | 41456 | }
| 41505 |  |  | 41457 |
| 41506 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_convertTo(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41458 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_convertTo(PyObject* self, PyObject* py_args, PyObject* kw)
| 41507 | { |  | 41459 | {
| 41508 | using namespace cv::cuda; |  | 41460 | using namespace cv::cuda;
| 41509 |  |  | 41461 |
| 41510 |  |  | 41462 |
| 41511 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41463 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41512 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41464 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41513 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41465 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41514 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41466 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41515 | pyPrepareArgumentConversionErrorsStorage(3); |  | 41467 | pyPrepareArgumentConversionErrorsStorage(3);
| 41516 |  |  | 41468 |
| 41517 | { |  | 41469 | {
| 41518 | PyObject* pyobj_dst = NULL; |  | 41470 | PyObject* pyobj_dst = NULL;
| 41519 | GpuMat dst; |  | 41471 | GpuMat dst;
| 41520 | PyObject* pyobj_rtype = NULL; |  | 41472 | PyObject* pyobj_rtype = NULL;
| 41521 | int rtype=0; |  | 41473 | int rtype=0;
| 41522 | PyObject* pyobj_stream = NULL; |  | 41474 | PyObject* pyobj_stream = NULL;
| 41523 | Stream stream=Stream::Null(); |  | 41475 | Stream stream=Stream::Null();
| 41524 |  |  | 41476 |
| 41525 | const char* keywords[] = { "rtype", "stream", "dst", NULL }; |  | 41477 | const char* keywords[] = { "rtype", "stream", "dst", NULL };
| 41526 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:cuda_GpuMat.convertTo", (char**)keywords, &pyobj_rtype, &pyobj_stream, &pyobj_dst) && |  | 41478 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:cuda_GpuMat.convertTo", (char**)keywords, &pyobj_rtype, &pyobj_stream, &pyobj_dst) &&
| 41527 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41479 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41528 | pyopencv_to_safe(pyobj_rtype, rtype, ArgInfo("rtype", 0)) && |  | 41480 | pyopencv_to_safe(pyobj_rtype, rtype, ArgInfo("rtype", 0)) &&
| 41529 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 41481 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 41530 | { |  | 41482 | {
| 41531 | ERRWRAP2(_self_->convertTo(dst, rtype, stream)); |  | 41483 | ERRWRAP2(_self_->convertTo(dst, rtype, stream));
| 41532 | return pyopencv_from(dst); |  | 41484 | return pyopencv_from(dst);
| 41533 | } |  | 41485 | }
| 41534 |  |  | 41486 |
| 41535 |  |  | 41487 |
| 41536 | pyPopulateArgumentConversionErrors(); |  | 41488 | pyPopulateArgumentConversionErrors();
| 41537 | } |  | 41489 | }
| 41538 |  |  | 41490 |
| 41539 |  |  | 41491 |
| 41540 | { |  | 41492 | {
| 41541 | PyObject* pyobj_dst = NULL; |  | 41493 | PyObject* pyobj_dst = NULL;
| 41542 | GpuMat dst; |  | 41494 | GpuMat dst;
| 41543 | PyObject* pyobj_rtype = NULL; |  | 41495 | PyObject* pyobj_rtype = NULL;
| 41544 | int rtype=0; |  | 41496 | int rtype=0;
| 41545 | PyObject* pyobj_alpha = NULL; |  | 41497 | PyObject* pyobj_alpha = NULL;
| 41546 | double alpha=1.0; |  | 41498 | double alpha=1.0;
| 41547 | PyObject* pyobj_beta = NULL; |  | 41499 | PyObject* pyobj_beta = NULL;
| 41548 | double beta=0.0; |  | 41500 | double beta=0.0;
| 41549 |  |  | 41501 |
| 41550 | const char* keywords[] = { "rtype", "dst", "alpha", "beta", NULL }; |  | 41502 | const char* keywords[] = { "rtype", "dst", "alpha", "beta", NULL };
| 41551 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:cuda_GpuMat.convertTo", (char**)keywords, &pyobj_rtype, &pyobj_dst, &pyobj_alpha, &pyobj_beta) && |  | 41503 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:cuda_GpuMat.convertTo", (char**)keywords, &pyobj_rtype, &pyobj_dst, &pyobj_alpha, &pyobj_beta) &&
| 41552 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41504 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41553 | pyopencv_to_safe(pyobj_rtype, rtype, ArgInfo("rtype", 0)) && |  | 41505 | pyopencv_to_safe(pyobj_rtype, rtype, ArgInfo("rtype", 0)) &&
| 41554 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) && |  | 41506 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) &&
| 41555 | pyopencv_to_safe(pyobj_beta, beta, ArgInfo("beta", 0)) ) |  | 41507 | pyopencv_to_safe(pyobj_beta, beta, ArgInfo("beta", 0)) )
| 41556 | { |  | 41508 | {
| 41557 | ERRWRAP2(_self_->convertTo(dst, rtype, alpha, beta)); |  | 41509 | ERRWRAP2(_self_->convertTo(dst, rtype, alpha, beta));
| 41558 | return pyopencv_from(dst); |  | 41510 | return pyopencv_from(dst);
| 41559 | } |  | 41511 | }
| 41560 |  |  | 41512 |
| 41561 |  |  | 41513 |
| 41562 | pyPopulateArgumentConversionErrors(); |  | 41514 | pyPopulateArgumentConversionErrors();
| 41563 | } |  | 41515 | }
| 41564 |  |  | 41516 |
| 41565 |  |  | 41517 |
| 41566 | { |  | 41518 | {
| 41567 | PyObject* pyobj_dst = NULL; |  | 41519 | PyObject* pyobj_dst = NULL;
| 41568 | GpuMat dst; |  | 41520 | GpuMat dst;
| 41569 | PyObject* pyobj_rtype = NULL; |  | 41521 | PyObject* pyobj_rtype = NULL;
| 41570 | int rtype=0; |  | 41522 | int rtype=0;
| 41571 | PyObject* pyobj_alpha = NULL; |  | 41523 | PyObject* pyobj_alpha = NULL;
| 41572 | double alpha=0; |  | 41524 | double alpha=0;
| 41573 | PyObject* pyobj_beta = NULL; |  | 41525 | PyObject* pyobj_beta = NULL;
| 41574 | double beta=0; |  | 41526 | double beta=0;
| 41575 | PyObject* pyobj_stream = NULL; |  | 41527 | PyObject* pyobj_stream = NULL;
| 41576 | Stream stream=Stream::Null(); |  | 41528 | Stream stream=Stream::Null();
| 41577 |  |  | 41529 |
| 41578 | const char* keywords[] = { "rtype", "alpha", "beta", "stream", "dst", NULL }; |  | 41530 | const char* keywords[] = { "rtype", "alpha", "beta", "stream", "dst", NULL };
| 41579 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:cuda_GpuMat.convertTo", (char**)keywords, &pyobj_rtype, &pyobj_alpha, &pyobj_beta, &pyobj_stream, &pyobj_dst) && |  | 41531 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:cuda_GpuMat.convertTo", (char**)keywords, &pyobj_rtype, &pyobj_alpha, &pyobj_beta, &pyobj_stream, &pyobj_dst) &&
| 41580 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41532 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41581 | pyopencv_to_safe(pyobj_rtype, rtype, ArgInfo("rtype", 0)) && |  | 41533 | pyopencv_to_safe(pyobj_rtype, rtype, ArgInfo("rtype", 0)) &&
| 41582 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) && |  | 41534 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) &&
| 41583 | pyopencv_to_safe(pyobj_beta, beta, ArgInfo("beta", 0)) && |  | 41535 | pyopencv_to_safe(pyobj_beta, beta, ArgInfo("beta", 0)) &&
| 41584 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 41536 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 41585 | { |  | 41537 | {
| 41586 | ERRWRAP2(_self_->convertTo(dst, rtype, alpha, beta, stream)); |  | 41538 | ERRWRAP2(_self_->convertTo(dst, rtype, alpha, beta, stream));
| 41587 | return pyopencv_from(dst); |  | 41539 | return pyopencv_from(dst);
| 41588 | } |  | 41540 | }
| 41589 |  |  | 41541 |
| 41590 |  |  | 41542 |
| 41591 | pyPopulateArgumentConversionErrors(); |  | 41543 | pyPopulateArgumentConversionErrors();
| 41592 | } |  | 41544 | }
| 41593 | pyRaiseCVOverloadException("convertTo"); |  | 41545 | pyRaiseCVOverloadException("convertTo");
| 41594 |  |  | 41546 |
| 41595 | return NULL; |  | 41547 | return NULL;
| 41596 | } |  | 41548 | }
| 41597 |  |  | 41549 |
| 41598 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_copyTo(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41550 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_copyTo(PyObject* self, PyObject* py_args, PyObject* kw)
| 41599 | { |  | 41551 | {
| 41600 | using namespace cv::cuda; |  | 41552 | using namespace cv::cuda;
| 41601 |  |  | 41553 |
| 41602 |  |  | 41554 |
| 41603 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41555 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41604 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41556 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41605 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41557 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41606 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41558 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41607 | pyPrepareArgumentConversionErrorsStorage(4); |  | 41559 | pyPrepareArgumentConversionErrorsStorage(4);
| 41608 |  |  | 41560 |
| 41609 | { |  | 41561 | {
| 41610 | PyObject* pyobj_dst = NULL; |  | 41562 | PyObject* pyobj_dst = NULL;
| 41611 | GpuMat dst; |  | 41563 | GpuMat dst;
| 41612 |  |  | 41564 |
| 41613 | const char* keywords[] = { "dst", NULL }; |  | 41565 | const char* keywords[] = { "dst", NULL };
| 41614 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_dst) && |  | 41566 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_dst) &&
| 41615 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 41567 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 41616 | { |  | 41568 | {
| 41617 | ERRWRAP2(_self_->copyTo(dst)); |  | 41569 | ERRWRAP2(_self_->copyTo(dst));
| 41618 | return pyopencv_from(dst); |  | 41570 | return pyopencv_from(dst);
| 41619 | } |  | 41571 | }
| 41620 |  |  | 41572 |
| 41621 |  |  | 41573 |
| 41622 | pyPopulateArgumentConversionErrors(); |  | 41574 | pyPopulateArgumentConversionErrors();
| 41623 | } |  | 41575 | }
| 41624 |  |  | 41576 |
| 41625 |  |  | 41577 |
| 41626 | { |  | 41578 | {
| 41627 | PyObject* pyobj_dst = NULL; |  | 41579 | PyObject* pyobj_dst = NULL;
| 41628 | GpuMat dst; |  | 41580 | GpuMat dst;
| 41629 | PyObject* pyobj_stream = NULL; |  | 41581 | PyObject* pyobj_stream = NULL;
| 41630 | Stream stream=Stream::Null(); |  | 41582 | Stream stream=Stream::Null();
| 41631 |  |  | 41583 |
| 41632 | const char* keywords[] = { "stream", "dst", NULL }; |  | 41584 | const char* keywords[] = { "stream", "dst", NULL };
| 41633 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_stream, &pyobj_dst) && |  | 41585 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_stream, &pyobj_dst) &&
| 41634 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41586 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41635 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 41587 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 41636 | { |  | 41588 | {
| 41637 | ERRWRAP2(_self_->copyTo(dst, stream)); |  | 41589 | ERRWRAP2(_self_->copyTo(dst, stream));
| 41638 | return pyopencv_from(dst); |  | 41590 | return pyopencv_from(dst);
| 41639 | } |  | 41591 | }
| 41640 |  |  | 41592 |
| 41641 |  |  | 41593 |
| 41642 | pyPopulateArgumentConversionErrors(); |  | 41594 | pyPopulateArgumentConversionErrors();
| 41643 | } |  | 41595 | }
| 41644 |  |  | 41596 |
| 41645 |  |  | 41597 |
| 41646 | { |  | 41598 | {
| 41647 | PyObject* pyobj_dst = NULL; |  | 41599 | PyObject* pyobj_dst = NULL;
| 41648 | GpuMat dst; |  | 41600 | GpuMat dst;
| 41649 | PyObject* pyobj_mask = NULL; |  | 41601 | PyObject* pyobj_mask = NULL;
| 41650 | GpuMat mask; |  | 41602 | GpuMat mask;
| 41651 |  |  | 41603 |
| 41652 | const char* keywords[] = { "mask", "dst", NULL }; |  | 41604 | const char* keywords[] = { "mask", "dst", NULL };
| 41653 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_mask, &pyobj_dst) && |  | 41605 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_mask, &pyobj_dst) &&
| 41654 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41606 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41655 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 41607 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 41656 | { |  | 41608 | {
| 41657 | ERRWRAP2(_self_->copyTo(dst, mask)); |  | 41609 | ERRWRAP2(_self_->copyTo(dst, mask));
| 41658 | return pyopencv_from(dst); |  | 41610 | return pyopencv_from(dst);
| 41659 | } |  | 41611 | }
| 41660 |  |  | 41612 |
| 41661 |  |  | 41613 |
| 41662 | pyPopulateArgumentConversionErrors(); |  | 41614 | pyPopulateArgumentConversionErrors();
| 41663 | } |  | 41615 | }
| 41664 |  |  | 41616 |
| 41665 |  |  | 41617 |
| 41666 | { |  | 41618 | {
| 41667 | PyObject* pyobj_dst = NULL; |  | 41619 | PyObject* pyobj_dst = NULL;
| 41668 | GpuMat dst; |  | 41620 | GpuMat dst;
| 41669 | PyObject* pyobj_mask = NULL; |  | 41621 | PyObject* pyobj_mask = NULL;
| 41670 | GpuMat mask; |  | 41622 | GpuMat mask;
| 41671 | PyObject* pyobj_stream = NULL; |  | 41623 | PyObject* pyobj_stream = NULL;
| 41672 | Stream stream=Stream::Null(); |  | 41624 | Stream stream=Stream::Null();
| 41673 |  |  | 41625 |
| 41674 | const char* keywords[] = { "mask", "stream", "dst", NULL }; |  | 41626 | const char* keywords[] = { "mask", "stream", "dst", NULL };
| 41675 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_mask, &pyobj_stream, &pyobj_dst) && |  | 41627 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:cuda_GpuMat.copyTo", (char**)keywords, &pyobj_mask, &pyobj_stream, &pyobj_dst) &&
| 41676 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41628 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41677 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 41629 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 41678 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 41630 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 41679 | { |  | 41631 | {
| 41680 | ERRWRAP2(_self_->copyTo(dst, mask, stream)); |  | 41632 | ERRWRAP2(_self_->copyTo(dst, mask, stream));
| 41681 | return pyopencv_from(dst); |  | 41633 | return pyopencv_from(dst);
| 41682 | } |  | 41634 | }
| 41683 |  |  | 41635 |
| 41684 |  |  | 41636 |
| 41685 | pyPopulateArgumentConversionErrors(); |  | 41637 | pyPopulateArgumentConversionErrors();
| 41686 | } |  | 41638 | }
| 41687 | pyRaiseCVOverloadException("copyTo"); |  | 41639 | pyRaiseCVOverloadException("copyTo");
| 41688 |  |  | 41640 |
| 41689 | return NULL; |  | 41641 | return NULL;
| 41690 | } |  | 41642 | }
| 41691 |  |  | 41643 |
| 41692 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_create(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41644 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_create(PyObject* self, PyObject* py_args, PyObject* kw)
| 41693 | { |  | 41645 | {
| 41694 | using namespace cv::cuda; |  | 41646 | using namespace cv::cuda;
| 41695 |  |  | 41647 |
| 41696 |  |  | 41648 |
| 41697 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41649 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41698 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41650 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41699 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41651 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41700 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41652 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41701 | pyPrepareArgumentConversionErrorsStorage(2); |  | 41653 | pyPrepareArgumentConversionErrorsStorage(2);
| 41702 |  |  | 41654 |
| 41703 | { |  | 41655 | {
| 41704 | PyObject* pyobj_rows = NULL; |  | 41656 | PyObject* pyobj_rows = NULL;
| 41705 | int rows=0; |  | 41657 | int rows=0;
| 41706 | PyObject* pyobj_cols = NULL; |  | 41658 | PyObject* pyobj_cols = NULL;
| 41707 | int cols=0; |  | 41659 | int cols=0;
| 41708 | PyObject* pyobj_type = NULL; |  | 41660 | PyObject* pyobj_type = NULL;
| 41709 | int type=0; |  | 41661 | int type=0;
| 41710 |  |  | 41662 |
| 41711 | const char* keywords[] = { "rows", "cols", "type", NULL }; |  | 41663 | const char* keywords[] = { "rows", "cols", "type", NULL };
| 41712 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type) && |  | 41664 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type) &&
| 41713 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 41665 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 41714 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 41666 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 41715 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 41667 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 41716 | { |  | 41668 | {
| 41717 | ERRWRAP2(_self_->create(rows, cols, type)); |  | 41669 | ERRWRAP2(_self_->create(rows, cols, type));
| 41718 | Py_RETURN_NONE; |  | 41670 | Py_RETURN_NONE;
| 41719 | } |  | 41671 | }
| 41720 |  |  | 41672 |
| 41721 |  |  | 41673 |
| 41722 | pyPopulateArgumentConversionErrors(); |  | 41674 | pyPopulateArgumentConversionErrors();
| 41723 | } |  | 41675 | }
| 41724 |  |  | 41676 |
| 41725 |  |  | 41677 |
| 41726 | { |  | 41678 | {
| 41727 | PyObject* pyobj_size = NULL; |  | 41679 | PyObject* pyobj_size = NULL;
| 41728 | Size size; |  | 41680 | Size size;
| 41729 | PyObject* pyobj_type = NULL; |  | 41681 | PyObject* pyobj_type = NULL;
| 41730 | int type=0; |  | 41682 | int type=0;
| 41731 |  |  | 41683 |
| 41732 | const char* keywords[] = { "size", "type", NULL }; |  | 41684 | const char* keywords[] = { "size", "type", NULL };
| 41733 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.create", (char**)keywords, &pyobj_size, &pyobj_type) && |  | 41685 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.create", (char**)keywords, &pyobj_size, &pyobj_type) &&
| 41734 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 41686 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 41735 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 41687 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 41736 | { |  | 41688 | {
| 41737 | ERRWRAP2(_self_->create(size, type)); |  | 41689 | ERRWRAP2(_self_->create(size, type));
| 41738 | Py_RETURN_NONE; |  | 41690 | Py_RETURN_NONE;
| 41739 | } |  | 41691 | }
| 41740 |  |  | 41692 |
| 41741 |  |  | 41693 |
| 41742 | pyPopulateArgumentConversionErrors(); |  | 41694 | pyPopulateArgumentConversionErrors();
| 41743 | } |  | 41695 | }
| 41744 | pyRaiseCVOverloadException("create"); |  | 41696 | pyRaiseCVOverloadException("create");
| 41745 |  |  | 41697 |
| 41746 | return NULL; |  | 41698 | return NULL;
| 41747 | } |  | 41699 | }
| 41748 |  |  | 41700 |
| 41749 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_cudaPtr(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41701 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_cudaPtr(PyObject* self, PyObject* py_args, PyObject* kw)
| 41750 | { |  | 41702 | {
| 41751 | using namespace cv::cuda; |  | 41703 | using namespace cv::cuda;
| 41752 |  |  | 41704 |
| 41753 |  |  | 41705 |
| 41754 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41706 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41755 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41707 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41756 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41708 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41757 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41709 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41758 | void* retval; |  | 41710 | void* retval;
| 41759 |  |  | 41711 |
| 41760 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41712 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41761 | { |  | 41713 | {
| 41762 | ERRWRAP2(retval = _self_->cudaPtr()); |  | 41714 | ERRWRAP2(retval = _self_->cudaPtr());
| 41763 | return pyopencv_from(retval); |  | 41715 | return pyopencv_from(retval);
| 41764 | } |  | 41716 | }
| 41765 |  |  | 41717 |
| 41766 | return NULL; |  | 41718 | return NULL;
| 41767 | } |  | 41719 | }
| 41768 |  |  | 41720 |
| 41769 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_defaultAllocator_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41721 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_defaultAllocator_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 41770 | { |  | 41722 | {
| 41771 | using namespace cv::cuda; |  | 41723 | using namespace cv::cuda;
| 41772 |  |  | 41724 |
| 41773 | GpuMat::Allocator* retval; |  | 41725 | GpuMat::Allocator* retval;
| 41774 |  |  | 41726 |
| 41775 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41727 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41776 | { |  | 41728 | {
| 41777 | ERRWRAP2(retval = cv::cuda::GpuMat::defaultAllocator()); |  | 41729 | ERRWRAP2(retval = cv::cuda::GpuMat::defaultAllocator());
| 41778 | return pyopencv_from(retval); |  | 41730 | return pyopencv_from(retval);
| 41779 | } |  | 41731 | }
| 41780 |  |  | 41732 |
| 41781 | return NULL; |  | 41733 | return NULL;
| 41782 | } |  | 41734 | }
| 41783 |  |  | 41735 |
| 41784 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_depth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41736 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_depth(PyObject* self, PyObject* py_args, PyObject* kw)
| 41785 | { |  | 41737 | {
| 41786 | using namespace cv::cuda; |  | 41738 | using namespace cv::cuda;
| 41787 |  |  | 41739 |
| 41788 |  |  | 41740 |
| 41789 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41741 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41790 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41742 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41791 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41743 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41792 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41744 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41793 | int retval; |  | 41745 | int retval;
| 41794 |  |  | 41746 |
| 41795 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41747 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41796 | { |  | 41748 | {
| 41797 | ERRWRAP2(retval = _self_->depth()); |  | 41749 | ERRWRAP2(retval = _self_->depth());
| 41798 | return pyopencv_from(retval); |  | 41750 | return pyopencv_from(retval);
| 41799 | } |  | 41751 | }
| 41800 |  |  | 41752 |
| 41801 | return NULL; |  | 41753 | return NULL;
| 41802 | } |  | 41754 | }
| 41803 |  |  | 41755 |
| 41804 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_download(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41756 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_download(PyObject* self, PyObject* py_args, PyObject* kw)
| 41805 | { |  | 41757 | {
| 41806 | using namespace cv::cuda; |  | 41758 | using namespace cv::cuda;
| 41807 |  |  | 41759 |
| 41808 |  |  | 41760 |
| 41809 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41761 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41810 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41762 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41811 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41763 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41812 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41764 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41813 | pyPrepareArgumentConversionErrorsStorage(6); |  | 41765 | pyPrepareArgumentConversionErrorsStorage(6);
| 41814 |  |  | 41766 |
| 41815 | { |  | 41767 | {
| 41816 | PyObject* pyobj_dst = NULL; |  | 41768 | PyObject* pyobj_dst = NULL;
| 41817 | Mat dst; |  | 41769 | Mat dst;
| 41818 |  |  | 41770 |
| 41819 | const char* keywords[] = { "dst", NULL }; |  | 41771 | const char* keywords[] = { "dst", NULL };
| 41820 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.download", (char**)keywords, &pyobj_dst) && |  | 41772 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.download", (char**)keywords, &pyobj_dst) &&
| 41821 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 41773 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 41822 | { |  | 41774 | {
| 41823 | ERRWRAP2(_self_->download(dst)); |  | 41775 | ERRWRAP2(_self_->download(dst));
| 41824 | return pyopencv_from(dst); |  | 41776 | return pyopencv_from(dst);
| 41825 | } |  | 41777 | }
| 41826 |  |  | 41778 |
| 41827 |  |  | 41779 |
| 41828 | pyPopulateArgumentConversionErrors(); |  | 41780 | pyPopulateArgumentConversionErrors();
| 41829 | } |  | 41781 | }
| 41830 |  |  | 41782 |
| 41831 |  |  | 41783 |
| 41832 | { |  | 41784 | {
| 41833 | PyObject* pyobj_dst = NULL; |  | 41785 | PyObject* pyobj_dst = NULL;
| 41834 | cuda::GpuMat dst; |  | 41786 | cuda::GpuMat dst;
| 41835 |  |  | 41787 |
| 41836 | const char* keywords[] = { "dst", NULL }; |  | 41788 | const char* keywords[] = { "dst", NULL };
| 41837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.download", (char**)keywords, &pyobj_dst) && |  | 41789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.download", (char**)keywords, &pyobj_dst) &&
| 41838 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 41790 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 41839 | { |  | 41791 | {
| 41840 | ERRWRAP2(_self_->download(dst)); |  | 41792 | ERRWRAP2(_self_->download(dst));
| 41841 | return pyopencv_from(dst); |  | 41793 | return pyopencv_from(dst);
| 41842 | } |  | 41794 | }
| 41843 |  |  | 41795 |
| 41844 |  |  | 41796 |
| 41845 | pyPopulateArgumentConversionErrors(); |  | 41797 | pyPopulateArgumentConversionErrors();
| 41846 | } |  | 41798 | }
| 41847 |  |  | 41799 |
| 41848 |  |  | 41800 |
| 41849 | { |  | 41801 | {
| 41850 | PyObject* pyobj_dst = NULL; |  | 41802 | PyObject* pyobj_dst = NULL;
| 41851 | Mat dst; |  | 41803 | Mat dst;
| 41852 | PyObject* pyobj_stream = NULL; |  | 41804 | PyObject* pyobj_stream = NULL;
| 41853 | Stream stream=Stream::Null(); |  | 41805 | Stream stream=Stream::Null();
| 41854 |  |  | 41806 |
| 41855 | const char* keywords[] = { "stream", "dst", NULL }; |  | 41807 | const char* keywords[] = { "stream", "dst", NULL };
| 41856 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.download", (char**)keywords, &pyobj_stream, &pyobj_dst) && |  | 41808 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.download", (char**)keywords, &pyobj_stream, &pyobj_dst) &&
| 41857 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41809 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41858 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 41810 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 41859 | { |  | 41811 | {
| 41860 | ERRWRAP2(_self_->download(dst, stream)); |  | 41812 | ERRWRAP2(_self_->download(dst, stream));
| 41861 | return pyopencv_from(dst); |  | 41813 | return pyopencv_from(dst);
| 41862 | } |  | 41814 | }
| 41863 |  |  | 41815 |
| 41864 |  |  | 41816 |
| 41865 | pyPopulateArgumentConversionErrors(); |  | 41817 | pyPopulateArgumentConversionErrors();
| 41866 | } |  | 41818 | }
| 41867 |  |  | 41819 |
| 41868 |  |  | 41820 |
| 41869 | { |  | 41821 | {
| 41870 | PyObject* pyobj_dst = NULL; |  | 41822 | PyObject* pyobj_dst = NULL;
| 41871 | cuda::GpuMat dst; |  | 41823 | cuda::GpuMat dst;
| 41872 | PyObject* pyobj_stream = NULL; |  | 41824 | PyObject* pyobj_stream = NULL;
| 41873 | Stream stream=Stream::Null(); |  | 41825 | Stream stream=Stream::Null();
| 41874 |  |  | 41826 |
| 41875 | const char* keywords[] = { "stream", "dst", NULL }; |  | 41827 | const char* keywords[] = { "stream", "dst", NULL };
| 41876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.download", (char**)keywords, &pyobj_stream, &pyobj_dst) && |  | 41828 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.download", (char**)keywords, &pyobj_stream, &pyobj_dst) &&
| 41877 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41829 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41878 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 41830 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 41879 | { |  | 41831 | {
| 41880 | ERRWRAP2(_self_->download(dst, stream)); |  | 41832 | ERRWRAP2(_self_->download(dst, stream));
| 41881 | return pyopencv_from(dst); |  | 41833 | return pyopencv_from(dst);
| 41882 | } |  | 41834 | }
| 41883 |  |  | 41835 |
| 41884 |  |  | 41836 |
| 41885 | pyPopulateArgumentConversionErrors(); |  | 41837 | pyPopulateArgumentConversionErrors();
| 41886 | } |  | 41838 | }
| 41887 |  |  | 41839 |
| 41888 |  |  | 41840 |
| 41889 | { |  | 41841 | {
| 41890 | PyObject* pyobj_dst = NULL; |  | 41842 | PyObject* pyobj_dst = NULL;
| 41891 | UMat dst; |  | 41843 | UMat dst;
| 41892 |  |  | 41844 |
| 41893 | const char* keywords[] = { "dst", NULL }; |  | 41845 | const char* keywords[] = { "dst", NULL };
| 41894 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.download", (char**)keywords, &pyobj_dst) && |  | 41846 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:cuda_GpuMat.download", (char**)keywords, &pyobj_dst) &&
| 41895 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 41847 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 41896 | { |  | 41848 | {
| 41897 | ERRWRAP2(_self_->download(dst)); |  | 41849 | ERRWRAP2(_self_->download(dst));
| 41898 | return pyopencv_from(dst); |  | 41850 | return pyopencv_from(dst);
| 41899 | } |  | 41851 | }
| 41900 |  |  | 41852 |
| 41901 |  |  | 41853 |
| 41902 | pyPopulateArgumentConversionErrors(); |  | 41854 | pyPopulateArgumentConversionErrors();
| 41903 | } |  | 41855 | }
| 41904 |  |  | 41856 |
| 41905 |  |  | 41857 |
| 41906 | { |  | 41858 | {
| 41907 | PyObject* pyobj_dst = NULL; |  | 41859 | PyObject* pyobj_dst = NULL;
| 41908 | UMat dst; |  | 41860 | UMat dst;
| 41909 | PyObject* pyobj_stream = NULL; |  | 41861 | PyObject* pyobj_stream = NULL;
| 41910 | Stream stream=Stream::Null(); |  | 41862 | Stream stream=Stream::Null();
| 41911 |  |  | 41863 |
| 41912 | const char* keywords[] = { "stream", "dst", NULL }; |  | 41864 | const char* keywords[] = { "stream", "dst", NULL };
| 41913 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.download", (char**)keywords, &pyobj_stream, &pyobj_dst) && |  | 41865 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.download", (char**)keywords, &pyobj_stream, &pyobj_dst) &&
| 41914 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 41866 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 41915 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 41867 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 41916 | { |  | 41868 | {
| 41917 | ERRWRAP2(_self_->download(dst, stream)); |  | 41869 | ERRWRAP2(_self_->download(dst, stream));
| 41918 | return pyopencv_from(dst); |  | 41870 | return pyopencv_from(dst);
| 41919 | } |  | 41871 | }
| 41920 |  |  | 41872 |
| 41921 |  |  | 41873 |
| 41922 | pyPopulateArgumentConversionErrors(); |  | 41874 | pyPopulateArgumentConversionErrors();
| 41923 | } |  | 41875 | }
| 41924 | pyRaiseCVOverloadException("download"); |  | 41876 | pyRaiseCVOverloadException("download");
| 41925 |  |  | 41877 |
| 41926 | return NULL; |  | 41878 | return NULL;
| 41927 | } |  | 41879 | }
| 41928 |  |  | 41880 |
| 41929 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_elemSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41881 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_elemSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 41930 | { |  | 41882 | {
| 41931 | using namespace cv::cuda; |  | 41883 | using namespace cv::cuda;
| 41932 |  |  | 41884 |
| 41933 |  |  | 41885 |
| 41934 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41886 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41935 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41887 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41936 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41888 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41937 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41889 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41938 | size_t retval; |  | 41890 | size_t retval;
| 41939 |  |  | 41891 |
| 41940 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41892 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41941 | { |  | 41893 | {
| 41942 | ERRWRAP2(retval = _self_->elemSize()); |  | 41894 | ERRWRAP2(retval = _self_->elemSize());
| 41943 | return pyopencv_from(retval); |  | 41895 | return pyopencv_from(retval);
| 41944 | } |  | 41896 | }
| 41945 |  |  | 41897 |
| 41946 | return NULL; |  | 41898 | return NULL;
| 41947 | } |  | 41899 | }
| 41948 |  |  | 41900 |
| 41949 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_elemSize1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41901 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_elemSize1(PyObject* self, PyObject* py_args, PyObject* kw)
| 41950 | { |  | 41902 | {
| 41951 | using namespace cv::cuda; |  | 41903 | using namespace cv::cuda;
| 41952 |  |  | 41904 |
| 41953 |  |  | 41905 |
| 41954 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41906 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41955 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41907 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41956 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41908 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41957 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41909 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41958 | size_t retval; |  | 41910 | size_t retval;
| 41959 |  |  | 41911 |
| 41960 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41912 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41961 | { |  | 41913 | {
| 41962 | ERRWRAP2(retval = _self_->elemSize1()); |  | 41914 | ERRWRAP2(retval = _self_->elemSize1());
| 41963 | return pyopencv_from(retval); |  | 41915 | return pyopencv_from(retval);
| 41964 | } |  | 41916 | }
| 41965 |  |  | 41917 |
| 41966 | return NULL; |  | 41918 | return NULL;
| 41967 | } |  | 41919 | }
| 41968 |  |  | 41920 |
| 41969 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41921 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 41970 | { |  | 41922 | {
| 41971 | using namespace cv::cuda; |  | 41923 | using namespace cv::cuda;
| 41972 |  |  | 41924 |
| 41973 |  |  | 41925 |
| 41974 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41926 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 41975 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41927 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 41976 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41928 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 41977 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41929 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 41978 | bool retval; |  | 41930 | bool retval;
| 41979 |  |  | 41931 |
| 41980 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41932 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41981 | { |  | 41933 | {
| 41982 | ERRWRAP2(retval = _self_->empty()); |  | 41934 | ERRWRAP2(retval = _self_->empty());
| 41983 | return pyopencv_from(retval); |  | 41935 | return pyopencv_from(retval);
| 41984 | } |  | 41936 | }
| 41985 |  |  | 41937 |
| 41986 | return NULL; |  | 41938 | return NULL;
| 41987 | } |  | 41939 | }
| 41988 |  |  | 41940 |
| 41989 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_getStdAllocator_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41941 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_getStdAllocator_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 41990 | { |  | 41942 | {
| 41991 | using namespace cv::cuda; |  | 41943 | using namespace cv::cuda;
| 41992 |  |  | 41944 |
| 41993 | GpuMat::Allocator* retval; |  | 41945 | GpuMat::Allocator* retval;
| 41994 |  |  | 41946 |
| 41995 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41947 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 41996 | { |  | 41948 | {
| 41997 | ERRWRAP2(retval = cv::cuda::GpuMat::getStdAllocator()); |  | 41949 | ERRWRAP2(retval = cv::cuda::GpuMat::getStdAllocator());
| 41998 | return pyopencv_from(retval); |  | 41950 | return pyopencv_from(retval);
| 41999 | } |  | 41951 | }
| 42000 |  |  | 41952 |
| 42001 | return NULL; |  | 41953 | return NULL;
| 42002 | } |  | 41954 | }
| 42003 |  |  | 41955 |
| 42004 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_isContinuous(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41956 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_isContinuous(PyObject* self, PyObject* py_args, PyObject* kw)
| 42005 | { |  | 41957 | {
| 42006 | using namespace cv::cuda; |  | 41958 | using namespace cv::cuda;
| 42007 |  |  | 41959 |
| 42008 |  |  | 41960 |
| 42009 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41961 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42010 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41962 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42011 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41963 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42012 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41964 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42013 | bool retval; |  | 41965 | bool retval;
| 42014 |  |  | 41966 |
| 42015 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 41967 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42016 | { |  | 41968 | {
| 42017 | ERRWRAP2(retval = _self_->isContinuous()); |  | 41969 | ERRWRAP2(retval = _self_->isContinuous());
| 42018 | return pyopencv_from(retval); |  | 41970 | return pyopencv_from(retval);
| 42019 | } |  | 41971 | }
| 42020 |  |  | 41972 |
| 42021 | return NULL; |  | 41973 | return NULL;
| 42022 | } |  | 41974 | }
| 42023 |  |  | 41975 |
| 42024 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_locateROI(PyObject* self, PyObject* py_args, PyObject* kw) |  | 41976 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_locateROI(PyObject* self, PyObject* py_args, PyObject* kw)
| 42025 | { |  | 41977 | {
| 42026 | using namespace cv::cuda; |  | 41978 | using namespace cv::cuda;
| 42027 |  |  | 41979 |
| 42028 |  |  | 41980 |
| 42029 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 41981 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42030 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 41982 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42031 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 41983 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42032 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 41984 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42033 | PyObject* pyobj_wholeSize = NULL; |  | 41985 | PyObject* pyobj_wholeSize = NULL;
| 42034 | Size wholeSize; |  | 41986 | Size wholeSize;
| 42035 | PyObject* pyobj_ofs = NULL; |  | 41987 | PyObject* pyobj_ofs = NULL;
| 42036 | Point ofs; |  | 41988 | Point ofs;
| 42037 |  |  | 41989 |
| 42038 | const char* keywords[] = { "wholeSize", "ofs", NULL }; |  | 41990 | const char* keywords[] = { "wholeSize", "ofs", NULL };
| 42039 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.locateROI", (char**)keywords, &pyobj_wholeSize, &pyobj_ofs) && |  | 41991 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.locateROI", (char**)keywords, &pyobj_wholeSize, &pyobj_ofs) &&
| 42040 | pyopencv_to_safe(pyobj_wholeSize, wholeSize, ArgInfo("wholeSize", 0)) && |  | 41992 | pyopencv_to_safe(pyobj_wholeSize, wholeSize, ArgInfo("wholeSize", 0)) &&
| 42041 | pyopencv_to_safe(pyobj_ofs, ofs, ArgInfo("ofs", 0)) ) |  | 41993 | pyopencv_to_safe(pyobj_ofs, ofs, ArgInfo("ofs", 0)) )
| 42042 | { |  | 41994 | {
| 42043 | ERRWRAP2(_self_->locateROI(wholeSize, ofs)); |  | 41995 | ERRWRAP2(_self_->locateROI(wholeSize, ofs));
| 42044 | Py_RETURN_NONE; |  | 41996 | Py_RETURN_NONE;
| 42045 | } |  | 41997 | }
| 42046 |  |  | 41998 |
| 42047 | return NULL; |  | 41999 | return NULL;
| 42048 | } |  | 42000 | }
| 42049 |  |  | 42001 |
| 42050 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42002 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 42051 | { |  | 42003 | {
| 42052 | using namespace cv::cuda; |  | 42004 | using namespace cv::cuda;
| 42053 |  |  | 42005 |
| 42054 |  |  | 42006 |
| 42055 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42007 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42056 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42008 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42057 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42009 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42058 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42010 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42059 |  |  | 42011 |
| 42060 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42012 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42061 | { |  | 42013 | {
| 42062 | ERRWRAP2(_self_->release()); |  | 42014 | ERRWRAP2(_self_->release());
| 42063 | Py_RETURN_NONE; |  | 42015 | Py_RETURN_NONE;
| 42064 | } |  | 42016 | }
| 42065 |  |  | 42017 |
| 42066 | return NULL; |  | 42018 | return NULL;
| 42067 | } |  | 42019 | }
| 42068 |  |  | 42020 |
| 42069 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_reshape(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42021 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_reshape(PyObject* self, PyObject* py_args, PyObject* kw)
| 42070 | { |  | 42022 | {
| 42071 | using namespace cv::cuda; |  | 42023 | using namespace cv::cuda;
| 42072 |  |  | 42024 |
| 42073 |  |  | 42025 |
| 42074 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42026 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42075 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42027 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42076 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42028 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42077 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42029 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42078 | PyObject* pyobj_cn = NULL; |  | 42030 | PyObject* pyobj_cn = NULL;
| 42079 | int cn=0; |  | 42031 | int cn=0;
| 42080 | PyObject* pyobj_rows = NULL; |  | 42032 | PyObject* pyobj_rows = NULL;
| 42081 | int rows=0; |  | 42033 | int rows=0;
| 42082 | GpuMat retval; |  | 42034 | GpuMat retval;
| 42083 |  |  | 42035 |
| 42084 | const char* keywords[] = { "cn", "rows", NULL }; |  | 42036 | const char* keywords[] = { "cn", "rows", NULL };
| 42085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.reshape", (char**)keywords, &pyobj_cn, &pyobj_rows) && |  | 42037 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_GpuMat.reshape", (char**)keywords, &pyobj_cn, &pyobj_rows) &&
| 42086 | pyopencv_to_safe(pyobj_cn, cn, ArgInfo("cn", 0)) && |  | 42038 | pyopencv_to_safe(pyobj_cn, cn, ArgInfo("cn", 0)) &&
| 42087 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) ) |  | 42039 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) )
| 42088 | { |  | 42040 | {
| 42089 | ERRWRAP2(retval = _self_->reshape(cn, rows)); |  | 42041 | ERRWRAP2(retval = _self_->reshape(cn, rows));
| 42090 | return pyopencv_from(retval); |  | 42042 | return pyopencv_from(retval);
| 42091 | } |  | 42043 | }
| 42092 |  |  | 42044 |
| 42093 | return NULL; |  | 42045 | return NULL;
| 42094 | } |  | 42046 | }
| 42095 |  |  | 42047 |
| 42096 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_row(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42048 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_row(PyObject* self, PyObject* py_args, PyObject* kw)
| 42097 | { |  | 42049 | {
| 42098 | using namespace cv::cuda; |  | 42050 | using namespace cv::cuda;
| 42099 |  |  | 42051 |
| 42100 |  |  | 42052 |
| 42101 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42053 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42102 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42054 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42103 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42055 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42104 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42056 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42105 | PyObject* pyobj_y = NULL; |  | 42057 | PyObject* pyobj_y = NULL;
| 42106 | int y=0; |  | 42058 | int y=0;
| 42107 | GpuMat retval; |  | 42059 | GpuMat retval;
| 42108 |  |  | 42060 |
| 42109 | const char* keywords[] = { "y", NULL }; |  | 42061 | const char* keywords[] = { "y", NULL };
| 42110 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.row", (char**)keywords, &pyobj_y) && |  | 42062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.row", (char**)keywords, &pyobj_y) &&
| 42111 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) ) |  | 42063 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) )
| 42112 | { |  | 42064 | {
| 42113 | ERRWRAP2(retval = _self_->row(y)); |  | 42065 | ERRWRAP2(retval = _self_->row(y));
| 42114 | return pyopencv_from(retval); |  | 42066 | return pyopencv_from(retval);
| 42115 | } |  | 42067 | }
| 42116 |  |  | 42068 |
| 42117 | return NULL; |  | 42069 | return NULL;
| 42118 | } |  | 42070 | }
| 42119 |  |  | 42071 |
| 42120 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_rowRange(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42072 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_rowRange(PyObject* self, PyObject* py_args, PyObject* kw)
| 42121 | { |  | 42073 | {
| 42122 | using namespace cv::cuda; |  | 42074 | using namespace cv::cuda;
| 42123 |  |  | 42075 |
| 42124 |  |  | 42076 |
| 42125 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42077 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42126 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42078 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42127 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42079 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42128 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42080 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42129 | pyPrepareArgumentConversionErrorsStorage(2); |  | 42081 | pyPrepareArgumentConversionErrorsStorage(2);
| 42130 |  |  | 42082 |
| 42131 | { |  | 42083 | {
| 42132 | PyObject* pyobj_startrow = NULL; |  | 42084 | PyObject* pyobj_startrow = NULL;
| 42133 | int startrow=0; |  | 42085 | int startrow=0;
| 42134 | PyObject* pyobj_endrow = NULL; |  | 42086 | PyObject* pyobj_endrow = NULL;
| 42135 | int endrow=0; |  | 42087 | int endrow=0;
| 42136 | GpuMat retval; |  | 42088 | GpuMat retval;
| 42137 |  |  | 42089 |
| 42138 | const char* keywords[] = { "startrow", "endrow", NULL }; |  | 42090 | const char* keywords[] = { "startrow", "endrow", NULL };
| 42139 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.rowRange", (char**)keywords, &pyobj_startrow, &pyobj_endrow) && |  | 42091 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.rowRange", (char**)keywords, &pyobj_startrow, &pyobj_endrow) &&
| 42140 | pyopencv_to_safe(pyobj_startrow, startrow, ArgInfo("startrow", 0)) && |  | 42092 | pyopencv_to_safe(pyobj_startrow, startrow, ArgInfo("startrow", 0)) &&
| 42141 | pyopencv_to_safe(pyobj_endrow, endrow, ArgInfo("endrow", 0)) ) |  | 42093 | pyopencv_to_safe(pyobj_endrow, endrow, ArgInfo("endrow", 0)) )
| 42142 | { |  | 42094 | {
| 42143 | ERRWRAP2(retval = _self_->rowRange(startrow, endrow)); |  | 42095 | ERRWRAP2(retval = _self_->rowRange(startrow, endrow));
| 42144 | return pyopencv_from(retval); |  | 42096 | return pyopencv_from(retval);
| 42145 | } |  | 42097 | }
| 42146 |  |  | 42098 |
| 42147 |  |  | 42099 |
| 42148 | pyPopulateArgumentConversionErrors(); |  | 42100 | pyPopulateArgumentConversionErrors();
| 42149 | } |  | 42101 | }
| 42150 |  |  | 42102 |
| 42151 |  |  | 42103 |
| 42152 | { |  | 42104 | {
| 42153 | PyObject* pyobj_r = NULL; |  | 42105 | PyObject* pyobj_r = NULL;
| 42154 | Range r; |  | 42106 | Range r;
| 42155 | GpuMat retval; |  | 42107 | GpuMat retval;
| 42156 |  |  | 42108 |
| 42157 | const char* keywords[] = { "r", NULL }; |  | 42109 | const char* keywords[] = { "r", NULL };
| 42158 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.rowRange", (char**)keywords, &pyobj_r) && |  | 42110 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.rowRange", (char**)keywords, &pyobj_r) &&
| 42159 | pyopencv_to_safe(pyobj_r, r, ArgInfo("r", 0)) ) |  | 42111 | pyopencv_to_safe(pyobj_r, r, ArgInfo("r", 0)) )
| 42160 | { |  | 42112 | {
| 42161 | ERRWRAP2(retval = _self_->rowRange(r)); |  | 42113 | ERRWRAP2(retval = _self_->rowRange(r));
| 42162 | return pyopencv_from(retval); |  | 42114 | return pyopencv_from(retval);
| 42163 | } |  | 42115 | }
| 42164 |  |  | 42116 |
| 42165 |  |  | 42117 |
| 42166 | pyPopulateArgumentConversionErrors(); |  | 42118 | pyPopulateArgumentConversionErrors();
| 42167 | } |  | 42119 | }
| 42168 | pyRaiseCVOverloadException("rowRange"); |  | 42120 | pyRaiseCVOverloadException("rowRange");
| 42169 |  |  | 42121 |
| 42170 | return NULL; |  | 42122 | return NULL;
| 42171 | } |  | 42123 | }
| 42172 |  |  | 42124 |
| 42173 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_setDefaultAllocator_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42125 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_setDefaultAllocator_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 42174 | { |  | 42126 | {
| 42175 | using namespace cv::cuda; |  | 42127 | using namespace cv::cuda;
| 42176 |  |  | 42128 |
| 42177 | PyObject* pyobj_allocator = NULL; |  | 42129 | PyObject* pyobj_allocator = NULL;
| 42178 | GpuMat_Allocator* allocator; |  | 42130 | GpuMat_Allocator* allocator;
| 42179 |  |  | 42131 |
| 42180 | const char* keywords[] = { "allocator", NULL }; |  | 42132 | const char* keywords[] = { "allocator", NULL };
| 42181 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.setDefaultAllocator", (char**)keywords, &pyobj_allocator) && |  | 42133 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.setDefaultAllocator", (char**)keywords, &pyobj_allocator) &&
| 42182 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 42134 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 42183 | { |  | 42135 | {
| 42184 | ERRWRAP2(cv::cuda::GpuMat::setDefaultAllocator(allocator)); |  | 42136 | ERRWRAP2(cv::cuda::GpuMat::setDefaultAllocator(allocator));
| 42185 | Py_RETURN_NONE; |  | 42137 | Py_RETURN_NONE;
| 42186 | } |  | 42138 | }
| 42187 |  |  | 42139 |
| 42188 | return NULL; |  | 42140 | return NULL;
| 42189 | } |  | 42141 | }
| 42190 |  |  | 42142 |
| 42191 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_setTo(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42143 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_setTo(PyObject* self, PyObject* py_args, PyObject* kw)
| 42192 | { |  | 42144 | {
| 42193 | using namespace cv::cuda; |  | 42145 | using namespace cv::cuda;
| 42194 |  |  | 42146 |
| 42195 |  |  | 42147 |
| 42196 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42148 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42197 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42149 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42198 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42150 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42199 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42151 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42200 | pyPrepareArgumentConversionErrorsStorage(8); |  | 42152 | pyPrepareArgumentConversionErrorsStorage(8);
| 42201 |  |  | 42153 |
| 42202 | { |  | 42154 | {
| 42203 | PyObject* pyobj_s = NULL; |  | 42155 | PyObject* pyobj_s = NULL;
| 42204 | Scalar s; |  | 42156 | Scalar s;
| 42205 | GpuMat retval; |  | 42157 | GpuMat retval;
| 42206 |  |  | 42158 |
| 42207 | const char* keywords[] = { "s", NULL }; |  | 42159 | const char* keywords[] = { "s", NULL };
| 42208 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s) && |  | 42160 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s) &&
| 42209 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) ) |  | 42161 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) )
| 42210 | { |  | 42162 | {
| 42211 | ERRWRAP2(retval = _self_->setTo(s)); |  | 42163 | ERRWRAP2(retval = _self_->setTo(s));
| 42212 | return pyopencv_from(retval); |  | 42164 | return pyopencv_from(retval);
| 42213 | } |  | 42165 | }
| 42214 |  |  | 42166 |
| 42215 |  |  | 42167 |
| 42216 | pyPopulateArgumentConversionErrors(); |  | 42168 | pyPopulateArgumentConversionErrors();
| 42217 | } |  | 42169 | }
| 42218 |  |  | 42170 |
| 42219 |  |  | 42171 |
| 42220 | { |  | 42172 | {
| 42221 | PyObject* pyobj_s = NULL; |  | 42173 | PyObject* pyobj_s = NULL;
| 42222 | Scalar s; |  | 42174 | Scalar s;
| 42223 | PyObject* pyobj_stream = NULL; |  | 42175 | PyObject* pyobj_stream = NULL;
| 42224 | Stream stream=Stream::Null(); |  | 42176 | Stream stream=Stream::Null();
| 42225 | GpuMat retval; |  | 42177 | GpuMat retval;
| 42226 |  |  | 42178 |
| 42227 | const char* keywords[] = { "s", "stream", NULL }; |  | 42179 | const char* keywords[] = { "s", "stream", NULL };
| 42228 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_stream) && |  | 42180 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_stream) &&
| 42229 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 42181 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 42230 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 42182 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 42231 | { |  | 42183 | {
| 42232 | ERRWRAP2(retval = _self_->setTo(s, stream)); |  | 42184 | ERRWRAP2(retval = _self_->setTo(s, stream));
| 42233 | return pyopencv_from(retval); |  | 42185 | return pyopencv_from(retval);
| 42234 | } |  | 42186 | }
| 42235 |  |  | 42187 |
| 42236 |  |  | 42188 |
| 42237 | pyPopulateArgumentConversionErrors(); |  | 42189 | pyPopulateArgumentConversionErrors();
| 42238 | } |  | 42190 | }
| 42239 |  |  | 42191 |
| 42240 |  |  | 42192 |
| 42241 | { |  | 42193 | {
| 42242 | PyObject* pyobj_s = NULL; |  | 42194 | PyObject* pyobj_s = NULL;
| 42243 | Scalar s; |  | 42195 | Scalar s;
| 42244 | PyObject* pyobj_mask = NULL; |  | 42196 | PyObject* pyobj_mask = NULL;
| 42245 | Mat mask; |  | 42197 | Mat mask;
| 42246 | GpuMat retval; |  | 42198 | GpuMat retval;
| 42247 |  |  | 42199 |
| 42248 | const char* keywords[] = { "s", "mask", NULL }; |  | 42200 | const char* keywords[] = { "s", "mask", NULL };
| 42249 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask) && |  | 42201 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask) &&
| 42250 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 42202 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 42251 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 42203 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 42252 | { |  | 42204 | {
| 42253 | ERRWRAP2(retval = _self_->setTo(s, mask)); |  | 42205 | ERRWRAP2(retval = _self_->setTo(s, mask));
| 42254 | return pyopencv_from(retval); |  | 42206 | return pyopencv_from(retval);
| 42255 | } |  | 42207 | }
| 42256 |  |  | 42208 |
| 42257 |  |  | 42209 |
| 42258 | pyPopulateArgumentConversionErrors(); |  | 42210 | pyPopulateArgumentConversionErrors();
| 42259 | } |  | 42211 | }
| 42260 |  |  | 42212 |
| 42261 |  |  | 42213 |
| 42262 | { |  | 42214 | {
| 42263 | PyObject* pyobj_s = NULL; |  | 42215 | PyObject* pyobj_s = NULL;
| 42264 | Scalar s; |  | 42216 | Scalar s;
| 42265 | PyObject* pyobj_mask = NULL; |  | 42217 | PyObject* pyobj_mask = NULL;
| 42266 | cuda::GpuMat mask; |  | 42218 | cuda::GpuMat mask;
| 42267 | GpuMat retval; |  | 42219 | GpuMat retval;
| 42268 |  |  | 42220 |
| 42269 | const char* keywords[] = { "s", "mask", NULL }; |  | 42221 | const char* keywords[] = { "s", "mask", NULL };
| 42270 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask) && |  | 42222 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask) &&
| 42271 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 42223 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 42272 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 42224 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 42273 | { |  | 42225 | {
| 42274 | ERRWRAP2(retval = _self_->setTo(s, mask)); |  | 42226 | ERRWRAP2(retval = _self_->setTo(s, mask));
| 42275 | return pyopencv_from(retval); |  | 42227 | return pyopencv_from(retval);
| 42276 | } |  | 42228 | }
| 42277 |  |  | 42229 |
| 42278 |  |  | 42230 |
| 42279 | pyPopulateArgumentConversionErrors(); |  | 42231 | pyPopulateArgumentConversionErrors();
| 42280 | } |  | 42232 | }
| 42281 |  |  | 42233 |
| 42282 |  |  | 42234 |
| 42283 | { |  | 42235 | {
| 42284 | PyObject* pyobj_s = NULL; |  | 42236 | PyObject* pyobj_s = NULL;
| 42285 | Scalar s; |  | 42237 | Scalar s;
| 42286 | PyObject* pyobj_mask = NULL; |  | 42238 | PyObject* pyobj_mask = NULL;
| 42287 | Mat mask; |  | 42239 | Mat mask;
| 42288 | PyObject* pyobj_stream = NULL; |  | 42240 | PyObject* pyobj_stream = NULL;
| 42289 | Stream stream=Stream::Null(); |  | 42241 | Stream stream=Stream::Null();
| 42290 | GpuMat retval; |  | 42242 | GpuMat retval;
| 42291 |  |  | 42243 |
| 42292 | const char* keywords[] = { "s", "mask", "stream", NULL }; |  | 42244 | const char* keywords[] = { "s", "mask", "stream", NULL };
| 42293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask, &pyobj_stream) && |  | 42245 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask, &pyobj_stream) &&
| 42294 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 42246 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 42295 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 42247 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 42296 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 42248 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 42297 | { |  | 42249 | {
| 42298 | ERRWRAP2(retval = _self_->setTo(s, mask, stream)); |  | 42250 | ERRWRAP2(retval = _self_->setTo(s, mask, stream));
| 42299 | return pyopencv_from(retval); |  | 42251 | return pyopencv_from(retval);
| 42300 | } |  | 42252 | }
| 42301 |  |  | 42253 |
| 42302 |  |  | 42254 |
| 42303 | pyPopulateArgumentConversionErrors(); |  | 42255 | pyPopulateArgumentConversionErrors();
| 42304 | } |  | 42256 | }
| 42305 |  |  | 42257 |
| 42306 |  |  | 42258 |
| 42307 | { |  | 42259 | {
| 42308 | PyObject* pyobj_s = NULL; |  | 42260 | PyObject* pyobj_s = NULL;
| 42309 | Scalar s; |  | 42261 | Scalar s;
| 42310 | PyObject* pyobj_mask = NULL; |  | 42262 | PyObject* pyobj_mask = NULL;
| 42311 | cuda::GpuMat mask; |  | 42263 | cuda::GpuMat mask;
| 42312 | PyObject* pyobj_stream = NULL; |  | 42264 | PyObject* pyobj_stream = NULL;
| 42313 | Stream stream=Stream::Null(); |  | 42265 | Stream stream=Stream::Null();
| 42314 | GpuMat retval; |  | 42266 | GpuMat retval;
| 42315 |  |  | 42267 |
| 42316 | const char* keywords[] = { "s", "mask", "stream", NULL }; |  | 42268 | const char* keywords[] = { "s", "mask", "stream", NULL };
| 42317 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask, &pyobj_stream) && |  | 42269 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask, &pyobj_stream) &&
| 42318 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 42270 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 42319 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 42271 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 42320 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 42272 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 42321 | { |  | 42273 | {
| 42322 | ERRWRAP2(retval = _self_->setTo(s, mask, stream)); |  | 42274 | ERRWRAP2(retval = _self_->setTo(s, mask, stream));
| 42323 | return pyopencv_from(retval); |  | 42275 | return pyopencv_from(retval);
| 42324 | } |  | 42276 | }
| 42325 |  |  | 42277 |
| 42326 |  |  | 42278 |
| 42327 | pyPopulateArgumentConversionErrors(); |  | 42279 | pyPopulateArgumentConversionErrors();
| 42328 | } |  | 42280 | }
| 42329 |  |  | 42281 |
| 42330 |  |  | 42282 |
| 42331 | { |  | 42283 | {
| 42332 | PyObject* pyobj_s = NULL; |  | 42284 | PyObject* pyobj_s = NULL;
| 42333 | Scalar s; |  | 42285 | Scalar s;
| 42334 | PyObject* pyobj_mask = NULL; |  | 42286 | PyObject* pyobj_mask = NULL;
| 42335 | UMat mask; |  | 42287 | UMat mask;
| 42336 | GpuMat retval; |  | 42288 | GpuMat retval;
| 42337 |  |  | 42289 |
| 42338 | const char* keywords[] = { "s", "mask", NULL }; |  | 42290 | const char* keywords[] = { "s", "mask", NULL };
| 42339 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask) && |  | 42291 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask) &&
| 42340 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 42292 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 42341 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 42293 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 42342 | { |  | 42294 | {
| 42343 | ERRWRAP2(retval = _self_->setTo(s, mask)); |  | 42295 | ERRWRAP2(retval = _self_->setTo(s, mask));
| 42344 | return pyopencv_from(retval); |  | 42296 | return pyopencv_from(retval);
| 42345 | } |  | 42297 | }
| 42346 |  |  | 42298 |
| 42347 |  |  | 42299 |
| 42348 | pyPopulateArgumentConversionErrors(); |  | 42300 | pyPopulateArgumentConversionErrors();
| 42349 | } |  | 42301 | }
| 42350 |  |  | 42302 |
| 42351 |  |  | 42303 |
| 42352 | { |  | 42304 | {
| 42353 | PyObject* pyobj_s = NULL; |  | 42305 | PyObject* pyobj_s = NULL;
| 42354 | Scalar s; |  | 42306 | Scalar s;
| 42355 | PyObject* pyobj_mask = NULL; |  | 42307 | PyObject* pyobj_mask = NULL;
| 42356 | UMat mask; |  | 42308 | UMat mask;
| 42357 | PyObject* pyobj_stream = NULL; |  | 42309 | PyObject* pyobj_stream = NULL;
| 42358 | Stream stream=Stream::Null(); |  | 42310 | Stream stream=Stream::Null();
| 42359 | GpuMat retval; |  | 42311 | GpuMat retval;
| 42360 |  |  | 42312 |
| 42361 | const char* keywords[] = { "s", "mask", "stream", NULL }; |  | 42313 | const char* keywords[] = { "s", "mask", "stream", NULL };
| 42362 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask, &pyobj_stream) && |  | 42314 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_GpuMat.setTo", (char**)keywords, &pyobj_s, &pyobj_mask, &pyobj_stream) &&
| 42363 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) && |  | 42315 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) &&
| 42364 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 42316 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 42365 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 42317 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 42366 | { |  | 42318 | {
| 42367 | ERRWRAP2(retval = _self_->setTo(s, mask, stream)); |  | 42319 | ERRWRAP2(retval = _self_->setTo(s, mask, stream));
| 42368 | return pyopencv_from(retval); |  | 42320 | return pyopencv_from(retval);
| 42369 | } |  | 42321 | }
| 42370 |  |  | 42322 |
| 42371 |  |  | 42323 |
| 42372 | pyPopulateArgumentConversionErrors(); |  | 42324 | pyPopulateArgumentConversionErrors();
| 42373 | } |  | 42325 | }
| 42374 | pyRaiseCVOverloadException("setTo"); |  | 42326 | pyRaiseCVOverloadException("setTo");
| 42375 |  |  | 42327 |
| 42376 | return NULL; |  | 42328 | return NULL;
| 42377 | } |  | 42329 | }
| 42378 |  |  | 42330 |
| 42379 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_size(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42331 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_size(PyObject* self, PyObject* py_args, PyObject* kw)
| 42380 | { |  | 42332 | {
| 42381 | using namespace cv::cuda; |  | 42333 | using namespace cv::cuda;
| 42382 |  |  | 42334 |
| 42383 |  |  | 42335 |
| 42384 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42336 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42385 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42337 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42386 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42338 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42387 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42339 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42388 | Size retval; |  | 42340 | Size retval;
| 42389 |  |  | 42341 |
| 42390 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42342 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42391 | { |  | 42343 | {
| 42392 | ERRWRAP2(retval = _self_->size()); |  | 42344 | ERRWRAP2(retval = _self_->size());
| 42393 | return pyopencv_from(retval); |  | 42345 | return pyopencv_from(retval);
| 42394 | } |  | 42346 | }
| 42395 |  |  | 42347 |
| 42396 | return NULL; |  | 42348 | return NULL;
| 42397 | } |  | 42349 | }
| 42398 |  |  | 42350 |
| 42399 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_step1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42351 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_step1(PyObject* self, PyObject* py_args, PyObject* kw)
| 42400 | { |  | 42352 | {
| 42401 | using namespace cv::cuda; |  | 42353 | using namespace cv::cuda;
| 42402 |  |  | 42354 |
| 42403 |  |  | 42355 |
| 42404 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42356 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42405 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42357 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42406 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42358 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42407 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42359 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42408 | size_t retval; |  | 42360 | size_t retval;
| 42409 |  |  | 42361 |
| 42410 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42362 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42411 | { |  | 42363 | {
| 42412 | ERRWRAP2(retval = _self_->step1()); |  | 42364 | ERRWRAP2(retval = _self_->step1());
| 42413 | return pyopencv_from(retval); |  | 42365 | return pyopencv_from(retval);
| 42414 | } |  | 42366 | }
| 42415 |  |  | 42367 |
| 42416 | return NULL; |  | 42368 | return NULL;
| 42417 | } |  | 42369 | }
| 42418 |  |  | 42370 |
| 42419 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_swap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42371 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_swap(PyObject* self, PyObject* py_args, PyObject* kw)
| 42420 | { |  | 42372 | {
| 42421 | using namespace cv::cuda; |  | 42373 | using namespace cv::cuda;
| 42422 |  |  | 42374 |
| 42423 |  |  | 42375 |
| 42424 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42376 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42425 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42377 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42426 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42378 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42427 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42379 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42428 | PyObject* pyobj_mat = NULL; |  | 42380 | PyObject* pyobj_mat = NULL;
| 42429 | GpuMat mat; |  | 42381 | GpuMat mat;
| 42430 |  |  | 42382 |
| 42431 | const char* keywords[] = { "mat", NULL }; |  | 42383 | const char* keywords[] = { "mat", NULL };
| 42432 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.swap", (char**)keywords, &pyobj_mat) && |  | 42384 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.swap", (char**)keywords, &pyobj_mat) &&
| 42433 | pyopencv_to_safe(pyobj_mat, mat, ArgInfo("mat", 0)) ) |  | 42385 | pyopencv_to_safe(pyobj_mat, mat, ArgInfo("mat", 0)) )
| 42434 | { |  | 42386 | {
| 42435 | ERRWRAP2(_self_->swap(mat)); |  | 42387 | ERRWRAP2(_self_->swap(mat));
| 42436 | Py_RETURN_NONE; |  | 42388 | Py_RETURN_NONE;
| 42437 | } |  | 42389 | }
| 42438 |  |  | 42390 |
| 42439 | return NULL; |  | 42391 | return NULL;
| 42440 | } |  | 42392 | }
| 42441 |  |  | 42393 |
| 42442 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_type(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42394 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_type(PyObject* self, PyObject* py_args, PyObject* kw)
| 42443 | { |  | 42395 | {
| 42444 | using namespace cv::cuda; |  | 42396 | using namespace cv::cuda;
| 42445 |  |  | 42397 |
| 42446 |  |  | 42398 |
| 42447 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42399 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42448 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42400 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42449 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42401 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42450 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42402 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42451 | int retval; |  | 42403 | int retval;
| 42452 |  |  | 42404 |
| 42453 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42405 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42454 | { |  | 42406 | {
| 42455 | ERRWRAP2(retval = _self_->type()); |  | 42407 | ERRWRAP2(retval = _self_->type());
| 42456 | return pyopencv_from(retval); |  | 42408 | return pyopencv_from(retval);
| 42457 | } |  | 42409 | }
| 42458 |  |  | 42410 |
| 42459 | return NULL; |  | 42411 | return NULL;
| 42460 | } |  | 42412 | }
| 42461 |  |  | 42413 |
| 42462 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_updateContinuityFlag(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42414 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_updateContinuityFlag(PyObject* self, PyObject* py_args, PyObject* kw)
| 42463 | { |  | 42415 | {
| 42464 | using namespace cv::cuda; |  | 42416 | using namespace cv::cuda;
| 42465 |  |  | 42417 |
| 42466 |  |  | 42418 |
| 42467 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42419 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42468 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42420 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42469 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42421 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42470 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42422 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42471 |  |  | 42423 |
| 42472 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42424 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42473 | { |  | 42425 | {
| 42474 | ERRWRAP2(_self_->updateContinuityFlag()); |  | 42426 | ERRWRAP2(_self_->updateContinuityFlag());
| 42475 | Py_RETURN_NONE; |  | 42427 | Py_RETURN_NONE;
| 42476 | } |  | 42428 | }
| 42477 |  |  | 42429 |
| 42478 | return NULL; |  | 42430 | return NULL;
| 42479 | } |  | 42431 | }
| 42480 |  |  | 42432 |
| 42481 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_upload(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42433 | static PyObject* pyopencv_cv_cuda_cuda_GpuMat_upload(PyObject* self, PyObject* py_args, PyObject* kw)
| 42482 | { |  | 42434 | {
| 42483 | using namespace cv::cuda; |  | 42435 | using namespace cv::cuda;
| 42484 |  |  | 42436 |
| 42485 |  |  | 42437 |
| 42486 | Ptr<cv::cuda::GpuMat> * self1 = 0; |  | 42438 | Ptr<cv::cuda::GpuMat> * self1 = 0;
| 42487 | if (!pyopencv_cuda_GpuMat_getp(self, self1)) |  | 42439 | if (!pyopencv_cuda_GpuMat_getp(self, self1))
| 42488 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)"); |  | 42440 | return failmsgp("Incorrect type of self (must be 'cuda_GpuMat' or its derivative)");
| 42489 | Ptr<cv::cuda::GpuMat> _self_ = *(self1); |  | 42441 | Ptr<cv::cuda::GpuMat> _self_ = *(self1);
| 42490 | pyPrepareArgumentConversionErrorsStorage(6); |  | 42442 | pyPrepareArgumentConversionErrorsStorage(6);
| 42491 |  |  | 42443 |
| 42492 | { |  | 42444 | {
| 42493 | PyObject* pyobj_arr = NULL; |  | 42445 | PyObject* pyobj_arr = NULL;
| 42494 | Mat arr; |  | 42446 | Mat arr;
| 42495 |  |  | 42447 |
| 42496 | const char* keywords[] = { "arr", NULL }; |  | 42448 | const char* keywords[] = { "arr", NULL };
| 42497 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr) && |  | 42449 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr) &&
| 42498 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) ) |  | 42450 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) )
| 42499 | { |  | 42451 | {
| 42500 | ERRWRAP2(_self_->upload(arr)); |  | 42452 | ERRWRAP2(_self_->upload(arr));
| 42501 | Py_RETURN_NONE; |  | 42453 | Py_RETURN_NONE;
| 42502 | } |  | 42454 | }
| 42503 |  |  | 42455 |
| 42504 |  |  | 42456 |
| 42505 | pyPopulateArgumentConversionErrors(); |  | 42457 | pyPopulateArgumentConversionErrors();
| 42506 | } |  | 42458 | }
| 42507 |  |  | 42459 |
| 42508 |  |  | 42460 |
| 42509 | { |  | 42461 | {
| 42510 | PyObject* pyobj_arr = NULL; |  | 42462 | PyObject* pyobj_arr = NULL;
| 42511 | cuda::GpuMat arr; |  | 42463 | cuda::GpuMat arr;
| 42512 |  |  | 42464 |
| 42513 | const char* keywords[] = { "arr", NULL }; |  | 42465 | const char* keywords[] = { "arr", NULL };
| 42514 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr) && |  | 42466 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr) &&
| 42515 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) ) |  | 42467 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) )
| 42516 | { |  | 42468 | {
| 42517 | ERRWRAP2(_self_->upload(arr)); |  | 42469 | ERRWRAP2(_self_->upload(arr));
| 42518 | Py_RETURN_NONE; |  | 42470 | Py_RETURN_NONE;
| 42519 | } |  | 42471 | }
| 42520 |  |  | 42472 |
| 42521 |  |  | 42473 |
| 42522 | pyPopulateArgumentConversionErrors(); |  | 42474 | pyPopulateArgumentConversionErrors();
| 42523 | } |  | 42475 | }
| 42524 |  |  | 42476 |
| 42525 |  |  | 42477 |
| 42526 | { |  | 42478 | {
| 42527 | PyObject* pyobj_arr = NULL; |  | 42479 | PyObject* pyobj_arr = NULL;
| 42528 | Mat arr; |  | 42480 | Mat arr;
| 42529 | PyObject* pyobj_stream = NULL; |  | 42481 | PyObject* pyobj_stream = NULL;
| 42530 | Stream stream=Stream::Null(); |  | 42482 | Stream stream=Stream::Null();
| 42531 |  |  | 42483 |
| 42532 | const char* keywords[] = { "arr", "stream", NULL }; |  | 42484 | const char* keywords[] = { "arr", "stream", NULL };
| 42533 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr, &pyobj_stream) && |  | 42485 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr, &pyobj_stream) &&
| 42534 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 42486 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 42535 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 42487 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 42536 | { |  | 42488 | {
| 42537 | ERRWRAP2(_self_->upload(arr, stream)); |  | 42489 | ERRWRAP2(_self_->upload(arr, stream));
| 42538 | Py_RETURN_NONE; |  | 42490 | Py_RETURN_NONE;
| 42539 | } |  | 42491 | }
| 42540 |  |  | 42492 |
| 42541 |  |  | 42493 |
| 42542 | pyPopulateArgumentConversionErrors(); |  | 42494 | pyPopulateArgumentConversionErrors();
| 42543 | } |  | 42495 | }
| 42544 |  |  | 42496 |
| 42545 |  |  | 42497 |
| 42546 | { |  | 42498 | {
| 42547 | PyObject* pyobj_arr = NULL; |  | 42499 | PyObject* pyobj_arr = NULL;
| 42548 | cuda::GpuMat arr; |  | 42500 | cuda::GpuMat arr;
| 42549 | PyObject* pyobj_stream = NULL; |  | 42501 | PyObject* pyobj_stream = NULL;
| 42550 | Stream stream=Stream::Null(); |  | 42502 | Stream stream=Stream::Null();
| 42551 |  |  | 42503 |
| 42552 | const char* keywords[] = { "arr", "stream", NULL }; |  | 42504 | const char* keywords[] = { "arr", "stream", NULL };
| 42553 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr, &pyobj_stream) && |  | 42505 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr, &pyobj_stream) &&
| 42554 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 42506 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 42555 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 42507 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 42556 | { |  | 42508 | {
| 42557 | ERRWRAP2(_self_->upload(arr, stream)); |  | 42509 | ERRWRAP2(_self_->upload(arr, stream));
| 42558 | Py_RETURN_NONE; |  | 42510 | Py_RETURN_NONE;
| 42559 | } |  | 42511 | }
| 42560 |  |  | 42512 |
| 42561 |  |  | 42513 |
| 42562 | pyPopulateArgumentConversionErrors(); |  | 42514 | pyPopulateArgumentConversionErrors();
| 42563 | } |  | 42515 | }
| 42564 |  |  | 42516 |
| 42565 |  |  | 42517 |
| 42566 | { |  | 42518 | {
| 42567 | PyObject* pyobj_arr = NULL; |  | 42519 | PyObject* pyobj_arr = NULL;
| 42568 | UMat arr; |  | 42520 | UMat arr;
| 42569 |  |  | 42521 |
| 42570 | const char* keywords[] = { "arr", NULL }; |  | 42522 | const char* keywords[] = { "arr", NULL };
| 42571 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr) && |  | 42523 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr) &&
| 42572 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) ) |  | 42524 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) )
| 42573 | { |  | 42525 | {
| 42574 | ERRWRAP2(_self_->upload(arr)); |  | 42526 | ERRWRAP2(_self_->upload(arr));
| 42575 | Py_RETURN_NONE; |  | 42527 | Py_RETURN_NONE;
| 42576 | } |  | 42528 | }
| 42577 |  |  | 42529 |
| 42578 |  |  | 42530 |
| 42579 | pyPopulateArgumentConversionErrors(); |  | 42531 | pyPopulateArgumentConversionErrors();
| 42580 | } |  | 42532 | }
| 42581 |  |  | 42533 |
| 42582 |  |  | 42534 |
| 42583 | { |  | 42535 | {
| 42584 | PyObject* pyobj_arr = NULL; |  | 42536 | PyObject* pyobj_arr = NULL;
| 42585 | UMat arr; |  | 42537 | UMat arr;
| 42586 | PyObject* pyobj_stream = NULL; |  | 42538 | PyObject* pyobj_stream = NULL;
| 42587 | Stream stream=Stream::Null(); |  | 42539 | Stream stream=Stream::Null();
| 42588 |  |  | 42540 |
| 42589 | const char* keywords[] = { "arr", "stream", NULL }; |  | 42541 | const char* keywords[] = { "arr", "stream", NULL };
| 42590 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr, &pyobj_stream) && |  | 42542 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_GpuMat.upload", (char**)keywords, &pyobj_arr, &pyobj_stream) &&
| 42591 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 42543 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 42592 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) ) |  | 42544 | pyopencv_to_safe(pyobj_stream, stream, ArgInfo("stream", 0)) )
| 42593 | { |  | 42545 | {
| 42594 | ERRWRAP2(_self_->upload(arr, stream)); |  | 42546 | ERRWRAP2(_self_->upload(arr, stream));
| 42595 | Py_RETURN_NONE; |  | 42547 | Py_RETURN_NONE;
| 42596 | } |  | 42548 | }
| 42597 |  |  | 42549 |
| 42598 |  |  | 42550 |
| 42599 | pyPopulateArgumentConversionErrors(); |  | 42551 | pyPopulateArgumentConversionErrors();
| 42600 | } |  | 42552 | }
| 42601 | pyRaiseCVOverloadException("upload"); |  | 42553 | pyRaiseCVOverloadException("upload");
| 42602 |  |  | 42554 |
| 42603 | return NULL; |  | 42555 | return NULL;
| 42604 | } |  | 42556 | }
| 42605 |  |  | 42557 |
| 42606 |  |  | 42558 |
| 42607 |  |  | 42559 |
| 42608 | // Tables (cuda_GpuMat) |  | 42560 | // Tables (cuda_GpuMat)
| 42609 |  |  | 42561 |
| 42610 | static PyGetSetDef pyopencv_cuda_GpuMat_getseters[] = |  | 42562 | static PyGetSetDef pyopencv_cuda_GpuMat_getseters[] =
| 42611 | { |  | 42563 | {
| 42612 | {(char*)"step", (getter)pyopencv_cuda_GpuMat_get_step, NULL, (char*)"step", NULL}, |  | 42564 | {(char*)"step", (getter)pyopencv_cuda_GpuMat_get_step, NULL, (char*)"step", NULL},
| 42613 | {NULL} /* Sentinel */ |  | 42565 | {NULL} /* Sentinel */
| 42614 | }; |  | 42566 | };
| 42615 |  |  | 42567 |
| 42616 | static PyMethodDef pyopencv_cuda_GpuMat_methods[] = |  | 42568 | static PyMethodDef pyopencv_cuda_GpuMat_methods[] =
| 42617 | { |  | 42569 | {
| 42618 | {"adjustROI", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_adjustROI, 0), "adjustROI(dtop, dbottom, dleft, dright) -> retval\n."}, |  | 42570 | {"adjustROI", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_adjustROI, 0), "adjustROI(dtop, dbottom, dleft, dright) -> retval\n."},
| 42619 | {"assignTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_assignTo, 0), "assignTo(m[, type]) -> None\n."}, |  | 42571 | {"assignTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_assignTo, 0), "assignTo(m[, type]) -> None\n."},
| 42620 | {"channels", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_channels, 0), "channels() -> retval\n."}, |  | 42572 | {"channels", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_channels, 0), "channels() -> retval\n."},
| 42621 | {"clone", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_clone, 0), "clone() -> retval\n."}, |  | 42573 | {"clone", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_clone, 0), "clone() -> retval\n."},
| 42622 | {"col", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_col, 0), "col(x) -> retval\n."}, |  | 42574 | {"col", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_col, 0), "col(x) -> retval\n."},
| 42623 | {"colRange", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_colRange, 0), "colRange(startcol, endcol) -> retval\n. \n\n\n\ncolRange(r) -> retval\n."}, |  | 42575 | {"colRange", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_colRange, 0), "colRange(startcol, endcol) -> retval\n. \n\n\n\ncolRange(r) -> retval\n."},
| 42624 | {"convertTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_convertTo, 0), "convertTo(rtype, stream[, dst]) -> dst\n. \n\n\n\nconvertTo(rtype[, dst[, alpha[, beta]]]) -> dst\n. \n\n\n\nconvertTo(rtype, alpha, beta, stream[, dst]) -> dst\n."}, |  | 42576 | {"convertTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_convertTo, 0), "convertTo(rtype, stream[, dst]) -> dst\n. \n\n\n\nconvertTo(rtype[, dst[, alpha[, beta]]]) -> dst\n. \n\n\n\nconvertTo(rtype, alpha, beta, stream[, dst]) -> dst\n."},
| 42625 | {"copyTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_copyTo, 0), "copyTo([, dst]) -> dst\n. \n\n\n\ncopyTo(stream[, dst]) -> dst\n. \n\n\n\ncopyTo(mask[, dst]) -> dst\n. \n\n\n\ncopyTo(mask, stream[, dst]) -> dst\n."}, |  | 42577 | {"copyTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_copyTo, 0), "copyTo([, dst]) -> dst\n. \n\n\n\ncopyTo(stream[, dst]) -> dst\n. \n\n\n\ncopyTo(mask[, dst]) -> dst\n. \n\n\n\ncopyTo(mask, stream[, dst]) -> dst\n."},
| 42626 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_create, 0), "create(rows, cols, type) -> None\n. \n\n\n\ncreate(size, type) -> None\n."}, |  | 42578 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_create, 0), "create(rows, cols, type) -> None\n. \n\n\n\ncreate(size, type) -> None\n."},
| 42627 | {"cudaPtr", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_cudaPtr, 0), "cudaPtr() -> retval\n."}, |  | 42579 | {"cudaPtr", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_cudaPtr, 0), "cudaPtr() -> retval\n."},
| 42628 | {"defaultAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_defaultAllocator_static, METH_STATIC), "defaultAllocator() -> retval\n."}, |  | 42580 | {"defaultAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_defaultAllocator_static, METH_STATIC), "defaultAllocator() -> retval\n."},
| 42629 | {"depth", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_depth, 0), "depth() -> retval\n."}, |  | 42581 | {"depth", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_depth, 0), "depth() -> retval\n."},
| 42630 | {"download", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_download, 0), "download([, dst]) -> dst\n. @brief Performs data download from GpuMat (Blocking call)\n. \n. This function copies data from device memory to host memory. As being a blocking call, it is\n. guaranteed that the copy operation is finished when this function returns.\n\n\n\ndownload(stream[, dst]) -> dst\n. @brief Performs data download from GpuMat (Non-Blocking call)\n. \n. This function copies data from device memory to host memory. As being a non-blocking call, this\n. function may return even if the copy operation is not finished.\n. \n. The copy operation may be overlapped with operations in other non-default streams if \\p stream is\n. not the default stream and \\p dst is HostMem allocated with HostMem::PAGE_LOCKED option."}, |  | 42582 | {"download", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_download, 0), "download([, dst]) -> dst\n. @brief Performs data download from GpuMat (Blocking call)\n. \n. This function copies data from device memory to host memory. As being a blocking call, it is\n. guaranteed that the copy operation is finished when this function returns.\n\n\n\ndownload(stream[, dst]) -> dst\n. @brief Performs data download from GpuMat (Non-Blocking call)\n. \n. This function copies data from device memory to host memory. As being a non-blocking call, this\n. function may return even if the copy operation is not finished.\n. \n. The copy operation may be overlapped with operations in other non-default streams if \\p stream is\n. not the default stream and \\p dst is HostMem allocated with HostMem::PAGE_LOCKED option."},
| 42631 | {"elemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_elemSize, 0), "elemSize() -> retval\n."}, |  | 42583 | {"elemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_elemSize, 0), "elemSize() -> retval\n."},
| 42632 | {"elemSize1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_elemSize1, 0), "elemSize1() -> retval\n."}, |  | 42584 | {"elemSize1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_elemSize1, 0), "elemSize1() -> retval\n."},
| 42633 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_empty, 0), "empty() -> retval\n."}, |  | 42585 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_empty, 0), "empty() -> retval\n."},
| 42634 | {"getStdAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_getStdAllocator_static, METH_STATIC), "getStdAllocator() -> retval\n."}, |  | 42586 | {"getStdAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_getStdAllocator_static, METH_STATIC), "getStdAllocator() -> retval\n."},
| 42635 | {"isContinuous", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_isContinuous, 0), "isContinuous() -> retval\n."}, |  | 42587 | {"isContinuous", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_isContinuous, 0), "isContinuous() -> retval\n."},
| 42636 | {"locateROI", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_locateROI, 0), "locateROI(wholeSize, ofs) -> None\n."}, |  | 42588 | {"locateROI", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_locateROI, 0), "locateROI(wholeSize, ofs) -> None\n."},
| 42637 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_release, 0), "release() -> None\n."}, |  | 42589 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_release, 0), "release() -> None\n."},
| 42638 | {"reshape", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_reshape, 0), "reshape(cn[, rows]) -> retval\n."}, |  | 42590 | {"reshape", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_reshape, 0), "reshape(cn[, rows]) -> retval\n."},
| 42639 | {"row", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_row, 0), "row(y) -> retval\n."}, |  | 42591 | {"row", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_row, 0), "row(y) -> retval\n."},
| 42640 | {"rowRange", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_rowRange, 0), "rowRange(startrow, endrow) -> retval\n. \n\n\n\nrowRange(r) -> retval\n."}, |  | 42592 | {"rowRange", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_rowRange, 0), "rowRange(startrow, endrow) -> retval\n. \n\n\n\nrowRange(r) -> retval\n."},
| 42641 | {"setDefaultAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_setDefaultAllocator_static, METH_STATIC), "setDefaultAllocator(allocator) -> None\n."}, |  | 42593 | {"setDefaultAllocator", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_setDefaultAllocator_static, METH_STATIC), "setDefaultAllocator(allocator) -> None\n."},
| 42642 | {"setTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_setTo, 0), "setTo(s) -> retval\n. \n\n\n\nsetTo(s, stream) -> retval\n. \n\n\n\nsetTo(s, mask) -> retval\n. \n\n\n\nsetTo(s, mask, stream) -> retval\n."}, |  | 42594 | {"setTo", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_setTo, 0), "setTo(s) -> retval\n. \n\n\n\nsetTo(s, stream) -> retval\n. \n\n\n\nsetTo(s, mask) -> retval\n. \n\n\n\nsetTo(s, mask, stream) -> retval\n."},
| 42643 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_size, 0), "size() -> retval\n."}, |  | 42595 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_size, 0), "size() -> retval\n."},
| 42644 | {"step1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_step1, 0), "step1() -> retval\n."}, |  | 42596 | {"step1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_step1, 0), "step1() -> retval\n."},
| 42645 | {"swap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_swap, 0), "swap(mat) -> None\n."}, |  | 42597 | {"swap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_swap, 0), "swap(mat) -> None\n."},
| 42646 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_type, 0), "type() -> retval\n."}, |  | 42598 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_type, 0), "type() -> retval\n."},
| 42647 | {"updateContinuityFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_updateContinuityFlag, 0), "updateContinuityFlag() -> None\n."}, |  | 42599 | {"updateContinuityFlag", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_updateContinuityFlag, 0), "updateContinuityFlag() -> None\n."},
| 42648 | {"upload", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_upload, 0), "upload(arr) -> None\n. @brief Performs data upload to GpuMat (Blocking call)\n. \n. This function copies data from host memory to device memory. As being a blocking call, it is\n. guaranteed that the copy operation is finished when this function returns.\n\n\n\nupload(arr, stream) -> None\n. @brief Performs data upload to GpuMat (Non-Blocking call)\n. \n. This function copies data from host memory to device memory. As being a non-blocking call, this\n. function may return even if the copy operation is not finished.\n. \n. The copy operation may be overlapped with operations in other non-default streams if \\p stream is\n. not the default stream and \\p dst is HostMem allocated with HostMem::PAGE_LOCKED option."}, |  | 42600 | {"upload", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_GpuMat_upload, 0), "upload(arr) -> None\n. @brief Performs data upload to GpuMat (Blocking call)\n. \n. This function copies data from host memory to device memory. As being a blocking call, it is\n. guaranteed that the copy operation is finished when this function returns.\n\n\n\nupload(arr, stream) -> None\n. @brief Performs data upload to GpuMat (Non-Blocking call)\n. \n. This function copies data from host memory to device memory. As being a non-blocking call, this\n. function may return even if the copy operation is not finished.\n. \n. The copy operation may be overlapped with operations in other non-default streams if \\p stream is\n. not the default stream and \\p dst is HostMem allocated with HostMem::PAGE_LOCKED option."},
| 42649 |  |  | 42601 |
| 42650 | {NULL, NULL} |  | 42602 | {NULL, NULL}
| 42651 | }; |  | 42603 | };
| 42652 |  |  | 42604 |
| 42653 | // Converter (cuda_GpuMat) |  | 42605 | // Converter (cuda_GpuMat)
| 42654 |  |  | 42606 |
| 42655 | template<> |  | 42607 | template<>
| 42656 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuMat> > |  | 42608 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuMat> >
| 42657 | { |  | 42609 | {
| 42658 | static PyObject* from(const Ptr<cv::cuda::GpuMat>& r) |  | 42610 | static PyObject* from(const Ptr<cv::cuda::GpuMat>& r)
| 42659 | { |  | 42611 | {
| 42660 | return pyopencv_cuda_GpuMat_Instance(r); |  | 42612 | return pyopencv_cuda_GpuMat_Instance(r);
| 42661 | } |  | 42613 | }
| 42662 | static bool to(PyObject* src, Ptr<cv::cuda::GpuMat>& dst, const ArgInfo& info) |  | 42614 | static bool to(PyObject* src, Ptr<cv::cuda::GpuMat>& dst, const ArgInfo& info)
| 42663 | { |  | 42615 | {
| 42664 | if(!src || src == Py_None) |  | 42616 | if(!src || src == Py_None)
| 42665 | return true; |  | 42617 | return true;
| 42666 | Ptr<cv::cuda::GpuMat> * dst_; |  | 42618 | Ptr<cv::cuda::GpuMat> * dst_;
| 42667 | if (pyopencv_cuda_GpuMat_getp(src, dst_)) |  | 42619 | if (pyopencv_cuda_GpuMat_getp(src, dst_))
| 42668 | { |  | 42620 | {
| 42669 | dst = *dst_; |  | 42621 | dst = *dst_;
| 42670 | return true; |  | 42622 | return true;
| 42671 | } |  | 42623 | }
| 42672 |  |  | 42624 |
| 42673 | failmsg("Expected Ptr<cv::cuda::GpuMat> for argument '%s'", info.name); |  | 42625 | failmsg("Expected Ptr<cv::cuda::GpuMat> for argument '%s'", info.name);
| 42674 | return false; |  | 42626 | return false;
| 42675 | } |  | 42627 | }
| 42676 | }; |  | 42628 | };
| 42677 |  |  | 42629 |
| 42678 | //================================================================================ |  | 42630 | //================================================================================
| 42679 | // cuda_GpuMatND (Generic) |  | 42631 | // cuda_GpuMatND (Generic)
| 42680 | //================================================================================ |  | 42632 | //================================================================================
| 42681 |  |  | 42633 |
| 42682 | // GetSet (cuda_GpuMatND) |  | 42634 | // GetSet (cuda_GpuMatND)
| 42683 |  |  | 42635 |
| 42684 |  |  | 42636 |
| 42685 |  |  | 42637 |
| 42686 | // Methods (cuda_GpuMatND) |  | 42638 | // Methods (cuda_GpuMatND)
| 42687 |  |  | 42639 |
| 42688 |  |  | 42640 |
| 42689 |  |  | 42641 |
| 42690 | // Tables (cuda_GpuMatND) |  | 42642 | // Tables (cuda_GpuMatND)
| 42691 |  |  | 42643 |
| 42692 | static PyGetSetDef pyopencv_cuda_GpuMatND_getseters[] = |  | 42644 | static PyGetSetDef pyopencv_cuda_GpuMatND_getseters[] =
| 42693 | { |  | 42645 | {
| 42694 | {NULL} /* Sentinel */ |  | 42646 | {NULL} /* Sentinel */
| 42695 | }; |  | 42647 | };
| 42696 |  |  | 42648 |
| 42697 | static PyMethodDef pyopencv_cuda_GpuMatND_methods[] = |  | 42649 | static PyMethodDef pyopencv_cuda_GpuMatND_methods[] =
| 42698 | { |  | 42650 | {
| 42699 |  |  | 42651 |
| 42700 | {NULL, NULL} |  | 42652 | {NULL, NULL}
| 42701 | }; |  | 42653 | };
| 42702 |  |  | 42654 |
| 42703 | // Converter (cuda_GpuMatND) |  | 42655 | // Converter (cuda_GpuMatND)
| 42704 |  |  | 42656 |
| 42705 | template<> |  | 42657 | template<>
| 42706 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuMatND> > |  | 42658 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuMatND> >
| 42707 | { |  | 42659 | {
| 42708 | static PyObject* from(const Ptr<cv::cuda::GpuMatND>& r) |  | 42660 | static PyObject* from(const Ptr<cv::cuda::GpuMatND>& r)
| 42709 | { |  | 42661 | {
| 42710 | return pyopencv_cuda_GpuMatND_Instance(r); |  | 42662 | return pyopencv_cuda_GpuMatND_Instance(r);
| 42711 | } |  | 42663 | }
| 42712 | static bool to(PyObject* src, Ptr<cv::cuda::GpuMatND>& dst, const ArgInfo& info) |  | 42664 | static bool to(PyObject* src, Ptr<cv::cuda::GpuMatND>& dst, const ArgInfo& info)
| 42713 | { |  | 42665 | {
| 42714 | if(!src || src == Py_None) |  | 42666 | if(!src || src == Py_None)
| 42715 | return true; |  | 42667 | return true;
| 42716 | Ptr<cv::cuda::GpuMatND> * dst_; |  | 42668 | Ptr<cv::cuda::GpuMatND> * dst_;
| 42717 | if (pyopencv_cuda_GpuMatND_getp(src, dst_)) |  | 42669 | if (pyopencv_cuda_GpuMatND_getp(src, dst_))
| 42718 | { |  | 42670 | {
| 42719 | dst = *dst_; |  | 42671 | dst = *dst_;
| 42720 | return true; |  | 42672 | return true;
| 42721 | } |  | 42673 | }
| 42722 |  |  | 42674 |
| 42723 | failmsg("Expected Ptr<cv::cuda::GpuMatND> for argument '%s'", info.name); |  | 42675 | failmsg("Expected Ptr<cv::cuda::GpuMatND> for argument '%s'", info.name);
| 42724 | return false; |  | 42676 | return false;
| 42725 | } |  | 42677 | }
| 42726 | }; |  | 42678 | };
| 42727 |  |  | 42679 |
| 42728 | //================================================================================ |  | 42680 | //================================================================================
| 42729 | // cuda_GpuMat_Allocator (Generic) |  | 42681 | // cuda_GpuMat_Allocator (Generic)
| 42730 | //================================================================================ |  | 42682 | //================================================================================
| 42731 |  |  | 42683 |
| 42732 | // GetSet (cuda_GpuMat_Allocator) |  | 42684 | // GetSet (cuda_GpuMat_Allocator)
| 42733 |  |  | 42685 |
| 42734 |  |  | 42686 |
| 42735 |  |  | 42687 |
| 42736 | // Methods (cuda_GpuMat_Allocator) |  | 42688 | // Methods (cuda_GpuMat_Allocator)
| 42737 |  |  | 42689 |
| 42738 |  |  | 42690 |
| 42739 |  |  | 42691 |
| 42740 | // Tables (cuda_GpuMat_Allocator) |  | 42692 | // Tables (cuda_GpuMat_Allocator)
| 42741 |  |  | 42693 |
| 42742 | static PyGetSetDef pyopencv_cuda_GpuMat_Allocator_getseters[] = |  | 42694 | static PyGetSetDef pyopencv_cuda_GpuMat_Allocator_getseters[] =
| 42743 | { |  | 42695 | {
| 42744 | {NULL} /* Sentinel */ |  | 42696 | {NULL} /* Sentinel */
| 42745 | }; |  | 42697 | };
| 42746 |  |  | 42698 |
| 42747 | static PyMethodDef pyopencv_cuda_GpuMat_Allocator_methods[] = |  | 42699 | static PyMethodDef pyopencv_cuda_GpuMat_Allocator_methods[] =
| 42748 | { |  | 42700 | {
| 42749 |  |  | 42701 |
| 42750 | {NULL, NULL} |  | 42702 | {NULL, NULL}
| 42751 | }; |  | 42703 | };
| 42752 |  |  | 42704 |
| 42753 | // Converter (cuda_GpuMat_Allocator) |  | 42705 | // Converter (cuda_GpuMat_Allocator)
| 42754 |  |  | 42706 |
| 42755 | template<> |  | 42707 | template<>
| 42756 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuMat::Allocator> > |  | 42708 | struct PyOpenCV_Converter< Ptr<cv::cuda::GpuMat::Allocator> >
| 42757 | { |  | 42709 | {
| 42758 | static PyObject* from(const Ptr<cv::cuda::GpuMat::Allocator>& r) |  | 42710 | static PyObject* from(const Ptr<cv::cuda::GpuMat::Allocator>& r)
| 42759 | { |  | 42711 | {
| 42760 | return pyopencv_cuda_GpuMat_Allocator_Instance(r); |  | 42712 | return pyopencv_cuda_GpuMat_Allocator_Instance(r);
| 42761 | } |  | 42713 | }
| 42762 | static bool to(PyObject* src, Ptr<cv::cuda::GpuMat::Allocator>& dst, const ArgInfo& info) |  | 42714 | static bool to(PyObject* src, Ptr<cv::cuda::GpuMat::Allocator>& dst, const ArgInfo& info)
| 42763 | { |  | 42715 | {
| 42764 | if(!src || src == Py_None) |  | 42716 | if(!src || src == Py_None)
| 42765 | return true; |  | 42717 | return true;
| 42766 | Ptr<cv::cuda::GpuMat::Allocator> * dst_; |  | 42718 | Ptr<cv::cuda::GpuMat::Allocator> * dst_;
| 42767 | if (pyopencv_cuda_GpuMat_Allocator_getp(src, dst_)) |  | 42719 | if (pyopencv_cuda_GpuMat_Allocator_getp(src, dst_))
| 42768 | { |  | 42720 | {
| 42769 | dst = *dst_; |  | 42721 | dst = *dst_;
| 42770 | return true; |  | 42722 | return true;
| 42771 | } |  | 42723 | }
| 42772 |  |  | 42724 |
| 42773 | failmsg("Expected Ptr<cv::cuda::GpuMat::Allocator> for argument '%s'", info.name); |  | 42725 | failmsg("Expected Ptr<cv::cuda::GpuMat::Allocator> for argument '%s'", info.name);
| 42774 | return false; |  | 42726 | return false;
| 42775 | } |  | 42727 | }
| 42776 | }; |  | 42728 | };
| 42777 |  |  | 42729 |
| 42778 | //================================================================================ |  | 42730 | //================================================================================
| 42779 | // cuda_HostMem (Generic) |  | 42731 | // cuda_HostMem (Generic)
| 42780 | //================================================================================ |  | 42732 | //================================================================================
| 42781 |  |  | 42733 |
| 42782 | // GetSet (cuda_HostMem) |  | 42734 | // GetSet (cuda_HostMem)
| 42783 |  |  | 42735 |
| 42784 |  |  | 42736 |
| 42785 | static PyObject* pyopencv_cuda_HostMem_get_step(pyopencv_cuda_HostMem_t* p, void *closure) |  | 42737 | static PyObject* pyopencv_cuda_HostMem_get_step(pyopencv_cuda_HostMem_t* p, void *closure)
| 42786 | { |  | 42738 | {
| 42787 | return pyopencv_from(p->v->step); |  | 42739 | return pyopencv_from(p->v->step);
| 42788 | } |  | 42740 | }
| 42789 |  |  | 42741 |
| 42790 |  |  | 42742 |
| 42791 | // Methods (cuda_HostMem) |  | 42743 | // Methods (cuda_HostMem)
| 42792 |  |  | 42744 |
| 42793 | static int pyopencv_cv_cuda_cuda_HostMem_HostMem(pyopencv_cuda_HostMem_t* self, PyObject* py_args, PyObject* kw) |  | 42745 | static int pyopencv_cv_cuda_cuda_HostMem_HostMem(pyopencv_cuda_HostMem_t* self, PyObject* py_args, PyObject* kw)
| 42794 | { |  | 42746 | {
| 42795 | using namespace cv::cuda; |  | 42747 | using namespace cv::cuda;
| 42796 |  |  | 42748 |
| 42797 | pyPrepareArgumentConversionErrorsStorage(6); |  | 42749 | pyPrepareArgumentConversionErrorsStorage(6);
| 42798 |  |  | 42750 |
| 42799 | { |  | 42751 | {
| 42800 | PyObject* pyobj_alloc_type = NULL; |  | 42752 | PyObject* pyobj_alloc_type = NULL;
| 42801 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED; |  | 42753 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED;
| 42802 |  |  | 42754 |
| 42803 | const char* keywords[] = { "alloc_type", NULL }; |  | 42755 | const char* keywords[] = { "alloc_type", NULL };
| 42804 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:HostMem", (char**)keywords, &pyobj_alloc_type) && |  | 42756 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:HostMem", (char**)keywords, &pyobj_alloc_type) &&
| 42805 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) ) |  | 42757 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) )
| 42806 | { |  | 42758 | {
| 42807 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new |  | 42759 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new
| 42808 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(alloc_type))); |  | 42760 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(alloc_type)));
| 42809 | return 0; |  | 42761 | return 0;
| 42810 | } |  | 42762 | }
| 42811 |  |  | 42763 |
| 42812 |  |  | 42764 |
| 42813 | pyPopulateArgumentConversionErrors(); |  | 42765 | pyPopulateArgumentConversionErrors();
| 42814 | } |  | 42766 | }
| 42815 |  |  | 42767 |
| 42816 |  |  | 42768 |
| 42817 | { |  | 42769 | {
| 42818 | PyObject* pyobj_rows = NULL; |  | 42770 | PyObject* pyobj_rows = NULL;
| 42819 | int rows=0; |  | 42771 | int rows=0;
| 42820 | PyObject* pyobj_cols = NULL; |  | 42772 | PyObject* pyobj_cols = NULL;
| 42821 | int cols=0; |  | 42773 | int cols=0;
| 42822 | PyObject* pyobj_type = NULL; |  | 42774 | PyObject* pyobj_type = NULL;
| 42823 | int type=0; |  | 42775 | int type=0;
| 42824 | PyObject* pyobj_alloc_type = NULL; |  | 42776 | PyObject* pyobj_alloc_type = NULL;
| 42825 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED; |  | 42777 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED;
| 42826 |  |  | 42778 |
| 42827 | const char* keywords[] = { "rows", "cols", "type", "alloc_type", NULL }; |  | 42779 | const char* keywords[] = { "rows", "cols", "type", "alloc_type", NULL };
| 42828 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:HostMem", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_alloc_type) && |  | 42780 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:HostMem", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_alloc_type) &&
| 42829 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 42781 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 42830 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 42782 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 42831 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 42783 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 42832 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) ) |  | 42784 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) )
| 42833 | { |  | 42785 | {
| 42834 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new |  | 42786 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new
| 42835 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(rows, cols, type, alloc_type))); |  | 42787 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(rows, cols, type, alloc_type)));
| 42836 | return 0; |  | 42788 | return 0;
| 42837 | } |  | 42789 | }
| 42838 |  |  | 42790 |
| 42839 |  |  | 42791 |
| 42840 | pyPopulateArgumentConversionErrors(); |  | 42792 | pyPopulateArgumentConversionErrors();
| 42841 | } |  | 42793 | }
| 42842 |  |  | 42794 |
| 42843 |  |  | 42795 |
| 42844 | { |  | 42796 | {
| 42845 | PyObject* pyobj_size = NULL; |  | 42797 | PyObject* pyobj_size = NULL;
| 42846 | Size size; |  | 42798 | Size size;
| 42847 | PyObject* pyobj_type = NULL; |  | 42799 | PyObject* pyobj_type = NULL;
| 42848 | int type=0; |  | 42800 | int type=0;
| 42849 | PyObject* pyobj_alloc_type = NULL; |  | 42801 | PyObject* pyobj_alloc_type = NULL;
| 42850 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED; |  | 42802 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED;
| 42851 |  |  | 42803 |
| 42852 | const char* keywords[] = { "size", "type", "alloc_type", NULL }; |  | 42804 | const char* keywords[] = { "size", "type", "alloc_type", NULL };
| 42853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:HostMem", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_alloc_type) && |  | 42805 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:HostMem", (char**)keywords, &pyobj_size, &pyobj_type, &pyobj_alloc_type) &&
| 42854 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 42806 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 42855 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 42807 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 42856 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) ) |  | 42808 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) )
| 42857 | { |  | 42809 | {
| 42858 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new |  | 42810 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new
| 42859 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(size, type, alloc_type))); |  | 42811 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(size, type, alloc_type)));
| 42860 | return 0; |  | 42812 | return 0;
| 42861 | } |  | 42813 | }
| 42862 |  |  | 42814 |
| 42863 |  |  | 42815 |
| 42864 | pyPopulateArgumentConversionErrors(); |  | 42816 | pyPopulateArgumentConversionErrors();
| 42865 | } |  | 42817 | }
| 42866 |  |  | 42818 |
| 42867 |  |  | 42819 |
| 42868 | { |  | 42820 | {
| 42869 | PyObject* pyobj_arr = NULL; |  | 42821 | PyObject* pyobj_arr = NULL;
| 42870 | Mat arr; |  | 42822 | Mat arr;
| 42871 | PyObject* pyobj_alloc_type = NULL; |  | 42823 | PyObject* pyobj_alloc_type = NULL;
| 42872 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED; |  | 42824 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED;
| 42873 |  |  | 42825 |
| 42874 | const char* keywords[] = { "arr", "alloc_type", NULL }; |  | 42826 | const char* keywords[] = { "arr", "alloc_type", NULL };
| 42875 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HostMem", (char**)keywords, &pyobj_arr, &pyobj_alloc_type) && |  | 42827 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HostMem", (char**)keywords, &pyobj_arr, &pyobj_alloc_type) &&
| 42876 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 42828 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 42877 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) ) |  | 42829 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) )
| 42878 | { |  | 42830 | {
| 42879 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new |  | 42831 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new
| 42880 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(arr, alloc_type))); |  | 42832 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(arr, alloc_type)));
| 42881 | return 0; |  | 42833 | return 0;
| 42882 | } |  | 42834 | }
| 42883 |  |  | 42835 |
| 42884 |  |  | 42836 |
| 42885 | pyPopulateArgumentConversionErrors(); |  | 42837 | pyPopulateArgumentConversionErrors();
| 42886 | } |  | 42838 | }
| 42887 |  |  | 42839 |
| 42888 |  |  | 42840 |
| 42889 | { |  | 42841 | {
| 42890 | PyObject* pyobj_arr = NULL; |  | 42842 | PyObject* pyobj_arr = NULL;
| 42891 | cuda::GpuMat arr; |  | 42843 | cuda::GpuMat arr;
| 42892 | PyObject* pyobj_alloc_type = NULL; |  | 42844 | PyObject* pyobj_alloc_type = NULL;
| 42893 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED; |  | 42845 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED;
| 42894 |  |  | 42846 |
| 42895 | const char* keywords[] = { "arr", "alloc_type", NULL }; |  | 42847 | const char* keywords[] = { "arr", "alloc_type", NULL };
| 42896 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HostMem", (char**)keywords, &pyobj_arr, &pyobj_alloc_type) && |  | 42848 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HostMem", (char**)keywords, &pyobj_arr, &pyobj_alloc_type) &&
| 42897 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 42849 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 42898 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) ) |  | 42850 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) )
| 42899 | { |  | 42851 | {
| 42900 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new |  | 42852 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new
| 42901 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(arr, alloc_type))); |  | 42853 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(arr, alloc_type)));
| 42902 | return 0; |  | 42854 | return 0;
| 42903 | } |  | 42855 | }
| 42904 |  |  | 42856 |
| 42905 |  |  | 42857 |
| 42906 | pyPopulateArgumentConversionErrors(); |  | 42858 | pyPopulateArgumentConversionErrors();
| 42907 | } |  | 42859 | }
| 42908 |  |  | 42860 |
| 42909 |  |  | 42861 |
| 42910 | { |  | 42862 | {
| 42911 | PyObject* pyobj_arr = NULL; |  | 42863 | PyObject* pyobj_arr = NULL;
| 42912 | UMat arr; |  | 42864 | UMat arr;
| 42913 | PyObject* pyobj_alloc_type = NULL; |  | 42865 | PyObject* pyobj_alloc_type = NULL;
| 42914 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED; |  | 42866 | HostMem_AllocType alloc_type=HostMem::AllocType::PAGE_LOCKED;
| 42915 |  |  | 42867 |
| 42916 | const char* keywords[] = { "arr", "alloc_type", NULL }; |  | 42868 | const char* keywords[] = { "arr", "alloc_type", NULL };
| 42917 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HostMem", (char**)keywords, &pyobj_arr, &pyobj_alloc_type) && |  | 42869 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:HostMem", (char**)keywords, &pyobj_arr, &pyobj_alloc_type) &&
| 42918 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) && |  | 42870 | pyopencv_to_safe(pyobj_arr, arr, ArgInfo("arr", 0)) &&
| 42919 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) ) |  | 42871 | pyopencv_to_safe(pyobj_alloc_type, alloc_type, ArgInfo("alloc_type", 0)) )
| 42920 | { |  | 42872 | {
| 42921 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new |  | 42873 | new (&(self->v)) Ptr<cv::cuda::HostMem>(); // init Ptr with placement new
| 42922 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(arr, alloc_type))); |  | 42874 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::HostMem(arr, alloc_type)));
| 42923 | return 0; |  | 42875 | return 0;
| 42924 | } |  | 42876 | }
| 42925 |  |  | 42877 |
| 42926 |  |  | 42878 |
| 42927 | pyPopulateArgumentConversionErrors(); |  | 42879 | pyPopulateArgumentConversionErrors();
| 42928 | } |  | 42880 | }
| 42929 | pyRaiseCVOverloadException("HostMem"); |  | 42881 | pyRaiseCVOverloadException("HostMem");
| 42930 |  |  | 42882 |
| 42931 | return -1; |  | 42883 | return -1;
| 42932 | } |  | 42884 | }
| 42933 |  |  | 42885 |
| 42934 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_channels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42886 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_channels(PyObject* self, PyObject* py_args, PyObject* kw)
| 42935 | { |  | 42887 | {
| 42936 | using namespace cv::cuda; |  | 42888 | using namespace cv::cuda;
| 42937 |  |  | 42889 |
| 42938 |  |  | 42890 |
| 42939 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 42891 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 42940 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 42892 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 42941 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 42893 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 42942 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 42894 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 42943 | int retval; |  | 42895 | int retval;
| 42944 |  |  | 42896 |
| 42945 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42897 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42946 | { |  | 42898 | {
| 42947 | ERRWRAP2(retval = _self_->channels()); |  | 42899 | ERRWRAP2(retval = _self_->channels());
| 42948 | return pyopencv_from(retval); |  | 42900 | return pyopencv_from(retval);
| 42949 | } |  | 42901 | }
| 42950 |  |  | 42902 |
| 42951 | return NULL; |  | 42903 | return NULL;
| 42952 | } |  | 42904 | }
| 42953 |  |  | 42905 |
| 42954 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_clone(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42906 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_clone(PyObject* self, PyObject* py_args, PyObject* kw)
| 42955 | { |  | 42907 | {
| 42956 | using namespace cv::cuda; |  | 42908 | using namespace cv::cuda;
| 42957 |  |  | 42909 |
| 42958 |  |  | 42910 |
| 42959 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 42911 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 42960 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 42912 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 42961 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 42913 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 42962 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 42914 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 42963 | HostMem retval; |  | 42915 | HostMem retval;
| 42964 |  |  | 42916 |
| 42965 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42917 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 42966 | { |  | 42918 | {
| 42967 | ERRWRAP2(retval = _self_->clone()); |  | 42919 | ERRWRAP2(retval = _self_->clone());
| 42968 | return pyopencv_from(retval); |  | 42920 | return pyopencv_from(retval);
| 42969 | } |  | 42921 | }
| 42970 |  |  | 42922 |
| 42971 | return NULL; |  | 42923 | return NULL;
| 42972 | } |  | 42924 | }
| 42973 |  |  | 42925 |
| 42974 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_create(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42926 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_create(PyObject* self, PyObject* py_args, PyObject* kw)
| 42975 | { |  | 42927 | {
| 42976 | using namespace cv::cuda; |  | 42928 | using namespace cv::cuda;
| 42977 |  |  | 42929 |
| 42978 |  |  | 42930 |
| 42979 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 42931 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 42980 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 42932 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 42981 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 42933 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 42982 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 42934 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 42983 | PyObject* pyobj_rows = NULL; |  | 42935 | PyObject* pyobj_rows = NULL;
| 42984 | int rows=0; |  | 42936 | int rows=0;
| 42985 | PyObject* pyobj_cols = NULL; |  | 42937 | PyObject* pyobj_cols = NULL;
| 42986 | int cols=0; |  | 42938 | int cols=0;
| 42987 | PyObject* pyobj_type = NULL; |  | 42939 | PyObject* pyobj_type = NULL;
| 42988 | int type=0; |  | 42940 | int type=0;
| 42989 |  |  | 42941 |
| 42990 | const char* keywords[] = { "rows", "cols", "type", NULL }; |  | 42942 | const char* keywords[] = { "rows", "cols", "type", NULL };
| 42991 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_HostMem.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type) && |  | 42943 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:cuda_HostMem.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type) &&
| 42992 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 42944 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 42993 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 42945 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 42994 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 42946 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 42995 | { |  | 42947 | {
| 42996 | ERRWRAP2(_self_->create(rows, cols, type)); |  | 42948 | ERRWRAP2(_self_->create(rows, cols, type));
| 42997 | Py_RETURN_NONE; |  | 42949 | Py_RETURN_NONE;
| 42998 | } |  | 42950 | }
| 42999 |  |  | 42951 |
| 43000 | return NULL; |  | 42952 | return NULL;
| 43001 | } |  | 42953 | }
| 43002 |  |  | 42954 |
| 43003 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_createMatHeader(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42955 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_createMatHeader(PyObject* self, PyObject* py_args, PyObject* kw)
| 43004 | { |  | 42956 | {
| 43005 | using namespace cv::cuda; |  | 42957 | using namespace cv::cuda;
| 43006 |  |  | 42958 |
| 43007 |  |  | 42959 |
| 43008 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 42960 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43009 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 42961 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43010 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 42962 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43011 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 42963 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43012 | Mat retval; |  | 42964 | Mat retval;
| 43013 |  |  | 42965 |
| 43014 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42966 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43015 | { |  | 42967 | {
| 43016 | ERRWRAP2(retval = _self_->createMatHeader()); |  | 42968 | ERRWRAP2(retval = _self_->createMatHeader());
| 43017 | return pyopencv_from(retval); |  | 42969 | return pyopencv_from(retval);
| 43018 | } |  | 42970 | }
| 43019 |  |  | 42971 |
| 43020 | return NULL; |  | 42972 | return NULL;
| 43021 | } |  | 42973 | }
| 43022 |  |  | 42974 |
| 43023 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_depth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42975 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_depth(PyObject* self, PyObject* py_args, PyObject* kw)
| 43024 | { |  | 42976 | {
| 43025 | using namespace cv::cuda; |  | 42977 | using namespace cv::cuda;
| 43026 |  |  | 42978 |
| 43027 |  |  | 42979 |
| 43028 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 42980 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43029 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 42981 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43030 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 42982 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43031 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 42983 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43032 | int retval; |  | 42984 | int retval;
| 43033 |  |  | 42985 |
| 43034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 42986 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43035 | { |  | 42987 | {
| 43036 | ERRWRAP2(retval = _self_->depth()); |  | 42988 | ERRWRAP2(retval = _self_->depth());
| 43037 | return pyopencv_from(retval); |  | 42989 | return pyopencv_from(retval);
| 43038 | } |  | 42990 | }
| 43039 |  |  | 42991 |
| 43040 | return NULL; |  | 42992 | return NULL;
| 43041 | } |  | 42993 | }
| 43042 |  |  | 42994 |
| 43043 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_elemSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 42995 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_elemSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 43044 | { |  | 42996 | {
| 43045 | using namespace cv::cuda; |  | 42997 | using namespace cv::cuda;
| 43046 |  |  | 42998 |
| 43047 |  |  | 42999 |
| 43048 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43000 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43049 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43001 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43050 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43002 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43051 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43003 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43052 | size_t retval; |  | 43004 | size_t retval;
| 43053 |  |  | 43005 |
| 43054 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43006 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43055 | { |  | 43007 | {
| 43056 | ERRWRAP2(retval = _self_->elemSize()); |  | 43008 | ERRWRAP2(retval = _self_->elemSize());
| 43057 | return pyopencv_from(retval); |  | 43009 | return pyopencv_from(retval);
| 43058 | } |  | 43010 | }
| 43059 |  |  | 43011 |
| 43060 | return NULL; |  | 43012 | return NULL;
| 43061 | } |  | 43013 | }
| 43062 |  |  | 43014 |
| 43063 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_elemSize1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43015 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_elemSize1(PyObject* self, PyObject* py_args, PyObject* kw)
| 43064 | { |  | 43016 | {
| 43065 | using namespace cv::cuda; |  | 43017 | using namespace cv::cuda;
| 43066 |  |  | 43018 |
| 43067 |  |  | 43019 |
| 43068 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43020 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43069 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43021 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43070 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43022 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43071 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43023 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43072 | size_t retval; |  | 43024 | size_t retval;
| 43073 |  |  | 43025 |
| 43074 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43026 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43075 | { |  | 43027 | {
| 43076 | ERRWRAP2(retval = _self_->elemSize1()); |  | 43028 | ERRWRAP2(retval = _self_->elemSize1());
| 43077 | return pyopencv_from(retval); |  | 43029 | return pyopencv_from(retval);
| 43078 | } |  | 43030 | }
| 43079 |  |  | 43031 |
| 43080 | return NULL; |  | 43032 | return NULL;
| 43081 | } |  | 43033 | }
| 43082 |  |  | 43034 |
| 43083 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43035 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 43084 | { |  | 43036 | {
| 43085 | using namespace cv::cuda; |  | 43037 | using namespace cv::cuda;
| 43086 |  |  | 43038 |
| 43087 |  |  | 43039 |
| 43088 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43040 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43089 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43041 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43090 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43042 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43091 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43043 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43092 | bool retval; |  | 43044 | bool retval;
| 43093 |  |  | 43045 |
| 43094 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43046 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43095 | { |  | 43047 | {
| 43096 | ERRWRAP2(retval = _self_->empty()); |  | 43048 | ERRWRAP2(retval = _self_->empty());
| 43097 | return pyopencv_from(retval); |  | 43049 | return pyopencv_from(retval);
| 43098 | } |  | 43050 | }
| 43099 |  |  | 43051 |
| 43100 | return NULL; |  | 43052 | return NULL;
| 43101 | } |  | 43053 | }
| 43102 |  |  | 43054 |
| 43103 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_isContinuous(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43055 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_isContinuous(PyObject* self, PyObject* py_args, PyObject* kw)
| 43104 | { |  | 43056 | {
| 43105 | using namespace cv::cuda; |  | 43057 | using namespace cv::cuda;
| 43106 |  |  | 43058 |
| 43107 |  |  | 43059 |
| 43108 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43060 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43109 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43061 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43110 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43062 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43111 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43063 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43112 | bool retval; |  | 43064 | bool retval;
| 43113 |  |  | 43065 |
| 43114 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43066 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43115 | { |  | 43067 | {
| 43116 | ERRWRAP2(retval = _self_->isContinuous()); |  | 43068 | ERRWRAP2(retval = _self_->isContinuous());
| 43117 | return pyopencv_from(retval); |  | 43069 | return pyopencv_from(retval);
| 43118 | } |  | 43070 | }
| 43119 |  |  | 43071 |
| 43120 | return NULL; |  | 43072 | return NULL;
| 43121 | } |  | 43073 | }
| 43122 |  |  | 43074 |
| 43123 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_reshape(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43075 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_reshape(PyObject* self, PyObject* py_args, PyObject* kw)
| 43124 | { |  | 43076 | {
| 43125 | using namespace cv::cuda; |  | 43077 | using namespace cv::cuda;
| 43126 |  |  | 43078 |
| 43127 |  |  | 43079 |
| 43128 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43080 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43129 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43081 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43130 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43082 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43131 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43083 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43132 | PyObject* pyobj_cn = NULL; |  | 43084 | PyObject* pyobj_cn = NULL;
| 43133 | int cn=0; |  | 43085 | int cn=0;
| 43134 | PyObject* pyobj_rows = NULL; |  | 43086 | PyObject* pyobj_rows = NULL;
| 43135 | int rows=0; |  | 43087 | int rows=0;
| 43136 | HostMem retval; |  | 43088 | HostMem retval;
| 43137 |  |  | 43089 |
| 43138 | const char* keywords[] = { "cn", "rows", NULL }; |  | 43090 | const char* keywords[] = { "cn", "rows", NULL };
| 43139 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_HostMem.reshape", (char**)keywords, &pyobj_cn, &pyobj_rows) && |  | 43091 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:cuda_HostMem.reshape", (char**)keywords, &pyobj_cn, &pyobj_rows) &&
| 43140 | pyopencv_to_safe(pyobj_cn, cn, ArgInfo("cn", 0)) && |  | 43092 | pyopencv_to_safe(pyobj_cn, cn, ArgInfo("cn", 0)) &&
| 43141 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) ) |  | 43093 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) )
| 43142 | { |  | 43094 | {
| 43143 | ERRWRAP2(retval = _self_->reshape(cn, rows)); |  | 43095 | ERRWRAP2(retval = _self_->reshape(cn, rows));
| 43144 | return pyopencv_from(retval); |  | 43096 | return pyopencv_from(retval);
| 43145 | } |  | 43097 | }
| 43146 |  |  | 43098 |
| 43147 | return NULL; |  | 43099 | return NULL;
| 43148 | } |  | 43100 | }
| 43149 |  |  | 43101 |
| 43150 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_size(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43102 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_size(PyObject* self, PyObject* py_args, PyObject* kw)
| 43151 | { |  | 43103 | {
| 43152 | using namespace cv::cuda; |  | 43104 | using namespace cv::cuda;
| 43153 |  |  | 43105 |
| 43154 |  |  | 43106 |
| 43155 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43107 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43156 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43108 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43157 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43109 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43158 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43110 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43159 | Size retval; |  | 43111 | Size retval;
| 43160 |  |  | 43112 |
| 43161 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43113 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43162 | { |  | 43114 | {
| 43163 | ERRWRAP2(retval = _self_->size()); |  | 43115 | ERRWRAP2(retval = _self_->size());
| 43164 | return pyopencv_from(retval); |  | 43116 | return pyopencv_from(retval);
| 43165 | } |  | 43117 | }
| 43166 |  |  | 43118 |
| 43167 | return NULL; |  | 43119 | return NULL;
| 43168 | } |  | 43120 | }
| 43169 |  |  | 43121 |
| 43170 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_step1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43122 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_step1(PyObject* self, PyObject* py_args, PyObject* kw)
| 43171 | { |  | 43123 | {
| 43172 | using namespace cv::cuda; |  | 43124 | using namespace cv::cuda;
| 43173 |  |  | 43125 |
| 43174 |  |  | 43126 |
| 43175 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43127 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43176 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43128 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43177 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43129 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43178 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43130 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43179 | size_t retval; |  | 43131 | size_t retval;
| 43180 |  |  | 43132 |
| 43181 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43133 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43182 | { |  | 43134 | {
| 43183 | ERRWRAP2(retval = _self_->step1()); |  | 43135 | ERRWRAP2(retval = _self_->step1());
| 43184 | return pyopencv_from(retval); |  | 43136 | return pyopencv_from(retval);
| 43185 | } |  | 43137 | }
| 43186 |  |  | 43138 |
| 43187 | return NULL; |  | 43139 | return NULL;
| 43188 | } |  | 43140 | }
| 43189 |  |  | 43141 |
| 43190 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_swap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43142 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_swap(PyObject* self, PyObject* py_args, PyObject* kw)
| 43191 | { |  | 43143 | {
| 43192 | using namespace cv::cuda; |  | 43144 | using namespace cv::cuda;
| 43193 |  |  | 43145 |
| 43194 |  |  | 43146 |
| 43195 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43147 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43196 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43148 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43197 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43149 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43198 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43150 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43199 | PyObject* pyobj_b = NULL; |  | 43151 | PyObject* pyobj_b = NULL;
| 43200 | HostMem b; |  | 43152 | HostMem b;
| 43201 |  |  | 43153 |
| 43202 | const char* keywords[] = { "b", NULL }; |  | 43154 | const char* keywords[] = { "b", NULL };
| 43203 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_HostMem.swap", (char**)keywords, &pyobj_b) && |  | 43155 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_HostMem.swap", (char**)keywords, &pyobj_b) &&
| 43204 | pyopencv_to_safe(pyobj_b, b, ArgInfo("b", 0)) ) |  | 43156 | pyopencv_to_safe(pyobj_b, b, ArgInfo("b", 0)) )
| 43205 | { |  | 43157 | {
| 43206 | ERRWRAP2(_self_->swap(b)); |  | 43158 | ERRWRAP2(_self_->swap(b));
| 43207 | Py_RETURN_NONE; |  | 43159 | Py_RETURN_NONE;
| 43208 | } |  | 43160 | }
| 43209 |  |  | 43161 |
| 43210 | return NULL; |  | 43162 | return NULL;
| 43211 | } |  | 43163 | }
| 43212 |  |  | 43164 |
| 43213 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_type(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43165 | static PyObject* pyopencv_cv_cuda_cuda_HostMem_type(PyObject* self, PyObject* py_args, PyObject* kw)
| 43214 | { |  | 43166 | {
| 43215 | using namespace cv::cuda; |  | 43167 | using namespace cv::cuda;
| 43216 |  |  | 43168 |
| 43217 |  |  | 43169 |
| 43218 | Ptr<cv::cuda::HostMem> * self1 = 0; |  | 43170 | Ptr<cv::cuda::HostMem> * self1 = 0;
| 43219 | if (!pyopencv_cuda_HostMem_getp(self, self1)) |  | 43171 | if (!pyopencv_cuda_HostMem_getp(self, self1))
| 43220 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)"); |  | 43172 | return failmsgp("Incorrect type of self (must be 'cuda_HostMem' or its derivative)");
| 43221 | Ptr<cv::cuda::HostMem> _self_ = *(self1); |  | 43173 | Ptr<cv::cuda::HostMem> _self_ = *(self1);
| 43222 | int retval; |  | 43174 | int retval;
| 43223 |  |  | 43175 |
| 43224 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43176 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43225 | { |  | 43177 | {
| 43226 | ERRWRAP2(retval = _self_->type()); |  | 43178 | ERRWRAP2(retval = _self_->type());
| 43227 | return pyopencv_from(retval); |  | 43179 | return pyopencv_from(retval);
| 43228 | } |  | 43180 | }
| 43229 |  |  | 43181 |
| 43230 | return NULL; |  | 43182 | return NULL;
| 43231 | } |  | 43183 | }
| 43232 |  |  | 43184 |
| 43233 |  |  | 43185 |
| 43234 |  |  | 43186 |
| 43235 | // Tables (cuda_HostMem) |  | 43187 | // Tables (cuda_HostMem)
| 43236 |  |  | 43188 |
| 43237 | static PyGetSetDef pyopencv_cuda_HostMem_getseters[] = |  | 43189 | static PyGetSetDef pyopencv_cuda_HostMem_getseters[] =
| 43238 | { |  | 43190 | {
| 43239 | {(char*)"step", (getter)pyopencv_cuda_HostMem_get_step, NULL, (char*)"step", NULL}, |  | 43191 | {(char*)"step", (getter)pyopencv_cuda_HostMem_get_step, NULL, (char*)"step", NULL},
| 43240 | {NULL} /* Sentinel */ |  | 43192 | {NULL} /* Sentinel */
| 43241 | }; |  | 43193 | };
| 43242 |  |  | 43194 |
| 43243 | static PyMethodDef pyopencv_cuda_HostMem_methods[] = |  | 43195 | static PyMethodDef pyopencv_cuda_HostMem_methods[] =
| 43244 | { |  | 43196 | {
| 43245 | {"channels", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_channels, 0), "channels() -> retval\n."}, |  | 43197 | {"channels", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_channels, 0), "channels() -> retval\n."},
| 43246 | {"clone", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_clone, 0), "clone() -> retval\n."}, |  | 43198 | {"clone", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_clone, 0), "clone() -> retval\n."},
| 43247 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_create, 0), "create(rows, cols, type) -> None\n."}, |  | 43199 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_create, 0), "create(rows, cols, type) -> None\n."},
| 43248 | {"createMatHeader", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_createMatHeader, 0), "createMatHeader() -> retval\n."}, |  | 43200 | {"createMatHeader", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_createMatHeader, 0), "createMatHeader() -> retval\n."},
| 43249 | {"depth", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_depth, 0), "depth() -> retval\n."}, |  | 43201 | {"depth", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_depth, 0), "depth() -> retval\n."},
| 43250 | {"elemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_elemSize, 0), "elemSize() -> retval\n."}, |  | 43202 | {"elemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_elemSize, 0), "elemSize() -> retval\n."},
| 43251 | {"elemSize1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_elemSize1, 0), "elemSize1() -> retval\n."}, |  | 43203 | {"elemSize1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_elemSize1, 0), "elemSize1() -> retval\n."},
| 43252 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_empty, 0), "empty() -> retval\n."}, |  | 43204 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_empty, 0), "empty() -> retval\n."},
| 43253 | {"isContinuous", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_isContinuous, 0), "isContinuous() -> retval\n. @brief Maps CPU memory to GPU address space and creates the cuda::GpuMat header without reference counting\n. for it.\n. \n. This can be done only if memory was allocated with the SHARED flag and if it is supported by the\n. hardware. Laptops often share video and CPU memory, so address spaces can be mapped, which\n. eliminates an extra copy."}, |  | 43205 | {"isContinuous", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_isContinuous, 0), "isContinuous() -> retval\n. @brief Maps CPU memory to GPU address space and creates the cuda::GpuMat header without reference counting\n. for it.\n. \n. This can be done only if memory was allocated with the SHARED flag and if it is supported by the\n. hardware. Laptops often share video and CPU memory, so address spaces can be mapped, which\n. eliminates an extra copy."},
| 43254 | {"reshape", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_reshape, 0), "reshape(cn[, rows]) -> retval\n."}, |  | 43206 | {"reshape", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_reshape, 0), "reshape(cn[, rows]) -> retval\n."},
| 43255 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_size, 0), "size() -> retval\n."}, |  | 43207 | {"size", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_size, 0), "size() -> retval\n."},
| 43256 | {"step1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_step1, 0), "step1() -> retval\n."}, |  | 43208 | {"step1", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_step1, 0), "step1() -> retval\n."},
| 43257 | {"swap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_swap, 0), "swap(b) -> None\n."}, |  | 43209 | {"swap", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_swap, 0), "swap(b) -> None\n."},
| 43258 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_type, 0), "type() -> retval\n."}, |  | 43210 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_HostMem_type, 0), "type() -> retval\n."},
| 43259 |  |  | 43211 |
| 43260 | {NULL, NULL} |  | 43212 | {NULL, NULL}
| 43261 | }; |  | 43213 | };
| 43262 |  |  | 43214 |
| 43263 | // Converter (cuda_HostMem) |  | 43215 | // Converter (cuda_HostMem)
| 43264 |  |  | 43216 |
| 43265 | template<> |  | 43217 | template<>
| 43266 | struct PyOpenCV_Converter< Ptr<cv::cuda::HostMem> > |  | 43218 | struct PyOpenCV_Converter< Ptr<cv::cuda::HostMem> >
| 43267 | { |  | 43219 | {
| 43268 | static PyObject* from(const Ptr<cv::cuda::HostMem>& r) |  | 43220 | static PyObject* from(const Ptr<cv::cuda::HostMem>& r)
| 43269 | { |  | 43221 | {
| 43270 | return pyopencv_cuda_HostMem_Instance(r); |  | 43222 | return pyopencv_cuda_HostMem_Instance(r);
| 43271 | } |  | 43223 | }
| 43272 | static bool to(PyObject* src, Ptr<cv::cuda::HostMem>& dst, const ArgInfo& info) |  | 43224 | static bool to(PyObject* src, Ptr<cv::cuda::HostMem>& dst, const ArgInfo& info)
| 43273 | { |  | 43225 | {
| 43274 | if(!src || src == Py_None) |  | 43226 | if(!src || src == Py_None)
| 43275 | return true; |  | 43227 | return true;
| 43276 | Ptr<cv::cuda::HostMem> * dst_; |  | 43228 | Ptr<cv::cuda::HostMem> * dst_;
| 43277 | if (pyopencv_cuda_HostMem_getp(src, dst_)) |  | 43229 | if (pyopencv_cuda_HostMem_getp(src, dst_))
| 43278 | { |  | 43230 | {
| 43279 | dst = *dst_; |  | 43231 | dst = *dst_;
| 43280 | return true; |  | 43232 | return true;
| 43281 | } |  | 43233 | }
| 43282 |  |  | 43234 |
| 43283 | failmsg("Expected Ptr<cv::cuda::HostMem> for argument '%s'", info.name); |  | 43235 | failmsg("Expected Ptr<cv::cuda::HostMem> for argument '%s'", info.name);
| 43284 | return false; |  | 43236 | return false;
| 43285 | } |  | 43237 | }
| 43286 | }; |  | 43238 | };
| 43287 |  |  | 43239 |
| 43288 | //================================================================================ |  | 43240 | //================================================================================
| 43289 | // cuda_SURF_CUDA (Generic) |  | 43241 | // cuda_SURF_CUDA (Generic)
| 43290 | //================================================================================ |  | 43242 | //================================================================================
| 43291 |  |  | 43243 |
| 43292 | // GetSet (cuda_SURF_CUDA) |  | 43244 | // GetSet (cuda_SURF_CUDA)
| 43293 |  |  | 43245 |
| 43294 |  |  | 43246 |
| 43295 | static PyObject* pyopencv_cuda_SURF_CUDA_get_extended(pyopencv_cuda_SURF_CUDA_t* p, void *closure) |  | 43247 | static PyObject* pyopencv_cuda_SURF_CUDA_get_extended(pyopencv_cuda_SURF_CUDA_t* p, void *closure)
| 43296 | { |  | 43248 | {
| 43297 | return pyopencv_from(p->v->extended); |  | 43249 | return pyopencv_from(p->v->extended);
| 43298 | } |  | 43250 | }
| 43299 |  |  | 43251 |
| 43300 | static PyObject* pyopencv_cuda_SURF_CUDA_get_hessianThreshold(pyopencv_cuda_SURF_CUDA_t* p, void *closure) |  | 43252 | static PyObject* pyopencv_cuda_SURF_CUDA_get_hessianThreshold(pyopencv_cuda_SURF_CUDA_t* p, void *closure)
| 43301 | { |  | 43253 | {
| 43302 | return pyopencv_from(p->v->hessianThreshold); |  | 43254 | return pyopencv_from(p->v->hessianThreshold);
| 43303 | } |  | 43255 | }
| 43304 |  |  | 43256 |
| 43305 | static PyObject* pyopencv_cuda_SURF_CUDA_get_keypointsRatio(pyopencv_cuda_SURF_CUDA_t* p, void *closure) |  | 43257 | static PyObject* pyopencv_cuda_SURF_CUDA_get_keypointsRatio(pyopencv_cuda_SURF_CUDA_t* p, void *closure)
| 43306 | { |  | 43258 | {
| 43307 | return pyopencv_from(p->v->keypointsRatio); |  | 43259 | return pyopencv_from(p->v->keypointsRatio);
| 43308 | } |  | 43260 | }
| 43309 |  |  | 43261 |
| 43310 | static PyObject* pyopencv_cuda_SURF_CUDA_get_nOctaveLayers(pyopencv_cuda_SURF_CUDA_t* p, void *closure) |  | 43262 | static PyObject* pyopencv_cuda_SURF_CUDA_get_nOctaveLayers(pyopencv_cuda_SURF_CUDA_t* p, void *closure)
| 43311 | { |  | 43263 | {
| 43312 | return pyopencv_from(p->v->nOctaveLayers); |  | 43264 | return pyopencv_from(p->v->nOctaveLayers);
| 43313 | } |  | 43265 | }
| 43314 |  |  | 43266 |
| 43315 | static PyObject* pyopencv_cuda_SURF_CUDA_get_nOctaves(pyopencv_cuda_SURF_CUDA_t* p, void *closure) |  | 43267 | static PyObject* pyopencv_cuda_SURF_CUDA_get_nOctaves(pyopencv_cuda_SURF_CUDA_t* p, void *closure)
| 43316 | { |  | 43268 | {
| 43317 | return pyopencv_from(p->v->nOctaves); |  | 43269 | return pyopencv_from(p->v->nOctaves);
| 43318 | } |  | 43270 | }
| 43319 |  |  | 43271 |
| 43320 | static PyObject* pyopencv_cuda_SURF_CUDA_get_upright(pyopencv_cuda_SURF_CUDA_t* p, void *closure) |  | 43272 | static PyObject* pyopencv_cuda_SURF_CUDA_get_upright(pyopencv_cuda_SURF_CUDA_t* p, void *closure)
| 43321 | { |  | 43273 | {
| 43322 | return pyopencv_from(p->v->upright); |  | 43274 | return pyopencv_from(p->v->upright);
| 43323 | } |  | 43275 | }
| 43324 |  |  | 43276 |
| 43325 |  |  | 43277 |
| 43326 | // Methods (cuda_SURF_CUDA) |  | 43278 | // Methods (cuda_SURF_CUDA)
| 43327 |  |  | 43279 |
| 43328 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43280 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43329 | { |  | 43281 | {
| 43330 | using namespace cv::cuda; |  | 43282 | using namespace cv::cuda;
| 43331 |  |  | 43283 |
| 43332 | PyObject* pyobj__hessianThreshold = NULL; |  | 43284 | PyObject* pyobj__hessianThreshold = NULL;
| 43333 | double _hessianThreshold=0; |  | 43285 | double _hessianThreshold=0;
| 43334 | PyObject* pyobj__nOctaves = NULL; |  | 43286 | PyObject* pyobj__nOctaves = NULL;
| 43335 | int _nOctaves=4; |  | 43287 | int _nOctaves=4;
| 43336 | PyObject* pyobj__nOctaveLayers = NULL; |  | 43288 | PyObject* pyobj__nOctaveLayers = NULL;
| 43337 | int _nOctaveLayers=2; |  | 43289 | int _nOctaveLayers=2;
| 43338 | PyObject* pyobj__extended = NULL; |  | 43290 | PyObject* pyobj__extended = NULL;
| 43339 | bool _extended=false; |  | 43291 | bool _extended=false;
| 43340 | PyObject* pyobj__keypointsRatio = NULL; |  | 43292 | PyObject* pyobj__keypointsRatio = NULL;
| 43341 | float _keypointsRatio=0.01f; |  | 43293 | float _keypointsRatio=0.01f;
| 43342 | PyObject* pyobj__upright = NULL; |  | 43294 | PyObject* pyobj__upright = NULL;
| 43343 | bool _upright=false; |  | 43295 | bool _upright=false;
| 43344 | Ptr<SURF_CUDA> retval; |  | 43296 | Ptr<SURF_CUDA> retval;
| 43345 |  |  | 43297 |
| 43346 | const char* keywords[] = { "_hessianThreshold", "_nOctaves", "_nOctaveLayers", "_extended", "_keypointsRatio", "_upright", NULL }; |  | 43298 | const char* keywords[] = { "_hessianThreshold", "_nOctaves", "_nOctaveLayers", "_extended", "_keypointsRatio", "_upright", NULL };
| 43347 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:cuda_SURF_CUDA.create", (char**)keywords, &pyobj__hessianThreshold, &pyobj__nOctaves, &pyobj__nOctaveLayers, &pyobj__extended, &pyobj__keypointsRatio, &pyobj__upright) && |  | 43299 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:cuda_SURF_CUDA.create", (char**)keywords, &pyobj__hessianThreshold, &pyobj__nOctaves, &pyobj__nOctaveLayers, &pyobj__extended, &pyobj__keypointsRatio, &pyobj__upright) &&
| 43348 | pyopencv_to_safe(pyobj__hessianThreshold, _hessianThreshold, ArgInfo("_hessianThreshold", 0)) && |  | 43300 | pyopencv_to_safe(pyobj__hessianThreshold, _hessianThreshold, ArgInfo("_hessianThreshold", 0)) &&
| 43349 | pyopencv_to_safe(pyobj__nOctaves, _nOctaves, ArgInfo("_nOctaves", 0)) && |  | 43301 | pyopencv_to_safe(pyobj__nOctaves, _nOctaves, ArgInfo("_nOctaves", 0)) &&
| 43350 | pyopencv_to_safe(pyobj__nOctaveLayers, _nOctaveLayers, ArgInfo("_nOctaveLayers", 0)) && |  | 43302 | pyopencv_to_safe(pyobj__nOctaveLayers, _nOctaveLayers, ArgInfo("_nOctaveLayers", 0)) &&
| 43351 | pyopencv_to_safe(pyobj__extended, _extended, ArgInfo("_extended", 0)) && |  | 43303 | pyopencv_to_safe(pyobj__extended, _extended, ArgInfo("_extended", 0)) &&
| 43352 | pyopencv_to_safe(pyobj__keypointsRatio, _keypointsRatio, ArgInfo("_keypointsRatio", 0)) && |  | 43304 | pyopencv_to_safe(pyobj__keypointsRatio, _keypointsRatio, ArgInfo("_keypointsRatio", 0)) &&
| 43353 | pyopencv_to_safe(pyobj__upright, _upright, ArgInfo("_upright", 0)) ) |  | 43305 | pyopencv_to_safe(pyobj__upright, _upright, ArgInfo("_upright", 0)) )
| 43354 | { |  | 43306 | {
| 43355 | ERRWRAP2(retval = cv::cuda::SURF_CUDA::create(_hessianThreshold, _nOctaves, _nOctaveLayers, _extended, _keypointsRatio, _upright)); |  | 43307 | ERRWRAP2(retval = cv::cuda::SURF_CUDA::create(_hessianThreshold, _nOctaves, _nOctaveLayers, _extended, _keypointsRatio, _upright));
| 43356 | return pyopencv_from(retval); |  | 43308 | return pyopencv_from(retval);
| 43357 | } |  | 43309 | }
| 43358 |  |  | 43310 |
| 43359 | return NULL; |  | 43311 | return NULL;
| 43360 | } |  | 43312 | }
| 43361 |  |  | 43313 |
| 43362 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_defaultNorm(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43314 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_defaultNorm(PyObject* self, PyObject* py_args, PyObject* kw)
| 43363 | { |  | 43315 | {
| 43364 | using namespace cv::cuda; |  | 43316 | using namespace cv::cuda;
| 43365 |  |  | 43317 |
| 43366 |  |  | 43318 |
| 43367 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0; |  | 43319 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0;
| 43368 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1)) |  | 43320 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1))
| 43369 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)"); |  | 43321 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)");
| 43370 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1); |  | 43322 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1);
| 43371 | int retval; |  | 43323 | int retval;
| 43372 |  |  | 43324 |
| 43373 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43374 | { |  | 43326 | {
| 43375 | ERRWRAP2(retval = _self_->defaultNorm()); |  | 43327 | ERRWRAP2(retval = _self_->defaultNorm());
| 43376 | return pyopencv_from(retval); |  | 43328 | return pyopencv_from(retval);
| 43377 | } |  | 43329 | }
| 43378 |  |  | 43330 |
| 43379 | return NULL; |  | 43331 | return NULL;
| 43380 | } |  | 43332 | }
| 43381 |  |  | 43333 |
| 43382 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_descriptorSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43334 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_descriptorSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 43383 | { |  | 43335 | {
| 43384 | using namespace cv::cuda; |  | 43336 | using namespace cv::cuda;
| 43385 |  |  | 43337 |
| 43386 |  |  | 43338 |
| 43387 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0; |  | 43339 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0;
| 43388 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1)) |  | 43340 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1))
| 43389 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)"); |  | 43341 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)");
| 43390 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1); |  | 43342 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1);
| 43391 | int retval; |  | 43343 | int retval;
| 43392 |  |  | 43344 |
| 43393 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43345 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43394 | { |  | 43346 | {
| 43395 | ERRWRAP2(retval = _self_->descriptorSize()); |  | 43347 | ERRWRAP2(retval = _self_->descriptorSize());
| 43396 | return pyopencv_from(retval); |  | 43348 | return pyopencv_from(retval);
| 43397 | } |  | 43349 | }
| 43398 |  |  | 43350 |
| 43399 | return NULL; |  | 43351 | return NULL;
| 43400 | } |  | 43352 | }
| 43401 |  |  | 43353 |
| 43402 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43354 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 43403 | { |  | 43355 | {
| 43404 | using namespace cv::cuda; |  | 43356 | using namespace cv::cuda;
| 43405 |  |  | 43357 |
| 43406 |  |  | 43358 |
| 43407 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0; |  | 43359 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0;
| 43408 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1)) |  | 43360 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1))
| 43409 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)"); |  | 43361 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)");
| 43410 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1); |  | 43362 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1);
| 43411 | PyObject* pyobj_img = NULL; |  | 43363 | PyObject* pyobj_img = NULL;
| 43412 | GpuMat img; |  | 43364 | GpuMat img;
| 43413 | PyObject* pyobj_mask = NULL; |  | 43365 | PyObject* pyobj_mask = NULL;
| 43414 | GpuMat mask; |  | 43366 | GpuMat mask;
| 43415 | PyObject* pyobj_keypoints = NULL; |  | 43367 | PyObject* pyobj_keypoints = NULL;
| 43416 | GpuMat keypoints; |  | 43368 | GpuMat keypoints;
| 43417 |  |  | 43369 |
| 43418 | const char* keywords[] = { "img", "mask", "keypoints", NULL }; |  | 43370 | const char* keywords[] = { "img", "mask", "keypoints", NULL };
| 43419 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:cuda_SURF_CUDA.detect", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_keypoints) && |  | 43371 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:cuda_SURF_CUDA.detect", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_keypoints) &&
| 43420 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 43372 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 43421 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 43373 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 43422 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) ) |  | 43374 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) )
| 43423 | { |  | 43375 | {
| 43424 | ERRWRAP2(_self_->detect(img, mask, keypoints)); |  | 43376 | ERRWRAP2(_self_->detect(img, mask, keypoints));
| 43425 | return pyopencv_from(keypoints); |  | 43377 | return pyopencv_from(keypoints);
| 43426 | } |  | 43378 | }
| 43427 |  |  | 43379 |
| 43428 | return NULL; |  | 43380 | return NULL;
| 43429 | } |  | 43381 | }
| 43430 |  |  | 43382 |
| 43431 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_detectWithDescriptors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43383 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_detectWithDescriptors(PyObject* self, PyObject* py_args, PyObject* kw)
| 43432 | { |  | 43384 | {
| 43433 | using namespace cv::cuda; |  | 43385 | using namespace cv::cuda;
| 43434 |  |  | 43386 |
| 43435 |  |  | 43387 |
| 43436 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0; |  | 43388 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0;
| 43437 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1)) |  | 43389 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1))
| 43438 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)"); |  | 43390 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)");
| 43439 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1); |  | 43391 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1);
| 43440 | PyObject* pyobj_img = NULL; |  | 43392 | PyObject* pyobj_img = NULL;
| 43441 | GpuMat img; |  | 43393 | GpuMat img;
| 43442 | PyObject* pyobj_mask = NULL; |  | 43394 | PyObject* pyobj_mask = NULL;
| 43443 | GpuMat mask; |  | 43395 | GpuMat mask;
| 43444 | PyObject* pyobj_keypoints = NULL; |  | 43396 | PyObject* pyobj_keypoints = NULL;
| 43445 | GpuMat keypoints; |  | 43397 | GpuMat keypoints;
| 43446 | PyObject* pyobj_descriptors = NULL; |  | 43398 | PyObject* pyobj_descriptors = NULL;
| 43447 | GpuMat descriptors; |  | 43399 | GpuMat descriptors;
| 43448 | PyObject* pyobj_useProvidedKeypoints = NULL; |  | 43400 | PyObject* pyobj_useProvidedKeypoints = NULL;
| 43449 | bool useProvidedKeypoints=false; |  | 43401 | bool useProvidedKeypoints=false;
| 43450 |  |  | 43402 |
| 43451 | const char* keywords[] = { "img", "mask", "keypoints", "descriptors", "useProvidedKeypoints", NULL }; |  | 43403 | const char* keywords[] = { "img", "mask", "keypoints", "descriptors", "useProvidedKeypoints", NULL };
| 43452 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:cuda_SURF_CUDA.detectWithDescriptors", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_keypoints, &pyobj_descriptors, &pyobj_useProvidedKeypoints) && |  | 43404 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:cuda_SURF_CUDA.detectWithDescriptors", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_keypoints, &pyobj_descriptors, &pyobj_useProvidedKeypoints) &&
| 43453 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 43405 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 43454 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 43406 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 43455 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) && |  | 43407 | pyopencv_to_safe(pyobj_keypoints, keypoints, ArgInfo("keypoints", 1)) &&
| 43456 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) && |  | 43408 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) &&
| 43457 | pyopencv_to_safe(pyobj_useProvidedKeypoints, useProvidedKeypoints, ArgInfo("useProvidedKeypoints", 0)) ) |  | 43409 | pyopencv_to_safe(pyobj_useProvidedKeypoints, useProvidedKeypoints, ArgInfo("useProvidedKeypoints", 0)) )
| 43458 | { |  | 43410 | {
| 43459 | ERRWRAP2(_self_->detectWithDescriptors(img, mask, keypoints, descriptors, useProvidedKeypoints)); |  | 43411 | ERRWRAP2(_self_->detectWithDescriptors(img, mask, keypoints, descriptors, useProvidedKeypoints));
| 43460 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors)); |  | 43412 | return Py_BuildValue("(NN)", pyopencv_from(keypoints), pyopencv_from(descriptors));
| 43461 | } |  | 43413 | }
| 43462 |  |  | 43414 |
| 43463 | return NULL; |  | 43415 | return NULL;
| 43464 | } |  | 43416 | }
| 43465 |  |  | 43417 |
| 43466 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_downloadKeypoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43418 | static PyObject* pyopencv_cv_cuda_cuda_SURF_CUDA_downloadKeypoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 43467 | { |  | 43419 | {
| 43468 | using namespace cv::cuda; |  | 43420 | using namespace cv::cuda;
| 43469 |  |  | 43421 |
| 43470 |  |  | 43422 |
| 43471 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0; |  | 43423 | Ptr<cv::cuda::SURF_CUDA> * self1 = 0;
| 43472 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1)) |  | 43424 | if (!pyopencv_cuda_SURF_CUDA_getp(self, self1))
| 43473 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)"); |  | 43425 | return failmsgp("Incorrect type of self (must be 'cuda_SURF_CUDA' or its derivative)");
| 43474 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1); |  | 43426 | Ptr<cv::cuda::SURF_CUDA> _self_ = *(self1);
| 43475 | PyObject* pyobj_keypointsGPU = NULL; |  | 43427 | PyObject* pyobj_keypointsGPU = NULL;
| 43476 | GpuMat keypointsGPU; |  | 43428 | GpuMat keypointsGPU;
| 43477 | vector_KeyPoint keypoints; |  | 43429 | vector_KeyPoint keypoints;
| 43478 |  |  | 43430 |
| 43479 | const char* keywords[] = { "keypointsGPU", NULL }; |  | 43431 | const char* keywords[] = { "keypointsGPU", NULL };
| 43480 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_SURF_CUDA.downloadKeypoints", (char**)keywords, &pyobj_keypointsGPU) && |  | 43432 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_SURF_CUDA.downloadKeypoints", (char**)keywords, &pyobj_keypointsGPU) &&
| 43481 | pyopencv_to_safe(pyobj_keypointsGPU, keypointsGPU, ArgInfo("keypointsGPU", 0)) ) |  | 43433 | pyopencv_to_safe(pyobj_keypointsGPU, keypointsGPU, ArgInfo("keypointsGPU", 0)) )
| 43482 | { |  | 43434 | {
| 43483 | ERRWRAP2(_self_->downloadKeypoints(keypointsGPU, keypoints)); |  | 43435 | ERRWRAP2(_self_->downloadKeypoints(keypointsGPU, keypoints));
| 43484 | return pyopencv_from(keypoints); |  | 43436 | return pyopencv_from(keypoints);
| 43485 | } |  | 43437 | }
| 43486 |  |  | 43438 |
| 43487 | return NULL; |  | 43439 | return NULL;
| 43488 | } |  | 43440 | }
| 43489 |  |  | 43441 |
| 43490 |  |  | 43442 |
| 43491 |  |  | 43443 |
| 43492 | // Tables (cuda_SURF_CUDA) |  | 43444 | // Tables (cuda_SURF_CUDA)
| 43493 |  |  | 43445 |
| 43494 | static PyGetSetDef pyopencv_cuda_SURF_CUDA_getseters[] = |  | 43446 | static PyGetSetDef pyopencv_cuda_SURF_CUDA_getseters[] =
| 43495 | { |  | 43447 | {
| 43496 | {(char*)"extended", (getter)pyopencv_cuda_SURF_CUDA_get_extended, NULL, (char*)"extended", NULL}, |  | 43448 | {(char*)"extended", (getter)pyopencv_cuda_SURF_CUDA_get_extended, NULL, (char*)"extended", NULL},
| 43497 | {(char*)"hessianThreshold", (getter)pyopencv_cuda_SURF_CUDA_get_hessianThreshold, NULL, (char*)"hessianThreshold", NULL}, |  | 43449 | {(char*)"hessianThreshold", (getter)pyopencv_cuda_SURF_CUDA_get_hessianThreshold, NULL, (char*)"hessianThreshold", NULL},
| 43498 | {(char*)"keypointsRatio", (getter)pyopencv_cuda_SURF_CUDA_get_keypointsRatio, NULL, (char*)"keypointsRatio", NULL}, |  | 43450 | {(char*)"keypointsRatio", (getter)pyopencv_cuda_SURF_CUDA_get_keypointsRatio, NULL, (char*)"keypointsRatio", NULL},
| 43499 | {(char*)"nOctaveLayers", (getter)pyopencv_cuda_SURF_CUDA_get_nOctaveLayers, NULL, (char*)"nOctaveLayers", NULL}, |  | 43451 | {(char*)"nOctaveLayers", (getter)pyopencv_cuda_SURF_CUDA_get_nOctaveLayers, NULL, (char*)"nOctaveLayers", NULL},
| 43500 | {(char*)"nOctaves", (getter)pyopencv_cuda_SURF_CUDA_get_nOctaves, NULL, (char*)"nOctaves", NULL}, |  | 43452 | {(char*)"nOctaves", (getter)pyopencv_cuda_SURF_CUDA_get_nOctaves, NULL, (char*)"nOctaves", NULL},
| 43501 | {(char*)"upright", (getter)pyopencv_cuda_SURF_CUDA_get_upright, NULL, (char*)"upright", NULL}, |  | 43453 | {(char*)"upright", (getter)pyopencv_cuda_SURF_CUDA_get_upright, NULL, (char*)"upright", NULL},
| 43502 | {NULL} /* Sentinel */ |  | 43454 | {NULL} /* Sentinel */
| 43503 | }; |  | 43455 | };
| 43504 |  |  | 43456 |
| 43505 | static PyMethodDef pyopencv_cuda_SURF_CUDA_methods[] = |  | 43457 | static PyMethodDef pyopencv_cuda_SURF_CUDA_methods[] =
| 43506 | { |  | 43458 | {
| 43507 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_create_static, METH_STATIC), "create(_hessianThreshold[, _nOctaves[, _nOctaveLayers[, _extended[, _keypointsRatio[, _upright]]]]]) -> retval\n. @param _hessianThreshold Threshold for hessian keypoint detector used in SURF.\n. @param _nOctaves Number of pyramid octaves the keypoint detector will use.\n. @param _nOctaveLayers Number of octave layers within each octave.\n. @param _extended Extended descriptor flag (true - use extended 128-element descriptors; false - use\n. 64-element descriptors).\n. @param _keypointsRatio Limits a maximum number of features\n. @param _upright Up-right or rotated features flag (true - do not compute orientation of features;\n. false - compute orientation)."}, |  | 43459 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_create_static, METH_STATIC), "create(_hessianThreshold[, _nOctaves[, _nOctaveLayers[, _extended[, _keypointsRatio[, _upright]]]]]) -> retval\n. @param _hessianThreshold Threshold for hessian keypoint detector used in SURF.\n. @param _nOctaves Number of pyramid octaves the keypoint detector will use.\n. @param _nOctaveLayers Number of octave layers within each octave.\n. @param _extended Extended descriptor flag (true - use extended 128-element descriptors; false - use\n. 64-element descriptors).\n. @param _keypointsRatio Limits a maximum number of features\n. @param _upright Up-right or rotated features flag (true - do not compute orientation of features;\n. false - compute orientation)."},
| 43508 | {"defaultNorm", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_defaultNorm, 0), "defaultNorm() -> retval\n."}, |  | 43460 | {"defaultNorm", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_defaultNorm, 0), "defaultNorm() -> retval\n."},
| 43509 | {"descriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_descriptorSize, 0), "descriptorSize() -> retval\n."}, |  | 43461 | {"descriptorSize", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_descriptorSize, 0), "descriptorSize() -> retval\n."},
| 43510 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_detect, 0), "detect(img, mask[, keypoints]) -> keypoints\n. @brief Finds the keypoints using fast hessian detector used in SURF\n. \n. @param img Source image, currently supports only CV_8UC1 images.\n. @param mask A mask image same size as src and of type CV_8UC1.\n. @param keypoints Detected keypoints."}, |  | 43462 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_detect, 0), "detect(img, mask[, keypoints]) -> keypoints\n. @brief Finds the keypoints using fast hessian detector used in SURF\n. \n. @param img Source image, currently supports only CV_8UC1 images.\n. @param mask A mask image same size as src and of type CV_8UC1.\n. @param keypoints Detected keypoints."},
| 43511 | {"detectWithDescriptors", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_detectWithDescriptors, 0), "detectWithDescriptors(img, mask[, keypoints[, descriptors[, useProvidedKeypoints]]]) -> keypoints, descriptors\n. @brief Finds the keypoints and computes their descriptors using fast hessian detector used in SURF\n. \n. @param img Source image, currently supports only CV_8UC1 images.\n. @param mask A mask image same size as src and of type CV_8UC1.\n. @param keypoints Detected keypoints.\n. @param descriptors Keypoint descriptors.\n. @param useProvidedKeypoints Compute descriptors for the user-provided keypoints and recompute keypoints direction."}, |  | 43463 | {"detectWithDescriptors", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_detectWithDescriptors, 0), "detectWithDescriptors(img, mask[, keypoints[, descriptors[, useProvidedKeypoints]]]) -> keypoints, descriptors\n. @brief Finds the keypoints and computes their descriptors using fast hessian detector used in SURF\n. \n. @param img Source image, currently supports only CV_8UC1 images.\n. @param mask A mask image same size as src and of type CV_8UC1.\n. @param keypoints Detected keypoints.\n. @param descriptors Keypoint descriptors.\n. @param useProvidedKeypoints Compute descriptors for the user-provided keypoints and recompute keypoints direction."},
| 43512 | {"downloadKeypoints", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_downloadKeypoints, 0), "downloadKeypoints(keypointsGPU) -> keypoints\n."}, |  | 43464 | {"downloadKeypoints", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_SURF_CUDA_downloadKeypoints, 0), "downloadKeypoints(keypointsGPU) -> keypoints\n."},
| 43513 |  |  | 43465 |
| 43514 | {NULL, NULL} |  | 43466 | {NULL, NULL}
| 43515 | }; |  | 43467 | };
| 43516 |  |  | 43468 |
| 43517 | // Converter (cuda_SURF_CUDA) |  | 43469 | // Converter (cuda_SURF_CUDA)
| 43518 |  |  | 43470 |
| 43519 | template<> |  | 43471 | template<>
| 43520 | struct PyOpenCV_Converter< Ptr<cv::cuda::SURF_CUDA> > |  | 43472 | struct PyOpenCV_Converter< Ptr<cv::cuda::SURF_CUDA> >
| 43521 | { |  | 43473 | {
| 43522 | static PyObject* from(const Ptr<cv::cuda::SURF_CUDA>& r) |  | 43474 | static PyObject* from(const Ptr<cv::cuda::SURF_CUDA>& r)
| 43523 | { |  | 43475 | {
| 43524 | return pyopencv_cuda_SURF_CUDA_Instance(r); |  | 43476 | return pyopencv_cuda_SURF_CUDA_Instance(r);
| 43525 | } |  | 43477 | }
| 43526 | static bool to(PyObject* src, Ptr<cv::cuda::SURF_CUDA>& dst, const ArgInfo& info) |  | 43478 | static bool to(PyObject* src, Ptr<cv::cuda::SURF_CUDA>& dst, const ArgInfo& info)
| 43527 | { |  | 43479 | {
| 43528 | if(!src || src == Py_None) |  | 43480 | if(!src || src == Py_None)
| 43529 | return true; |  | 43481 | return true;
| 43530 | Ptr<cv::cuda::SURF_CUDA> * dst_; |  | 43482 | Ptr<cv::cuda::SURF_CUDA> * dst_;
| 43531 | if (pyopencv_cuda_SURF_CUDA_getp(src, dst_)) |  | 43483 | if (pyopencv_cuda_SURF_CUDA_getp(src, dst_))
| 43532 | { |  | 43484 | {
| 43533 | dst = *dst_; |  | 43485 | dst = *dst_;
| 43534 | return true; |  | 43486 | return true;
| 43535 | } |  | 43487 | }
| 43536 |  |  | 43488 |
| 43537 | failmsg("Expected Ptr<cv::cuda::SURF_CUDA> for argument '%s'", info.name); |  | 43489 | failmsg("Expected Ptr<cv::cuda::SURF_CUDA> for argument '%s'", info.name);
| 43538 | return false; |  | 43490 | return false;
| 43539 | } |  | 43491 | }
| 43540 | }; |  | 43492 | };
| 43541 |  |  | 43493 |
| 43542 | //================================================================================ |  | 43494 | //================================================================================
| 43543 | // cuda_Stream (Generic) |  | 43495 | // cuda_Stream (Generic)
| 43544 | //================================================================================ |  | 43496 | //================================================================================
| 43545 |  |  | 43497 |
| 43546 | // GetSet (cuda_Stream) |  | 43498 | // GetSet (cuda_Stream)
| 43547 |  |  | 43499 |
| 43548 |  |  | 43500 |
| 43549 |  |  | 43501 |
| 43550 | // Methods (cuda_Stream) |  | 43502 | // Methods (cuda_Stream)
| 43551 |  |  | 43503 |
| 43552 | static int pyopencv_cv_cuda_cuda_Stream_Stream(pyopencv_cuda_Stream_t* self, PyObject* py_args, PyObject* kw) |  | 43504 | static int pyopencv_cv_cuda_cuda_Stream_Stream(pyopencv_cuda_Stream_t* self, PyObject* py_args, PyObject* kw)
| 43553 | { |  | 43505 | {
| 43554 | using namespace cv::cuda; |  | 43506 | using namespace cv::cuda;
| 43555 |  |  | 43507 |
| 43556 | pyPrepareArgumentConversionErrorsStorage(3); |  | 43508 | pyPrepareArgumentConversionErrorsStorage(3);
| 43557 |  |  | 43509 |
| 43558 | { |  | 43510 | {
| 43559 |  |  | 43511 |
| 43560 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43512 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43561 | { |  | 43513 | {
| 43562 | new (&(self->v)) Ptr<cv::cuda::Stream>(); // init Ptr with placement new |  | 43514 | new (&(self->v)) Ptr<cv::cuda::Stream>(); // init Ptr with placement new
| 43563 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Stream())); |  | 43515 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Stream()));
| 43564 | return 0; |  | 43516 | return 0;
| 43565 | } |  | 43517 | }
| 43566 |  |  | 43518 |
| 43567 |  |  | 43519 |
| 43568 | pyPopulateArgumentConversionErrors(); |  | 43520 | pyPopulateArgumentConversionErrors();
| 43569 | } |  | 43521 | }
| 43570 |  |  | 43522 |
| 43571 |  |  | 43523 |
| 43572 | { |  | 43524 | {
| 43573 | PyObject* pyobj_allocator = NULL; |  | 43525 | PyObject* pyobj_allocator = NULL;
| 43574 | Ptr<GpuMat::Allocator> allocator; |  | 43526 | Ptr<GpuMat::Allocator> allocator;
| 43575 |  |  | 43527 |
| 43576 | const char* keywords[] = { "allocator", NULL }; |  | 43528 | const char* keywords[] = { "allocator", NULL };
| 43577 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stream", (char**)keywords, &pyobj_allocator) && |  | 43529 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stream", (char**)keywords, &pyobj_allocator) &&
| 43578 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) ) |  | 43530 | pyopencv_to_safe(pyobj_allocator, allocator, ArgInfo("allocator", 0)) )
| 43579 | { |  | 43531 | {
| 43580 | new (&(self->v)) Ptr<cv::cuda::Stream>(); // init Ptr with placement new |  | 43532 | new (&(self->v)) Ptr<cv::cuda::Stream>(); // init Ptr with placement new
| 43581 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Stream(allocator))); |  | 43533 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Stream(allocator)));
| 43582 | return 0; |  | 43534 | return 0;
| 43583 | } |  | 43535 | }
| 43584 |  |  | 43536 |
| 43585 |  |  | 43537 |
| 43586 | pyPopulateArgumentConversionErrors(); |  | 43538 | pyPopulateArgumentConversionErrors();
| 43587 | } |  | 43539 | }
| 43588 |  |  | 43540 |
| 43589 |  |  | 43541 |
| 43590 | { |  | 43542 | {
| 43591 | PyObject* pyobj_cudaFlags = NULL; |  | 43543 | PyObject* pyobj_cudaFlags = NULL;
| 43592 | size_t cudaFlags=0; |  | 43544 | size_t cudaFlags=0;
| 43593 |  |  | 43545 |
| 43594 | const char* keywords[] = { "cudaFlags", NULL }; |  | 43546 | const char* keywords[] = { "cudaFlags", NULL };
| 43595 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stream", (char**)keywords, &pyobj_cudaFlags) && |  | 43547 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Stream", (char**)keywords, &pyobj_cudaFlags) &&
| 43596 | pyopencv_to_safe(pyobj_cudaFlags, cudaFlags, ArgInfo("cudaFlags", 0)) ) |  | 43548 | pyopencv_to_safe(pyobj_cudaFlags, cudaFlags, ArgInfo("cudaFlags", 0)) )
| 43597 | { |  | 43549 | {
| 43598 | new (&(self->v)) Ptr<cv::cuda::Stream>(); // init Ptr with placement new |  | 43550 | new (&(self->v)) Ptr<cv::cuda::Stream>(); // init Ptr with placement new
| 43599 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Stream(cudaFlags))); |  | 43551 | if(self) ERRWRAP2(self->v.reset(new cv::cuda::Stream(cudaFlags)));
| 43600 | return 0; |  | 43552 | return 0;
| 43601 | } |  | 43553 | }
| 43602 |  |  | 43554 |
| 43603 |  |  | 43555 |
| 43604 | pyPopulateArgumentConversionErrors(); |  | 43556 | pyPopulateArgumentConversionErrors();
| 43605 | } |  | 43557 | }
| 43606 | pyRaiseCVOverloadException("Stream"); |  | 43558 | pyRaiseCVOverloadException("Stream");
| 43607 |  |  | 43559 |
| 43608 | return -1; |  | 43560 | return -1;
| 43609 | } |  | 43561 | }
| 43610 |  |  | 43562 |
| 43611 | static PyObject* pyopencv_cv_cuda_cuda_Stream_Null_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43563 | static PyObject* pyopencv_cv_cuda_cuda_Stream_Null_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43612 | { |  | 43564 | {
| 43613 | using namespace cv::cuda; |  | 43565 | using namespace cv::cuda;
| 43614 |  |  | 43566 |
| 43615 | Stream retval; |  | 43567 | Stream retval;
| 43616 |  |  | 43568 |
| 43617 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43569 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43618 | { |  | 43570 | {
| 43619 | ERRWRAP2(retval = cv::cuda::Stream::Null()); |  | 43571 | ERRWRAP2(retval = cv::cuda::Stream::Null());
| 43620 | return pyopencv_from(retval); |  | 43572 | return pyopencv_from(retval);
| 43621 | } |  | 43573 | }
| 43622 |  |  | 43574 |
| 43623 | return NULL; |  | 43575 | return NULL;
| 43624 | } |  | 43576 | }
| 43625 |  |  | 43577 |
| 43626 | static PyObject* pyopencv_cv_cuda_cuda_Stream_cudaPtr(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43578 | static PyObject* pyopencv_cv_cuda_cuda_Stream_cudaPtr(PyObject* self, PyObject* py_args, PyObject* kw)
| 43627 | { |  | 43579 | {
| 43628 | using namespace cv::cuda; |  | 43580 | using namespace cv::cuda;
| 43629 |  |  | 43581 |
| 43630 |  |  | 43582 |
| 43631 | Ptr<cv::cuda::Stream> * self1 = 0; |  | 43583 | Ptr<cv::cuda::Stream> * self1 = 0;
| 43632 | if (!pyopencv_cuda_Stream_getp(self, self1)) |  | 43584 | if (!pyopencv_cuda_Stream_getp(self, self1))
| 43633 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)"); |  | 43585 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)");
| 43634 | Ptr<cv::cuda::Stream> _self_ = *(self1); |  | 43586 | Ptr<cv::cuda::Stream> _self_ = *(self1);
| 43635 | void* retval; |  | 43587 | void* retval;
| 43636 |  |  | 43588 |
| 43637 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43589 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43638 | { |  | 43590 | {
| 43639 | ERRWRAP2(retval = _self_->cudaPtr()); |  | 43591 | ERRWRAP2(retval = _self_->cudaPtr());
| 43640 | return pyopencv_from(retval); |  | 43592 | return pyopencv_from(retval);
| 43641 | } |  | 43593 | }
| 43642 |  |  | 43594 |
| 43643 | return NULL; |  | 43595 | return NULL;
| 43644 | } |  | 43596 | }
| 43645 |  |  | 43597 |
| 43646 | static PyObject* pyopencv_cv_cuda_cuda_Stream_queryIfComplete(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43598 | static PyObject* pyopencv_cv_cuda_cuda_Stream_queryIfComplete(PyObject* self, PyObject* py_args, PyObject* kw)
| 43647 | { |  | 43599 | {
| 43648 | using namespace cv::cuda; |  | 43600 | using namespace cv::cuda;
| 43649 |  |  | 43601 |
| 43650 |  |  | 43602 |
| 43651 | Ptr<cv::cuda::Stream> * self1 = 0; |  | 43603 | Ptr<cv::cuda::Stream> * self1 = 0;
| 43652 | if (!pyopencv_cuda_Stream_getp(self, self1)) |  | 43604 | if (!pyopencv_cuda_Stream_getp(self, self1))
| 43653 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)"); |  | 43605 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)");
| 43654 | Ptr<cv::cuda::Stream> _self_ = *(self1); |  | 43606 | Ptr<cv::cuda::Stream> _self_ = *(self1);
| 43655 | bool retval; |  | 43607 | bool retval;
| 43656 |  |  | 43608 |
| 43657 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43609 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43658 | { |  | 43610 | {
| 43659 | ERRWRAP2(retval = _self_->queryIfComplete()); |  | 43611 | ERRWRAP2(retval = _self_->queryIfComplete());
| 43660 | return pyopencv_from(retval); |  | 43612 | return pyopencv_from(retval);
| 43661 | } |  | 43613 | }
| 43662 |  |  | 43614 |
| 43663 | return NULL; |  | 43615 | return NULL;
| 43664 | } |  | 43616 | }
| 43665 |  |  | 43617 |
| 43666 | static PyObject* pyopencv_cv_cuda_cuda_Stream_waitEvent(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43618 | static PyObject* pyopencv_cv_cuda_cuda_Stream_waitEvent(PyObject* self, PyObject* py_args, PyObject* kw)
| 43667 | { |  | 43619 | {
| 43668 | using namespace cv::cuda; |  | 43620 | using namespace cv::cuda;
| 43669 |  |  | 43621 |
| 43670 |  |  | 43622 |
| 43671 | Ptr<cv::cuda::Stream> * self1 = 0; |  | 43623 | Ptr<cv::cuda::Stream> * self1 = 0;
| 43672 | if (!pyopencv_cuda_Stream_getp(self, self1)) |  | 43624 | if (!pyopencv_cuda_Stream_getp(self, self1))
| 43673 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)"); |  | 43625 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)");
| 43674 | Ptr<cv::cuda::Stream> _self_ = *(self1); |  | 43626 | Ptr<cv::cuda::Stream> _self_ = *(self1);
| 43675 | PyObject* pyobj_event = NULL; |  | 43627 | PyObject* pyobj_event = NULL;
| 43676 | Event event; |  | 43628 | Event event;
| 43677 |  |  | 43629 |
| 43678 | const char* keywords[] = { "event", NULL }; |  | 43630 | const char* keywords[] = { "event", NULL };
| 43679 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_Stream.waitEvent", (char**)keywords, &pyobj_event) && |  | 43631 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:cuda_Stream.waitEvent", (char**)keywords, &pyobj_event) &&
| 43680 | pyopencv_to_safe(pyobj_event, event, ArgInfo("event", 0)) ) |  | 43632 | pyopencv_to_safe(pyobj_event, event, ArgInfo("event", 0)) )
| 43681 | { |  | 43633 | {
| 43682 | ERRWRAP2(_self_->waitEvent(event)); |  | 43634 | ERRWRAP2(_self_->waitEvent(event));
| 43683 | Py_RETURN_NONE; |  | 43635 | Py_RETURN_NONE;
| 43684 | } |  | 43636 | }
| 43685 |  |  | 43637 |
| 43686 | return NULL; |  | 43638 | return NULL;
| 43687 | } |  | 43639 | }
| 43688 |  |  | 43640 |
| 43689 | static PyObject* pyopencv_cv_cuda_cuda_Stream_waitForCompletion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43641 | static PyObject* pyopencv_cv_cuda_cuda_Stream_waitForCompletion(PyObject* self, PyObject* py_args, PyObject* kw)
| 43690 | { |  | 43642 | {
| 43691 | using namespace cv::cuda; |  | 43643 | using namespace cv::cuda;
| 43692 |  |  | 43644 |
| 43693 |  |  | 43645 |
| 43694 | Ptr<cv::cuda::Stream> * self1 = 0; |  | 43646 | Ptr<cv::cuda::Stream> * self1 = 0;
| 43695 | if (!pyopencv_cuda_Stream_getp(self, self1)) |  | 43647 | if (!pyopencv_cuda_Stream_getp(self, self1))
| 43696 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)"); |  | 43648 | return failmsgp("Incorrect type of self (must be 'cuda_Stream' or its derivative)");
| 43697 | Ptr<cv::cuda::Stream> _self_ = *(self1); |  | 43649 | Ptr<cv::cuda::Stream> _self_ = *(self1);
| 43698 |  |  | 43650 |
| 43699 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43651 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43700 | { |  | 43652 | {
| 43701 | ERRWRAP2(_self_->waitForCompletion()); |  | 43653 | ERRWRAP2(_self_->waitForCompletion());
| 43702 | Py_RETURN_NONE; |  | 43654 | Py_RETURN_NONE;
| 43703 | } |  | 43655 | }
| 43704 |  |  | 43656 |
| 43705 | return NULL; |  | 43657 | return NULL;
| 43706 | } |  | 43658 | }
| 43707 |  |  | 43659 |
| 43708 |  |  | 43660 |
| 43709 |  |  | 43661 |
| 43710 | // Tables (cuda_Stream) |  | 43662 | // Tables (cuda_Stream)
| 43711 |  |  | 43663 |
| 43712 | static PyGetSetDef pyopencv_cuda_Stream_getseters[] = |  | 43664 | static PyGetSetDef pyopencv_cuda_Stream_getseters[] =
| 43713 | { |  | 43665 | {
| 43714 | {NULL} /* Sentinel */ |  | 43666 | {NULL} /* Sentinel */
| 43715 | }; |  | 43667 | };
| 43716 |  |  | 43668 |
| 43717 | static PyMethodDef pyopencv_cuda_Stream_methods[] = |  | 43669 | static PyMethodDef pyopencv_cuda_Stream_methods[] =
| 43718 | { |  | 43670 | {
| 43719 | {"Null", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_Null_static, METH_STATIC), "Null() -> retval\n. @brief Adds a callback to be called on the host after all currently enqueued items in the stream have\n. completed.\n. \n. @note Callbacks must not make any CUDA API calls. Callbacks must not perform any synchronization\n. that may depend on outstanding device work or other callbacks that are not mandated to run earlier.\n. Callbacks without a mandated order (in independent streams) execute in undefined order and may be\n. serialized."}, |  | 43671 | {"Null", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_Null_static, METH_STATIC), "Null() -> retval\n. @brief Adds a callback to be called on the host after all currently enqueued items in the stream have\n. completed.\n. \n. @note Callbacks must not make any CUDA API calls. Callbacks must not perform any synchronization\n. that may depend on outstanding device work or other callbacks that are not mandated to run earlier.\n. Callbacks without a mandated order (in independent streams) execute in undefined order and may be\n. serialized."},
| 43720 | {"cudaPtr", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_cudaPtr, 0), "cudaPtr() -> retval\n."}, |  | 43672 | {"cudaPtr", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_cudaPtr, 0), "cudaPtr() -> retval\n."},
| 43721 | {"queryIfComplete", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_queryIfComplete, 0), "queryIfComplete() -> retval\n. @brief Returns true if the current stream queue is finished. Otherwise, it returns false."}, |  | 43673 | {"queryIfComplete", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_queryIfComplete, 0), "queryIfComplete() -> retval\n. @brief Returns true if the current stream queue is finished. Otherwise, it returns false."},
| 43722 | {"waitEvent", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_waitEvent, 0), "waitEvent(event) -> None\n. @brief Makes a compute stream wait on an event."}, |  | 43674 | {"waitEvent", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_waitEvent, 0), "waitEvent(event) -> None\n. @brief Makes a compute stream wait on an event."},
| 43723 | {"waitForCompletion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_waitForCompletion, 0), "waitForCompletion() -> None\n. @brief Blocks the current CPU thread until all operations in the stream are complete."}, |  | 43675 | {"waitForCompletion", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_Stream_waitForCompletion, 0), "waitForCompletion() -> None\n. @brief Blocks the current CPU thread until all operations in the stream are complete."},
| 43724 |  |  | 43676 |
| 43725 | {NULL, NULL} |  | 43677 | {NULL, NULL}
| 43726 | }; |  | 43678 | };
| 43727 |  |  | 43679 |
| 43728 | // Converter (cuda_Stream) |  | 43680 | // Converter (cuda_Stream)
| 43729 |  |  | 43681 |
| 43730 | template<> |  | 43682 | template<>
| 43731 | struct PyOpenCV_Converter< Ptr<cv::cuda::Stream> > |  | 43683 | struct PyOpenCV_Converter< Ptr<cv::cuda::Stream> >
| 43732 | { |  | 43684 | {
| 43733 | static PyObject* from(const Ptr<cv::cuda::Stream>& r) |  | 43685 | static PyObject* from(const Ptr<cv::cuda::Stream>& r)
| 43734 | { |  | 43686 | {
| 43735 | return pyopencv_cuda_Stream_Instance(r); |  | 43687 | return pyopencv_cuda_Stream_Instance(r);
| 43736 | } |  | 43688 | }
| 43737 | static bool to(PyObject* src, Ptr<cv::cuda::Stream>& dst, const ArgInfo& info) |  | 43689 | static bool to(PyObject* src, Ptr<cv::cuda::Stream>& dst, const ArgInfo& info)
| 43738 | { |  | 43690 | {
| 43739 | if(!src || src == Py_None) |  | 43691 | if(!src || src == Py_None)
| 43740 | return true; |  | 43692 | return true;
| 43741 | Ptr<cv::cuda::Stream> * dst_; |  | 43693 | Ptr<cv::cuda::Stream> * dst_;
| 43742 | if (pyopencv_cuda_Stream_getp(src, dst_)) |  | 43694 | if (pyopencv_cuda_Stream_getp(src, dst_))
| 43743 | { |  | 43695 | {
| 43744 | dst = *dst_; |  | 43696 | dst = *dst_;
| 43745 | return true; |  | 43697 | return true;
| 43746 | } |  | 43698 | }
| 43747 |  |  | 43699 |
| 43748 | failmsg("Expected Ptr<cv::cuda::Stream> for argument '%s'", info.name); |  | 43700 | failmsg("Expected Ptr<cv::cuda::Stream> for argument '%s'", info.name);
| 43749 | return false; |  | 43701 | return false;
| 43750 | } |  | 43702 | }
| 43751 | }; |  | 43703 | };
| 43752 |  |  | 43704 |
| 43753 | //================================================================================ |  | 43705 | //================================================================================
| 43754 | // cuda_TargetArchs (Generic) |  | 43706 | // cuda_TargetArchs (Generic)
| 43755 | //================================================================================ |  | 43707 | //================================================================================
| 43756 |  |  | 43708 |
| 43757 | // GetSet (cuda_TargetArchs) |  | 43709 | // GetSet (cuda_TargetArchs)
| 43758 |  |  | 43710 |
| 43759 |  |  | 43711 |
| 43760 |  |  | 43712 |
| 43761 | // Methods (cuda_TargetArchs) |  | 43713 | // Methods (cuda_TargetArchs)
| 43762 |  |  | 43714 |
| 43763 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_has_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43715 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_has_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43764 | { |  | 43716 | {
| 43765 | using namespace cv::cuda; |  | 43717 | using namespace cv::cuda;
| 43766 |  |  | 43718 |
| 43767 | PyObject* pyobj_major = NULL; |  | 43719 | PyObject* pyobj_major = NULL;
| 43768 | int major=0; |  | 43720 | int major=0;
| 43769 | PyObject* pyobj_minor = NULL; |  | 43721 | PyObject* pyobj_minor = NULL;
| 43770 | int minor=0; |  | 43722 | int minor=0;
| 43771 | bool retval; |  | 43723 | bool retval;
| 43772 |  |  | 43724 |
| 43773 | const char* keywords[] = { "major", "minor", NULL }; |  | 43725 | const char* keywords[] = { "major", "minor", NULL };
| 43774 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.has", (char**)keywords, &pyobj_major, &pyobj_minor) && |  | 43726 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.has", (char**)keywords, &pyobj_major, &pyobj_minor) &&
| 43775 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) && |  | 43727 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) &&
| 43776 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) ) |  | 43728 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) )
| 43777 | { |  | 43729 | {
| 43778 | ERRWRAP2(retval = cv::cuda::TargetArchs::has(major, minor)); |  | 43730 | ERRWRAP2(retval = cv::cuda::TargetArchs::has(major, minor));
| 43779 | return pyopencv_from(retval); |  | 43731 | return pyopencv_from(retval);
| 43780 | } |  | 43732 | }
| 43781 |  |  | 43733 |
| 43782 | return NULL; |  | 43734 | return NULL;
| 43783 | } |  | 43735 | }
| 43784 |  |  | 43736 |
| 43785 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasBin_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43737 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasBin_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43786 | { |  | 43738 | {
| 43787 | using namespace cv::cuda; |  | 43739 | using namespace cv::cuda;
| 43788 |  |  | 43740 |
| 43789 | PyObject* pyobj_major = NULL; |  | 43741 | PyObject* pyobj_major = NULL;
| 43790 | int major=0; |  | 43742 | int major=0;
| 43791 | PyObject* pyobj_minor = NULL; |  | 43743 | PyObject* pyobj_minor = NULL;
| 43792 | int minor=0; |  | 43744 | int minor=0;
| 43793 | bool retval; |  | 43745 | bool retval;
| 43794 |  |  | 43746 |
| 43795 | const char* keywords[] = { "major", "minor", NULL }; |  | 43747 | const char* keywords[] = { "major", "minor", NULL };
| 43796 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasBin", (char**)keywords, &pyobj_major, &pyobj_minor) && |  | 43748 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasBin", (char**)keywords, &pyobj_major, &pyobj_minor) &&
| 43797 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) && |  | 43749 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) &&
| 43798 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) ) |  | 43750 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) )
| 43799 | { |  | 43751 | {
| 43800 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasBin(major, minor)); |  | 43752 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasBin(major, minor));
| 43801 | return pyopencv_from(retval); |  | 43753 | return pyopencv_from(retval);
| 43802 | } |  | 43754 | }
| 43803 |  |  | 43755 |
| 43804 | return NULL; |  | 43756 | return NULL;
| 43805 | } |  | 43757 | }
| 43806 |  |  | 43758 |
| 43807 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreater_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43759 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreater_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43808 | { |  | 43760 | {
| 43809 | using namespace cv::cuda; |  | 43761 | using namespace cv::cuda;
| 43810 |  |  | 43762 |
| 43811 | PyObject* pyobj_major = NULL; |  | 43763 | PyObject* pyobj_major = NULL;
| 43812 | int major=0; |  | 43764 | int major=0;
| 43813 | PyObject* pyobj_minor = NULL; |  | 43765 | PyObject* pyobj_minor = NULL;
| 43814 | int minor=0; |  | 43766 | int minor=0;
| 43815 | bool retval; |  | 43767 | bool retval;
| 43816 |  |  | 43768 |
| 43817 | const char* keywords[] = { "major", "minor", NULL }; |  | 43769 | const char* keywords[] = { "major", "minor", NULL };
| 43818 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrGreater", (char**)keywords, &pyobj_major, &pyobj_minor) && |  | 43770 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrGreater", (char**)keywords, &pyobj_major, &pyobj_minor) &&
| 43819 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) && |  | 43771 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) &&
| 43820 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) ) |  | 43772 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) )
| 43821 | { |  | 43773 | {
| 43822 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrGreater(major, minor)); |  | 43774 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrGreater(major, minor));
| 43823 | return pyopencv_from(retval); |  | 43775 | return pyopencv_from(retval);
| 43824 | } |  | 43776 | }
| 43825 |  |  | 43777 |
| 43826 | return NULL; |  | 43778 | return NULL;
| 43827 | } |  | 43779 | }
| 43828 |  |  | 43780 |
| 43829 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterBin_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43781 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterBin_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43830 | { |  | 43782 | {
| 43831 | using namespace cv::cuda; |  | 43783 | using namespace cv::cuda;
| 43832 |  |  | 43784 |
| 43833 | PyObject* pyobj_major = NULL; |  | 43785 | PyObject* pyobj_major = NULL;
| 43834 | int major=0; |  | 43786 | int major=0;
| 43835 | PyObject* pyobj_minor = NULL; |  | 43787 | PyObject* pyobj_minor = NULL;
| 43836 | int minor=0; |  | 43788 | int minor=0;
| 43837 | bool retval; |  | 43789 | bool retval;
| 43838 |  |  | 43790 |
| 43839 | const char* keywords[] = { "major", "minor", NULL }; |  | 43791 | const char* keywords[] = { "major", "minor", NULL };
| 43840 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrGreaterBin", (char**)keywords, &pyobj_major, &pyobj_minor) && |  | 43792 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrGreaterBin", (char**)keywords, &pyobj_major, &pyobj_minor) &&
| 43841 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) && |  | 43793 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) &&
| 43842 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) ) |  | 43794 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) )
| 43843 | { |  | 43795 | {
| 43844 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrGreaterBin(major, minor)); |  | 43796 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrGreaterBin(major, minor));
| 43845 | return pyopencv_from(retval); |  | 43797 | return pyopencv_from(retval);
| 43846 | } |  | 43798 | }
| 43847 |  |  | 43799 |
| 43848 | return NULL; |  | 43800 | return NULL;
| 43849 | } |  | 43801 | }
| 43850 |  |  | 43802 |
| 43851 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterPtx_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43803 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterPtx_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43852 | { |  | 43804 | {
| 43853 | using namespace cv::cuda; |  | 43805 | using namespace cv::cuda;
| 43854 |  |  | 43806 |
| 43855 | PyObject* pyobj_major = NULL; |  | 43807 | PyObject* pyobj_major = NULL;
| 43856 | int major=0; |  | 43808 | int major=0;
| 43857 | PyObject* pyobj_minor = NULL; |  | 43809 | PyObject* pyobj_minor = NULL;
| 43858 | int minor=0; |  | 43810 | int minor=0;
| 43859 | bool retval; |  | 43811 | bool retval;
| 43860 |  |  | 43812 |
| 43861 | const char* keywords[] = { "major", "minor", NULL }; |  | 43813 | const char* keywords[] = { "major", "minor", NULL };
| 43862 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrGreaterPtx", (char**)keywords, &pyobj_major, &pyobj_minor) && |  | 43814 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrGreaterPtx", (char**)keywords, &pyobj_major, &pyobj_minor) &&
| 43863 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) && |  | 43815 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) &&
| 43864 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) ) |  | 43816 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) )
| 43865 | { |  | 43817 | {
| 43866 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrGreaterPtx(major, minor)); |  | 43818 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrGreaterPtx(major, minor));
| 43867 | return pyopencv_from(retval); |  | 43819 | return pyopencv_from(retval);
| 43868 | } |  | 43820 | }
| 43869 |  |  | 43821 |
| 43870 | return NULL; |  | 43822 | return NULL;
| 43871 | } |  | 43823 | }
| 43872 |  |  | 43824 |
| 43873 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrLessPtx_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43825 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrLessPtx_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43874 | { |  | 43826 | {
| 43875 | using namespace cv::cuda; |  | 43827 | using namespace cv::cuda;
| 43876 |  |  | 43828 |
| 43877 | PyObject* pyobj_major = NULL; |  | 43829 | PyObject* pyobj_major = NULL;
| 43878 | int major=0; |  | 43830 | int major=0;
| 43879 | PyObject* pyobj_minor = NULL; |  | 43831 | PyObject* pyobj_minor = NULL;
| 43880 | int minor=0; |  | 43832 | int minor=0;
| 43881 | bool retval; |  | 43833 | bool retval;
| 43882 |  |  | 43834 |
| 43883 | const char* keywords[] = { "major", "minor", NULL }; |  | 43835 | const char* keywords[] = { "major", "minor", NULL };
| 43884 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrLessPtx", (char**)keywords, &pyobj_major, &pyobj_minor) && |  | 43836 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasEqualOrLessPtx", (char**)keywords, &pyobj_major, &pyobj_minor) &&
| 43885 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) && |  | 43837 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) &&
| 43886 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) ) |  | 43838 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) )
| 43887 | { |  | 43839 | {
| 43888 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrLessPtx(major, minor)); |  | 43840 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasEqualOrLessPtx(major, minor));
| 43889 | return pyopencv_from(retval); |  | 43841 | return pyopencv_from(retval);
| 43890 | } |  | 43842 | }
| 43891 |  |  | 43843 |
| 43892 | return NULL; |  | 43844 | return NULL;
| 43893 | } |  | 43845 | }
| 43894 |  |  | 43846 |
| 43895 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasPtx_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 43847 | static PyObject* pyopencv_cv_cuda_cuda_TargetArchs_hasPtx_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 43896 | { |  | 43848 | {
| 43897 | using namespace cv::cuda; |  | 43849 | using namespace cv::cuda;
| 43898 |  |  | 43850 |
| 43899 | PyObject* pyobj_major = NULL; |  | 43851 | PyObject* pyobj_major = NULL;
| 43900 | int major=0; |  | 43852 | int major=0;
| 43901 | PyObject* pyobj_minor = NULL; |  | 43853 | PyObject* pyobj_minor = NULL;
| 43902 | int minor=0; |  | 43854 | int minor=0;
| 43903 | bool retval; |  | 43855 | bool retval;
| 43904 |  |  | 43856 |
| 43905 | const char* keywords[] = { "major", "minor", NULL }; |  | 43857 | const char* keywords[] = { "major", "minor", NULL };
| 43906 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasPtx", (char**)keywords, &pyobj_major, &pyobj_minor) && |  | 43858 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:cuda_TargetArchs.hasPtx", (char**)keywords, &pyobj_major, &pyobj_minor) &&
| 43907 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) && |  | 43859 | pyopencv_to_safe(pyobj_major, major, ArgInfo("major", 0)) &&
| 43908 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) ) |  | 43860 | pyopencv_to_safe(pyobj_minor, minor, ArgInfo("minor", 0)) )
| 43909 | { |  | 43861 | {
| 43910 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasPtx(major, minor)); |  | 43862 | ERRWRAP2(retval = cv::cuda::TargetArchs::hasPtx(major, minor));
| 43911 | return pyopencv_from(retval); |  | 43863 | return pyopencv_from(retval);
| 43912 | } |  | 43864 | }
| 43913 |  |  | 43865 |
| 43914 | return NULL; |  | 43866 | return NULL;
| 43915 | } |  | 43867 | }
| 43916 |  |  | 43868 |
| 43917 |  |  | 43869 |
| 43918 |  |  | 43870 |
| 43919 | // Tables (cuda_TargetArchs) |  | 43871 | // Tables (cuda_TargetArchs)
| 43920 |  |  | 43872 |
| 43921 | static PyGetSetDef pyopencv_cuda_TargetArchs_getseters[] = |  | 43873 | static PyGetSetDef pyopencv_cuda_TargetArchs_getseters[] =
| 43922 | { |  | 43874 | {
| 43923 | {NULL} /* Sentinel */ |  | 43875 | {NULL} /* Sentinel */
| 43924 | }; |  | 43876 | };
| 43925 |  |  | 43877 |
| 43926 | static PyMethodDef pyopencv_cuda_TargetArchs_methods[] = |  | 43878 | static PyMethodDef pyopencv_cuda_TargetArchs_methods[] =
| 43927 | { |  | 43879 | {
| 43928 | {"has", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_has_static, METH_STATIC), "has(major, minor) -> retval\n. @brief There is a set of methods to check whether the module contains intermediate (PTX) or binary CUDA\n. code for the given architecture(s):\n. \n. @param major Major compute capability version.\n. @param minor Minor compute capability version."}, |  | 43880 | {"has", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_has_static, METH_STATIC), "has(major, minor) -> retval\n. @brief There is a set of methods to check whether the module contains intermediate (PTX) or binary CUDA\n. code for the given architecture(s):\n. \n. @param major Major compute capability version.\n. @param minor Minor compute capability version."},
| 43929 | {"hasBin", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasBin_static, METH_STATIC), "hasBin(major, minor) -> retval\n."}, |  | 43881 | {"hasBin", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasBin_static, METH_STATIC), "hasBin(major, minor) -> retval\n."},
| 43930 | {"hasEqualOrGreater", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreater_static, METH_STATIC), "hasEqualOrGreater(major, minor) -> retval\n."}, |  | 43882 | {"hasEqualOrGreater", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreater_static, METH_STATIC), "hasEqualOrGreater(major, minor) -> retval\n."},
| 43931 | {"hasEqualOrGreaterBin", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterBin_static, METH_STATIC), "hasEqualOrGreaterBin(major, minor) -> retval\n."}, |  | 43883 | {"hasEqualOrGreaterBin", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterBin_static, METH_STATIC), "hasEqualOrGreaterBin(major, minor) -> retval\n."},
| 43932 | {"hasEqualOrGreaterPtx", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterPtx_static, METH_STATIC), "hasEqualOrGreaterPtx(major, minor) -> retval\n."}, |  | 43884 | {"hasEqualOrGreaterPtx", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrGreaterPtx_static, METH_STATIC), "hasEqualOrGreaterPtx(major, minor) -> retval\n."},
| 43933 | {"hasEqualOrLessPtx", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrLessPtx_static, METH_STATIC), "hasEqualOrLessPtx(major, minor) -> retval\n."}, |  | 43885 | {"hasEqualOrLessPtx", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasEqualOrLessPtx_static, METH_STATIC), "hasEqualOrLessPtx(major, minor) -> retval\n."},
| 43934 | {"hasPtx", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasPtx_static, METH_STATIC), "hasPtx(major, minor) -> retval\n."}, |  | 43886 | {"hasPtx", CV_PY_FN_WITH_KW_(pyopencv_cv_cuda_cuda_TargetArchs_hasPtx_static, METH_STATIC), "hasPtx(major, minor) -> retval\n."},
| 43935 |  |  | 43887 |
| 43936 | {NULL, NULL} |  | 43888 | {NULL, NULL}
| 43937 | }; |  | 43889 | };
| 43938 |  |  | 43890 |
| 43939 | // Converter (cuda_TargetArchs) |  | 43891 | // Converter (cuda_TargetArchs)
| 43940 |  |  | 43892 |
| 43941 | template<> |  | 43893 | template<>
| 43942 | struct PyOpenCV_Converter< Ptr<cv::cuda::TargetArchs> > |  | 43894 | struct PyOpenCV_Converter< Ptr<cv::cuda::TargetArchs> >
| 43943 | { |  | 43895 | {
| 43944 | static PyObject* from(const Ptr<cv::cuda::TargetArchs>& r) |  | 43896 | static PyObject* from(const Ptr<cv::cuda::TargetArchs>& r)
| 43945 | { |  | 43897 | {
| 43946 | return pyopencv_cuda_TargetArchs_Instance(r); |  | 43898 | return pyopencv_cuda_TargetArchs_Instance(r);
| 43947 | } |  | 43899 | }
| 43948 | static bool to(PyObject* src, Ptr<cv::cuda::TargetArchs>& dst, const ArgInfo& info) |  | 43900 | static bool to(PyObject* src, Ptr<cv::cuda::TargetArchs>& dst, const ArgInfo& info)
| 43949 | { |  | 43901 | {
| 43950 | if(!src || src == Py_None) |  | 43902 | if(!src || src == Py_None)
| 43951 | return true; |  | 43903 | return true;
| 43952 | Ptr<cv::cuda::TargetArchs> * dst_; |  | 43904 | Ptr<cv::cuda::TargetArchs> * dst_;
| 43953 | if (pyopencv_cuda_TargetArchs_getp(src, dst_)) |  | 43905 | if (pyopencv_cuda_TargetArchs_getp(src, dst_))
| 43954 | { |  | 43906 | {
| 43955 | dst = *dst_; |  | 43907 | dst = *dst_;
| 43956 | return true; |  | 43908 | return true;
| 43957 | } |  | 43909 | }
| 43958 |  |  | 43910 |
| 43959 | failmsg("Expected Ptr<cv::cuda::TargetArchs> for argument '%s'", info.name); |  | 43911 | failmsg("Expected Ptr<cv::cuda::TargetArchs> for argument '%s'", info.name);
| 43960 | return false; |  | 43912 | return false;
| 43961 | } |  | 43913 | }
| 43962 | }; |  | 43914 | };
| 43963 |  |  | 43915 |
| 43964 | //================================================================================ |  | 43916 | //================================================================================
| 43965 | // detail_AffineBasedEstimator (Generic) |  | 43917 | // detail_AffineBasedEstimator (Generic)
| 43966 | //================================================================================ |  | 43918 | //================================================================================
| 43967 |  |  | 43919 |
| 43968 | // GetSet (detail_AffineBasedEstimator) |  | 43920 | // GetSet (detail_AffineBasedEstimator)
| 43969 |  |  | 43921 |
| 43970 |  |  | 43922 |
| 43971 |  |  | 43923 |
| 43972 | // Methods (detail_AffineBasedEstimator) |  | 43924 | // Methods (detail_AffineBasedEstimator)
| 43973 |  |  | 43925 |
| 43974 | static int pyopencv_cv_detail_detail_AffineBasedEstimator_AffineBasedEstimator(pyopencv_detail_AffineBasedEstimator_t* self, PyObject* py_args, PyObject* kw) |  | 43926 | static int pyopencv_cv_detail_detail_AffineBasedEstimator_AffineBasedEstimator(pyopencv_detail_AffineBasedEstimator_t* self, PyObject* py_args, PyObject* kw)
| 43975 | { |  | 43927 | {
| 43976 | using namespace cv::detail; |  | 43928 | using namespace cv::detail;
| 43977 |  |  | 43929 |
| 43978 |  |  | 43930 |
| 43979 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 43931 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 43980 | { |  | 43932 | {
| 43981 | new (&(self->v)) Ptr<cv::detail::AffineBasedEstimator>(); // init Ptr with placement new |  | 43933 | new (&(self->v)) Ptr<cv::detail::AffineBasedEstimator>(); // init Ptr with placement new
| 43982 | if(self) ERRWRAP2(self->v.reset(new cv::detail::AffineBasedEstimator())); |  | 43934 | if(self) ERRWRAP2(self->v.reset(new cv::detail::AffineBasedEstimator()));
| 43983 | return 0; |  | 43935 | return 0;
| 43984 | } |  | 43936 | }
| 43985 |  |  | 43937 |
| 43986 | return -1; |  | 43938 | return -1;
| 43987 | } |  | 43939 | }
| 43988 |  |  | 43940 |
| 43989 |  |  | 43941 |
| 43990 |  |  | 43942 |
| 43991 | // Tables (detail_AffineBasedEstimator) |  | 43943 | // Tables (detail_AffineBasedEstimator)
| 43992 |  |  | 43944 |
| 43993 | static PyGetSetDef pyopencv_detail_AffineBasedEstimator_getseters[] = |  | 43945 | static PyGetSetDef pyopencv_detail_AffineBasedEstimator_getseters[] =
| 43994 | { |  | 43946 | {
| 43995 | {NULL} /* Sentinel */ |  | 43947 | {NULL} /* Sentinel */
| 43996 | }; |  | 43948 | };
| 43997 |  |  | 43949 |
| 43998 | static PyMethodDef pyopencv_detail_AffineBasedEstimator_methods[] = |  | 43950 | static PyMethodDef pyopencv_detail_AffineBasedEstimator_methods[] =
| 43999 | { |  | 43951 | {
| 44000 |  |  | 43952 |
| 44001 | {NULL, NULL} |  | 43953 | {NULL, NULL}
| 44002 | }; |  | 43954 | };
| 44003 |  |  | 43955 |
| 44004 | // Converter (detail_AffineBasedEstimator) |  | 43956 | // Converter (detail_AffineBasedEstimator)
| 44005 |  |  | 43957 |
| 44006 | template<> |  | 43958 | template<>
| 44007 | struct PyOpenCV_Converter< Ptr<cv::detail::AffineBasedEstimator> > |  | 43959 | struct PyOpenCV_Converter< Ptr<cv::detail::AffineBasedEstimator> >
| 44008 | { |  | 43960 | {
| 44009 | static PyObject* from(const Ptr<cv::detail::AffineBasedEstimator>& r) |  | 43961 | static PyObject* from(const Ptr<cv::detail::AffineBasedEstimator>& r)
| 44010 | { |  | 43962 | {
| 44011 | return pyopencv_detail_AffineBasedEstimator_Instance(r); |  | 43963 | return pyopencv_detail_AffineBasedEstimator_Instance(r);
| 44012 | } |  | 43964 | }
| 44013 | static bool to(PyObject* src, Ptr<cv::detail::AffineBasedEstimator>& dst, const ArgInfo& info) |  | 43965 | static bool to(PyObject* src, Ptr<cv::detail::AffineBasedEstimator>& dst, const ArgInfo& info)
| 44014 | { |  | 43966 | {
| 44015 | if(!src || src == Py_None) |  | 43967 | if(!src || src == Py_None)
| 44016 | return true; |  | 43968 | return true;
| 44017 | Ptr<cv::detail::AffineBasedEstimator> * dst_; |  | 43969 | Ptr<cv::detail::AffineBasedEstimator> * dst_;
| 44018 | if (pyopencv_detail_AffineBasedEstimator_getp(src, dst_)) |  | 43970 | if (pyopencv_detail_AffineBasedEstimator_getp(src, dst_))
| 44019 | { |  | 43971 | {
| 44020 | dst = *dst_; |  | 43972 | dst = *dst_;
| 44021 | return true; |  | 43973 | return true;
| 44022 | } |  | 43974 | }
| 44023 |  |  | 43975 |
| 44024 | failmsg("Expected Ptr<cv::detail::AffineBasedEstimator> for argument '%s'", info.name); |  | 43976 | failmsg("Expected Ptr<cv::detail::AffineBasedEstimator> for argument '%s'", info.name);
| 44025 | return false; |  | 43977 | return false;
| 44026 | } |  | 43978 | }
| 44027 | }; |  | 43979 | };
| 44028 |  |  | 43980 |
| 44029 | //================================================================================ |  | 43981 | //================================================================================
| 44030 | // detail_AffineBestOf2NearestMatcher (Generic) |  | 43982 | // detail_AffineBestOf2NearestMatcher (Generic)
| 44031 | //================================================================================ |  | 43983 | //================================================================================
| 44032 |  |  | 43984 |
| 44033 | // GetSet (detail_AffineBestOf2NearestMatcher) |  | 43985 | // GetSet (detail_AffineBestOf2NearestMatcher)
| 44034 |  |  | 43986 |
| 44035 |  |  | 43987 |
| 44036 |  |  | 43988 |
| 44037 | // Methods (detail_AffineBestOf2NearestMatcher) |  | 43989 | // Methods (detail_AffineBestOf2NearestMatcher)
| 44038 |  |  | 43990 |
| 44039 | static int pyopencv_cv_detail_detail_AffineBestOf2NearestMatcher_AffineBestOf2NearestMatcher(pyopencv_detail_AffineBestOf2NearestMatcher_t* self, PyObject* py_args, PyObject* kw) |  | 43991 | static int pyopencv_cv_detail_detail_AffineBestOf2NearestMatcher_AffineBestOf2NearestMatcher(pyopencv_detail_AffineBestOf2NearestMatcher_t* self, PyObject* py_args, PyObject* kw)
| 44040 | { |  | 43992 | {
| 44041 | using namespace cv::detail; |  | 43993 | using namespace cv::detail;
| 44042 |  |  | 43994 |
| 44043 | PyObject* pyobj_full_affine = NULL; |  | 43995 | PyObject* pyobj_full_affine = NULL;
| 44044 | bool full_affine=false; |  | 43996 | bool full_affine=false;
| 44045 | PyObject* pyobj_try_use_gpu = NULL; |  | 43997 | PyObject* pyobj_try_use_gpu = NULL;
| 44046 | bool try_use_gpu=false; |  | 43998 | bool try_use_gpu=false;
| 44047 | PyObject* pyobj_match_conf = NULL; |  | 43999 | PyObject* pyobj_match_conf = NULL;
| 44048 | float match_conf=0.3f; |  | 44000 | float match_conf=0.3f;
| 44049 | PyObject* pyobj_num_matches_thresh1 = NULL; |  | 44001 | PyObject* pyobj_num_matches_thresh1 = NULL;
| 44050 | int num_matches_thresh1=6; |  | 44002 | int num_matches_thresh1=6;
| 44051 |  |  | 44003 |
| 44052 | const char* keywords[] = { "full_affine", "try_use_gpu", "match_conf", "num_matches_thresh1", NULL }; |  | 44004 | const char* keywords[] = { "full_affine", "try_use_gpu", "match_conf", "num_matches_thresh1", NULL };
| 44053 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOO:AffineBestOf2NearestMatcher", (char**)keywords, &pyobj_full_affine, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1) && |  | 44005 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOO:AffineBestOf2NearestMatcher", (char**)keywords, &pyobj_full_affine, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1) &&
| 44054 | pyopencv_to_safe(pyobj_full_affine, full_affine, ArgInfo("full_affine", 0)) && |  | 44006 | pyopencv_to_safe(pyobj_full_affine, full_affine, ArgInfo("full_affine", 0)) &&
| 44055 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) && |  | 44007 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) &&
| 44056 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) && |  | 44008 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) &&
| 44057 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) ) |  | 44009 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) )
| 44058 | { |  | 44010 | {
| 44059 | new (&(self->v)) Ptr<cv::detail::AffineBestOf2NearestMatcher>(); // init Ptr with placement new |  | 44011 | new (&(self->v)) Ptr<cv::detail::AffineBestOf2NearestMatcher>(); // init Ptr with placement new
| 44060 | if(self) ERRWRAP2(self->v.reset(new cv::detail::AffineBestOf2NearestMatcher(full_affine, try_use_gpu, match_conf, num_matches_thresh1))); |  | 44012 | if(self) ERRWRAP2(self->v.reset(new cv::detail::AffineBestOf2NearestMatcher(full_affine, try_use_gpu, match_conf, num_matches_thresh1)));
| 44061 | return 0; |  | 44013 | return 0;
| 44062 | } |  | 44014 | }
| 44063 |  |  | 44015 |
| 44064 | return -1; |  | 44016 | return -1;
| 44065 | } |  | 44017 | }
| 44066 |  |  | 44018 |
| 44067 |  |  | 44019 |
| 44068 |  |  | 44020 |
| 44069 | // Tables (detail_AffineBestOf2NearestMatcher) |  | 44021 | // Tables (detail_AffineBestOf2NearestMatcher)
| 44070 |  |  | 44022 |
| 44071 | static PyGetSetDef pyopencv_detail_AffineBestOf2NearestMatcher_getseters[] = |  | 44023 | static PyGetSetDef pyopencv_detail_AffineBestOf2NearestMatcher_getseters[] =
| 44072 | { |  | 44024 | {
| 44073 | {NULL} /* Sentinel */ |  | 44025 | {NULL} /* Sentinel */
| 44074 | }; |  | 44026 | };
| 44075 |  |  | 44027 |
| 44076 | static PyMethodDef pyopencv_detail_AffineBestOf2NearestMatcher_methods[] = |  | 44028 | static PyMethodDef pyopencv_detail_AffineBestOf2NearestMatcher_methods[] =
| 44077 | { |  | 44029 | {
| 44078 |  |  | 44030 |
| 44079 | {NULL, NULL} |  | 44031 | {NULL, NULL}
| 44080 | }; |  | 44032 | };
| 44081 |  |  | 44033 |
| 44082 | // Converter (detail_AffineBestOf2NearestMatcher) |  | 44034 | // Converter (detail_AffineBestOf2NearestMatcher)
| 44083 |  |  | 44035 |
| 44084 | template<> |  | 44036 | template<>
| 44085 | struct PyOpenCV_Converter< Ptr<cv::detail::AffineBestOf2NearestMatcher> > |  | 44037 | struct PyOpenCV_Converter< Ptr<cv::detail::AffineBestOf2NearestMatcher> >
| 44086 | { |  | 44038 | {
| 44087 | static PyObject* from(const Ptr<cv::detail::AffineBestOf2NearestMatcher>& r) |  | 44039 | static PyObject* from(const Ptr<cv::detail::AffineBestOf2NearestMatcher>& r)
| 44088 | { |  | 44040 | {
| 44089 | return pyopencv_detail_AffineBestOf2NearestMatcher_Instance(r); |  | 44041 | return pyopencv_detail_AffineBestOf2NearestMatcher_Instance(r);
| 44090 | } |  | 44042 | }
| 44091 | static bool to(PyObject* src, Ptr<cv::detail::AffineBestOf2NearestMatcher>& dst, const ArgInfo& info) |  | 44043 | static bool to(PyObject* src, Ptr<cv::detail::AffineBestOf2NearestMatcher>& dst, const ArgInfo& info)
| 44092 | { |  | 44044 | {
| 44093 | if(!src || src == Py_None) |  | 44045 | if(!src || src == Py_None)
| 44094 | return true; |  | 44046 | return true;
| 44095 | Ptr<cv::detail::AffineBestOf2NearestMatcher> * dst_; |  | 44047 | Ptr<cv::detail::AffineBestOf2NearestMatcher> * dst_;
| 44096 | if (pyopencv_detail_AffineBestOf2NearestMatcher_getp(src, dst_)) |  | 44048 | if (pyopencv_detail_AffineBestOf2NearestMatcher_getp(src, dst_))
| 44097 | { |  | 44049 | {
| 44098 | dst = *dst_; |  | 44050 | dst = *dst_;
| 44099 | return true; |  | 44051 | return true;
| 44100 | } |  | 44052 | }
| 44101 |  |  | 44053 |
| 44102 | failmsg("Expected Ptr<cv::detail::AffineBestOf2NearestMatcher> for argument '%s'", info.name); |  | 44054 | failmsg("Expected Ptr<cv::detail::AffineBestOf2NearestMatcher> for argument '%s'", info.name);
| 44103 | return false; |  | 44055 | return false;
| 44104 | } |  | 44056 | }
| 44105 | }; |  | 44057 | };
| 44106 |  |  | 44058 |
| 44107 | //================================================================================ |  | 44059 | //================================================================================
| 44108 | // detail_BestOf2NearestMatcher (Generic) |  | 44060 | // detail_BestOf2NearestMatcher (Generic)
| 44109 | //================================================================================ |  | 44061 | //================================================================================
| 44110 |  |  | 44062 |
| 44111 | // GetSet (detail_BestOf2NearestMatcher) |  | 44063 | // GetSet (detail_BestOf2NearestMatcher)
| 44112 |  |  | 44064 |
| 44113 |  |  | 44065 |
| 44114 |  |  | 44066 |
| 44115 | // Methods (detail_BestOf2NearestMatcher) |  | 44067 | // Methods (detail_BestOf2NearestMatcher)
| 44116 |  |  | 44068 |
| 44117 | static int pyopencv_cv_detail_detail_BestOf2NearestMatcher_BestOf2NearestMatcher(pyopencv_detail_BestOf2NearestMatcher_t* self, PyObject* py_args, PyObject* kw) |  | 44069 | static int pyopencv_cv_detail_detail_BestOf2NearestMatcher_BestOf2NearestMatcher(pyopencv_detail_BestOf2NearestMatcher_t* self, PyObject* py_args, PyObject* kw)
| 44118 | { |  | 44070 | {
| 44119 | using namespace cv::detail; |  | 44071 | using namespace cv::detail;
| 44120 |  |  | 44072 |
| 44121 | PyObject* pyobj_try_use_gpu = NULL; |  | 44073 | PyObject* pyobj_try_use_gpu = NULL;
| 44122 | bool try_use_gpu=false; |  | 44074 | bool try_use_gpu=false;
| 44123 | PyObject* pyobj_match_conf = NULL; |  | 44075 | PyObject* pyobj_match_conf = NULL;
| 44124 | float match_conf=0.3f; |  | 44076 | float match_conf=0.3f;
| 44125 | PyObject* pyobj_num_matches_thresh1 = NULL; |  | 44077 | PyObject* pyobj_num_matches_thresh1 = NULL;
| 44126 | int num_matches_thresh1=6; |  | 44078 | int num_matches_thresh1=6;
| 44127 | PyObject* pyobj_num_matches_thresh2 = NULL; |  | 44079 | PyObject* pyobj_num_matches_thresh2 = NULL;
| 44128 | int num_matches_thresh2=6; |  | 44080 | int num_matches_thresh2=6;
| 44129 | PyObject* pyobj_matches_confindece_thresh = NULL; |  | 44081 | PyObject* pyobj_matches_confindece_thresh = NULL;
| 44130 | double matches_confindece_thresh=3.; |  | 44082 | double matches_confindece_thresh=3.;
| 44131 |  |  | 44083 |
| 44132 | const char* keywords[] = { "try_use_gpu", "match_conf", "num_matches_thresh1", "num_matches_thresh2", "matches_confindece_thresh", NULL }; |  | 44084 | const char* keywords[] = { "try_use_gpu", "match_conf", "num_matches_thresh1", "num_matches_thresh2", "matches_confindece_thresh", NULL };
| 44133 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:BestOf2NearestMatcher", (char**)keywords, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1, &pyobj_num_matches_thresh2, &pyobj_matches_confindece_thresh) && |  | 44085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:BestOf2NearestMatcher", (char**)keywords, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1, &pyobj_num_matches_thresh2, &pyobj_matches_confindece_thresh) &&
| 44134 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) && |  | 44086 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) &&
| 44135 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) && |  | 44087 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) &&
| 44136 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) && |  | 44088 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) &&
| 44137 | pyopencv_to_safe(pyobj_num_matches_thresh2, num_matches_thresh2, ArgInfo("num_matches_thresh2", 0)) && |  | 44089 | pyopencv_to_safe(pyobj_num_matches_thresh2, num_matches_thresh2, ArgInfo("num_matches_thresh2", 0)) &&
| 44138 | pyopencv_to_safe(pyobj_matches_confindece_thresh, matches_confindece_thresh, ArgInfo("matches_confindece_thresh", 0)) ) |  | 44090 | pyopencv_to_safe(pyobj_matches_confindece_thresh, matches_confindece_thresh, ArgInfo("matches_confindece_thresh", 0)) )
| 44139 | { |  | 44091 | {
| 44140 | new (&(self->v)) Ptr<cv::detail::BestOf2NearestMatcher>(); // init Ptr with placement new |  | 44092 | new (&(self->v)) Ptr<cv::detail::BestOf2NearestMatcher>(); // init Ptr with placement new
| 44141 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BestOf2NearestMatcher(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2, matches_confindece_thresh))); |  | 44093 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BestOf2NearestMatcher(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2, matches_confindece_thresh)));
| 44142 | return 0; |  | 44094 | return 0;
| 44143 | } |  | 44095 | }
| 44144 |  |  | 44096 |
| 44145 | return -1; |  | 44097 | return -1;
| 44146 | } |  | 44098 | }
| 44147 |  |  | 44099 |
| 44148 | static PyObject* pyopencv_cv_detail_detail_BestOf2NearestMatcher_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44100 | static PyObject* pyopencv_cv_detail_detail_BestOf2NearestMatcher_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw)
| 44149 | { |  | 44101 | {
| 44150 | using namespace cv::detail; |  | 44102 | using namespace cv::detail;
| 44151 |  |  | 44103 |
| 44152 |  |  | 44104 |
| 44153 | Ptr<cv::detail::BestOf2NearestMatcher> * self1 = 0; |  | 44105 | Ptr<cv::detail::BestOf2NearestMatcher> * self1 = 0;
| 44154 | if (!pyopencv_detail_BestOf2NearestMatcher_getp(self, self1)) |  | 44106 | if (!pyopencv_detail_BestOf2NearestMatcher_getp(self, self1))
| 44155 | return failmsgp("Incorrect type of self (must be 'detail_BestOf2NearestMatcher' or its derivative)"); |  | 44107 | return failmsgp("Incorrect type of self (must be 'detail_BestOf2NearestMatcher' or its derivative)");
| 44156 | Ptr<cv::detail::BestOf2NearestMatcher> _self_ = *(self1); |  | 44108 | Ptr<cv::detail::BestOf2NearestMatcher> _self_ = *(self1);
| 44157 |  |  | 44109 |
| 44158 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 44110 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 44159 | { |  | 44111 | {
| 44160 | ERRWRAP2(_self_->collectGarbage()); |  | 44112 | ERRWRAP2(_self_->collectGarbage());
| 44161 | Py_RETURN_NONE; |  | 44113 | Py_RETURN_NONE;
| 44162 | } |  | 44114 | }
| 44163 |  |  | 44115 |
| 44164 | return NULL; |  | 44116 | return NULL;
| 44165 | } |  | 44117 | }
| 44166 |  |  | 44118 |
| 44167 | static PyObject* pyopencv_cv_detail_detail_BestOf2NearestMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44119 | static PyObject* pyopencv_cv_detail_detail_BestOf2NearestMatcher_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 44168 | { |  | 44120 | {
| 44169 | using namespace cv::detail; |  | 44121 | using namespace cv::detail;
| 44170 |  |  | 44122 |
| 44171 | PyObject* pyobj_try_use_gpu = NULL; |  | 44123 | PyObject* pyobj_try_use_gpu = NULL;
| 44172 | bool try_use_gpu=false; |  | 44124 | bool try_use_gpu=false;
| 44173 | PyObject* pyobj_match_conf = NULL; |  | 44125 | PyObject* pyobj_match_conf = NULL;
| 44174 | float match_conf=0.3f; |  | 44126 | float match_conf=0.3f;
| 44175 | PyObject* pyobj_num_matches_thresh1 = NULL; |  | 44127 | PyObject* pyobj_num_matches_thresh1 = NULL;
| 44176 | int num_matches_thresh1=6; |  | 44128 | int num_matches_thresh1=6;
| 44177 | PyObject* pyobj_num_matches_thresh2 = NULL; |  | 44129 | PyObject* pyobj_num_matches_thresh2 = NULL;
| 44178 | int num_matches_thresh2=6; |  | 44130 | int num_matches_thresh2=6;
| 44179 | PyObject* pyobj_matches_confindece_thresh = NULL; |  | 44131 | PyObject* pyobj_matches_confindece_thresh = NULL;
| 44180 | double matches_confindece_thresh=3.; |  | 44132 | double matches_confindece_thresh=3.;
| 44181 | Ptr<BestOf2NearestMatcher> retval; |  | 44133 | Ptr<BestOf2NearestMatcher> retval;
| 44182 |  |  | 44134 |
| 44183 | const char* keywords[] = { "try_use_gpu", "match_conf", "num_matches_thresh1", "num_matches_thresh2", "matches_confindece_thresh", NULL }; |  | 44135 | const char* keywords[] = { "try_use_gpu", "match_conf", "num_matches_thresh1", "num_matches_thresh2", "matches_confindece_thresh", NULL };
| 44184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:detail_BestOf2NearestMatcher.create", (char**)keywords, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1, &pyobj_num_matches_thresh2, &pyobj_matches_confindece_thresh) && |  | 44136 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:detail_BestOf2NearestMatcher.create", (char**)keywords, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1, &pyobj_num_matches_thresh2, &pyobj_matches_confindece_thresh) &&
| 44185 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) && |  | 44137 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) &&
| 44186 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) && |  | 44138 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) &&
| 44187 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) && |  | 44139 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) &&
| 44188 | pyopencv_to_safe(pyobj_num_matches_thresh2, num_matches_thresh2, ArgInfo("num_matches_thresh2", 0)) && |  | 44140 | pyopencv_to_safe(pyobj_num_matches_thresh2, num_matches_thresh2, ArgInfo("num_matches_thresh2", 0)) &&
| 44189 | pyopencv_to_safe(pyobj_matches_confindece_thresh, matches_confindece_thresh, ArgInfo("matches_confindece_thresh", 0)) ) |  | 44141 | pyopencv_to_safe(pyobj_matches_confindece_thresh, matches_confindece_thresh, ArgInfo("matches_confindece_thresh", 0)) )
| 44190 | { |  | 44142 | {
| 44191 | ERRWRAP2(retval = cv::detail::BestOf2NearestMatcher::create(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2, matches_confindece_thresh)); |  | 44143 | ERRWRAP2(retval = cv::detail::BestOf2NearestMatcher::create(try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2, matches_confindece_thresh));
| 44192 | return pyopencv_from(retval); |  | 44144 | return pyopencv_from(retval);
| 44193 | } |  | 44145 | }
| 44194 |  |  | 44146 |
| 44195 | return NULL; |  | 44147 | return NULL;
| 44196 | } |  | 44148 | }
| 44197 |  |  | 44149 |
| 44198 |  |  | 44150 |
| 44199 |  |  | 44151 |
| 44200 | // Tables (detail_BestOf2NearestMatcher) |  | 44152 | // Tables (detail_BestOf2NearestMatcher)
| 44201 |  |  | 44153 |
| 44202 | static PyGetSetDef pyopencv_detail_BestOf2NearestMatcher_getseters[] = |  | 44154 | static PyGetSetDef pyopencv_detail_BestOf2NearestMatcher_getseters[] =
| 44203 | { |  | 44155 | {
| 44204 | {NULL} /* Sentinel */ |  | 44156 | {NULL} /* Sentinel */
| 44205 | }; |  | 44157 | };
| 44206 |  |  | 44158 |
| 44207 | static PyMethodDef pyopencv_detail_BestOf2NearestMatcher_methods[] = |  | 44159 | static PyMethodDef pyopencv_detail_BestOf2NearestMatcher_methods[] =
| 44208 | { |  | 44160 | {
| 44209 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BestOf2NearestMatcher_collectGarbage, 0), "collectGarbage() -> None\n."}, |  | 44161 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BestOf2NearestMatcher_collectGarbage, 0), "collectGarbage() -> None\n."},
| 44210 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BestOf2NearestMatcher_create_static, METH_STATIC), "create([, try_use_gpu[, match_conf[, num_matches_thresh1[, num_matches_thresh2[, matches_confindece_thresh]]]]]) -> retval\n."}, |  | 44162 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BestOf2NearestMatcher_create_static, METH_STATIC), "create([, try_use_gpu[, match_conf[, num_matches_thresh1[, num_matches_thresh2[, matches_confindece_thresh]]]]]) -> retval\n."},
| 44211 |  |  | 44163 |
| 44212 | {NULL, NULL} |  | 44164 | {NULL, NULL}
| 44213 | }; |  | 44165 | };
| 44214 |  |  | 44166 |
| 44215 | // Converter (detail_BestOf2NearestMatcher) |  | 44167 | // Converter (detail_BestOf2NearestMatcher)
| 44216 |  |  | 44168 |
| 44217 | template<> |  | 44169 | template<>
| 44218 | struct PyOpenCV_Converter< Ptr<cv::detail::BestOf2NearestMatcher> > |  | 44170 | struct PyOpenCV_Converter< Ptr<cv::detail::BestOf2NearestMatcher> >
| 44219 | { |  | 44171 | {
| 44220 | static PyObject* from(const Ptr<cv::detail::BestOf2NearestMatcher>& r) |  | 44172 | static PyObject* from(const Ptr<cv::detail::BestOf2NearestMatcher>& r)
| 44221 | { |  | 44173 | {
| 44222 | return pyopencv_detail_BestOf2NearestMatcher_Instance(r); |  | 44174 | return pyopencv_detail_BestOf2NearestMatcher_Instance(r);
| 44223 | } |  | 44175 | }
| 44224 | static bool to(PyObject* src, Ptr<cv::detail::BestOf2NearestMatcher>& dst, const ArgInfo& info) |  | 44176 | static bool to(PyObject* src, Ptr<cv::detail::BestOf2NearestMatcher>& dst, const ArgInfo& info)
| 44225 | { |  | 44177 | {
| 44226 | if(!src || src == Py_None) |  | 44178 | if(!src || src == Py_None)
| 44227 | return true; |  | 44179 | return true;
| 44228 | Ptr<cv::detail::BestOf2NearestMatcher> * dst_; |  | 44180 | Ptr<cv::detail::BestOf2NearestMatcher> * dst_;
| 44229 | if (pyopencv_detail_BestOf2NearestMatcher_getp(src, dst_)) |  | 44181 | if (pyopencv_detail_BestOf2NearestMatcher_getp(src, dst_))
| 44230 | { |  | 44182 | {
| 44231 | dst = *dst_; |  | 44183 | dst = *dst_;
| 44232 | return true; |  | 44184 | return true;
| 44233 | } |  | 44185 | }
| 44234 |  |  | 44186 |
| 44235 | failmsg("Expected Ptr<cv::detail::BestOf2NearestMatcher> for argument '%s'", info.name); |  | 44187 | failmsg("Expected Ptr<cv::detail::BestOf2NearestMatcher> for argument '%s'", info.name);
| 44236 | return false; |  | 44188 | return false;
| 44237 | } |  | 44189 | }
| 44238 | }; |  | 44190 | };
| 44239 |  |  | 44191 |
| 44240 | //================================================================================ |  | 44192 | //================================================================================
| 44241 | // detail_BestOf2NearestRangeMatcher (Generic) |  | 44193 | // detail_BestOf2NearestRangeMatcher (Generic)
| 44242 | //================================================================================ |  | 44194 | //================================================================================
| 44243 |  |  | 44195 |
| 44244 | // GetSet (detail_BestOf2NearestRangeMatcher) |  | 44196 | // GetSet (detail_BestOf2NearestRangeMatcher)
| 44245 |  |  | 44197 |
| 44246 |  |  | 44198 |
| 44247 |  |  | 44199 |
| 44248 | // Methods (detail_BestOf2NearestRangeMatcher) |  | 44200 | // Methods (detail_BestOf2NearestRangeMatcher)
| 44249 |  |  | 44201 |
| 44250 | static int pyopencv_cv_detail_detail_BestOf2NearestRangeMatcher_BestOf2NearestRangeMatcher(pyopencv_detail_BestOf2NearestRangeMatcher_t* self, PyObject* py_args, PyObject* kw) |  | 44202 | static int pyopencv_cv_detail_detail_BestOf2NearestRangeMatcher_BestOf2NearestRangeMatcher(pyopencv_detail_BestOf2NearestRangeMatcher_t* self, PyObject* py_args, PyObject* kw)
| 44251 | { |  | 44203 | {
| 44252 | using namespace cv::detail; |  | 44204 | using namespace cv::detail;
| 44253 |  |  | 44205 |
| 44254 | PyObject* pyobj_range_width = NULL; |  | 44206 | PyObject* pyobj_range_width = NULL;
| 44255 | int range_width=5; |  | 44207 | int range_width=5;
| 44256 | PyObject* pyobj_try_use_gpu = NULL; |  | 44208 | PyObject* pyobj_try_use_gpu = NULL;
| 44257 | bool try_use_gpu=false; |  | 44209 | bool try_use_gpu=false;
| 44258 | PyObject* pyobj_match_conf = NULL; |  | 44210 | PyObject* pyobj_match_conf = NULL;
| 44259 | float match_conf=0.3f; |  | 44211 | float match_conf=0.3f;
| 44260 | PyObject* pyobj_num_matches_thresh1 = NULL; |  | 44212 | PyObject* pyobj_num_matches_thresh1 = NULL;
| 44261 | int num_matches_thresh1=6; |  | 44213 | int num_matches_thresh1=6;
| 44262 | PyObject* pyobj_num_matches_thresh2 = NULL; |  | 44214 | PyObject* pyobj_num_matches_thresh2 = NULL;
| 44263 | int num_matches_thresh2=6; |  | 44215 | int num_matches_thresh2=6;
| 44264 |  |  | 44216 |
| 44265 | const char* keywords[] = { "range_width", "try_use_gpu", "match_conf", "num_matches_thresh1", "num_matches_thresh2", NULL }; |  | 44217 | const char* keywords[] = { "range_width", "try_use_gpu", "match_conf", "num_matches_thresh1", "num_matches_thresh2", NULL };
| 44266 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:BestOf2NearestRangeMatcher", (char**)keywords, &pyobj_range_width, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1, &pyobj_num_matches_thresh2) && |  | 44218 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:BestOf2NearestRangeMatcher", (char**)keywords, &pyobj_range_width, &pyobj_try_use_gpu, &pyobj_match_conf, &pyobj_num_matches_thresh1, &pyobj_num_matches_thresh2) &&
| 44267 | pyopencv_to_safe(pyobj_range_width, range_width, ArgInfo("range_width", 0)) && |  | 44219 | pyopencv_to_safe(pyobj_range_width, range_width, ArgInfo("range_width", 0)) &&
| 44268 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) && |  | 44220 | pyopencv_to_safe(pyobj_try_use_gpu, try_use_gpu, ArgInfo("try_use_gpu", 0)) &&
| 44269 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) && |  | 44221 | pyopencv_to_safe(pyobj_match_conf, match_conf, ArgInfo("match_conf", 0)) &&
| 44270 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) && |  | 44222 | pyopencv_to_safe(pyobj_num_matches_thresh1, num_matches_thresh1, ArgInfo("num_matches_thresh1", 0)) &&
| 44271 | pyopencv_to_safe(pyobj_num_matches_thresh2, num_matches_thresh2, ArgInfo("num_matches_thresh2", 0)) ) |  | 44223 | pyopencv_to_safe(pyobj_num_matches_thresh2, num_matches_thresh2, ArgInfo("num_matches_thresh2", 0)) )
| 44272 | { |  | 44224 | {
| 44273 | new (&(self->v)) Ptr<cv::detail::BestOf2NearestRangeMatcher>(); // init Ptr with placement new |  | 44225 | new (&(self->v)) Ptr<cv::detail::BestOf2NearestRangeMatcher>(); // init Ptr with placement new
| 44274 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BestOf2NearestRangeMatcher(range_width, try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2))); |  | 44226 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BestOf2NearestRangeMatcher(range_width, try_use_gpu, match_conf, num_matches_thresh1, num_matches_thresh2)));
| 44275 | return 0; |  | 44227 | return 0;
| 44276 | } |  | 44228 | }
| 44277 |  |  | 44229 |
| 44278 | return -1; |  | 44230 | return -1;
| 44279 | } |  | 44231 | }
| 44280 |  |  | 44232 |
| 44281 |  |  | 44233 |
| 44282 |  |  | 44234 |
| 44283 | // Tables (detail_BestOf2NearestRangeMatcher) |  | 44235 | // Tables (detail_BestOf2NearestRangeMatcher)
| 44284 |  |  | 44236 |
| 44285 | static PyGetSetDef pyopencv_detail_BestOf2NearestRangeMatcher_getseters[] = |  | 44237 | static PyGetSetDef pyopencv_detail_BestOf2NearestRangeMatcher_getseters[] =
| 44286 | { |  | 44238 | {
| 44287 | {NULL} /* Sentinel */ |  | 44239 | {NULL} /* Sentinel */
| 44288 | }; |  | 44240 | };
| 44289 |  |  | 44241 |
| 44290 | static PyMethodDef pyopencv_detail_BestOf2NearestRangeMatcher_methods[] = |  | 44242 | static PyMethodDef pyopencv_detail_BestOf2NearestRangeMatcher_methods[] =
| 44291 | { |  | 44243 | {
| 44292 |  |  | 44244 |
| 44293 | {NULL, NULL} |  | 44245 | {NULL, NULL}
| 44294 | }; |  | 44246 | };
| 44295 |  |  | 44247 |
| 44296 | // Converter (detail_BestOf2NearestRangeMatcher) |  | 44248 | // Converter (detail_BestOf2NearestRangeMatcher)
| 44297 |  |  | 44249 |
| 44298 | template<> |  | 44250 | template<>
| 44299 | struct PyOpenCV_Converter< Ptr<cv::detail::BestOf2NearestRangeMatcher> > |  | 44251 | struct PyOpenCV_Converter< Ptr<cv::detail::BestOf2NearestRangeMatcher> >
| 44300 | { |  | 44252 | {
| 44301 | static PyObject* from(const Ptr<cv::detail::BestOf2NearestRangeMatcher>& r) |  | 44253 | static PyObject* from(const Ptr<cv::detail::BestOf2NearestRangeMatcher>& r)
| 44302 | { |  | 44254 | {
| 44303 | return pyopencv_detail_BestOf2NearestRangeMatcher_Instance(r); |  | 44255 | return pyopencv_detail_BestOf2NearestRangeMatcher_Instance(r);
| 44304 | } |  | 44256 | }
| 44305 | static bool to(PyObject* src, Ptr<cv::detail::BestOf2NearestRangeMatcher>& dst, const ArgInfo& info) |  | 44257 | static bool to(PyObject* src, Ptr<cv::detail::BestOf2NearestRangeMatcher>& dst, const ArgInfo& info)
| 44306 | { |  | 44258 | {
| 44307 | if(!src || src == Py_None) |  | 44259 | if(!src || src == Py_None)
| 44308 | return true; |  | 44260 | return true;
| 44309 | Ptr<cv::detail::BestOf2NearestRangeMatcher> * dst_; |  | 44261 | Ptr<cv::detail::BestOf2NearestRangeMatcher> * dst_;
| 44310 | if (pyopencv_detail_BestOf2NearestRangeMatcher_getp(src, dst_)) |  | 44262 | if (pyopencv_detail_BestOf2NearestRangeMatcher_getp(src, dst_))
| 44311 | { |  | 44263 | {
| 44312 | dst = *dst_; |  | 44264 | dst = *dst_;
| 44313 | return true; |  | 44265 | return true;
| 44314 | } |  | 44266 | }
| 44315 |  |  | 44267 |
| 44316 | failmsg("Expected Ptr<cv::detail::BestOf2NearestRangeMatcher> for argument '%s'", info.name); |  | 44268 | failmsg("Expected Ptr<cv::detail::BestOf2NearestRangeMatcher> for argument '%s'", info.name);
| 44317 | return false; |  | 44269 | return false;
| 44318 | } |  | 44270 | }
| 44319 | }; |  | 44271 | };
| 44320 |  |  | 44272 |
| 44321 | //================================================================================ |  | 44273 | //================================================================================
| 44322 | // detail_Blender (Generic) |  | 44274 | // detail_Blender (Generic)
| 44323 | //================================================================================ |  | 44275 | //================================================================================
| 44324 |  |  | 44276 |
| 44325 | // GetSet (detail_Blender) |  | 44277 | // GetSet (detail_Blender)
| 44326 |  |  | 44278 |
| 44327 |  |  | 44279 |
| 44328 |  |  | 44280 |
| 44329 | // Methods (detail_Blender) |  | 44281 | // Methods (detail_Blender)
| 44330 |  |  | 44282 |
| 44331 | static PyObject* pyopencv_cv_detail_detail_Blender_blend(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44283 | static PyObject* pyopencv_cv_detail_detail_Blender_blend(PyObject* self, PyObject* py_args, PyObject* kw)
| 44332 | { |  | 44284 | {
| 44333 | using namespace cv::detail; |  | 44285 | using namespace cv::detail;
| 44334 |  |  | 44286 |
| 44335 |  |  | 44287 |
| 44336 | Ptr<cv::detail::Blender> * self1 = 0; |  | 44288 | Ptr<cv::detail::Blender> * self1 = 0;
| 44337 | if (!pyopencv_detail_Blender_getp(self, self1)) |  | 44289 | if (!pyopencv_detail_Blender_getp(self, self1))
| 44338 | return failmsgp("Incorrect type of self (must be 'detail_Blender' or its derivative)"); |  | 44290 | return failmsgp("Incorrect type of self (must be 'detail_Blender' or its derivative)");
| 44339 | Ptr<cv::detail::Blender> _self_ = *(self1); |  | 44291 | Ptr<cv::detail::Blender> _self_ = *(self1);
| 44340 | pyPrepareArgumentConversionErrorsStorage(2); |  | 44292 | pyPrepareArgumentConversionErrorsStorage(2);
| 44341 |  |  | 44293 |
| 44342 | { |  | 44294 | {
| 44343 | PyObject* pyobj_dst = NULL; |  | 44295 | PyObject* pyobj_dst = NULL;
| 44344 | Mat dst; |  | 44296 | Mat dst;
| 44345 | PyObject* pyobj_dst_mask = NULL; |  | 44297 | PyObject* pyobj_dst_mask = NULL;
| 44346 | Mat dst_mask; |  | 44298 | Mat dst_mask;
| 44347 |  |  | 44299 |
| 44348 | const char* keywords[] = { "dst", "dst_mask", NULL }; |  | 44300 | const char* keywords[] = { "dst", "dst_mask", NULL };
| 44349 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Blender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) && |  | 44301 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Blender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) &&
| 44350 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 44302 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 44351 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) ) |  | 44303 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) )
| 44352 | { |  | 44304 | {
| 44353 | ERRWRAP2(_self_->blend(dst, dst_mask)); |  | 44305 | ERRWRAP2(_self_->blend(dst, dst_mask));
| 44354 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask)); |  | 44306 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask));
| 44355 | } |  | 44307 | }
| 44356 |  |  | 44308 |
| 44357 |  |  | 44309 |
| 44358 | pyPopulateArgumentConversionErrors(); |  | 44310 | pyPopulateArgumentConversionErrors();
| 44359 | } |  | 44311 | }
| 44360 |  |  | 44312 |
| 44361 |  |  | 44313 |
| 44362 | { |  | 44314 | {
| 44363 | PyObject* pyobj_dst = NULL; |  | 44315 | PyObject* pyobj_dst = NULL;
| 44364 | UMat dst; |  | 44316 | UMat dst;
| 44365 | PyObject* pyobj_dst_mask = NULL; |  | 44317 | PyObject* pyobj_dst_mask = NULL;
| 44366 | UMat dst_mask; |  | 44318 | UMat dst_mask;
| 44367 |  |  | 44319 |
| 44368 | const char* keywords[] = { "dst", "dst_mask", NULL }; |  | 44320 | const char* keywords[] = { "dst", "dst_mask", NULL };
| 44369 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Blender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) && |  | 44321 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Blender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) &&
| 44370 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 44322 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 44371 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) ) |  | 44323 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) )
| 44372 | { |  | 44324 | {
| 44373 | ERRWRAP2(_self_->blend(dst, dst_mask)); |  | 44325 | ERRWRAP2(_self_->blend(dst, dst_mask));
| 44374 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask)); |  | 44326 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask));
| 44375 | } |  | 44327 | }
| 44376 |  |  | 44328 |
| 44377 |  |  | 44329 |
| 44378 | pyPopulateArgumentConversionErrors(); |  | 44330 | pyPopulateArgumentConversionErrors();
| 44379 | } |  | 44331 | }
| 44380 | pyRaiseCVOverloadException("blend"); |  | 44332 | pyRaiseCVOverloadException("blend");
| 44381 |  |  | 44333 |
| 44382 | return NULL; |  | 44334 | return NULL;
| 44383 | } |  | 44335 | }
| 44384 |  |  | 44336 |
| 44385 | static PyObject* pyopencv_cv_detail_detail_Blender_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44337 | static PyObject* pyopencv_cv_detail_detail_Blender_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 44386 | { |  | 44338 | {
| 44387 | using namespace cv::detail; |  | 44339 | using namespace cv::detail;
| 44388 |  |  | 44340 |
| 44389 | PyObject* pyobj_type = NULL; |  | 44341 | PyObject* pyobj_type = NULL;
| 44390 | int type=0; |  | 44342 | int type=0;
| 44391 | PyObject* pyobj_try_gpu = NULL; |  | 44343 | PyObject* pyobj_try_gpu = NULL;
| 44392 | bool try_gpu=false; |  | 44344 | bool try_gpu=false;
| 44393 | Ptr<Blender> retval; |  | 44345 | Ptr<Blender> retval;
| 44394 |  |  | 44346 |
| 44395 | const char* keywords[] = { "type", "try_gpu", NULL }; |  | 44347 | const char* keywords[] = { "type", "try_gpu", NULL };
| 44396 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:detail_Blender.createDefault", (char**)keywords, &pyobj_type, &pyobj_try_gpu) && |  | 44348 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:detail_Blender.createDefault", (char**)keywords, &pyobj_type, &pyobj_try_gpu) &&
| 44397 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 44349 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 44398 | pyopencv_to_safe(pyobj_try_gpu, try_gpu, ArgInfo("try_gpu", 0)) ) |  | 44350 | pyopencv_to_safe(pyobj_try_gpu, try_gpu, ArgInfo("try_gpu", 0)) )
| 44399 | { |  | 44351 | {
| 44400 | ERRWRAP2(retval = cv::detail::Blender::createDefault(type, try_gpu)); |  | 44352 | ERRWRAP2(retval = cv::detail::Blender::createDefault(type, try_gpu));
| 44401 | return pyopencv_from(retval); |  | 44353 | return pyopencv_from(retval);
| 44402 | } |  | 44354 | }
| 44403 |  |  | 44355 |
| 44404 | return NULL; |  | 44356 | return NULL;
| 44405 | } |  | 44357 | }
| 44406 |  |  | 44358 |
| 44407 | static PyObject* pyopencv_cv_detail_detail_Blender_feed(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44359 | static PyObject* pyopencv_cv_detail_detail_Blender_feed(PyObject* self, PyObject* py_args, PyObject* kw)
| 44408 | { |  | 44360 | {
| 44409 | using namespace cv::detail; |  | 44361 | using namespace cv::detail;
| 44410 |  |  | 44362 |
| 44411 |  |  | 44363 |
| 44412 | Ptr<cv::detail::Blender> * self1 = 0; |  | 44364 | Ptr<cv::detail::Blender> * self1 = 0;
| 44413 | if (!pyopencv_detail_Blender_getp(self, self1)) |  | 44365 | if (!pyopencv_detail_Blender_getp(self, self1))
| 44414 | return failmsgp("Incorrect type of self (must be 'detail_Blender' or its derivative)"); |  | 44366 | return failmsgp("Incorrect type of self (must be 'detail_Blender' or its derivative)");
| 44415 | Ptr<cv::detail::Blender> _self_ = *(self1); |  | 44367 | Ptr<cv::detail::Blender> _self_ = *(self1);
| 44416 | pyPrepareArgumentConversionErrorsStorage(2); |  | 44368 | pyPrepareArgumentConversionErrorsStorage(2);
| 44417 |  |  | 44369 |
| 44418 | { |  | 44370 | {
| 44419 | PyObject* pyobj_img = NULL; |  | 44371 | PyObject* pyobj_img = NULL;
| 44420 | Mat img; |  | 44372 | Mat img;
| 44421 | PyObject* pyobj_mask = NULL; |  | 44373 | PyObject* pyobj_mask = NULL;
| 44422 | Mat mask; |  | 44374 | Mat mask;
| 44423 | PyObject* pyobj_tl = NULL; |  | 44375 | PyObject* pyobj_tl = NULL;
| 44424 | Point tl; |  | 44376 | Point tl;
| 44425 |  |  | 44377 |
| 44426 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 44378 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 44427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Blender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 44379 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Blender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 44428 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 44380 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 44429 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 44381 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 44430 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 44382 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 44431 | { |  | 44383 | {
| 44432 | ERRWRAP2(_self_->feed(img, mask, tl)); |  | 44384 | ERRWRAP2(_self_->feed(img, mask, tl));
| 44433 | Py_RETURN_NONE; |  | 44385 | Py_RETURN_NONE;
| 44434 | } |  | 44386 | }
| 44435 |  |  | 44387 |
| 44436 |  |  | 44388 |
| 44437 | pyPopulateArgumentConversionErrors(); |  | 44389 | pyPopulateArgumentConversionErrors();
| 44438 | } |  | 44390 | }
| 44439 |  |  | 44391 |
| 44440 |  |  | 44392 |
| 44441 | { |  | 44393 | {
| 44442 | PyObject* pyobj_img = NULL; |  | 44394 | PyObject* pyobj_img = NULL;
| 44443 | UMat img; |  | 44395 | UMat img;
| 44444 | PyObject* pyobj_mask = NULL; |  | 44396 | PyObject* pyobj_mask = NULL;
| 44445 | UMat mask; |  | 44397 | UMat mask;
| 44446 | PyObject* pyobj_tl = NULL; |  | 44398 | PyObject* pyobj_tl = NULL;
| 44447 | Point tl; |  | 44399 | Point tl;
| 44448 |  |  | 44400 |
| 44449 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 44401 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 44450 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Blender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 44402 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Blender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 44451 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 44403 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 44452 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 44404 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 44453 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 44405 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 44454 | { |  | 44406 | {
| 44455 | ERRWRAP2(_self_->feed(img, mask, tl)); |  | 44407 | ERRWRAP2(_self_->feed(img, mask, tl));
| 44456 | Py_RETURN_NONE; |  | 44408 | Py_RETURN_NONE;
| 44457 | } |  | 44409 | }
| 44458 |  |  | 44410 |
| 44459 |  |  | 44411 |
| 44460 | pyPopulateArgumentConversionErrors(); |  | 44412 | pyPopulateArgumentConversionErrors();
| 44461 | } |  | 44413 | }
| 44462 | pyRaiseCVOverloadException("feed"); |  | 44414 | pyRaiseCVOverloadException("feed");
| 44463 |  |  | 44415 |
| 44464 | return NULL; |  | 44416 | return NULL;
| 44465 | } |  | 44417 | }
| 44466 |  |  | 44418 |
| 44467 | static PyObject* pyopencv_cv_detail_detail_Blender_prepare(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44419 | static PyObject* pyopencv_cv_detail_detail_Blender_prepare(PyObject* self, PyObject* py_args, PyObject* kw)
| 44468 | { |  | 44420 | {
| 44469 | using namespace cv::detail; |  | 44421 | using namespace cv::detail;
| 44470 |  |  | 44422 |
| 44471 |  |  | 44423 |
| 44472 | Ptr<cv::detail::Blender> * self1 = 0; |  | 44424 | Ptr<cv::detail::Blender> * self1 = 0;
| 44473 | if (!pyopencv_detail_Blender_getp(self, self1)) |  | 44425 | if (!pyopencv_detail_Blender_getp(self, self1))
| 44474 | return failmsgp("Incorrect type of self (must be 'detail_Blender' or its derivative)"); |  | 44426 | return failmsgp("Incorrect type of self (must be 'detail_Blender' or its derivative)");
| 44475 | Ptr<cv::detail::Blender> _self_ = *(self1); |  | 44427 | Ptr<cv::detail::Blender> _self_ = *(self1);
| 44476 | pyPrepareArgumentConversionErrorsStorage(2); |  | 44428 | pyPrepareArgumentConversionErrorsStorage(2);
| 44477 |  |  | 44429 |
| 44478 | { |  | 44430 | {
| 44479 | PyObject* pyobj_corners = NULL; |  | 44431 | PyObject* pyobj_corners = NULL;
| 44480 | vector_Point corners; |  | 44432 | vector_Point corners;
| 44481 | PyObject* pyobj_sizes = NULL; |  | 44433 | PyObject* pyobj_sizes = NULL;
| 44482 | vector_Size sizes; |  | 44434 | vector_Size sizes;
| 44483 |  |  | 44435 |
| 44484 | const char* keywords[] = { "corners", "sizes", NULL }; |  | 44436 | const char* keywords[] = { "corners", "sizes", NULL };
| 44485 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Blender.prepare", (char**)keywords, &pyobj_corners, &pyobj_sizes) && |  | 44437 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Blender.prepare", (char**)keywords, &pyobj_corners, &pyobj_sizes) &&
| 44486 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 44438 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 44487 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) ) |  | 44439 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) )
| 44488 | { |  | 44440 | {
| 44489 | ERRWRAP2(_self_->prepare(corners, sizes)); |  | 44441 | ERRWRAP2(_self_->prepare(corners, sizes));
| 44490 | Py_RETURN_NONE; |  | 44442 | Py_RETURN_NONE;
| 44491 | } |  | 44443 | }
| 44492 |  |  | 44444 |
| 44493 |  |  | 44445 |
| 44494 | pyPopulateArgumentConversionErrors(); |  | 44446 | pyPopulateArgumentConversionErrors();
| 44495 | } |  | 44447 | }
| 44496 |  |  | 44448 |
| 44497 |  |  | 44449 |
| 44498 | { |  | 44450 | {
| 44499 | PyObject* pyobj_dst_roi = NULL; |  | 44451 | PyObject* pyobj_dst_roi = NULL;
| 44500 | Rect dst_roi; |  | 44452 | Rect dst_roi;
| 44501 |  |  | 44453 |
| 44502 | const char* keywords[] = { "dst_roi", NULL }; |  | 44454 | const char* keywords[] = { "dst_roi", NULL };
| 44503 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_Blender.prepare", (char**)keywords, &pyobj_dst_roi) && |  | 44455 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_Blender.prepare", (char**)keywords, &pyobj_dst_roi) &&
| 44504 | pyopencv_to_safe(pyobj_dst_roi, dst_roi, ArgInfo("dst_roi", 0)) ) |  | 44456 | pyopencv_to_safe(pyobj_dst_roi, dst_roi, ArgInfo("dst_roi", 0)) )
| 44505 | { |  | 44457 | {
| 44506 | ERRWRAP2(_self_->prepare(dst_roi)); |  | 44458 | ERRWRAP2(_self_->prepare(dst_roi));
| 44507 | Py_RETURN_NONE; |  | 44459 | Py_RETURN_NONE;
| 44508 | } |  | 44460 | }
| 44509 |  |  | 44461 |
| 44510 |  |  | 44462 |
| 44511 | pyPopulateArgumentConversionErrors(); |  | 44463 | pyPopulateArgumentConversionErrors();
| 44512 | } |  | 44464 | }
| 44513 | pyRaiseCVOverloadException("prepare"); |  | 44465 | pyRaiseCVOverloadException("prepare");
| 44514 |  |  | 44466 |
| 44515 | return NULL; |  | 44467 | return NULL;
| 44516 | } |  | 44468 | }
| 44517 |  |  | 44469 |
| 44518 |  |  | 44470 |
| 44519 |  |  | 44471 |
| 44520 | // Tables (detail_Blender) |  | 44472 | // Tables (detail_Blender)
| 44521 |  |  | 44473 |
| 44522 | static PyGetSetDef pyopencv_detail_Blender_getseters[] = |  | 44474 | static PyGetSetDef pyopencv_detail_Blender_getseters[] =
| 44523 | { |  | 44475 | {
| 44524 | {NULL} /* Sentinel */ |  | 44476 | {NULL} /* Sentinel */
| 44525 | }; |  | 44477 | };
| 44526 |  |  | 44478 |
| 44527 | static PyMethodDef pyopencv_detail_Blender_methods[] = |  | 44479 | static PyMethodDef pyopencv_detail_Blender_methods[] =
| 44528 | { |  | 44480 | {
| 44529 | {"blend", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_blend, 0), "blend(dst, dst_mask) -> dst, dst_mask\n. @brief Blends and returns the final pano.\n. \n. @param dst Final pano\n. @param dst_mask Final pano mask"}, |  | 44481 | {"blend", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_blend, 0), "blend(dst, dst_mask) -> dst, dst_mask\n. @brief Blends and returns the final pano.\n. \n. @param dst Final pano\n. @param dst_mask Final pano mask"},
| 44530 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_createDefault_static, METH_STATIC), "createDefault(type[, try_gpu]) -> retval\n."}, |  | 44482 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_createDefault_static, METH_STATIC), "createDefault(type[, try_gpu]) -> retval\n."},
| 44531 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_feed, 0), "feed(img, mask, tl) -> None\n. @brief Processes the image.\n. \n. @param img Source image\n. @param mask Source image mask\n. @param tl Source image top-left corners"}, |  | 44483 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_feed, 0), "feed(img, mask, tl) -> None\n. @brief Processes the image.\n. \n. @param img Source image\n. @param mask Source image mask\n. @param tl Source image top-left corners"},
| 44532 | {"prepare", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_prepare, 0), "prepare(corners, sizes) -> None\n. @brief Prepares the blender for blending.\n. \n. @param corners Source images top-left corners\n. @param sizes Source image sizes\n\n\n\nprepare(dst_roi) -> None\n. @overload"}, |  | 44484 | {"prepare", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Blender_prepare, 0), "prepare(corners, sizes) -> None\n. @brief Prepares the blender for blending.\n. \n. @param corners Source images top-left corners\n. @param sizes Source image sizes\n\n\n\nprepare(dst_roi) -> None\n. @overload"},
| 44533 |  |  | 44485 |
| 44534 | {NULL, NULL} |  | 44486 | {NULL, NULL}
| 44535 | }; |  | 44487 | };
| 44536 |  |  | 44488 |
| 44537 | // Converter (detail_Blender) |  | 44489 | // Converter (detail_Blender)
| 44538 |  |  | 44490 |
| 44539 | template<> |  | 44491 | template<>
| 44540 | struct PyOpenCV_Converter< Ptr<cv::detail::Blender> > |  | 44492 | struct PyOpenCV_Converter< Ptr<cv::detail::Blender> >
| 44541 | { |  | 44493 | {
| 44542 | static PyObject* from(const Ptr<cv::detail::Blender>& r) |  | 44494 | static PyObject* from(const Ptr<cv::detail::Blender>& r)
| 44543 | { |  | 44495 | {
| 44544 | return pyopencv_detail_Blender_Instance(r); |  | 44496 | return pyopencv_detail_Blender_Instance(r);
| 44545 | } |  | 44497 | }
| 44546 | static bool to(PyObject* src, Ptr<cv::detail::Blender>& dst, const ArgInfo& info) |  | 44498 | static bool to(PyObject* src, Ptr<cv::detail::Blender>& dst, const ArgInfo& info)
| 44547 | { |  | 44499 | {
| 44548 | if(!src || src == Py_None) |  | 44500 | if(!src || src == Py_None)
| 44549 | return true; |  | 44501 | return true;
| 44550 | Ptr<cv::detail::Blender> * dst_; |  | 44502 | Ptr<cv::detail::Blender> * dst_;
| 44551 | if (pyopencv_detail_Blender_getp(src, dst_)) |  | 44503 | if (pyopencv_detail_Blender_getp(src, dst_))
| 44552 | { |  | 44504 | {
| 44553 | dst = *dst_; |  | 44505 | dst = *dst_;
| 44554 | return true; |  | 44506 | return true;
| 44555 | } |  | 44507 | }
| 44556 |  |  | 44508 |
| 44557 | failmsg("Expected Ptr<cv::detail::Blender> for argument '%s'", info.name); |  | 44509 | failmsg("Expected Ptr<cv::detail::Blender> for argument '%s'", info.name);
| 44558 | return false; |  | 44510 | return false;
| 44559 | } |  | 44511 | }
| 44560 | }; |  | 44512 | };
| 44561 |  |  | 44513 |
| 44562 | //================================================================================ |  | 44514 | //================================================================================
| 44563 | // detail_BlocksChannelsCompensator (Generic) |  | 44515 | // detail_BlocksChannelsCompensator (Generic)
| 44564 | //================================================================================ |  | 44516 | //================================================================================
| 44565 |  |  | 44517 |
| 44566 | // GetSet (detail_BlocksChannelsCompensator) |  | 44518 | // GetSet (detail_BlocksChannelsCompensator)
| 44567 |  |  | 44519 |
| 44568 |  |  | 44520 |
| 44569 |  |  | 44521 |
| 44570 | // Methods (detail_BlocksChannelsCompensator) |  | 44522 | // Methods (detail_BlocksChannelsCompensator)
| 44571 |  |  | 44523 |
| 44572 | static int pyopencv_cv_detail_detail_BlocksChannelsCompensator_BlocksChannelsCompensator(pyopencv_detail_BlocksChannelsCompensator_t* self, PyObject* py_args, PyObject* kw) |  | 44524 | static int pyopencv_cv_detail_detail_BlocksChannelsCompensator_BlocksChannelsCompensator(pyopencv_detail_BlocksChannelsCompensator_t* self, PyObject* py_args, PyObject* kw)
| 44573 | { |  | 44525 | {
| 44574 | using namespace cv::detail; |  | 44526 | using namespace cv::detail;
| 44575 |  |  | 44527 |
| 44576 | PyObject* pyobj_bl_width = NULL; |  | 44528 | PyObject* pyobj_bl_width = NULL;
| 44577 | int bl_width=32; |  | 44529 | int bl_width=32;
| 44578 | PyObject* pyobj_bl_height = NULL; |  | 44530 | PyObject* pyobj_bl_height = NULL;
| 44579 | int bl_height=32; |  | 44531 | int bl_height=32;
| 44580 | PyObject* pyobj_nr_feeds = NULL; |  | 44532 | PyObject* pyobj_nr_feeds = NULL;
| 44581 | int nr_feeds=1; |  | 44533 | int nr_feeds=1;
| 44582 |  |  | 44534 |
| 44583 | const char* keywords[] = { "bl_width", "bl_height", "nr_feeds", NULL }; |  | 44535 | const char* keywords[] = { "bl_width", "bl_height", "nr_feeds", NULL };
| 44584 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:BlocksChannelsCompensator", (char**)keywords, &pyobj_bl_width, &pyobj_bl_height, &pyobj_nr_feeds) && |  | 44536 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:BlocksChannelsCompensator", (char**)keywords, &pyobj_bl_width, &pyobj_bl_height, &pyobj_nr_feeds) &&
| 44585 | pyopencv_to_safe(pyobj_bl_width, bl_width, ArgInfo("bl_width", 0)) && |  | 44537 | pyopencv_to_safe(pyobj_bl_width, bl_width, ArgInfo("bl_width", 0)) &&
| 44586 | pyopencv_to_safe(pyobj_bl_height, bl_height, ArgInfo("bl_height", 0)) && |  | 44538 | pyopencv_to_safe(pyobj_bl_height, bl_height, ArgInfo("bl_height", 0)) &&
| 44587 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) ) |  | 44539 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) )
| 44588 | { |  | 44540 | {
| 44589 | new (&(self->v)) Ptr<cv::detail::BlocksChannelsCompensator>(); // init Ptr with placement new |  | 44541 | new (&(self->v)) Ptr<cv::detail::BlocksChannelsCompensator>(); // init Ptr with placement new
| 44590 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BlocksChannelsCompensator(bl_width, bl_height, nr_feeds))); |  | 44542 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BlocksChannelsCompensator(bl_width, bl_height, nr_feeds)));
| 44591 | return 0; |  | 44543 | return 0;
| 44592 | } |  | 44544 | }
| 44593 |  |  | 44545 |
| 44594 | return -1; |  | 44546 | return -1;
| 44595 | } |  | 44547 | }
| 44596 |  |  | 44548 |
| 44597 |  |  | 44549 |
| 44598 |  |  | 44550 |
| 44599 | // Tables (detail_BlocksChannelsCompensator) |  | 44551 | // Tables (detail_BlocksChannelsCompensator)
| 44600 |  |  | 44552 |
| 44601 | static PyGetSetDef pyopencv_detail_BlocksChannelsCompensator_getseters[] = |  | 44553 | static PyGetSetDef pyopencv_detail_BlocksChannelsCompensator_getseters[] =
| 44602 | { |  | 44554 | {
| 44603 | {NULL} /* Sentinel */ |  | 44555 | {NULL} /* Sentinel */
| 44604 | }; |  | 44556 | };
| 44605 |  |  | 44557 |
| 44606 | static PyMethodDef pyopencv_detail_BlocksChannelsCompensator_methods[] = |  | 44558 | static PyMethodDef pyopencv_detail_BlocksChannelsCompensator_methods[] =
| 44607 | { |  | 44559 | {
| 44608 |  |  | 44560 |
| 44609 | {NULL, NULL} |  | 44561 | {NULL, NULL}
| 44610 | }; |  | 44562 | };
| 44611 |  |  | 44563 |
| 44612 | // Converter (detail_BlocksChannelsCompensator) |  | 44564 | // Converter (detail_BlocksChannelsCompensator)
| 44613 |  |  | 44565 |
| 44614 | template<> |  | 44566 | template<>
| 44615 | struct PyOpenCV_Converter< Ptr<cv::detail::BlocksChannelsCompensator> > |  | 44567 | struct PyOpenCV_Converter< Ptr<cv::detail::BlocksChannelsCompensator> >
| 44616 | { |  | 44568 | {
| 44617 | static PyObject* from(const Ptr<cv::detail::BlocksChannelsCompensator>& r) |  | 44569 | static PyObject* from(const Ptr<cv::detail::BlocksChannelsCompensator>& r)
| 44618 | { |  | 44570 | {
| 44619 | return pyopencv_detail_BlocksChannelsCompensator_Instance(r); |  | 44571 | return pyopencv_detail_BlocksChannelsCompensator_Instance(r);
| 44620 | } |  | 44572 | }
| 44621 | static bool to(PyObject* src, Ptr<cv::detail::BlocksChannelsCompensator>& dst, const ArgInfo& info) |  | 44573 | static bool to(PyObject* src, Ptr<cv::detail::BlocksChannelsCompensator>& dst, const ArgInfo& info)
| 44622 | { |  | 44574 | {
| 44623 | if(!src || src == Py_None) |  | 44575 | if(!src || src == Py_None)
| 44624 | return true; |  | 44576 | return true;
| 44625 | Ptr<cv::detail::BlocksChannelsCompensator> * dst_; |  | 44577 | Ptr<cv::detail::BlocksChannelsCompensator> * dst_;
| 44626 | if (pyopencv_detail_BlocksChannelsCompensator_getp(src, dst_)) |  | 44578 | if (pyopencv_detail_BlocksChannelsCompensator_getp(src, dst_))
| 44627 | { |  | 44579 | {
| 44628 | dst = *dst_; |  | 44580 | dst = *dst_;
| 44629 | return true; |  | 44581 | return true;
| 44630 | } |  | 44582 | }
| 44631 |  |  | 44583 |
| 44632 | failmsg("Expected Ptr<cv::detail::BlocksChannelsCompensator> for argument '%s'", info.name); |  | 44584 | failmsg("Expected Ptr<cv::detail::BlocksChannelsCompensator> for argument '%s'", info.name);
| 44633 | return false; |  | 44585 | return false;
| 44634 | } |  | 44586 | }
| 44635 | }; |  | 44587 | };
| 44636 |  |  | 44588 |
| 44637 | //================================================================================ |  | 44589 | //================================================================================
| 44638 | // detail_BlocksCompensator (Generic) |  | 44590 | // detail_BlocksCompensator (Generic)
| 44639 | //================================================================================ |  | 44591 | //================================================================================
| 44640 |  |  | 44592 |
| 44641 | // GetSet (detail_BlocksCompensator) |  | 44593 | // GetSet (detail_BlocksCompensator)
| 44642 |  |  | 44594 |
| 44643 |  |  | 44595 |
| 44644 |  |  | 44596 |
| 44645 | // Methods (detail_BlocksCompensator) |  | 44597 | // Methods (detail_BlocksCompensator)
| 44646 |  |  | 44598 |
| 44647 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44599 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 44648 | { |  | 44600 | {
| 44649 | using namespace cv::detail; |  | 44601 | using namespace cv::detail;
| 44650 |  |  | 44602 |
| 44651 |  |  | 44603 |
| 44652 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44604 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44653 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44605 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44654 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44606 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44655 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44607 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44656 | pyPrepareArgumentConversionErrorsStorage(2); |  | 44608 | pyPrepareArgumentConversionErrorsStorage(2);
| 44657 |  |  | 44609 |
| 44658 | { |  | 44610 | {
| 44659 | PyObject* pyobj_index = NULL; |  | 44611 | PyObject* pyobj_index = NULL;
| 44660 | int index=0; |  | 44612 | int index=0;
| 44661 | PyObject* pyobj_corner = NULL; |  | 44613 | PyObject* pyobj_corner = NULL;
| 44662 | Point corner; |  | 44614 | Point corner;
| 44663 | PyObject* pyobj_image = NULL; |  | 44615 | PyObject* pyobj_image = NULL;
| 44664 | Mat image; |  | 44616 | Mat image;
| 44665 | PyObject* pyobj_mask = NULL; |  | 44617 | PyObject* pyobj_mask = NULL;
| 44666 | Mat mask; |  | 44618 | Mat mask;
| 44667 |  |  | 44619 |
| 44668 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 44620 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 44669 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 44621 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 44670 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 44622 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 44671 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 44623 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 44672 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 44624 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 44673 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 44625 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 44674 | { |  | 44626 | {
| 44675 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 44627 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 44676 | return pyopencv_from(image); |  | 44628 | return pyopencv_from(image);
| 44677 | } |  | 44629 | }
| 44678 |  |  | 44630 |
| 44679 |  |  | 44631 |
| 44680 | pyPopulateArgumentConversionErrors(); |  | 44632 | pyPopulateArgumentConversionErrors();
| 44681 | } |  | 44633 | }
| 44682 |  |  | 44634 |
| 44683 |  |  | 44635 |
| 44684 | { |  | 44636 | {
| 44685 | PyObject* pyobj_index = NULL; |  | 44637 | PyObject* pyobj_index = NULL;
| 44686 | int index=0; |  | 44638 | int index=0;
| 44687 | PyObject* pyobj_corner = NULL; |  | 44639 | PyObject* pyobj_corner = NULL;
| 44688 | Point corner; |  | 44640 | Point corner;
| 44689 | PyObject* pyobj_image = NULL; |  | 44641 | PyObject* pyobj_image = NULL;
| 44690 | UMat image; |  | 44642 | UMat image;
| 44691 | PyObject* pyobj_mask = NULL; |  | 44643 | PyObject* pyobj_mask = NULL;
| 44692 | UMat mask; |  | 44644 | UMat mask;
| 44693 |  |  | 44645 |
| 44694 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 44646 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 44695 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 44647 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 44696 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 44648 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 44697 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 44649 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 44698 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 44650 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 44699 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 44651 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 44700 | { |  | 44652 | {
| 44701 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 44653 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 44702 | return pyopencv_from(image); |  | 44654 | return pyopencv_from(image);
| 44703 | } |  | 44655 | }
| 44704 |  |  | 44656 |
| 44705 |  |  | 44657 |
| 44706 | pyPopulateArgumentConversionErrors(); |  | 44658 | pyPopulateArgumentConversionErrors();
| 44707 | } |  | 44659 | }
| 44708 | pyRaiseCVOverloadException("apply"); |  | 44660 | pyRaiseCVOverloadException("apply");
| 44709 |  |  | 44661 |
| 44710 | return NULL; |  | 44662 | return NULL;
| 44711 | } |  | 44663 | }
| 44712 |  |  | 44664 |
| 44713 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44665 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 44714 | { |  | 44666 | {
| 44715 | using namespace cv::detail; |  | 44667 | using namespace cv::detail;
| 44716 |  |  | 44668 |
| 44717 |  |  | 44669 |
| 44718 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44670 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44719 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44671 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44720 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44672 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44721 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44673 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44722 | Size retval; |  | 44674 | Size retval;
| 44723 |  |  | 44675 |
| 44724 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 44676 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 44725 | { |  | 44677 | {
| 44726 | ERRWRAP2(retval = _self_->getBlockSize()); |  | 44678 | ERRWRAP2(retval = _self_->getBlockSize());
| 44727 | return pyopencv_from(retval); |  | 44679 | return pyopencv_from(retval);
| 44728 | } |  | 44680 | }
| 44729 |  |  | 44681 |
| 44730 | return NULL; |  | 44682 | return NULL;
| 44731 | } |  | 44683 | }
| 44732 |  |  | 44684 |
| 44733 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44685 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 44734 | { |  | 44686 | {
| 44735 | using namespace cv::detail; |  | 44687 | using namespace cv::detail;
| 44736 |  |  | 44688 |
| 44737 |  |  | 44689 |
| 44738 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44690 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44739 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44691 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44740 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44692 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44741 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44693 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44742 | PyObject* pyobj_umv = NULL; |  | 44694 | PyObject* pyobj_umv = NULL;
| 44743 | vector_Mat umv; |  | 44695 | vector_Mat umv;
| 44744 |  |  | 44696 |
| 44745 | const char* keywords[] = { "umv", NULL }; |  | 44697 | const char* keywords[] = { "umv", NULL };
| 44746 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_BlocksCompensator.getMatGains", (char**)keywords, &pyobj_umv) && |  | 44698 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_BlocksCompensator.getMatGains", (char**)keywords, &pyobj_umv) &&
| 44747 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) ) |  | 44699 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) )
| 44748 | { |  | 44700 | {
| 44749 | ERRWRAP2(_self_->getMatGains(umv)); |  | 44701 | ERRWRAP2(_self_->getMatGains(umv));
| 44750 | return pyopencv_from(umv); |  | 44702 | return pyopencv_from(umv);
| 44751 | } |  | 44703 | }
| 44752 |  |  | 44704 |
| 44753 | return NULL; |  | 44705 | return NULL;
| 44754 | } |  | 44706 | }
| 44755 |  |  | 44707 |
| 44756 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44708 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw)
| 44757 | { |  | 44709 | {
| 44758 | using namespace cv::detail; |  | 44710 | using namespace cv::detail;
| 44759 |  |  | 44711 |
| 44760 |  |  | 44712 |
| 44761 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44713 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44762 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44714 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44763 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44715 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44764 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44716 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44765 | int retval; |  | 44717 | int retval;
| 44766 |  |  | 44718 |
| 44767 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 44719 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 44768 | { |  | 44720 | {
| 44769 | ERRWRAP2(retval = _self_->getNrFeeds()); |  | 44721 | ERRWRAP2(retval = _self_->getNrFeeds());
| 44770 | return pyopencv_from(retval); |  | 44722 | return pyopencv_from(retval);
| 44771 | } |  | 44723 | }
| 44772 |  |  | 44724 |
| 44773 | return NULL; |  | 44725 | return NULL;
| 44774 | } |  | 44726 | }
| 44775 |  |  | 44727 |
| 44776 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getNrGainsFilteringIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44728 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getNrGainsFilteringIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 44777 | { |  | 44729 | {
| 44778 | using namespace cv::detail; |  | 44730 | using namespace cv::detail;
| 44779 |  |  | 44731 |
| 44780 |  |  | 44732 |
| 44781 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44733 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44782 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44734 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44783 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44735 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44784 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44736 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44785 | int retval; |  | 44737 | int retval;
| 44786 |  |  | 44738 |
| 44787 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 44739 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 44788 | { |  | 44740 | {
| 44789 | ERRWRAP2(retval = _self_->getNrGainsFilteringIterations()); |  | 44741 | ERRWRAP2(retval = _self_->getNrGainsFilteringIterations());
| 44790 | return pyopencv_from(retval); |  | 44742 | return pyopencv_from(retval);
| 44791 | } |  | 44743 | }
| 44792 |  |  | 44744 |
| 44793 | return NULL; |  | 44745 | return NULL;
| 44794 | } |  | 44746 | }
| 44795 |  |  | 44747 |
| 44796 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44748 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_getSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 44797 | { |  | 44749 | {
| 44798 | using namespace cv::detail; |  | 44750 | using namespace cv::detail;
| 44799 |  |  | 44751 |
| 44800 |  |  | 44752 |
| 44801 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44753 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44802 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44754 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44803 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44755 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44804 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44756 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44805 | double retval; |  | 44757 | double retval;
| 44806 |  |  | 44758 |
| 44807 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 44759 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 44808 | { |  | 44760 | {
| 44809 | ERRWRAP2(retval = _self_->getSimilarityThreshold()); |  | 44761 | ERRWRAP2(retval = _self_->getSimilarityThreshold());
| 44810 | return pyopencv_from(retval); |  | 44762 | return pyopencv_from(retval);
| 44811 | } |  | 44763 | }
| 44812 |  |  | 44764 |
| 44813 | return NULL; |  | 44765 | return NULL;
| 44814 | } |  | 44766 | }
| 44815 |  |  | 44767 |
| 44816 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44768 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 44817 | { |  | 44769 | {
| 44818 | using namespace cv::detail; |  | 44770 | using namespace cv::detail;
| 44819 |  |  | 44771 |
| 44820 |  |  | 44772 |
| 44821 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44773 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44822 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44774 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44823 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44775 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44824 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44776 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44825 | pyPrepareArgumentConversionErrorsStorage(2); |  | 44777 | pyPrepareArgumentConversionErrorsStorage(2);
| 44826 |  |  | 44778 |
| 44827 | { |  | 44779 | {
| 44828 | PyObject* pyobj_width = NULL; |  | 44780 | PyObject* pyobj_width = NULL;
| 44829 | int width=0; |  | 44781 | int width=0;
| 44830 | PyObject* pyobj_height = NULL; |  | 44782 | PyObject* pyobj_height = NULL;
| 44831 | int height=0; |  | 44783 | int height=0;
| 44832 |  |  | 44784 |
| 44833 | const char* keywords[] = { "width", "height", NULL }; |  | 44785 | const char* keywords[] = { "width", "height", NULL };
| 44834 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_BlocksCompensator.setBlockSize", (char**)keywords, &pyobj_width, &pyobj_height) && |  | 44786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_BlocksCompensator.setBlockSize", (char**)keywords, &pyobj_width, &pyobj_height) &&
| 44835 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) && |  | 44787 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) &&
| 44836 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) ) |  | 44788 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) )
| 44837 | { |  | 44789 | {
| 44838 | ERRWRAP2(_self_->setBlockSize(width, height)); |  | 44790 | ERRWRAP2(_self_->setBlockSize(width, height));
| 44839 | Py_RETURN_NONE; |  | 44791 | Py_RETURN_NONE;
| 44840 | } |  | 44792 | }
| 44841 |  |  | 44793 |
| 44842 |  |  | 44794 |
| 44843 | pyPopulateArgumentConversionErrors(); |  | 44795 | pyPopulateArgumentConversionErrors();
| 44844 | } |  | 44796 | }
| 44845 |  |  | 44797 |
| 44846 |  |  | 44798 |
| 44847 | { |  | 44799 | {
| 44848 | PyObject* pyobj_size = NULL; |  | 44800 | PyObject* pyobj_size = NULL;
| 44849 | Size size; |  | 44801 | Size size;
| 44850 |  |  | 44802 |
| 44851 | const char* keywords[] = { "size", NULL }; |  | 44803 | const char* keywords[] = { "size", NULL };
| 44852 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setBlockSize", (char**)keywords, &pyobj_size) && |  | 44804 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setBlockSize", (char**)keywords, &pyobj_size) &&
| 44853 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) ) |  | 44805 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) )
| 44854 | { |  | 44806 | {
| 44855 | ERRWRAP2(_self_->setBlockSize(size)); |  | 44807 | ERRWRAP2(_self_->setBlockSize(size));
| 44856 | Py_RETURN_NONE; |  | 44808 | Py_RETURN_NONE;
| 44857 | } |  | 44809 | }
| 44858 |  |  | 44810 |
| 44859 |  |  | 44811 |
| 44860 | pyPopulateArgumentConversionErrors(); |  | 44812 | pyPopulateArgumentConversionErrors();
| 44861 | } |  | 44813 | }
| 44862 | pyRaiseCVOverloadException("setBlockSize"); |  | 44814 | pyRaiseCVOverloadException("setBlockSize");
| 44863 |  |  | 44815 |
| 44864 | return NULL; |  | 44816 | return NULL;
| 44865 | } |  | 44817 | }
| 44866 |  |  | 44818 |
| 44867 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44819 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 44868 | { |  | 44820 | {
| 44869 | using namespace cv::detail; |  | 44821 | using namespace cv::detail;
| 44870 |  |  | 44822 |
| 44871 |  |  | 44823 |
| 44872 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44824 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44873 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44825 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44874 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44826 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44875 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44827 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44876 | PyObject* pyobj_umv = NULL; |  | 44828 | PyObject* pyobj_umv = NULL;
| 44877 | vector_Mat umv; |  | 44829 | vector_Mat umv;
| 44878 |  |  | 44830 |
| 44879 | const char* keywords[] = { "umv", NULL }; |  | 44831 | const char* keywords[] = { "umv", NULL };
| 44880 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setMatGains", (char**)keywords, &pyobj_umv) && |  | 44832 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setMatGains", (char**)keywords, &pyobj_umv) &&
| 44881 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) ) |  | 44833 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) )
| 44882 | { |  | 44834 | {
| 44883 | ERRWRAP2(_self_->setMatGains(umv)); |  | 44835 | ERRWRAP2(_self_->setMatGains(umv));
| 44884 | Py_RETURN_NONE; |  | 44836 | Py_RETURN_NONE;
| 44885 | } |  | 44837 | }
| 44886 |  |  | 44838 |
| 44887 | return NULL; |  | 44839 | return NULL;
| 44888 | } |  | 44840 | }
| 44889 |  |  | 44841 |
| 44890 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44842 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw)
| 44891 | { |  | 44843 | {
| 44892 | using namespace cv::detail; |  | 44844 | using namespace cv::detail;
| 44893 |  |  | 44845 |
| 44894 |  |  | 44846 |
| 44895 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44847 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44896 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44848 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44897 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44849 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44898 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44850 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44899 | PyObject* pyobj_nr_feeds = NULL; |  | 44851 | PyObject* pyobj_nr_feeds = NULL;
| 44900 | int nr_feeds=0; |  | 44852 | int nr_feeds=0;
| 44901 |  |  | 44853 |
| 44902 | const char* keywords[] = { "nr_feeds", NULL }; |  | 44854 | const char* keywords[] = { "nr_feeds", NULL };
| 44903 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setNrFeeds", (char**)keywords, &pyobj_nr_feeds) && |  | 44855 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setNrFeeds", (char**)keywords, &pyobj_nr_feeds) &&
| 44904 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) ) |  | 44856 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) )
| 44905 | { |  | 44857 | {
| 44906 | ERRWRAP2(_self_->setNrFeeds(nr_feeds)); |  | 44858 | ERRWRAP2(_self_->setNrFeeds(nr_feeds));
| 44907 | Py_RETURN_NONE; |  | 44859 | Py_RETURN_NONE;
| 44908 | } |  | 44860 | }
| 44909 |  |  | 44861 |
| 44910 | return NULL; |  | 44862 | return NULL;
| 44911 | } |  | 44863 | }
| 44912 |  |  | 44864 |
| 44913 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setNrGainsFilteringIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44865 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setNrGainsFilteringIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 44914 | { |  | 44866 | {
| 44915 | using namespace cv::detail; |  | 44867 | using namespace cv::detail;
| 44916 |  |  | 44868 |
| 44917 |  |  | 44869 |
| 44918 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44870 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44919 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44871 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44920 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44872 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44921 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44873 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44922 | PyObject* pyobj_nr_iterations = NULL; |  | 44874 | PyObject* pyobj_nr_iterations = NULL;
| 44923 | int nr_iterations=0; |  | 44875 | int nr_iterations=0;
| 44924 |  |  | 44876 |
| 44925 | const char* keywords[] = { "nr_iterations", NULL }; |  | 44877 | const char* keywords[] = { "nr_iterations", NULL };
| 44926 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setNrGainsFilteringIterations", (char**)keywords, &pyobj_nr_iterations) && |  | 44878 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setNrGainsFilteringIterations", (char**)keywords, &pyobj_nr_iterations) &&
| 44927 | pyopencv_to_safe(pyobj_nr_iterations, nr_iterations, ArgInfo("nr_iterations", 0)) ) |  | 44879 | pyopencv_to_safe(pyobj_nr_iterations, nr_iterations, ArgInfo("nr_iterations", 0)) )
| 44928 | { |  | 44880 | {
| 44929 | ERRWRAP2(_self_->setNrGainsFilteringIterations(nr_iterations)); |  | 44881 | ERRWRAP2(_self_->setNrGainsFilteringIterations(nr_iterations));
| 44930 | Py_RETURN_NONE; |  | 44882 | Py_RETURN_NONE;
| 44931 | } |  | 44883 | }
| 44932 |  |  | 44884 |
| 44933 | return NULL; |  | 44885 | return NULL;
| 44934 | } |  | 44886 | }
| 44935 |  |  | 44887 |
| 44936 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 44888 | static PyObject* pyopencv_cv_detail_detail_BlocksCompensator_setSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 44937 | { |  | 44889 | {
| 44938 | using namespace cv::detail; |  | 44890 | using namespace cv::detail;
| 44939 |  |  | 44891 |
| 44940 |  |  | 44892 |
| 44941 | Ptr<cv::detail::BlocksCompensator> * self1 = 0; |  | 44893 | Ptr<cv::detail::BlocksCompensator> * self1 = 0;
| 44942 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1)) |  | 44894 | if (!pyopencv_detail_BlocksCompensator_getp(self, self1))
| 44943 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)"); |  | 44895 | return failmsgp("Incorrect type of self (must be 'detail_BlocksCompensator' or its derivative)");
| 44944 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1); |  | 44896 | Ptr<cv::detail::BlocksCompensator> _self_ = *(self1);
| 44945 | PyObject* pyobj_similarity_threshold = NULL; |  | 44897 | PyObject* pyobj_similarity_threshold = NULL;
| 44946 | double similarity_threshold=0; |  | 44898 | double similarity_threshold=0;
| 44947 |  |  | 44899 |
| 44948 | const char* keywords[] = { "similarity_threshold", NULL }; |  | 44900 | const char* keywords[] = { "similarity_threshold", NULL };
| 44949 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setSimilarityThreshold", (char**)keywords, &pyobj_similarity_threshold) && |  | 44901 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksCompensator.setSimilarityThreshold", (char**)keywords, &pyobj_similarity_threshold) &&
| 44950 | pyopencv_to_safe(pyobj_similarity_threshold, similarity_threshold, ArgInfo("similarity_threshold", 0)) ) |  | 44902 | pyopencv_to_safe(pyobj_similarity_threshold, similarity_threshold, ArgInfo("similarity_threshold", 0)) )
| 44951 | { |  | 44903 | {
| 44952 | ERRWRAP2(_self_->setSimilarityThreshold(similarity_threshold)); |  | 44904 | ERRWRAP2(_self_->setSimilarityThreshold(similarity_threshold));
| 44953 | Py_RETURN_NONE; |  | 44905 | Py_RETURN_NONE;
| 44954 | } |  | 44906 | }
| 44955 |  |  | 44907 |
| 44956 | return NULL; |  | 44908 | return NULL;
| 44957 | } |  | 44909 | }
| 44958 |  |  | 44910 |
| 44959 |  |  | 44911 |
| 44960 |  |  | 44912 |
| 44961 | // Tables (detail_BlocksCompensator) |  | 44913 | // Tables (detail_BlocksCompensator)
| 44962 |  |  | 44914 |
| 44963 | static PyGetSetDef pyopencv_detail_BlocksCompensator_getseters[] = |  | 44915 | static PyGetSetDef pyopencv_detail_BlocksCompensator_getseters[] =
| 44964 | { |  | 44916 | {
| 44965 | {NULL} /* Sentinel */ |  | 44917 | {NULL} /* Sentinel */
| 44966 | }; |  | 44918 | };
| 44967 |  |  | 44919 |
| 44968 | static PyMethodDef pyopencv_detail_BlocksCompensator_methods[] = |  | 44920 | static PyMethodDef pyopencv_detail_BlocksCompensator_methods[] =
| 44969 | { |  | 44921 | {
| 44970 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."}, |  | 44922 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."},
| 44971 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getBlockSize, 0), "getBlockSize() -> retval\n."}, |  | 44923 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getBlockSize, 0), "getBlockSize() -> retval\n."},
| 44972 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."}, |  | 44924 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."},
| 44973 | {"getNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getNrFeeds, 0), "getNrFeeds() -> retval\n."}, |  | 44925 | {"getNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getNrFeeds, 0), "getNrFeeds() -> retval\n."},
| 44974 | {"getNrGainsFilteringIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getNrGainsFilteringIterations, 0), "getNrGainsFilteringIterations() -> retval\n."}, |  | 44926 | {"getNrGainsFilteringIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getNrGainsFilteringIterations, 0), "getNrGainsFilteringIterations() -> retval\n."},
| 44975 | {"getSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getSimilarityThreshold, 0), "getSimilarityThreshold() -> retval\n."}, |  | 44927 | {"getSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_getSimilarityThreshold, 0), "getSimilarityThreshold() -> retval\n."},
| 44976 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setBlockSize, 0), "setBlockSize(width, height) -> None\n. \n\n\n\nsetBlockSize(size) -> None\n."}, |  | 44928 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setBlockSize, 0), "setBlockSize(width, height) -> None\n. \n\n\n\nsetBlockSize(size) -> None\n."},
| 44977 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."}, |  | 44929 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."},
| 44978 | {"setNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setNrFeeds, 0), "setNrFeeds(nr_feeds) -> None\n."}, |  | 44930 | {"setNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setNrFeeds, 0), "setNrFeeds(nr_feeds) -> None\n."},
| 44979 | {"setNrGainsFilteringIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setNrGainsFilteringIterations, 0), "setNrGainsFilteringIterations(nr_iterations) -> None\n."}, |  | 44931 | {"setNrGainsFilteringIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setNrGainsFilteringIterations, 0), "setNrGainsFilteringIterations(nr_iterations) -> None\n."},
| 44980 | {"setSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setSimilarityThreshold, 0), "setSimilarityThreshold(similarity_threshold) -> None\n."}, |  | 44932 | {"setSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksCompensator_setSimilarityThreshold, 0), "setSimilarityThreshold(similarity_threshold) -> None\n."},
| 44981 |  |  | 44933 |
| 44982 | {NULL, NULL} |  | 44934 | {NULL, NULL}
| 44983 | }; |  | 44935 | };
| 44984 |  |  | 44936 |
| 44985 | // Converter (detail_BlocksCompensator) |  | 44937 | // Converter (detail_BlocksCompensator)
| 44986 |  |  | 44938 |
| 44987 | template<> |  | 44939 | template<>
| 44988 | struct PyOpenCV_Converter< Ptr<cv::detail::BlocksCompensator> > |  | 44940 | struct PyOpenCV_Converter< Ptr<cv::detail::BlocksCompensator> >
| 44989 | { |  | 44941 | {
| 44990 | static PyObject* from(const Ptr<cv::detail::BlocksCompensator>& r) |  | 44942 | static PyObject* from(const Ptr<cv::detail::BlocksCompensator>& r)
| 44991 | { |  | 44943 | {
| 44992 | return pyopencv_detail_BlocksCompensator_Instance(r); |  | 44944 | return pyopencv_detail_BlocksCompensator_Instance(r);
| 44993 | } |  | 44945 | }
| 44994 | static bool to(PyObject* src, Ptr<cv::detail::BlocksCompensator>& dst, const ArgInfo& info) |  | 44946 | static bool to(PyObject* src, Ptr<cv::detail::BlocksCompensator>& dst, const ArgInfo& info)
| 44995 | { |  | 44947 | {
| 44996 | if(!src || src == Py_None) |  | 44948 | if(!src || src == Py_None)
| 44997 | return true; |  | 44949 | return true;
| 44998 | Ptr<cv::detail::BlocksCompensator> * dst_; |  | 44950 | Ptr<cv::detail::BlocksCompensator> * dst_;
| 44999 | if (pyopencv_detail_BlocksCompensator_getp(src, dst_)) |  | 44951 | if (pyopencv_detail_BlocksCompensator_getp(src, dst_))
| 45000 | { |  | 44952 | {
| 45001 | dst = *dst_; |  | 44953 | dst = *dst_;
| 45002 | return true; |  | 44954 | return true;
| 45003 | } |  | 44955 | }
| 45004 |  |  | 44956 |
| 45005 | failmsg("Expected Ptr<cv::detail::BlocksCompensator> for argument '%s'", info.name); |  | 44957 | failmsg("Expected Ptr<cv::detail::BlocksCompensator> for argument '%s'", info.name);
| 45006 | return false; |  | 44958 | return false;
| 45007 | } |  | 44959 | }
| 45008 | }; |  | 44960 | };
| 45009 |  |  | 44961 |
| 45010 | //================================================================================ |  | 44962 | //================================================================================
| 45011 | // detail_BlocksGainCompensator (Generic) |  | 44963 | // detail_BlocksGainCompensator (Generic)
| 45012 | //================================================================================ |  | 44964 | //================================================================================
| 45013 |  |  | 44965 |
| 45014 | // GetSet (detail_BlocksGainCompensator) |  | 44966 | // GetSet (detail_BlocksGainCompensator)
| 45015 |  |  | 44967 |
| 45016 |  |  | 44968 |
| 45017 |  |  | 44969 |
| 45018 | // Methods (detail_BlocksGainCompensator) |  | 44970 | // Methods (detail_BlocksGainCompensator)
| 45019 |  |  | 44971 |
| 45020 | static int pyopencv_cv_detail_detail_BlocksGainCompensator_BlocksGainCompensator(pyopencv_detail_BlocksGainCompensator_t* self, PyObject* py_args, PyObject* kw) |  | 44972 | static int pyopencv_cv_detail_detail_BlocksGainCompensator_BlocksGainCompensator(pyopencv_detail_BlocksGainCompensator_t* self, PyObject* py_args, PyObject* kw)
| 45021 | { |  | 44973 | {
| 45022 | using namespace cv::detail; |  | 44974 | using namespace cv::detail;
| 45023 |  |  | 44975 |
| 45024 | pyPrepareArgumentConversionErrorsStorage(2); |  | 44976 | pyPrepareArgumentConversionErrorsStorage(2);
| 45025 |  |  | 44977 |
| 45026 | { |  | 44978 | {
| 45027 | PyObject* pyobj_bl_width = NULL; |  | 44979 | PyObject* pyobj_bl_width = NULL;
| 45028 | int bl_width=32; |  | 44980 | int bl_width=32;
| 45029 | PyObject* pyobj_bl_height = NULL; |  | 44981 | PyObject* pyobj_bl_height = NULL;
| 45030 | int bl_height=32; |  | 44982 | int bl_height=32;
| 45031 |  |  | 44983 |
| 45032 | const char* keywords[] = { "bl_width", "bl_height", NULL }; |  | 44984 | const char* keywords[] = { "bl_width", "bl_height", NULL };
| 45033 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:BlocksGainCompensator", (char**)keywords, &pyobj_bl_width, &pyobj_bl_height) && |  | 44985 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:BlocksGainCompensator", (char**)keywords, &pyobj_bl_width, &pyobj_bl_height) &&
| 45034 | pyopencv_to_safe(pyobj_bl_width, bl_width, ArgInfo("bl_width", 0)) && |  | 44986 | pyopencv_to_safe(pyobj_bl_width, bl_width, ArgInfo("bl_width", 0)) &&
| 45035 | pyopencv_to_safe(pyobj_bl_height, bl_height, ArgInfo("bl_height", 0)) ) |  | 44987 | pyopencv_to_safe(pyobj_bl_height, bl_height, ArgInfo("bl_height", 0)) )
| 45036 | { |  | 44988 | {
| 45037 | new (&(self->v)) Ptr<cv::detail::BlocksGainCompensator>(); // init Ptr with placement new |  | 44989 | new (&(self->v)) Ptr<cv::detail::BlocksGainCompensator>(); // init Ptr with placement new
| 45038 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BlocksGainCompensator(bl_width, bl_height))); |  | 44990 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BlocksGainCompensator(bl_width, bl_height)));
| 45039 | return 0; |  | 44991 | return 0;
| 45040 | } |  | 44992 | }
| 45041 |  |  | 44993 |
| 45042 |  |  | 44994 |
| 45043 | pyPopulateArgumentConversionErrors(); |  | 44995 | pyPopulateArgumentConversionErrors();
| 45044 | } |  | 44996 | }
| 45045 |  |  | 44997 |
| 45046 |  |  | 44998 |
| 45047 | { |  | 44999 | {
| 45048 | PyObject* pyobj_bl_width = NULL; |  | 45000 | PyObject* pyobj_bl_width = NULL;
| 45049 | int bl_width=0; |  | 45001 | int bl_width=0;
| 45050 | PyObject* pyobj_bl_height = NULL; |  | 45002 | PyObject* pyobj_bl_height = NULL;
| 45051 | int bl_height=0; |  | 45003 | int bl_height=0;
| 45052 | PyObject* pyobj_nr_feeds = NULL; |  | 45004 | PyObject* pyobj_nr_feeds = NULL;
| 45053 | int nr_feeds=0; |  | 45005 | int nr_feeds=0;
| 45054 |  |  | 45006 |
| 45055 | const char* keywords[] = { "bl_width", "bl_height", "nr_feeds", NULL }; |  | 45007 | const char* keywords[] = { "bl_width", "bl_height", "nr_feeds", NULL };
| 45056 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:BlocksGainCompensator", (char**)keywords, &pyobj_bl_width, &pyobj_bl_height, &pyobj_nr_feeds) && |  | 45008 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:BlocksGainCompensator", (char**)keywords, &pyobj_bl_width, &pyobj_bl_height, &pyobj_nr_feeds) &&
| 45057 | pyopencv_to_safe(pyobj_bl_width, bl_width, ArgInfo("bl_width", 0)) && |  | 45009 | pyopencv_to_safe(pyobj_bl_width, bl_width, ArgInfo("bl_width", 0)) &&
| 45058 | pyopencv_to_safe(pyobj_bl_height, bl_height, ArgInfo("bl_height", 0)) && |  | 45010 | pyopencv_to_safe(pyobj_bl_height, bl_height, ArgInfo("bl_height", 0)) &&
| 45059 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) ) |  | 45011 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) )
| 45060 | { |  | 45012 | {
| 45061 | new (&(self->v)) Ptr<cv::detail::BlocksGainCompensator>(); // init Ptr with placement new |  | 45013 | new (&(self->v)) Ptr<cv::detail::BlocksGainCompensator>(); // init Ptr with placement new
| 45062 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BlocksGainCompensator(bl_width, bl_height, nr_feeds))); |  | 45014 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BlocksGainCompensator(bl_width, bl_height, nr_feeds)));
| 45063 | return 0; |  | 45015 | return 0;
| 45064 | } |  | 45016 | }
| 45065 |  |  | 45017 |
| 45066 |  |  | 45018 |
| 45067 | pyPopulateArgumentConversionErrors(); |  | 45019 | pyPopulateArgumentConversionErrors();
| 45068 | } |  | 45020 | }
| 45069 | pyRaiseCVOverloadException("BlocksGainCompensator"); |  | 45021 | pyRaiseCVOverloadException("BlocksGainCompensator");
| 45070 |  |  | 45022 |
| 45071 | return -1; |  | 45023 | return -1;
| 45072 | } |  | 45024 | }
| 45073 |  |  | 45025 |
| 45074 | static PyObject* pyopencv_cv_detail_detail_BlocksGainCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45026 | static PyObject* pyopencv_cv_detail_detail_BlocksGainCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 45075 | { |  | 45027 | {
| 45076 | using namespace cv::detail; |  | 45028 | using namespace cv::detail;
| 45077 |  |  | 45029 |
| 45078 |  |  | 45030 |
| 45079 | Ptr<cv::detail::BlocksGainCompensator> * self1 = 0; |  | 45031 | Ptr<cv::detail::BlocksGainCompensator> * self1 = 0;
| 45080 | if (!pyopencv_detail_BlocksGainCompensator_getp(self, self1)) |  | 45032 | if (!pyopencv_detail_BlocksGainCompensator_getp(self, self1))
| 45081 | return failmsgp("Incorrect type of self (must be 'detail_BlocksGainCompensator' or its derivative)"); |  | 45033 | return failmsgp("Incorrect type of self (must be 'detail_BlocksGainCompensator' or its derivative)");
| 45082 | Ptr<cv::detail::BlocksGainCompensator> _self_ = *(self1); |  | 45034 | Ptr<cv::detail::BlocksGainCompensator> _self_ = *(self1);
| 45083 | pyPrepareArgumentConversionErrorsStorage(2); |  | 45035 | pyPrepareArgumentConversionErrorsStorage(2);
| 45084 |  |  | 45036 |
| 45085 | { |  | 45037 | {
| 45086 | PyObject* pyobj_index = NULL; |  | 45038 | PyObject* pyobj_index = NULL;
| 45087 | int index=0; |  | 45039 | int index=0;
| 45088 | PyObject* pyobj_corner = NULL; |  | 45040 | PyObject* pyobj_corner = NULL;
| 45089 | Point corner; |  | 45041 | Point corner;
| 45090 | PyObject* pyobj_image = NULL; |  | 45042 | PyObject* pyobj_image = NULL;
| 45091 | Mat image; |  | 45043 | Mat image;
| 45092 | PyObject* pyobj_mask = NULL; |  | 45044 | PyObject* pyobj_mask = NULL;
| 45093 | Mat mask; |  | 45045 | Mat mask;
| 45094 |  |  | 45046 |
| 45095 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 45047 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 45096 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksGainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 45048 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksGainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 45097 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 45049 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 45098 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 45050 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 45099 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 45051 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 45100 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 45052 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 45101 | { |  | 45053 | {
| 45102 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 45054 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 45103 | return pyopencv_from(image); |  | 45055 | return pyopencv_from(image);
| 45104 | } |  | 45056 | }
| 45105 |  |  | 45057 |
| 45106 |  |  | 45058 |
| 45107 | pyPopulateArgumentConversionErrors(); |  | 45059 | pyPopulateArgumentConversionErrors();
| 45108 | } |  | 45060 | }
| 45109 |  |  | 45061 |
| 45110 |  |  | 45062 |
| 45111 | { |  | 45063 | {
| 45112 | PyObject* pyobj_index = NULL; |  | 45064 | PyObject* pyobj_index = NULL;
| 45113 | int index=0; |  | 45065 | int index=0;
| 45114 | PyObject* pyobj_corner = NULL; |  | 45066 | PyObject* pyobj_corner = NULL;
| 45115 | Point corner; |  | 45067 | Point corner;
| 45116 | PyObject* pyobj_image = NULL; |  | 45068 | PyObject* pyobj_image = NULL;
| 45117 | UMat image; |  | 45069 | UMat image;
| 45118 | PyObject* pyobj_mask = NULL; |  | 45070 | PyObject* pyobj_mask = NULL;
| 45119 | UMat mask; |  | 45071 | UMat mask;
| 45120 |  |  | 45072 |
| 45121 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 45073 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 45122 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksGainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 45074 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_BlocksGainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 45123 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 45075 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 45124 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 45076 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 45125 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 45077 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 45126 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 45078 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 45127 | { |  | 45079 | {
| 45128 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 45080 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 45129 | return pyopencv_from(image); |  | 45081 | return pyopencv_from(image);
| 45130 | } |  | 45082 | }
| 45131 |  |  | 45083 |
| 45132 |  |  | 45084 |
| 45133 | pyPopulateArgumentConversionErrors(); |  | 45085 | pyPopulateArgumentConversionErrors();
| 45134 | } |  | 45086 | }
| 45135 | pyRaiseCVOverloadException("apply"); |  | 45087 | pyRaiseCVOverloadException("apply");
| 45136 |  |  | 45088 |
| 45137 | return NULL; |  | 45089 | return NULL;
| 45138 | } |  | 45090 | }
| 45139 |  |  | 45091 |
| 45140 | static PyObject* pyopencv_cv_detail_detail_BlocksGainCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45092 | static PyObject* pyopencv_cv_detail_detail_BlocksGainCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 45141 | { |  | 45093 | {
| 45142 | using namespace cv::detail; |  | 45094 | using namespace cv::detail;
| 45143 |  |  | 45095 |
| 45144 |  |  | 45096 |
| 45145 | Ptr<cv::detail::BlocksGainCompensator> * self1 = 0; |  | 45097 | Ptr<cv::detail::BlocksGainCompensator> * self1 = 0;
| 45146 | if (!pyopencv_detail_BlocksGainCompensator_getp(self, self1)) |  | 45098 | if (!pyopencv_detail_BlocksGainCompensator_getp(self, self1))
| 45147 | return failmsgp("Incorrect type of self (must be 'detail_BlocksGainCompensator' or its derivative)"); |  | 45099 | return failmsgp("Incorrect type of self (must be 'detail_BlocksGainCompensator' or its derivative)");
| 45148 | Ptr<cv::detail::BlocksGainCompensator> _self_ = *(self1); |  | 45100 | Ptr<cv::detail::BlocksGainCompensator> _self_ = *(self1);
| 45149 | PyObject* pyobj_umv = NULL; |  | 45101 | PyObject* pyobj_umv = NULL;
| 45150 | vector_Mat umv; |  | 45102 | vector_Mat umv;
| 45151 |  |  | 45103 |
| 45152 | const char* keywords[] = { "umv", NULL }; |  | 45104 | const char* keywords[] = { "umv", NULL };
| 45153 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_BlocksGainCompensator.getMatGains", (char**)keywords, &pyobj_umv) && |  | 45105 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_BlocksGainCompensator.getMatGains", (char**)keywords, &pyobj_umv) &&
| 45154 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) ) |  | 45106 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) )
| 45155 | { |  | 45107 | {
| 45156 | ERRWRAP2(_self_->getMatGains(umv)); |  | 45108 | ERRWRAP2(_self_->getMatGains(umv));
| 45157 | return pyopencv_from(umv); |  | 45109 | return pyopencv_from(umv);
| 45158 | } |  | 45110 | }
| 45159 |  |  | 45111 |
| 45160 | return NULL; |  | 45112 | return NULL;
| 45161 | } |  | 45113 | }
| 45162 |  |  | 45114 |
| 45163 | static PyObject* pyopencv_cv_detail_detail_BlocksGainCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45115 | static PyObject* pyopencv_cv_detail_detail_BlocksGainCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 45164 | { |  | 45116 | {
| 45165 | using namespace cv::detail; |  | 45117 | using namespace cv::detail;
| 45166 |  |  | 45118 |
| 45167 |  |  | 45119 |
| 45168 | Ptr<cv::detail::BlocksGainCompensator> * self1 = 0; |  | 45120 | Ptr<cv::detail::BlocksGainCompensator> * self1 = 0;
| 45169 | if (!pyopencv_detail_BlocksGainCompensator_getp(self, self1)) |  | 45121 | if (!pyopencv_detail_BlocksGainCompensator_getp(self, self1))
| 45170 | return failmsgp("Incorrect type of self (must be 'detail_BlocksGainCompensator' or its derivative)"); |  | 45122 | return failmsgp("Incorrect type of self (must be 'detail_BlocksGainCompensator' or its derivative)");
| 45171 | Ptr<cv::detail::BlocksGainCompensator> _self_ = *(self1); |  | 45123 | Ptr<cv::detail::BlocksGainCompensator> _self_ = *(self1);
| 45172 | PyObject* pyobj_umv = NULL; |  | 45124 | PyObject* pyobj_umv = NULL;
| 45173 | vector_Mat umv; |  | 45125 | vector_Mat umv;
| 45174 |  |  | 45126 |
| 45175 | const char* keywords[] = { "umv", NULL }; |  | 45127 | const char* keywords[] = { "umv", NULL };
| 45176 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksGainCompensator.setMatGains", (char**)keywords, &pyobj_umv) && |  | 45128 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BlocksGainCompensator.setMatGains", (char**)keywords, &pyobj_umv) &&
| 45177 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) ) |  | 45129 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) )
| 45178 | { |  | 45130 | {
| 45179 | ERRWRAP2(_self_->setMatGains(umv)); |  | 45131 | ERRWRAP2(_self_->setMatGains(umv));
| 45180 | Py_RETURN_NONE; |  | 45132 | Py_RETURN_NONE;
| 45181 | } |  | 45133 | }
| 45182 |  |  | 45134 |
| 45183 | return NULL; |  | 45135 | return NULL;
| 45184 | } |  | 45136 | }
| 45185 |  |  | 45137 |
| 45186 |  |  | 45138 |
| 45187 |  |  | 45139 |
| 45188 | // Tables (detail_BlocksGainCompensator) |  | 45140 | // Tables (detail_BlocksGainCompensator)
| 45189 |  |  | 45141 |
| 45190 | static PyGetSetDef pyopencv_detail_BlocksGainCompensator_getseters[] = |  | 45142 | static PyGetSetDef pyopencv_detail_BlocksGainCompensator_getseters[] =
| 45191 | { |  | 45143 | {
| 45192 | {NULL} /* Sentinel */ |  | 45144 | {NULL} /* Sentinel */
| 45193 | }; |  | 45145 | };
| 45194 |  |  | 45146 |
| 45195 | static PyMethodDef pyopencv_detail_BlocksGainCompensator_methods[] = |  | 45147 | static PyMethodDef pyopencv_detail_BlocksGainCompensator_methods[] =
| 45196 | { |  | 45148 | {
| 45197 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksGainCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."}, |  | 45149 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksGainCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."},
| 45198 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksGainCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."}, |  | 45150 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksGainCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."},
| 45199 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksGainCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."}, |  | 45151 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BlocksGainCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."},
| 45200 |  |  | 45152 |
| 45201 | {NULL, NULL} |  | 45153 | {NULL, NULL}
| 45202 | }; |  | 45154 | };
| 45203 |  |  | 45155 |
| 45204 | // Converter (detail_BlocksGainCompensator) |  | 45156 | // Converter (detail_BlocksGainCompensator)
| 45205 |  |  | 45157 |
| 45206 | template<> |  | 45158 | template<>
| 45207 | struct PyOpenCV_Converter< Ptr<cv::detail::BlocksGainCompensator> > |  | 45159 | struct PyOpenCV_Converter< Ptr<cv::detail::BlocksGainCompensator> >
| 45208 | { |  | 45160 | {
| 45209 | static PyObject* from(const Ptr<cv::detail::BlocksGainCompensator>& r) |  | 45161 | static PyObject* from(const Ptr<cv::detail::BlocksGainCompensator>& r)
| 45210 | { |  | 45162 | {
| 45211 | return pyopencv_detail_BlocksGainCompensator_Instance(r); |  | 45163 | return pyopencv_detail_BlocksGainCompensator_Instance(r);
| 45212 | } |  | 45164 | }
| 45213 | static bool to(PyObject* src, Ptr<cv::detail::BlocksGainCompensator>& dst, const ArgInfo& info) |  | 45165 | static bool to(PyObject* src, Ptr<cv::detail::BlocksGainCompensator>& dst, const ArgInfo& info)
| 45214 | { |  | 45166 | {
| 45215 | if(!src || src == Py_None) |  | 45167 | if(!src || src == Py_None)
| 45216 | return true; |  | 45168 | return true;
| 45217 | Ptr<cv::detail::BlocksGainCompensator> * dst_; |  | 45169 | Ptr<cv::detail::BlocksGainCompensator> * dst_;
| 45218 | if (pyopencv_detail_BlocksGainCompensator_getp(src, dst_)) |  | 45170 | if (pyopencv_detail_BlocksGainCompensator_getp(src, dst_))
| 45219 | { |  | 45171 | {
| 45220 | dst = *dst_; |  | 45172 | dst = *dst_;
| 45221 | return true; |  | 45173 | return true;
| 45222 | } |  | 45174 | }
| 45223 |  |  | 45175 |
| 45224 | failmsg("Expected Ptr<cv::detail::BlocksGainCompensator> for argument '%s'", info.name); |  | 45176 | failmsg("Expected Ptr<cv::detail::BlocksGainCompensator> for argument '%s'", info.name);
| 45225 | return false; |  | 45177 | return false;
| 45226 | } |  | 45178 | }
| 45227 | }; |  | 45179 | };
| 45228 |  |  | 45180 |
| 45229 | //================================================================================ |  | 45181 | //================================================================================
| 45230 | // detail_BundleAdjusterAffine (Generic) |  | 45182 | // detail_BundleAdjusterAffine (Generic)
| 45231 | //================================================================================ |  | 45183 | //================================================================================
| 45232 |  |  | 45184 |
| 45233 | // GetSet (detail_BundleAdjusterAffine) |  | 45185 | // GetSet (detail_BundleAdjusterAffine)
| 45234 |  |  | 45186 |
| 45235 |  |  | 45187 |
| 45236 |  |  | 45188 |
| 45237 | // Methods (detail_BundleAdjusterAffine) |  | 45189 | // Methods (detail_BundleAdjusterAffine)
| 45238 |  |  | 45190 |
| 45239 | static int pyopencv_cv_detail_detail_BundleAdjusterAffine_BundleAdjusterAffine(pyopencv_detail_BundleAdjusterAffine_t* self, PyObject* py_args, PyObject* kw) |  | 45191 | static int pyopencv_cv_detail_detail_BundleAdjusterAffine_BundleAdjusterAffine(pyopencv_detail_BundleAdjusterAffine_t* self, PyObject* py_args, PyObject* kw)
| 45240 | { |  | 45192 | {
| 45241 | using namespace cv::detail; |  | 45193 | using namespace cv::detail;
| 45242 |  |  | 45194 |
| 45243 |  |  | 45195 |
| 45244 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45196 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45245 | { |  | 45197 | {
| 45246 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterAffine>(); // init Ptr with placement new |  | 45198 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterAffine>(); // init Ptr with placement new
| 45247 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterAffine())); |  | 45199 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterAffine()));
| 45248 | return 0; |  | 45200 | return 0;
| 45249 | } |  | 45201 | }
| 45250 |  |  | 45202 |
| 45251 | return -1; |  | 45203 | return -1;
| 45252 | } |  | 45204 | }
| 45253 |  |  | 45205 |
| 45254 |  |  | 45206 |
| 45255 |  |  | 45207 |
| 45256 | // Tables (detail_BundleAdjusterAffine) |  | 45208 | // Tables (detail_BundleAdjusterAffine)
| 45257 |  |  | 45209 |
| 45258 | static PyGetSetDef pyopencv_detail_BundleAdjusterAffine_getseters[] = |  | 45210 | static PyGetSetDef pyopencv_detail_BundleAdjusterAffine_getseters[] =
| 45259 | { |  | 45211 | {
| 45260 | {NULL} /* Sentinel */ |  | 45212 | {NULL} /* Sentinel */
| 45261 | }; |  | 45213 | };
| 45262 |  |  | 45214 |
| 45263 | static PyMethodDef pyopencv_detail_BundleAdjusterAffine_methods[] = |  | 45215 | static PyMethodDef pyopencv_detail_BundleAdjusterAffine_methods[] =
| 45264 | { |  | 45216 | {
| 45265 |  |  | 45217 |
| 45266 | {NULL, NULL} |  | 45218 | {NULL, NULL}
| 45267 | }; |  | 45219 | };
| 45268 |  |  | 45220 |
| 45269 | // Converter (detail_BundleAdjusterAffine) |  | 45221 | // Converter (detail_BundleAdjusterAffine)
| 45270 |  |  | 45222 |
| 45271 | template<> |  | 45223 | template<>
| 45272 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterAffine> > |  | 45224 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterAffine> >
| 45273 | { |  | 45225 | {
| 45274 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterAffine>& r) |  | 45226 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterAffine>& r)
| 45275 | { |  | 45227 | {
| 45276 | return pyopencv_detail_BundleAdjusterAffine_Instance(r); |  | 45228 | return pyopencv_detail_BundleAdjusterAffine_Instance(r);
| 45277 | } |  | 45229 | }
| 45278 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterAffine>& dst, const ArgInfo& info) |  | 45230 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterAffine>& dst, const ArgInfo& info)
| 45279 | { |  | 45231 | {
| 45280 | if(!src || src == Py_None) |  | 45232 | if(!src || src == Py_None)
| 45281 | return true; |  | 45233 | return true;
| 45282 | Ptr<cv::detail::BundleAdjusterAffine> * dst_; |  | 45234 | Ptr<cv::detail::BundleAdjusterAffine> * dst_;
| 45283 | if (pyopencv_detail_BundleAdjusterAffine_getp(src, dst_)) |  | 45235 | if (pyopencv_detail_BundleAdjusterAffine_getp(src, dst_))
| 45284 | { |  | 45236 | {
| 45285 | dst = *dst_; |  | 45237 | dst = *dst_;
| 45286 | return true; |  | 45238 | return true;
| 45287 | } |  | 45239 | }
| 45288 |  |  | 45240 |
| 45289 | failmsg("Expected Ptr<cv::detail::BundleAdjusterAffine> for argument '%s'", info.name); |  | 45241 | failmsg("Expected Ptr<cv::detail::BundleAdjusterAffine> for argument '%s'", info.name);
| 45290 | return false; |  | 45242 | return false;
| 45291 | } |  | 45243 | }
| 45292 | }; |  | 45244 | };
| 45293 |  |  | 45245 |
| 45294 | //================================================================================ |  | 45246 | //================================================================================
| 45295 | // detail_BundleAdjusterAffinePartial (Generic) |  | 45247 | // detail_BundleAdjusterAffinePartial (Generic)
| 45296 | //================================================================================ |  | 45248 | //================================================================================
| 45297 |  |  | 45249 |
| 45298 | // GetSet (detail_BundleAdjusterAffinePartial) |  | 45250 | // GetSet (detail_BundleAdjusterAffinePartial)
| 45299 |  |  | 45251 |
| 45300 |  |  | 45252 |
| 45301 |  |  | 45253 |
| 45302 | // Methods (detail_BundleAdjusterAffinePartial) |  | 45254 | // Methods (detail_BundleAdjusterAffinePartial)
| 45303 |  |  | 45255 |
| 45304 | static int pyopencv_cv_detail_detail_BundleAdjusterAffinePartial_BundleAdjusterAffinePartial(pyopencv_detail_BundleAdjusterAffinePartial_t* self, PyObject* py_args, PyObject* kw) |  | 45256 | static int pyopencv_cv_detail_detail_BundleAdjusterAffinePartial_BundleAdjusterAffinePartial(pyopencv_detail_BundleAdjusterAffinePartial_t* self, PyObject* py_args, PyObject* kw)
| 45305 | { |  | 45257 | {
| 45306 | using namespace cv::detail; |  | 45258 | using namespace cv::detail;
| 45307 |  |  | 45259 |
| 45308 |  |  | 45260 |
| 45309 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45261 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45310 | { |  | 45262 | {
| 45311 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterAffinePartial>(); // init Ptr with placement new |  | 45263 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterAffinePartial>(); // init Ptr with placement new
| 45312 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterAffinePartial())); |  | 45264 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterAffinePartial()));
| 45313 | return 0; |  | 45265 | return 0;
| 45314 | } |  | 45266 | }
| 45315 |  |  | 45267 |
| 45316 | return -1; |  | 45268 | return -1;
| 45317 | } |  | 45269 | }
| 45318 |  |  | 45270 |
| 45319 |  |  | 45271 |
| 45320 |  |  | 45272 |
| 45321 | // Tables (detail_BundleAdjusterAffinePartial) |  | 45273 | // Tables (detail_BundleAdjusterAffinePartial)
| 45322 |  |  | 45274 |
| 45323 | static PyGetSetDef pyopencv_detail_BundleAdjusterAffinePartial_getseters[] = |  | 45275 | static PyGetSetDef pyopencv_detail_BundleAdjusterAffinePartial_getseters[] =
| 45324 | { |  | 45276 | {
| 45325 | {NULL} /* Sentinel */ |  | 45277 | {NULL} /* Sentinel */
| 45326 | }; |  | 45278 | };
| 45327 |  |  | 45279 |
| 45328 | static PyMethodDef pyopencv_detail_BundleAdjusterAffinePartial_methods[] = |  | 45280 | static PyMethodDef pyopencv_detail_BundleAdjusterAffinePartial_methods[] =
| 45329 | { |  | 45281 | {
| 45330 |  |  | 45282 |
| 45331 | {NULL, NULL} |  | 45283 | {NULL, NULL}
| 45332 | }; |  | 45284 | };
| 45333 |  |  | 45285 |
| 45334 | // Converter (detail_BundleAdjusterAffinePartial) |  | 45286 | // Converter (detail_BundleAdjusterAffinePartial)
| 45335 |  |  | 45287 |
| 45336 | template<> |  | 45288 | template<>
| 45337 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterAffinePartial> > |  | 45289 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterAffinePartial> >
| 45338 | { |  | 45290 | {
| 45339 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterAffinePartial>& r) |  | 45291 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterAffinePartial>& r)
| 45340 | { |  | 45292 | {
| 45341 | return pyopencv_detail_BundleAdjusterAffinePartial_Instance(r); |  | 45293 | return pyopencv_detail_BundleAdjusterAffinePartial_Instance(r);
| 45342 | } |  | 45294 | }
| 45343 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterAffinePartial>& dst, const ArgInfo& info) |  | 45295 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterAffinePartial>& dst, const ArgInfo& info)
| 45344 | { |  | 45296 | {
| 45345 | if(!src || src == Py_None) |  | 45297 | if(!src || src == Py_None)
| 45346 | return true; |  | 45298 | return true;
| 45347 | Ptr<cv::detail::BundleAdjusterAffinePartial> * dst_; |  | 45299 | Ptr<cv::detail::BundleAdjusterAffinePartial> * dst_;
| 45348 | if (pyopencv_detail_BundleAdjusterAffinePartial_getp(src, dst_)) |  | 45300 | if (pyopencv_detail_BundleAdjusterAffinePartial_getp(src, dst_))
| 45349 | { |  | 45301 | {
| 45350 | dst = *dst_; |  | 45302 | dst = *dst_;
| 45351 | return true; |  | 45303 | return true;
| 45352 | } |  | 45304 | }
| 45353 |  |  | 45305 |
| 45354 | failmsg("Expected Ptr<cv::detail::BundleAdjusterAffinePartial> for argument '%s'", info.name); |  | 45306 | failmsg("Expected Ptr<cv::detail::BundleAdjusterAffinePartial> for argument '%s'", info.name);
| 45355 | return false; |  | 45307 | return false;
| 45356 | } |  | 45308 | }
| 45357 | }; |  | 45309 | };
| 45358 |  |  | 45310 |
| 45359 | //================================================================================ |  | 45311 | //================================================================================
| 45360 | // detail_BundleAdjusterBase (Generic) |  | 45312 | // detail_BundleAdjusterBase (Generic)
| 45361 | //================================================================================ |  | 45313 | //================================================================================
| 45362 |  |  | 45314 |
| 45363 | // GetSet (detail_BundleAdjusterBase) |  | 45315 | // GetSet (detail_BundleAdjusterBase)
| 45364 |  |  | 45316 |
| 45365 |  |  | 45317 |
| 45366 |  |  | 45318 |
| 45367 | // Methods (detail_BundleAdjusterBase) |  | 45319 | // Methods (detail_BundleAdjusterBase)
| 45368 |  |  | 45320 |
| 45369 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_confThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45321 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_confThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 45370 | { |  | 45322 | {
| 45371 | using namespace cv::detail; |  | 45323 | using namespace cv::detail;
| 45372 |  |  | 45324 |
| 45373 |  |  | 45325 |
| 45374 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0; |  | 45326 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0;
| 45375 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1)) |  | 45327 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1))
| 45376 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)"); |  | 45328 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)");
| 45377 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1); |  | 45329 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1);
| 45378 | double retval; |  | 45330 | double retval;
| 45379 |  |  | 45331 |
| 45380 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45332 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45381 | { |  | 45333 | {
| 45382 | ERRWRAP2(retval = _self_->confThresh()); |  | 45334 | ERRWRAP2(retval = _self_->confThresh());
| 45383 | return pyopencv_from(retval); |  | 45335 | return pyopencv_from(retval);
| 45384 | } |  | 45336 | }
| 45385 |  |  | 45337 |
| 45386 | return NULL; |  | 45338 | return NULL;
| 45387 | } |  | 45339 | }
| 45388 |  |  | 45340 |
| 45389 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_refinementMask(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45341 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_refinementMask(PyObject* self, PyObject* py_args, PyObject* kw)
| 45390 | { |  | 45342 | {
| 45391 | using namespace cv::detail; |  | 45343 | using namespace cv::detail;
| 45392 |  |  | 45344 |
| 45393 |  |  | 45345 |
| 45394 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0; |  | 45346 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0;
| 45395 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1)) |  | 45347 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1))
| 45396 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)"); |  | 45348 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)");
| 45397 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1); |  | 45349 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1);
| 45398 | Mat retval; |  | 45350 | Mat retval;
| 45399 |  |  | 45351 |
| 45400 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45352 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45401 | { |  | 45353 | {
| 45402 | ERRWRAP2(retval = _self_->refinementMask()); |  | 45354 | ERRWRAP2(retval = _self_->refinementMask());
| 45403 | return pyopencv_from(retval); |  | 45355 | return pyopencv_from(retval);
| 45404 | } |  | 45356 | }
| 45405 |  |  | 45357 |
| 45406 | return NULL; |  | 45358 | return NULL;
| 45407 | } |  | 45359 | }
| 45408 |  |  | 45360 |
| 45409 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_setConfThresh(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45361 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_setConfThresh(PyObject* self, PyObject* py_args, PyObject* kw)
| 45410 | { |  | 45362 | {
| 45411 | using namespace cv::detail; |  | 45363 | using namespace cv::detail;
| 45412 |  |  | 45364 |
| 45413 |  |  | 45365 |
| 45414 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0; |  | 45366 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0;
| 45415 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1)) |  | 45367 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1))
| 45416 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)"); |  | 45368 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)");
| 45417 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1); |  | 45369 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1);
| 45418 | PyObject* pyobj_conf_thresh = NULL; |  | 45370 | PyObject* pyobj_conf_thresh = NULL;
| 45419 | double conf_thresh=0; |  | 45371 | double conf_thresh=0;
| 45420 |  |  | 45372 |
| 45421 | const char* keywords[] = { "conf_thresh", NULL }; |  | 45373 | const char* keywords[] = { "conf_thresh", NULL };
| 45422 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BundleAdjusterBase.setConfThresh", (char**)keywords, &pyobj_conf_thresh) && |  | 45374 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BundleAdjusterBase.setConfThresh", (char**)keywords, &pyobj_conf_thresh) &&
| 45423 | pyopencv_to_safe(pyobj_conf_thresh, conf_thresh, ArgInfo("conf_thresh", 0)) ) |  | 45375 | pyopencv_to_safe(pyobj_conf_thresh, conf_thresh, ArgInfo("conf_thresh", 0)) )
| 45424 | { |  | 45376 | {
| 45425 | ERRWRAP2(_self_->setConfThresh(conf_thresh)); |  | 45377 | ERRWRAP2(_self_->setConfThresh(conf_thresh));
| 45426 | Py_RETURN_NONE; |  | 45378 | Py_RETURN_NONE;
| 45427 | } |  | 45379 | }
| 45428 |  |  | 45380 |
| 45429 | return NULL; |  | 45381 | return NULL;
| 45430 | } |  | 45382 | }
| 45431 |  |  | 45383 |
| 45432 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_setRefinementMask(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45384 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_setRefinementMask(PyObject* self, PyObject* py_args, PyObject* kw)
| 45433 | { |  | 45385 | {
| 45434 | using namespace cv::detail; |  | 45386 | using namespace cv::detail;
| 45435 |  |  | 45387 |
| 45436 |  |  | 45388 |
| 45437 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0; |  | 45389 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0;
| 45438 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1)) |  | 45390 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1))
| 45439 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)"); |  | 45391 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)");
| 45440 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1); |  | 45392 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1);
| 45441 | PyObject* pyobj_mask = NULL; |  | 45393 | PyObject* pyobj_mask = NULL;
| 45442 | Mat mask; |  | 45394 | Mat mask;
| 45443 |  |  | 45395 |
| 45444 | const char* keywords[] = { "mask", NULL }; |  | 45396 | const char* keywords[] = { "mask", NULL };
| 45445 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BundleAdjusterBase.setRefinementMask", (char**)keywords, &pyobj_mask) && |  | 45397 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BundleAdjusterBase.setRefinementMask", (char**)keywords, &pyobj_mask) &&
| 45446 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 45398 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 45447 | { |  | 45399 | {
| 45448 | ERRWRAP2(_self_->setRefinementMask(mask)); |  | 45400 | ERRWRAP2(_self_->setRefinementMask(mask));
| 45449 | Py_RETURN_NONE; |  | 45401 | Py_RETURN_NONE;
| 45450 | } |  | 45402 | }
| 45451 |  |  | 45403 |
| 45452 | return NULL; |  | 45404 | return NULL;
| 45453 | } |  | 45405 | }
| 45454 |  |  | 45406 |
| 45455 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45407 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 45456 | { |  | 45408 | {
| 45457 | using namespace cv::detail; |  | 45409 | using namespace cv::detail;
| 45458 |  |  | 45410 |
| 45459 |  |  | 45411 |
| 45460 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0; |  | 45412 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0;
| 45461 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1)) |  | 45413 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1))
| 45462 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)"); |  | 45414 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)");
| 45463 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1); |  | 45415 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1);
| 45464 | PyObject* pyobj_term_criteria = NULL; |  | 45416 | PyObject* pyobj_term_criteria = NULL;
| 45465 | TermCriteria term_criteria; |  | 45417 | TermCriteria term_criteria;
| 45466 |  |  | 45418 |
| 45467 | const char* keywords[] = { "term_criteria", NULL }; |  | 45419 | const char* keywords[] = { "term_criteria", NULL };
| 45468 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BundleAdjusterBase.setTermCriteria", (char**)keywords, &pyobj_term_criteria) && |  | 45420 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_BundleAdjusterBase.setTermCriteria", (char**)keywords, &pyobj_term_criteria) &&
| 45469 | pyopencv_to_safe(pyobj_term_criteria, term_criteria, ArgInfo("term_criteria", 0)) ) |  | 45421 | pyopencv_to_safe(pyobj_term_criteria, term_criteria, ArgInfo("term_criteria", 0)) )
| 45470 | { |  | 45422 | {
| 45471 | ERRWRAP2(_self_->setTermCriteria(term_criteria)); |  | 45423 | ERRWRAP2(_self_->setTermCriteria(term_criteria));
| 45472 | Py_RETURN_NONE; |  | 45424 | Py_RETURN_NONE;
| 45473 | } |  | 45425 | }
| 45474 |  |  | 45426 |
| 45475 | return NULL; |  | 45427 | return NULL;
| 45476 | } |  | 45428 | }
| 45477 |  |  | 45429 |
| 45478 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_termCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45430 | static PyObject* pyopencv_cv_detail_detail_BundleAdjusterBase_termCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 45479 | { |  | 45431 | {
| 45480 | using namespace cv::detail; |  | 45432 | using namespace cv::detail;
| 45481 |  |  | 45433 |
| 45482 |  |  | 45434 |
| 45483 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0; |  | 45435 | Ptr<cv::detail::BundleAdjusterBase> * self1 = 0;
| 45484 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1)) |  | 45436 | if (!pyopencv_detail_BundleAdjusterBase_getp(self, self1))
| 45485 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)"); |  | 45437 | return failmsgp("Incorrect type of self (must be 'detail_BundleAdjusterBase' or its derivative)");
| 45486 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1); |  | 45438 | Ptr<cv::detail::BundleAdjusterBase> _self_ = *(self1);
| 45487 | TermCriteria retval; |  | 45439 | TermCriteria retval;
| 45488 |  |  | 45440 |
| 45489 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45441 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45490 | { |  | 45442 | {
| 45491 | ERRWRAP2(retval = _self_->termCriteria()); |  | 45443 | ERRWRAP2(retval = _self_->termCriteria());
| 45492 | return pyopencv_from(retval); |  | 45444 | return pyopencv_from(retval);
| 45493 | } |  | 45445 | }
| 45494 |  |  | 45446 |
| 45495 | return NULL; |  | 45447 | return NULL;
| 45496 | } |  | 45448 | }
| 45497 |  |  | 45449 |
| 45498 |  |  | 45450 |
| 45499 |  |  | 45451 |
| 45500 | // Tables (detail_BundleAdjusterBase) |  | 45452 | // Tables (detail_BundleAdjusterBase)
| 45501 |  |  | 45453 |
| 45502 | static PyGetSetDef pyopencv_detail_BundleAdjusterBase_getseters[] = |  | 45454 | static PyGetSetDef pyopencv_detail_BundleAdjusterBase_getseters[] =
| 45503 | { |  | 45455 | {
| 45504 | {NULL} /* Sentinel */ |  | 45456 | {NULL} /* Sentinel */
| 45505 | }; |  | 45457 | };
| 45506 |  |  | 45458 |
| 45507 | static PyMethodDef pyopencv_detail_BundleAdjusterBase_methods[] = |  | 45459 | static PyMethodDef pyopencv_detail_BundleAdjusterBase_methods[] =
| 45508 | { |  | 45460 | {
| 45509 | {"confThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_confThresh, 0), "confThresh() -> retval\n."}, |  | 45461 | {"confThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_confThresh, 0), "confThresh() -> retval\n."},
| 45510 | {"refinementMask", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_refinementMask, 0), "refinementMask() -> retval\n."}, |  | 45462 | {"refinementMask", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_refinementMask, 0), "refinementMask() -> retval\n."},
| 45511 | {"setConfThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_setConfThresh, 0), "setConfThresh(conf_thresh) -> None\n."}, |  | 45463 | {"setConfThresh", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_setConfThresh, 0), "setConfThresh(conf_thresh) -> None\n."},
| 45512 | {"setRefinementMask", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_setRefinementMask, 0), "setRefinementMask(mask) -> None\n."}, |  | 45464 | {"setRefinementMask", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_setRefinementMask, 0), "setRefinementMask(mask) -> None\n."},
| 45513 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_setTermCriteria, 0), "setTermCriteria(term_criteria) -> None\n."}, |  | 45465 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_setTermCriteria, 0), "setTermCriteria(term_criteria) -> None\n."},
| 45514 | {"termCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_termCriteria, 0), "termCriteria() -> retval\n."}, |  | 45466 | {"termCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_BundleAdjusterBase_termCriteria, 0), "termCriteria() -> retval\n."},
| 45515 |  |  | 45467 |
| 45516 | {NULL, NULL} |  | 45468 | {NULL, NULL}
| 45517 | }; |  | 45469 | };
| 45518 |  |  | 45470 |
| 45519 | // Converter (detail_BundleAdjusterBase) |  | 45471 | // Converter (detail_BundleAdjusterBase)
| 45520 |  |  | 45472 |
| 45521 | template<> |  | 45473 | template<>
| 45522 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterBase> > |  | 45474 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterBase> >
| 45523 | { |  | 45475 | {
| 45524 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterBase>& r) |  | 45476 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterBase>& r)
| 45525 | { |  | 45477 | {
| 45526 | return pyopencv_detail_BundleAdjusterBase_Instance(r); |  | 45478 | return pyopencv_detail_BundleAdjusterBase_Instance(r);
| 45527 | } |  | 45479 | }
| 45528 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterBase>& dst, const ArgInfo& info) |  | 45480 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterBase>& dst, const ArgInfo& info)
| 45529 | { |  | 45481 | {
| 45530 | if(!src || src == Py_None) |  | 45482 | if(!src || src == Py_None)
| 45531 | return true; |  | 45483 | return true;
| 45532 | Ptr<cv::detail::BundleAdjusterBase> * dst_; |  | 45484 | Ptr<cv::detail::BundleAdjusterBase> * dst_;
| 45533 | if (pyopencv_detail_BundleAdjusterBase_getp(src, dst_)) |  | 45485 | if (pyopencv_detail_BundleAdjusterBase_getp(src, dst_))
| 45534 | { |  | 45486 | {
| 45535 | dst = *dst_; |  | 45487 | dst = *dst_;
| 45536 | return true; |  | 45488 | return true;
| 45537 | } |  | 45489 | }
| 45538 |  |  | 45490 |
| 45539 | failmsg("Expected Ptr<cv::detail::BundleAdjusterBase> for argument '%s'", info.name); |  | 45491 | failmsg("Expected Ptr<cv::detail::BundleAdjusterBase> for argument '%s'", info.name);
| 45540 | return false; |  | 45492 | return false;
| 45541 | } |  | 45493 | }
| 45542 | }; |  | 45494 | };
| 45543 |  |  | 45495 |
| 45544 | //================================================================================ |  | 45496 | //================================================================================
| 45545 | // detail_BundleAdjusterRay (Generic) |  | 45497 | // detail_BundleAdjusterRay (Generic)
| 45546 | //================================================================================ |  | 45498 | //================================================================================
| 45547 |  |  | 45499 |
| 45548 | // GetSet (detail_BundleAdjusterRay) |  | 45500 | // GetSet (detail_BundleAdjusterRay)
| 45549 |  |  | 45501 |
| 45550 |  |  | 45502 |
| 45551 |  |  | 45503 |
| 45552 | // Methods (detail_BundleAdjusterRay) |  | 45504 | // Methods (detail_BundleAdjusterRay)
| 45553 |  |  | 45505 |
| 45554 | static int pyopencv_cv_detail_detail_BundleAdjusterRay_BundleAdjusterRay(pyopencv_detail_BundleAdjusterRay_t* self, PyObject* py_args, PyObject* kw) |  | 45506 | static int pyopencv_cv_detail_detail_BundleAdjusterRay_BundleAdjusterRay(pyopencv_detail_BundleAdjusterRay_t* self, PyObject* py_args, PyObject* kw)
| 45555 | { |  | 45507 | {
| 45556 | using namespace cv::detail; |  | 45508 | using namespace cv::detail;
| 45557 |  |  | 45509 |
| 45558 |  |  | 45510 |
| 45559 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45511 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45560 | { |  | 45512 | {
| 45561 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterRay>(); // init Ptr with placement new |  | 45513 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterRay>(); // init Ptr with placement new
| 45562 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterRay())); |  | 45514 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterRay()));
| 45563 | return 0; |  | 45515 | return 0;
| 45564 | } |  | 45516 | }
| 45565 |  |  | 45517 |
| 45566 | return -1; |  | 45518 | return -1;
| 45567 | } |  | 45519 | }
| 45568 |  |  | 45520 |
| 45569 |  |  | 45521 |
| 45570 |  |  | 45522 |
| 45571 | // Tables (detail_BundleAdjusterRay) |  | 45523 | // Tables (detail_BundleAdjusterRay)
| 45572 |  |  | 45524 |
| 45573 | static PyGetSetDef pyopencv_detail_BundleAdjusterRay_getseters[] = |  | 45525 | static PyGetSetDef pyopencv_detail_BundleAdjusterRay_getseters[] =
| 45574 | { |  | 45526 | {
| 45575 | {NULL} /* Sentinel */ |  | 45527 | {NULL} /* Sentinel */
| 45576 | }; |  | 45528 | };
| 45577 |  |  | 45529 |
| 45578 | static PyMethodDef pyopencv_detail_BundleAdjusterRay_methods[] = |  | 45530 | static PyMethodDef pyopencv_detail_BundleAdjusterRay_methods[] =
| 45579 | { |  | 45531 | {
| 45580 |  |  | 45532 |
| 45581 | {NULL, NULL} |  | 45533 | {NULL, NULL}
| 45582 | }; |  | 45534 | };
| 45583 |  |  | 45535 |
| 45584 | // Converter (detail_BundleAdjusterRay) |  | 45536 | // Converter (detail_BundleAdjusterRay)
| 45585 |  |  | 45537 |
| 45586 | template<> |  | 45538 | template<>
| 45587 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterRay> > |  | 45539 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterRay> >
| 45588 | { |  | 45540 | {
| 45589 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterRay>& r) |  | 45541 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterRay>& r)
| 45590 | { |  | 45542 | {
| 45591 | return pyopencv_detail_BundleAdjusterRay_Instance(r); |  | 45543 | return pyopencv_detail_BundleAdjusterRay_Instance(r);
| 45592 | } |  | 45544 | }
| 45593 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterRay>& dst, const ArgInfo& info) |  | 45545 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterRay>& dst, const ArgInfo& info)
| 45594 | { |  | 45546 | {
| 45595 | if(!src || src == Py_None) |  | 45547 | if(!src || src == Py_None)
| 45596 | return true; |  | 45548 | return true;
| 45597 | Ptr<cv::detail::BundleAdjusterRay> * dst_; |  | 45549 | Ptr<cv::detail::BundleAdjusterRay> * dst_;
| 45598 | if (pyopencv_detail_BundleAdjusterRay_getp(src, dst_)) |  | 45550 | if (pyopencv_detail_BundleAdjusterRay_getp(src, dst_))
| 45599 | { |  | 45551 | {
| 45600 | dst = *dst_; |  | 45552 | dst = *dst_;
| 45601 | return true; |  | 45553 | return true;
| 45602 | } |  | 45554 | }
| 45603 |  |  | 45555 |
| 45604 | failmsg("Expected Ptr<cv::detail::BundleAdjusterRay> for argument '%s'", info.name); |  | 45556 | failmsg("Expected Ptr<cv::detail::BundleAdjusterRay> for argument '%s'", info.name);
| 45605 | return false; |  | 45557 | return false;
| 45606 | } |  | 45558 | }
| 45607 | }; |  | 45559 | };
| 45608 |  |  | 45560 |
| 45609 | //================================================================================ |  | 45561 | //================================================================================
| 45610 | // detail_BundleAdjusterReproj (Generic) |  | 45562 | // detail_BundleAdjusterReproj (Generic)
| 45611 | //================================================================================ |  | 45563 | //================================================================================
| 45612 |  |  | 45564 |
| 45613 | // GetSet (detail_BundleAdjusterReproj) |  | 45565 | // GetSet (detail_BundleAdjusterReproj)
| 45614 |  |  | 45566 |
| 45615 |  |  | 45567 |
| 45616 |  |  | 45568 |
| 45617 | // Methods (detail_BundleAdjusterReproj) |  | 45569 | // Methods (detail_BundleAdjusterReproj)
| 45618 |  |  | 45570 |
| 45619 | static int pyopencv_cv_detail_detail_BundleAdjusterReproj_BundleAdjusterReproj(pyopencv_detail_BundleAdjusterReproj_t* self, PyObject* py_args, PyObject* kw) |  | 45571 | static int pyopencv_cv_detail_detail_BundleAdjusterReproj_BundleAdjusterReproj(pyopencv_detail_BundleAdjusterReproj_t* self, PyObject* py_args, PyObject* kw)
| 45620 | { |  | 45572 | {
| 45621 | using namespace cv::detail; |  | 45573 | using namespace cv::detail;
| 45622 |  |  | 45574 |
| 45623 |  |  | 45575 |
| 45624 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45576 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45625 | { |  | 45577 | {
| 45626 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterReproj>(); // init Ptr with placement new |  | 45578 | new (&(self->v)) Ptr<cv::detail::BundleAdjusterReproj>(); // init Ptr with placement new
| 45627 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterReproj())); |  | 45579 | if(self) ERRWRAP2(self->v.reset(new cv::detail::BundleAdjusterReproj()));
| 45628 | return 0; |  | 45580 | return 0;
| 45629 | } |  | 45581 | }
| 45630 |  |  | 45582 |
| 45631 | return -1; |  | 45583 | return -1;
| 45632 | } |  | 45584 | }
| 45633 |  |  | 45585 |
| 45634 |  |  | 45586 |
| 45635 |  |  | 45587 |
| 45636 | // Tables (detail_BundleAdjusterReproj) |  | 45588 | // Tables (detail_BundleAdjusterReproj)
| 45637 |  |  | 45589 |
| 45638 | static PyGetSetDef pyopencv_detail_BundleAdjusterReproj_getseters[] = |  | 45590 | static PyGetSetDef pyopencv_detail_BundleAdjusterReproj_getseters[] =
| 45639 | { |  | 45591 | {
| 45640 | {NULL} /* Sentinel */ |  | 45592 | {NULL} /* Sentinel */
| 45641 | }; |  | 45593 | };
| 45642 |  |  | 45594 |
| 45643 | static PyMethodDef pyopencv_detail_BundleAdjusterReproj_methods[] = |  | 45595 | static PyMethodDef pyopencv_detail_BundleAdjusterReproj_methods[] =
| 45644 | { |  | 45596 | {
| 45645 |  |  | 45597 |
| 45646 | {NULL, NULL} |  | 45598 | {NULL, NULL}
| 45647 | }; |  | 45599 | };
| 45648 |  |  | 45600 |
| 45649 | // Converter (detail_BundleAdjusterReproj) |  | 45601 | // Converter (detail_BundleAdjusterReproj)
| 45650 |  |  | 45602 |
| 45651 | template<> |  | 45603 | template<>
| 45652 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterReproj> > |  | 45604 | struct PyOpenCV_Converter< Ptr<cv::detail::BundleAdjusterReproj> >
| 45653 | { |  | 45605 | {
| 45654 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterReproj>& r) |  | 45606 | static PyObject* from(const Ptr<cv::detail::BundleAdjusterReproj>& r)
| 45655 | { |  | 45607 | {
| 45656 | return pyopencv_detail_BundleAdjusterReproj_Instance(r); |  | 45608 | return pyopencv_detail_BundleAdjusterReproj_Instance(r);
| 45657 | } |  | 45609 | }
| 45658 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterReproj>& dst, const ArgInfo& info) |  | 45610 | static bool to(PyObject* src, Ptr<cv::detail::BundleAdjusterReproj>& dst, const ArgInfo& info)
| 45659 | { |  | 45611 | {
| 45660 | if(!src || src == Py_None) |  | 45612 | if(!src || src == Py_None)
| 45661 | return true; |  | 45613 | return true;
| 45662 | Ptr<cv::detail::BundleAdjusterReproj> * dst_; |  | 45614 | Ptr<cv::detail::BundleAdjusterReproj> * dst_;
| 45663 | if (pyopencv_detail_BundleAdjusterReproj_getp(src, dst_)) |  | 45615 | if (pyopencv_detail_BundleAdjusterReproj_getp(src, dst_))
| 45664 | { |  | 45616 | {
| 45665 | dst = *dst_; |  | 45617 | dst = *dst_;
| 45666 | return true; |  | 45618 | return true;
| 45667 | } |  | 45619 | }
| 45668 |  |  | 45620 |
| 45669 | failmsg("Expected Ptr<cv::detail::BundleAdjusterReproj> for argument '%s'", info.name); |  | 45621 | failmsg("Expected Ptr<cv::detail::BundleAdjusterReproj> for argument '%s'", info.name);
| 45670 | return false; |  | 45622 | return false;
| 45671 | } |  | 45623 | }
| 45672 | }; |  | 45624 | };
| 45673 |  |  | 45625 |
| 45674 | //================================================================================ |  | 45626 | //================================================================================
| 45675 | // detail_CameraParams (Generic) |  | 45627 | // detail_CameraParams (Generic)
| 45676 | //================================================================================ |  | 45628 | //================================================================================
| 45677 |  |  | 45629 |
| 45678 | // GetSet (detail_CameraParams) |  | 45630 | // GetSet (detail_CameraParams)
| 45679 |  |  | 45631 |
| 45680 |  |  | 45632 |
| 45681 | static PyObject* pyopencv_detail_CameraParams_get_R(pyopencv_detail_CameraParams_t* p, void *closure) |  | 45633 | static PyObject* pyopencv_detail_CameraParams_get_R(pyopencv_detail_CameraParams_t* p, void *closure)
| 45682 | { |  | 45634 | {
| 45683 | return pyopencv_from(p->v.R); |  | 45635 | return pyopencv_from(p->v.R);
| 45684 | } |  | 45636 | }
| 45685 |  |  | 45637 |
| 45686 | static int pyopencv_detail_CameraParams_set_R(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure) |  | 45638 | static int pyopencv_detail_CameraParams_set_R(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure)
| 45687 | { |  | 45639 | {
| 45688 | if (!value) |  | 45640 | if (!value)
| 45689 | { |  | 45641 | {
| 45690 | PyErr_SetString(PyExc_TypeError, "Cannot delete the R attribute"); |  | 45642 | PyErr_SetString(PyExc_TypeError, "Cannot delete the R attribute");
| 45691 | return -1; |  | 45643 | return -1;
| 45692 | } |  | 45644 | }
| 45693 | return pyopencv_to_safe(value, p->v.R, ArgInfo("value", 0)) ? 0 : -1; |  | 45645 | return pyopencv_to_safe(value, p->v.R, ArgInfo("value", 0)) ? 0 : -1;
| 45694 | } |  | 45646 | }
| 45695 |  |  | 45647 |
| 45696 | static PyObject* pyopencv_detail_CameraParams_get_aspect(pyopencv_detail_CameraParams_t* p, void *closure) |  | 45648 | static PyObject* pyopencv_detail_CameraParams_get_aspect(pyopencv_detail_CameraParams_t* p, void *closure)
| 45697 | { |  | 45649 | {
| 45698 | return pyopencv_from(p->v.aspect); |  | 45650 | return pyopencv_from(p->v.aspect);
| 45699 | } |  | 45651 | }
| 45700 |  |  | 45652 |
| 45701 | static int pyopencv_detail_CameraParams_set_aspect(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure) |  | 45653 | static int pyopencv_detail_CameraParams_set_aspect(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure)
| 45702 | { |  | 45654 | {
| 45703 | if (!value) |  | 45655 | if (!value)
| 45704 | { |  | 45656 | {
| 45705 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aspect attribute"); |  | 45657 | PyErr_SetString(PyExc_TypeError, "Cannot delete the aspect attribute");
| 45706 | return -1; |  | 45658 | return -1;
| 45707 | } |  | 45659 | }
| 45708 | return pyopencv_to_safe(value, p->v.aspect, ArgInfo("value", 0)) ? 0 : -1; |  | 45660 | return pyopencv_to_safe(value, p->v.aspect, ArgInfo("value", 0)) ? 0 : -1;
| 45709 | } |  | 45661 | }
| 45710 |  |  | 45662 |
| 45711 | static PyObject* pyopencv_detail_CameraParams_get_focal(pyopencv_detail_CameraParams_t* p, void *closure) |  | 45663 | static PyObject* pyopencv_detail_CameraParams_get_focal(pyopencv_detail_CameraParams_t* p, void *closure)
| 45712 | { |  | 45664 | {
| 45713 | return pyopencv_from(p->v.focal); |  | 45665 | return pyopencv_from(p->v.focal);
| 45714 | } |  | 45666 | }
| 45715 |  |  | 45667 |
| 45716 | static int pyopencv_detail_CameraParams_set_focal(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure) |  | 45668 | static int pyopencv_detail_CameraParams_set_focal(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure)
| 45717 | { |  | 45669 | {
| 45718 | if (!value) |  | 45670 | if (!value)
| 45719 | { |  | 45671 | {
| 45720 | PyErr_SetString(PyExc_TypeError, "Cannot delete the focal attribute"); |  | 45672 | PyErr_SetString(PyExc_TypeError, "Cannot delete the focal attribute");
| 45721 | return -1; |  | 45673 | return -1;
| 45722 | } |  | 45674 | }
| 45723 | return pyopencv_to_safe(value, p->v.focal, ArgInfo("value", 0)) ? 0 : -1; |  | 45675 | return pyopencv_to_safe(value, p->v.focal, ArgInfo("value", 0)) ? 0 : -1;
| 45724 | } |  | 45676 | }
| 45725 |  |  | 45677 |
| 45726 | static PyObject* pyopencv_detail_CameraParams_get_ppx(pyopencv_detail_CameraParams_t* p, void *closure) |  | 45678 | static PyObject* pyopencv_detail_CameraParams_get_ppx(pyopencv_detail_CameraParams_t* p, void *closure)
| 45727 | { |  | 45679 | {
| 45728 | return pyopencv_from(p->v.ppx); |  | 45680 | return pyopencv_from(p->v.ppx);
| 45729 | } |  | 45681 | }
| 45730 |  |  | 45682 |
| 45731 | static int pyopencv_detail_CameraParams_set_ppx(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure) |  | 45683 | static int pyopencv_detail_CameraParams_set_ppx(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure)
| 45732 | { |  | 45684 | {
| 45733 | if (!value) |  | 45685 | if (!value)
| 45734 | { |  | 45686 | {
| 45735 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ppx attribute"); |  | 45687 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ppx attribute");
| 45736 | return -1; |  | 45688 | return -1;
| 45737 | } |  | 45689 | }
| 45738 | return pyopencv_to_safe(value, p->v.ppx, ArgInfo("value", 0)) ? 0 : -1; |  | 45690 | return pyopencv_to_safe(value, p->v.ppx, ArgInfo("value", 0)) ? 0 : -1;
| 45739 | } |  | 45691 | }
| 45740 |  |  | 45692 |
| 45741 | static PyObject* pyopencv_detail_CameraParams_get_ppy(pyopencv_detail_CameraParams_t* p, void *closure) |  | 45693 | static PyObject* pyopencv_detail_CameraParams_get_ppy(pyopencv_detail_CameraParams_t* p, void *closure)
| 45742 | { |  | 45694 | {
| 45743 | return pyopencv_from(p->v.ppy); |  | 45695 | return pyopencv_from(p->v.ppy);
| 45744 | } |  | 45696 | }
| 45745 |  |  | 45697 |
| 45746 | static int pyopencv_detail_CameraParams_set_ppy(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure) |  | 45698 | static int pyopencv_detail_CameraParams_set_ppy(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure)
| 45747 | { |  | 45699 | {
| 45748 | if (!value) |  | 45700 | if (!value)
| 45749 | { |  | 45701 | {
| 45750 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ppy attribute"); |  | 45702 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ppy attribute");
| 45751 | return -1; |  | 45703 | return -1;
| 45752 | } |  | 45704 | }
| 45753 | return pyopencv_to_safe(value, p->v.ppy, ArgInfo("value", 0)) ? 0 : -1; |  | 45705 | return pyopencv_to_safe(value, p->v.ppy, ArgInfo("value", 0)) ? 0 : -1;
| 45754 | } |  | 45706 | }
| 45755 |  |  | 45707 |
| 45756 | static PyObject* pyopencv_detail_CameraParams_get_t(pyopencv_detail_CameraParams_t* p, void *closure) |  | 45708 | static PyObject* pyopencv_detail_CameraParams_get_t(pyopencv_detail_CameraParams_t* p, void *closure)
| 45757 | { |  | 45709 | {
| 45758 | return pyopencv_from(p->v.t); |  | 45710 | return pyopencv_from(p->v.t);
| 45759 | } |  | 45711 | }
| 45760 |  |  | 45712 |
| 45761 | static int pyopencv_detail_CameraParams_set_t(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure) |  | 45713 | static int pyopencv_detail_CameraParams_set_t(pyopencv_detail_CameraParams_t* p, PyObject *value, void *closure)
| 45762 | { |  | 45714 | {
| 45763 | if (!value) |  | 45715 | if (!value)
| 45764 | { |  | 45716 | {
| 45765 | PyErr_SetString(PyExc_TypeError, "Cannot delete the t attribute"); |  | 45717 | PyErr_SetString(PyExc_TypeError, "Cannot delete the t attribute");
| 45766 | return -1; |  | 45718 | return -1;
| 45767 | } |  | 45719 | }
| 45768 | return pyopencv_to_safe(value, p->v.t, ArgInfo("value", 0)) ? 0 : -1; |  | 45720 | return pyopencv_to_safe(value, p->v.t, ArgInfo("value", 0)) ? 0 : -1;
| 45769 | } |  | 45721 | }
| 45770 |  |  | 45722 |
| 45771 |  |  | 45723 |
| 45772 | // Methods (detail_CameraParams) |  | 45724 | // Methods (detail_CameraParams)
| 45773 |  |  | 45725 |
| 45774 | static PyObject* pyopencv_cv_detail_detail_CameraParams_K(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45726 | static PyObject* pyopencv_cv_detail_detail_CameraParams_K(PyObject* self, PyObject* py_args, PyObject* kw)
| 45775 | { |  | 45727 | {
| 45776 | using namespace cv::detail; |  | 45728 | using namespace cv::detail;
| 45777 |  |  | 45729 |
| 45778 |  |  | 45730 |
| 45779 | cv::detail::CameraParams * self1 = 0; |  | 45731 | cv::detail::CameraParams * self1 = 0;
| 45780 | if (!pyopencv_detail_CameraParams_getp(self, self1)) |  | 45732 | if (!pyopencv_detail_CameraParams_getp(self, self1))
| 45781 | return failmsgp("Incorrect type of self (must be 'detail_CameraParams' or its derivative)"); |  | 45733 | return failmsgp("Incorrect type of self (must be 'detail_CameraParams' or its derivative)");
| 45782 | cv::detail::CameraParams* _self_ = (self1); |  | 45734 | cv::detail::CameraParams* _self_ = (self1);
| 45783 | Mat retval; |  | 45735 | Mat retval;
| 45784 |  |  | 45736 |
| 45785 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45737 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45786 | { |  | 45738 | {
| 45787 | ERRWRAP2(retval = _self_->K()); |  | 45739 | ERRWRAP2(retval = _self_->K());
| 45788 | return pyopencv_from(retval); |  | 45740 | return pyopencv_from(retval);
| 45789 | } |  | 45741 | }
| 45790 |  |  | 45742 |
| 45791 | return NULL; |  | 45743 | return NULL;
| 45792 | } |  | 45744 | }
| 45793 |  |  | 45745 |
| 45794 |  |  | 45746 |
| 45795 |  |  | 45747 |
| 45796 | // Tables (detail_CameraParams) |  | 45748 | // Tables (detail_CameraParams)
| 45797 |  |  | 45749 |
| 45798 | static PyGetSetDef pyopencv_detail_CameraParams_getseters[] = |  | 45750 | static PyGetSetDef pyopencv_detail_CameraParams_getseters[] =
| 45799 | { |  | 45751 | {
| 45800 | {(char*)"R", (getter)pyopencv_detail_CameraParams_get_R, (setter)pyopencv_detail_CameraParams_set_R, (char*)"R", NULL}, |  | 45752 | {(char*)"R", (getter)pyopencv_detail_CameraParams_get_R, (setter)pyopencv_detail_CameraParams_set_R, (char*)"R", NULL},
| 45801 | {(char*)"aspect", (getter)pyopencv_detail_CameraParams_get_aspect, (setter)pyopencv_detail_CameraParams_set_aspect, (char*)"aspect", NULL}, |  | 45753 | {(char*)"aspect", (getter)pyopencv_detail_CameraParams_get_aspect, (setter)pyopencv_detail_CameraParams_set_aspect, (char*)"aspect", NULL},
| 45802 | {(char*)"focal", (getter)pyopencv_detail_CameraParams_get_focal, (setter)pyopencv_detail_CameraParams_set_focal, (char*)"focal", NULL}, |  | 45754 | {(char*)"focal", (getter)pyopencv_detail_CameraParams_get_focal, (setter)pyopencv_detail_CameraParams_set_focal, (char*)"focal", NULL},
| 45803 | {(char*)"ppx", (getter)pyopencv_detail_CameraParams_get_ppx, (setter)pyopencv_detail_CameraParams_set_ppx, (char*)"ppx", NULL}, |  | 45755 | {(char*)"ppx", (getter)pyopencv_detail_CameraParams_get_ppx, (setter)pyopencv_detail_CameraParams_set_ppx, (char*)"ppx", NULL},
| 45804 | {(char*)"ppy", (getter)pyopencv_detail_CameraParams_get_ppy, (setter)pyopencv_detail_CameraParams_set_ppy, (char*)"ppy", NULL}, |  | 45756 | {(char*)"ppy", (getter)pyopencv_detail_CameraParams_get_ppy, (setter)pyopencv_detail_CameraParams_set_ppy, (char*)"ppy", NULL},
| 45805 | {(char*)"t", (getter)pyopencv_detail_CameraParams_get_t, (setter)pyopencv_detail_CameraParams_set_t, (char*)"t", NULL}, |  | 45757 | {(char*)"t", (getter)pyopencv_detail_CameraParams_get_t, (setter)pyopencv_detail_CameraParams_set_t, (char*)"t", NULL},
| 45806 | {NULL} /* Sentinel */ |  | 45758 | {NULL} /* Sentinel */
| 45807 | }; |  | 45759 | };
| 45808 |  |  | 45760 |
| 45809 | static PyMethodDef pyopencv_detail_CameraParams_methods[] = |  | 45761 | static PyMethodDef pyopencv_detail_CameraParams_methods[] =
| 45810 | { |  | 45762 | {
| 45811 | {"K", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_CameraParams_K, 0), "K() -> retval\n."}, |  | 45763 | {"K", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_CameraParams_K, 0), "K() -> retval\n."},
| 45812 |  |  | 45764 |
| 45813 | {NULL, NULL} |  | 45765 | {NULL, NULL}
| 45814 | }; |  | 45766 | };
| 45815 |  |  | 45767 |
| 45816 | // Converter (detail_CameraParams) |  | 45768 | // Converter (detail_CameraParams)
| 45817 |  |  | 45769 |
| 45818 | template<> |  | 45770 | template<>
| 45819 | struct PyOpenCV_Converter< cv::detail::CameraParams > |  | 45771 | struct PyOpenCV_Converter< cv::detail::CameraParams >
| 45820 | { |  | 45772 | {
| 45821 | static PyObject* from(const cv::detail::CameraParams& r) |  | 45773 | static PyObject* from(const cv::detail::CameraParams& r)
| 45822 | { |  | 45774 | {
| 45823 | return pyopencv_detail_CameraParams_Instance(r); |  | 45775 | return pyopencv_detail_CameraParams_Instance(r);
| 45824 | } |  | 45776 | }
| 45825 | static bool to(PyObject* src, cv::detail::CameraParams& dst, const ArgInfo& info) |  | 45777 | static bool to(PyObject* src, cv::detail::CameraParams& dst, const ArgInfo& info)
| 45826 | { |  | 45778 | {
| 45827 | if(!src || src == Py_None) |  | 45779 | if(!src || src == Py_None)
| 45828 | return true; |  | 45780 | return true;
| 45829 | cv::detail::CameraParams * dst_; |  | 45781 | cv::detail::CameraParams * dst_;
| 45830 | if (pyopencv_detail_CameraParams_getp(src, dst_)) |  | 45782 | if (pyopencv_detail_CameraParams_getp(src, dst_))
| 45831 | { |  | 45783 | {
| 45832 | dst = *dst_; |  | 45784 | dst = *dst_;
| 45833 | return true; |  | 45785 | return true;
| 45834 | } |  | 45786 | }
| 45835 |  |  | 45787 |
| 45836 | failmsg("Expected cv::detail::CameraParams for argument '%s'", info.name); |  | 45788 | failmsg("Expected cv::detail::CameraParams for argument '%s'", info.name);
| 45837 | return false; |  | 45789 | return false;
| 45838 | } |  | 45790 | }
| 45839 | }; |  | 45791 | };
| 45840 |  |  | 45792 |
| 45841 | //================================================================================ |  | 45793 | //================================================================================
| 45842 | // detail_ChannelsCompensator (Generic) |  | 45794 | // detail_ChannelsCompensator (Generic)
| 45843 | //================================================================================ |  | 45795 | //================================================================================
| 45844 |  |  | 45796 |
| 45845 | // GetSet (detail_ChannelsCompensator) |  | 45797 | // GetSet (detail_ChannelsCompensator)
| 45846 |  |  | 45798 |
| 45847 |  |  | 45799 |
| 45848 |  |  | 45800 |
| 45849 | // Methods (detail_ChannelsCompensator) |  | 45801 | // Methods (detail_ChannelsCompensator)
| 45850 |  |  | 45802 |
| 45851 | static int pyopencv_cv_detail_detail_ChannelsCompensator_ChannelsCompensator(pyopencv_detail_ChannelsCompensator_t* self, PyObject* py_args, PyObject* kw) |  | 45803 | static int pyopencv_cv_detail_detail_ChannelsCompensator_ChannelsCompensator(pyopencv_detail_ChannelsCompensator_t* self, PyObject* py_args, PyObject* kw)
| 45852 | { |  | 45804 | {
| 45853 | using namespace cv::detail; |  | 45805 | using namespace cv::detail;
| 45854 |  |  | 45806 |
| 45855 | PyObject* pyobj_nr_feeds = NULL; |  | 45807 | PyObject* pyobj_nr_feeds = NULL;
| 45856 | int nr_feeds=1; |  | 45808 | int nr_feeds=1;
| 45857 |  |  | 45809 |
| 45858 | const char* keywords[] = { "nr_feeds", NULL }; |  | 45810 | const char* keywords[] = { "nr_feeds", NULL };
| 45859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:ChannelsCompensator", (char**)keywords, &pyobj_nr_feeds) && |  | 45811 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:ChannelsCompensator", (char**)keywords, &pyobj_nr_feeds) &&
| 45860 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) ) |  | 45812 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) )
| 45861 | { |  | 45813 | {
| 45862 | new (&(self->v)) Ptr<cv::detail::ChannelsCompensator>(); // init Ptr with placement new |  | 45814 | new (&(self->v)) Ptr<cv::detail::ChannelsCompensator>(); // init Ptr with placement new
| 45863 | if(self) ERRWRAP2(self->v.reset(new cv::detail::ChannelsCompensator(nr_feeds))); |  | 45815 | if(self) ERRWRAP2(self->v.reset(new cv::detail::ChannelsCompensator(nr_feeds)));
| 45864 | return 0; |  | 45816 | return 0;
| 45865 | } |  | 45817 | }
| 45866 |  |  | 45818 |
| 45867 | return -1; |  | 45819 | return -1;
| 45868 | } |  | 45820 | }
| 45869 |  |  | 45821 |
| 45870 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45822 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 45871 | { |  | 45823 | {
| 45872 | using namespace cv::detail; |  | 45824 | using namespace cv::detail;
| 45873 |  |  | 45825 |
| 45874 |  |  | 45826 |
| 45875 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0; |  | 45827 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0;
| 45876 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1)) |  | 45828 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1))
| 45877 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)"); |  | 45829 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)");
| 45878 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1); |  | 45830 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1);
| 45879 | pyPrepareArgumentConversionErrorsStorage(2); |  | 45831 | pyPrepareArgumentConversionErrorsStorage(2);
| 45880 |  |  | 45832 |
| 45881 | { |  | 45833 | {
| 45882 | PyObject* pyobj_index = NULL; |  | 45834 | PyObject* pyobj_index = NULL;
| 45883 | int index=0; |  | 45835 | int index=0;
| 45884 | PyObject* pyobj_corner = NULL; |  | 45836 | PyObject* pyobj_corner = NULL;
| 45885 | Point corner; |  | 45837 | Point corner;
| 45886 | PyObject* pyobj_image = NULL; |  | 45838 | PyObject* pyobj_image = NULL;
| 45887 | Mat image; |  | 45839 | Mat image;
| 45888 | PyObject* pyobj_mask = NULL; |  | 45840 | PyObject* pyobj_mask = NULL;
| 45889 | Mat mask; |  | 45841 | Mat mask;
| 45890 |  |  | 45842 |
| 45891 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 45843 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 45892 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ChannelsCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 45844 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ChannelsCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 45893 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 45845 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 45894 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 45846 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 45895 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 45847 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 45896 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 45848 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 45897 | { |  | 45849 | {
| 45898 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 45850 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 45899 | return pyopencv_from(image); |  | 45851 | return pyopencv_from(image);
| 45900 | } |  | 45852 | }
| 45901 |  |  | 45853 |
| 45902 |  |  | 45854 |
| 45903 | pyPopulateArgumentConversionErrors(); |  | 45855 | pyPopulateArgumentConversionErrors();
| 45904 | } |  | 45856 | }
| 45905 |  |  | 45857 |
| 45906 |  |  | 45858 |
| 45907 | { |  | 45859 | {
| 45908 | PyObject* pyobj_index = NULL; |  | 45860 | PyObject* pyobj_index = NULL;
| 45909 | int index=0; |  | 45861 | int index=0;
| 45910 | PyObject* pyobj_corner = NULL; |  | 45862 | PyObject* pyobj_corner = NULL;
| 45911 | Point corner; |  | 45863 | Point corner;
| 45912 | PyObject* pyobj_image = NULL; |  | 45864 | PyObject* pyobj_image = NULL;
| 45913 | UMat image; |  | 45865 | UMat image;
| 45914 | PyObject* pyobj_mask = NULL; |  | 45866 | PyObject* pyobj_mask = NULL;
| 45915 | UMat mask; |  | 45867 | UMat mask;
| 45916 |  |  | 45868 |
| 45917 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 45869 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 45918 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ChannelsCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 45870 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ChannelsCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 45919 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 45871 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 45920 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 45872 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 45921 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 45873 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 45922 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 45874 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 45923 | { |  | 45875 | {
| 45924 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 45876 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 45925 | return pyopencv_from(image); |  | 45877 | return pyopencv_from(image);
| 45926 | } |  | 45878 | }
| 45927 |  |  | 45879 |
| 45928 |  |  | 45880 |
| 45929 | pyPopulateArgumentConversionErrors(); |  | 45881 | pyPopulateArgumentConversionErrors();
| 45930 | } |  | 45882 | }
| 45931 | pyRaiseCVOverloadException("apply"); |  | 45883 | pyRaiseCVOverloadException("apply");
| 45932 |  |  | 45884 |
| 45933 | return NULL; |  | 45885 | return NULL;
| 45934 | } |  | 45886 | }
| 45935 |  |  | 45887 |
| 45936 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45888 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 45937 | { |  | 45889 | {
| 45938 | using namespace cv::detail; |  | 45890 | using namespace cv::detail;
| 45939 |  |  | 45891 |
| 45940 |  |  | 45892 |
| 45941 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0; |  | 45893 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0;
| 45942 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1)) |  | 45894 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1))
| 45943 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)"); |  | 45895 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)");
| 45944 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1); |  | 45896 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1);
| 45945 | PyObject* pyobj_umv = NULL; |  | 45897 | PyObject* pyobj_umv = NULL;
| 45946 | vector_Mat umv; |  | 45898 | vector_Mat umv;
| 45947 |  |  | 45899 |
| 45948 | const char* keywords[] = { "umv", NULL }; |  | 45900 | const char* keywords[] = { "umv", NULL };
| 45949 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_ChannelsCompensator.getMatGains", (char**)keywords, &pyobj_umv) && |  | 45901 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_ChannelsCompensator.getMatGains", (char**)keywords, &pyobj_umv) &&
| 45950 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) ) |  | 45902 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) )
| 45951 | { |  | 45903 | {
| 45952 | ERRWRAP2(_self_->getMatGains(umv)); |  | 45904 | ERRWRAP2(_self_->getMatGains(umv));
| 45953 | return pyopencv_from(umv); |  | 45905 | return pyopencv_from(umv);
| 45954 | } |  | 45906 | }
| 45955 |  |  | 45907 |
| 45956 | return NULL; |  | 45908 | return NULL;
| 45957 | } |  | 45909 | }
| 45958 |  |  | 45910 |
| 45959 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_getNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45911 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_getNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw)
| 45960 | { |  | 45912 | {
| 45961 | using namespace cv::detail; |  | 45913 | using namespace cv::detail;
| 45962 |  |  | 45914 |
| 45963 |  |  | 45915 |
| 45964 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0; |  | 45916 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0;
| 45965 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1)) |  | 45917 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1))
| 45966 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)"); |  | 45918 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)");
| 45967 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1); |  | 45919 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1);
| 45968 | int retval; |  | 45920 | int retval;
| 45969 |  |  | 45921 |
| 45970 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45922 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45971 | { |  | 45923 | {
| 45972 | ERRWRAP2(retval = _self_->getNrFeeds()); |  | 45924 | ERRWRAP2(retval = _self_->getNrFeeds());
| 45973 | return pyopencv_from(retval); |  | 45925 | return pyopencv_from(retval);
| 45974 | } |  | 45926 | }
| 45975 |  |  | 45927 |
| 45976 | return NULL; |  | 45928 | return NULL;
| 45977 | } |  | 45929 | }
| 45978 |  |  | 45930 |
| 45979 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_getSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45931 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_getSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 45980 | { |  | 45932 | {
| 45981 | using namespace cv::detail; |  | 45933 | using namespace cv::detail;
| 45982 |  |  | 45934 |
| 45983 |  |  | 45935 |
| 45984 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0; |  | 45936 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0;
| 45985 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1)) |  | 45937 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1))
| 45986 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)"); |  | 45938 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)");
| 45987 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1); |  | 45939 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1);
| 45988 | double retval; |  | 45940 | double retval;
| 45989 |  |  | 45941 |
| 45990 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 45942 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 45991 | { |  | 45943 | {
| 45992 | ERRWRAP2(retval = _self_->getSimilarityThreshold()); |  | 45944 | ERRWRAP2(retval = _self_->getSimilarityThreshold());
| 45993 | return pyopencv_from(retval); |  | 45945 | return pyopencv_from(retval);
| 45994 | } |  | 45946 | }
| 45995 |  |  | 45947 |
| 45996 | return NULL; |  | 45948 | return NULL;
| 45997 | } |  | 45949 | }
| 45998 |  |  | 45950 |
| 45999 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45951 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 46000 | { |  | 45952 | {
| 46001 | using namespace cv::detail; |  | 45953 | using namespace cv::detail;
| 46002 |  |  | 45954 |
| 46003 |  |  | 45955 |
| 46004 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0; |  | 45956 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0;
| 46005 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1)) |  | 45957 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1))
| 46006 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)"); |  | 45958 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)");
| 46007 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1); |  | 45959 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1);
| 46008 | PyObject* pyobj_umv = NULL; |  | 45960 | PyObject* pyobj_umv = NULL;
| 46009 | vector_Mat umv; |  | 45961 | vector_Mat umv;
| 46010 |  |  | 45962 |
| 46011 | const char* keywords[] = { "umv", NULL }; |  | 45963 | const char* keywords[] = { "umv", NULL };
| 46012 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ChannelsCompensator.setMatGains", (char**)keywords, &pyobj_umv) && |  | 45964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ChannelsCompensator.setMatGains", (char**)keywords, &pyobj_umv) &&
| 46013 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) ) |  | 45965 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) )
| 46014 | { |  | 45966 | {
| 46015 | ERRWRAP2(_self_->setMatGains(umv)); |  | 45967 | ERRWRAP2(_self_->setMatGains(umv));
| 46016 | Py_RETURN_NONE; |  | 45968 | Py_RETURN_NONE;
| 46017 | } |  | 45969 | }
| 46018 |  |  | 45970 |
| 46019 | return NULL; |  | 45971 | return NULL;
| 46020 | } |  | 45972 | }
| 46021 |  |  | 45973 |
| 46022 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_setNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45974 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_setNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw)
| 46023 | { |  | 45975 | {
| 46024 | using namespace cv::detail; |  | 45976 | using namespace cv::detail;
| 46025 |  |  | 45977 |
| 46026 |  |  | 45978 |
| 46027 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0; |  | 45979 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0;
| 46028 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1)) |  | 45980 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1))
| 46029 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)"); |  | 45981 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)");
| 46030 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1); |  | 45982 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1);
| 46031 | PyObject* pyobj_nr_feeds = NULL; |  | 45983 | PyObject* pyobj_nr_feeds = NULL;
| 46032 | int nr_feeds=0; |  | 45984 | int nr_feeds=0;
| 46033 |  |  | 45985 |
| 46034 | const char* keywords[] = { "nr_feeds", NULL }; |  | 45986 | const char* keywords[] = { "nr_feeds", NULL };
| 46035 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ChannelsCompensator.setNrFeeds", (char**)keywords, &pyobj_nr_feeds) && |  | 45987 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ChannelsCompensator.setNrFeeds", (char**)keywords, &pyobj_nr_feeds) &&
| 46036 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) ) |  | 45988 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) )
| 46037 | { |  | 45989 | {
| 46038 | ERRWRAP2(_self_->setNrFeeds(nr_feeds)); |  | 45990 | ERRWRAP2(_self_->setNrFeeds(nr_feeds));
| 46039 | Py_RETURN_NONE; |  | 45991 | Py_RETURN_NONE;
| 46040 | } |  | 45992 | }
| 46041 |  |  | 45993 |
| 46042 | return NULL; |  | 45994 | return NULL;
| 46043 | } |  | 45995 | }
| 46044 |  |  | 45996 |
| 46045 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_setSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 45997 | static PyObject* pyopencv_cv_detail_detail_ChannelsCompensator_setSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 46046 | { |  | 45998 | {
| 46047 | using namespace cv::detail; |  | 45999 | using namespace cv::detail;
| 46048 |  |  | 46000 |
| 46049 |  |  | 46001 |
| 46050 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0; |  | 46002 | Ptr<cv::detail::ChannelsCompensator> * self1 = 0;
| 46051 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1)) |  | 46003 | if (!pyopencv_detail_ChannelsCompensator_getp(self, self1))
| 46052 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)"); |  | 46004 | return failmsgp("Incorrect type of self (must be 'detail_ChannelsCompensator' or its derivative)");
| 46053 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1); |  | 46005 | Ptr<cv::detail::ChannelsCompensator> _self_ = *(self1);
| 46054 | PyObject* pyobj_similarity_threshold = NULL; |  | 46006 | PyObject* pyobj_similarity_threshold = NULL;
| 46055 | double similarity_threshold=0; |  | 46007 | double similarity_threshold=0;
| 46056 |  |  | 46008 |
| 46057 | const char* keywords[] = { "similarity_threshold", NULL }; |  | 46009 | const char* keywords[] = { "similarity_threshold", NULL };
| 46058 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ChannelsCompensator.setSimilarityThreshold", (char**)keywords, &pyobj_similarity_threshold) && |  | 46010 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ChannelsCompensator.setSimilarityThreshold", (char**)keywords, &pyobj_similarity_threshold) &&
| 46059 | pyopencv_to_safe(pyobj_similarity_threshold, similarity_threshold, ArgInfo("similarity_threshold", 0)) ) |  | 46011 | pyopencv_to_safe(pyobj_similarity_threshold, similarity_threshold, ArgInfo("similarity_threshold", 0)) )
| 46060 | { |  | 46012 | {
| 46061 | ERRWRAP2(_self_->setSimilarityThreshold(similarity_threshold)); |  | 46013 | ERRWRAP2(_self_->setSimilarityThreshold(similarity_threshold));
| 46062 | Py_RETURN_NONE; |  | 46014 | Py_RETURN_NONE;
| 46063 | } |  | 46015 | }
| 46064 |  |  | 46016 |
| 46065 | return NULL; |  | 46017 | return NULL;
| 46066 | } |  | 46018 | }
| 46067 |  |  | 46019 |
| 46068 |  |  | 46020 |
| 46069 |  |  | 46021 |
| 46070 | // Tables (detail_ChannelsCompensator) |  | 46022 | // Tables (detail_ChannelsCompensator)
| 46071 |  |  | 46023 |
| 46072 | static PyGetSetDef pyopencv_detail_ChannelsCompensator_getseters[] = |  | 46024 | static PyGetSetDef pyopencv_detail_ChannelsCompensator_getseters[] =
| 46073 | { |  | 46025 | {
| 46074 | {NULL} /* Sentinel */ |  | 46026 | {NULL} /* Sentinel */
| 46075 | }; |  | 46027 | };
| 46076 |  |  | 46028 |
| 46077 | static PyMethodDef pyopencv_detail_ChannelsCompensator_methods[] = |  | 46029 | static PyMethodDef pyopencv_detail_ChannelsCompensator_methods[] =
| 46078 | { |  | 46030 | {
| 46079 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."}, |  | 46031 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."},
| 46080 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."}, |  | 46032 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."},
| 46081 | {"getNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_getNrFeeds, 0), "getNrFeeds() -> retval\n."}, |  | 46033 | {"getNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_getNrFeeds, 0), "getNrFeeds() -> retval\n."},
| 46082 | {"getSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_getSimilarityThreshold, 0), "getSimilarityThreshold() -> retval\n."}, |  | 46034 | {"getSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_getSimilarityThreshold, 0), "getSimilarityThreshold() -> retval\n."},
| 46083 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."}, |  | 46035 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."},
| 46084 | {"setNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_setNrFeeds, 0), "setNrFeeds(nr_feeds) -> None\n."}, |  | 46036 | {"setNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_setNrFeeds, 0), "setNrFeeds(nr_feeds) -> None\n."},
| 46085 | {"setSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_setSimilarityThreshold, 0), "setSimilarityThreshold(similarity_threshold) -> None\n."}, |  | 46037 | {"setSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ChannelsCompensator_setSimilarityThreshold, 0), "setSimilarityThreshold(similarity_threshold) -> None\n."},
| 46086 |  |  | 46038 |
| 46087 | {NULL, NULL} |  | 46039 | {NULL, NULL}
| 46088 | }; |  | 46040 | };
| 46089 |  |  | 46041 |
| 46090 | // Converter (detail_ChannelsCompensator) |  | 46042 | // Converter (detail_ChannelsCompensator)
| 46091 |  |  | 46043 |
| 46092 | template<> |  | 46044 | template<>
| 46093 | struct PyOpenCV_Converter< Ptr<cv::detail::ChannelsCompensator> > |  | 46045 | struct PyOpenCV_Converter< Ptr<cv::detail::ChannelsCompensator> >
| 46094 | { |  | 46046 | {
| 46095 | static PyObject* from(const Ptr<cv::detail::ChannelsCompensator>& r) |  | 46047 | static PyObject* from(const Ptr<cv::detail::ChannelsCompensator>& r)
| 46096 | { |  | 46048 | {
| 46097 | return pyopencv_detail_ChannelsCompensator_Instance(r); |  | 46049 | return pyopencv_detail_ChannelsCompensator_Instance(r);
| 46098 | } |  | 46050 | }
| 46099 | static bool to(PyObject* src, Ptr<cv::detail::ChannelsCompensator>& dst, const ArgInfo& info) |  | 46051 | static bool to(PyObject* src, Ptr<cv::detail::ChannelsCompensator>& dst, const ArgInfo& info)
| 46100 | { |  | 46052 | {
| 46101 | if(!src || src == Py_None) |  | 46053 | if(!src || src == Py_None)
| 46102 | return true; |  | 46054 | return true;
| 46103 | Ptr<cv::detail::ChannelsCompensator> * dst_; |  | 46055 | Ptr<cv::detail::ChannelsCompensator> * dst_;
| 46104 | if (pyopencv_detail_ChannelsCompensator_getp(src, dst_)) |  | 46056 | if (pyopencv_detail_ChannelsCompensator_getp(src, dst_))
| 46105 | { |  | 46057 | {
| 46106 | dst = *dst_; |  | 46058 | dst = *dst_;
| 46107 | return true; |  | 46059 | return true;
| 46108 | } |  | 46060 | }
| 46109 |  |  | 46061 |
| 46110 | failmsg("Expected Ptr<cv::detail::ChannelsCompensator> for argument '%s'", info.name); |  | 46062 | failmsg("Expected Ptr<cv::detail::ChannelsCompensator> for argument '%s'", info.name);
| 46111 | return false; |  | 46063 | return false;
| 46112 | } |  | 46064 | }
| 46113 | }; |  | 46065 | };
| 46114 |  |  | 46066 |
| 46115 | //================================================================================ |  | 46067 | //================================================================================
| 46116 | // detail_DpSeamFinder (Generic) |  | 46068 | // detail_DpSeamFinder (Generic)
| 46117 | //================================================================================ |  | 46069 | //================================================================================
| 46118 |  |  | 46070 |
| 46119 | // GetSet (detail_DpSeamFinder) |  | 46071 | // GetSet (detail_DpSeamFinder)
| 46120 |  |  | 46072 |
| 46121 |  |  | 46073 |
| 46122 |  |  | 46074 |
| 46123 | // Methods (detail_DpSeamFinder) |  | 46075 | // Methods (detail_DpSeamFinder)
| 46124 |  |  | 46076 |
| 46125 | static int pyopencv_cv_detail_detail_DpSeamFinder_DpSeamFinder(pyopencv_detail_DpSeamFinder_t* self, PyObject* py_args, PyObject* kw) |  | 46077 | static int pyopencv_cv_detail_detail_DpSeamFinder_DpSeamFinder(pyopencv_detail_DpSeamFinder_t* self, PyObject* py_args, PyObject* kw)
| 46126 | { |  | 46078 | {
| 46127 | using namespace cv::detail; |  | 46079 | using namespace cv::detail;
| 46128 |  |  | 46080 |
| 46129 | PyObject* pyobj_costFunc = NULL; |  | 46081 | PyObject* pyobj_costFunc = NULL;
| 46130 | String costFunc; |  | 46082 | String costFunc;
| 46131 |  |  | 46083 |
| 46132 | const char* keywords[] = { "costFunc", NULL }; |  | 46084 | const char* keywords[] = { "costFunc", NULL };
| 46133 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DpSeamFinder", (char**)keywords, &pyobj_costFunc) && |  | 46085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DpSeamFinder", (char**)keywords, &pyobj_costFunc) &&
| 46134 | pyopencv_to_safe(pyobj_costFunc, costFunc, ArgInfo("costFunc", 0)) ) |  | 46086 | pyopencv_to_safe(pyobj_costFunc, costFunc, ArgInfo("costFunc", 0)) )
| 46135 | { |  | 46087 | {
| 46136 | new (&(self->v)) Ptr<cv::detail::DpSeamFinder>(); // init Ptr with placement new |  | 46088 | new (&(self->v)) Ptr<cv::detail::DpSeamFinder>(); // init Ptr with placement new
| 46137 | if(self) ERRWRAP2(self->v.reset(new cv::detail::DpSeamFinder(costFunc))); |  | 46089 | if(self) ERRWRAP2(self->v.reset(new cv::detail::DpSeamFinder(costFunc)));
| 46138 | return 0; |  | 46090 | return 0;
| 46139 | } |  | 46091 | }
| 46140 |  |  | 46092 |
| 46141 | return -1; |  | 46093 | return -1;
| 46142 | } |  | 46094 | }
| 46143 |  |  | 46095 |
| 46144 | static PyObject* pyopencv_cv_detail_detail_DpSeamFinder_setCostFunction(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46096 | static PyObject* pyopencv_cv_detail_detail_DpSeamFinder_setCostFunction(PyObject* self, PyObject* py_args, PyObject* kw)
| 46145 | { |  | 46097 | {
| 46146 | using namespace cv::detail; |  | 46098 | using namespace cv::detail;
| 46147 |  |  | 46099 |
| 46148 |  |  | 46100 |
| 46149 | Ptr<cv::detail::DpSeamFinder> * self1 = 0; |  | 46101 | Ptr<cv::detail::DpSeamFinder> * self1 = 0;
| 46150 | if (!pyopencv_detail_DpSeamFinder_getp(self, self1)) |  | 46102 | if (!pyopencv_detail_DpSeamFinder_getp(self, self1))
| 46151 | return failmsgp("Incorrect type of self (must be 'detail_DpSeamFinder' or its derivative)"); |  | 46103 | return failmsgp("Incorrect type of self (must be 'detail_DpSeamFinder' or its derivative)");
| 46152 | Ptr<cv::detail::DpSeamFinder> _self_ = *(self1); |  | 46104 | Ptr<cv::detail::DpSeamFinder> _self_ = *(self1);
| 46153 | PyObject* pyobj_val = NULL; |  | 46105 | PyObject* pyobj_val = NULL;
| 46154 | String val; |  | 46106 | String val;
| 46155 |  |  | 46107 |
| 46156 | const char* keywords[] = { "val", NULL }; |  | 46108 | const char* keywords[] = { "val", NULL };
| 46157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_DpSeamFinder.setCostFunction", (char**)keywords, &pyobj_val) && |  | 46109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_DpSeamFinder.setCostFunction", (char**)keywords, &pyobj_val) &&
| 46158 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 46110 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 46159 | { |  | 46111 | {
| 46160 | ERRWRAP2(_self_->setCostFunction(val)); |  | 46112 | ERRWRAP2(_self_->setCostFunction(val));
| 46161 | Py_RETURN_NONE; |  | 46113 | Py_RETURN_NONE;
| 46162 | } |  | 46114 | }
| 46163 |  |  | 46115 |
| 46164 | return NULL; |  | 46116 | return NULL;
| 46165 | } |  | 46117 | }
| 46166 |  |  | 46118 |
| 46167 |  |  | 46119 |
| 46168 |  |  | 46120 |
| 46169 | // Tables (detail_DpSeamFinder) |  | 46121 | // Tables (detail_DpSeamFinder)
| 46170 |  |  | 46122 |
| 46171 | static PyGetSetDef pyopencv_detail_DpSeamFinder_getseters[] = |  | 46123 | static PyGetSetDef pyopencv_detail_DpSeamFinder_getseters[] =
| 46172 | { |  | 46124 | {
| 46173 | {NULL} /* Sentinel */ |  | 46125 | {NULL} /* Sentinel */
| 46174 | }; |  | 46126 | };
| 46175 |  |  | 46127 |
| 46176 | static PyMethodDef pyopencv_detail_DpSeamFinder_methods[] = |  | 46128 | static PyMethodDef pyopencv_detail_DpSeamFinder_methods[] =
| 46177 | { |  | 46129 | {
| 46178 | {"setCostFunction", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_DpSeamFinder_setCostFunction, 0), "setCostFunction(val) -> None\n."}, |  | 46130 | {"setCostFunction", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_DpSeamFinder_setCostFunction, 0), "setCostFunction(val) -> None\n."},
| 46179 |  |  | 46131 |
| 46180 | {NULL, NULL} |  | 46132 | {NULL, NULL}
| 46181 | }; |  | 46133 | };
| 46182 |  |  | 46134 |
| 46183 | // Converter (detail_DpSeamFinder) |  | 46135 | // Converter (detail_DpSeamFinder)
| 46184 |  |  | 46136 |
| 46185 | template<> |  | 46137 | template<>
| 46186 | struct PyOpenCV_Converter< Ptr<cv::detail::DpSeamFinder> > |  | 46138 | struct PyOpenCV_Converter< Ptr<cv::detail::DpSeamFinder> >
| 46187 | { |  | 46139 | {
| 46188 | static PyObject* from(const Ptr<cv::detail::DpSeamFinder>& r) |  | 46140 | static PyObject* from(const Ptr<cv::detail::DpSeamFinder>& r)
| 46189 | { |  | 46141 | {
| 46190 | return pyopencv_detail_DpSeamFinder_Instance(r); |  | 46142 | return pyopencv_detail_DpSeamFinder_Instance(r);
| 46191 | } |  | 46143 | }
| 46192 | static bool to(PyObject* src, Ptr<cv::detail::DpSeamFinder>& dst, const ArgInfo& info) |  | 46144 | static bool to(PyObject* src, Ptr<cv::detail::DpSeamFinder>& dst, const ArgInfo& info)
| 46193 | { |  | 46145 | {
| 46194 | if(!src || src == Py_None) |  | 46146 | if(!src || src == Py_None)
| 46195 | return true; |  | 46147 | return true;
| 46196 | Ptr<cv::detail::DpSeamFinder> * dst_; |  | 46148 | Ptr<cv::detail::DpSeamFinder> * dst_;
| 46197 | if (pyopencv_detail_DpSeamFinder_getp(src, dst_)) |  | 46149 | if (pyopencv_detail_DpSeamFinder_getp(src, dst_))
| 46198 | { |  | 46150 | {
| 46199 | dst = *dst_; |  | 46151 | dst = *dst_;
| 46200 | return true; |  | 46152 | return true;
| 46201 | } |  | 46153 | }
| 46202 |  |  | 46154 |
| 46203 | failmsg("Expected Ptr<cv::detail::DpSeamFinder> for argument '%s'", info.name); |  | 46155 | failmsg("Expected Ptr<cv::detail::DpSeamFinder> for argument '%s'", info.name);
| 46204 | return false; |  | 46156 | return false;
| 46205 | } |  | 46157 | }
| 46206 | }; |  | 46158 | };
| 46207 |  |  | 46159 |
| 46208 | //================================================================================ |  | 46160 | //================================================================================
| 46209 | // detail_Estimator (Generic) |  | 46161 | // detail_Estimator (Generic)
| 46210 | //================================================================================ |  | 46162 | //================================================================================
| 46211 |  |  | 46163 |
| 46212 | // GetSet (detail_Estimator) |  | 46164 | // GetSet (detail_Estimator)
| 46213 |  |  | 46165 |
| 46214 |  |  | 46166 |
| 46215 |  |  | 46167 |
| 46216 | // Methods (detail_Estimator) |  | 46168 | // Methods (detail_Estimator)
| 46217 |  |  | 46169 |
| 46218 | static PyObject* pyopencv_cv_detail_detail_Estimator_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46170 | static PyObject* pyopencv_cv_detail_detail_Estimator_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 46219 | { |  | 46171 | {
| 46220 | using namespace cv::detail; |  | 46172 | using namespace cv::detail;
| 46221 |  |  | 46173 |
| 46222 |  |  | 46174 |
| 46223 | Ptr<cv::detail::Estimator> * self1 = 0; |  | 46175 | Ptr<cv::detail::Estimator> * self1 = 0;
| 46224 | if (!pyopencv_detail_Estimator_getp(self, self1)) |  | 46176 | if (!pyopencv_detail_Estimator_getp(self, self1))
| 46225 | return failmsgp("Incorrect type of self (must be 'detail_Estimator' or its derivative)"); |  | 46177 | return failmsgp("Incorrect type of self (must be 'detail_Estimator' or its derivative)");
| 46226 | Ptr<cv::detail::Estimator> _self_ = *(self1); |  | 46178 | Ptr<cv::detail::Estimator> _self_ = *(self1);
| 46227 | PyObject* pyobj_features = NULL; |  | 46179 | PyObject* pyobj_features = NULL;
| 46228 | vector_ImageFeatures features; |  | 46180 | vector_ImageFeatures features;
| 46229 | PyObject* pyobj_pairwise_matches = NULL; |  | 46181 | PyObject* pyobj_pairwise_matches = NULL;
| 46230 | vector_MatchesInfo pairwise_matches; |  | 46182 | vector_MatchesInfo pairwise_matches;
| 46231 | PyObject* pyobj_cameras = NULL; |  | 46183 | PyObject* pyobj_cameras = NULL;
| 46232 | vector_CameraParams cameras; |  | 46184 | vector_CameraParams cameras;
| 46233 | bool retval; |  | 46185 | bool retval;
| 46234 |  |  | 46186 |
| 46235 | const char* keywords[] = { "features", "pairwise_matches", "cameras", NULL }; |  | 46187 | const char* keywords[] = { "features", "pairwise_matches", "cameras", NULL };
| 46236 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Estimator.apply", (char**)keywords, &pyobj_features, &pyobj_pairwise_matches, &pyobj_cameras) && |  | 46188 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Estimator.apply", (char**)keywords, &pyobj_features, &pyobj_pairwise_matches, &pyobj_cameras) &&
| 46237 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 46189 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 46238 | pyopencv_to_safe(pyobj_pairwise_matches, pairwise_matches, ArgInfo("pairwise_matches", 0)) && |  | 46190 | pyopencv_to_safe(pyobj_pairwise_matches, pairwise_matches, ArgInfo("pairwise_matches", 0)) &&
| 46239 | pyopencv_to_safe(pyobj_cameras, cameras, ArgInfo("cameras", 1)) ) |  | 46191 | pyopencv_to_safe(pyobj_cameras, cameras, ArgInfo("cameras", 1)) )
| 46240 | { |  | 46192 | {
| 46241 | ERRWRAP2(retval = _self_->operator ()(features, pairwise_matches, cameras)); |  | 46193 | ERRWRAP2(retval = _self_->operator ()(features, pairwise_matches, cameras));
| 46242 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(cameras)); |  | 46194 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(cameras));
| 46243 | } |  | 46195 | }
| 46244 |  |  | 46196 |
| 46245 | return NULL; |  | 46197 | return NULL;
| 46246 | } |  | 46198 | }
| 46247 |  |  | 46199 |
| 46248 |  |  | 46200 |
| 46249 |  |  | 46201 |
| 46250 | // Tables (detail_Estimator) |  | 46202 | // Tables (detail_Estimator)
| 46251 |  |  | 46203 |
| 46252 | static PyGetSetDef pyopencv_detail_Estimator_getseters[] = |  | 46204 | static PyGetSetDef pyopencv_detail_Estimator_getseters[] =
| 46253 | { |  | 46205 | {
| 46254 | {NULL} /* Sentinel */ |  | 46206 | {NULL} /* Sentinel */
| 46255 | }; |  | 46207 | };
| 46256 |  |  | 46208 |
| 46257 | static PyMethodDef pyopencv_detail_Estimator_methods[] = |  | 46209 | static PyMethodDef pyopencv_detail_Estimator_methods[] =
| 46258 | { |  | 46210 | {
| 46259 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Estimator_apply, 0), "apply(features, pairwise_matches, cameras) -> retval, cameras\n. @brief Estimates camera parameters.\n. \n. @param features Features of images\n. @param pairwise_matches Pairwise matches of images\n. @param cameras Estimated camera parameters\n. @return True in case of success, false otherwise"}, |  | 46211 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Estimator_apply, 0), "apply(features, pairwise_matches, cameras) -> retval, cameras\n. @brief Estimates camera parameters.\n. \n. @param features Features of images\n. @param pairwise_matches Pairwise matches of images\n. @param cameras Estimated camera parameters\n. @return True in case of success, false otherwise"},
| 46260 |  |  | 46212 |
| 46261 | {NULL, NULL} |  | 46213 | {NULL, NULL}
| 46262 | }; |  | 46214 | };
| 46263 |  |  | 46215 |
| 46264 | // Converter (detail_Estimator) |  | 46216 | // Converter (detail_Estimator)
| 46265 |  |  | 46217 |
| 46266 | template<> |  | 46218 | template<>
| 46267 | struct PyOpenCV_Converter< Ptr<cv::detail::Estimator> > |  | 46219 | struct PyOpenCV_Converter< Ptr<cv::detail::Estimator> >
| 46268 | { |  | 46220 | {
| 46269 | static PyObject* from(const Ptr<cv::detail::Estimator>& r) |  | 46221 | static PyObject* from(const Ptr<cv::detail::Estimator>& r)
| 46270 | { |  | 46222 | {
| 46271 | return pyopencv_detail_Estimator_Instance(r); |  | 46223 | return pyopencv_detail_Estimator_Instance(r);
| 46272 | } |  | 46224 | }
| 46273 | static bool to(PyObject* src, Ptr<cv::detail::Estimator>& dst, const ArgInfo& info) |  | 46225 | static bool to(PyObject* src, Ptr<cv::detail::Estimator>& dst, const ArgInfo& info)
| 46274 | { |  | 46226 | {
| 46275 | if(!src || src == Py_None) |  | 46227 | if(!src || src == Py_None)
| 46276 | return true; |  | 46228 | return true;
| 46277 | Ptr<cv::detail::Estimator> * dst_; |  | 46229 | Ptr<cv::detail::Estimator> * dst_;
| 46278 | if (pyopencv_detail_Estimator_getp(src, dst_)) |  | 46230 | if (pyopencv_detail_Estimator_getp(src, dst_))
| 46279 | { |  | 46231 | {
| 46280 | dst = *dst_; |  | 46232 | dst = *dst_;
| 46281 | return true; |  | 46233 | return true;
| 46282 | } |  | 46234 | }
| 46283 |  |  | 46235 |
| 46284 | failmsg("Expected Ptr<cv::detail::Estimator> for argument '%s'", info.name); |  | 46236 | failmsg("Expected Ptr<cv::detail::Estimator> for argument '%s'", info.name);
| 46285 | return false; |  | 46237 | return false;
| 46286 | } |  | 46238 | }
| 46287 | }; |  | 46239 | };
| 46288 |  |  | 46240 |
| 46289 | //================================================================================ |  | 46241 | //================================================================================
| 46290 | // detail_ExposureCompensator (Generic) |  | 46242 | // detail_ExposureCompensator (Generic)
| 46291 | //================================================================================ |  | 46243 | //================================================================================
| 46292 |  |  | 46244 |
| 46293 | // GetSet (detail_ExposureCompensator) |  | 46245 | // GetSet (detail_ExposureCompensator)
| 46294 |  |  | 46246 |
| 46295 |  |  | 46247 |
| 46296 |  |  | 46248 |
| 46297 | // Methods (detail_ExposureCompensator) |  | 46249 | // Methods (detail_ExposureCompensator)
| 46298 |  |  | 46250 |
| 46299 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46251 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 46300 | { |  | 46252 | {
| 46301 | using namespace cv::detail; |  | 46253 | using namespace cv::detail;
| 46302 |  |  | 46254 |
| 46303 |  |  | 46255 |
| 46304 | Ptr<cv::detail::ExposureCompensator> * self1 = 0; |  | 46256 | Ptr<cv::detail::ExposureCompensator> * self1 = 0;
| 46305 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1)) |  | 46257 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1))
| 46306 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)"); |  | 46258 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)");
| 46307 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1); |  | 46259 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1);
| 46308 | pyPrepareArgumentConversionErrorsStorage(2); |  | 46260 | pyPrepareArgumentConversionErrorsStorage(2);
| 46309 |  |  | 46261 |
| 46310 | { |  | 46262 | {
| 46311 | PyObject* pyobj_index = NULL; |  | 46263 | PyObject* pyobj_index = NULL;
| 46312 | int index=0; |  | 46264 | int index=0;
| 46313 | PyObject* pyobj_corner = NULL; |  | 46265 | PyObject* pyobj_corner = NULL;
| 46314 | Point corner; |  | 46266 | Point corner;
| 46315 | PyObject* pyobj_image = NULL; |  | 46267 | PyObject* pyobj_image = NULL;
| 46316 | Mat image; |  | 46268 | Mat image;
| 46317 | PyObject* pyobj_mask = NULL; |  | 46269 | PyObject* pyobj_mask = NULL;
| 46318 | Mat mask; |  | 46270 | Mat mask;
| 46319 |  |  | 46271 |
| 46320 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 46272 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 46321 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ExposureCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 46273 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ExposureCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 46322 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 46274 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 46323 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 46275 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 46324 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 46276 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 46325 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 46277 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 46326 | { |  | 46278 | {
| 46327 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 46279 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 46328 | return pyopencv_from(image); |  | 46280 | return pyopencv_from(image);
| 46329 | } |  | 46281 | }
| 46330 |  |  | 46282 |
| 46331 |  |  | 46283 |
| 46332 | pyPopulateArgumentConversionErrors(); |  | 46284 | pyPopulateArgumentConversionErrors();
| 46333 | } |  | 46285 | }
| 46334 |  |  | 46286 |
| 46335 |  |  | 46287 |
| 46336 | { |  | 46288 | {
| 46337 | PyObject* pyobj_index = NULL; |  | 46289 | PyObject* pyobj_index = NULL;
| 46338 | int index=0; |  | 46290 | int index=0;
| 46339 | PyObject* pyobj_corner = NULL; |  | 46291 | PyObject* pyobj_corner = NULL;
| 46340 | Point corner; |  | 46292 | Point corner;
| 46341 | PyObject* pyobj_image = NULL; |  | 46293 | PyObject* pyobj_image = NULL;
| 46342 | UMat image; |  | 46294 | UMat image;
| 46343 | PyObject* pyobj_mask = NULL; |  | 46295 | PyObject* pyobj_mask = NULL;
| 46344 | UMat mask; |  | 46296 | UMat mask;
| 46345 |  |  | 46297 |
| 46346 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 46298 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 46347 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ExposureCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 46299 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_ExposureCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 46348 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 46300 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 46349 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 46301 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 46350 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 46302 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 46351 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 46303 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 46352 | { |  | 46304 | {
| 46353 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 46305 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 46354 | return pyopencv_from(image); |  | 46306 | return pyopencv_from(image);
| 46355 | } |  | 46307 | }
| 46356 |  |  | 46308 |
| 46357 |  |  | 46309 |
| 46358 | pyPopulateArgumentConversionErrors(); |  | 46310 | pyPopulateArgumentConversionErrors();
| 46359 | } |  | 46311 | }
| 46360 | pyRaiseCVOverloadException("apply"); |  | 46312 | pyRaiseCVOverloadException("apply");
| 46361 |  |  | 46313 |
| 46362 | return NULL; |  | 46314 | return NULL;
| 46363 | } |  | 46315 | }
| 46364 |  |  | 46316 |
| 46365 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46317 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 46366 | { |  | 46318 | {
| 46367 | using namespace cv::detail; |  | 46319 | using namespace cv::detail;
| 46368 |  |  | 46320 |
| 46369 | PyObject* pyobj_type = NULL; |  | 46321 | PyObject* pyobj_type = NULL;
| 46370 | int type=0; |  | 46322 | int type=0;
| 46371 | Ptr<ExposureCompensator> retval; |  | 46323 | Ptr<ExposureCompensator> retval;
| 46372 |  |  | 46324 |
| 46373 | const char* keywords[] = { "type", NULL }; |  | 46325 | const char* keywords[] = { "type", NULL };
| 46374 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ExposureCompensator.createDefault", (char**)keywords, &pyobj_type) && |  | 46326 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ExposureCompensator.createDefault", (char**)keywords, &pyobj_type) &&
| 46375 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 46327 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 46376 | { |  | 46328 | {
| 46377 | ERRWRAP2(retval = cv::detail::ExposureCompensator::createDefault(type)); |  | 46329 | ERRWRAP2(retval = cv::detail::ExposureCompensator::createDefault(type));
| 46378 | return pyopencv_from(retval); |  | 46330 | return pyopencv_from(retval);
| 46379 | } |  | 46331 | }
| 46380 |  |  | 46332 |
| 46381 | return NULL; |  | 46333 | return NULL;
| 46382 | } |  | 46334 | }
| 46383 |  |  | 46335 |
| 46384 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_feed(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46336 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_feed(PyObject* self, PyObject* py_args, PyObject* kw)
| 46385 | { |  | 46337 | {
| 46386 | using namespace cv::detail; |  | 46338 | using namespace cv::detail;
| 46387 |  |  | 46339 |
| 46388 |  |  | 46340 |
| 46389 | Ptr<cv::detail::ExposureCompensator> * self1 = 0; |  | 46341 | Ptr<cv::detail::ExposureCompensator> * self1 = 0;
| 46390 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1)) |  | 46342 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1))
| 46391 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)"); |  | 46343 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)");
| 46392 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1); |  | 46344 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1);
| 46393 | PyObject* pyobj_corners = NULL; |  | 46345 | PyObject* pyobj_corners = NULL;
| 46394 | vector_Point corners; |  | 46346 | vector_Point corners;
| 46395 | PyObject* pyobj_images = NULL; |  | 46347 | PyObject* pyobj_images = NULL;
| 46396 | vector_UMat images; |  | 46348 | vector_UMat images;
| 46397 | PyObject* pyobj_masks = NULL; |  | 46349 | PyObject* pyobj_masks = NULL;
| 46398 | vector_UMat masks; |  | 46350 | vector_UMat masks;
| 46399 |  |  | 46351 |
| 46400 | const char* keywords[] = { "corners", "images", "masks", NULL }; |  | 46352 | const char* keywords[] = { "corners", "images", "masks", NULL };
| 46401 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_ExposureCompensator.feed", (char**)keywords, &pyobj_corners, &pyobj_images, &pyobj_masks) && |  | 46353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_ExposureCompensator.feed", (char**)keywords, &pyobj_corners, &pyobj_images, &pyobj_masks) &&
| 46402 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 46354 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 46403 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 46355 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 46404 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 46356 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 46405 | { |  | 46357 | {
| 46406 | ERRWRAP2(_self_->feed(corners, images, masks)); |  | 46358 | ERRWRAP2(_self_->feed(corners, images, masks));
| 46407 | Py_RETURN_NONE; |  | 46359 | Py_RETURN_NONE;
| 46408 | } |  | 46360 | }
| 46409 |  |  | 46361 |
| 46410 | return NULL; |  | 46362 | return NULL;
| 46411 | } |  | 46363 | }
| 46412 |  |  | 46364 |
| 46413 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46365 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 46414 | { |  | 46366 | {
| 46415 | using namespace cv::detail; |  | 46367 | using namespace cv::detail;
| 46416 |  |  | 46368 |
| 46417 |  |  | 46369 |
| 46418 | Ptr<cv::detail::ExposureCompensator> * self1 = 0; |  | 46370 | Ptr<cv::detail::ExposureCompensator> * self1 = 0;
| 46419 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1)) |  | 46371 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1))
| 46420 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)"); |  | 46372 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)");
| 46421 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1); |  | 46373 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1);
| 46422 | PyObject* pyobj_arg1 = NULL; |  | 46374 | PyObject* pyobj_arg1 = NULL;
| 46423 | vector_Mat arg1; |  | 46375 | vector_Mat arg1;
| 46424 |  |  | 46376 |
| 46425 | const char* keywords[] = { "arg1", NULL }; |  | 46377 | const char* keywords[] = { "arg1", NULL };
| 46426 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_ExposureCompensator.getMatGains", (char**)keywords, &pyobj_arg1) && |  | 46378 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_ExposureCompensator.getMatGains", (char**)keywords, &pyobj_arg1) &&
| 46427 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 1)) ) |  | 46379 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 1)) )
| 46428 | { |  | 46380 | {
| 46429 | ERRWRAP2(_self_->getMatGains(arg1)); |  | 46381 | ERRWRAP2(_self_->getMatGains(arg1));
| 46430 | return pyopencv_from(arg1); |  | 46382 | return pyopencv_from(arg1);
| 46431 | } |  | 46383 | }
| 46432 |  |  | 46384 |
| 46433 | return NULL; |  | 46385 | return NULL;
| 46434 | } |  | 46386 | }
| 46435 |  |  | 46387 |
| 46436 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_getUpdateGain(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46388 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_getUpdateGain(PyObject* self, PyObject* py_args, PyObject* kw)
| 46437 | { |  | 46389 | {
| 46438 | using namespace cv::detail; |  | 46390 | using namespace cv::detail;
| 46439 |  |  | 46391 |
| 46440 |  |  | 46392 |
| 46441 | Ptr<cv::detail::ExposureCompensator> * self1 = 0; |  | 46393 | Ptr<cv::detail::ExposureCompensator> * self1 = 0;
| 46442 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1)) |  | 46394 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1))
| 46443 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)"); |  | 46395 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)");
| 46444 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1); |  | 46396 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1);
| 46445 | bool retval; |  | 46397 | bool retval;
| 46446 |  |  | 46398 |
| 46447 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 46399 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 46448 | { |  | 46400 | {
| 46449 | ERRWRAP2(retval = _self_->getUpdateGain()); |  | 46401 | ERRWRAP2(retval = _self_->getUpdateGain());
| 46450 | return pyopencv_from(retval); |  | 46402 | return pyopencv_from(retval);
| 46451 | } |  | 46403 | }
| 46452 |  |  | 46404 |
| 46453 | return NULL; |  | 46405 | return NULL;
| 46454 | } |  | 46406 | }
| 46455 |  |  | 46407 |
| 46456 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46408 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 46457 | { |  | 46409 | {
| 46458 | using namespace cv::detail; |  | 46410 | using namespace cv::detail;
| 46459 |  |  | 46411 |
| 46460 |  |  | 46412 |
| 46461 | Ptr<cv::detail::ExposureCompensator> * self1 = 0; |  | 46413 | Ptr<cv::detail::ExposureCompensator> * self1 = 0;
| 46462 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1)) |  | 46414 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1))
| 46463 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)"); |  | 46415 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)");
| 46464 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1); |  | 46416 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1);
| 46465 | PyObject* pyobj_arg1 = NULL; |  | 46417 | PyObject* pyobj_arg1 = NULL;
| 46466 | vector_Mat arg1; |  | 46418 | vector_Mat arg1;
| 46467 |  |  | 46419 |
| 46468 | const char* keywords[] = { "arg1", NULL }; |  | 46420 | const char* keywords[] = { "arg1", NULL };
| 46469 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ExposureCompensator.setMatGains", (char**)keywords, &pyobj_arg1) && |  | 46421 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ExposureCompensator.setMatGains", (char**)keywords, &pyobj_arg1) &&
| 46470 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) ) |  | 46422 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) )
| 46471 | { |  | 46423 | {
| 46472 | ERRWRAP2(_self_->setMatGains(arg1)); |  | 46424 | ERRWRAP2(_self_->setMatGains(arg1));
| 46473 | Py_RETURN_NONE; |  | 46425 | Py_RETURN_NONE;
| 46474 | } |  | 46426 | }
| 46475 |  |  | 46427 |
| 46476 | return NULL; |  | 46428 | return NULL;
| 46477 | } |  | 46429 | }
| 46478 |  |  | 46430 |
| 46479 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_setUpdateGain(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46431 | static PyObject* pyopencv_cv_detail_detail_ExposureCompensator_setUpdateGain(PyObject* self, PyObject* py_args, PyObject* kw)
| 46480 | { |  | 46432 | {
| 46481 | using namespace cv::detail; |  | 46433 | using namespace cv::detail;
| 46482 |  |  | 46434 |
| 46483 |  |  | 46435 |
| 46484 | Ptr<cv::detail::ExposureCompensator> * self1 = 0; |  | 46436 | Ptr<cv::detail::ExposureCompensator> * self1 = 0;
| 46485 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1)) |  | 46437 | if (!pyopencv_detail_ExposureCompensator_getp(self, self1))
| 46486 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)"); |  | 46438 | return failmsgp("Incorrect type of self (must be 'detail_ExposureCompensator' or its derivative)");
| 46487 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1); |  | 46439 | Ptr<cv::detail::ExposureCompensator> _self_ = *(self1);
| 46488 | PyObject* pyobj_b = NULL; |  | 46440 | PyObject* pyobj_b = NULL;
| 46489 | bool b=0; |  | 46441 | bool b=0;
| 46490 |  |  | 46442 |
| 46491 | const char* keywords[] = { "b", NULL }; |  | 46443 | const char* keywords[] = { "b", NULL };
| 46492 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ExposureCompensator.setUpdateGain", (char**)keywords, &pyobj_b) && |  | 46444 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_ExposureCompensator.setUpdateGain", (char**)keywords, &pyobj_b) &&
| 46493 | pyopencv_to_safe(pyobj_b, b, ArgInfo("b", 0)) ) |  | 46445 | pyopencv_to_safe(pyobj_b, b, ArgInfo("b", 0)) )
| 46494 | { |  | 46446 | {
| 46495 | ERRWRAP2(_self_->setUpdateGain(b)); |  | 46447 | ERRWRAP2(_self_->setUpdateGain(b));
| 46496 | Py_RETURN_NONE; |  | 46448 | Py_RETURN_NONE;
| 46497 | } |  | 46449 | }
| 46498 |  |  | 46450 |
| 46499 | return NULL; |  | 46451 | return NULL;
| 46500 | } |  | 46452 | }
| 46501 |  |  | 46453 |
| 46502 |  |  | 46454 |
| 46503 |  |  | 46455 |
| 46504 | // Tables (detail_ExposureCompensator) |  | 46456 | // Tables (detail_ExposureCompensator)
| 46505 |  |  | 46457 |
| 46506 | static PyGetSetDef pyopencv_detail_ExposureCompensator_getseters[] = |  | 46458 | static PyGetSetDef pyopencv_detail_ExposureCompensator_getseters[] =
| 46507 | { |  | 46459 | {
| 46508 | {NULL} /* Sentinel */ |  | 46460 | {NULL} /* Sentinel */
| 46509 | }; |  | 46461 | };
| 46510 |  |  | 46462 |
| 46511 | static PyMethodDef pyopencv_detail_ExposureCompensator_methods[] = |  | 46463 | static PyMethodDef pyopencv_detail_ExposureCompensator_methods[] =
| 46512 | { |  | 46464 | {
| 46513 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n. @brief Compensate exposure in the specified image.\n. \n. @param index Image index\n. @param corner Image top-left corner\n. @param image Image to process\n. @param mask Image mask"}, |  | 46465 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n. @brief Compensate exposure in the specified image.\n. \n. @param index Image index\n. @param corner Image top-left corner\n. @param image Image to process\n. @param mask Image mask"},
| 46514 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_createDefault_static, METH_STATIC), "createDefault(type) -> retval\n."}, |  | 46466 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_createDefault_static, METH_STATIC), "createDefault(type) -> retval\n."},
| 46515 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_feed, 0), "feed(corners, images, masks) -> None\n. @param corners Source image top-left corners\n. @param images Source images\n. @param masks Image masks to update (second value in pair specifies the value which should be used\n. to detect where image is)"}, |  | 46467 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_feed, 0), "feed(corners, images, masks) -> None\n. @param corners Source image top-left corners\n. @param images Source images\n. @param masks Image masks to update (second value in pair specifies the value which should be used\n. to detect where image is)"},
| 46516 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_getMatGains, 0), "getMatGains([, arg1]) -> arg1\n."}, |  | 46468 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_getMatGains, 0), "getMatGains([, arg1]) -> arg1\n."},
| 46517 | {"getUpdateGain", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_getUpdateGain, 0), "getUpdateGain() -> retval\n."}, |  | 46469 | {"getUpdateGain", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_getUpdateGain, 0), "getUpdateGain() -> retval\n."},
| 46518 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_setMatGains, 0), "setMatGains(arg1) -> None\n."}, |  | 46470 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_setMatGains, 0), "setMatGains(arg1) -> None\n."},
| 46519 | {"setUpdateGain", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_setUpdateGain, 0), "setUpdateGain(b) -> None\n."}, |  | 46471 | {"setUpdateGain", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ExposureCompensator_setUpdateGain, 0), "setUpdateGain(b) -> None\n."},
| 46520 |  |  | 46472 |
| 46521 | {NULL, NULL} |  | 46473 | {NULL, NULL}
| 46522 | }; |  | 46474 | };
| 46523 |  |  | 46475 |
| 46524 | // Converter (detail_ExposureCompensator) |  | 46476 | // Converter (detail_ExposureCompensator)
| 46525 |  |  | 46477 |
| 46526 | template<> |  | 46478 | template<>
| 46527 | struct PyOpenCV_Converter< Ptr<cv::detail::ExposureCompensator> > |  | 46479 | struct PyOpenCV_Converter< Ptr<cv::detail::ExposureCompensator> >
| 46528 | { |  | 46480 | {
| 46529 | static PyObject* from(const Ptr<cv::detail::ExposureCompensator>& r) |  | 46481 | static PyObject* from(const Ptr<cv::detail::ExposureCompensator>& r)
| 46530 | { |  | 46482 | {
| 46531 | return pyopencv_detail_ExposureCompensator_Instance(r); |  | 46483 | return pyopencv_detail_ExposureCompensator_Instance(r);
| 46532 | } |  | 46484 | }
| 46533 | static bool to(PyObject* src, Ptr<cv::detail::ExposureCompensator>& dst, const ArgInfo& info) |  | 46485 | static bool to(PyObject* src, Ptr<cv::detail::ExposureCompensator>& dst, const ArgInfo& info)
| 46534 | { |  | 46486 | {
| 46535 | if(!src || src == Py_None) |  | 46487 | if(!src || src == Py_None)
| 46536 | return true; |  | 46488 | return true;
| 46537 | Ptr<cv::detail::ExposureCompensator> * dst_; |  | 46489 | Ptr<cv::detail::ExposureCompensator> * dst_;
| 46538 | if (pyopencv_detail_ExposureCompensator_getp(src, dst_)) |  | 46490 | if (pyopencv_detail_ExposureCompensator_getp(src, dst_))
| 46539 | { |  | 46491 | {
| 46540 | dst = *dst_; |  | 46492 | dst = *dst_;
| 46541 | return true; |  | 46493 | return true;
| 46542 | } |  | 46494 | }
| 46543 |  |  | 46495 |
| 46544 | failmsg("Expected Ptr<cv::detail::ExposureCompensator> for argument '%s'", info.name); |  | 46496 | failmsg("Expected Ptr<cv::detail::ExposureCompensator> for argument '%s'", info.name);
| 46545 | return false; |  | 46497 | return false;
| 46546 | } |  | 46498 | }
| 46547 | }; |  | 46499 | };
| 46548 |  |  | 46500 |
| 46549 | //================================================================================ |  | 46501 | //================================================================================
| 46550 | // detail_FeatherBlender (Generic) |  | 46502 | // detail_FeatherBlender (Generic)
| 46551 | //================================================================================ |  | 46503 | //================================================================================
| 46552 |  |  | 46504 |
| 46553 | // GetSet (detail_FeatherBlender) |  | 46505 | // GetSet (detail_FeatherBlender)
| 46554 |  |  | 46506 |
| 46555 |  |  | 46507 |
| 46556 |  |  | 46508 |
| 46557 | // Methods (detail_FeatherBlender) |  | 46509 | // Methods (detail_FeatherBlender)
| 46558 |  |  | 46510 |
| 46559 | static int pyopencv_cv_detail_detail_FeatherBlender_FeatherBlender(pyopencv_detail_FeatherBlender_t* self, PyObject* py_args, PyObject* kw) |  | 46511 | static int pyopencv_cv_detail_detail_FeatherBlender_FeatherBlender(pyopencv_detail_FeatherBlender_t* self, PyObject* py_args, PyObject* kw)
| 46560 | { |  | 46512 | {
| 46561 | using namespace cv::detail; |  | 46513 | using namespace cv::detail;
| 46562 |  |  | 46514 |
| 46563 | PyObject* pyobj_sharpness = NULL; |  | 46515 | PyObject* pyobj_sharpness = NULL;
| 46564 | float sharpness=0.02f; |  | 46516 | float sharpness=0.02f;
| 46565 |  |  | 46517 |
| 46566 | const char* keywords[] = { "sharpness", NULL }; |  | 46518 | const char* keywords[] = { "sharpness", NULL };
| 46567 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:FeatherBlender", (char**)keywords, &pyobj_sharpness) && |  | 46519 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:FeatherBlender", (char**)keywords, &pyobj_sharpness) &&
| 46568 | pyopencv_to_safe(pyobj_sharpness, sharpness, ArgInfo("sharpness", 0)) ) |  | 46520 | pyopencv_to_safe(pyobj_sharpness, sharpness, ArgInfo("sharpness", 0)) )
| 46569 | { |  | 46521 | {
| 46570 | new (&(self->v)) Ptr<cv::detail::FeatherBlender>(); // init Ptr with placement new |  | 46522 | new (&(self->v)) Ptr<cv::detail::FeatherBlender>(); // init Ptr with placement new
| 46571 | if(self) ERRWRAP2(self->v.reset(new cv::detail::FeatherBlender(sharpness))); |  | 46523 | if(self) ERRWRAP2(self->v.reset(new cv::detail::FeatherBlender(sharpness)));
| 46572 | return 0; |  | 46524 | return 0;
| 46573 | } |  | 46525 | }
| 46574 |  |  | 46526 |
| 46575 | return -1; |  | 46527 | return -1;
| 46576 | } |  | 46528 | }
| 46577 |  |  | 46529 |
| 46578 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_blend(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46530 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_blend(PyObject* self, PyObject* py_args, PyObject* kw)
| 46579 | { |  | 46531 | {
| 46580 | using namespace cv::detail; |  | 46532 | using namespace cv::detail;
| 46581 |  |  | 46533 |
| 46582 |  |  | 46534 |
| 46583 | Ptr<cv::detail::FeatherBlender> * self1 = 0; |  | 46535 | Ptr<cv::detail::FeatherBlender> * self1 = 0;
| 46584 | if (!pyopencv_detail_FeatherBlender_getp(self, self1)) |  | 46536 | if (!pyopencv_detail_FeatherBlender_getp(self, self1))
| 46585 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)"); |  | 46537 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)");
| 46586 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1); |  | 46538 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1);
| 46587 | pyPrepareArgumentConversionErrorsStorage(2); |  | 46539 | pyPrepareArgumentConversionErrorsStorage(2);
| 46588 |  |  | 46540 |
| 46589 | { |  | 46541 | {
| 46590 | PyObject* pyobj_dst = NULL; |  | 46542 | PyObject* pyobj_dst = NULL;
| 46591 | Mat dst; |  | 46543 | Mat dst;
| 46592 | PyObject* pyobj_dst_mask = NULL; |  | 46544 | PyObject* pyobj_dst_mask = NULL;
| 46593 | Mat dst_mask; |  | 46545 | Mat dst_mask;
| 46594 |  |  | 46546 |
| 46595 | const char* keywords[] = { "dst", "dst_mask", NULL }; |  | 46547 | const char* keywords[] = { "dst", "dst_mask", NULL };
| 46596 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_FeatherBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) && |  | 46548 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_FeatherBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) &&
| 46597 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 46549 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 46598 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) ) |  | 46550 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) )
| 46599 | { |  | 46551 | {
| 46600 | ERRWRAP2(_self_->blend(dst, dst_mask)); |  | 46552 | ERRWRAP2(_self_->blend(dst, dst_mask));
| 46601 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask)); |  | 46553 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask));
| 46602 | } |  | 46554 | }
| 46603 |  |  | 46555 |
| 46604 |  |  | 46556 |
| 46605 | pyPopulateArgumentConversionErrors(); |  | 46557 | pyPopulateArgumentConversionErrors();
| 46606 | } |  | 46558 | }
| 46607 |  |  | 46559 |
| 46608 |  |  | 46560 |
| 46609 | { |  | 46561 | {
| 46610 | PyObject* pyobj_dst = NULL; |  | 46562 | PyObject* pyobj_dst = NULL;
| 46611 | UMat dst; |  | 46563 | UMat dst;
| 46612 | PyObject* pyobj_dst_mask = NULL; |  | 46564 | PyObject* pyobj_dst_mask = NULL;
| 46613 | UMat dst_mask; |  | 46565 | UMat dst_mask;
| 46614 |  |  | 46566 |
| 46615 | const char* keywords[] = { "dst", "dst_mask", NULL }; |  | 46567 | const char* keywords[] = { "dst", "dst_mask", NULL };
| 46616 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_FeatherBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) && |  | 46568 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_FeatherBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) &&
| 46617 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 46569 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 46618 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) ) |  | 46570 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) )
| 46619 | { |  | 46571 | {
| 46620 | ERRWRAP2(_self_->blend(dst, dst_mask)); |  | 46572 | ERRWRAP2(_self_->blend(dst, dst_mask));
| 46621 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask)); |  | 46573 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask));
| 46622 | } |  | 46574 | }
| 46623 |  |  | 46575 |
| 46624 |  |  | 46576 |
| 46625 | pyPopulateArgumentConversionErrors(); |  | 46577 | pyPopulateArgumentConversionErrors();
| 46626 | } |  | 46578 | }
| 46627 | pyRaiseCVOverloadException("blend"); |  | 46579 | pyRaiseCVOverloadException("blend");
| 46628 |  |  | 46580 |
| 46629 | return NULL; |  | 46581 | return NULL;
| 46630 | } |  | 46582 | }
| 46631 |  |  | 46583 |
| 46632 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_createWeightMaps(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46584 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_createWeightMaps(PyObject* self, PyObject* py_args, PyObject* kw)
| 46633 | { |  | 46585 | {
| 46634 | using namespace cv::detail; |  | 46586 | using namespace cv::detail;
| 46635 |  |  | 46587 |
| 46636 |  |  | 46588 |
| 46637 | Ptr<cv::detail::FeatherBlender> * self1 = 0; |  | 46589 | Ptr<cv::detail::FeatherBlender> * self1 = 0;
| 46638 | if (!pyopencv_detail_FeatherBlender_getp(self, self1)) |  | 46590 | if (!pyopencv_detail_FeatherBlender_getp(self, self1))
| 46639 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)"); |  | 46591 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)");
| 46640 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1); |  | 46592 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1);
| 46641 | PyObject* pyobj_masks = NULL; |  | 46593 | PyObject* pyobj_masks = NULL;
| 46642 | vector_UMat masks; |  | 46594 | vector_UMat masks;
| 46643 | PyObject* pyobj_corners = NULL; |  | 46595 | PyObject* pyobj_corners = NULL;
| 46644 | vector_Point corners; |  | 46596 | vector_Point corners;
| 46645 | PyObject* pyobj_weight_maps = NULL; |  | 46597 | PyObject* pyobj_weight_maps = NULL;
| 46646 | vector_UMat weight_maps; |  | 46598 | vector_UMat weight_maps;
| 46647 | Rect retval; |  | 46599 | Rect retval;
| 46648 |  |  | 46600 |
| 46649 | const char* keywords[] = { "masks", "corners", "weight_maps", NULL }; |  | 46601 | const char* keywords[] = { "masks", "corners", "weight_maps", NULL };
| 46650 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_FeatherBlender.createWeightMaps", (char**)keywords, &pyobj_masks, &pyobj_corners, &pyobj_weight_maps) && |  | 46602 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_FeatherBlender.createWeightMaps", (char**)keywords, &pyobj_masks, &pyobj_corners, &pyobj_weight_maps) &&
| 46651 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 46603 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 46652 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 46604 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 46653 | pyopencv_to_safe(pyobj_weight_maps, weight_maps, ArgInfo("weight_maps", 1)) ) |  | 46605 | pyopencv_to_safe(pyobj_weight_maps, weight_maps, ArgInfo("weight_maps", 1)) )
| 46654 | { |  | 46606 | {
| 46655 | ERRWRAP2(retval = _self_->createWeightMaps(masks, corners, weight_maps)); |  | 46607 | ERRWRAP2(retval = _self_->createWeightMaps(masks, corners, weight_maps));
| 46656 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(weight_maps)); |  | 46608 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(weight_maps));
| 46657 | } |  | 46609 | }
| 46658 |  |  | 46610 |
| 46659 | return NULL; |  | 46611 | return NULL;
| 46660 | } |  | 46612 | }
| 46661 |  |  | 46613 |
| 46662 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_feed(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46614 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_feed(PyObject* self, PyObject* py_args, PyObject* kw)
| 46663 | { |  | 46615 | {
| 46664 | using namespace cv::detail; |  | 46616 | using namespace cv::detail;
| 46665 |  |  | 46617 |
| 46666 |  |  | 46618 |
| 46667 | Ptr<cv::detail::FeatherBlender> * self1 = 0; |  | 46619 | Ptr<cv::detail::FeatherBlender> * self1 = 0;
| 46668 | if (!pyopencv_detail_FeatherBlender_getp(self, self1)) |  | 46620 | if (!pyopencv_detail_FeatherBlender_getp(self, self1))
| 46669 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)"); |  | 46621 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)");
| 46670 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1); |  | 46622 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1);
| 46671 | pyPrepareArgumentConversionErrorsStorage(2); |  | 46623 | pyPrepareArgumentConversionErrorsStorage(2);
| 46672 |  |  | 46624 |
| 46673 | { |  | 46625 | {
| 46674 | PyObject* pyobj_img = NULL; |  | 46626 | PyObject* pyobj_img = NULL;
| 46675 | Mat img; |  | 46627 | Mat img;
| 46676 | PyObject* pyobj_mask = NULL; |  | 46628 | PyObject* pyobj_mask = NULL;
| 46677 | Mat mask; |  | 46629 | Mat mask;
| 46678 | PyObject* pyobj_tl = NULL; |  | 46630 | PyObject* pyobj_tl = NULL;
| 46679 | Point tl; |  | 46631 | Point tl;
| 46680 |  |  | 46632 |
| 46681 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 46633 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 46682 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_FeatherBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 46634 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_FeatherBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 46683 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 46635 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 46684 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 46636 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 46685 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 46637 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 46686 | { |  | 46638 | {
| 46687 | ERRWRAP2(_self_->feed(img, mask, tl)); |  | 46639 | ERRWRAP2(_self_->feed(img, mask, tl));
| 46688 | Py_RETURN_NONE; |  | 46640 | Py_RETURN_NONE;
| 46689 | } |  | 46641 | }
| 46690 |  |  | 46642 |
| 46691 |  |  | 46643 |
| 46692 | pyPopulateArgumentConversionErrors(); |  | 46644 | pyPopulateArgumentConversionErrors();
| 46693 | } |  | 46645 | }
| 46694 |  |  | 46646 |
| 46695 |  |  | 46647 |
| 46696 | { |  | 46648 | {
| 46697 | PyObject* pyobj_img = NULL; |  | 46649 | PyObject* pyobj_img = NULL;
| 46698 | UMat img; |  | 46650 | UMat img;
| 46699 | PyObject* pyobj_mask = NULL; |  | 46651 | PyObject* pyobj_mask = NULL;
| 46700 | UMat mask; |  | 46652 | UMat mask;
| 46701 | PyObject* pyobj_tl = NULL; |  | 46653 | PyObject* pyobj_tl = NULL;
| 46702 | Point tl; |  | 46654 | Point tl;
| 46703 |  |  | 46655 |
| 46704 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 46656 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 46705 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_FeatherBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 46657 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_FeatherBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 46706 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 46658 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 46707 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 46659 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 46708 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 46660 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 46709 | { |  | 46661 | {
| 46710 | ERRWRAP2(_self_->feed(img, mask, tl)); |  | 46662 | ERRWRAP2(_self_->feed(img, mask, tl));
| 46711 | Py_RETURN_NONE; |  | 46663 | Py_RETURN_NONE;
| 46712 | } |  | 46664 | }
| 46713 |  |  | 46665 |
| 46714 |  |  | 46666 |
| 46715 | pyPopulateArgumentConversionErrors(); |  | 46667 | pyPopulateArgumentConversionErrors();
| 46716 | } |  | 46668 | }
| 46717 | pyRaiseCVOverloadException("feed"); |  | 46669 | pyRaiseCVOverloadException("feed");
| 46718 |  |  | 46670 |
| 46719 | return NULL; |  | 46671 | return NULL;
| 46720 | } |  | 46672 | }
| 46721 |  |  | 46673 |
| 46722 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_prepare(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46674 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_prepare(PyObject* self, PyObject* py_args, PyObject* kw)
| 46723 | { |  | 46675 | {
| 46724 | using namespace cv::detail; |  | 46676 | using namespace cv::detail;
| 46725 |  |  | 46677 |
| 46726 |  |  | 46678 |
| 46727 | Ptr<cv::detail::FeatherBlender> * self1 = 0; |  | 46679 | Ptr<cv::detail::FeatherBlender> * self1 = 0;
| 46728 | if (!pyopencv_detail_FeatherBlender_getp(self, self1)) |  | 46680 | if (!pyopencv_detail_FeatherBlender_getp(self, self1))
| 46729 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)"); |  | 46681 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)");
| 46730 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1); |  | 46682 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1);
| 46731 | PyObject* pyobj_dst_roi = NULL; |  | 46683 | PyObject* pyobj_dst_roi = NULL;
| 46732 | Rect dst_roi; |  | 46684 | Rect dst_roi;
| 46733 |  |  | 46685 |
| 46734 | const char* keywords[] = { "dst_roi", NULL }; |  | 46686 | const char* keywords[] = { "dst_roi", NULL };
| 46735 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_FeatherBlender.prepare", (char**)keywords, &pyobj_dst_roi) && |  | 46687 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_FeatherBlender.prepare", (char**)keywords, &pyobj_dst_roi) &&
| 46736 | pyopencv_to_safe(pyobj_dst_roi, dst_roi, ArgInfo("dst_roi", 0)) ) |  | 46688 | pyopencv_to_safe(pyobj_dst_roi, dst_roi, ArgInfo("dst_roi", 0)) )
| 46737 | { |  | 46689 | {
| 46738 | ERRWRAP2(_self_->prepare(dst_roi)); |  | 46690 | ERRWRAP2(_self_->prepare(dst_roi));
| 46739 | Py_RETURN_NONE; |  | 46691 | Py_RETURN_NONE;
| 46740 | } |  | 46692 | }
| 46741 |  |  | 46693 |
| 46742 | return NULL; |  | 46694 | return NULL;
| 46743 | } |  | 46695 | }
| 46744 |  |  | 46696 |
| 46745 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_setSharpness(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46697 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_setSharpness(PyObject* self, PyObject* py_args, PyObject* kw)
| 46746 | { |  | 46698 | {
| 46747 | using namespace cv::detail; |  | 46699 | using namespace cv::detail;
| 46748 |  |  | 46700 |
| 46749 |  |  | 46701 |
| 46750 | Ptr<cv::detail::FeatherBlender> * self1 = 0; |  | 46702 | Ptr<cv::detail::FeatherBlender> * self1 = 0;
| 46751 | if (!pyopencv_detail_FeatherBlender_getp(self, self1)) |  | 46703 | if (!pyopencv_detail_FeatherBlender_getp(self, self1))
| 46752 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)"); |  | 46704 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)");
| 46753 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1); |  | 46705 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1);
| 46754 | PyObject* pyobj_val = NULL; |  | 46706 | PyObject* pyobj_val = NULL;
| 46755 | float val=0.f; |  | 46707 | float val=0.f;
| 46756 |  |  | 46708 |
| 46757 | const char* keywords[] = { "val", NULL }; |  | 46709 | const char* keywords[] = { "val", NULL };
| 46758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_FeatherBlender.setSharpness", (char**)keywords, &pyobj_val) && |  | 46710 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_FeatherBlender.setSharpness", (char**)keywords, &pyobj_val) &&
| 46759 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 46711 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 46760 | { |  | 46712 | {
| 46761 | ERRWRAP2(_self_->setSharpness(val)); |  | 46713 | ERRWRAP2(_self_->setSharpness(val));
| 46762 | Py_RETURN_NONE; |  | 46714 | Py_RETURN_NONE;
| 46763 | } |  | 46715 | }
| 46764 |  |  | 46716 |
| 46765 | return NULL; |  | 46717 | return NULL;
| 46766 | } |  | 46718 | }
| 46767 |  |  | 46719 |
| 46768 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_sharpness(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46720 | static PyObject* pyopencv_cv_detail_detail_FeatherBlender_sharpness(PyObject* self, PyObject* py_args, PyObject* kw)
| 46769 | { |  | 46721 | {
| 46770 | using namespace cv::detail; |  | 46722 | using namespace cv::detail;
| 46771 |  |  | 46723 |
| 46772 |  |  | 46724 |
| 46773 | Ptr<cv::detail::FeatherBlender> * self1 = 0; |  | 46725 | Ptr<cv::detail::FeatherBlender> * self1 = 0;
| 46774 | if (!pyopencv_detail_FeatherBlender_getp(self, self1)) |  | 46726 | if (!pyopencv_detail_FeatherBlender_getp(self, self1))
| 46775 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)"); |  | 46727 | return failmsgp("Incorrect type of self (must be 'detail_FeatherBlender' or its derivative)");
| 46776 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1); |  | 46728 | Ptr<cv::detail::FeatherBlender> _self_ = *(self1);
| 46777 | float retval; |  | 46729 | float retval;
| 46778 |  |  | 46730 |
| 46779 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 46731 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 46780 | { |  | 46732 | {
| 46781 | ERRWRAP2(retval = _self_->sharpness()); |  | 46733 | ERRWRAP2(retval = _self_->sharpness());
| 46782 | return pyopencv_from(retval); |  | 46734 | return pyopencv_from(retval);
| 46783 | } |  | 46735 | }
| 46784 |  |  | 46736 |
| 46785 | return NULL; |  | 46737 | return NULL;
| 46786 | } |  | 46738 | }
| 46787 |  |  | 46739 |
| 46788 |  |  | 46740 |
| 46789 |  |  | 46741 |
| 46790 | // Tables (detail_FeatherBlender) |  | 46742 | // Tables (detail_FeatherBlender)
| 46791 |  |  | 46743 |
| 46792 | static PyGetSetDef pyopencv_detail_FeatherBlender_getseters[] = |  | 46744 | static PyGetSetDef pyopencv_detail_FeatherBlender_getseters[] =
| 46793 | { |  | 46745 | {
| 46794 | {NULL} /* Sentinel */ |  | 46746 | {NULL} /* Sentinel */
| 46795 | }; |  | 46747 | };
| 46796 |  |  | 46748 |
| 46797 | static PyMethodDef pyopencv_detail_FeatherBlender_methods[] = |  | 46749 | static PyMethodDef pyopencv_detail_FeatherBlender_methods[] =
| 46798 | { |  | 46750 | {
| 46799 | {"blend", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_blend, 0), "blend(dst, dst_mask) -> dst, dst_mask\n."}, |  | 46751 | {"blend", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_blend, 0), "blend(dst, dst_mask) -> dst, dst_mask\n."},
| 46800 | {"createWeightMaps", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_createWeightMaps, 0), "createWeightMaps(masks, corners, weight_maps) -> retval, weight_maps\n."}, |  | 46752 | {"createWeightMaps", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_createWeightMaps, 0), "createWeightMaps(masks, corners, weight_maps) -> retval, weight_maps\n."},
| 46801 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_feed, 0), "feed(img, mask, tl) -> None\n."}, |  | 46753 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_feed, 0), "feed(img, mask, tl) -> None\n."},
| 46802 | {"prepare", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_prepare, 0), "prepare(dst_roi) -> None\n."}, |  | 46754 | {"prepare", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_prepare, 0), "prepare(dst_roi) -> None\n."},
| 46803 | {"setSharpness", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_setSharpness, 0), "setSharpness(val) -> None\n."}, |  | 46755 | {"setSharpness", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_setSharpness, 0), "setSharpness(val) -> None\n."},
| 46804 | {"sharpness", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_sharpness, 0), "sharpness() -> retval\n."}, |  | 46756 | {"sharpness", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeatherBlender_sharpness, 0), "sharpness() -> retval\n."},
| 46805 |  |  | 46757 |
| 46806 | {NULL, NULL} |  | 46758 | {NULL, NULL}
| 46807 | }; |  | 46759 | };
| 46808 |  |  | 46760 |
| 46809 | // Converter (detail_FeatherBlender) |  | 46761 | // Converter (detail_FeatherBlender)
| 46810 |  |  | 46762 |
| 46811 | template<> |  | 46763 | template<>
| 46812 | struct PyOpenCV_Converter< Ptr<cv::detail::FeatherBlender> > |  | 46764 | struct PyOpenCV_Converter< Ptr<cv::detail::FeatherBlender> >
| 46813 | { |  | 46765 | {
| 46814 | static PyObject* from(const Ptr<cv::detail::FeatherBlender>& r) |  | 46766 | static PyObject* from(const Ptr<cv::detail::FeatherBlender>& r)
| 46815 | { |  | 46767 | {
| 46816 | return pyopencv_detail_FeatherBlender_Instance(r); |  | 46768 | return pyopencv_detail_FeatherBlender_Instance(r);
| 46817 | } |  | 46769 | }
| 46818 | static bool to(PyObject* src, Ptr<cv::detail::FeatherBlender>& dst, const ArgInfo& info) |  | 46770 | static bool to(PyObject* src, Ptr<cv::detail::FeatherBlender>& dst, const ArgInfo& info)
| 46819 | { |  | 46771 | {
| 46820 | if(!src || src == Py_None) |  | 46772 | if(!src || src == Py_None)
| 46821 | return true; |  | 46773 | return true;
| 46822 | Ptr<cv::detail::FeatherBlender> * dst_; |  | 46774 | Ptr<cv::detail::FeatherBlender> * dst_;
| 46823 | if (pyopencv_detail_FeatherBlender_getp(src, dst_)) |  | 46775 | if (pyopencv_detail_FeatherBlender_getp(src, dst_))
| 46824 | { |  | 46776 | {
| 46825 | dst = *dst_; |  | 46777 | dst = *dst_;
| 46826 | return true; |  | 46778 | return true;
| 46827 | } |  | 46779 | }
| 46828 |  |  | 46780 |
| 46829 | failmsg("Expected Ptr<cv::detail::FeatherBlender> for argument '%s'", info.name); |  | 46781 | failmsg("Expected Ptr<cv::detail::FeatherBlender> for argument '%s'", info.name);
| 46830 | return false; |  | 46782 | return false;
| 46831 | } |  | 46783 | }
| 46832 | }; |  | 46784 | };
| 46833 |  |  | 46785 |
| 46834 | //================================================================================ |  | 46786 | //================================================================================
| 46835 | // detail_FeaturesMatcher (Generic) |  | 46787 | // detail_FeaturesMatcher (Generic)
| 46836 | //================================================================================ |  | 46788 | //================================================================================
| 46837 |  |  | 46789 |
| 46838 | // GetSet (detail_FeaturesMatcher) |  | 46790 | // GetSet (detail_FeaturesMatcher)
| 46839 |  |  | 46791 |
| 46840 |  |  | 46792 |
| 46841 |  |  | 46793 |
| 46842 | // Methods (detail_FeaturesMatcher) |  | 46794 | // Methods (detail_FeaturesMatcher)
| 46843 |  |  | 46795 |
| 46844 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46796 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 46845 | { |  | 46797 | {
| 46846 | using namespace cv::detail; |  | 46798 | using namespace cv::detail;
| 46847 |  |  | 46799 |
| 46848 |  |  | 46800 |
| 46849 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0; |  | 46801 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0;
| 46850 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1)) |  | 46802 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1))
| 46851 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)"); |  | 46803 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)");
| 46852 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1); |  | 46804 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1);
| 46853 | PyObject* pyobj_features1 = NULL; |  | 46805 | PyObject* pyobj_features1 = NULL;
| 46854 | ImageFeatures features1; |  | 46806 | ImageFeatures features1;
| 46855 | PyObject* pyobj_features2 = NULL; |  | 46807 | PyObject* pyobj_features2 = NULL;
| 46856 | ImageFeatures features2; |  | 46808 | ImageFeatures features2;
| 46857 | MatchesInfo matches_info; |  | 46809 | MatchesInfo matches_info;
| 46858 |  |  | 46810 |
| 46859 | const char* keywords[] = { "features1", "features2", NULL }; |  | 46811 | const char* keywords[] = { "features1", "features2", NULL };
| 46860 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_FeaturesMatcher.apply", (char**)keywords, &pyobj_features1, &pyobj_features2) && |  | 46812 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_FeaturesMatcher.apply", (char**)keywords, &pyobj_features1, &pyobj_features2) &&
| 46861 | pyopencv_to_safe(pyobj_features1, features1, ArgInfo("features1", 0)) && |  | 46813 | pyopencv_to_safe(pyobj_features1, features1, ArgInfo("features1", 0)) &&
| 46862 | pyopencv_to_safe(pyobj_features2, features2, ArgInfo("features2", 0)) ) |  | 46814 | pyopencv_to_safe(pyobj_features2, features2, ArgInfo("features2", 0)) )
| 46863 | { |  | 46815 | {
| 46864 | ERRWRAP2(_self_->operator ()(features1, features2, matches_info)); |  | 46816 | ERRWRAP2(_self_->operator ()(features1, features2, matches_info));
| 46865 | return pyopencv_from(matches_info); |  | 46817 | return pyopencv_from(matches_info);
| 46866 | } |  | 46818 | }
| 46867 |  |  | 46819 |
| 46868 | return NULL; |  | 46820 | return NULL;
| 46869 | } |  | 46821 | }
| 46870 |  |  | 46822 |
| 46871 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_apply2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46823 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_apply2(PyObject* self, PyObject* py_args, PyObject* kw)
| 46872 | { |  | 46824 | {
| 46873 | using namespace cv::detail; |  | 46825 | using namespace cv::detail;
| 46874 |  |  | 46826 |
| 46875 |  |  | 46827 |
| 46876 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0; |  | 46828 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0;
| 46877 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1)) |  | 46829 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1))
| 46878 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)"); |  | 46830 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)");
| 46879 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1); |  | 46831 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1);
| 46880 | PyObject* pyobj_features = NULL; |  | 46832 | PyObject* pyobj_features = NULL;
| 46881 | vector_ImageFeatures features; |  | 46833 | vector_ImageFeatures features;
| 46882 | vector_MatchesInfo pairwise_matches; |  | 46834 | vector_MatchesInfo pairwise_matches;
| 46883 | PyObject* pyobj_mask = NULL; |  | 46835 | PyObject* pyobj_mask = NULL;
| 46884 | UMat mask=cv::UMat(); |  | 46836 | UMat mask=cv::UMat();
| 46885 |  |  | 46837 |
| 46886 | const char* keywords[] = { "features", "mask", NULL }; |  | 46838 | const char* keywords[] = { "features", "mask", NULL };
| 46887 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:detail_FeaturesMatcher.apply2", (char**)keywords, &pyobj_features, &pyobj_mask) && |  | 46839 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:detail_FeaturesMatcher.apply2", (char**)keywords, &pyobj_features, &pyobj_mask) &&
| 46888 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 46840 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 46889 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 46841 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 46890 | { |  | 46842 | {
| 46891 | ERRWRAP2(_self_->operator ()(features, pairwise_matches, mask)); |  | 46843 | ERRWRAP2(_self_->operator ()(features, pairwise_matches, mask));
| 46892 | return pyopencv_from(pairwise_matches); |  | 46844 | return pyopencv_from(pairwise_matches);
| 46893 | } |  | 46845 | }
| 46894 |  |  | 46846 |
| 46895 | return NULL; |  | 46847 | return NULL;
| 46896 | } |  | 46848 | }
| 46897 |  |  | 46849 |
| 46898 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46850 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_collectGarbage(PyObject* self, PyObject* py_args, PyObject* kw)
| 46899 | { |  | 46851 | {
| 46900 | using namespace cv::detail; |  | 46852 | using namespace cv::detail;
| 46901 |  |  | 46853 |
| 46902 |  |  | 46854 |
| 46903 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0; |  | 46855 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0;
| 46904 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1)) |  | 46856 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1))
| 46905 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)"); |  | 46857 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)");
| 46906 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1); |  | 46858 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1);
| 46907 |  |  | 46859 |
| 46908 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 46860 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 46909 | { |  | 46861 | {
| 46910 | ERRWRAP2(_self_->collectGarbage()); |  | 46862 | ERRWRAP2(_self_->collectGarbage());
| 46911 | Py_RETURN_NONE; |  | 46863 | Py_RETURN_NONE;
| 46912 | } |  | 46864 | }
| 46913 |  |  | 46865 |
| 46914 | return NULL; |  | 46866 | return NULL;
| 46915 | } |  | 46867 | }
| 46916 |  |  | 46868 |
| 46917 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_isThreadSafe(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46869 | static PyObject* pyopencv_cv_detail_detail_FeaturesMatcher_isThreadSafe(PyObject* self, PyObject* py_args, PyObject* kw)
| 46918 | { |  | 46870 | {
| 46919 | using namespace cv::detail; |  | 46871 | using namespace cv::detail;
| 46920 |  |  | 46872 |
| 46921 |  |  | 46873 |
| 46922 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0; |  | 46874 | Ptr<cv::detail::FeaturesMatcher> * self1 = 0;
| 46923 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1)) |  | 46875 | if (!pyopencv_detail_FeaturesMatcher_getp(self, self1))
| 46924 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)"); |  | 46876 | return failmsgp("Incorrect type of self (must be 'detail_FeaturesMatcher' or its derivative)");
| 46925 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1); |  | 46877 | Ptr<cv::detail::FeaturesMatcher> _self_ = *(self1);
| 46926 | bool retval; |  | 46878 | bool retval;
| 46927 |  |  | 46879 |
| 46928 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 46880 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 46929 | { |  | 46881 | {
| 46930 | ERRWRAP2(retval = _self_->isThreadSafe()); |  | 46882 | ERRWRAP2(retval = _self_->isThreadSafe());
| 46931 | return pyopencv_from(retval); |  | 46883 | return pyopencv_from(retval);
| 46932 | } |  | 46884 | }
| 46933 |  |  | 46885 |
| 46934 | return NULL; |  | 46886 | return NULL;
| 46935 | } |  | 46887 | }
| 46936 |  |  | 46888 |
| 46937 |  |  | 46889 |
| 46938 |  |  | 46890 |
| 46939 | // Tables (detail_FeaturesMatcher) |  | 46891 | // Tables (detail_FeaturesMatcher)
| 46940 |  |  | 46892 |
| 46941 | static PyGetSetDef pyopencv_detail_FeaturesMatcher_getseters[] = |  | 46893 | static PyGetSetDef pyopencv_detail_FeaturesMatcher_getseters[] =
| 46942 | { |  | 46894 | {
| 46943 | {NULL} /* Sentinel */ |  | 46895 | {NULL} /* Sentinel */
| 46944 | }; |  | 46896 | };
| 46945 |  |  | 46897 |
| 46946 | static PyMethodDef pyopencv_detail_FeaturesMatcher_methods[] = |  | 46898 | static PyMethodDef pyopencv_detail_FeaturesMatcher_methods[] =
| 46947 | { |  | 46899 | {
| 46948 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_apply, 0), "apply(features1, features2) -> matches_info\n. @overload\n. @param features1 First image features\n. @param features2 Second image features\n. @param matches_info Found matches"}, |  | 46900 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_apply, 0), "apply(features1, features2) -> matches_info\n. @overload\n. @param features1 First image features\n. @param features2 Second image features\n. @param matches_info Found matches"},
| 46949 | {"apply2", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_apply2, 0), "apply2(features[, mask]) -> pairwise_matches\n. @brief Performs images matching.\n. \n. @param features Features of the source images\n. @param pairwise_matches Found pairwise matches\n. @param mask Mask indicating which image pairs must be matched\n. \n. The function is parallelized with the TBB library.\n. \n. @sa detail::MatchesInfo"}, |  | 46901 | {"apply2", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_apply2, 0), "apply2(features[, mask]) -> pairwise_matches\n. @brief Performs images matching.\n. \n. @param features Features of the source images\n. @param pairwise_matches Found pairwise matches\n. @param mask Mask indicating which image pairs must be matched\n. \n. The function is parallelized with the TBB library.\n. \n. @sa detail::MatchesInfo"},
| 46950 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_collectGarbage, 0), "collectGarbage() -> None\n. @brief Frees unused memory allocated before if there is any."}, |  | 46902 | {"collectGarbage", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_collectGarbage, 0), "collectGarbage() -> None\n. @brief Frees unused memory allocated before if there is any."},
| 46951 | {"isThreadSafe", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_isThreadSafe, 0), "isThreadSafe() -> retval\n. @return True, if it's possible to use the same matcher instance in parallel, false otherwise"}, |  | 46903 | {"isThreadSafe", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_FeaturesMatcher_isThreadSafe, 0), "isThreadSafe() -> retval\n. @return True, if it's possible to use the same matcher instance in parallel, false otherwise"},
| 46952 |  |  | 46904 |
| 46953 | {NULL, NULL} |  | 46905 | {NULL, NULL}
| 46954 | }; |  | 46906 | };
| 46955 |  |  | 46907 |
| 46956 | // Converter (detail_FeaturesMatcher) |  | 46908 | // Converter (detail_FeaturesMatcher)
| 46957 |  |  | 46909 |
| 46958 | template<> |  | 46910 | template<>
| 46959 | struct PyOpenCV_Converter< Ptr<cv::detail::FeaturesMatcher> > |  | 46911 | struct PyOpenCV_Converter< Ptr<cv::detail::FeaturesMatcher> >
| 46960 | { |  | 46912 | {
| 46961 | static PyObject* from(const Ptr<cv::detail::FeaturesMatcher>& r) |  | 46913 | static PyObject* from(const Ptr<cv::detail::FeaturesMatcher>& r)
| 46962 | { |  | 46914 | {
| 46963 | return pyopencv_detail_FeaturesMatcher_Instance(r); |  | 46915 | return pyopencv_detail_FeaturesMatcher_Instance(r);
| 46964 | } |  | 46916 | }
| 46965 | static bool to(PyObject* src, Ptr<cv::detail::FeaturesMatcher>& dst, const ArgInfo& info) |  | 46917 | static bool to(PyObject* src, Ptr<cv::detail::FeaturesMatcher>& dst, const ArgInfo& info)
| 46966 | { |  | 46918 | {
| 46967 | if(!src || src == Py_None) |  | 46919 | if(!src || src == Py_None)
| 46968 | return true; |  | 46920 | return true;
| 46969 | Ptr<cv::detail::FeaturesMatcher> * dst_; |  | 46921 | Ptr<cv::detail::FeaturesMatcher> * dst_;
| 46970 | if (pyopencv_detail_FeaturesMatcher_getp(src, dst_)) |  | 46922 | if (pyopencv_detail_FeaturesMatcher_getp(src, dst_))
| 46971 | { |  | 46923 | {
| 46972 | dst = *dst_; |  | 46924 | dst = *dst_;
| 46973 | return true; |  | 46925 | return true;
| 46974 | } |  | 46926 | }
| 46975 |  |  | 46927 |
| 46976 | failmsg("Expected Ptr<cv::detail::FeaturesMatcher> for argument '%s'", info.name); |  | 46928 | failmsg("Expected Ptr<cv::detail::FeaturesMatcher> for argument '%s'", info.name);
| 46977 | return false; |  | 46929 | return false;
| 46978 | } |  | 46930 | }
| 46979 | }; |  | 46931 | };
| 46980 |  |  | 46932 |
| 46981 | //================================================================================ |  | 46933 | //================================================================================
| 46982 | // detail_GainCompensator (Generic) |  | 46934 | // detail_GainCompensator (Generic)
| 46983 | //================================================================================ |  | 46935 | //================================================================================
| 46984 |  |  | 46936 |
| 46985 | // GetSet (detail_GainCompensator) |  | 46937 | // GetSet (detail_GainCompensator)
| 46986 |  |  | 46938 |
| 46987 |  |  | 46939 |
| 46988 |  |  | 46940 |
| 46989 | // Methods (detail_GainCompensator) |  | 46941 | // Methods (detail_GainCompensator)
| 46990 |  |  | 46942 |
| 46991 | static int pyopencv_cv_detail_detail_GainCompensator_GainCompensator(pyopencv_detail_GainCompensator_t* self, PyObject* py_args, PyObject* kw) |  | 46943 | static int pyopencv_cv_detail_detail_GainCompensator_GainCompensator(pyopencv_detail_GainCompensator_t* self, PyObject* py_args, PyObject* kw)
| 46992 | { |  | 46944 | {
| 46993 | using namespace cv::detail; |  | 46945 | using namespace cv::detail;
| 46994 |  |  | 46946 |
| 46995 | pyPrepareArgumentConversionErrorsStorage(2); |  | 46947 | pyPrepareArgumentConversionErrorsStorage(2);
| 46996 |  |  | 46948 |
| 46997 | { |  | 46949 | {
| 46998 |  |  | 46950 |
| 46999 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 46951 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 47000 | { |  | 46952 | {
| 47001 | new (&(self->v)) Ptr<cv::detail::GainCompensator>(); // init Ptr with placement new |  | 46953 | new (&(self->v)) Ptr<cv::detail::GainCompensator>(); // init Ptr with placement new
| 47002 | if(self) ERRWRAP2(self->v.reset(new cv::detail::GainCompensator())); |  | 46954 | if(self) ERRWRAP2(self->v.reset(new cv::detail::GainCompensator()));
| 47003 | return 0; |  | 46955 | return 0;
| 47004 | } |  | 46956 | }
| 47005 |  |  | 46957 |
| 47006 |  |  | 46958 |
| 47007 | pyPopulateArgumentConversionErrors(); |  | 46959 | pyPopulateArgumentConversionErrors();
| 47008 | } |  | 46960 | }
| 47009 |  |  | 46961 |
| 47010 |  |  | 46962 |
| 47011 | { |  | 46963 | {
| 47012 | PyObject* pyobj_nr_feeds = NULL; |  | 46964 | PyObject* pyobj_nr_feeds = NULL;
| 47013 | int nr_feeds=0; |  | 46965 | int nr_feeds=0;
| 47014 |  |  | 46966 |
| 47015 | const char* keywords[] = { "nr_feeds", NULL }; |  | 46967 | const char* keywords[] = { "nr_feeds", NULL };
| 47016 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GainCompensator", (char**)keywords, &pyobj_nr_feeds) && |  | 46968 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GainCompensator", (char**)keywords, &pyobj_nr_feeds) &&
| 47017 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) ) |  | 46969 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) )
| 47018 | { |  | 46970 | {
| 47019 | new (&(self->v)) Ptr<cv::detail::GainCompensator>(); // init Ptr with placement new |  | 46971 | new (&(self->v)) Ptr<cv::detail::GainCompensator>(); // init Ptr with placement new
| 47020 | if(self) ERRWRAP2(self->v.reset(new cv::detail::GainCompensator(nr_feeds))); |  | 46972 | if(self) ERRWRAP2(self->v.reset(new cv::detail::GainCompensator(nr_feeds)));
| 47021 | return 0; |  | 46973 | return 0;
| 47022 | } |  | 46974 | }
| 47023 |  |  | 46975 |
| 47024 |  |  | 46976 |
| 47025 | pyPopulateArgumentConversionErrors(); |  | 46977 | pyPopulateArgumentConversionErrors();
| 47026 | } |  | 46978 | }
| 47027 | pyRaiseCVOverloadException("GainCompensator"); |  | 46979 | pyRaiseCVOverloadException("GainCompensator");
| 47028 |  |  | 46980 |
| 47029 | return -1; |  | 46981 | return -1;
| 47030 | } |  | 46982 | }
| 47031 |  |  | 46983 |
| 47032 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 46984 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 47033 | { |  | 46985 | {
| 47034 | using namespace cv::detail; |  | 46986 | using namespace cv::detail;
| 47035 |  |  | 46987 |
| 47036 |  |  | 46988 |
| 47037 | Ptr<cv::detail::GainCompensator> * self1 = 0; |  | 46989 | Ptr<cv::detail::GainCompensator> * self1 = 0;
| 47038 | if (!pyopencv_detail_GainCompensator_getp(self, self1)) |  | 46990 | if (!pyopencv_detail_GainCompensator_getp(self, self1))
| 47039 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)"); |  | 46991 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)");
| 47040 | Ptr<cv::detail::GainCompensator> _self_ = *(self1); |  | 46992 | Ptr<cv::detail::GainCompensator> _self_ = *(self1);
| 47041 | pyPrepareArgumentConversionErrorsStorage(2); |  | 46993 | pyPrepareArgumentConversionErrorsStorage(2);
| 47042 |  |  | 46994 |
| 47043 | { |  | 46995 | {
| 47044 | PyObject* pyobj_index = NULL; |  | 46996 | PyObject* pyobj_index = NULL;
| 47045 | int index=0; |  | 46997 | int index=0;
| 47046 | PyObject* pyobj_corner = NULL; |  | 46998 | PyObject* pyobj_corner = NULL;
| 47047 | Point corner; |  | 46999 | Point corner;
| 47048 | PyObject* pyobj_image = NULL; |  | 47000 | PyObject* pyobj_image = NULL;
| 47049 | Mat image; |  | 47001 | Mat image;
| 47050 | PyObject* pyobj_mask = NULL; |  | 47002 | PyObject* pyobj_mask = NULL;
| 47051 | Mat mask; |  | 47003 | Mat mask;
| 47052 |  |  | 47004 |
| 47053 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 47005 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 47054 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_GainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 47006 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_GainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 47055 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 47007 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 47056 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 47008 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 47057 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 47009 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 47058 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 47010 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 47059 | { |  | 47011 | {
| 47060 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 47012 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 47061 | return pyopencv_from(image); |  | 47013 | return pyopencv_from(image);
| 47062 | } |  | 47014 | }
| 47063 |  |  | 47015 |
| 47064 |  |  | 47016 |
| 47065 | pyPopulateArgumentConversionErrors(); |  | 47017 | pyPopulateArgumentConversionErrors();
| 47066 | } |  | 47018 | }
| 47067 |  |  | 47019 |
| 47068 |  |  | 47020 |
| 47069 | { |  | 47021 | {
| 47070 | PyObject* pyobj_index = NULL; |  | 47022 | PyObject* pyobj_index = NULL;
| 47071 | int index=0; |  | 47023 | int index=0;
| 47072 | PyObject* pyobj_corner = NULL; |  | 47024 | PyObject* pyobj_corner = NULL;
| 47073 | Point corner; |  | 47025 | Point corner;
| 47074 | PyObject* pyobj_image = NULL; |  | 47026 | PyObject* pyobj_image = NULL;
| 47075 | UMat image; |  | 47027 | UMat image;
| 47076 | PyObject* pyobj_mask = NULL; |  | 47028 | PyObject* pyobj_mask = NULL;
| 47077 | UMat mask; |  | 47029 | UMat mask;
| 47078 |  |  | 47030 |
| 47079 | const char* keywords[] = { "index", "corner", "image", "mask", NULL }; |  | 47031 | const char* keywords[] = { "index", "corner", "image", "mask", NULL };
| 47080 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_GainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) && |  | 47032 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_GainCompensator.apply", (char**)keywords, &pyobj_index, &pyobj_corner, &pyobj_image, &pyobj_mask) &&
| 47081 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) && |  | 47033 | pyopencv_to_safe(pyobj_index, index, ArgInfo("index", 0)) &&
| 47082 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) && |  | 47034 | pyopencv_to_safe(pyobj_corner, corner, ArgInfo("corner", 0)) &&
| 47083 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 47035 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 47084 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 47036 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 47085 | { |  | 47037 | {
| 47086 | ERRWRAP2(_self_->apply(index, corner, image, mask)); |  | 47038 | ERRWRAP2(_self_->apply(index, corner, image, mask));
| 47087 | return pyopencv_from(image); |  | 47039 | return pyopencv_from(image);
| 47088 | } |  | 47040 | }
| 47089 |  |  | 47041 |
| 47090 |  |  | 47042 |
| 47091 | pyPopulateArgumentConversionErrors(); |  | 47043 | pyPopulateArgumentConversionErrors();
| 47092 | } |  | 47044 | }
| 47093 | pyRaiseCVOverloadException("apply"); |  | 47045 | pyRaiseCVOverloadException("apply");
| 47094 |  |  | 47046 |
| 47095 | return NULL; |  | 47047 | return NULL;
| 47096 | } |  | 47048 | }
| 47097 |  |  | 47049 |
| 47098 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47050 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 47099 | { |  | 47051 | {
| 47100 | using namespace cv::detail; |  | 47052 | using namespace cv::detail;
| 47101 |  |  | 47053 |
| 47102 |  |  | 47054 |
| 47103 | Ptr<cv::detail::GainCompensator> * self1 = 0; |  | 47055 | Ptr<cv::detail::GainCompensator> * self1 = 0;
| 47104 | if (!pyopencv_detail_GainCompensator_getp(self, self1)) |  | 47056 | if (!pyopencv_detail_GainCompensator_getp(self, self1))
| 47105 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)"); |  | 47057 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)");
| 47106 | Ptr<cv::detail::GainCompensator> _self_ = *(self1); |  | 47058 | Ptr<cv::detail::GainCompensator> _self_ = *(self1);
| 47107 | PyObject* pyobj_umv = NULL; |  | 47059 | PyObject* pyobj_umv = NULL;
| 47108 | vector_Mat umv; |  | 47060 | vector_Mat umv;
| 47109 |  |  | 47061 |
| 47110 | const char* keywords[] = { "umv", NULL }; |  | 47062 | const char* keywords[] = { "umv", NULL };
| 47111 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_GainCompensator.getMatGains", (char**)keywords, &pyobj_umv) && |  | 47063 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_GainCompensator.getMatGains", (char**)keywords, &pyobj_umv) &&
| 47112 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) ) |  | 47064 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) )
| 47113 | { |  | 47065 | {
| 47114 | ERRWRAP2(_self_->getMatGains(umv)); |  | 47066 | ERRWRAP2(_self_->getMatGains(umv));
| 47115 | return pyopencv_from(umv); |  | 47067 | return pyopencv_from(umv);
| 47116 | } |  | 47068 | }
| 47117 |  |  | 47069 |
| 47118 | return NULL; |  | 47070 | return NULL;
| 47119 | } |  | 47071 | }
| 47120 |  |  | 47072 |
| 47121 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_getNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47073 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_getNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw)
| 47122 | { |  | 47074 | {
| 47123 | using namespace cv::detail; |  | 47075 | using namespace cv::detail;
| 47124 |  |  | 47076 |
| 47125 |  |  | 47077 |
| 47126 | Ptr<cv::detail::GainCompensator> * self1 = 0; |  | 47078 | Ptr<cv::detail::GainCompensator> * self1 = 0;
| 47127 | if (!pyopencv_detail_GainCompensator_getp(self, self1)) |  | 47079 | if (!pyopencv_detail_GainCompensator_getp(self, self1))
| 47128 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)"); |  | 47080 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)");
| 47129 | Ptr<cv::detail::GainCompensator> _self_ = *(self1); |  | 47081 | Ptr<cv::detail::GainCompensator> _self_ = *(self1);
| 47130 | int retval; |  | 47082 | int retval;
| 47131 |  |  | 47083 |
| 47132 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 47084 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 47133 | { |  | 47085 | {
| 47134 | ERRWRAP2(retval = _self_->getNrFeeds()); |  | 47086 | ERRWRAP2(retval = _self_->getNrFeeds());
| 47135 | return pyopencv_from(retval); |  | 47087 | return pyopencv_from(retval);
| 47136 | } |  | 47088 | }
| 47137 |  |  | 47089 |
| 47138 | return NULL; |  | 47090 | return NULL;
| 47139 | } |  | 47091 | }
| 47140 |  |  | 47092 |
| 47141 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_getSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47093 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_getSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 47142 | { |  | 47094 | {
| 47143 | using namespace cv::detail; |  | 47095 | using namespace cv::detail;
| 47144 |  |  | 47096 |
| 47145 |  |  | 47097 |
| 47146 | Ptr<cv::detail::GainCompensator> * self1 = 0; |  | 47098 | Ptr<cv::detail::GainCompensator> * self1 = 0;
| 47147 | if (!pyopencv_detail_GainCompensator_getp(self, self1)) |  | 47099 | if (!pyopencv_detail_GainCompensator_getp(self, self1))
| 47148 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)"); |  | 47100 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)");
| 47149 | Ptr<cv::detail::GainCompensator> _self_ = *(self1); |  | 47101 | Ptr<cv::detail::GainCompensator> _self_ = *(self1);
| 47150 | double retval; |  | 47102 | double retval;
| 47151 |  |  | 47103 |
| 47152 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 47104 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 47153 | { |  | 47105 | {
| 47154 | ERRWRAP2(retval = _self_->getSimilarityThreshold()); |  | 47106 | ERRWRAP2(retval = _self_->getSimilarityThreshold());
| 47155 | return pyopencv_from(retval); |  | 47107 | return pyopencv_from(retval);
| 47156 | } |  | 47108 | }
| 47157 |  |  | 47109 |
| 47158 | return NULL; |  | 47110 | return NULL;
| 47159 | } |  | 47111 | }
| 47160 |  |  | 47112 |
| 47161 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47113 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 47162 | { |  | 47114 | {
| 47163 | using namespace cv::detail; |  | 47115 | using namespace cv::detail;
| 47164 |  |  | 47116 |
| 47165 |  |  | 47117 |
| 47166 | Ptr<cv::detail::GainCompensator> * self1 = 0; |  | 47118 | Ptr<cv::detail::GainCompensator> * self1 = 0;
| 47167 | if (!pyopencv_detail_GainCompensator_getp(self, self1)) |  | 47119 | if (!pyopencv_detail_GainCompensator_getp(self, self1))
| 47168 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)"); |  | 47120 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)");
| 47169 | Ptr<cv::detail::GainCompensator> _self_ = *(self1); |  | 47121 | Ptr<cv::detail::GainCompensator> _self_ = *(self1);
| 47170 | PyObject* pyobj_umv = NULL; |  | 47122 | PyObject* pyobj_umv = NULL;
| 47171 | vector_Mat umv; |  | 47123 | vector_Mat umv;
| 47172 |  |  | 47124 |
| 47173 | const char* keywords[] = { "umv", NULL }; |  | 47125 | const char* keywords[] = { "umv", NULL };
| 47174 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_GainCompensator.setMatGains", (char**)keywords, &pyobj_umv) && |  | 47126 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_GainCompensator.setMatGains", (char**)keywords, &pyobj_umv) &&
| 47175 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) ) |  | 47127 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) )
| 47176 | { |  | 47128 | {
| 47177 | ERRWRAP2(_self_->setMatGains(umv)); |  | 47129 | ERRWRAP2(_self_->setMatGains(umv));
| 47178 | Py_RETURN_NONE; |  | 47130 | Py_RETURN_NONE;
| 47179 | } |  | 47131 | }
| 47180 |  |  | 47132 |
| 47181 | return NULL; |  | 47133 | return NULL;
| 47182 | } |  | 47134 | }
| 47183 |  |  | 47135 |
| 47184 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_setNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47136 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_setNrFeeds(PyObject* self, PyObject* py_args, PyObject* kw)
| 47185 | { |  | 47137 | {
| 47186 | using namespace cv::detail; |  | 47138 | using namespace cv::detail;
| 47187 |  |  | 47139 |
| 47188 |  |  | 47140 |
| 47189 | Ptr<cv::detail::GainCompensator> * self1 = 0; |  | 47141 | Ptr<cv::detail::GainCompensator> * self1 = 0;
| 47190 | if (!pyopencv_detail_GainCompensator_getp(self, self1)) |  | 47142 | if (!pyopencv_detail_GainCompensator_getp(self, self1))
| 47191 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)"); |  | 47143 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)");
| 47192 | Ptr<cv::detail::GainCompensator> _self_ = *(self1); |  | 47144 | Ptr<cv::detail::GainCompensator> _self_ = *(self1);
| 47193 | PyObject* pyobj_nr_feeds = NULL; |  | 47145 | PyObject* pyobj_nr_feeds = NULL;
| 47194 | int nr_feeds=0; |  | 47146 | int nr_feeds=0;
| 47195 |  |  | 47147 |
| 47196 | const char* keywords[] = { "nr_feeds", NULL }; |  | 47148 | const char* keywords[] = { "nr_feeds", NULL };
| 47197 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_GainCompensator.setNrFeeds", (char**)keywords, &pyobj_nr_feeds) && |  | 47149 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_GainCompensator.setNrFeeds", (char**)keywords, &pyobj_nr_feeds) &&
| 47198 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) ) |  | 47150 | pyopencv_to_safe(pyobj_nr_feeds, nr_feeds, ArgInfo("nr_feeds", 0)) )
| 47199 | { |  | 47151 | {
| 47200 | ERRWRAP2(_self_->setNrFeeds(nr_feeds)); |  | 47152 | ERRWRAP2(_self_->setNrFeeds(nr_feeds));
| 47201 | Py_RETURN_NONE; |  | 47153 | Py_RETURN_NONE;
| 47202 | } |  | 47154 | }
| 47203 |  |  | 47155 |
| 47204 | return NULL; |  | 47156 | return NULL;
| 47205 | } |  | 47157 | }
| 47206 |  |  | 47158 |
| 47207 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_setSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47159 | static PyObject* pyopencv_cv_detail_detail_GainCompensator_setSimilarityThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 47208 | { |  | 47160 | {
| 47209 | using namespace cv::detail; |  | 47161 | using namespace cv::detail;
| 47210 |  |  | 47162 |
| 47211 |  |  | 47163 |
| 47212 | Ptr<cv::detail::GainCompensator> * self1 = 0; |  | 47164 | Ptr<cv::detail::GainCompensator> * self1 = 0;
| 47213 | if (!pyopencv_detail_GainCompensator_getp(self, self1)) |  | 47165 | if (!pyopencv_detail_GainCompensator_getp(self, self1))
| 47214 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)"); |  | 47166 | return failmsgp("Incorrect type of self (must be 'detail_GainCompensator' or its derivative)");
| 47215 | Ptr<cv::detail::GainCompensator> _self_ = *(self1); |  | 47167 | Ptr<cv::detail::GainCompensator> _self_ = *(self1);
| 47216 | PyObject* pyobj_similarity_threshold = NULL; |  | 47168 | PyObject* pyobj_similarity_threshold = NULL;
| 47217 | double similarity_threshold=0; |  | 47169 | double similarity_threshold=0;
| 47218 |  |  | 47170 |
| 47219 | const char* keywords[] = { "similarity_threshold", NULL }; |  | 47171 | const char* keywords[] = { "similarity_threshold", NULL };
| 47220 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_GainCompensator.setSimilarityThreshold", (char**)keywords, &pyobj_similarity_threshold) && |  | 47172 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_GainCompensator.setSimilarityThreshold", (char**)keywords, &pyobj_similarity_threshold) &&
| 47221 | pyopencv_to_safe(pyobj_similarity_threshold, similarity_threshold, ArgInfo("similarity_threshold", 0)) ) |  | 47173 | pyopencv_to_safe(pyobj_similarity_threshold, similarity_threshold, ArgInfo("similarity_threshold", 0)) )
| 47222 | { |  | 47174 | {
| 47223 | ERRWRAP2(_self_->setSimilarityThreshold(similarity_threshold)); |  | 47175 | ERRWRAP2(_self_->setSimilarityThreshold(similarity_threshold));
| 47224 | Py_RETURN_NONE; |  | 47176 | Py_RETURN_NONE;
| 47225 | } |  | 47177 | }
| 47226 |  |  | 47178 |
| 47227 | return NULL; |  | 47179 | return NULL;
| 47228 | } |  | 47180 | }
| 47229 |  |  | 47181 |
| 47230 |  |  | 47182 |
| 47231 |  |  | 47183 |
| 47232 | // Tables (detail_GainCompensator) |  | 47184 | // Tables (detail_GainCompensator)
| 47233 |  |  | 47185 |
| 47234 | static PyGetSetDef pyopencv_detail_GainCompensator_getseters[] = |  | 47186 | static PyGetSetDef pyopencv_detail_GainCompensator_getseters[] =
| 47235 | { |  | 47187 | {
| 47236 | {NULL} /* Sentinel */ |  | 47188 | {NULL} /* Sentinel */
| 47237 | }; |  | 47189 | };
| 47238 |  |  | 47190 |
| 47239 | static PyMethodDef pyopencv_detail_GainCompensator_methods[] = |  | 47191 | static PyMethodDef pyopencv_detail_GainCompensator_methods[] =
| 47240 | { |  | 47192 | {
| 47241 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."}, |  | 47193 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_apply, 0), "apply(index, corner, image, mask) -> image\n."},
| 47242 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."}, |  | 47194 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."},
| 47243 | {"getNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_getNrFeeds, 0), "getNrFeeds() -> retval\n."}, |  | 47195 | {"getNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_getNrFeeds, 0), "getNrFeeds() -> retval\n."},
| 47244 | {"getSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_getSimilarityThreshold, 0), "getSimilarityThreshold() -> retval\n."}, |  | 47196 | {"getSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_getSimilarityThreshold, 0), "getSimilarityThreshold() -> retval\n."},
| 47245 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."}, |  | 47197 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."},
| 47246 | {"setNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_setNrFeeds, 0), "setNrFeeds(nr_feeds) -> None\n."}, |  | 47198 | {"setNrFeeds", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_setNrFeeds, 0), "setNrFeeds(nr_feeds) -> None\n."},
| 47247 | {"setSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_setSimilarityThreshold, 0), "setSimilarityThreshold(similarity_threshold) -> None\n."}, |  | 47199 | {"setSimilarityThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GainCompensator_setSimilarityThreshold, 0), "setSimilarityThreshold(similarity_threshold) -> None\n."},
| 47248 |  |  | 47200 |
| 47249 | {NULL, NULL} |  | 47201 | {NULL, NULL}
| 47250 | }; |  | 47202 | };
| 47251 |  |  | 47203 |
| 47252 | // Converter (detail_GainCompensator) |  | 47204 | // Converter (detail_GainCompensator)
| 47253 |  |  | 47205 |
| 47254 | template<> |  | 47206 | template<>
| 47255 | struct PyOpenCV_Converter< Ptr<cv::detail::GainCompensator> > |  | 47207 | struct PyOpenCV_Converter< Ptr<cv::detail::GainCompensator> >
| 47256 | { |  | 47208 | {
| 47257 | static PyObject* from(const Ptr<cv::detail::GainCompensator>& r) |  | 47209 | static PyObject* from(const Ptr<cv::detail::GainCompensator>& r)
| 47258 | { |  | 47210 | {
| 47259 | return pyopencv_detail_GainCompensator_Instance(r); |  | 47211 | return pyopencv_detail_GainCompensator_Instance(r);
| 47260 | } |  | 47212 | }
| 47261 | static bool to(PyObject* src, Ptr<cv::detail::GainCompensator>& dst, const ArgInfo& info) |  | 47213 | static bool to(PyObject* src, Ptr<cv::detail::GainCompensator>& dst, const ArgInfo& info)
| 47262 | { |  | 47214 | {
| 47263 | if(!src || src == Py_None) |  | 47215 | if(!src || src == Py_None)
| 47264 | return true; |  | 47216 | return true;
| 47265 | Ptr<cv::detail::GainCompensator> * dst_; |  | 47217 | Ptr<cv::detail::GainCompensator> * dst_;
| 47266 | if (pyopencv_detail_GainCompensator_getp(src, dst_)) |  | 47218 | if (pyopencv_detail_GainCompensator_getp(src, dst_))
| 47267 | { |  | 47219 | {
| 47268 | dst = *dst_; |  | 47220 | dst = *dst_;
| 47269 | return true; |  | 47221 | return true;
| 47270 | } |  | 47222 | }
| 47271 |  |  | 47223 |
| 47272 | failmsg("Expected Ptr<cv::detail::GainCompensator> for argument '%s'", info.name); |  | 47224 | failmsg("Expected Ptr<cv::detail::GainCompensator> for argument '%s'", info.name);
| 47273 | return false; |  | 47225 | return false;
| 47274 | } |  | 47226 | }
| 47275 | }; |  | 47227 | };
| 47276 |  |  | 47228 |
| 47277 | //================================================================================ |  | 47229 | //================================================================================
| 47278 | // detail_GraphCutSeamFinder (Generic) |  | 47230 | // detail_GraphCutSeamFinder (Generic)
| 47279 | //================================================================================ |  | 47231 | //================================================================================
| 47280 |  |  | 47232 |
| 47281 | // GetSet (detail_GraphCutSeamFinder) |  | 47233 | // GetSet (detail_GraphCutSeamFinder)
| 47282 |  |  | 47234 |
| 47283 |  |  | 47235 |
| 47284 |  |  | 47236 |
| 47285 | // Methods (detail_GraphCutSeamFinder) |  | 47237 | // Methods (detail_GraphCutSeamFinder)
| 47286 |  |  | 47238 |
| 47287 | static int pyopencv_cv_detail_detail_GraphCutSeamFinder_GraphCutSeamFinder(pyopencv_detail_GraphCutSeamFinder_t* self, PyObject* py_args, PyObject* kw) |  | 47239 | static int pyopencv_cv_detail_detail_GraphCutSeamFinder_GraphCutSeamFinder(pyopencv_detail_GraphCutSeamFinder_t* self, PyObject* py_args, PyObject* kw)
| 47288 | { |  | 47240 | {
| 47289 | using namespace cv::detail; |  | 47241 | using namespace cv::detail;
| 47290 |  |  | 47242 |
| 47291 | PyObject* pyobj_cost_type = NULL; |  | 47243 | PyObject* pyobj_cost_type = NULL;
| 47292 | String cost_type; |  | 47244 | String cost_type;
| 47293 | PyObject* pyobj_terminal_cost = NULL; |  | 47245 | PyObject* pyobj_terminal_cost = NULL;
| 47294 | float terminal_cost=10000.f; |  | 47246 | float terminal_cost=10000.f;
| 47295 | PyObject* pyobj_bad_region_penalty = NULL; |  | 47247 | PyObject* pyobj_bad_region_penalty = NULL;
| 47296 | float bad_region_penalty=1000.f; |  | 47248 | float bad_region_penalty=1000.f;
| 47297 |  |  | 47249 |
| 47298 | const char* keywords[] = { "cost_type", "terminal_cost", "bad_region_penalty", NULL }; |  | 47250 | const char* keywords[] = { "cost_type", "terminal_cost", "bad_region_penalty", NULL };
| 47299 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphCutSeamFinder", (char**)keywords, &pyobj_cost_type, &pyobj_terminal_cost, &pyobj_bad_region_penalty) && |  | 47251 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:GraphCutSeamFinder", (char**)keywords, &pyobj_cost_type, &pyobj_terminal_cost, &pyobj_bad_region_penalty) &&
| 47300 | pyopencv_to_safe(pyobj_cost_type, cost_type, ArgInfo("cost_type", 0)) && |  | 47252 | pyopencv_to_safe(pyobj_cost_type, cost_type, ArgInfo("cost_type", 0)) &&
| 47301 | pyopencv_to_safe(pyobj_terminal_cost, terminal_cost, ArgInfo("terminal_cost", 0)) && |  | 47253 | pyopencv_to_safe(pyobj_terminal_cost, terminal_cost, ArgInfo("terminal_cost", 0)) &&
| 47302 | pyopencv_to_safe(pyobj_bad_region_penalty, bad_region_penalty, ArgInfo("bad_region_penalty", 0)) ) |  | 47254 | pyopencv_to_safe(pyobj_bad_region_penalty, bad_region_penalty, ArgInfo("bad_region_penalty", 0)) )
| 47303 | { |  | 47255 | {
| 47304 | new (&(self->v)) Ptr<cv::detail::GraphCutSeamFinder>(); // init Ptr with placement new |  | 47256 | new (&(self->v)) Ptr<cv::detail::GraphCutSeamFinder>(); // init Ptr with placement new
| 47305 | if(self) ERRWRAP2(self->v.reset(new cv::detail::GraphCutSeamFinder(cost_type, terminal_cost, bad_region_penalty))); |  | 47257 | if(self) ERRWRAP2(self->v.reset(new cv::detail::GraphCutSeamFinder(cost_type, terminal_cost, bad_region_penalty)));
| 47306 | return 0; |  | 47258 | return 0;
| 47307 | } |  | 47259 | }
| 47308 |  |  | 47260 |
| 47309 | return -1; |  | 47261 | return -1;
| 47310 | } |  | 47262 | }
| 47311 |  |  | 47263 |
| 47312 | static PyObject* pyopencv_cv_detail_detail_GraphCutSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47264 | static PyObject* pyopencv_cv_detail_detail_GraphCutSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw)
| 47313 | { |  | 47265 | {
| 47314 | using namespace cv::detail; |  | 47266 | using namespace cv::detail;
| 47315 |  |  | 47267 |
| 47316 |  |  | 47268 |
| 47317 | Ptr<cv::detail::GraphCutSeamFinder> * self1 = 0; |  | 47269 | Ptr<cv::detail::GraphCutSeamFinder> * self1 = 0;
| 47318 | if (!pyopencv_detail_GraphCutSeamFinder_getp(self, self1)) |  | 47270 | if (!pyopencv_detail_GraphCutSeamFinder_getp(self, self1))
| 47319 | return failmsgp("Incorrect type of self (must be 'detail_GraphCutSeamFinder' or its derivative)"); |  | 47271 | return failmsgp("Incorrect type of self (must be 'detail_GraphCutSeamFinder' or its derivative)");
| 47320 | Ptr<cv::detail::GraphCutSeamFinder> _self_ = *(self1); |  | 47272 | Ptr<cv::detail::GraphCutSeamFinder> _self_ = *(self1);
| 47321 | PyObject* pyobj_src = NULL; |  | 47273 | PyObject* pyobj_src = NULL;
| 47322 | vector_UMat src; |  | 47274 | vector_UMat src;
| 47323 | PyObject* pyobj_corners = NULL; |  | 47275 | PyObject* pyobj_corners = NULL;
| 47324 | vector_Point corners; |  | 47276 | vector_Point corners;
| 47325 | PyObject* pyobj_masks = NULL; |  | 47277 | PyObject* pyobj_masks = NULL;
| 47326 | vector_UMat masks; |  | 47278 | vector_UMat masks;
| 47327 |  |  | 47279 |
| 47328 | const char* keywords[] = { "src", "corners", "masks", NULL }; |  | 47280 | const char* keywords[] = { "src", "corners", "masks", NULL };
| 47329 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_GraphCutSeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) && |  | 47281 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_GraphCutSeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) &&
| 47330 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 47282 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 47331 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 47283 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 47332 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) ) |  | 47284 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) )
| 47333 | { |  | 47285 | {
| 47334 | ERRWRAP2(_self_->find(src, corners, masks)); |  | 47286 | ERRWRAP2(_self_->find(src, corners, masks));
| 47335 | return pyopencv_from(masks); |  | 47287 | return pyopencv_from(masks);
| 47336 | } |  | 47288 | }
| 47337 |  |  | 47289 |
| 47338 | return NULL; |  | 47290 | return NULL;
| 47339 | } |  | 47291 | }
| 47340 |  |  | 47292 |
| 47341 |  |  | 47293 |
| 47342 |  |  | 47294 |
| 47343 | // Tables (detail_GraphCutSeamFinder) |  | 47295 | // Tables (detail_GraphCutSeamFinder)
| 47344 |  |  | 47296 |
| 47345 | static PyGetSetDef pyopencv_detail_GraphCutSeamFinder_getseters[] = |  | 47297 | static PyGetSetDef pyopencv_detail_GraphCutSeamFinder_getseters[] =
| 47346 | { |  | 47298 | {
| 47347 | {NULL} /* Sentinel */ |  | 47299 | {NULL} /* Sentinel */
| 47348 | }; |  | 47300 | };
| 47349 |  |  | 47301 |
| 47350 | static PyMethodDef pyopencv_detail_GraphCutSeamFinder_methods[] = |  | 47302 | static PyMethodDef pyopencv_detail_GraphCutSeamFinder_methods[] =
| 47351 | { |  | 47303 | {
| 47352 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GraphCutSeamFinder_find, 0), "find(src, corners, masks) -> masks\n."}, |  | 47304 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_GraphCutSeamFinder_find, 0), "find(src, corners, masks) -> masks\n."},
| 47353 |  |  | 47305 |
| 47354 | {NULL, NULL} |  | 47306 | {NULL, NULL}
| 47355 | }; |  | 47307 | };
| 47356 |  |  | 47308 |
| 47357 | // Converter (detail_GraphCutSeamFinder) |  | 47309 | // Converter (detail_GraphCutSeamFinder)
| 47358 |  |  | 47310 |
| 47359 | template<> |  | 47311 | template<>
| 47360 | struct PyOpenCV_Converter< Ptr<cv::detail::GraphCutSeamFinder> > |  | 47312 | struct PyOpenCV_Converter< Ptr<cv::detail::GraphCutSeamFinder> >
| 47361 | { |  | 47313 | {
| 47362 | static PyObject* from(const Ptr<cv::detail::GraphCutSeamFinder>& r) |  | 47314 | static PyObject* from(const Ptr<cv::detail::GraphCutSeamFinder>& r)
| 47363 | { |  | 47315 | {
| 47364 | return pyopencv_detail_GraphCutSeamFinder_Instance(r); |  | 47316 | return pyopencv_detail_GraphCutSeamFinder_Instance(r);
| 47365 | } |  | 47317 | }
| 47366 | static bool to(PyObject* src, Ptr<cv::detail::GraphCutSeamFinder>& dst, const ArgInfo& info) |  | 47318 | static bool to(PyObject* src, Ptr<cv::detail::GraphCutSeamFinder>& dst, const ArgInfo& info)
| 47367 | { |  | 47319 | {
| 47368 | if(!src || src == Py_None) |  | 47320 | if(!src || src == Py_None)
| 47369 | return true; |  | 47321 | return true;
| 47370 | Ptr<cv::detail::GraphCutSeamFinder> * dst_; |  | 47322 | Ptr<cv::detail::GraphCutSeamFinder> * dst_;
| 47371 | if (pyopencv_detail_GraphCutSeamFinder_getp(src, dst_)) |  | 47323 | if (pyopencv_detail_GraphCutSeamFinder_getp(src, dst_))
| 47372 | { |  | 47324 | {
| 47373 | dst = *dst_; |  | 47325 | dst = *dst_;
| 47374 | return true; |  | 47326 | return true;
| 47375 | } |  | 47327 | }
| 47376 |  |  | 47328 |
| 47377 | failmsg("Expected Ptr<cv::detail::GraphCutSeamFinder> for argument '%s'", info.name); |  | 47329 | failmsg("Expected Ptr<cv::detail::GraphCutSeamFinder> for argument '%s'", info.name);
| 47378 | return false; |  | 47330 | return false;
| 47379 | } |  | 47331 | }
| 47380 | }; |  | 47332 | };
| 47381 |  |  | 47333 |
| 47382 | //================================================================================ |  | 47334 | //================================================================================
| 47383 | // detail_HomographyBasedEstimator (Generic) |  | 47335 | // detail_HomographyBasedEstimator (Generic)
| 47384 | //================================================================================ |  | 47336 | //================================================================================
| 47385 |  |  | 47337 |
| 47386 | // GetSet (detail_HomographyBasedEstimator) |  | 47338 | // GetSet (detail_HomographyBasedEstimator)
| 47387 |  |  | 47339 |
| 47388 |  |  | 47340 |
| 47389 |  |  | 47341 |
| 47390 | // Methods (detail_HomographyBasedEstimator) |  | 47342 | // Methods (detail_HomographyBasedEstimator)
| 47391 |  |  | 47343 |
| 47392 | static int pyopencv_cv_detail_detail_HomographyBasedEstimator_HomographyBasedEstimator(pyopencv_detail_HomographyBasedEstimator_t* self, PyObject* py_args, PyObject* kw) |  | 47344 | static int pyopencv_cv_detail_detail_HomographyBasedEstimator_HomographyBasedEstimator(pyopencv_detail_HomographyBasedEstimator_t* self, PyObject* py_args, PyObject* kw)
| 47393 | { |  | 47345 | {
| 47394 | using namespace cv::detail; |  | 47346 | using namespace cv::detail;
| 47395 |  |  | 47347 |
| 47396 | PyObject* pyobj_is_focals_estimated = NULL; |  | 47348 | PyObject* pyobj_is_focals_estimated = NULL;
| 47397 | bool is_focals_estimated=false; |  | 47349 | bool is_focals_estimated=false;
| 47398 |  |  | 47350 |
| 47399 | const char* keywords[] = { "is_focals_estimated", NULL }; |  | 47351 | const char* keywords[] = { "is_focals_estimated", NULL };
| 47400 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:HomographyBasedEstimator", (char**)keywords, &pyobj_is_focals_estimated) && |  | 47352 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:HomographyBasedEstimator", (char**)keywords, &pyobj_is_focals_estimated) &&
| 47401 | pyopencv_to_safe(pyobj_is_focals_estimated, is_focals_estimated, ArgInfo("is_focals_estimated", 0)) ) |  | 47353 | pyopencv_to_safe(pyobj_is_focals_estimated, is_focals_estimated, ArgInfo("is_focals_estimated", 0)) )
| 47402 | { |  | 47354 | {
| 47403 | new (&(self->v)) Ptr<cv::detail::HomographyBasedEstimator>(); // init Ptr with placement new |  | 47355 | new (&(self->v)) Ptr<cv::detail::HomographyBasedEstimator>(); // init Ptr with placement new
| 47404 | if(self) ERRWRAP2(self->v.reset(new cv::detail::HomographyBasedEstimator(is_focals_estimated))); |  | 47356 | if(self) ERRWRAP2(self->v.reset(new cv::detail::HomographyBasedEstimator(is_focals_estimated)));
| 47405 | return 0; |  | 47357 | return 0;
| 47406 | } |  | 47358 | }
| 47407 |  |  | 47359 |
| 47408 | return -1; |  | 47360 | return -1;
| 47409 | } |  | 47361 | }
| 47410 |  |  | 47362 |
| 47411 |  |  | 47363 |
| 47412 |  |  | 47364 |
| 47413 | // Tables (detail_HomographyBasedEstimator) |  | 47365 | // Tables (detail_HomographyBasedEstimator)
| 47414 |  |  | 47366 |
| 47415 | static PyGetSetDef pyopencv_detail_HomographyBasedEstimator_getseters[] = |  | 47367 | static PyGetSetDef pyopencv_detail_HomographyBasedEstimator_getseters[] =
| 47416 | { |  | 47368 | {
| 47417 | {NULL} /* Sentinel */ |  | 47369 | {NULL} /* Sentinel */
| 47418 | }; |  | 47370 | };
| 47419 |  |  | 47371 |
| 47420 | static PyMethodDef pyopencv_detail_HomographyBasedEstimator_methods[] = |  | 47372 | static PyMethodDef pyopencv_detail_HomographyBasedEstimator_methods[] =
| 47421 | { |  | 47373 | {
| 47422 |  |  | 47374 |
| 47423 | {NULL, NULL} |  | 47375 | {NULL, NULL}
| 47424 | }; |  | 47376 | };
| 47425 |  |  | 47377 |
| 47426 | // Converter (detail_HomographyBasedEstimator) |  | 47378 | // Converter (detail_HomographyBasedEstimator)
| 47427 |  |  | 47379 |
| 47428 | template<> |  | 47380 | template<>
| 47429 | struct PyOpenCV_Converter< Ptr<cv::detail::HomographyBasedEstimator> > |  | 47381 | struct PyOpenCV_Converter< Ptr<cv::detail::HomographyBasedEstimator> >
| 47430 | { |  | 47382 | {
| 47431 | static PyObject* from(const Ptr<cv::detail::HomographyBasedEstimator>& r) |  | 47383 | static PyObject* from(const Ptr<cv::detail::HomographyBasedEstimator>& r)
| 47432 | { |  | 47384 | {
| 47433 | return pyopencv_detail_HomographyBasedEstimator_Instance(r); |  | 47385 | return pyopencv_detail_HomographyBasedEstimator_Instance(r);
| 47434 | } |  | 47386 | }
| 47435 | static bool to(PyObject* src, Ptr<cv::detail::HomographyBasedEstimator>& dst, const ArgInfo& info) |  | 47387 | static bool to(PyObject* src, Ptr<cv::detail::HomographyBasedEstimator>& dst, const ArgInfo& info)
| 47436 | { |  | 47388 | {
| 47437 | if(!src || src == Py_None) |  | 47389 | if(!src || src == Py_None)
| 47438 | return true; |  | 47390 | return true;
| 47439 | Ptr<cv::detail::HomographyBasedEstimator> * dst_; |  | 47391 | Ptr<cv::detail::HomographyBasedEstimator> * dst_;
| 47440 | if (pyopencv_detail_HomographyBasedEstimator_getp(src, dst_)) |  | 47392 | if (pyopencv_detail_HomographyBasedEstimator_getp(src, dst_))
| 47441 | { |  | 47393 | {
| 47442 | dst = *dst_; |  | 47394 | dst = *dst_;
| 47443 | return true; |  | 47395 | return true;
| 47444 | } |  | 47396 | }
| 47445 |  |  | 47397 |
| 47446 | failmsg("Expected Ptr<cv::detail::HomographyBasedEstimator> for argument '%s'", info.name); |  | 47398 | failmsg("Expected Ptr<cv::detail::HomographyBasedEstimator> for argument '%s'", info.name);
| 47447 | return false; |  | 47399 | return false;
| 47448 | } |  | 47400 | }
| 47449 | }; |  | 47401 | };
| 47450 |  |  | 47402 |
| 47451 | //================================================================================ |  | 47403 | //================================================================================
| 47452 | // detail_ImageFeatures (Generic) |  | 47404 | // detail_ImageFeatures (Generic)
| 47453 | //================================================================================ |  | 47405 | //================================================================================
| 47454 |  |  | 47406 |
| 47455 | // GetSet (detail_ImageFeatures) |  | 47407 | // GetSet (detail_ImageFeatures)
| 47456 |  |  | 47408 |
| 47457 |  |  | 47409 |
| 47458 | static PyObject* pyopencv_detail_ImageFeatures_get_descriptors(pyopencv_detail_ImageFeatures_t* p, void *closure) |  | 47410 | static PyObject* pyopencv_detail_ImageFeatures_get_descriptors(pyopencv_detail_ImageFeatures_t* p, void *closure)
| 47459 | { |  | 47411 | {
| 47460 | return pyopencv_from(p->v.descriptors); |  | 47412 | return pyopencv_from(p->v.descriptors);
| 47461 | } |  | 47413 | }
| 47462 |  |  | 47414 |
| 47463 | static int pyopencv_detail_ImageFeatures_set_descriptors(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure) |  | 47415 | static int pyopencv_detail_ImageFeatures_set_descriptors(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure)
| 47464 | { |  | 47416 | {
| 47465 | if (!value) |  | 47417 | if (!value)
| 47466 | { |  | 47418 | {
| 47467 | PyErr_SetString(PyExc_TypeError, "Cannot delete the descriptors attribute"); |  | 47419 | PyErr_SetString(PyExc_TypeError, "Cannot delete the descriptors attribute");
| 47468 | return -1; |  | 47420 | return -1;
| 47469 | } |  | 47421 | }
| 47470 | return pyopencv_to_safe(value, p->v.descriptors, ArgInfo("value", 0)) ? 0 : -1; |  | 47422 | return pyopencv_to_safe(value, p->v.descriptors, ArgInfo("value", 0)) ? 0 : -1;
| 47471 | } |  | 47423 | }
| 47472 |  |  | 47424 |
| 47473 | static PyObject* pyopencv_detail_ImageFeatures_get_img_idx(pyopencv_detail_ImageFeatures_t* p, void *closure) |  | 47425 | static PyObject* pyopencv_detail_ImageFeatures_get_img_idx(pyopencv_detail_ImageFeatures_t* p, void *closure)
| 47474 | { |  | 47426 | {
| 47475 | return pyopencv_from(p->v.img_idx); |  | 47427 | return pyopencv_from(p->v.img_idx);
| 47476 | } |  | 47428 | }
| 47477 |  |  | 47429 |
| 47478 | static int pyopencv_detail_ImageFeatures_set_img_idx(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure) |  | 47430 | static int pyopencv_detail_ImageFeatures_set_img_idx(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure)
| 47479 | { |  | 47431 | {
| 47480 | if (!value) |  | 47432 | if (!value)
| 47481 | { |  | 47433 | {
| 47482 | PyErr_SetString(PyExc_TypeError, "Cannot delete the img_idx attribute"); |  | 47434 | PyErr_SetString(PyExc_TypeError, "Cannot delete the img_idx attribute");
| 47483 | return -1; |  | 47435 | return -1;
| 47484 | } |  | 47436 | }
| 47485 | return pyopencv_to_safe(value, p->v.img_idx, ArgInfo("value", 0)) ? 0 : -1; |  | 47437 | return pyopencv_to_safe(value, p->v.img_idx, ArgInfo("value", 0)) ? 0 : -1;
| 47486 | } |  | 47438 | }
| 47487 |  |  | 47439 |
| 47488 | static PyObject* pyopencv_detail_ImageFeatures_get_img_size(pyopencv_detail_ImageFeatures_t* p, void *closure) |  | 47440 | static PyObject* pyopencv_detail_ImageFeatures_get_img_size(pyopencv_detail_ImageFeatures_t* p, void *closure)
| 47489 | { |  | 47441 | {
| 47490 | return pyopencv_from(p->v.img_size); |  | 47442 | return pyopencv_from(p->v.img_size);
| 47491 | } |  | 47443 | }
| 47492 |  |  | 47444 |
| 47493 | static int pyopencv_detail_ImageFeatures_set_img_size(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure) |  | 47445 | static int pyopencv_detail_ImageFeatures_set_img_size(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure)
| 47494 | { |  | 47446 | {
| 47495 | if (!value) |  | 47447 | if (!value)
| 47496 | { |  | 47448 | {
| 47497 | PyErr_SetString(PyExc_TypeError, "Cannot delete the img_size attribute"); |  | 47449 | PyErr_SetString(PyExc_TypeError, "Cannot delete the img_size attribute");
| 47498 | return -1; |  | 47450 | return -1;
| 47499 | } |  | 47451 | }
| 47500 | return pyopencv_to_safe(value, p->v.img_size, ArgInfo("value", 0)) ? 0 : -1; |  | 47452 | return pyopencv_to_safe(value, p->v.img_size, ArgInfo("value", 0)) ? 0 : -1;
| 47501 | } |  | 47453 | }
| 47502 |  |  | 47454 |
| 47503 | static PyObject* pyopencv_detail_ImageFeatures_get_keypoints(pyopencv_detail_ImageFeatures_t* p, void *closure) |  | 47455 | static PyObject* pyopencv_detail_ImageFeatures_get_keypoints(pyopencv_detail_ImageFeatures_t* p, void *closure)
| 47504 | { |  | 47456 | {
| 47505 | return pyopencv_from(p->v.keypoints); |  | 47457 | return pyopencv_from(p->v.keypoints);
| 47506 | } |  | 47458 | }
| 47507 |  |  | 47459 |
| 47508 | static int pyopencv_detail_ImageFeatures_set_keypoints(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure) |  | 47460 | static int pyopencv_detail_ImageFeatures_set_keypoints(pyopencv_detail_ImageFeatures_t* p, PyObject *value, void *closure)
| 47509 | { |  | 47461 | {
| 47510 | if (!value) |  | 47462 | if (!value)
| 47511 | { |  | 47463 | {
| 47512 | PyErr_SetString(PyExc_TypeError, "Cannot delete the keypoints attribute"); |  | 47464 | PyErr_SetString(PyExc_TypeError, "Cannot delete the keypoints attribute");
| 47513 | return -1; |  | 47465 | return -1;
| 47514 | } |  | 47466 | }
| 47515 | return pyopencv_to_safe(value, p->v.keypoints, ArgInfo("value", 0)) ? 0 : -1; |  | 47467 | return pyopencv_to_safe(value, p->v.keypoints, ArgInfo("value", 0)) ? 0 : -1;
| 47516 | } |  | 47468 | }
| 47517 |  |  | 47469 |
| 47518 |  |  | 47470 |
| 47519 | // Methods (detail_ImageFeatures) |  | 47471 | // Methods (detail_ImageFeatures)
| 47520 |  |  | 47472 |
| 47521 | static PyObject* pyopencv_cv_detail_detail_ImageFeatures_getKeypoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47473 | static PyObject* pyopencv_cv_detail_detail_ImageFeatures_getKeypoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 47522 | { |  | 47474 | {
| 47523 | using namespace cv::detail; |  | 47475 | using namespace cv::detail;
| 47524 |  |  | 47476 |
| 47525 |  |  | 47477 |
| 47526 | cv::detail::ImageFeatures * self1 = 0; |  | 47478 | cv::detail::ImageFeatures * self1 = 0;
| 47527 | if (!pyopencv_detail_ImageFeatures_getp(self, self1)) |  | 47479 | if (!pyopencv_detail_ImageFeatures_getp(self, self1))
| 47528 | return failmsgp("Incorrect type of self (must be 'detail_ImageFeatures' or its derivative)"); |  | 47480 | return failmsgp("Incorrect type of self (must be 'detail_ImageFeatures' or its derivative)");
| 47529 | cv::detail::ImageFeatures* _self_ = (self1); |  | 47481 | cv::detail::ImageFeatures* _self_ = (self1);
| 47530 | std::vector<KeyPoint> retval; |  | 47482 | std::vector<KeyPoint> retval;
| 47531 |  |  | 47483 |
| 47532 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 47484 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 47533 | { |  | 47485 | {
| 47534 | ERRWRAP2(retval = _self_->getKeypoints()); |  | 47486 | ERRWRAP2(retval = _self_->getKeypoints());
| 47535 | return pyopencv_from(retval); |  | 47487 | return pyopencv_from(retval);
| 47536 | } |  | 47488 | }
| 47537 |  |  | 47489 |
| 47538 | return NULL; |  | 47490 | return NULL;
| 47539 | } |  | 47491 | }
| 47540 |  |  | 47492 |
| 47541 |  |  | 47493 |
| 47542 |  |  | 47494 |
| 47543 | // Tables (detail_ImageFeatures) |  | 47495 | // Tables (detail_ImageFeatures)
| 47544 |  |  | 47496 |
| 47545 | static PyGetSetDef pyopencv_detail_ImageFeatures_getseters[] = |  | 47497 | static PyGetSetDef pyopencv_detail_ImageFeatures_getseters[] =
| 47546 | { |  | 47498 | {
| 47547 | {(char*)"descriptors", (getter)pyopencv_detail_ImageFeatures_get_descriptors, (setter)pyopencv_detail_ImageFeatures_set_descriptors, (char*)"descriptors", NULL}, |  | 47499 | {(char*)"descriptors", (getter)pyopencv_detail_ImageFeatures_get_descriptors, (setter)pyopencv_detail_ImageFeatures_set_descriptors, (char*)"descriptors", NULL},
| 47548 | {(char*)"img_idx", (getter)pyopencv_detail_ImageFeatures_get_img_idx, (setter)pyopencv_detail_ImageFeatures_set_img_idx, (char*)"img_idx", NULL}, |  | 47500 | {(char*)"img_idx", (getter)pyopencv_detail_ImageFeatures_get_img_idx, (setter)pyopencv_detail_ImageFeatures_set_img_idx, (char*)"img_idx", NULL},
| 47549 | {(char*)"img_size", (getter)pyopencv_detail_ImageFeatures_get_img_size, (setter)pyopencv_detail_ImageFeatures_set_img_size, (char*)"img_size", NULL}, |  | 47501 | {(char*)"img_size", (getter)pyopencv_detail_ImageFeatures_get_img_size, (setter)pyopencv_detail_ImageFeatures_set_img_size, (char*)"img_size", NULL},
| 47550 | {(char*)"keypoints", (getter)pyopencv_detail_ImageFeatures_get_keypoints, (setter)pyopencv_detail_ImageFeatures_set_keypoints, (char*)"keypoints", NULL}, |  | 47502 | {(char*)"keypoints", (getter)pyopencv_detail_ImageFeatures_get_keypoints, (setter)pyopencv_detail_ImageFeatures_set_keypoints, (char*)"keypoints", NULL},
| 47551 | {NULL} /* Sentinel */ |  | 47503 | {NULL} /* Sentinel */
| 47552 | }; |  | 47504 | };
| 47553 |  |  | 47505 |
| 47554 | static PyMethodDef pyopencv_detail_ImageFeatures_methods[] = |  | 47506 | static PyMethodDef pyopencv_detail_ImageFeatures_methods[] =
| 47555 | { |  | 47507 | {
| 47556 | {"getKeypoints", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ImageFeatures_getKeypoints, 0), "getKeypoints() -> retval\n."}, |  | 47508 | {"getKeypoints", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_ImageFeatures_getKeypoints, 0), "getKeypoints() -> retval\n."},
| 47557 |  |  | 47509 |
| 47558 | {NULL, NULL} |  | 47510 | {NULL, NULL}
| 47559 | }; |  | 47511 | };
| 47560 |  |  | 47512 |
| 47561 | // Converter (detail_ImageFeatures) |  | 47513 | // Converter (detail_ImageFeatures)
| 47562 |  |  | 47514 |
| 47563 | template<> |  | 47515 | template<>
| 47564 | struct PyOpenCV_Converter< cv::detail::ImageFeatures > |  | 47516 | struct PyOpenCV_Converter< cv::detail::ImageFeatures >
| 47565 | { |  | 47517 | {
| 47566 | static PyObject* from(const cv::detail::ImageFeatures& r) |  | 47518 | static PyObject* from(const cv::detail::ImageFeatures& r)
| 47567 | { |  | 47519 | {
| 47568 | return pyopencv_detail_ImageFeatures_Instance(r); |  | 47520 | return pyopencv_detail_ImageFeatures_Instance(r);
| 47569 | } |  | 47521 | }
| 47570 | static bool to(PyObject* src, cv::detail::ImageFeatures& dst, const ArgInfo& info) |  | 47522 | static bool to(PyObject* src, cv::detail::ImageFeatures& dst, const ArgInfo& info)
| 47571 | { |  | 47523 | {
| 47572 | if(!src || src == Py_None) |  | 47524 | if(!src || src == Py_None)
| 47573 | return true; |  | 47525 | return true;
| 47574 | cv::detail::ImageFeatures * dst_; |  | 47526 | cv::detail::ImageFeatures * dst_;
| 47575 | if (pyopencv_detail_ImageFeatures_getp(src, dst_)) |  | 47527 | if (pyopencv_detail_ImageFeatures_getp(src, dst_))
| 47576 | { |  | 47528 | {
| 47577 | dst = *dst_; |  | 47529 | dst = *dst_;
| 47578 | return true; |  | 47530 | return true;
| 47579 | } |  | 47531 | }
| 47580 |  |  | 47532 |
| 47581 | failmsg("Expected cv::detail::ImageFeatures for argument '%s'", info.name); |  | 47533 | failmsg("Expected cv::detail::ImageFeatures for argument '%s'", info.name);
| 47582 | return false; |  | 47534 | return false;
| 47583 | } |  | 47535 | }
| 47584 | }; |  | 47536 | };
| 47585 |  |  | 47537 |
| 47586 | //================================================================================ |  | 47538 | //================================================================================
| 47587 | // detail_MatchesInfo (Generic) |  | 47539 | // detail_MatchesInfo (Generic)
| 47588 | //================================================================================ |  | 47540 | //================================================================================
| 47589 |  |  | 47541 |
| 47590 | // GetSet (detail_MatchesInfo) |  | 47542 | // GetSet (detail_MatchesInfo)
| 47591 |  |  | 47543 |
| 47592 |  |  | 47544 |
| 47593 | static PyObject* pyopencv_detail_MatchesInfo_get_H(pyopencv_detail_MatchesInfo_t* p, void *closure) |  | 47545 | static PyObject* pyopencv_detail_MatchesInfo_get_H(pyopencv_detail_MatchesInfo_t* p, void *closure)
| 47594 | { |  | 47546 | {
| 47595 | return pyopencv_from(p->v.H); |  | 47547 | return pyopencv_from(p->v.H);
| 47596 | } |  | 47548 | }
| 47597 |  |  | 47549 |
| 47598 | static int pyopencv_detail_MatchesInfo_set_H(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure) |  | 47550 | static int pyopencv_detail_MatchesInfo_set_H(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure)
| 47599 | { |  | 47551 | {
| 47600 | if (!value) |  | 47552 | if (!value)
| 47601 | { |  | 47553 | {
| 47602 | PyErr_SetString(PyExc_TypeError, "Cannot delete the H attribute"); |  | 47554 | PyErr_SetString(PyExc_TypeError, "Cannot delete the H attribute");
| 47603 | return -1; |  | 47555 | return -1;
| 47604 | } |  | 47556 | }
| 47605 | return pyopencv_to_safe(value, p->v.H, ArgInfo("value", 0)) ? 0 : -1; |  | 47557 | return pyopencv_to_safe(value, p->v.H, ArgInfo("value", 0)) ? 0 : -1;
| 47606 | } |  | 47558 | }
| 47607 |  |  | 47559 |
| 47608 | static PyObject* pyopencv_detail_MatchesInfo_get_confidence(pyopencv_detail_MatchesInfo_t* p, void *closure) |  | 47560 | static PyObject* pyopencv_detail_MatchesInfo_get_confidence(pyopencv_detail_MatchesInfo_t* p, void *closure)
| 47609 | { |  | 47561 | {
| 47610 | return pyopencv_from(p->v.confidence); |  | 47562 | return pyopencv_from(p->v.confidence);
| 47611 | } |  | 47563 | }
| 47612 |  |  | 47564 |
| 47613 | static int pyopencv_detail_MatchesInfo_set_confidence(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure) |  | 47565 | static int pyopencv_detail_MatchesInfo_set_confidence(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure)
| 47614 | { |  | 47566 | {
| 47615 | if (!value) |  | 47567 | if (!value)
| 47616 | { |  | 47568 | {
| 47617 | PyErr_SetString(PyExc_TypeError, "Cannot delete the confidence attribute"); |  | 47569 | PyErr_SetString(PyExc_TypeError, "Cannot delete the confidence attribute");
| 47618 | return -1; |  | 47570 | return -1;
| 47619 | } |  | 47571 | }
| 47620 | return pyopencv_to_safe(value, p->v.confidence, ArgInfo("value", 0)) ? 0 : -1; |  | 47572 | return pyopencv_to_safe(value, p->v.confidence, ArgInfo("value", 0)) ? 0 : -1;
| 47621 | } |  | 47573 | }
| 47622 |  |  | 47574 |
| 47623 | static PyObject* pyopencv_detail_MatchesInfo_get_dst_img_idx(pyopencv_detail_MatchesInfo_t* p, void *closure) |  | 47575 | static PyObject* pyopencv_detail_MatchesInfo_get_dst_img_idx(pyopencv_detail_MatchesInfo_t* p, void *closure)
| 47624 | { |  | 47576 | {
| 47625 | return pyopencv_from(p->v.dst_img_idx); |  | 47577 | return pyopencv_from(p->v.dst_img_idx);
| 47626 | } |  | 47578 | }
| 47627 |  |  | 47579 |
| 47628 | static int pyopencv_detail_MatchesInfo_set_dst_img_idx(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure) |  | 47580 | static int pyopencv_detail_MatchesInfo_set_dst_img_idx(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure)
| 47629 | { |  | 47581 | {
| 47630 | if (!value) |  | 47582 | if (!value)
| 47631 | { |  | 47583 | {
| 47632 | PyErr_SetString(PyExc_TypeError, "Cannot delete the dst_img_idx attribute"); |  | 47584 | PyErr_SetString(PyExc_TypeError, "Cannot delete the dst_img_idx attribute");
| 47633 | return -1; |  | 47585 | return -1;
| 47634 | } |  | 47586 | }
| 47635 | return pyopencv_to_safe(value, p->v.dst_img_idx, ArgInfo("value", 0)) ? 0 : -1; |  | 47587 | return pyopencv_to_safe(value, p->v.dst_img_idx, ArgInfo("value", 0)) ? 0 : -1;
| 47636 | } |  | 47588 | }
| 47637 |  |  | 47589 |
| 47638 | static PyObject* pyopencv_detail_MatchesInfo_get_inliers_mask(pyopencv_detail_MatchesInfo_t* p, void *closure) |  | 47590 | static PyObject* pyopencv_detail_MatchesInfo_get_inliers_mask(pyopencv_detail_MatchesInfo_t* p, void *closure)
| 47639 | { |  | 47591 | {
| 47640 | return pyopencv_from(p->v.inliers_mask); |  | 47592 | return pyopencv_from(p->v.inliers_mask);
| 47641 | } |  | 47593 | }
| 47642 |  |  | 47594 |
| 47643 | static int pyopencv_detail_MatchesInfo_set_inliers_mask(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure) |  | 47595 | static int pyopencv_detail_MatchesInfo_set_inliers_mask(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure)
| 47644 | { |  | 47596 | {
| 47645 | if (!value) |  | 47597 | if (!value)
| 47646 | { |  | 47598 | {
| 47647 | PyErr_SetString(PyExc_TypeError, "Cannot delete the inliers_mask attribute"); |  | 47599 | PyErr_SetString(PyExc_TypeError, "Cannot delete the inliers_mask attribute");
| 47648 | return -1; |  | 47600 | return -1;
| 47649 | } |  | 47601 | }
| 47650 | return pyopencv_to_safe(value, p->v.inliers_mask, ArgInfo("value", 0)) ? 0 : -1; |  | 47602 | return pyopencv_to_safe(value, p->v.inliers_mask, ArgInfo("value", 0)) ? 0 : -1;
| 47651 | } |  | 47603 | }
| 47652 |  |  | 47604 |
| 47653 | static PyObject* pyopencv_detail_MatchesInfo_get_matches(pyopencv_detail_MatchesInfo_t* p, void *closure) |  | 47605 | static PyObject* pyopencv_detail_MatchesInfo_get_matches(pyopencv_detail_MatchesInfo_t* p, void *closure)
| 47654 | { |  | 47606 | {
| 47655 | return pyopencv_from(p->v.matches); |  | 47607 | return pyopencv_from(p->v.matches);
| 47656 | } |  | 47608 | }
| 47657 |  |  | 47609 |
| 47658 | static int pyopencv_detail_MatchesInfo_set_matches(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure) |  | 47610 | static int pyopencv_detail_MatchesInfo_set_matches(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure)
| 47659 | { |  | 47611 | {
| 47660 | if (!value) |  | 47612 | if (!value)
| 47661 | { |  | 47613 | {
| 47662 | PyErr_SetString(PyExc_TypeError, "Cannot delete the matches attribute"); |  | 47614 | PyErr_SetString(PyExc_TypeError, "Cannot delete the matches attribute");
| 47663 | return -1; |  | 47615 | return -1;
| 47664 | } |  | 47616 | }
| 47665 | return pyopencv_to_safe(value, p->v.matches, ArgInfo("value", 0)) ? 0 : -1; |  | 47617 | return pyopencv_to_safe(value, p->v.matches, ArgInfo("value", 0)) ? 0 : -1;
| 47666 | } |  | 47618 | }
| 47667 |  |  | 47619 |
| 47668 | static PyObject* pyopencv_detail_MatchesInfo_get_num_inliers(pyopencv_detail_MatchesInfo_t* p, void *closure) |  | 47620 | static PyObject* pyopencv_detail_MatchesInfo_get_num_inliers(pyopencv_detail_MatchesInfo_t* p, void *closure)
| 47669 | { |  | 47621 | {
| 47670 | return pyopencv_from(p->v.num_inliers); |  | 47622 | return pyopencv_from(p->v.num_inliers);
| 47671 | } |  | 47623 | }
| 47672 |  |  | 47624 |
| 47673 | static int pyopencv_detail_MatchesInfo_set_num_inliers(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure) |  | 47625 | static int pyopencv_detail_MatchesInfo_set_num_inliers(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure)
| 47674 | { |  | 47626 | {
| 47675 | if (!value) |  | 47627 | if (!value)
| 47676 | { |  | 47628 | {
| 47677 | PyErr_SetString(PyExc_TypeError, "Cannot delete the num_inliers attribute"); |  | 47629 | PyErr_SetString(PyExc_TypeError, "Cannot delete the num_inliers attribute");
| 47678 | return -1; |  | 47630 | return -1;
| 47679 | } |  | 47631 | }
| 47680 | return pyopencv_to_safe(value, p->v.num_inliers, ArgInfo("value", 0)) ? 0 : -1; |  | 47632 | return pyopencv_to_safe(value, p->v.num_inliers, ArgInfo("value", 0)) ? 0 : -1;
| 47681 | } |  | 47633 | }
| 47682 |  |  | 47634 |
| 47683 | static PyObject* pyopencv_detail_MatchesInfo_get_src_img_idx(pyopencv_detail_MatchesInfo_t* p, void *closure) |  | 47635 | static PyObject* pyopencv_detail_MatchesInfo_get_src_img_idx(pyopencv_detail_MatchesInfo_t* p, void *closure)
| 47684 | { |  | 47636 | {
| 47685 | return pyopencv_from(p->v.src_img_idx); |  | 47637 | return pyopencv_from(p->v.src_img_idx);
| 47686 | } |  | 47638 | }
| 47687 |  |  | 47639 |
| 47688 | static int pyopencv_detail_MatchesInfo_set_src_img_idx(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure) |  | 47640 | static int pyopencv_detail_MatchesInfo_set_src_img_idx(pyopencv_detail_MatchesInfo_t* p, PyObject *value, void *closure)
| 47689 | { |  | 47641 | {
| 47690 | if (!value) |  | 47642 | if (!value)
| 47691 | { |  | 47643 | {
| 47692 | PyErr_SetString(PyExc_TypeError, "Cannot delete the src_img_idx attribute"); |  | 47644 | PyErr_SetString(PyExc_TypeError, "Cannot delete the src_img_idx attribute");
| 47693 | return -1; |  | 47645 | return -1;
| 47694 | } |  | 47646 | }
| 47695 | return pyopencv_to_safe(value, p->v.src_img_idx, ArgInfo("value", 0)) ? 0 : -1; |  | 47647 | return pyopencv_to_safe(value, p->v.src_img_idx, ArgInfo("value", 0)) ? 0 : -1;
| 47696 | } |  | 47648 | }
| 47697 |  |  | 47649 |
| 47698 |  |  | 47650 |
| 47699 | // Methods (detail_MatchesInfo) |  | 47651 | // Methods (detail_MatchesInfo)
| 47700 |  |  | 47652 |
| 47701 | static PyObject* pyopencv_cv_detail_detail_MatchesInfo_getInliers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47653 | static PyObject* pyopencv_cv_detail_detail_MatchesInfo_getInliers(PyObject* self, PyObject* py_args, PyObject* kw)
| 47702 | { |  | 47654 | {
| 47703 | using namespace cv::detail; |  | 47655 | using namespace cv::detail;
| 47704 |  |  | 47656 |
| 47705 |  |  | 47657 |
| 47706 | cv::detail::MatchesInfo * self1 = 0; |  | 47658 | cv::detail::MatchesInfo * self1 = 0;
| 47707 | if (!pyopencv_detail_MatchesInfo_getp(self, self1)) |  | 47659 | if (!pyopencv_detail_MatchesInfo_getp(self, self1))
| 47708 | return failmsgp("Incorrect type of self (must be 'detail_MatchesInfo' or its derivative)"); |  | 47660 | return failmsgp("Incorrect type of self (must be 'detail_MatchesInfo' or its derivative)");
| 47709 | cv::detail::MatchesInfo* _self_ = (self1); |  | 47661 | cv::detail::MatchesInfo* _self_ = (self1);
| 47710 | std::vector<uchar> retval; |  | 47662 | std::vector<uchar> retval;
| 47711 |  |  | 47663 |
| 47712 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 47664 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 47713 | { |  | 47665 | {
| 47714 | ERRWRAP2(retval = _self_->getInliers()); |  | 47666 | ERRWRAP2(retval = _self_->getInliers());
| 47715 | return pyopencv_from(retval); |  | 47667 | return pyopencv_from(retval);
| 47716 | } |  | 47668 | }
| 47717 |  |  | 47669 |
| 47718 | return NULL; |  | 47670 | return NULL;
| 47719 | } |  | 47671 | }
| 47720 |  |  | 47672 |
| 47721 | static PyObject* pyopencv_cv_detail_detail_MatchesInfo_getMatches(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47673 | static PyObject* pyopencv_cv_detail_detail_MatchesInfo_getMatches(PyObject* self, PyObject* py_args, PyObject* kw)
| 47722 | { |  | 47674 | {
| 47723 | using namespace cv::detail; |  | 47675 | using namespace cv::detail;
| 47724 |  |  | 47676 |
| 47725 |  |  | 47677 |
| 47726 | cv::detail::MatchesInfo * self1 = 0; |  | 47678 | cv::detail::MatchesInfo * self1 = 0;
| 47727 | if (!pyopencv_detail_MatchesInfo_getp(self, self1)) |  | 47679 | if (!pyopencv_detail_MatchesInfo_getp(self, self1))
| 47728 | return failmsgp("Incorrect type of self (must be 'detail_MatchesInfo' or its derivative)"); |  | 47680 | return failmsgp("Incorrect type of self (must be 'detail_MatchesInfo' or its derivative)");
| 47729 | cv::detail::MatchesInfo* _self_ = (self1); |  | 47681 | cv::detail::MatchesInfo* _self_ = (self1);
| 47730 | std::vector<DMatch> retval; |  | 47682 | std::vector<DMatch> retval;
| 47731 |  |  | 47683 |
| 47732 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 47684 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 47733 | { |  | 47685 | {
| 47734 | ERRWRAP2(retval = _self_->getMatches()); |  | 47686 | ERRWRAP2(retval = _self_->getMatches());
| 47735 | return pyopencv_from(retval); |  | 47687 | return pyopencv_from(retval);
| 47736 | } |  | 47688 | }
| 47737 |  |  | 47689 |
| 47738 | return NULL; |  | 47690 | return NULL;
| 47739 | } |  | 47691 | }
| 47740 |  |  | 47692 |
| 47741 |  |  | 47693 |
| 47742 |  |  | 47694 |
| 47743 | // Tables (detail_MatchesInfo) |  | 47695 | // Tables (detail_MatchesInfo)
| 47744 |  |  | 47696 |
| 47745 | static PyGetSetDef pyopencv_detail_MatchesInfo_getseters[] = |  | 47697 | static PyGetSetDef pyopencv_detail_MatchesInfo_getseters[] =
| 47746 | { |  | 47698 | {
| 47747 | {(char*)"H", (getter)pyopencv_detail_MatchesInfo_get_H, (setter)pyopencv_detail_MatchesInfo_set_H, (char*)"H", NULL}, |  | 47699 | {(char*)"H", (getter)pyopencv_detail_MatchesInfo_get_H, (setter)pyopencv_detail_MatchesInfo_set_H, (char*)"H", NULL},
| 47748 | {(char*)"confidence", (getter)pyopencv_detail_MatchesInfo_get_confidence, (setter)pyopencv_detail_MatchesInfo_set_confidence, (char*)"confidence", NULL}, |  | 47700 | {(char*)"confidence", (getter)pyopencv_detail_MatchesInfo_get_confidence, (setter)pyopencv_detail_MatchesInfo_set_confidence, (char*)"confidence", NULL},
| 47749 | {(char*)"dst_img_idx", (getter)pyopencv_detail_MatchesInfo_get_dst_img_idx, (setter)pyopencv_detail_MatchesInfo_set_dst_img_idx, (char*)"dst_img_idx", NULL}, |  | 47701 | {(char*)"dst_img_idx", (getter)pyopencv_detail_MatchesInfo_get_dst_img_idx, (setter)pyopencv_detail_MatchesInfo_set_dst_img_idx, (char*)"dst_img_idx", NULL},
| 47750 | {(char*)"inliers_mask", (getter)pyopencv_detail_MatchesInfo_get_inliers_mask, (setter)pyopencv_detail_MatchesInfo_set_inliers_mask, (char*)"inliers_mask", NULL}, |  | 47702 | {(char*)"inliers_mask", (getter)pyopencv_detail_MatchesInfo_get_inliers_mask, (setter)pyopencv_detail_MatchesInfo_set_inliers_mask, (char*)"inliers_mask", NULL},
| 47751 | {(char*)"matches", (getter)pyopencv_detail_MatchesInfo_get_matches, (setter)pyopencv_detail_MatchesInfo_set_matches, (char*)"matches", NULL}, |  | 47703 | {(char*)"matches", (getter)pyopencv_detail_MatchesInfo_get_matches, (setter)pyopencv_detail_MatchesInfo_set_matches, (char*)"matches", NULL},
| 47752 | {(char*)"num_inliers", (getter)pyopencv_detail_MatchesInfo_get_num_inliers, (setter)pyopencv_detail_MatchesInfo_set_num_inliers, (char*)"num_inliers", NULL}, |  | 47704 | {(char*)"num_inliers", (getter)pyopencv_detail_MatchesInfo_get_num_inliers, (setter)pyopencv_detail_MatchesInfo_set_num_inliers, (char*)"num_inliers", NULL},
| 47753 | {(char*)"src_img_idx", (getter)pyopencv_detail_MatchesInfo_get_src_img_idx, (setter)pyopencv_detail_MatchesInfo_set_src_img_idx, (char*)"src_img_idx", NULL}, |  | 47705 | {(char*)"src_img_idx", (getter)pyopencv_detail_MatchesInfo_get_src_img_idx, (setter)pyopencv_detail_MatchesInfo_set_src_img_idx, (char*)"src_img_idx", NULL},
| 47754 | {NULL} /* Sentinel */ |  | 47706 | {NULL} /* Sentinel */
| 47755 | }; |  | 47707 | };
| 47756 |  |  | 47708 |
| 47757 | static PyMethodDef pyopencv_detail_MatchesInfo_methods[] = |  | 47709 | static PyMethodDef pyopencv_detail_MatchesInfo_methods[] =
| 47758 | { |  | 47710 | {
| 47759 | {"getInliers", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MatchesInfo_getInliers, 0), "getInliers() -> retval\n."}, |  | 47711 | {"getInliers", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MatchesInfo_getInliers, 0), "getInliers() -> retval\n."},
| 47760 | {"getMatches", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MatchesInfo_getMatches, 0), "getMatches() -> retval\n."}, |  | 47712 | {"getMatches", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MatchesInfo_getMatches, 0), "getMatches() -> retval\n."},
| 47761 |  |  | 47713 |
| 47762 | {NULL, NULL} |  | 47714 | {NULL, NULL}
| 47763 | }; |  | 47715 | };
| 47764 |  |  | 47716 |
| 47765 | // Converter (detail_MatchesInfo) |  | 47717 | // Converter (detail_MatchesInfo)
| 47766 |  |  | 47718 |
| 47767 | template<> |  | 47719 | template<>
| 47768 | struct PyOpenCV_Converter< cv::detail::MatchesInfo > |  | 47720 | struct PyOpenCV_Converter< cv::detail::MatchesInfo >
| 47769 | { |  | 47721 | {
| 47770 | static PyObject* from(const cv::detail::MatchesInfo& r) |  | 47722 | static PyObject* from(const cv::detail::MatchesInfo& r)
| 47771 | { |  | 47723 | {
| 47772 | return pyopencv_detail_MatchesInfo_Instance(r); |  | 47724 | return pyopencv_detail_MatchesInfo_Instance(r);
| 47773 | } |  | 47725 | }
| 47774 | static bool to(PyObject* src, cv::detail::MatchesInfo& dst, const ArgInfo& info) |  | 47726 | static bool to(PyObject* src, cv::detail::MatchesInfo& dst, const ArgInfo& info)
| 47775 | { |  | 47727 | {
| 47776 | if(!src || src == Py_None) |  | 47728 | if(!src || src == Py_None)
| 47777 | return true; |  | 47729 | return true;
| 47778 | cv::detail::MatchesInfo * dst_; |  | 47730 | cv::detail::MatchesInfo * dst_;
| 47779 | if (pyopencv_detail_MatchesInfo_getp(src, dst_)) |  | 47731 | if (pyopencv_detail_MatchesInfo_getp(src, dst_))
| 47780 | { |  | 47732 | {
| 47781 | dst = *dst_; |  | 47733 | dst = *dst_;
| 47782 | return true; |  | 47734 | return true;
| 47783 | } |  | 47735 | }
| 47784 |  |  | 47736 |
| 47785 | failmsg("Expected cv::detail::MatchesInfo for argument '%s'", info.name); |  | 47737 | failmsg("Expected cv::detail::MatchesInfo for argument '%s'", info.name);
| 47786 | return false; |  | 47738 | return false;
| 47787 | } |  | 47739 | }
| 47788 | }; |  | 47740 | };
| 47789 |  |  | 47741 |
| 47790 | //================================================================================ |  | 47742 | //================================================================================
| 47791 | // detail_MultiBandBlender (Generic) |  | 47743 | // detail_MultiBandBlender (Generic)
| 47792 | //================================================================================ |  | 47744 | //================================================================================
| 47793 |  |  | 47745 |
| 47794 | // GetSet (detail_MultiBandBlender) |  | 47746 | // GetSet (detail_MultiBandBlender)
| 47795 |  |  | 47747 |
| 47796 |  |  | 47748 |
| 47797 |  |  | 47749 |
| 47798 | // Methods (detail_MultiBandBlender) |  | 47750 | // Methods (detail_MultiBandBlender)
| 47799 |  |  | 47751 |
| 47800 | static int pyopencv_cv_detail_detail_MultiBandBlender_MultiBandBlender(pyopencv_detail_MultiBandBlender_t* self, PyObject* py_args, PyObject* kw) |  | 47752 | static int pyopencv_cv_detail_detail_MultiBandBlender_MultiBandBlender(pyopencv_detail_MultiBandBlender_t* self, PyObject* py_args, PyObject* kw)
| 47801 | { |  | 47753 | {
| 47802 | using namespace cv::detail; |  | 47754 | using namespace cv::detail;
| 47803 |  |  | 47755 |
| 47804 | PyObject* pyobj_try_gpu = NULL; |  | 47756 | PyObject* pyobj_try_gpu = NULL;
| 47805 | int try_gpu=false; |  | 47757 | int try_gpu=false;
| 47806 | PyObject* pyobj_num_bands = NULL; |  | 47758 | PyObject* pyobj_num_bands = NULL;
| 47807 | int num_bands=5; |  | 47759 | int num_bands=5;
| 47808 | PyObject* pyobj_weight_type = NULL; |  | 47760 | PyObject* pyobj_weight_type = NULL;
| 47809 | int weight_type=CV_32F; |  | 47761 | int weight_type=CV_32F;
| 47810 |  |  | 47762 |
| 47811 | const char* keywords[] = { "try_gpu", "num_bands", "weight_type", NULL }; |  | 47763 | const char* keywords[] = { "try_gpu", "num_bands", "weight_type", NULL };
| 47812 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:MultiBandBlender", (char**)keywords, &pyobj_try_gpu, &pyobj_num_bands, &pyobj_weight_type) && |  | 47764 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:MultiBandBlender", (char**)keywords, &pyobj_try_gpu, &pyobj_num_bands, &pyobj_weight_type) &&
| 47813 | pyopencv_to_safe(pyobj_try_gpu, try_gpu, ArgInfo("try_gpu", 0)) && |  | 47765 | pyopencv_to_safe(pyobj_try_gpu, try_gpu, ArgInfo("try_gpu", 0)) &&
| 47814 | pyopencv_to_safe(pyobj_num_bands, num_bands, ArgInfo("num_bands", 0)) && |  | 47766 | pyopencv_to_safe(pyobj_num_bands, num_bands, ArgInfo("num_bands", 0)) &&
| 47815 | pyopencv_to_safe(pyobj_weight_type, weight_type, ArgInfo("weight_type", 0)) ) |  | 47767 | pyopencv_to_safe(pyobj_weight_type, weight_type, ArgInfo("weight_type", 0)) )
| 47816 | { |  | 47768 | {
| 47817 | new (&(self->v)) Ptr<cv::detail::MultiBandBlender>(); // init Ptr with placement new |  | 47769 | new (&(self->v)) Ptr<cv::detail::MultiBandBlender>(); // init Ptr with placement new
| 47818 | if(self) ERRWRAP2(self->v.reset(new cv::detail::MultiBandBlender(try_gpu, num_bands, weight_type))); |  | 47770 | if(self) ERRWRAP2(self->v.reset(new cv::detail::MultiBandBlender(try_gpu, num_bands, weight_type)));
| 47819 | return 0; |  | 47771 | return 0;
| 47820 | } |  | 47772 | }
| 47821 |  |  | 47773 |
| 47822 | return -1; |  | 47774 | return -1;
| 47823 | } |  | 47775 | }
| 47824 |  |  | 47776 |
| 47825 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_blend(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47777 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_blend(PyObject* self, PyObject* py_args, PyObject* kw)
| 47826 | { |  | 47778 | {
| 47827 | using namespace cv::detail; |  | 47779 | using namespace cv::detail;
| 47828 |  |  | 47780 |
| 47829 |  |  | 47781 |
| 47830 | Ptr<cv::detail::MultiBandBlender> * self1 = 0; |  | 47782 | Ptr<cv::detail::MultiBandBlender> * self1 = 0;
| 47831 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1)) |  | 47783 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1))
| 47832 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)"); |  | 47784 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)");
| 47833 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1); |  | 47785 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1);
| 47834 | pyPrepareArgumentConversionErrorsStorage(2); |  | 47786 | pyPrepareArgumentConversionErrorsStorage(2);
| 47835 |  |  | 47787 |
| 47836 | { |  | 47788 | {
| 47837 | PyObject* pyobj_dst = NULL; |  | 47789 | PyObject* pyobj_dst = NULL;
| 47838 | Mat dst; |  | 47790 | Mat dst;
| 47839 | PyObject* pyobj_dst_mask = NULL; |  | 47791 | PyObject* pyobj_dst_mask = NULL;
| 47840 | Mat dst_mask; |  | 47792 | Mat dst_mask;
| 47841 |  |  | 47793 |
| 47842 | const char* keywords[] = { "dst", "dst_mask", NULL }; |  | 47794 | const char* keywords[] = { "dst", "dst_mask", NULL };
| 47843 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_MultiBandBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) && |  | 47795 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_MultiBandBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) &&
| 47844 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 47796 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 47845 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) ) |  | 47797 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) )
| 47846 | { |  | 47798 | {
| 47847 | ERRWRAP2(_self_->blend(dst, dst_mask)); |  | 47799 | ERRWRAP2(_self_->blend(dst, dst_mask));
| 47848 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask)); |  | 47800 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask));
| 47849 | } |  | 47801 | }
| 47850 |  |  | 47802 |
| 47851 |  |  | 47803 |
| 47852 | pyPopulateArgumentConversionErrors(); |  | 47804 | pyPopulateArgumentConversionErrors();
| 47853 | } |  | 47805 | }
| 47854 |  |  | 47806 |
| 47855 |  |  | 47807 |
| 47856 | { |  | 47808 | {
| 47857 | PyObject* pyobj_dst = NULL; |  | 47809 | PyObject* pyobj_dst = NULL;
| 47858 | UMat dst; |  | 47810 | UMat dst;
| 47859 | PyObject* pyobj_dst_mask = NULL; |  | 47811 | PyObject* pyobj_dst_mask = NULL;
| 47860 | UMat dst_mask; |  | 47812 | UMat dst_mask;
| 47861 |  |  | 47813 |
| 47862 | const char* keywords[] = { "dst", "dst_mask", NULL }; |  | 47814 | const char* keywords[] = { "dst", "dst_mask", NULL };
| 47863 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_MultiBandBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) && |  | 47815 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_MultiBandBlender.blend", (char**)keywords, &pyobj_dst, &pyobj_dst_mask) &&
| 47864 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) && |  | 47816 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) &&
| 47865 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) ) |  | 47817 | pyopencv_to_safe(pyobj_dst_mask, dst_mask, ArgInfo("dst_mask", 1)) )
| 47866 | { |  | 47818 | {
| 47867 | ERRWRAP2(_self_->blend(dst, dst_mask)); |  | 47819 | ERRWRAP2(_self_->blend(dst, dst_mask));
| 47868 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask)); |  | 47820 | return Py_BuildValue("(NN)", pyopencv_from(dst), pyopencv_from(dst_mask));
| 47869 | } |  | 47821 | }
| 47870 |  |  | 47822 |
| 47871 |  |  | 47823 |
| 47872 | pyPopulateArgumentConversionErrors(); |  | 47824 | pyPopulateArgumentConversionErrors();
| 47873 | } |  | 47825 | }
| 47874 | pyRaiseCVOverloadException("blend"); |  | 47826 | pyRaiseCVOverloadException("blend");
| 47875 |  |  | 47827 |
| 47876 | return NULL; |  | 47828 | return NULL;
| 47877 | } |  | 47829 | }
| 47878 |  |  | 47830 |
| 47879 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_feed(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47831 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_feed(PyObject* self, PyObject* py_args, PyObject* kw)
| 47880 | { |  | 47832 | {
| 47881 | using namespace cv::detail; |  | 47833 | using namespace cv::detail;
| 47882 |  |  | 47834 |
| 47883 |  |  | 47835 |
| 47884 | Ptr<cv::detail::MultiBandBlender> * self1 = 0; |  | 47836 | Ptr<cv::detail::MultiBandBlender> * self1 = 0;
| 47885 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1)) |  | 47837 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1))
| 47886 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)"); |  | 47838 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)");
| 47887 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1); |  | 47839 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1);
| 47888 | pyPrepareArgumentConversionErrorsStorage(2); |  | 47840 | pyPrepareArgumentConversionErrorsStorage(2);
| 47889 |  |  | 47841 |
| 47890 | { |  | 47842 | {
| 47891 | PyObject* pyobj_img = NULL; |  | 47843 | PyObject* pyobj_img = NULL;
| 47892 | Mat img; |  | 47844 | Mat img;
| 47893 | PyObject* pyobj_mask = NULL; |  | 47845 | PyObject* pyobj_mask = NULL;
| 47894 | Mat mask; |  | 47846 | Mat mask;
| 47895 | PyObject* pyobj_tl = NULL; |  | 47847 | PyObject* pyobj_tl = NULL;
| 47896 | Point tl; |  | 47848 | Point tl;
| 47897 |  |  | 47849 |
| 47898 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 47850 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 47899 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_MultiBandBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 47851 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_MultiBandBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 47900 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 47852 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 47901 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 47853 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 47902 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 47854 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 47903 | { |  | 47855 | {
| 47904 | ERRWRAP2(_self_->feed(img, mask, tl)); |  | 47856 | ERRWRAP2(_self_->feed(img, mask, tl));
| 47905 | Py_RETURN_NONE; |  | 47857 | Py_RETURN_NONE;
| 47906 | } |  | 47858 | }
| 47907 |  |  | 47859 |
| 47908 |  |  | 47860 |
| 47909 | pyPopulateArgumentConversionErrors(); |  | 47861 | pyPopulateArgumentConversionErrors();
| 47910 | } |  | 47862 | }
| 47911 |  |  | 47863 |
| 47912 |  |  | 47864 |
| 47913 | { |  | 47865 | {
| 47914 | PyObject* pyobj_img = NULL; |  | 47866 | PyObject* pyobj_img = NULL;
| 47915 | UMat img; |  | 47867 | UMat img;
| 47916 | PyObject* pyobj_mask = NULL; |  | 47868 | PyObject* pyobj_mask = NULL;
| 47917 | UMat mask; |  | 47869 | UMat mask;
| 47918 | PyObject* pyobj_tl = NULL; |  | 47870 | PyObject* pyobj_tl = NULL;
| 47919 | Point tl; |  | 47871 | Point tl;
| 47920 |  |  | 47872 |
| 47921 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 47873 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 47922 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_MultiBandBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 47874 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_MultiBandBlender.feed", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 47923 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 47875 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 47924 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 47876 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 47925 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 47877 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 47926 | { |  | 47878 | {
| 47927 | ERRWRAP2(_self_->feed(img, mask, tl)); |  | 47879 | ERRWRAP2(_self_->feed(img, mask, tl));
| 47928 | Py_RETURN_NONE; |  | 47880 | Py_RETURN_NONE;
| 47929 | } |  | 47881 | }
| 47930 |  |  | 47882 |
| 47931 |  |  | 47883 |
| 47932 | pyPopulateArgumentConversionErrors(); |  | 47884 | pyPopulateArgumentConversionErrors();
| 47933 | } |  | 47885 | }
| 47934 | pyRaiseCVOverloadException("feed"); |  | 47886 | pyRaiseCVOverloadException("feed");
| 47935 |  |  | 47887 |
| 47936 | return NULL; |  | 47888 | return NULL;
| 47937 | } |  | 47889 | }
| 47938 |  |  | 47890 |
| 47939 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_numBands(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47891 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_numBands(PyObject* self, PyObject* py_args, PyObject* kw)
| 47940 | { |  | 47892 | {
| 47941 | using namespace cv::detail; |  | 47893 | using namespace cv::detail;
| 47942 |  |  | 47894 |
| 47943 |  |  | 47895 |
| 47944 | Ptr<cv::detail::MultiBandBlender> * self1 = 0; |  | 47896 | Ptr<cv::detail::MultiBandBlender> * self1 = 0;
| 47945 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1)) |  | 47897 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1))
| 47946 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)"); |  | 47898 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)");
| 47947 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1); |  | 47899 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1);
| 47948 | int retval; |  | 47900 | int retval;
| 47949 |  |  | 47901 |
| 47950 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 47902 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 47951 | { |  | 47903 | {
| 47952 | ERRWRAP2(retval = _self_->numBands()); |  | 47904 | ERRWRAP2(retval = _self_->numBands());
| 47953 | return pyopencv_from(retval); |  | 47905 | return pyopencv_from(retval);
| 47954 | } |  | 47906 | }
| 47955 |  |  | 47907 |
| 47956 | return NULL; |  | 47908 | return NULL;
| 47957 | } |  | 47909 | }
| 47958 |  |  | 47910 |
| 47959 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_prepare(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47911 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_prepare(PyObject* self, PyObject* py_args, PyObject* kw)
| 47960 | { |  | 47912 | {
| 47961 | using namespace cv::detail; |  | 47913 | using namespace cv::detail;
| 47962 |  |  | 47914 |
| 47963 |  |  | 47915 |
| 47964 | Ptr<cv::detail::MultiBandBlender> * self1 = 0; |  | 47916 | Ptr<cv::detail::MultiBandBlender> * self1 = 0;
| 47965 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1)) |  | 47917 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1))
| 47966 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)"); |  | 47918 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)");
| 47967 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1); |  | 47919 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1);
| 47968 | PyObject* pyobj_dst_roi = NULL; |  | 47920 | PyObject* pyobj_dst_roi = NULL;
| 47969 | Rect dst_roi; |  | 47921 | Rect dst_roi;
| 47970 |  |  | 47922 |
| 47971 | const char* keywords[] = { "dst_roi", NULL }; |  | 47923 | const char* keywords[] = { "dst_roi", NULL };
| 47972 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_MultiBandBlender.prepare", (char**)keywords, &pyobj_dst_roi) && |  | 47924 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_MultiBandBlender.prepare", (char**)keywords, &pyobj_dst_roi) &&
| 47973 | pyopencv_to_safe(pyobj_dst_roi, dst_roi, ArgInfo("dst_roi", 0)) ) |  | 47925 | pyopencv_to_safe(pyobj_dst_roi, dst_roi, ArgInfo("dst_roi", 0)) )
| 47974 | { |  | 47926 | {
| 47975 | ERRWRAP2(_self_->prepare(dst_roi)); |  | 47927 | ERRWRAP2(_self_->prepare(dst_roi));
| 47976 | Py_RETURN_NONE; |  | 47928 | Py_RETURN_NONE;
| 47977 | } |  | 47929 | }
| 47978 |  |  | 47930 |
| 47979 | return NULL; |  | 47931 | return NULL;
| 47980 | } |  | 47932 | }
| 47981 |  |  | 47933 |
| 47982 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_setNumBands(PyObject* self, PyObject* py_args, PyObject* kw) |  | 47934 | static PyObject* pyopencv_cv_detail_detail_MultiBandBlender_setNumBands(PyObject* self, PyObject* py_args, PyObject* kw)
| 47983 | { |  | 47935 | {
| 47984 | using namespace cv::detail; |  | 47936 | using namespace cv::detail;
| 47985 |  |  | 47937 |
| 47986 |  |  | 47938 |
| 47987 | Ptr<cv::detail::MultiBandBlender> * self1 = 0; |  | 47939 | Ptr<cv::detail::MultiBandBlender> * self1 = 0;
| 47988 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1)) |  | 47940 | if (!pyopencv_detail_MultiBandBlender_getp(self, self1))
| 47989 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)"); |  | 47941 | return failmsgp("Incorrect type of self (must be 'detail_MultiBandBlender' or its derivative)");
| 47990 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1); |  | 47942 | Ptr<cv::detail::MultiBandBlender> _self_ = *(self1);
| 47991 | PyObject* pyobj_val = NULL; |  | 47943 | PyObject* pyobj_val = NULL;
| 47992 | int val=0; |  | 47944 | int val=0;
| 47993 |  |  | 47945 |
| 47994 | const char* keywords[] = { "val", NULL }; |  | 47946 | const char* keywords[] = { "val", NULL };
| 47995 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_MultiBandBlender.setNumBands", (char**)keywords, &pyobj_val) && |  | 47947 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_MultiBandBlender.setNumBands", (char**)keywords, &pyobj_val) &&
| 47996 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 47948 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 47997 | { |  | 47949 | {
| 47998 | ERRWRAP2(_self_->setNumBands(val)); |  | 47950 | ERRWRAP2(_self_->setNumBands(val));
| 47999 | Py_RETURN_NONE; |  | 47951 | Py_RETURN_NONE;
| 48000 | } |  | 47952 | }
| 48001 |  |  | 47953 |
| 48002 | return NULL; |  | 47954 | return NULL;
| 48003 | } |  | 47955 | }
| 48004 |  |  | 47956 |
| 48005 |  |  | 47957 |
| 48006 |  |  | 47958 |
| 48007 | // Tables (detail_MultiBandBlender) |  | 47959 | // Tables (detail_MultiBandBlender)
| 48008 |  |  | 47960 |
| 48009 | static PyGetSetDef pyopencv_detail_MultiBandBlender_getseters[] = |  | 47961 | static PyGetSetDef pyopencv_detail_MultiBandBlender_getseters[] =
| 48010 | { |  | 47962 | {
| 48011 | {NULL} /* Sentinel */ |  | 47963 | {NULL} /* Sentinel */
| 48012 | }; |  | 47964 | };
| 48013 |  |  | 47965 |
| 48014 | static PyMethodDef pyopencv_detail_MultiBandBlender_methods[] = |  | 47966 | static PyMethodDef pyopencv_detail_MultiBandBlender_methods[] =
| 48015 | { |  | 47967 | {
| 48016 | {"blend", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_blend, 0), "blend(dst, dst_mask) -> dst, dst_mask\n."}, |  | 47968 | {"blend", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_blend, 0), "blend(dst, dst_mask) -> dst, dst_mask\n."},
| 48017 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_feed, 0), "feed(img, mask, tl) -> None\n."}, |  | 47969 | {"feed", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_feed, 0), "feed(img, mask, tl) -> None\n."},
| 48018 | {"numBands", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_numBands, 0), "numBands() -> retval\n."}, |  | 47970 | {"numBands", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_numBands, 0), "numBands() -> retval\n."},
| 48019 | {"prepare", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_prepare, 0), "prepare(dst_roi) -> None\n."}, |  | 47971 | {"prepare", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_prepare, 0), "prepare(dst_roi) -> None\n."},
| 48020 | {"setNumBands", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_setNumBands, 0), "setNumBands(val) -> None\n."}, |  | 47972 | {"setNumBands", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_MultiBandBlender_setNumBands, 0), "setNumBands(val) -> None\n."},
| 48021 |  |  | 47973 |
| 48022 | {NULL, NULL} |  | 47974 | {NULL, NULL}
| 48023 | }; |  | 47975 | };
| 48024 |  |  | 47976 |
| 48025 | // Converter (detail_MultiBandBlender) |  | 47977 | // Converter (detail_MultiBandBlender)
| 48026 |  |  | 47978 |
| 48027 | template<> |  | 47979 | template<>
| 48028 | struct PyOpenCV_Converter< Ptr<cv::detail::MultiBandBlender> > |  | 47980 | struct PyOpenCV_Converter< Ptr<cv::detail::MultiBandBlender> >
| 48029 | { |  | 47981 | {
| 48030 | static PyObject* from(const Ptr<cv::detail::MultiBandBlender>& r) |  | 47982 | static PyObject* from(const Ptr<cv::detail::MultiBandBlender>& r)
| 48031 | { |  | 47983 | {
| 48032 | return pyopencv_detail_MultiBandBlender_Instance(r); |  | 47984 | return pyopencv_detail_MultiBandBlender_Instance(r);
| 48033 | } |  | 47985 | }
| 48034 | static bool to(PyObject* src, Ptr<cv::detail::MultiBandBlender>& dst, const ArgInfo& info) |  | 47986 | static bool to(PyObject* src, Ptr<cv::detail::MultiBandBlender>& dst, const ArgInfo& info)
| 48035 | { |  | 47987 | {
| 48036 | if(!src || src == Py_None) |  | 47988 | if(!src || src == Py_None)
| 48037 | return true; |  | 47989 | return true;
| 48038 | Ptr<cv::detail::MultiBandBlender> * dst_; |  | 47990 | Ptr<cv::detail::MultiBandBlender> * dst_;
| 48039 | if (pyopencv_detail_MultiBandBlender_getp(src, dst_)) |  | 47991 | if (pyopencv_detail_MultiBandBlender_getp(src, dst_))
| 48040 | { |  | 47992 | {
| 48041 | dst = *dst_; |  | 47993 | dst = *dst_;
| 48042 | return true; |  | 47994 | return true;
| 48043 | } |  | 47995 | }
| 48044 |  |  | 47996 |
| 48045 | failmsg("Expected Ptr<cv::detail::MultiBandBlender> for argument '%s'", info.name); |  | 47997 | failmsg("Expected Ptr<cv::detail::MultiBandBlender> for argument '%s'", info.name);
| 48046 | return false; |  | 47998 | return false;
| 48047 | } |  | 47999 | }
| 48048 | }; |  | 48000 | };
| 48049 |  |  | 48001 |
| 48050 | //================================================================================ |  | 48002 | //================================================================================
| 48051 | // detail_NoBundleAdjuster (Generic) |  | 48003 | // detail_NoBundleAdjuster (Generic)
| 48052 | //================================================================================ |  | 48004 | //================================================================================
| 48053 |  |  | 48005 |
| 48054 | // GetSet (detail_NoBundleAdjuster) |  | 48006 | // GetSet (detail_NoBundleAdjuster)
| 48055 |  |  | 48007 |
| 48056 |  |  | 48008 |
| 48057 |  |  | 48009 |
| 48058 | // Methods (detail_NoBundleAdjuster) |  | 48010 | // Methods (detail_NoBundleAdjuster)
| 48059 |  |  | 48011 |
| 48060 | static int pyopencv_cv_detail_detail_NoBundleAdjuster_NoBundleAdjuster(pyopencv_detail_NoBundleAdjuster_t* self, PyObject* py_args, PyObject* kw) |  | 48012 | static int pyopencv_cv_detail_detail_NoBundleAdjuster_NoBundleAdjuster(pyopencv_detail_NoBundleAdjuster_t* self, PyObject* py_args, PyObject* kw)
| 48061 | { |  | 48013 | {
| 48062 | using namespace cv::detail; |  | 48014 | using namespace cv::detail;
| 48063 |  |  | 48015 |
| 48064 |  |  | 48016 |
| 48065 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 48017 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 48066 | { |  | 48018 | {
| 48067 | new (&(self->v)) Ptr<cv::detail::NoBundleAdjuster>(); // init Ptr with placement new |  | 48019 | new (&(self->v)) Ptr<cv::detail::NoBundleAdjuster>(); // init Ptr with placement new
| 48068 | if(self) ERRWRAP2(self->v.reset(new cv::detail::NoBundleAdjuster())); |  | 48020 | if(self) ERRWRAP2(self->v.reset(new cv::detail::NoBundleAdjuster()));
| 48069 | return 0; |  | 48021 | return 0;
| 48070 | } |  | 48022 | }
| 48071 |  |  | 48023 |
| 48072 | return -1; |  | 48024 | return -1;
| 48073 | } |  | 48025 | }
| 48074 |  |  | 48026 |
| 48075 |  |  | 48027 |
| 48076 |  |  | 48028 |
| 48077 | // Tables (detail_NoBundleAdjuster) |  | 48029 | // Tables (detail_NoBundleAdjuster)
| 48078 |  |  | 48030 |
| 48079 | static PyGetSetDef pyopencv_detail_NoBundleAdjuster_getseters[] = |  | 48031 | static PyGetSetDef pyopencv_detail_NoBundleAdjuster_getseters[] =
| 48080 | { |  | 48032 | {
| 48081 | {NULL} /* Sentinel */ |  | 48033 | {NULL} /* Sentinel */
| 48082 | }; |  | 48034 | };
| 48083 |  |  | 48035 |
| 48084 | static PyMethodDef pyopencv_detail_NoBundleAdjuster_methods[] = |  | 48036 | static PyMethodDef pyopencv_detail_NoBundleAdjuster_methods[] =
| 48085 | { |  | 48037 | {
| 48086 |  |  | 48038 |
| 48087 | {NULL, NULL} |  | 48039 | {NULL, NULL}
| 48088 | }; |  | 48040 | };
| 48089 |  |  | 48041 |
| 48090 | // Converter (detail_NoBundleAdjuster) |  | 48042 | // Converter (detail_NoBundleAdjuster)
| 48091 |  |  | 48043 |
| 48092 | template<> |  | 48044 | template<>
| 48093 | struct PyOpenCV_Converter< Ptr<cv::detail::NoBundleAdjuster> > |  | 48045 | struct PyOpenCV_Converter< Ptr<cv::detail::NoBundleAdjuster> >
| 48094 | { |  | 48046 | {
| 48095 | static PyObject* from(const Ptr<cv::detail::NoBundleAdjuster>& r) |  | 48047 | static PyObject* from(const Ptr<cv::detail::NoBundleAdjuster>& r)
| 48096 | { |  | 48048 | {
| 48097 | return pyopencv_detail_NoBundleAdjuster_Instance(r); |  | 48049 | return pyopencv_detail_NoBundleAdjuster_Instance(r);
| 48098 | } |  | 48050 | }
| 48099 | static bool to(PyObject* src, Ptr<cv::detail::NoBundleAdjuster>& dst, const ArgInfo& info) |  | 48051 | static bool to(PyObject* src, Ptr<cv::detail::NoBundleAdjuster>& dst, const ArgInfo& info)
| 48100 | { |  | 48052 | {
| 48101 | if(!src || src == Py_None) |  | 48053 | if(!src || src == Py_None)
| 48102 | return true; |  | 48054 | return true;
| 48103 | Ptr<cv::detail::NoBundleAdjuster> * dst_; |  | 48055 | Ptr<cv::detail::NoBundleAdjuster> * dst_;
| 48104 | if (pyopencv_detail_NoBundleAdjuster_getp(src, dst_)) |  | 48056 | if (pyopencv_detail_NoBundleAdjuster_getp(src, dst_))
| 48105 | { |  | 48057 | {
| 48106 | dst = *dst_; |  | 48058 | dst = *dst_;
| 48107 | return true; |  | 48059 | return true;
| 48108 | } |  | 48060 | }
| 48109 |  |  | 48061 |
| 48110 | failmsg("Expected Ptr<cv::detail::NoBundleAdjuster> for argument '%s'", info.name); |  | 48062 | failmsg("Expected Ptr<cv::detail::NoBundleAdjuster> for argument '%s'", info.name);
| 48111 | return false; |  | 48063 | return false;
| 48112 | } |  | 48064 | }
| 48113 | }; |  | 48065 | };
| 48114 |  |  | 48066 |
| 48115 | //================================================================================ |  | 48067 | //================================================================================
| 48116 | // detail_NoExposureCompensator (Generic) |  | 48068 | // detail_NoExposureCompensator (Generic)
| 48117 | //================================================================================ |  | 48069 | //================================================================================
| 48118 |  |  | 48070 |
| 48119 | // GetSet (detail_NoExposureCompensator) |  | 48071 | // GetSet (detail_NoExposureCompensator)
| 48120 |  |  | 48072 |
| 48121 |  |  | 48073 |
| 48122 |  |  | 48074 |
| 48123 | // Methods (detail_NoExposureCompensator) |  | 48075 | // Methods (detail_NoExposureCompensator)
| 48124 |  |  | 48076 |
| 48125 | static PyObject* pyopencv_cv_detail_detail_NoExposureCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48077 | static PyObject* pyopencv_cv_detail_detail_NoExposureCompensator_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 48126 | { |  | 48078 | {
| 48127 | using namespace cv::detail; |  | 48079 | using namespace cv::detail;
| 48128 |  |  | 48080 |
| 48129 |  |  | 48081 |
| 48130 | Ptr<cv::detail::NoExposureCompensator> * self1 = 0; |  | 48082 | Ptr<cv::detail::NoExposureCompensator> * self1 = 0;
| 48131 | if (!pyopencv_detail_NoExposureCompensator_getp(self, self1)) |  | 48083 | if (!pyopencv_detail_NoExposureCompensator_getp(self, self1))
| 48132 | return failmsgp("Incorrect type of self (must be 'detail_NoExposureCompensator' or its derivative)"); |  | 48084 | return failmsgp("Incorrect type of self (must be 'detail_NoExposureCompensator' or its derivative)");
| 48133 | Ptr<cv::detail::NoExposureCompensator> _self_ = *(self1); |  | 48085 | Ptr<cv::detail::NoExposureCompensator> _self_ = *(self1);
| 48134 | pyPrepareArgumentConversionErrorsStorage(2); |  | 48086 | pyPrepareArgumentConversionErrorsStorage(2);
| 48135 |  |  | 48087 |
| 48136 | { |  | 48088 | {
| 48137 | PyObject* pyobj_arg1 = NULL; |  | 48089 | PyObject* pyobj_arg1 = NULL;
| 48138 | int arg1=0; |  | 48090 | int arg1=0;
| 48139 | PyObject* pyobj_arg2 = NULL; |  | 48091 | PyObject* pyobj_arg2 = NULL;
| 48140 | Point arg2; |  | 48092 | Point arg2;
| 48141 | PyObject* pyobj_arg3 = NULL; |  | 48093 | PyObject* pyobj_arg3 = NULL;
| 48142 | Mat arg3; |  | 48094 | Mat arg3;
| 48143 | PyObject* pyobj_arg4 = NULL; |  | 48095 | PyObject* pyobj_arg4 = NULL;
| 48144 | Mat arg4; |  | 48096 | Mat arg4;
| 48145 |  |  | 48097 |
| 48146 | const char* keywords[] = { "arg1", "arg2", "arg3", "arg4", NULL }; |  | 48098 | const char* keywords[] = { "arg1", "arg2", "arg3", "arg4", NULL };
| 48147 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_NoExposureCompensator.apply", (char**)keywords, &pyobj_arg1, &pyobj_arg2, &pyobj_arg3, &pyobj_arg4) && |  | 48099 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_NoExposureCompensator.apply", (char**)keywords, &pyobj_arg1, &pyobj_arg2, &pyobj_arg3, &pyobj_arg4) &&
| 48148 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) && |  | 48100 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) &&
| 48149 | pyopencv_to_safe(pyobj_arg2, arg2, ArgInfo("arg2", 0)) && |  | 48101 | pyopencv_to_safe(pyobj_arg2, arg2, ArgInfo("arg2", 0)) &&
| 48150 | pyopencv_to_safe(pyobj_arg3, arg3, ArgInfo("arg3", 1)) && |  | 48102 | pyopencv_to_safe(pyobj_arg3, arg3, ArgInfo("arg3", 1)) &&
| 48151 | pyopencv_to_safe(pyobj_arg4, arg4, ArgInfo("arg4", 0)) ) |  | 48103 | pyopencv_to_safe(pyobj_arg4, arg4, ArgInfo("arg4", 0)) )
| 48152 | { |  | 48104 | {
| 48153 | ERRWRAP2(_self_->apply(arg1, arg2, arg3, arg4)); |  | 48105 | ERRWRAP2(_self_->apply(arg1, arg2, arg3, arg4));
| 48154 | return pyopencv_from(arg3); |  | 48106 | return pyopencv_from(arg3);
| 48155 | } |  | 48107 | }
| 48156 |  |  | 48108 |
| 48157 |  |  | 48109 |
| 48158 | pyPopulateArgumentConversionErrors(); |  | 48110 | pyPopulateArgumentConversionErrors();
| 48159 | } |  | 48111 | }
| 48160 |  |  | 48112 |
| 48161 |  |  | 48113 |
| 48162 | { |  | 48114 | {
| 48163 | PyObject* pyobj_arg1 = NULL; |  | 48115 | PyObject* pyobj_arg1 = NULL;
| 48164 | int arg1=0; |  | 48116 | int arg1=0;
| 48165 | PyObject* pyobj_arg2 = NULL; |  | 48117 | PyObject* pyobj_arg2 = NULL;
| 48166 | Point arg2; |  | 48118 | Point arg2;
| 48167 | PyObject* pyobj_arg3 = NULL; |  | 48119 | PyObject* pyobj_arg3 = NULL;
| 48168 | UMat arg3; |  | 48120 | UMat arg3;
| 48169 | PyObject* pyobj_arg4 = NULL; |  | 48121 | PyObject* pyobj_arg4 = NULL;
| 48170 | UMat arg4; |  | 48122 | UMat arg4;
| 48171 |  |  | 48123 |
| 48172 | const char* keywords[] = { "arg1", "arg2", "arg3", "arg4", NULL }; |  | 48124 | const char* keywords[] = { "arg1", "arg2", "arg3", "arg4", NULL };
| 48173 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_NoExposureCompensator.apply", (char**)keywords, &pyobj_arg1, &pyobj_arg2, &pyobj_arg3, &pyobj_arg4) && |  | 48125 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_NoExposureCompensator.apply", (char**)keywords, &pyobj_arg1, &pyobj_arg2, &pyobj_arg3, &pyobj_arg4) &&
| 48174 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) && |  | 48126 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) &&
| 48175 | pyopencv_to_safe(pyobj_arg2, arg2, ArgInfo("arg2", 0)) && |  | 48127 | pyopencv_to_safe(pyobj_arg2, arg2, ArgInfo("arg2", 0)) &&
| 48176 | pyopencv_to_safe(pyobj_arg3, arg3, ArgInfo("arg3", 1)) && |  | 48128 | pyopencv_to_safe(pyobj_arg3, arg3, ArgInfo("arg3", 1)) &&
| 48177 | pyopencv_to_safe(pyobj_arg4, arg4, ArgInfo("arg4", 0)) ) |  | 48129 | pyopencv_to_safe(pyobj_arg4, arg4, ArgInfo("arg4", 0)) )
| 48178 | { |  | 48130 | {
| 48179 | ERRWRAP2(_self_->apply(arg1, arg2, arg3, arg4)); |  | 48131 | ERRWRAP2(_self_->apply(arg1, arg2, arg3, arg4));
| 48180 | return pyopencv_from(arg3); |  | 48132 | return pyopencv_from(arg3);
| 48181 | } |  | 48133 | }
| 48182 |  |  | 48134 |
| 48183 |  |  | 48135 |
| 48184 | pyPopulateArgumentConversionErrors(); |  | 48136 | pyPopulateArgumentConversionErrors();
| 48185 | } |  | 48137 | }
| 48186 | pyRaiseCVOverloadException("apply"); |  | 48138 | pyRaiseCVOverloadException("apply");
| 48187 |  |  | 48139 |
| 48188 | return NULL; |  | 48140 | return NULL;
| 48189 | } |  | 48141 | }
| 48190 |  |  | 48142 |
| 48191 | static PyObject* pyopencv_cv_detail_detail_NoExposureCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48143 | static PyObject* pyopencv_cv_detail_detail_NoExposureCompensator_getMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 48192 | { |  | 48144 | {
| 48193 | using namespace cv::detail; |  | 48145 | using namespace cv::detail;
| 48194 |  |  | 48146 |
| 48195 |  |  | 48147 |
| 48196 | Ptr<cv::detail::NoExposureCompensator> * self1 = 0; |  | 48148 | Ptr<cv::detail::NoExposureCompensator> * self1 = 0;
| 48197 | if (!pyopencv_detail_NoExposureCompensator_getp(self, self1)) |  | 48149 | if (!pyopencv_detail_NoExposureCompensator_getp(self, self1))
| 48198 | return failmsgp("Incorrect type of self (must be 'detail_NoExposureCompensator' or its derivative)"); |  | 48150 | return failmsgp("Incorrect type of self (must be 'detail_NoExposureCompensator' or its derivative)");
| 48199 | Ptr<cv::detail::NoExposureCompensator> _self_ = *(self1); |  | 48151 | Ptr<cv::detail::NoExposureCompensator> _self_ = *(self1);
| 48200 | PyObject* pyobj_umv = NULL; |  | 48152 | PyObject* pyobj_umv = NULL;
| 48201 | vector_Mat umv; |  | 48153 | vector_Mat umv;
| 48202 |  |  | 48154 |
| 48203 | const char* keywords[] = { "umv", NULL }; |  | 48155 | const char* keywords[] = { "umv", NULL };
| 48204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_NoExposureCompensator.getMatGains", (char**)keywords, &pyobj_umv) && |  | 48156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:detail_NoExposureCompensator.getMatGains", (char**)keywords, &pyobj_umv) &&
| 48205 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) ) |  | 48157 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 1)) )
| 48206 | { |  | 48158 | {
| 48207 | ERRWRAP2(_self_->getMatGains(umv)); |  | 48159 | ERRWRAP2(_self_->getMatGains(umv));
| 48208 | return pyopencv_from(umv); |  | 48160 | return pyopencv_from(umv);
| 48209 | } |  | 48161 | }
| 48210 |  |  | 48162 |
| 48211 | return NULL; |  | 48163 | return NULL;
| 48212 | } |  | 48164 | }
| 48213 |  |  | 48165 |
| 48214 | static PyObject* pyopencv_cv_detail_detail_NoExposureCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48166 | static PyObject* pyopencv_cv_detail_detail_NoExposureCompensator_setMatGains(PyObject* self, PyObject* py_args, PyObject* kw)
| 48215 | { |  | 48167 | {
| 48216 | using namespace cv::detail; |  | 48168 | using namespace cv::detail;
| 48217 |  |  | 48169 |
| 48218 |  |  | 48170 |
| 48219 | Ptr<cv::detail::NoExposureCompensator> * self1 = 0; |  | 48171 | Ptr<cv::detail::NoExposureCompensator> * self1 = 0;
| 48220 | if (!pyopencv_detail_NoExposureCompensator_getp(self, self1)) |  | 48172 | if (!pyopencv_detail_NoExposureCompensator_getp(self, self1))
| 48221 | return failmsgp("Incorrect type of self (must be 'detail_NoExposureCompensator' or its derivative)"); |  | 48173 | return failmsgp("Incorrect type of self (must be 'detail_NoExposureCompensator' or its derivative)");
| 48222 | Ptr<cv::detail::NoExposureCompensator> _self_ = *(self1); |  | 48174 | Ptr<cv::detail::NoExposureCompensator> _self_ = *(self1);
| 48223 | PyObject* pyobj_umv = NULL; |  | 48175 | PyObject* pyobj_umv = NULL;
| 48224 | vector_Mat umv; |  | 48176 | vector_Mat umv;
| 48225 |  |  | 48177 |
| 48226 | const char* keywords[] = { "umv", NULL }; |  | 48178 | const char* keywords[] = { "umv", NULL };
| 48227 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_NoExposureCompensator.setMatGains", (char**)keywords, &pyobj_umv) && |  | 48179 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_NoExposureCompensator.setMatGains", (char**)keywords, &pyobj_umv) &&
| 48228 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) ) |  | 48180 | pyopencv_to_safe(pyobj_umv, umv, ArgInfo("umv", 0)) )
| 48229 | { |  | 48181 | {
| 48230 | ERRWRAP2(_self_->setMatGains(umv)); |  | 48182 | ERRWRAP2(_self_->setMatGains(umv));
| 48231 | Py_RETURN_NONE; |  | 48183 | Py_RETURN_NONE;
| 48232 | } |  | 48184 | }
| 48233 |  |  | 48185 |
| 48234 | return NULL; |  | 48186 | return NULL;
| 48235 | } |  | 48187 | }
| 48236 |  |  | 48188 |
| 48237 |  |  | 48189 |
| 48238 |  |  | 48190 |
| 48239 | // Tables (detail_NoExposureCompensator) |  | 48191 | // Tables (detail_NoExposureCompensator)
| 48240 |  |  | 48192 |
| 48241 | static PyGetSetDef pyopencv_detail_NoExposureCompensator_getseters[] = |  | 48193 | static PyGetSetDef pyopencv_detail_NoExposureCompensator_getseters[] =
| 48242 | { |  | 48194 | {
| 48243 | {NULL} /* Sentinel */ |  | 48195 | {NULL} /* Sentinel */
| 48244 | }; |  | 48196 | };
| 48245 |  |  | 48197 |
| 48246 | static PyMethodDef pyopencv_detail_NoExposureCompensator_methods[] = |  | 48198 | static PyMethodDef pyopencv_detail_NoExposureCompensator_methods[] =
| 48247 | { |  | 48199 | {
| 48248 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoExposureCompensator_apply, 0), "apply(arg1, arg2, arg3, arg4) -> arg3\n."}, |  | 48200 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoExposureCompensator_apply, 0), "apply(arg1, arg2, arg3, arg4) -> arg3\n."},
| 48249 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoExposureCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."}, |  | 48201 | {"getMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoExposureCompensator_getMatGains, 0), "getMatGains([, umv]) -> umv\n."},
| 48250 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoExposureCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."}, |  | 48202 | {"setMatGains", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoExposureCompensator_setMatGains, 0), "setMatGains(umv) -> None\n."},
| 48251 |  |  | 48203 |
| 48252 | {NULL, NULL} |  | 48204 | {NULL, NULL}
| 48253 | }; |  | 48205 | };
| 48254 |  |  | 48206 |
| 48255 | // Converter (detail_NoExposureCompensator) |  | 48207 | // Converter (detail_NoExposureCompensator)
| 48256 |  |  | 48208 |
| 48257 | template<> |  | 48209 | template<>
| 48258 | struct PyOpenCV_Converter< Ptr<cv::detail::NoExposureCompensator> > |  | 48210 | struct PyOpenCV_Converter< Ptr<cv::detail::NoExposureCompensator> >
| 48259 | { |  | 48211 | {
| 48260 | static PyObject* from(const Ptr<cv::detail::NoExposureCompensator>& r) |  | 48212 | static PyObject* from(const Ptr<cv::detail::NoExposureCompensator>& r)
| 48261 | { |  | 48213 | {
| 48262 | return pyopencv_detail_NoExposureCompensator_Instance(r); |  | 48214 | return pyopencv_detail_NoExposureCompensator_Instance(r);
| 48263 | } |  | 48215 | }
| 48264 | static bool to(PyObject* src, Ptr<cv::detail::NoExposureCompensator>& dst, const ArgInfo& info) |  | 48216 | static bool to(PyObject* src, Ptr<cv::detail::NoExposureCompensator>& dst, const ArgInfo& info)
| 48265 | { |  | 48217 | {
| 48266 | if(!src || src == Py_None) |  | 48218 | if(!src || src == Py_None)
| 48267 | return true; |  | 48219 | return true;
| 48268 | Ptr<cv::detail::NoExposureCompensator> * dst_; |  | 48220 | Ptr<cv::detail::NoExposureCompensator> * dst_;
| 48269 | if (pyopencv_detail_NoExposureCompensator_getp(src, dst_)) |  | 48221 | if (pyopencv_detail_NoExposureCompensator_getp(src, dst_))
| 48270 | { |  | 48222 | {
| 48271 | dst = *dst_; |  | 48223 | dst = *dst_;
| 48272 | return true; |  | 48224 | return true;
| 48273 | } |  | 48225 | }
| 48274 |  |  | 48226 |
| 48275 | failmsg("Expected Ptr<cv::detail::NoExposureCompensator> for argument '%s'", info.name); |  | 48227 | failmsg("Expected Ptr<cv::detail::NoExposureCompensator> for argument '%s'", info.name);
| 48276 | return false; |  | 48228 | return false;
| 48277 | } |  | 48229 | }
| 48278 | }; |  | 48230 | };
| 48279 |  |  | 48231 |
| 48280 | //================================================================================ |  | 48232 | //================================================================================
| 48281 | // detail_NoSeamFinder (Generic) |  | 48233 | // detail_NoSeamFinder (Generic)
| 48282 | //================================================================================ |  | 48234 | //================================================================================
| 48283 |  |  | 48235 |
| 48284 | // GetSet (detail_NoSeamFinder) |  | 48236 | // GetSet (detail_NoSeamFinder)
| 48285 |  |  | 48237 |
| 48286 |  |  | 48238 |
| 48287 |  |  | 48239 |
| 48288 | // Methods (detail_NoSeamFinder) |  | 48240 | // Methods (detail_NoSeamFinder)
| 48289 |  |  | 48241 |
| 48290 | static PyObject* pyopencv_cv_detail_detail_NoSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48242 | static PyObject* pyopencv_cv_detail_detail_NoSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw)
| 48291 | { |  | 48243 | {
| 48292 | using namespace cv::detail; |  | 48244 | using namespace cv::detail;
| 48293 |  |  | 48245 |
| 48294 |  |  | 48246 |
| 48295 | Ptr<cv::detail::NoSeamFinder> * self1 = 0; |  | 48247 | Ptr<cv::detail::NoSeamFinder> * self1 = 0;
| 48296 | if (!pyopencv_detail_NoSeamFinder_getp(self, self1)) |  | 48248 | if (!pyopencv_detail_NoSeamFinder_getp(self, self1))
| 48297 | return failmsgp("Incorrect type of self (must be 'detail_NoSeamFinder' or its derivative)"); |  | 48249 | return failmsgp("Incorrect type of self (must be 'detail_NoSeamFinder' or its derivative)");
| 48298 | Ptr<cv::detail::NoSeamFinder> _self_ = *(self1); |  | 48250 | Ptr<cv::detail::NoSeamFinder> _self_ = *(self1);
| 48299 | PyObject* pyobj_arg1 = NULL; |  | 48251 | PyObject* pyobj_arg1 = NULL;
| 48300 | vector_UMat arg1; |  | 48252 | vector_UMat arg1;
| 48301 | PyObject* pyobj_arg2 = NULL; |  | 48253 | PyObject* pyobj_arg2 = NULL;
| 48302 | vector_Point arg2; |  | 48254 | vector_Point arg2;
| 48303 | PyObject* pyobj_arg3 = NULL; |  | 48255 | PyObject* pyobj_arg3 = NULL;
| 48304 | vector_UMat arg3; |  | 48256 | vector_UMat arg3;
| 48305 |  |  | 48257 |
| 48306 | const char* keywords[] = { "arg1", "arg2", "arg3", NULL }; |  | 48258 | const char* keywords[] = { "arg1", "arg2", "arg3", NULL };
| 48307 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_NoSeamFinder.find", (char**)keywords, &pyobj_arg1, &pyobj_arg2, &pyobj_arg3) && |  | 48259 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_NoSeamFinder.find", (char**)keywords, &pyobj_arg1, &pyobj_arg2, &pyobj_arg3) &&
| 48308 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) && |  | 48260 | pyopencv_to_safe(pyobj_arg1, arg1, ArgInfo("arg1", 0)) &&
| 48309 | pyopencv_to_safe(pyobj_arg2, arg2, ArgInfo("arg2", 0)) && |  | 48261 | pyopencv_to_safe(pyobj_arg2, arg2, ArgInfo("arg2", 0)) &&
| 48310 | pyopencv_to_safe(pyobj_arg3, arg3, ArgInfo("arg3", 1)) ) |  | 48262 | pyopencv_to_safe(pyobj_arg3, arg3, ArgInfo("arg3", 1)) )
| 48311 | { |  | 48263 | {
| 48312 | ERRWRAP2(_self_->find(arg1, arg2, arg3)); |  | 48264 | ERRWRAP2(_self_->find(arg1, arg2, arg3));
| 48313 | return pyopencv_from(arg3); |  | 48265 | return pyopencv_from(arg3);
| 48314 | } |  | 48266 | }
| 48315 |  |  | 48267 |
| 48316 | return NULL; |  | 48268 | return NULL;
| 48317 | } |  | 48269 | }
| 48318 |  |  | 48270 |
| 48319 |  |  | 48271 |
| 48320 |  |  | 48272 |
| 48321 | // Tables (detail_NoSeamFinder) |  | 48273 | // Tables (detail_NoSeamFinder)
| 48322 |  |  | 48274 |
| 48323 | static PyGetSetDef pyopencv_detail_NoSeamFinder_getseters[] = |  | 48275 | static PyGetSetDef pyopencv_detail_NoSeamFinder_getseters[] =
| 48324 | { |  | 48276 | {
| 48325 | {NULL} /* Sentinel */ |  | 48277 | {NULL} /* Sentinel */
| 48326 | }; |  | 48278 | };
| 48327 |  |  | 48279 |
| 48328 | static PyMethodDef pyopencv_detail_NoSeamFinder_methods[] = |  | 48280 | static PyMethodDef pyopencv_detail_NoSeamFinder_methods[] =
| 48329 | { |  | 48281 | {
| 48330 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoSeamFinder_find, 0), "find(arg1, arg2, arg3) -> arg3\n."}, |  | 48282 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_NoSeamFinder_find, 0), "find(arg1, arg2, arg3) -> arg3\n."},
| 48331 |  |  | 48283 |
| 48332 | {NULL, NULL} |  | 48284 | {NULL, NULL}
| 48333 | }; |  | 48285 | };
| 48334 |  |  | 48286 |
| 48335 | // Converter (detail_NoSeamFinder) |  | 48287 | // Converter (detail_NoSeamFinder)
| 48336 |  |  | 48288 |
| 48337 | template<> |  | 48289 | template<>
| 48338 | struct PyOpenCV_Converter< Ptr<cv::detail::NoSeamFinder> > |  | 48290 | struct PyOpenCV_Converter< Ptr<cv::detail::NoSeamFinder> >
| 48339 | { |  | 48291 | {
| 48340 | static PyObject* from(const Ptr<cv::detail::NoSeamFinder>& r) |  | 48292 | static PyObject* from(const Ptr<cv::detail::NoSeamFinder>& r)
| 48341 | { |  | 48293 | {
| 48342 | return pyopencv_detail_NoSeamFinder_Instance(r); |  | 48294 | return pyopencv_detail_NoSeamFinder_Instance(r);
| 48343 | } |  | 48295 | }
| 48344 | static bool to(PyObject* src, Ptr<cv::detail::NoSeamFinder>& dst, const ArgInfo& info) |  | 48296 | static bool to(PyObject* src, Ptr<cv::detail::NoSeamFinder>& dst, const ArgInfo& info)
| 48345 | { |  | 48297 | {
| 48346 | if(!src || src == Py_None) |  | 48298 | if(!src || src == Py_None)
| 48347 | return true; |  | 48299 | return true;
| 48348 | Ptr<cv::detail::NoSeamFinder> * dst_; |  | 48300 | Ptr<cv::detail::NoSeamFinder> * dst_;
| 48349 | if (pyopencv_detail_NoSeamFinder_getp(src, dst_)) |  | 48301 | if (pyopencv_detail_NoSeamFinder_getp(src, dst_))
| 48350 | { |  | 48302 | {
| 48351 | dst = *dst_; |  | 48303 | dst = *dst_;
| 48352 | return true; |  | 48304 | return true;
| 48353 | } |  | 48305 | }
| 48354 |  |  | 48306 |
| 48355 | failmsg("Expected Ptr<cv::detail::NoSeamFinder> for argument '%s'", info.name); |  | 48307 | failmsg("Expected Ptr<cv::detail::NoSeamFinder> for argument '%s'", info.name);
| 48356 | return false; |  | 48308 | return false;
| 48357 | } |  | 48309 | }
| 48358 | }; |  | 48310 | };
| 48359 |  |  | 48311 |
| 48360 | //================================================================================ |  | 48312 | //================================================================================
| 48361 | // detail_PairwiseSeamFinder (Generic) |  | 48313 | // detail_PairwiseSeamFinder (Generic)
| 48362 | //================================================================================ |  | 48314 | //================================================================================
| 48363 |  |  | 48315 |
| 48364 | // GetSet (detail_PairwiseSeamFinder) |  | 48316 | // GetSet (detail_PairwiseSeamFinder)
| 48365 |  |  | 48317 |
| 48366 |  |  | 48318 |
| 48367 |  |  | 48319 |
| 48368 | // Methods (detail_PairwiseSeamFinder) |  | 48320 | // Methods (detail_PairwiseSeamFinder)
| 48369 |  |  | 48321 |
| 48370 | static PyObject* pyopencv_cv_detail_detail_PairwiseSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48322 | static PyObject* pyopencv_cv_detail_detail_PairwiseSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw)
| 48371 | { |  | 48323 | {
| 48372 | using namespace cv::detail; |  | 48324 | using namespace cv::detail;
| 48373 |  |  | 48325 |
| 48374 |  |  | 48326 |
| 48375 | Ptr<cv::detail::PairwiseSeamFinder> * self1 = 0; |  | 48327 | Ptr<cv::detail::PairwiseSeamFinder> * self1 = 0;
| 48376 | if (!pyopencv_detail_PairwiseSeamFinder_getp(self, self1)) |  | 48328 | if (!pyopencv_detail_PairwiseSeamFinder_getp(self, self1))
| 48377 | return failmsgp("Incorrect type of self (must be 'detail_PairwiseSeamFinder' or its derivative)"); |  | 48329 | return failmsgp("Incorrect type of self (must be 'detail_PairwiseSeamFinder' or its derivative)");
| 48378 | Ptr<cv::detail::PairwiseSeamFinder> _self_ = *(self1); |  | 48330 | Ptr<cv::detail::PairwiseSeamFinder> _self_ = *(self1);
| 48379 | PyObject* pyobj_src = NULL; |  | 48331 | PyObject* pyobj_src = NULL;
| 48380 | vector_UMat src; |  | 48332 | vector_UMat src;
| 48381 | PyObject* pyobj_corners = NULL; |  | 48333 | PyObject* pyobj_corners = NULL;
| 48382 | vector_Point corners; |  | 48334 | vector_Point corners;
| 48383 | PyObject* pyobj_masks = NULL; |  | 48335 | PyObject* pyobj_masks = NULL;
| 48384 | vector_UMat masks; |  | 48336 | vector_UMat masks;
| 48385 |  |  | 48337 |
| 48386 | const char* keywords[] = { "src", "corners", "masks", NULL }; |  | 48338 | const char* keywords[] = { "src", "corners", "masks", NULL };
| 48387 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_PairwiseSeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) && |  | 48339 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_PairwiseSeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) &&
| 48388 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 48340 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 48389 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 48341 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 48390 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) ) |  | 48342 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) )
| 48391 | { |  | 48343 | {
| 48392 | ERRWRAP2(_self_->find(src, corners, masks)); |  | 48344 | ERRWRAP2(_self_->find(src, corners, masks));
| 48393 | return pyopencv_from(masks); |  | 48345 | return pyopencv_from(masks);
| 48394 | } |  | 48346 | }
| 48395 |  |  | 48347 |
| 48396 | return NULL; |  | 48348 | return NULL;
| 48397 | } |  | 48349 | }
| 48398 |  |  | 48350 |
| 48399 |  |  | 48351 |
| 48400 |  |  | 48352 |
| 48401 | // Tables (detail_PairwiseSeamFinder) |  | 48353 | // Tables (detail_PairwiseSeamFinder)
| 48402 |  |  | 48354 |
| 48403 | static PyGetSetDef pyopencv_detail_PairwiseSeamFinder_getseters[] = |  | 48355 | static PyGetSetDef pyopencv_detail_PairwiseSeamFinder_getseters[] =
| 48404 | { |  | 48356 | {
| 48405 | {NULL} /* Sentinel */ |  | 48357 | {NULL} /* Sentinel */
| 48406 | }; |  | 48358 | };
| 48407 |  |  | 48359 |
| 48408 | static PyMethodDef pyopencv_detail_PairwiseSeamFinder_methods[] = |  | 48360 | static PyMethodDef pyopencv_detail_PairwiseSeamFinder_methods[] =
| 48409 | { |  | 48361 | {
| 48410 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_PairwiseSeamFinder_find, 0), "find(src, corners, masks) -> masks\n."}, |  | 48362 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_PairwiseSeamFinder_find, 0), "find(src, corners, masks) -> masks\n."},
| 48411 |  |  | 48363 |
| 48412 | {NULL, NULL} |  | 48364 | {NULL, NULL}
| 48413 | }; |  | 48365 | };
| 48414 |  |  | 48366 |
| 48415 | // Converter (detail_PairwiseSeamFinder) |  | 48367 | // Converter (detail_PairwiseSeamFinder)
| 48416 |  |  | 48368 |
| 48417 | template<> |  | 48369 | template<>
| 48418 | struct PyOpenCV_Converter< Ptr<cv::detail::PairwiseSeamFinder> > |  | 48370 | struct PyOpenCV_Converter< Ptr<cv::detail::PairwiseSeamFinder> >
| 48419 | { |  | 48371 | {
| 48420 | static PyObject* from(const Ptr<cv::detail::PairwiseSeamFinder>& r) |  | 48372 | static PyObject* from(const Ptr<cv::detail::PairwiseSeamFinder>& r)
| 48421 | { |  | 48373 | {
| 48422 | return pyopencv_detail_PairwiseSeamFinder_Instance(r); |  | 48374 | return pyopencv_detail_PairwiseSeamFinder_Instance(r);
| 48423 | } |  | 48375 | }
| 48424 | static bool to(PyObject* src, Ptr<cv::detail::PairwiseSeamFinder>& dst, const ArgInfo& info) |  | 48376 | static bool to(PyObject* src, Ptr<cv::detail::PairwiseSeamFinder>& dst, const ArgInfo& info)
| 48425 | { |  | 48377 | {
| 48426 | if(!src || src == Py_None) |  | 48378 | if(!src || src == Py_None)
| 48427 | return true; |  | 48379 | return true;
| 48428 | Ptr<cv::detail::PairwiseSeamFinder> * dst_; |  | 48380 | Ptr<cv::detail::PairwiseSeamFinder> * dst_;
| 48429 | if (pyopencv_detail_PairwiseSeamFinder_getp(src, dst_)) |  | 48381 | if (pyopencv_detail_PairwiseSeamFinder_getp(src, dst_))
| 48430 | { |  | 48382 | {
| 48431 | dst = *dst_; |  | 48383 | dst = *dst_;
| 48432 | return true; |  | 48384 | return true;
| 48433 | } |  | 48385 | }
| 48434 |  |  | 48386 |
| 48435 | failmsg("Expected Ptr<cv::detail::PairwiseSeamFinder> for argument '%s'", info.name); |  | 48387 | failmsg("Expected Ptr<cv::detail::PairwiseSeamFinder> for argument '%s'", info.name);
| 48436 | return false; |  | 48388 | return false;
| 48437 | } |  | 48389 | }
| 48438 | }; |  | 48390 | };
| 48439 |  |  | 48391 |
| 48440 | //================================================================================ |  | 48392 | //================================================================================
| 48441 | // detail_ProjectorBase (Generic) |  | 48393 | // detail_ProjectorBase (Generic)
| 48442 | //================================================================================ |  | 48394 | //================================================================================
| 48443 |  |  | 48395 |
| 48444 | // GetSet (detail_ProjectorBase) |  | 48396 | // GetSet (detail_ProjectorBase)
| 48445 |  |  | 48397 |
| 48446 |  |  | 48398 |
| 48447 |  |  | 48399 |
| 48448 | // Methods (detail_ProjectorBase) |  | 48400 | // Methods (detail_ProjectorBase)
| 48449 |  |  | 48401 |
| 48450 |  |  | 48402 |
| 48451 |  |  | 48403 |
| 48452 | // Tables (detail_ProjectorBase) |  | 48404 | // Tables (detail_ProjectorBase)
| 48453 |  |  | 48405 |
| 48454 | static PyGetSetDef pyopencv_detail_ProjectorBase_getseters[] = |  | 48406 | static PyGetSetDef pyopencv_detail_ProjectorBase_getseters[] =
| 48455 | { |  | 48407 | {
| 48456 | {NULL} /* Sentinel */ |  | 48408 | {NULL} /* Sentinel */
| 48457 | }; |  | 48409 | };
| 48458 |  |  | 48410 |
| 48459 | static PyMethodDef pyopencv_detail_ProjectorBase_methods[] = |  | 48411 | static PyMethodDef pyopencv_detail_ProjectorBase_methods[] =
| 48460 | { |  | 48412 | {
| 48461 |  |  | 48413 |
| 48462 | {NULL, NULL} |  | 48414 | {NULL, NULL}
| 48463 | }; |  | 48415 | };
| 48464 |  |  | 48416 |
| 48465 | // Converter (detail_ProjectorBase) |  | 48417 | // Converter (detail_ProjectorBase)
| 48466 |  |  | 48418 |
| 48467 | template<> |  | 48419 | template<>
| 48468 | struct PyOpenCV_Converter< cv::detail::ProjectorBase > |  | 48420 | struct PyOpenCV_Converter< cv::detail::ProjectorBase >
| 48469 | { |  | 48421 | {
| 48470 | static PyObject* from(const cv::detail::ProjectorBase& r) |  | 48422 | static PyObject* from(const cv::detail::ProjectorBase& r)
| 48471 | { |  | 48423 | {
| 48472 | return pyopencv_detail_ProjectorBase_Instance(r); |  | 48424 | return pyopencv_detail_ProjectorBase_Instance(r);
| 48473 | } |  | 48425 | }
| 48474 | static bool to(PyObject* src, cv::detail::ProjectorBase& dst, const ArgInfo& info) |  | 48426 | static bool to(PyObject* src, cv::detail::ProjectorBase& dst, const ArgInfo& info)
| 48475 | { |  | 48427 | {
| 48476 | if(!src || src == Py_None) |  | 48428 | if(!src || src == Py_None)
| 48477 | return true; |  | 48429 | return true;
| 48478 | cv::detail::ProjectorBase * dst_; |  | 48430 | cv::detail::ProjectorBase * dst_;
| 48479 | if (pyopencv_detail_ProjectorBase_getp(src, dst_)) |  | 48431 | if (pyopencv_detail_ProjectorBase_getp(src, dst_))
| 48480 | { |  | 48432 | {
| 48481 | dst = *dst_; |  | 48433 | dst = *dst_;
| 48482 | return true; |  | 48434 | return true;
| 48483 | } |  | 48435 | }
| 48484 |  |  | 48436 |
| 48485 | failmsg("Expected cv::detail::ProjectorBase for argument '%s'", info.name); |  | 48437 | failmsg("Expected cv::detail::ProjectorBase for argument '%s'", info.name);
| 48486 | return false; |  | 48438 | return false;
| 48487 | } |  | 48439 | }
| 48488 | }; |  | 48440 | };
| 48489 |  |  | 48441 |
| 48490 | //================================================================================ |  | 48442 | //================================================================================
| 48491 | // detail_SeamFinder (Generic) |  | 48443 | // detail_SeamFinder (Generic)
| 48492 | //================================================================================ |  | 48444 | //================================================================================
| 48493 |  |  | 48445 |
| 48494 | // GetSet (detail_SeamFinder) |  | 48446 | // GetSet (detail_SeamFinder)
| 48495 |  |  | 48447 |
| 48496 |  |  | 48448 |
| 48497 |  |  | 48449 |
| 48498 | // Methods (detail_SeamFinder) |  | 48450 | // Methods (detail_SeamFinder)
| 48499 |  |  | 48451 |
| 48500 | static PyObject* pyopencv_cv_detail_detail_SeamFinder_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48452 | static PyObject* pyopencv_cv_detail_detail_SeamFinder_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 48501 | { |  | 48453 | {
| 48502 | using namespace cv::detail; |  | 48454 | using namespace cv::detail;
| 48503 |  |  | 48455 |
| 48504 | PyObject* pyobj_type = NULL; |  | 48456 | PyObject* pyobj_type = NULL;
| 48505 | int type=0; |  | 48457 | int type=0;
| 48506 | Ptr<SeamFinder> retval; |  | 48458 | Ptr<SeamFinder> retval;
| 48507 |  |  | 48459 |
| 48508 | const char* keywords[] = { "type", NULL }; |  | 48460 | const char* keywords[] = { "type", NULL };
| 48509 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_SeamFinder.createDefault", (char**)keywords, &pyobj_type) && |  | 48461 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_SeamFinder.createDefault", (char**)keywords, &pyobj_type) &&
| 48510 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 48462 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 48511 | { |  | 48463 | {
| 48512 | ERRWRAP2(retval = cv::detail::SeamFinder::createDefault(type)); |  | 48464 | ERRWRAP2(retval = cv::detail::SeamFinder::createDefault(type));
| 48513 | return pyopencv_from(retval); |  | 48465 | return pyopencv_from(retval);
| 48514 | } |  | 48466 | }
| 48515 |  |  | 48467 |
| 48516 | return NULL; |  | 48468 | return NULL;
| 48517 | } |  | 48469 | }
| 48518 |  |  | 48470 |
| 48519 | static PyObject* pyopencv_cv_detail_detail_SeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48471 | static PyObject* pyopencv_cv_detail_detail_SeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw)
| 48520 | { |  | 48472 | {
| 48521 | using namespace cv::detail; |  | 48473 | using namespace cv::detail;
| 48522 |  |  | 48474 |
| 48523 |  |  | 48475 |
| 48524 | Ptr<cv::detail::SeamFinder> * self1 = 0; |  | 48476 | Ptr<cv::detail::SeamFinder> * self1 = 0;
| 48525 | if (!pyopencv_detail_SeamFinder_getp(self, self1)) |  | 48477 | if (!pyopencv_detail_SeamFinder_getp(self, self1))
| 48526 | return failmsgp("Incorrect type of self (must be 'detail_SeamFinder' or its derivative)"); |  | 48478 | return failmsgp("Incorrect type of self (must be 'detail_SeamFinder' or its derivative)");
| 48527 | Ptr<cv::detail::SeamFinder> _self_ = *(self1); |  | 48479 | Ptr<cv::detail::SeamFinder> _self_ = *(self1);
| 48528 | PyObject* pyobj_src = NULL; |  | 48480 | PyObject* pyobj_src = NULL;
| 48529 | vector_UMat src; |  | 48481 | vector_UMat src;
| 48530 | PyObject* pyobj_corners = NULL; |  | 48482 | PyObject* pyobj_corners = NULL;
| 48531 | vector_Point corners; |  | 48483 | vector_Point corners;
| 48532 | PyObject* pyobj_masks = NULL; |  | 48484 | PyObject* pyobj_masks = NULL;
| 48533 | vector_UMat masks; |  | 48485 | vector_UMat masks;
| 48534 |  |  | 48486 |
| 48535 | const char* keywords[] = { "src", "corners", "masks", NULL }; |  | 48487 | const char* keywords[] = { "src", "corners", "masks", NULL };
| 48536 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_SeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) && |  | 48488 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_SeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) &&
| 48537 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 48489 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 48538 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 48490 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 48539 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) ) |  | 48491 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) )
| 48540 | { |  | 48492 | {
| 48541 | ERRWRAP2(_self_->find(src, corners, masks)); |  | 48493 | ERRWRAP2(_self_->find(src, corners, masks));
| 48542 | return pyopencv_from(masks); |  | 48494 | return pyopencv_from(masks);
| 48543 | } |  | 48495 | }
| 48544 |  |  | 48496 |
| 48545 | return NULL; |  | 48497 | return NULL;
| 48546 | } |  | 48498 | }
| 48547 |  |  | 48499 |
| 48548 |  |  | 48500 |
| 48549 |  |  | 48501 |
| 48550 | // Tables (detail_SeamFinder) |  | 48502 | // Tables (detail_SeamFinder)
| 48551 |  |  | 48503 |
| 48552 | static PyGetSetDef pyopencv_detail_SeamFinder_getseters[] = |  | 48504 | static PyGetSetDef pyopencv_detail_SeamFinder_getseters[] =
| 48553 | { |  | 48505 | {
| 48554 | {NULL} /* Sentinel */ |  | 48506 | {NULL} /* Sentinel */
| 48555 | }; |  | 48507 | };
| 48556 |  |  | 48508 |
| 48557 | static PyMethodDef pyopencv_detail_SeamFinder_methods[] = |  | 48509 | static PyMethodDef pyopencv_detail_SeamFinder_methods[] =
| 48558 | { |  | 48510 | {
| 48559 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SeamFinder_createDefault_static, METH_STATIC), "createDefault(type) -> retval\n."}, |  | 48511 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SeamFinder_createDefault_static, METH_STATIC), "createDefault(type) -> retval\n."},
| 48560 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SeamFinder_find, 0), "find(src, corners, masks) -> masks\n. @brief Estimates seams.\n. \n. @param src Source images\n. @param corners Source image top-left corners\n. @param masks Source image masks to update"}, |  | 48512 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SeamFinder_find, 0), "find(src, corners, masks) -> masks\n. @brief Estimates seams.\n. \n. @param src Source images\n. @param corners Source image top-left corners\n. @param masks Source image masks to update"},
| 48561 |  |  | 48513 |
| 48562 | {NULL, NULL} |  | 48514 | {NULL, NULL}
| 48563 | }; |  | 48515 | };
| 48564 |  |  | 48516 |
| 48565 | // Converter (detail_SeamFinder) |  | 48517 | // Converter (detail_SeamFinder)
| 48566 |  |  | 48518 |
| 48567 | template<> |  | 48519 | template<>
| 48568 | struct PyOpenCV_Converter< Ptr<cv::detail::SeamFinder> > |  | 48520 | struct PyOpenCV_Converter< Ptr<cv::detail::SeamFinder> >
| 48569 | { |  | 48521 | {
| 48570 | static PyObject* from(const Ptr<cv::detail::SeamFinder>& r) |  | 48522 | static PyObject* from(const Ptr<cv::detail::SeamFinder>& r)
| 48571 | { |  | 48523 | {
| 48572 | return pyopencv_detail_SeamFinder_Instance(r); |  | 48524 | return pyopencv_detail_SeamFinder_Instance(r);
| 48573 | } |  | 48525 | }
| 48574 | static bool to(PyObject* src, Ptr<cv::detail::SeamFinder>& dst, const ArgInfo& info) |  | 48526 | static bool to(PyObject* src, Ptr<cv::detail::SeamFinder>& dst, const ArgInfo& info)
| 48575 | { |  | 48527 | {
| 48576 | if(!src || src == Py_None) |  | 48528 | if(!src || src == Py_None)
| 48577 | return true; |  | 48529 | return true;
| 48578 | Ptr<cv::detail::SeamFinder> * dst_; |  | 48530 | Ptr<cv::detail::SeamFinder> * dst_;
| 48579 | if (pyopencv_detail_SeamFinder_getp(src, dst_)) |  | 48531 | if (pyopencv_detail_SeamFinder_getp(src, dst_))
| 48580 | { |  | 48532 | {
| 48581 | dst = *dst_; |  | 48533 | dst = *dst_;
| 48582 | return true; |  | 48534 | return true;
| 48583 | } |  | 48535 | }
| 48584 |  |  | 48536 |
| 48585 | failmsg("Expected Ptr<cv::detail::SeamFinder> for argument '%s'", info.name); |  | 48537 | failmsg("Expected Ptr<cv::detail::SeamFinder> for argument '%s'", info.name);
| 48586 | return false; |  | 48538 | return false;
| 48587 | } |  | 48539 | }
| 48588 | }; |  | 48540 | };
| 48589 |  |  | 48541 |
| 48590 | //================================================================================ |  | 48542 | //================================================================================
| 48591 | // detail_SphericalProjector (Generic) |  | 48543 | // detail_SphericalProjector (Generic)
| 48592 | //================================================================================ |  | 48544 | //================================================================================
| 48593 |  |  | 48545 |
| 48594 | // GetSet (detail_SphericalProjector) |  | 48546 | // GetSet (detail_SphericalProjector)
| 48595 |  |  | 48547 |
| 48596 |  |  | 48548 |
| 48597 |  |  | 48549 |
| 48598 | // Methods (detail_SphericalProjector) |  | 48550 | // Methods (detail_SphericalProjector)
| 48599 |  |  | 48551 |
| 48600 | static PyObject* pyopencv_cv_detail_detail_SphericalProjector_mapBackward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48552 | static PyObject* pyopencv_cv_detail_detail_SphericalProjector_mapBackward(PyObject* self, PyObject* py_args, PyObject* kw)
| 48601 | { |  | 48553 | {
| 48602 | using namespace cv::detail; |  | 48554 | using namespace cv::detail;
| 48603 |  |  | 48555 |
| 48604 |  |  | 48556 |
| 48605 | cv::detail::SphericalProjector * self1 = 0; |  | 48557 | cv::detail::SphericalProjector * self1 = 0;
| 48606 | if (!pyopencv_detail_SphericalProjector_getp(self, self1)) |  | 48558 | if (!pyopencv_detail_SphericalProjector_getp(self, self1))
| 48607 | return failmsgp("Incorrect type of self (must be 'detail_SphericalProjector' or its derivative)"); |  | 48559 | return failmsgp("Incorrect type of self (must be 'detail_SphericalProjector' or its derivative)");
| 48608 | cv::detail::SphericalProjector* _self_ = (self1); |  | 48560 | cv::detail::SphericalProjector* _self_ = (self1);
| 48609 | PyObject* pyobj_u = NULL; |  | 48561 | PyObject* pyobj_u = NULL;
| 48610 | float u=0.f; |  | 48562 | float u=0.f;
| 48611 | PyObject* pyobj_v = NULL; |  | 48563 | PyObject* pyobj_v = NULL;
| 48612 | float v=0.f; |  | 48564 | float v=0.f;
| 48613 | PyObject* pyobj_x = NULL; |  | 48565 | PyObject* pyobj_x = NULL;
| 48614 | float x=0.f; |  | 48566 | float x=0.f;
| 48615 | PyObject* pyobj_y = NULL; |  | 48567 | PyObject* pyobj_y = NULL;
| 48616 | float y=0.f; |  | 48568 | float y=0.f;
| 48617 |  |  | 48569 |
| 48618 | const char* keywords[] = { "u", "v", "x", "y", NULL }; |  | 48570 | const char* keywords[] = { "u", "v", "x", "y", NULL };
| 48619 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_SphericalProjector.mapBackward", (char**)keywords, &pyobj_u, &pyobj_v, &pyobj_x, &pyobj_y) && |  | 48571 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_SphericalProjector.mapBackward", (char**)keywords, &pyobj_u, &pyobj_v, &pyobj_x, &pyobj_y) &&
| 48620 | pyopencv_to_safe(pyobj_u, u, ArgInfo("u", 0)) && |  | 48572 | pyopencv_to_safe(pyobj_u, u, ArgInfo("u", 0)) &&
| 48621 | pyopencv_to_safe(pyobj_v, v, ArgInfo("v", 0)) && |  | 48573 | pyopencv_to_safe(pyobj_v, v, ArgInfo("v", 0)) &&
| 48622 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) && |  | 48574 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) &&
| 48623 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) ) |  | 48575 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) )
| 48624 | { |  | 48576 | {
| 48625 | ERRWRAP2(_self_->mapBackward(u, v, x, y)); |  | 48577 | ERRWRAP2(_self_->mapBackward(u, v, x, y));
| 48626 | Py_RETURN_NONE; |  | 48578 | Py_RETURN_NONE;
| 48627 | } |  | 48579 | }
| 48628 |  |  | 48580 |
| 48629 | return NULL; |  | 48581 | return NULL;
| 48630 | } |  | 48582 | }
| 48631 |  |  | 48583 |
| 48632 | static PyObject* pyopencv_cv_detail_detail_SphericalProjector_mapForward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48584 | static PyObject* pyopencv_cv_detail_detail_SphericalProjector_mapForward(PyObject* self, PyObject* py_args, PyObject* kw)
| 48633 | { |  | 48585 | {
| 48634 | using namespace cv::detail; |  | 48586 | using namespace cv::detail;
| 48635 |  |  | 48587 |
| 48636 |  |  | 48588 |
| 48637 | cv::detail::SphericalProjector * self1 = 0; |  | 48589 | cv::detail::SphericalProjector * self1 = 0;
| 48638 | if (!pyopencv_detail_SphericalProjector_getp(self, self1)) |  | 48590 | if (!pyopencv_detail_SphericalProjector_getp(self, self1))
| 48639 | return failmsgp("Incorrect type of self (must be 'detail_SphericalProjector' or its derivative)"); |  | 48591 | return failmsgp("Incorrect type of self (must be 'detail_SphericalProjector' or its derivative)");
| 48640 | cv::detail::SphericalProjector* _self_ = (self1); |  | 48592 | cv::detail::SphericalProjector* _self_ = (self1);
| 48641 | PyObject* pyobj_x = NULL; |  | 48593 | PyObject* pyobj_x = NULL;
| 48642 | float x=0.f; |  | 48594 | float x=0.f;
| 48643 | PyObject* pyobj_y = NULL; |  | 48595 | PyObject* pyobj_y = NULL;
| 48644 | float y=0.f; |  | 48596 | float y=0.f;
| 48645 | PyObject* pyobj_u = NULL; |  | 48597 | PyObject* pyobj_u = NULL;
| 48646 | float u=0.f; |  | 48598 | float u=0.f;
| 48647 | PyObject* pyobj_v = NULL; |  | 48599 | PyObject* pyobj_v = NULL;
| 48648 | float v=0.f; |  | 48600 | float v=0.f;
| 48649 |  |  | 48601 |
| 48650 | const char* keywords[] = { "x", "y", "u", "v", NULL }; |  | 48602 | const char* keywords[] = { "x", "y", "u", "v", NULL };
| 48651 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_SphericalProjector.mapForward", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_u, &pyobj_v) && |  | 48603 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:detail_SphericalProjector.mapForward", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_u, &pyobj_v) &&
| 48652 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) && |  | 48604 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) &&
| 48653 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) && |  | 48605 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) &&
| 48654 | pyopencv_to_safe(pyobj_u, u, ArgInfo("u", 0)) && |  | 48606 | pyopencv_to_safe(pyobj_u, u, ArgInfo("u", 0)) &&
| 48655 | pyopencv_to_safe(pyobj_v, v, ArgInfo("v", 0)) ) |  | 48607 | pyopencv_to_safe(pyobj_v, v, ArgInfo("v", 0)) )
| 48656 | { |  | 48608 | {
| 48657 | ERRWRAP2(_self_->mapForward(x, y, u, v)); |  | 48609 | ERRWRAP2(_self_->mapForward(x, y, u, v));
| 48658 | Py_RETURN_NONE; |  | 48610 | Py_RETURN_NONE;
| 48659 | } |  | 48611 | }
| 48660 |  |  | 48612 |
| 48661 | return NULL; |  | 48613 | return NULL;
| 48662 | } |  | 48614 | }
| 48663 |  |  | 48615 |
| 48664 |  |  | 48616 |
| 48665 |  |  | 48617 |
| 48666 | // Tables (detail_SphericalProjector) |  | 48618 | // Tables (detail_SphericalProjector)
| 48667 |  |  | 48619 |
| 48668 | static PyGetSetDef pyopencv_detail_SphericalProjector_getseters[] = |  | 48620 | static PyGetSetDef pyopencv_detail_SphericalProjector_getseters[] =
| 48669 | { |  | 48621 | {
| 48670 | {NULL} /* Sentinel */ |  | 48622 | {NULL} /* Sentinel */
| 48671 | }; |  | 48623 | };
| 48672 |  |  | 48624 |
| 48673 | static PyMethodDef pyopencv_detail_SphericalProjector_methods[] = |  | 48625 | static PyMethodDef pyopencv_detail_SphericalProjector_methods[] =
| 48674 | { |  | 48626 | {
| 48675 | {"mapBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SphericalProjector_mapBackward, 0), "mapBackward(u, v, x, y) -> None\n."}, |  | 48627 | {"mapBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SphericalProjector_mapBackward, 0), "mapBackward(u, v, x, y) -> None\n."},
| 48676 | {"mapForward", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SphericalProjector_mapForward, 0), "mapForward(x, y, u, v) -> None\n."}, |  | 48628 | {"mapForward", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_SphericalProjector_mapForward, 0), "mapForward(x, y, u, v) -> None\n."},
| 48677 |  |  | 48629 |
| 48678 | {NULL, NULL} |  | 48630 | {NULL, NULL}
| 48679 | }; |  | 48631 | };
| 48680 |  |  | 48632 |
| 48681 | // Converter (detail_SphericalProjector) |  | 48633 | // Converter (detail_SphericalProjector)
| 48682 |  |  | 48634 |
| 48683 | template<> |  | 48635 | template<>
| 48684 | struct PyOpenCV_Converter< cv::detail::SphericalProjector > |  | 48636 | struct PyOpenCV_Converter< cv::detail::SphericalProjector >
| 48685 | { |  | 48637 | {
| 48686 | static PyObject* from(const cv::detail::SphericalProjector& r) |  | 48638 | static PyObject* from(const cv::detail::SphericalProjector& r)
| 48687 | { |  | 48639 | {
| 48688 | return pyopencv_detail_SphericalProjector_Instance(r); |  | 48640 | return pyopencv_detail_SphericalProjector_Instance(r);
| 48689 | } |  | 48641 | }
| 48690 | static bool to(PyObject* src, cv::detail::SphericalProjector& dst, const ArgInfo& info) |  | 48642 | static bool to(PyObject* src, cv::detail::SphericalProjector& dst, const ArgInfo& info)
| 48691 | { |  | 48643 | {
| 48692 | if(!src || src == Py_None) |  | 48644 | if(!src || src == Py_None)
| 48693 | return true; |  | 48645 | return true;
| 48694 | cv::detail::SphericalProjector * dst_; |  | 48646 | cv::detail::SphericalProjector * dst_;
| 48695 | if (pyopencv_detail_SphericalProjector_getp(src, dst_)) |  | 48647 | if (pyopencv_detail_SphericalProjector_getp(src, dst_))
| 48696 | { |  | 48648 | {
| 48697 | dst = *dst_; |  | 48649 | dst = *dst_;
| 48698 | return true; |  | 48650 | return true;
| 48699 | } |  | 48651 | }
| 48700 |  |  | 48652 |
| 48701 | failmsg("Expected cv::detail::SphericalProjector for argument '%s'", info.name); |  | 48653 | failmsg("Expected cv::detail::SphericalProjector for argument '%s'", info.name);
| 48702 | return false; |  | 48654 | return false;
| 48703 | } |  | 48655 | }
| 48704 | }; |  | 48656 | };
| 48705 |  |  | 48657 |
| 48706 | //================================================================================ |  | 48658 | //================================================================================
| 48707 | // detail_Timelapser (Generic) |  | 48659 | // detail_Timelapser (Generic)
| 48708 | //================================================================================ |  | 48660 | //================================================================================
| 48709 |  |  | 48661 |
| 48710 | // GetSet (detail_Timelapser) |  | 48662 | // GetSet (detail_Timelapser)
| 48711 |  |  | 48663 |
| 48712 |  |  | 48664 |
| 48713 |  |  | 48665 |
| 48714 | // Methods (detail_Timelapser) |  | 48666 | // Methods (detail_Timelapser)
| 48715 |  |  | 48667 |
| 48716 | static PyObject* pyopencv_cv_detail_detail_Timelapser_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48668 | static PyObject* pyopencv_cv_detail_detail_Timelapser_createDefault_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 48717 | { |  | 48669 | {
| 48718 | using namespace cv::detail; |  | 48670 | using namespace cv::detail;
| 48719 |  |  | 48671 |
| 48720 | PyObject* pyobj_type = NULL; |  | 48672 | PyObject* pyobj_type = NULL;
| 48721 | int type=0; |  | 48673 | int type=0;
| 48722 | Ptr<Timelapser> retval; |  | 48674 | Ptr<Timelapser> retval;
| 48723 |  |  | 48675 |
| 48724 | const char* keywords[] = { "type", NULL }; |  | 48676 | const char* keywords[] = { "type", NULL };
| 48725 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_Timelapser.createDefault", (char**)keywords, &pyobj_type) && |  | 48677 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:detail_Timelapser.createDefault", (char**)keywords, &pyobj_type) &&
| 48726 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 48678 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 48727 | { |  | 48679 | {
| 48728 | ERRWRAP2(retval = cv::detail::Timelapser::createDefault(type)); |  | 48680 | ERRWRAP2(retval = cv::detail::Timelapser::createDefault(type));
| 48729 | return pyopencv_from(retval); |  | 48681 | return pyopencv_from(retval);
| 48730 | } |  | 48682 | }
| 48731 |  |  | 48683 |
| 48732 | return NULL; |  | 48684 | return NULL;
| 48733 | } |  | 48685 | }
| 48734 |  |  | 48686 |
| 48735 | static PyObject* pyopencv_cv_detail_detail_Timelapser_getDst(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48687 | static PyObject* pyopencv_cv_detail_detail_Timelapser_getDst(PyObject* self, PyObject* py_args, PyObject* kw)
| 48736 | { |  | 48688 | {
| 48737 | using namespace cv::detail; |  | 48689 | using namespace cv::detail;
| 48738 |  |  | 48690 |
| 48739 |  |  | 48691 |
| 48740 | Ptr<cv::detail::Timelapser> * self1 = 0; |  | 48692 | Ptr<cv::detail::Timelapser> * self1 = 0;
| 48741 | if (!pyopencv_detail_Timelapser_getp(self, self1)) |  | 48693 | if (!pyopencv_detail_Timelapser_getp(self, self1))
| 48742 | return failmsgp("Incorrect type of self (must be 'detail_Timelapser' or its derivative)"); |  | 48694 | return failmsgp("Incorrect type of self (must be 'detail_Timelapser' or its derivative)");
| 48743 | Ptr<cv::detail::Timelapser> _self_ = *(self1); |  | 48695 | Ptr<cv::detail::Timelapser> _self_ = *(self1);
| 48744 | UMat retval; |  | 48696 | UMat retval;
| 48745 |  |  | 48697 |
| 48746 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 48698 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 48747 | { |  | 48699 | {
| 48748 | ERRWRAP2(retval = _self_->getDst()); |  | 48700 | ERRWRAP2(retval = _self_->getDst());
| 48749 | return pyopencv_from(retval); |  | 48701 | return pyopencv_from(retval);
| 48750 | } |  | 48702 | }
| 48751 |  |  | 48703 |
| 48752 | return NULL; |  | 48704 | return NULL;
| 48753 | } |  | 48705 | }
| 48754 |  |  | 48706 |
| 48755 | static PyObject* pyopencv_cv_detail_detail_Timelapser_initialize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48707 | static PyObject* pyopencv_cv_detail_detail_Timelapser_initialize(PyObject* self, PyObject* py_args, PyObject* kw)
| 48756 | { |  | 48708 | {
| 48757 | using namespace cv::detail; |  | 48709 | using namespace cv::detail;
| 48758 |  |  | 48710 |
| 48759 |  |  | 48711 |
| 48760 | Ptr<cv::detail::Timelapser> * self1 = 0; |  | 48712 | Ptr<cv::detail::Timelapser> * self1 = 0;
| 48761 | if (!pyopencv_detail_Timelapser_getp(self, self1)) |  | 48713 | if (!pyopencv_detail_Timelapser_getp(self, self1))
| 48762 | return failmsgp("Incorrect type of self (must be 'detail_Timelapser' or its derivative)"); |  | 48714 | return failmsgp("Incorrect type of self (must be 'detail_Timelapser' or its derivative)");
| 48763 | Ptr<cv::detail::Timelapser> _self_ = *(self1); |  | 48715 | Ptr<cv::detail::Timelapser> _self_ = *(self1);
| 48764 | PyObject* pyobj_corners = NULL; |  | 48716 | PyObject* pyobj_corners = NULL;
| 48765 | vector_Point corners; |  | 48717 | vector_Point corners;
| 48766 | PyObject* pyobj_sizes = NULL; |  | 48718 | PyObject* pyobj_sizes = NULL;
| 48767 | vector_Size sizes; |  | 48719 | vector_Size sizes;
| 48768 |  |  | 48720 |
| 48769 | const char* keywords[] = { "corners", "sizes", NULL }; |  | 48721 | const char* keywords[] = { "corners", "sizes", NULL };
| 48770 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Timelapser.initialize", (char**)keywords, &pyobj_corners, &pyobj_sizes) && |  | 48722 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:detail_Timelapser.initialize", (char**)keywords, &pyobj_corners, &pyobj_sizes) &&
| 48771 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 48723 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 48772 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) ) |  | 48724 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) )
| 48773 | { |  | 48725 | {
| 48774 | ERRWRAP2(_self_->initialize(corners, sizes)); |  | 48726 | ERRWRAP2(_self_->initialize(corners, sizes));
| 48775 | Py_RETURN_NONE; |  | 48727 | Py_RETURN_NONE;
| 48776 | } |  | 48728 | }
| 48777 |  |  | 48729 |
| 48778 | return NULL; |  | 48730 | return NULL;
| 48779 | } |  | 48731 | }
| 48780 |  |  | 48732 |
| 48781 | static PyObject* pyopencv_cv_detail_detail_Timelapser_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48733 | static PyObject* pyopencv_cv_detail_detail_Timelapser_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 48782 | { |  | 48734 | {
| 48783 | using namespace cv::detail; |  | 48735 | using namespace cv::detail;
| 48784 |  |  | 48736 |
| 48785 |  |  | 48737 |
| 48786 | Ptr<cv::detail::Timelapser> * self1 = 0; |  | 48738 | Ptr<cv::detail::Timelapser> * self1 = 0;
| 48787 | if (!pyopencv_detail_Timelapser_getp(self, self1)) |  | 48739 | if (!pyopencv_detail_Timelapser_getp(self, self1))
| 48788 | return failmsgp("Incorrect type of self (must be 'detail_Timelapser' or its derivative)"); |  | 48740 | return failmsgp("Incorrect type of self (must be 'detail_Timelapser' or its derivative)");
| 48789 | Ptr<cv::detail::Timelapser> _self_ = *(self1); |  | 48741 | Ptr<cv::detail::Timelapser> _self_ = *(self1);
| 48790 | pyPrepareArgumentConversionErrorsStorage(2); |  | 48742 | pyPrepareArgumentConversionErrorsStorage(2);
| 48791 |  |  | 48743 |
| 48792 | { |  | 48744 | {
| 48793 | PyObject* pyobj_img = NULL; |  | 48745 | PyObject* pyobj_img = NULL;
| 48794 | Mat img; |  | 48746 | Mat img;
| 48795 | PyObject* pyobj_mask = NULL; |  | 48747 | PyObject* pyobj_mask = NULL;
| 48796 | Mat mask; |  | 48748 | Mat mask;
| 48797 | PyObject* pyobj_tl = NULL; |  | 48749 | PyObject* pyobj_tl = NULL;
| 48798 | Point tl; |  | 48750 | Point tl;
| 48799 |  |  | 48751 |
| 48800 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 48752 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 48801 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Timelapser.process", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 48753 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Timelapser.process", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 48802 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 48754 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 48803 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 48755 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 48804 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 48756 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 48805 | { |  | 48757 | {
| 48806 | ERRWRAP2(_self_->process(img, mask, tl)); |  | 48758 | ERRWRAP2(_self_->process(img, mask, tl));
| 48807 | Py_RETURN_NONE; |  | 48759 | Py_RETURN_NONE;
| 48808 | } |  | 48760 | }
| 48809 |  |  | 48761 |
| 48810 |  |  | 48762 |
| 48811 | pyPopulateArgumentConversionErrors(); |  | 48763 | pyPopulateArgumentConversionErrors();
| 48812 | } |  | 48764 | }
| 48813 |  |  | 48765 |
| 48814 |  |  | 48766 |
| 48815 | { |  | 48767 | {
| 48816 | PyObject* pyobj_img = NULL; |  | 48768 | PyObject* pyobj_img = NULL;
| 48817 | UMat img; |  | 48769 | UMat img;
| 48818 | PyObject* pyobj_mask = NULL; |  | 48770 | PyObject* pyobj_mask = NULL;
| 48819 | UMat mask; |  | 48771 | UMat mask;
| 48820 | PyObject* pyobj_tl = NULL; |  | 48772 | PyObject* pyobj_tl = NULL;
| 48821 | Point tl; |  | 48773 | Point tl;
| 48822 |  |  | 48774 |
| 48823 | const char* keywords[] = { "img", "mask", "tl", NULL }; |  | 48775 | const char* keywords[] = { "img", "mask", "tl", NULL };
| 48824 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Timelapser.process", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) && |  | 48776 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_Timelapser.process", (char**)keywords, &pyobj_img, &pyobj_mask, &pyobj_tl) &&
| 48825 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 48777 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 48826 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 48778 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 48827 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) ) |  | 48779 | pyopencv_to_safe(pyobj_tl, tl, ArgInfo("tl", 0)) )
| 48828 | { |  | 48780 | {
| 48829 | ERRWRAP2(_self_->process(img, mask, tl)); |  | 48781 | ERRWRAP2(_self_->process(img, mask, tl));
| 48830 | Py_RETURN_NONE; |  | 48782 | Py_RETURN_NONE;
| 48831 | } |  | 48783 | }
| 48832 |  |  | 48784 |
| 48833 |  |  | 48785 |
| 48834 | pyPopulateArgumentConversionErrors(); |  | 48786 | pyPopulateArgumentConversionErrors();
| 48835 | } |  | 48787 | }
| 48836 | pyRaiseCVOverloadException("process"); |  | 48788 | pyRaiseCVOverloadException("process");
| 48837 |  |  | 48789 |
| 48838 | return NULL; |  | 48790 | return NULL;
| 48839 | } |  | 48791 | }
| 48840 |  |  | 48792 |
| 48841 |  |  | 48793 |
| 48842 |  |  | 48794 |
| 48843 | // Tables (detail_Timelapser) |  | 48795 | // Tables (detail_Timelapser)
| 48844 |  |  | 48796 |
| 48845 | static PyGetSetDef pyopencv_detail_Timelapser_getseters[] = |  | 48797 | static PyGetSetDef pyopencv_detail_Timelapser_getseters[] =
| 48846 | { |  | 48798 | {
| 48847 | {NULL} /* Sentinel */ |  | 48799 | {NULL} /* Sentinel */
| 48848 | }; |  | 48800 | };
| 48849 |  |  | 48801 |
| 48850 | static PyMethodDef pyopencv_detail_Timelapser_methods[] = |  | 48802 | static PyMethodDef pyopencv_detail_Timelapser_methods[] =
| 48851 | { |  | 48803 | {
| 48852 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_createDefault_static, METH_STATIC), "createDefault(type) -> retval\n."}, |  | 48804 | {"createDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_createDefault_static, METH_STATIC), "createDefault(type) -> retval\n."},
| 48853 | {"getDst", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_getDst, 0), "getDst() -> retval\n."}, |  | 48805 | {"getDst", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_getDst, 0), "getDst() -> retval\n."},
| 48854 | {"initialize", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_initialize, 0), "initialize(corners, sizes) -> None\n."}, |  | 48806 | {"initialize", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_initialize, 0), "initialize(corners, sizes) -> None\n."},
| 48855 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_process, 0), "process(img, mask, tl) -> None\n."}, |  | 48807 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_Timelapser_process, 0), "process(img, mask, tl) -> None\n."},
| 48856 |  |  | 48808 |
| 48857 | {NULL, NULL} |  | 48809 | {NULL, NULL}
| 48858 | }; |  | 48810 | };
| 48859 |  |  | 48811 |
| 48860 | // Converter (detail_Timelapser) |  | 48812 | // Converter (detail_Timelapser)
| 48861 |  |  | 48813 |
| 48862 | template<> |  | 48814 | template<>
| 48863 | struct PyOpenCV_Converter< Ptr<cv::detail::Timelapser> > |  | 48815 | struct PyOpenCV_Converter< Ptr<cv::detail::Timelapser> >
| 48864 | { |  | 48816 | {
| 48865 | static PyObject* from(const Ptr<cv::detail::Timelapser>& r) |  | 48817 | static PyObject* from(const Ptr<cv::detail::Timelapser>& r)
| 48866 | { |  | 48818 | {
| 48867 | return pyopencv_detail_Timelapser_Instance(r); |  | 48819 | return pyopencv_detail_Timelapser_Instance(r);
| 48868 | } |  | 48820 | }
| 48869 | static bool to(PyObject* src, Ptr<cv::detail::Timelapser>& dst, const ArgInfo& info) |  | 48821 | static bool to(PyObject* src, Ptr<cv::detail::Timelapser>& dst, const ArgInfo& info)
| 48870 | { |  | 48822 | {
| 48871 | if(!src || src == Py_None) |  | 48823 | if(!src || src == Py_None)
| 48872 | return true; |  | 48824 | return true;
| 48873 | Ptr<cv::detail::Timelapser> * dst_; |  | 48825 | Ptr<cv::detail::Timelapser> * dst_;
| 48874 | if (pyopencv_detail_Timelapser_getp(src, dst_)) |  | 48826 | if (pyopencv_detail_Timelapser_getp(src, dst_))
| 48875 | { |  | 48827 | {
| 48876 | dst = *dst_; |  | 48828 | dst = *dst_;
| 48877 | return true; |  | 48829 | return true;
| 48878 | } |  | 48830 | }
| 48879 |  |  | 48831 |
| 48880 | failmsg("Expected Ptr<cv::detail::Timelapser> for argument '%s'", info.name); |  | 48832 | failmsg("Expected Ptr<cv::detail::Timelapser> for argument '%s'", info.name);
| 48881 | return false; |  | 48833 | return false;
| 48882 | } |  | 48834 | }
| 48883 | }; |  | 48835 | };
| 48884 |  |  | 48836 |
| 48885 | //================================================================================ |  | 48837 | //================================================================================
| 48886 | // detail_TimelapserCrop (Generic) |  | 48838 | // detail_TimelapserCrop (Generic)
| 48887 | //================================================================================ |  | 48839 | //================================================================================
| 48888 |  |  | 48840 |
| 48889 | // GetSet (detail_TimelapserCrop) |  | 48841 | // GetSet (detail_TimelapserCrop)
| 48890 |  |  | 48842 |
| 48891 |  |  | 48843 |
| 48892 |  |  | 48844 |
| 48893 | // Methods (detail_TimelapserCrop) |  | 48845 | // Methods (detail_TimelapserCrop)
| 48894 |  |  | 48846 |
| 48895 |  |  | 48847 |
| 48896 |  |  | 48848 |
| 48897 | // Tables (detail_TimelapserCrop) |  | 48849 | // Tables (detail_TimelapserCrop)
| 48898 |  |  | 48850 |
| 48899 | static PyGetSetDef pyopencv_detail_TimelapserCrop_getseters[] = |  | 48851 | static PyGetSetDef pyopencv_detail_TimelapserCrop_getseters[] =
| 48900 | { |  | 48852 | {
| 48901 | {NULL} /* Sentinel */ |  | 48853 | {NULL} /* Sentinel */
| 48902 | }; |  | 48854 | };
| 48903 |  |  | 48855 |
| 48904 | static PyMethodDef pyopencv_detail_TimelapserCrop_methods[] = |  | 48856 | static PyMethodDef pyopencv_detail_TimelapserCrop_methods[] =
| 48905 | { |  | 48857 | {
| 48906 |  |  | 48858 |
| 48907 | {NULL, NULL} |  | 48859 | {NULL, NULL}
| 48908 | }; |  | 48860 | };
| 48909 |  |  | 48861 |
| 48910 | // Converter (detail_TimelapserCrop) |  | 48862 | // Converter (detail_TimelapserCrop)
| 48911 |  |  | 48863 |
| 48912 | template<> |  | 48864 | template<>
| 48913 | struct PyOpenCV_Converter< Ptr<cv::detail::TimelapserCrop> > |  | 48865 | struct PyOpenCV_Converter< Ptr<cv::detail::TimelapserCrop> >
| 48914 | { |  | 48866 | {
| 48915 | static PyObject* from(const Ptr<cv::detail::TimelapserCrop>& r) |  | 48867 | static PyObject* from(const Ptr<cv::detail::TimelapserCrop>& r)
| 48916 | { |  | 48868 | {
| 48917 | return pyopencv_detail_TimelapserCrop_Instance(r); |  | 48869 | return pyopencv_detail_TimelapserCrop_Instance(r);
| 48918 | } |  | 48870 | }
| 48919 | static bool to(PyObject* src, Ptr<cv::detail::TimelapserCrop>& dst, const ArgInfo& info) |  | 48871 | static bool to(PyObject* src, Ptr<cv::detail::TimelapserCrop>& dst, const ArgInfo& info)
| 48920 | { |  | 48872 | {
| 48921 | if(!src || src == Py_None) |  | 48873 | if(!src || src == Py_None)
| 48922 | return true; |  | 48874 | return true;
| 48923 | Ptr<cv::detail::TimelapserCrop> * dst_; |  | 48875 | Ptr<cv::detail::TimelapserCrop> * dst_;
| 48924 | if (pyopencv_detail_TimelapserCrop_getp(src, dst_)) |  | 48876 | if (pyopencv_detail_TimelapserCrop_getp(src, dst_))
| 48925 | { |  | 48877 | {
| 48926 | dst = *dst_; |  | 48878 | dst = *dst_;
| 48927 | return true; |  | 48879 | return true;
| 48928 | } |  | 48880 | }
| 48929 |  |  | 48881 |
| 48930 | failmsg("Expected Ptr<cv::detail::TimelapserCrop> for argument '%s'", info.name); |  | 48882 | failmsg("Expected Ptr<cv::detail::TimelapserCrop> for argument '%s'", info.name);
| 48931 | return false; |  | 48883 | return false;
| 48932 | } |  | 48884 | }
| 48933 | }; |  | 48885 | };
| 48934 |  |  | 48886 |
| 48935 | //================================================================================ |  | 48887 | //================================================================================
| 48936 | // detail_VoronoiSeamFinder (Generic) |  | 48888 | // detail_VoronoiSeamFinder (Generic)
| 48937 | //================================================================================ |  | 48889 | //================================================================================
| 48938 |  |  | 48890 |
| 48939 | // GetSet (detail_VoronoiSeamFinder) |  | 48891 | // GetSet (detail_VoronoiSeamFinder)
| 48940 |  |  | 48892 |
| 48941 |  |  | 48893 |
| 48942 |  |  | 48894 |
| 48943 | // Methods (detail_VoronoiSeamFinder) |  | 48895 | // Methods (detail_VoronoiSeamFinder)
| 48944 |  |  | 48896 |
| 48945 | static PyObject* pyopencv_cv_detail_detail_VoronoiSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw) |  | 48897 | static PyObject* pyopencv_cv_detail_detail_VoronoiSeamFinder_find(PyObject* self, PyObject* py_args, PyObject* kw)
| 48946 | { |  | 48898 | {
| 48947 | using namespace cv::detail; |  | 48899 | using namespace cv::detail;
| 48948 |  |  | 48900 |
| 48949 |  |  | 48901 |
| 48950 | Ptr<cv::detail::VoronoiSeamFinder> * self1 = 0; |  | 48902 | Ptr<cv::detail::VoronoiSeamFinder> * self1 = 0;
| 48951 | if (!pyopencv_detail_VoronoiSeamFinder_getp(self, self1)) |  | 48903 | if (!pyopencv_detail_VoronoiSeamFinder_getp(self, self1))
| 48952 | return failmsgp("Incorrect type of self (must be 'detail_VoronoiSeamFinder' or its derivative)"); |  | 48904 | return failmsgp("Incorrect type of self (must be 'detail_VoronoiSeamFinder' or its derivative)");
| 48953 | Ptr<cv::detail::VoronoiSeamFinder> _self_ = *(self1); |  | 48905 | Ptr<cv::detail::VoronoiSeamFinder> _self_ = *(self1);
| 48954 | PyObject* pyobj_src = NULL; |  | 48906 | PyObject* pyobj_src = NULL;
| 48955 | vector_UMat src; |  | 48907 | vector_UMat src;
| 48956 | PyObject* pyobj_corners = NULL; |  | 48908 | PyObject* pyobj_corners = NULL;
| 48957 | vector_Point corners; |  | 48909 | vector_Point corners;
| 48958 | PyObject* pyobj_masks = NULL; |  | 48910 | PyObject* pyobj_masks = NULL;
| 48959 | vector_UMat masks; |  | 48911 | vector_UMat masks;
| 48960 |  |  | 48912 |
| 48961 | const char* keywords[] = { "src", "corners", "masks", NULL }; |  | 48913 | const char* keywords[] = { "src", "corners", "masks", NULL };
| 48962 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_VoronoiSeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) && |  | 48914 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:detail_VoronoiSeamFinder.find", (char**)keywords, &pyobj_src, &pyobj_corners, &pyobj_masks) &&
| 48963 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 48915 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 48964 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) && |  | 48916 | pyopencv_to_safe(pyobj_corners, corners, ArgInfo("corners", 0)) &&
| 48965 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) ) |  | 48917 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 1)) )
| 48966 | { |  | 48918 | {
| 48967 | ERRWRAP2(_self_->find(src, corners, masks)); |  | 48919 | ERRWRAP2(_self_->find(src, corners, masks));
| 48968 | return pyopencv_from(masks); |  | 48920 | return pyopencv_from(masks);
| 48969 | } |  | 48921 | }
| 48970 |  |  | 48922 |
| 48971 | return NULL; |  | 48923 | return NULL;
| 48972 | } |  | 48924 | }
| 48973 |  |  | 48925 |
| 48974 |  |  | 48926 |
| 48975 |  |  | 48927 |
| 48976 | // Tables (detail_VoronoiSeamFinder) |  | 48928 | // Tables (detail_VoronoiSeamFinder)
| 48977 |  |  | 48929 |
| 48978 | static PyGetSetDef pyopencv_detail_VoronoiSeamFinder_getseters[] = |  | 48930 | static PyGetSetDef pyopencv_detail_VoronoiSeamFinder_getseters[] =
| 48979 | { |  | 48931 | {
| 48980 | {NULL} /* Sentinel */ |  | 48932 | {NULL} /* Sentinel */
| 48981 | }; |  | 48933 | };
| 48982 |  |  | 48934 |
| 48983 | static PyMethodDef pyopencv_detail_VoronoiSeamFinder_methods[] = |  | 48935 | static PyMethodDef pyopencv_detail_VoronoiSeamFinder_methods[] =
| 48984 | { |  | 48936 | {
| 48985 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_VoronoiSeamFinder_find, 0), "find(src, corners, masks) -> masks\n."}, |  | 48937 | {"find", CV_PY_FN_WITH_KW_(pyopencv_cv_detail_detail_VoronoiSeamFinder_find, 0), "find(src, corners, masks) -> masks\n."},
| 48986 |  |  | 48938 |
| 48987 | {NULL, NULL} |  | 48939 | {NULL, NULL}
| 48988 | }; |  | 48940 | };
| 48989 |  |  | 48941 |
| 48990 | // Converter (detail_VoronoiSeamFinder) |  | 48942 | // Converter (detail_VoronoiSeamFinder)
| 48991 |  |  | 48943 |
| 48992 | template<> |  | 48944 | template<>
| 48993 | struct PyOpenCV_Converter< Ptr<cv::detail::VoronoiSeamFinder> > |  | 48945 | struct PyOpenCV_Converter< Ptr<cv::detail::VoronoiSeamFinder> >
| 48994 | { |  | 48946 | {
| 48995 | static PyObject* from(const Ptr<cv::detail::VoronoiSeamFinder>& r) |  | 48947 | static PyObject* from(const Ptr<cv::detail::VoronoiSeamFinder>& r)
| 48996 | { |  | 48948 | {
| 48997 | return pyopencv_detail_VoronoiSeamFinder_Instance(r); |  | 48949 | return pyopencv_detail_VoronoiSeamFinder_Instance(r);
| 48998 | } |  | 48950 | }
| 48999 | static bool to(PyObject* src, Ptr<cv::detail::VoronoiSeamFinder>& dst, const ArgInfo& info) |  | 48951 | static bool to(PyObject* src, Ptr<cv::detail::VoronoiSeamFinder>& dst, const ArgInfo& info)
| 49000 | { |  | 48952 | {
| 49001 | if(!src || src == Py_None) |  | 48953 | if(!src || src == Py_None)
| 49002 | return true; |  | 48954 | return true;
| 49003 | Ptr<cv::detail::VoronoiSeamFinder> * dst_; |  | 48955 | Ptr<cv::detail::VoronoiSeamFinder> * dst_;
| 49004 | if (pyopencv_detail_VoronoiSeamFinder_getp(src, dst_)) |  | 48956 | if (pyopencv_detail_VoronoiSeamFinder_getp(src, dst_))
| 49005 | { |  | 48957 | {
| 49006 | dst = *dst_; |  | 48958 | dst = *dst_;
| 49007 | return true; |  | 48959 | return true;
| 49008 | } |  | 48960 | }
| 49009 |  |  | 48961 |
| 49010 | failmsg("Expected Ptr<cv::detail::VoronoiSeamFinder> for argument '%s'", info.name); |  | 48962 | failmsg("Expected Ptr<cv::detail::VoronoiSeamFinder> for argument '%s'", info.name);
| 49011 | return false; |  | 48963 | return false;
| 49012 | } |  | 48964 | }
| 49013 | }; |  | 48965 | };
| 49014 |  |  | 48966 |
| 49015 | //================================================================================ |  | 48967 | //================================================================================
| 49016 | // dnn_ClassificationModel (Generic) |  | 48968 | // dnn_ClassificationModel (Generic)
| 49017 | //================================================================================ |  | 48969 | //================================================================================
| 49018 |  |  | 48970 |
| 49019 | // GetSet (dnn_ClassificationModel) |  | 48971 | // GetSet (dnn_ClassificationModel)
| 49020 |  |  | 48972 |
| 49021 |  |  | 48973 |
| 49022 |  |  | 48974 |
| 49023 | // Methods (dnn_ClassificationModel) |  | 48975 | // Methods (dnn_ClassificationModel)
| 49024 |  |  | 48976 |
| 49025 | static int pyopencv_cv_dnn_dnn_ClassificationModel_ClassificationModel(pyopencv_dnn_ClassificationModel_t* self, PyObject* py_args, PyObject* kw) |  | 48977 | static int pyopencv_cv_dnn_dnn_ClassificationModel_ClassificationModel(pyopencv_dnn_ClassificationModel_t* self, PyObject* py_args, PyObject* kw)
| 49026 | { |  | 48978 | {
| 49027 | using namespace cv::dnn; |  | 48979 | using namespace cv::dnn;
| 49028 |  |  | 48980 |
| 49029 | pyPrepareArgumentConversionErrorsStorage(2); |  | 48981 | pyPrepareArgumentConversionErrorsStorage(2);
| 49030 |  |  | 48982 |
| 49031 | { |  | 48983 | {
| 49032 | PyObject* pyobj_model = NULL; |  | 48984 | PyObject* pyobj_model = NULL;
| 49033 | String model; |  | 48985 | String model;
| 49034 | PyObject* pyobj_config = NULL; |  | 48986 | PyObject* pyobj_config = NULL;
| 49035 | String config=""; |  | 48987 | String config="";
| 49036 |  |  | 48988 |
| 49037 | const char* keywords[] = { "model", "config", NULL }; |  | 48989 | const char* keywords[] = { "model", "config", NULL };
| 49038 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ClassificationModel", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 48990 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ClassificationModel", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 49039 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 48991 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 49040 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 48992 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 49041 | { |  | 48993 | {
| 49042 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::ClassificationModel(model, config)); |  | 48994 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::ClassificationModel(model, config));
| 49043 | return 0; |  | 48995 | return 0;
| 49044 | } |  | 48996 | }
| 49045 |  |  | 48997 |
| 49046 |  |  | 48998 |
| 49047 | pyPopulateArgumentConversionErrors(); |  | 48999 | pyPopulateArgumentConversionErrors();
| 49048 | } |  | 49000 | }
| 49049 |  |  | 49001 |
| 49050 |  |  | 49002 |
| 49051 | { |  | 49003 | {
| 49052 | PyObject* pyobj_network = NULL; |  | 49004 | PyObject* pyobj_network = NULL;
| 49053 | Net network; |  | 49005 | Net network;
| 49054 |  |  | 49006 |
| 49055 | const char* keywords[] = { "network", NULL }; |  | 49007 | const char* keywords[] = { "network", NULL };
| 49056 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ClassificationModel", (char**)keywords, &pyobj_network) && |  | 49008 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ClassificationModel", (char**)keywords, &pyobj_network) &&
| 49057 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 49009 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 49058 | { |  | 49010 | {
| 49059 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::ClassificationModel(network)); |  | 49011 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::ClassificationModel(network));
| 49060 | return 0; |  | 49012 | return 0;
| 49061 | } |  | 49013 | }
| 49062 |  |  | 49014 |
| 49063 |  |  | 49015 |
| 49064 | pyPopulateArgumentConversionErrors(); |  | 49016 | pyPopulateArgumentConversionErrors();
| 49065 | } |  | 49017 | }
| 49066 | pyRaiseCVOverloadException("ClassificationModel"); |  | 49018 | pyRaiseCVOverloadException("ClassificationModel");
| 49067 |  |  | 49019 |
| 49068 | return -1; |  | 49020 | return -1;
| 49069 | } |  | 49021 | }
| 49070 |  |  | 49022 |
| 49071 | static PyObject* pyopencv_cv_dnn_dnn_ClassificationModel_classify(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49023 | static PyObject* pyopencv_cv_dnn_dnn_ClassificationModel_classify(PyObject* self, PyObject* py_args, PyObject* kw)
| 49072 | { |  | 49024 | {
| 49073 | using namespace cv::dnn; |  | 49025 | using namespace cv::dnn;
| 49074 |  |  | 49026 |
| 49075 |  |  | 49027 |
| 49076 | cv::dnn::ClassificationModel * self1 = 0; |  | 49028 | cv::dnn::ClassificationModel * self1 = 0;
| 49077 | if (!pyopencv_dnn_ClassificationModel_getp(self, self1)) |  | 49029 | if (!pyopencv_dnn_ClassificationModel_getp(self, self1))
| 49078 | return failmsgp("Incorrect type of self (must be 'dnn_ClassificationModel' or its derivative)"); |  | 49030 | return failmsgp("Incorrect type of self (must be 'dnn_ClassificationModel' or its derivative)");
| 49079 | cv::dnn::ClassificationModel* _self_ = (self1); |  | 49031 | cv::dnn::ClassificationModel* _self_ = (self1);
| 49080 | pyPrepareArgumentConversionErrorsStorage(2); |  | 49032 | pyPrepareArgumentConversionErrorsStorage(2);
| 49081 |  |  | 49033 |
| 49082 | { |  | 49034 | {
| 49083 | PyObject* pyobj_frame = NULL; |  | 49035 | PyObject* pyobj_frame = NULL;
| 49084 | Mat frame; |  | 49036 | Mat frame;
| 49085 | int classId; |  | 49037 | int classId;
| 49086 | float conf; |  | 49038 | float conf;
| 49087 |  |  | 49039 |
| 49088 | const char* keywords[] = { "frame", NULL }; |  | 49040 | const char* keywords[] = { "frame", NULL };
| 49089 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_ClassificationModel.classify", (char**)keywords, &pyobj_frame) && |  | 49041 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_ClassificationModel.classify", (char**)keywords, &pyobj_frame) &&
| 49090 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 49042 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 49091 | { |  | 49043 | {
| 49092 | ERRWRAP2(_self_->classify(frame, classId, conf)); |  | 49044 | ERRWRAP2(_self_->classify(frame, classId, conf));
| 49093 | return Py_BuildValue("(NN)", pyopencv_from(classId), pyopencv_from(conf)); |  | 49045 | return Py_BuildValue("(NN)", pyopencv_from(classId), pyopencv_from(conf));
| 49094 | } |  | 49046 | }
| 49095 |  |  | 49047 |
| 49096 |  |  | 49048 |
| 49097 | pyPopulateArgumentConversionErrors(); |  | 49049 | pyPopulateArgumentConversionErrors();
| 49098 | } |  | 49050 | }
| 49099 |  |  | 49051 |
| 49100 |  |  | 49052 |
| 49101 | { |  | 49053 | {
| 49102 | PyObject* pyobj_frame = NULL; |  | 49054 | PyObject* pyobj_frame = NULL;
| 49103 | UMat frame; |  | 49055 | UMat frame;
| 49104 | int classId; |  | 49056 | int classId;
| 49105 | float conf; |  | 49057 | float conf;
| 49106 |  |  | 49058 |
| 49107 | const char* keywords[] = { "frame", NULL }; |  | 49059 | const char* keywords[] = { "frame", NULL };
| 49108 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_ClassificationModel.classify", (char**)keywords, &pyobj_frame) && |  | 49060 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_ClassificationModel.classify", (char**)keywords, &pyobj_frame) &&
| 49109 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 49061 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 49110 | { |  | 49062 | {
| 49111 | ERRWRAP2(_self_->classify(frame, classId, conf)); |  | 49063 | ERRWRAP2(_self_->classify(frame, classId, conf));
| 49112 | return Py_BuildValue("(NN)", pyopencv_from(classId), pyopencv_from(conf)); |  | 49064 | return Py_BuildValue("(NN)", pyopencv_from(classId), pyopencv_from(conf));
| 49113 | } |  | 49065 | }
| 49114 |  |  | 49066 |
| 49115 |  |  | 49067 |
| 49116 | pyPopulateArgumentConversionErrors(); |  | 49068 | pyPopulateArgumentConversionErrors();
| 49117 | } |  | 49069 | }
| 49118 | pyRaiseCVOverloadException("classify"); |  | 49070 | pyRaiseCVOverloadException("classify");
| 49119 |  |  | 49071 |
| 49120 | return NULL; |  | 49072 | return NULL;
| 49121 | } |  | 49073 | }
| 49122 |  |  | 49074 |
| 49123 | static PyObject* pyopencv_cv_dnn_dnn_ClassificationModel_getEnableSoftmaxPostProcessing(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49075 | static PyObject* pyopencv_cv_dnn_dnn_ClassificationModel_getEnableSoftmaxPostProcessing(PyObject* self, PyObject* py_args, PyObject* kw)
| 49124 | { |  | 49076 | {
| 49125 | using namespace cv::dnn; |  | 49077 | using namespace cv::dnn;
| 49126 |  |  | 49078 |
| 49127 |  |  | 49079 |
| 49128 | cv::dnn::ClassificationModel * self1 = 0; |  | 49080 | cv::dnn::ClassificationModel * self1 = 0;
| 49129 | if (!pyopencv_dnn_ClassificationModel_getp(self, self1)) |  | 49081 | if (!pyopencv_dnn_ClassificationModel_getp(self, self1))
| 49130 | return failmsgp("Incorrect type of self (must be 'dnn_ClassificationModel' or its derivative)"); |  | 49082 | return failmsgp("Incorrect type of self (must be 'dnn_ClassificationModel' or its derivative)");
| 49131 | cv::dnn::ClassificationModel* _self_ = (self1); |  | 49083 | cv::dnn::ClassificationModel* _self_ = (self1);
| 49132 | bool retval; |  | 49084 | bool retval;
| 49133 |  |  | 49085 |
| 49134 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 49086 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 49135 | { |  | 49087 | {
| 49136 | ERRWRAP2(retval = _self_->getEnableSoftmaxPostProcessing()); |  | 49088 | ERRWRAP2(retval = _self_->getEnableSoftmaxPostProcessing());
| 49137 | return pyopencv_from(retval); |  | 49089 | return pyopencv_from(retval);
| 49138 | } |  | 49090 | }
| 49139 |  |  | 49091 |
| 49140 | return NULL; |  | 49092 | return NULL;
| 49141 | } |  | 49093 | }
| 49142 |  |  | 49094 |
| 49143 | static PyObject* pyopencv_cv_dnn_dnn_ClassificationModel_setEnableSoftmaxPostProcessing(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49095 | static PyObject* pyopencv_cv_dnn_dnn_ClassificationModel_setEnableSoftmaxPostProcessing(PyObject* self, PyObject* py_args, PyObject* kw)
| 49144 | { |  | 49096 | {
| 49145 | using namespace cv::dnn; |  | 49097 | using namespace cv::dnn;
| 49146 |  |  | 49098 |
| 49147 |  |  | 49099 |
| 49148 | cv::dnn::ClassificationModel * self1 = 0; |  | 49100 | cv::dnn::ClassificationModel * self1 = 0;
| 49149 | if (!pyopencv_dnn_ClassificationModel_getp(self, self1)) |  | 49101 | if (!pyopencv_dnn_ClassificationModel_getp(self, self1))
| 49150 | return failmsgp("Incorrect type of self (must be 'dnn_ClassificationModel' or its derivative)"); |  | 49102 | return failmsgp("Incorrect type of self (must be 'dnn_ClassificationModel' or its derivative)");
| 49151 | cv::dnn::ClassificationModel* _self_ = (self1); |  | 49103 | cv::dnn::ClassificationModel* _self_ = (self1);
| 49152 | PyObject* pyobj_enable = NULL; |  | 49104 | PyObject* pyobj_enable = NULL;
| 49153 | bool enable=0; |  | 49105 | bool enable=0;
| 49154 | ClassificationModel retval; |  | 49106 | ClassificationModel retval;
| 49155 |  |  | 49107 |
| 49156 | const char* keywords[] = { "enable", NULL }; |  | 49108 | const char* keywords[] = { "enable", NULL };
| 49157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_ClassificationModel.setEnableSoftmaxPostProcessing", (char**)keywords, &pyobj_enable) && |  | 49109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_ClassificationModel.setEnableSoftmaxPostProcessing", (char**)keywords, &pyobj_enable) &&
| 49158 | pyopencv_to_safe(pyobj_enable, enable, ArgInfo("enable", 0)) ) |  | 49110 | pyopencv_to_safe(pyobj_enable, enable, ArgInfo("enable", 0)) )
| 49159 | { |  | 49111 | {
| 49160 | ERRWRAP2(retval = _self_->setEnableSoftmaxPostProcessing(enable)); |  | 49112 | ERRWRAP2(retval = _self_->setEnableSoftmaxPostProcessing(enable));
| 49161 | return pyopencv_from(retval); |  | 49113 | return pyopencv_from(retval);
| 49162 | } |  | 49114 | }
| 49163 |  |  | 49115 |
| 49164 | return NULL; |  | 49116 | return NULL;
| 49165 | } |  | 49117 | }
| 49166 |  |  | 49118 |
| 49167 |  |  | 49119 |
| 49168 |  |  | 49120 |
| 49169 | // Tables (dnn_ClassificationModel) |  | 49121 | // Tables (dnn_ClassificationModel)
| 49170 |  |  | 49122 |
| 49171 | static PyGetSetDef pyopencv_dnn_ClassificationModel_getseters[] = |  | 49123 | static PyGetSetDef pyopencv_dnn_ClassificationModel_getseters[] =
| 49172 | { |  | 49124 | {
| 49173 | {NULL} /* Sentinel */ |  | 49125 | {NULL} /* Sentinel */
| 49174 | }; |  | 49126 | };
| 49175 |  |  | 49127 |
| 49176 | static PyMethodDef pyopencv_dnn_ClassificationModel_methods[] = |  | 49128 | static PyMethodDef pyopencv_dnn_ClassificationModel_methods[] =
| 49177 | { |  | 49129 | {
| 49178 | {"classify", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_ClassificationModel_classify, 0), "classify(frame) -> classId, conf\n. @overload"}, |  | 49130 | {"classify", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_ClassificationModel_classify, 0), "classify(frame) -> classId, conf\n. @overload"},
| 49179 | {"getEnableSoftmaxPostProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_ClassificationModel_getEnableSoftmaxPostProcessing, 0), "getEnableSoftmaxPostProcessing() -> retval\n. * @brief Get enable/disable softmax post processing option.\n. *\n. * This option defaults to false, softmax post processing is not applied within the classify() function."}, |  | 49131 | {"getEnableSoftmaxPostProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_ClassificationModel_getEnableSoftmaxPostProcessing, 0), "getEnableSoftmaxPostProcessing() -> retval\n. * @brief Get enable/disable softmax post processing option.\n. *\n. * This option defaults to false, softmax post processing is not applied within the classify() function."},
| 49180 | {"setEnableSoftmaxPostProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_ClassificationModel_setEnableSoftmaxPostProcessing, 0), "setEnableSoftmaxPostProcessing(enable) -> retval\n. * @brief Set enable/disable softmax post processing option.\n. *\n. * If this option is true, softmax is applied after forward inference within the classify() function\n. * to convert the confidences range to [0.0-1.0].\n. * This function allows you to toggle this behavior.\n. * Please turn true when not contain softmax layer in model.\n. * @param[in] enable Set enable softmax post processing within the classify() function."}, |  | 49132 | {"setEnableSoftmaxPostProcessing", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_ClassificationModel_setEnableSoftmaxPostProcessing, 0), "setEnableSoftmaxPostProcessing(enable) -> retval\n. * @brief Set enable/disable softmax post processing option.\n. *\n. * If this option is true, softmax is applied after forward inference within the classify() function\n. * to convert the confidences range to [0.0-1.0].\n. * This function allows you to toggle this behavior.\n. * Please turn true when not contain softmax layer in model.\n. * @param[in] enable Set enable softmax post processing within the classify() function."},
| 49181 |  |  | 49133 |
| 49182 | {NULL, NULL} |  | 49134 | {NULL, NULL}
| 49183 | }; |  | 49135 | };
| 49184 |  |  | 49136 |
| 49185 | // Converter (dnn_ClassificationModel) |  | 49137 | // Converter (dnn_ClassificationModel)
| 49186 |  |  | 49138 |
| 49187 | template<> |  | 49139 | template<>
| 49188 | struct PyOpenCV_Converter< cv::dnn::ClassificationModel > |  | 49140 | struct PyOpenCV_Converter< cv::dnn::ClassificationModel >
| 49189 | { |  | 49141 | {
| 49190 | static PyObject* from(const cv::dnn::ClassificationModel& r) |  | 49142 | static PyObject* from(const cv::dnn::ClassificationModel& r)
| 49191 | { |  | 49143 | {
| 49192 | return pyopencv_dnn_ClassificationModel_Instance(r); |  | 49144 | return pyopencv_dnn_ClassificationModel_Instance(r);
| 49193 | } |  | 49145 | }
| 49194 | static bool to(PyObject* src, cv::dnn::ClassificationModel& dst, const ArgInfo& info) |  | 49146 | static bool to(PyObject* src, cv::dnn::ClassificationModel& dst, const ArgInfo& info)
| 49195 | { |  | 49147 | {
| 49196 | if(!src || src == Py_None) |  | 49148 | if(!src || src == Py_None)
| 49197 | return true; |  | 49149 | return true;
| 49198 | cv::dnn::ClassificationModel * dst_; |  | 49150 | cv::dnn::ClassificationModel * dst_;
| 49199 | if (pyopencv_dnn_ClassificationModel_getp(src, dst_)) |  | 49151 | if (pyopencv_dnn_ClassificationModel_getp(src, dst_))
| 49200 | { |  | 49152 | {
| 49201 | dst = *dst_; |  | 49153 | dst = *dst_;
| 49202 | return true; |  | 49154 | return true;
| 49203 | } |  | 49155 | }
| 49204 |  |  | 49156 |
| 49205 | failmsg("Expected cv::dnn::ClassificationModel for argument '%s'", info.name); |  | 49157 | failmsg("Expected cv::dnn::ClassificationModel for argument '%s'", info.name);
| 49206 | return false; |  | 49158 | return false;
| 49207 | } |  | 49159 | }
| 49208 | }; |  | 49160 | };
| 49209 |  |  | 49161 |
| 49210 | //================================================================================ |  | 49162 | //================================================================================
| 49211 | // dnn_DetectionModel (Generic) |  | 49163 | // dnn_DetectionModel (Generic)
| 49212 | //================================================================================ |  | 49164 | //================================================================================
| 49213 |  |  | 49165 |
| 49214 | // GetSet (dnn_DetectionModel) |  | 49166 | // GetSet (dnn_DetectionModel)
| 49215 |  |  | 49167 |
| 49216 |  |  | 49168 |
| 49217 |  |  | 49169 |
| 49218 | // Methods (dnn_DetectionModel) |  | 49170 | // Methods (dnn_DetectionModel)
| 49219 |  |  | 49171 |
| 49220 | static int pyopencv_cv_dnn_dnn_DetectionModel_DetectionModel(pyopencv_dnn_DetectionModel_t* self, PyObject* py_args, PyObject* kw) |  | 49172 | static int pyopencv_cv_dnn_dnn_DetectionModel_DetectionModel(pyopencv_dnn_DetectionModel_t* self, PyObject* py_args, PyObject* kw)
| 49221 | { |  | 49173 | {
| 49222 | using namespace cv::dnn; |  | 49174 | using namespace cv::dnn;
| 49223 |  |  | 49175 |
| 49224 | pyPrepareArgumentConversionErrorsStorage(2); |  | 49176 | pyPrepareArgumentConversionErrorsStorage(2);
| 49225 |  |  | 49177 |
| 49226 | { |  | 49178 | {
| 49227 | PyObject* pyobj_model = NULL; |  | 49179 | PyObject* pyobj_model = NULL;
| 49228 | String model; |  | 49180 | String model;
| 49229 | PyObject* pyobj_config = NULL; |  | 49181 | PyObject* pyobj_config = NULL;
| 49230 | String config=""; |  | 49182 | String config="";
| 49231 |  |  | 49183 |
| 49232 | const char* keywords[] = { "model", "config", NULL }; |  | 49184 | const char* keywords[] = { "model", "config", NULL };
| 49233 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:DetectionModel", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 49185 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:DetectionModel", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 49234 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 49186 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 49235 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 49187 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 49236 | { |  | 49188 | {
| 49237 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::DetectionModel(model, config)); |  | 49189 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::DetectionModel(model, config));
| 49238 | return 0; |  | 49190 | return 0;
| 49239 | } |  | 49191 | }
| 49240 |  |  | 49192 |
| 49241 |  |  | 49193 |
| 49242 | pyPopulateArgumentConversionErrors(); |  | 49194 | pyPopulateArgumentConversionErrors();
| 49243 | } |  | 49195 | }
| 49244 |  |  | 49196 |
| 49245 |  |  | 49197 |
| 49246 | { |  | 49198 | {
| 49247 | PyObject* pyobj_network = NULL; |  | 49199 | PyObject* pyobj_network = NULL;
| 49248 | Net network; |  | 49200 | Net network;
| 49249 |  |  | 49201 |
| 49250 | const char* keywords[] = { "network", NULL }; |  | 49202 | const char* keywords[] = { "network", NULL };
| 49251 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DetectionModel", (char**)keywords, &pyobj_network) && |  | 49203 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DetectionModel", (char**)keywords, &pyobj_network) &&
| 49252 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 49204 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 49253 | { |  | 49205 | {
| 49254 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::DetectionModel(network)); |  | 49206 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::DetectionModel(network));
| 49255 | return 0; |  | 49207 | return 0;
| 49256 | } |  | 49208 | }
| 49257 |  |  | 49209 |
| 49258 |  |  | 49210 |
| 49259 | pyPopulateArgumentConversionErrors(); |  | 49211 | pyPopulateArgumentConversionErrors();
| 49260 | } |  | 49212 | }
| 49261 | pyRaiseCVOverloadException("DetectionModel"); |  | 49213 | pyRaiseCVOverloadException("DetectionModel");
| 49262 |  |  | 49214 |
| 49263 | return -1; |  | 49215 | return -1;
| 49264 | } |  | 49216 | }
| 49265 |  |  | 49217 |
| 49266 | static PyObject* pyopencv_cv_dnn_dnn_DetectionModel_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49218 | static PyObject* pyopencv_cv_dnn_dnn_DetectionModel_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 49267 | { |  | 49219 | {
| 49268 | using namespace cv::dnn; |  | 49220 | using namespace cv::dnn;
| 49269 |  |  | 49221 |
| 49270 |  |  | 49222 |
| 49271 | cv::dnn::DetectionModel * self1 = 0; |  | 49223 | cv::dnn::DetectionModel * self1 = 0;
| 49272 | if (!pyopencv_dnn_DetectionModel_getp(self, self1)) |  | 49224 | if (!pyopencv_dnn_DetectionModel_getp(self, self1))
| 49273 | return failmsgp("Incorrect type of self (must be 'dnn_DetectionModel' or its derivative)"); |  | 49225 | return failmsgp("Incorrect type of self (must be 'dnn_DetectionModel' or its derivative)");
| 49274 | cv::dnn::DetectionModel* _self_ = (self1); |  | 49226 | cv::dnn::DetectionModel* _self_ = (self1);
| 49275 | pyPrepareArgumentConversionErrorsStorage(2); |  | 49227 | pyPrepareArgumentConversionErrorsStorage(2);
| 49276 |  |  | 49228 |
| 49277 | { |  | 49229 | {
| 49278 | PyObject* pyobj_frame = NULL; |  | 49230 | PyObject* pyobj_frame = NULL;
| 49279 | Mat frame; |  | 49231 | Mat frame;
| 49280 | vector_int classIds; |  | 49232 | vector_int classIds;
| 49281 | vector_float confidences; |  | 49233 | vector_float confidences;
| 49282 | vector_Rect boxes; |  | 49234 | vector_Rect boxes;
| 49283 | PyObject* pyobj_confThreshold = NULL; |  | 49235 | PyObject* pyobj_confThreshold = NULL;
| 49284 | float confThreshold=0.5f; |  | 49236 | float confThreshold=0.5f;
| 49285 | PyObject* pyobj_nmsThreshold = NULL; |  | 49237 | PyObject* pyobj_nmsThreshold = NULL;
| 49286 | float nmsThreshold=0.0f; |  | 49238 | float nmsThreshold=0.0f;
| 49287 |  |  | 49239 |
| 49288 | const char* keywords[] = { "frame", "confThreshold", "nmsThreshold", NULL }; |  | 49240 | const char* keywords[] = { "frame", "confThreshold", "nmsThreshold", NULL };
| 49289 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:dnn_DetectionModel.detect", (char**)keywords, &pyobj_frame, &pyobj_confThreshold, &pyobj_nmsThreshold) && |  | 49241 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:dnn_DetectionModel.detect", (char**)keywords, &pyobj_frame, &pyobj_confThreshold, &pyobj_nmsThreshold) &&
| 49290 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 49242 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 49291 | pyopencv_to_safe(pyobj_confThreshold, confThreshold, ArgInfo("confThreshold", 0)) && |  | 49243 | pyopencv_to_safe(pyobj_confThreshold, confThreshold, ArgInfo("confThreshold", 0)) &&
| 49292 | pyopencv_to_safe(pyobj_nmsThreshold, nmsThreshold, ArgInfo("nmsThreshold", 0)) ) |  | 49244 | pyopencv_to_safe(pyobj_nmsThreshold, nmsThreshold, ArgInfo("nmsThreshold", 0)) )
| 49293 | { |  | 49245 | {
| 49294 | ERRWRAP2(_self_->detect(frame, classIds, confidences, boxes, confThreshold, nmsThreshold)); |  | 49246 | ERRWRAP2(_self_->detect(frame, classIds, confidences, boxes, confThreshold, nmsThreshold));
| 49295 | return Py_BuildValue("(NNN)", pyopencv_from(classIds), pyopencv_from(confidences), pyopencv_from(boxes)); |  | 49247 | return Py_BuildValue("(NNN)", pyopencv_from(classIds), pyopencv_from(confidences), pyopencv_from(boxes));
| 49296 | } |  | 49248 | }
| 49297 |  |  | 49249 |
| 49298 |  |  | 49250 |
| 49299 | pyPopulateArgumentConversionErrors(); |  | 49251 | pyPopulateArgumentConversionErrors();
| 49300 | } |  | 49252 | }
| 49301 |  |  | 49253 |
| 49302 |  |  | 49254 |
| 49303 | { |  | 49255 | {
| 49304 | PyObject* pyobj_frame = NULL; |  | 49256 | PyObject* pyobj_frame = NULL;
| 49305 | UMat frame; |  | 49257 | UMat frame;
| 49306 | vector_int classIds; |  | 49258 | vector_int classIds;
| 49307 | vector_float confidences; |  | 49259 | vector_float confidences;
| 49308 | vector_Rect boxes; |  | 49260 | vector_Rect boxes;
| 49309 | PyObject* pyobj_confThreshold = NULL; |  | 49261 | PyObject* pyobj_confThreshold = NULL;
| 49310 | float confThreshold=0.5f; |  | 49262 | float confThreshold=0.5f;
| 49311 | PyObject* pyobj_nmsThreshold = NULL; |  | 49263 | PyObject* pyobj_nmsThreshold = NULL;
| 49312 | float nmsThreshold=0.0f; |  | 49264 | float nmsThreshold=0.0f;
| 49313 |  |  | 49265 |
| 49314 | const char* keywords[] = { "frame", "confThreshold", "nmsThreshold", NULL }; |  | 49266 | const char* keywords[] = { "frame", "confThreshold", "nmsThreshold", NULL };
| 49315 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:dnn_DetectionModel.detect", (char**)keywords, &pyobj_frame, &pyobj_confThreshold, &pyobj_nmsThreshold) && |  | 49267 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:dnn_DetectionModel.detect", (char**)keywords, &pyobj_frame, &pyobj_confThreshold, &pyobj_nmsThreshold) &&
| 49316 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 49268 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 49317 | pyopencv_to_safe(pyobj_confThreshold, confThreshold, ArgInfo("confThreshold", 0)) && |  | 49269 | pyopencv_to_safe(pyobj_confThreshold, confThreshold, ArgInfo("confThreshold", 0)) &&
| 49318 | pyopencv_to_safe(pyobj_nmsThreshold, nmsThreshold, ArgInfo("nmsThreshold", 0)) ) |  | 49270 | pyopencv_to_safe(pyobj_nmsThreshold, nmsThreshold, ArgInfo("nmsThreshold", 0)) )
| 49319 | { |  | 49271 | {
| 49320 | ERRWRAP2(_self_->detect(frame, classIds, confidences, boxes, confThreshold, nmsThreshold)); |  | 49272 | ERRWRAP2(_self_->detect(frame, classIds, confidences, boxes, confThreshold, nmsThreshold));
| 49321 | return Py_BuildValue("(NNN)", pyopencv_from(classIds), pyopencv_from(confidences), pyopencv_from(boxes)); |  | 49273 | return Py_BuildValue("(NNN)", pyopencv_from(classIds), pyopencv_from(confidences), pyopencv_from(boxes));
| 49322 | } |  | 49274 | }
| 49323 |  |  | 49275 |
| 49324 |  |  | 49276 |
| 49325 | pyPopulateArgumentConversionErrors(); |  | 49277 | pyPopulateArgumentConversionErrors();
| 49326 | } |  | 49278 | }
| 49327 | pyRaiseCVOverloadException("detect"); |  | 49279 | pyRaiseCVOverloadException("detect");
| 49328 |  |  | 49280 |
| 49329 | return NULL; |  | 49281 | return NULL;
| 49330 | } |  | 49282 | }
| 49331 |  |  | 49283 |
| 49332 | static PyObject* pyopencv_cv_dnn_dnn_DetectionModel_getNmsAcrossClasses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49284 | static PyObject* pyopencv_cv_dnn_dnn_DetectionModel_getNmsAcrossClasses(PyObject* self, PyObject* py_args, PyObject* kw)
| 49333 | { |  | 49285 | {
| 49334 | using namespace cv::dnn; |  | 49286 | using namespace cv::dnn;
| 49335 |  |  | 49287 |
| 49336 |  |  | 49288 |
| 49337 | cv::dnn::DetectionModel * self1 = 0; |  | 49289 | cv::dnn::DetectionModel * self1 = 0;
| 49338 | if (!pyopencv_dnn_DetectionModel_getp(self, self1)) |  | 49290 | if (!pyopencv_dnn_DetectionModel_getp(self, self1))
| 49339 | return failmsgp("Incorrect type of self (must be 'dnn_DetectionModel' or its derivative)"); |  | 49291 | return failmsgp("Incorrect type of self (must be 'dnn_DetectionModel' or its derivative)");
| 49340 | cv::dnn::DetectionModel* _self_ = (self1); |  | 49292 | cv::dnn::DetectionModel* _self_ = (self1);
| 49341 | bool retval; |  | 49293 | bool retval;
| 49342 |  |  | 49294 |
| 49343 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 49295 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 49344 | { |  | 49296 | {
| 49345 | ERRWRAP2(retval = _self_->getNmsAcrossClasses()); |  | 49297 | ERRWRAP2(retval = _self_->getNmsAcrossClasses());
| 49346 | return pyopencv_from(retval); |  | 49298 | return pyopencv_from(retval);
| 49347 | } |  | 49299 | }
| 49348 |  |  | 49300 |
| 49349 | return NULL; |  | 49301 | return NULL;
| 49350 | } |  | 49302 | }
| 49351 |  |  | 49303 |
| 49352 | static PyObject* pyopencv_cv_dnn_dnn_DetectionModel_setNmsAcrossClasses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49304 | static PyObject* pyopencv_cv_dnn_dnn_DetectionModel_setNmsAcrossClasses(PyObject* self, PyObject* py_args, PyObject* kw)
| 49353 | { |  | 49305 | {
| 49354 | using namespace cv::dnn; |  | 49306 | using namespace cv::dnn;
| 49355 |  |  | 49307 |
| 49356 |  |  | 49308 |
| 49357 | cv::dnn::DetectionModel * self1 = 0; |  | 49309 | cv::dnn::DetectionModel * self1 = 0;
| 49358 | if (!pyopencv_dnn_DetectionModel_getp(self, self1)) |  | 49310 | if (!pyopencv_dnn_DetectionModel_getp(self, self1))
| 49359 | return failmsgp("Incorrect type of self (must be 'dnn_DetectionModel' or its derivative)"); |  | 49311 | return failmsgp("Incorrect type of self (must be 'dnn_DetectionModel' or its derivative)");
| 49360 | cv::dnn::DetectionModel* _self_ = (self1); |  | 49312 | cv::dnn::DetectionModel* _self_ = (self1);
| 49361 | PyObject* pyobj_value = NULL; |  | 49313 | PyObject* pyobj_value = NULL;
| 49362 | bool value=0; |  | 49314 | bool value=0;
| 49363 | DetectionModel retval; |  | 49315 | DetectionModel retval;
| 49364 |  |  | 49316 |
| 49365 | const char* keywords[] = { "value", NULL }; |  | 49317 | const char* keywords[] = { "value", NULL };
| 49366 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_DetectionModel.setNmsAcrossClasses", (char**)keywords, &pyobj_value) && |  | 49318 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_DetectionModel.setNmsAcrossClasses", (char**)keywords, &pyobj_value) &&
| 49367 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 49319 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 49368 | { |  | 49320 | {
| 49369 | ERRWRAP2(retval = _self_->setNmsAcrossClasses(value)); |  | 49321 | ERRWRAP2(retval = _self_->setNmsAcrossClasses(value));
| 49370 | return pyopencv_from(retval); |  | 49322 | return pyopencv_from(retval);
| 49371 | } |  | 49323 | }
| 49372 |  |  | 49324 |
| 49373 | return NULL; |  | 49325 | return NULL;
| 49374 | } |  | 49326 | }
| 49375 |  |  | 49327 |
| 49376 |  |  | 49328 |
| 49377 |  |  | 49329 |
| 49378 | // Tables (dnn_DetectionModel) |  | 49330 | // Tables (dnn_DetectionModel)
| 49379 |  |  | 49331 |
| 49380 | static PyGetSetDef pyopencv_dnn_DetectionModel_getseters[] = |  | 49332 | static PyGetSetDef pyopencv_dnn_DetectionModel_getseters[] =
| 49381 | { |  | 49333 | {
| 49382 | {NULL} /* Sentinel */ |  | 49334 | {NULL} /* Sentinel */
| 49383 | }; |  | 49335 | };
| 49384 |  |  | 49336 |
| 49385 | static PyMethodDef pyopencv_dnn_DetectionModel_methods[] = |  | 49337 | static PyMethodDef pyopencv_dnn_DetectionModel_methods[] =
| 49386 | { |  | 49338 | {
| 49387 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DetectionModel_detect, 0), "detect(frame[, confThreshold[, nmsThreshold]]) -> classIds, confidences, boxes\n. @brief Given the @p input frame, create input blob, run net and return result detections.\n. * @param[in] frame The input image.\n. * @param[out] classIds Class indexes in result detection.\n. * @param[out] confidences A set of corresponding confidences.\n. * @param[out] boxes A set of bounding boxes.\n. * @param[in] confThreshold A threshold used to filter boxes by confidences.\n. * @param[in] nmsThreshold A threshold used in non maximum suppression."}, |  | 49339 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DetectionModel_detect, 0), "detect(frame[, confThreshold[, nmsThreshold]]) -> classIds, confidences, boxes\n. @brief Given the @p input frame, create input blob, run net and return result detections.\n. * @param[in] frame The input image.\n. * @param[out] classIds Class indexes in result detection.\n. * @param[out] confidences A set of corresponding confidences.\n. * @param[out] boxes A set of bounding boxes.\n. * @param[in] confThreshold A threshold used to filter boxes by confidences.\n. * @param[in] nmsThreshold A threshold used in non maximum suppression."},
| 49388 | {"getNmsAcrossClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DetectionModel_getNmsAcrossClasses, 0), "getNmsAcrossClasses() -> retval\n. * @brief Getter for nmsAcrossClasses. This variable defaults to false,\n. * such that when non max suppression is used during the detect() function, it will do so only per-class"}, |  | 49340 | {"getNmsAcrossClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DetectionModel_getNmsAcrossClasses, 0), "getNmsAcrossClasses() -> retval\n. * @brief Getter for nmsAcrossClasses. This variable defaults to false,\n. * such that when non max suppression is used during the detect() function, it will do so only per-class"},
| 49389 | {"setNmsAcrossClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DetectionModel_setNmsAcrossClasses, 0), "setNmsAcrossClasses(value) -> retval\n. * @brief nmsAcrossClasses defaults to false,\n. * such that when non max suppression is used during the detect() function, it will do so per-class.\n. * This function allows you to toggle this behaviour.\n. * @param[in] value The new value for nmsAcrossClasses"}, |  | 49341 | {"setNmsAcrossClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DetectionModel_setNmsAcrossClasses, 0), "setNmsAcrossClasses(value) -> retval\n. * @brief nmsAcrossClasses defaults to false,\n. * such that when non max suppression is used during the detect() function, it will do so per-class.\n. * This function allows you to toggle this behaviour.\n. * @param[in] value The new value for nmsAcrossClasses"},
| 49390 |  |  | 49342 |
| 49391 | {NULL, NULL} |  | 49343 | {NULL, NULL}
| 49392 | }; |  | 49344 | };
| 49393 |  |  | 49345 |
| 49394 | // Converter (dnn_DetectionModel) |  | 49346 | // Converter (dnn_DetectionModel)
| 49395 |  |  | 49347 |
| 49396 | template<> |  | 49348 | template<>
| 49397 | struct PyOpenCV_Converter< cv::dnn::DetectionModel > |  | 49349 | struct PyOpenCV_Converter< cv::dnn::DetectionModel >
| 49398 | { |  | 49350 | {
| 49399 | static PyObject* from(const cv::dnn::DetectionModel& r) |  | 49351 | static PyObject* from(const cv::dnn::DetectionModel& r)
| 49400 | { |  | 49352 | {
| 49401 | return pyopencv_dnn_DetectionModel_Instance(r); |  | 49353 | return pyopencv_dnn_DetectionModel_Instance(r);
| 49402 | } |  | 49354 | }
| 49403 | static bool to(PyObject* src, cv::dnn::DetectionModel& dst, const ArgInfo& info) |  | 49355 | static bool to(PyObject* src, cv::dnn::DetectionModel& dst, const ArgInfo& info)
| 49404 | { |  | 49356 | {
| 49405 | if(!src || src == Py_None) |  | 49357 | if(!src || src == Py_None)
| 49406 | return true; |  | 49358 | return true;
| 49407 | cv::dnn::DetectionModel * dst_; |  | 49359 | cv::dnn::DetectionModel * dst_;
| 49408 | if (pyopencv_dnn_DetectionModel_getp(src, dst_)) |  | 49360 | if (pyopencv_dnn_DetectionModel_getp(src, dst_))
| 49409 | { |  | 49361 | {
| 49410 | dst = *dst_; |  | 49362 | dst = *dst_;
| 49411 | return true; |  | 49363 | return true;
| 49412 | } |  | 49364 | }
| 49413 |  |  | 49365 |
| 49414 | failmsg("Expected cv::dnn::DetectionModel for argument '%s'", info.name); |  | 49366 | failmsg("Expected cv::dnn::DetectionModel for argument '%s'", info.name);
| 49415 | return false; |  | 49367 | return false;
| 49416 | } |  | 49368 | }
| 49417 | }; |  | 49369 | };
| 49418 |  |  | 49370 |
| 49419 | //================================================================================ |  | 49371 | //================================================================================
| 49420 | // dnn_DictValue (Generic) |  | 49372 | // dnn_DictValue (Generic)
| 49421 | //================================================================================ |  | 49373 | //================================================================================
| 49422 |  |  | 49374 |
| 49423 | // GetSet (dnn_DictValue) |  | 49375 | // GetSet (dnn_DictValue)
| 49424 |  |  | 49376 |
| 49425 |  |  | 49377 |
| 49426 |  |  | 49378 |
| 49427 | // Methods (dnn_DictValue) |  | 49379 | // Methods (dnn_DictValue)
| 49428 |  |  | 49380 |
| 49429 | static int pyopencv_cv_dnn_dnn_DictValue_DictValue(pyopencv_dnn_DictValue_t* self, PyObject* py_args, PyObject* kw) |  | 49381 | static int pyopencv_cv_dnn_dnn_DictValue_DictValue(pyopencv_dnn_DictValue_t* self, PyObject* py_args, PyObject* kw)
| 49430 | { |  | 49382 | {
| 49431 | using namespace cv::dnn; |  | 49383 | using namespace cv::dnn;
| 49432 |  |  | 49384 |
| 49433 | pyPrepareArgumentConversionErrorsStorage(3); |  | 49385 | pyPrepareArgumentConversionErrorsStorage(3);
| 49434 |  |  | 49386 |
| 49435 | { |  | 49387 | {
| 49436 | PyObject* pyobj_i = NULL; |  | 49388 | PyObject* pyobj_i = NULL;
| 49437 | int i=0; |  | 49389 | int i=0;
| 49438 |  |  | 49390 |
| 49439 | const char* keywords[] = { "i", NULL }; |  | 49391 | const char* keywords[] = { "i", NULL };
| 49440 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DictValue", (char**)keywords, &pyobj_i) && |  | 49392 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DictValue", (char**)keywords, &pyobj_i) &&
| 49441 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) ) |  | 49393 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) )
| 49442 | { |  | 49394 | {
| 49443 | new (&(self->v)) Ptr<cv::dnn::DictValue>(); // init Ptr with placement new |  | 49395 | new (&(self->v)) Ptr<cv::dnn::DictValue>(); // init Ptr with placement new
| 49444 | if(self) ERRWRAP2(self->v.reset(new cv::dnn::DictValue(i))); |  | 49396 | if(self) ERRWRAP2(self->v.reset(new cv::dnn::DictValue(i)));
| 49445 | return 0; |  | 49397 | return 0;
| 49446 | } |  | 49398 | }
| 49447 |  |  | 49399 |
| 49448 |  |  | 49400 |
| 49449 | pyPopulateArgumentConversionErrors(); |  | 49401 | pyPopulateArgumentConversionErrors();
| 49450 | } |  | 49402 | }
| 49451 |  |  | 49403 |
| 49452 |  |  | 49404 |
| 49453 | { |  | 49405 | {
| 49454 | PyObject* pyobj_p = NULL; |  | 49406 | PyObject* pyobj_p = NULL;
| 49455 | double p=0; |  | 49407 | double p=0;
| 49456 |  |  | 49408 |
| 49457 | const char* keywords[] = { "p", NULL }; |  | 49409 | const char* keywords[] = { "p", NULL };
| 49458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DictValue", (char**)keywords, &pyobj_p) && |  | 49410 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DictValue", (char**)keywords, &pyobj_p) &&
| 49459 | pyopencv_to_safe(pyobj_p, p, ArgInfo("p", 0)) ) |  | 49411 | pyopencv_to_safe(pyobj_p, p, ArgInfo("p", 0)) )
| 49460 | { |  | 49412 | {
| 49461 | new (&(self->v)) Ptr<cv::dnn::DictValue>(); // init Ptr with placement new |  | 49413 | new (&(self->v)) Ptr<cv::dnn::DictValue>(); // init Ptr with placement new
| 49462 | if(self) ERRWRAP2(self->v.reset(new cv::dnn::DictValue(p))); |  | 49414 | if(self) ERRWRAP2(self->v.reset(new cv::dnn::DictValue(p)));
| 49463 | return 0; |  | 49415 | return 0;
| 49464 | } |  | 49416 | }
| 49465 |  |  | 49417 |
| 49466 |  |  | 49418 |
| 49467 | pyPopulateArgumentConversionErrors(); |  | 49419 | pyPopulateArgumentConversionErrors();
| 49468 | } |  | 49420 | }
| 49469 |  |  | 49421 |
| 49470 |  |  | 49422 |
| 49471 | { |  | 49423 | {
| 49472 | PyObject* pyobj_s = NULL; |  | 49424 | PyObject* pyobj_s = NULL;
| 49473 | String s; |  | 49425 | String s;
| 49474 |  |  | 49426 |
| 49475 | const char* keywords[] = { "s", NULL }; |  | 49427 | const char* keywords[] = { "s", NULL };
| 49476 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DictValue", (char**)keywords, &pyobj_s) && |  | 49428 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DictValue", (char**)keywords, &pyobj_s) &&
| 49477 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) ) |  | 49429 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) )
| 49478 | { |  | 49430 | {
| 49479 | new (&(self->v)) Ptr<cv::dnn::DictValue>(); // init Ptr with placement new |  | 49431 | new (&(self->v)) Ptr<cv::dnn::DictValue>(); // init Ptr with placement new
| 49480 | if(self) ERRWRAP2(self->v.reset(new cv::dnn::DictValue(s))); |  | 49432 | if(self) ERRWRAP2(self->v.reset(new cv::dnn::DictValue(s)));
| 49481 | return 0; |  | 49433 | return 0;
| 49482 | } |  | 49434 | }
| 49483 |  |  | 49435 |
| 49484 |  |  | 49436 |
| 49485 | pyPopulateArgumentConversionErrors(); |  | 49437 | pyPopulateArgumentConversionErrors();
| 49486 | } |  | 49438 | }
| 49487 | pyRaiseCVOverloadException("DictValue"); |  | 49439 | pyRaiseCVOverloadException("DictValue");
| 49488 |  |  | 49440 |
| 49489 | return -1; |  | 49441 | return -1;
| 49490 | } |  | 49442 | }
| 49491 |  |  | 49443 |
| 49492 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_getIntValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49444 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_getIntValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 49493 | { |  | 49445 | {
| 49494 | using namespace cv::dnn; |  | 49446 | using namespace cv::dnn;
| 49495 |  |  | 49447 |
| 49496 |  |  | 49448 |
| 49497 | Ptr<cv::dnn::DictValue> * self1 = 0; |  | 49449 | Ptr<cv::dnn::DictValue> * self1 = 0;
| 49498 | if (!pyopencv_dnn_DictValue_getp(self, self1)) |  | 49450 | if (!pyopencv_dnn_DictValue_getp(self, self1))
| 49499 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)"); |  | 49451 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)");
| 49500 | Ptr<cv::dnn::DictValue> _self_ = *(self1); |  | 49452 | Ptr<cv::dnn::DictValue> _self_ = *(self1);
| 49501 | PyObject* pyobj_idx = NULL; |  | 49453 | PyObject* pyobj_idx = NULL;
| 49502 | int idx=-1; |  | 49454 | int idx=-1;
| 49503 | int retval; |  | 49455 | int retval;
| 49504 |  |  | 49456 |
| 49505 | const char* keywords[] = { "idx", NULL }; |  | 49457 | const char* keywords[] = { "idx", NULL };
| 49506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_DictValue.getIntValue", (char**)keywords, &pyobj_idx) && |  | 49458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_DictValue.getIntValue", (char**)keywords, &pyobj_idx) &&
| 49507 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) ) |  | 49459 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) )
| 49508 | { |  | 49460 | {
| 49509 | ERRWRAP2(retval = _self_->getIntValue(idx)); |  | 49461 | ERRWRAP2(retval = _self_->getIntValue(idx));
| 49510 | return pyopencv_from(retval); |  | 49462 | return pyopencv_from(retval);
| 49511 | } |  | 49463 | }
| 49512 |  |  | 49464 |
| 49513 | return NULL; |  | 49465 | return NULL;
| 49514 | } |  | 49466 | }
| 49515 |  |  | 49467 |
| 49516 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_getRealValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49468 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_getRealValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 49517 | { |  | 49469 | {
| 49518 | using namespace cv::dnn; |  | 49470 | using namespace cv::dnn;
| 49519 |  |  | 49471 |
| 49520 |  |  | 49472 |
| 49521 | Ptr<cv::dnn::DictValue> * self1 = 0; |  | 49473 | Ptr<cv::dnn::DictValue> * self1 = 0;
| 49522 | if (!pyopencv_dnn_DictValue_getp(self, self1)) |  | 49474 | if (!pyopencv_dnn_DictValue_getp(self, self1))
| 49523 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)"); |  | 49475 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)");
| 49524 | Ptr<cv::dnn::DictValue> _self_ = *(self1); |  | 49476 | Ptr<cv::dnn::DictValue> _self_ = *(self1);
| 49525 | PyObject* pyobj_idx = NULL; |  | 49477 | PyObject* pyobj_idx = NULL;
| 49526 | int idx=-1; |  | 49478 | int idx=-1;
| 49527 | double retval; |  | 49479 | double retval;
| 49528 |  |  | 49480 |
| 49529 | const char* keywords[] = { "idx", NULL }; |  | 49481 | const char* keywords[] = { "idx", NULL };
| 49530 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_DictValue.getRealValue", (char**)keywords, &pyobj_idx) && |  | 49482 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_DictValue.getRealValue", (char**)keywords, &pyobj_idx) &&
| 49531 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) ) |  | 49483 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) )
| 49532 | { |  | 49484 | {
| 49533 | ERRWRAP2(retval = _self_->getRealValue(idx)); |  | 49485 | ERRWRAP2(retval = _self_->getRealValue(idx));
| 49534 | return pyopencv_from(retval); |  | 49486 | return pyopencv_from(retval);
| 49535 | } |  | 49487 | }
| 49536 |  |  | 49488 |
| 49537 | return NULL; |  | 49489 | return NULL;
| 49538 | } |  | 49490 | }
| 49539 |  |  | 49491 |
| 49540 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_getStringValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49492 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_getStringValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 49541 | { |  | 49493 | {
| 49542 | using namespace cv::dnn; |  | 49494 | using namespace cv::dnn;
| 49543 |  |  | 49495 |
| 49544 |  |  | 49496 |
| 49545 | Ptr<cv::dnn::DictValue> * self1 = 0; |  | 49497 | Ptr<cv::dnn::DictValue> * self1 = 0;
| 49546 | if (!pyopencv_dnn_DictValue_getp(self, self1)) |  | 49498 | if (!pyopencv_dnn_DictValue_getp(self, self1))
| 49547 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)"); |  | 49499 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)");
| 49548 | Ptr<cv::dnn::DictValue> _self_ = *(self1); |  | 49500 | Ptr<cv::dnn::DictValue> _self_ = *(self1);
| 49549 | PyObject* pyobj_idx = NULL; |  | 49501 | PyObject* pyobj_idx = NULL;
| 49550 | int idx=-1; |  | 49502 | int idx=-1;
| 49551 | String retval; |  | 49503 | String retval;
| 49552 |  |  | 49504 |
| 49553 | const char* keywords[] = { "idx", NULL }; |  | 49505 | const char* keywords[] = { "idx", NULL };
| 49554 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_DictValue.getStringValue", (char**)keywords, &pyobj_idx) && |  | 49506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_DictValue.getStringValue", (char**)keywords, &pyobj_idx) &&
| 49555 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) ) |  | 49507 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) )
| 49556 | { |  | 49508 | {
| 49557 | ERRWRAP2(retval = _self_->getStringValue(idx)); |  | 49509 | ERRWRAP2(retval = _self_->getStringValue(idx));
| 49558 | return pyopencv_from(retval); |  | 49510 | return pyopencv_from(retval);
| 49559 | } |  | 49511 | }
| 49560 |  |  | 49512 |
| 49561 | return NULL; |  | 49513 | return NULL;
| 49562 | } |  | 49514 | }
| 49563 |  |  | 49515 |
| 49564 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_isInt(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49516 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_isInt(PyObject* self, PyObject* py_args, PyObject* kw)
| 49565 | { |  | 49517 | {
| 49566 | using namespace cv::dnn; |  | 49518 | using namespace cv::dnn;
| 49567 |  |  | 49519 |
| 49568 |  |  | 49520 |
| 49569 | Ptr<cv::dnn::DictValue> * self1 = 0; |  | 49521 | Ptr<cv::dnn::DictValue> * self1 = 0;
| 49570 | if (!pyopencv_dnn_DictValue_getp(self, self1)) |  | 49522 | if (!pyopencv_dnn_DictValue_getp(self, self1))
| 49571 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)"); |  | 49523 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)");
| 49572 | Ptr<cv::dnn::DictValue> _self_ = *(self1); |  | 49524 | Ptr<cv::dnn::DictValue> _self_ = *(self1);
| 49573 | bool retval; |  | 49525 | bool retval;
| 49574 |  |  | 49526 |
| 49575 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 49527 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 49576 | { |  | 49528 | {
| 49577 | ERRWRAP2(retval = _self_->isInt()); |  | 49529 | ERRWRAP2(retval = _self_->isInt());
| 49578 | return pyopencv_from(retval); |  | 49530 | return pyopencv_from(retval);
| 49579 | } |  | 49531 | }
| 49580 |  |  | 49532 |
| 49581 | return NULL; |  | 49533 | return NULL;
| 49582 | } |  | 49534 | }
| 49583 |  |  | 49535 |
| 49584 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_isReal(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49536 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_isReal(PyObject* self, PyObject* py_args, PyObject* kw)
| 49585 | { |  | 49537 | {
| 49586 | using namespace cv::dnn; |  | 49538 | using namespace cv::dnn;
| 49587 |  |  | 49539 |
| 49588 |  |  | 49540 |
| 49589 | Ptr<cv::dnn::DictValue> * self1 = 0; |  | 49541 | Ptr<cv::dnn::DictValue> * self1 = 0;
| 49590 | if (!pyopencv_dnn_DictValue_getp(self, self1)) |  | 49542 | if (!pyopencv_dnn_DictValue_getp(self, self1))
| 49591 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)"); |  | 49543 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)");
| 49592 | Ptr<cv::dnn::DictValue> _self_ = *(self1); |  | 49544 | Ptr<cv::dnn::DictValue> _self_ = *(self1);
| 49593 | bool retval; |  | 49545 | bool retval;
| 49594 |  |  | 49546 |
| 49595 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 49547 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 49596 | { |  | 49548 | {
| 49597 | ERRWRAP2(retval = _self_->isReal()); |  | 49549 | ERRWRAP2(retval = _self_->isReal());
| 49598 | return pyopencv_from(retval); |  | 49550 | return pyopencv_from(retval);
| 49599 | } |  | 49551 | }
| 49600 |  |  | 49552 |
| 49601 | return NULL; |  | 49553 | return NULL;
| 49602 | } |  | 49554 | }
| 49603 |  |  | 49555 |
| 49604 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_isString(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49556 | static PyObject* pyopencv_cv_dnn_dnn_DictValue_isString(PyObject* self, PyObject* py_args, PyObject* kw)
| 49605 | { |  | 49557 | {
| 49606 | using namespace cv::dnn; |  | 49558 | using namespace cv::dnn;
| 49607 |  |  | 49559 |
| 49608 |  |  | 49560 |
| 49609 | Ptr<cv::dnn::DictValue> * self1 = 0; |  | 49561 | Ptr<cv::dnn::DictValue> * self1 = 0;
| 49610 | if (!pyopencv_dnn_DictValue_getp(self, self1)) |  | 49562 | if (!pyopencv_dnn_DictValue_getp(self, self1))
| 49611 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)"); |  | 49563 | return failmsgp("Incorrect type of self (must be 'dnn_DictValue' or its derivative)");
| 49612 | Ptr<cv::dnn::DictValue> _self_ = *(self1); |  | 49564 | Ptr<cv::dnn::DictValue> _self_ = *(self1);
| 49613 | bool retval; |  | 49565 | bool retval;
| 49614 |  |  | 49566 |
| 49615 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 49567 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 49616 | { |  | 49568 | {
| 49617 | ERRWRAP2(retval = _self_->isString()); |  | 49569 | ERRWRAP2(retval = _self_->isString());
| 49618 | return pyopencv_from(retval); |  | 49570 | return pyopencv_from(retval);
| 49619 | } |  | 49571 | }
| 49620 |  |  | 49572 |
| 49621 | return NULL; |  | 49573 | return NULL;
| 49622 | } |  | 49574 | }
| 49623 |  |  | 49575 |
| 49624 |  |  | 49576 |
| 49625 |  |  | 49577 |
| 49626 | // Tables (dnn_DictValue) |  | 49578 | // Tables (dnn_DictValue)
| 49627 |  |  | 49579 |
| 49628 | static PyGetSetDef pyopencv_dnn_DictValue_getseters[] = |  | 49580 | static PyGetSetDef pyopencv_dnn_DictValue_getseters[] =
| 49629 | { |  | 49581 | {
| 49630 | {NULL} /* Sentinel */ |  | 49582 | {NULL} /* Sentinel */
| 49631 | }; |  | 49583 | };
| 49632 |  |  | 49584 |
| 49633 | static PyMethodDef pyopencv_dnn_DictValue_methods[] = |  | 49585 | static PyMethodDef pyopencv_dnn_DictValue_methods[] =
| 49634 | { |  | 49586 | {
| 49635 | {"getIntValue", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_getIntValue, 0), "getIntValue([, idx]) -> retval\n."}, |  | 49587 | {"getIntValue", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_getIntValue, 0), "getIntValue([, idx]) -> retval\n."},
| 49636 | {"getRealValue", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_getRealValue, 0), "getRealValue([, idx]) -> retval\n."}, |  | 49588 | {"getRealValue", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_getRealValue, 0), "getRealValue([, idx]) -> retval\n."},
| 49637 | {"getStringValue", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_getStringValue, 0), "getStringValue([, idx]) -> retval\n."}, |  | 49589 | {"getStringValue", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_getStringValue, 0), "getStringValue([, idx]) -> retval\n."},
| 49638 | {"isInt", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_isInt, 0), "isInt() -> retval\n."}, |  | 49590 | {"isInt", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_isInt, 0), "isInt() -> retval\n."},
| 49639 | {"isReal", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_isReal, 0), "isReal() -> retval\n."}, |  | 49591 | {"isReal", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_isReal, 0), "isReal() -> retval\n."},
| 49640 | {"isString", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_isString, 0), "isString() -> retval\n."}, |  | 49592 | {"isString", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_DictValue_isString, 0), "isString() -> retval\n."},
| 49641 |  |  | 49593 |
| 49642 | {NULL, NULL} |  | 49594 | {NULL, NULL}
| 49643 | }; |  | 49595 | };
| 49644 |  |  | 49596 |
| 49645 | // Converter (dnn_DictValue) |  | 49597 | // Converter (dnn_DictValue)
| 49646 |  |  | 49598 |
| 49647 | template<> |  | 49599 | template<>
| 49648 | struct PyOpenCV_Converter< Ptr<cv::dnn::DictValue> > |  | 49600 | struct PyOpenCV_Converter< Ptr<cv::dnn::DictValue> >
| 49649 | { |  | 49601 | {
| 49650 | static PyObject* from(const Ptr<cv::dnn::DictValue>& r) |  | 49602 | static PyObject* from(const Ptr<cv::dnn::DictValue>& r)
| 49651 | { |  | 49603 | {
| 49652 | return pyopencv_dnn_DictValue_Instance(r); |  | 49604 | return pyopencv_dnn_DictValue_Instance(r);
| 49653 | } |  | 49605 | }
| 49654 | static bool to(PyObject* src, Ptr<cv::dnn::DictValue>& dst, const ArgInfo& info) |  | 49606 | static bool to(PyObject* src, Ptr<cv::dnn::DictValue>& dst, const ArgInfo& info)
| 49655 | { |  | 49607 | {
| 49656 | if(!src || src == Py_None) |  | 49608 | if(!src || src == Py_None)
| 49657 | return true; |  | 49609 | return true;
| 49658 | Ptr<cv::dnn::DictValue> * dst_; |  | 49610 | Ptr<cv::dnn::DictValue> * dst_;
| 49659 | if (pyopencv_dnn_DictValue_getp(src, dst_)) |  | 49611 | if (pyopencv_dnn_DictValue_getp(src, dst_))
| 49660 | { |  | 49612 | {
| 49661 | dst = *dst_; |  | 49613 | dst = *dst_;
| 49662 | return true; |  | 49614 | return true;
| 49663 | } |  | 49615 | }
| 49664 |  |  | 49616 |
| 49665 | failmsg("Expected Ptr<cv::dnn::DictValue> for argument '%s'", info.name); |  | 49617 | failmsg("Expected Ptr<cv::dnn::DictValue> for argument '%s'", info.name);
| 49666 | return false; |  | 49618 | return false;
| 49667 | } |  | 49619 | }
| 49668 | }; |  | 49620 | };
| 49669 |  |  | 49621 |
| 49670 | //================================================================================ |  | 49622 | //================================================================================
| 49671 | // dnn_Image2BlobParams (Generic) |  | 49623 | // dnn_Image2BlobParams (Generic)
| 49672 | //================================================================================ |  | 49624 | //================================================================================
| 49673 |  |  | 49625 |
| 49674 | // GetSet (dnn_Image2BlobParams) |  | 49626 | // GetSet (dnn_Image2BlobParams)
| 49675 |  |  | 49627 |
| 49676 |  |  | 49628 |
| 49677 | static PyObject* pyopencv_dnn_Image2BlobParams_get_borderValue(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49629 | static PyObject* pyopencv_dnn_Image2BlobParams_get_borderValue(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49678 | { |  | 49630 | {
| 49679 | return pyopencv_from(p->v.borderValue); |  | 49631 | return pyopencv_from(p->v.borderValue);
| 49680 | } |  | 49632 | }
| 49681 |  |  | 49633 |
| 49682 | static int pyopencv_dnn_Image2BlobParams_set_borderValue(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49634 | static int pyopencv_dnn_Image2BlobParams_set_borderValue(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49683 | { |  | 49635 | {
| 49684 | if (!value) |  | 49636 | if (!value)
| 49685 | { |  | 49637 | {
| 49686 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderValue attribute"); |  | 49638 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderValue attribute");
| 49687 | return -1; |  | 49639 | return -1;
| 49688 | } |  | 49640 | }
| 49689 | return pyopencv_to_safe(value, p->v.borderValue, ArgInfo("value", 0)) ? 0 : -1; |  | 49641 | return pyopencv_to_safe(value, p->v.borderValue, ArgInfo("value", 0)) ? 0 : -1;
| 49690 | } |  | 49642 | }
| 49691 |  |  | 49643 |
| 49692 | static PyObject* pyopencv_dnn_Image2BlobParams_get_datalayout(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49644 | static PyObject* pyopencv_dnn_Image2BlobParams_get_datalayout(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49693 | { |  | 49645 | {
| 49694 | return pyopencv_from(p->v.datalayout); |  | 49646 | return pyopencv_from(p->v.datalayout);
| 49695 | } |  | 49647 | }
| 49696 |  |  | 49648 |
| 49697 | static int pyopencv_dnn_Image2BlobParams_set_datalayout(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49649 | static int pyopencv_dnn_Image2BlobParams_set_datalayout(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49698 | { |  | 49650 | {
| 49699 | if (!value) |  | 49651 | if (!value)
| 49700 | { |  | 49652 | {
| 49701 | PyErr_SetString(PyExc_TypeError, "Cannot delete the datalayout attribute"); |  | 49653 | PyErr_SetString(PyExc_TypeError, "Cannot delete the datalayout attribute");
| 49702 | return -1; |  | 49654 | return -1;
| 49703 | } |  | 49655 | }
| 49704 | return pyopencv_to_safe(value, p->v.datalayout, ArgInfo("value", 0)) ? 0 : -1; |  | 49656 | return pyopencv_to_safe(value, p->v.datalayout, ArgInfo("value", 0)) ? 0 : -1;
| 49705 | } |  | 49657 | }
| 49706 |  |  | 49658 |
| 49707 | static PyObject* pyopencv_dnn_Image2BlobParams_get_ddepth(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49659 | static PyObject* pyopencv_dnn_Image2BlobParams_get_ddepth(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49708 | { |  | 49660 | {
| 49709 | return pyopencv_from(p->v.ddepth); |  | 49661 | return pyopencv_from(p->v.ddepth);
| 49710 | } |  | 49662 | }
| 49711 |  |  | 49663 |
| 49712 | static int pyopencv_dnn_Image2BlobParams_set_ddepth(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49664 | static int pyopencv_dnn_Image2BlobParams_set_ddepth(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49713 | { |  | 49665 | {
| 49714 | if (!value) |  | 49666 | if (!value)
| 49715 | { |  | 49667 | {
| 49716 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ddepth attribute"); |  | 49668 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ddepth attribute");
| 49717 | return -1; |  | 49669 | return -1;
| 49718 | } |  | 49670 | }
| 49719 | return pyopencv_to_safe(value, p->v.ddepth, ArgInfo("value", 0)) ? 0 : -1; |  | 49671 | return pyopencv_to_safe(value, p->v.ddepth, ArgInfo("value", 0)) ? 0 : -1;
| 49720 | } |  | 49672 | }
| 49721 |  |  | 49673 |
| 49722 | static PyObject* pyopencv_dnn_Image2BlobParams_get_mean(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49674 | static PyObject* pyopencv_dnn_Image2BlobParams_get_mean(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49723 | { |  | 49675 | {
| 49724 | return pyopencv_from(p->v.mean); |  | 49676 | return pyopencv_from(p->v.mean);
| 49725 | } |  | 49677 | }
| 49726 |  |  | 49678 |
| 49727 | static int pyopencv_dnn_Image2BlobParams_set_mean(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49679 | static int pyopencv_dnn_Image2BlobParams_set_mean(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49728 | { |  | 49680 | {
| 49729 | if (!value) |  | 49681 | if (!value)
| 49730 | { |  | 49682 | {
| 49731 | PyErr_SetString(PyExc_TypeError, "Cannot delete the mean attribute"); |  | 49683 | PyErr_SetString(PyExc_TypeError, "Cannot delete the mean attribute");
| 49732 | return -1; |  | 49684 | return -1;
| 49733 | } |  | 49685 | }
| 49734 | return pyopencv_to_safe(value, p->v.mean, ArgInfo("value", 0)) ? 0 : -1; |  | 49686 | return pyopencv_to_safe(value, p->v.mean, ArgInfo("value", 0)) ? 0 : -1;
| 49735 | } |  | 49687 | }
| 49736 |  |  | 49688 |
| 49737 | static PyObject* pyopencv_dnn_Image2BlobParams_get_paddingmode(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49689 | static PyObject* pyopencv_dnn_Image2BlobParams_get_paddingmode(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49738 | { |  | 49690 | {
| 49739 | return pyopencv_from(p->v.paddingmode); |  | 49691 | return pyopencv_from(p->v.paddingmode);
| 49740 | } |  | 49692 | }
| 49741 |  |  | 49693 |
| 49742 | static int pyopencv_dnn_Image2BlobParams_set_paddingmode(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49694 | static int pyopencv_dnn_Image2BlobParams_set_paddingmode(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49743 | { |  | 49695 | {
| 49744 | if (!value) |  | 49696 | if (!value)
| 49745 | { |  | 49697 | {
| 49746 | PyErr_SetString(PyExc_TypeError, "Cannot delete the paddingmode attribute"); |  | 49698 | PyErr_SetString(PyExc_TypeError, "Cannot delete the paddingmode attribute");
| 49747 | return -1; |  | 49699 | return -1;
| 49748 | } |  | 49700 | }
| 49749 | return pyopencv_to_safe(value, p->v.paddingmode, ArgInfo("value", 0)) ? 0 : -1; |  | 49701 | return pyopencv_to_safe(value, p->v.paddingmode, ArgInfo("value", 0)) ? 0 : -1;
| 49750 | } |  | 49702 | }
| 49751 |  |  | 49703 |
| 49752 | static PyObject* pyopencv_dnn_Image2BlobParams_get_scalefactor(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49704 | static PyObject* pyopencv_dnn_Image2BlobParams_get_scalefactor(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49753 | { |  | 49705 | {
| 49754 | return pyopencv_from(p->v.scalefactor); |  | 49706 | return pyopencv_from(p->v.scalefactor);
| 49755 | } |  | 49707 | }
| 49756 |  |  | 49708 |
| 49757 | static int pyopencv_dnn_Image2BlobParams_set_scalefactor(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49709 | static int pyopencv_dnn_Image2BlobParams_set_scalefactor(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49758 | { |  | 49710 | {
| 49759 | if (!value) |  | 49711 | if (!value)
| 49760 | { |  | 49712 | {
| 49761 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scalefactor attribute"); |  | 49713 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scalefactor attribute");
| 49762 | return -1; |  | 49714 | return -1;
| 49763 | } |  | 49715 | }
| 49764 | return pyopencv_to_safe(value, p->v.scalefactor, ArgInfo("value", 0)) ? 0 : -1; |  | 49716 | return pyopencv_to_safe(value, p->v.scalefactor, ArgInfo("value", 0)) ? 0 : -1;
| 49765 | } |  | 49717 | }
| 49766 |  |  | 49718 |
| 49767 | static PyObject* pyopencv_dnn_Image2BlobParams_get_size(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49719 | static PyObject* pyopencv_dnn_Image2BlobParams_get_size(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49768 | { |  | 49720 | {
| 49769 | return pyopencv_from(p->v.size); |  | 49721 | return pyopencv_from(p->v.size);
| 49770 | } |  | 49722 | }
| 49771 |  |  | 49723 |
| 49772 | static int pyopencv_dnn_Image2BlobParams_set_size(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49724 | static int pyopencv_dnn_Image2BlobParams_set_size(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49773 | { |  | 49725 | {
| 49774 | if (!value) |  | 49726 | if (!value)
| 49775 | { |  | 49727 | {
| 49776 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute"); |  | 49728 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute");
| 49777 | return -1; |  | 49729 | return -1;
| 49778 | } |  | 49730 | }
| 49779 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1; |  | 49731 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1;
| 49780 | } |  | 49732 | }
| 49781 |  |  | 49733 |
| 49782 | static PyObject* pyopencv_dnn_Image2BlobParams_get_swapRB(pyopencv_dnn_Image2BlobParams_t* p, void *closure) |  | 49734 | static PyObject* pyopencv_dnn_Image2BlobParams_get_swapRB(pyopencv_dnn_Image2BlobParams_t* p, void *closure)
| 49783 | { |  | 49735 | {
| 49784 | return pyopencv_from(p->v.swapRB); |  | 49736 | return pyopencv_from(p->v.swapRB);
| 49785 | } |  | 49737 | }
| 49786 |  |  | 49738 |
| 49787 | static int pyopencv_dnn_Image2BlobParams_set_swapRB(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure) |  | 49739 | static int pyopencv_dnn_Image2BlobParams_set_swapRB(pyopencv_dnn_Image2BlobParams_t* p, PyObject *value, void *closure)
| 49788 | { |  | 49740 | {
| 49789 | if (!value) |  | 49741 | if (!value)
| 49790 | { |  | 49742 | {
| 49791 | PyErr_SetString(PyExc_TypeError, "Cannot delete the swapRB attribute"); |  | 49743 | PyErr_SetString(PyExc_TypeError, "Cannot delete the swapRB attribute");
| 49792 | return -1; |  | 49744 | return -1;
| 49793 | } |  | 49745 | }
| 49794 | return pyopencv_to_safe(value, p->v.swapRB, ArgInfo("value", 0)) ? 0 : -1; |  | 49746 | return pyopencv_to_safe(value, p->v.swapRB, ArgInfo("value", 0)) ? 0 : -1;
| 49795 | } |  | 49747 | }
| 49796 |  |  | 49748 |
| 49797 |  |  | 49749 |
| 49798 | // Methods (dnn_Image2BlobParams) |  | 49750 | // Methods (dnn_Image2BlobParams)
| 49799 |  |  | 49751 |
| 49800 | static int pyopencv_cv_dnn_dnn_Image2BlobParams_Image2BlobParams(pyopencv_dnn_Image2BlobParams_t* self, PyObject* py_args, PyObject* kw) |  | 49752 | static int pyopencv_cv_dnn_dnn_Image2BlobParams_Image2BlobParams(pyopencv_dnn_Image2BlobParams_t* self, PyObject* py_args, PyObject* kw)
| 49801 | { |  | 49753 | {
| 49802 | using namespace cv::dnn; |  | 49754 | using namespace cv::dnn;
| 49803 |  |  | 49755 |
| 49804 | pyPrepareArgumentConversionErrorsStorage(2); |  | 49756 | pyPrepareArgumentConversionErrorsStorage(2);
| 49805 |  |  | 49757 |
| 49806 | { |  | 49758 | {
| 49807 |  |  | 49759 |
| 49808 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 49760 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 49809 | { |  | 49761 | {
| 49810 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Image2BlobParams()); |  | 49762 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Image2BlobParams());
| 49811 | return 0; |  | 49763 | return 0;
| 49812 | } |  | 49764 | }
| 49813 |  |  | 49765 |
| 49814 |  |  | 49766 |
| 49815 | pyPopulateArgumentConversionErrors(); |  | 49767 | pyPopulateArgumentConversionErrors();
| 49816 | } |  | 49768 | }
| 49817 |  |  | 49769 |
| 49818 |  |  | 49770 |
| 49819 | { |  | 49771 | {
| 49820 | PyObject* pyobj_scalefactor = NULL; |  | 49772 | PyObject* pyobj_scalefactor = NULL;
| 49821 | Scalar scalefactor; |  | 49773 | Scalar scalefactor;
| 49822 | PyObject* pyobj_size = NULL; |  | 49774 | PyObject* pyobj_size = NULL;
| 49823 | Size size; |  | 49775 | Size size;
| 49824 | PyObject* pyobj_mean = NULL; |  | 49776 | PyObject* pyobj_mean = NULL;
| 49825 | Scalar mean; |  | 49777 | Scalar mean;
| 49826 | PyObject* pyobj_swapRB = NULL; |  | 49778 | PyObject* pyobj_swapRB = NULL;
| 49827 | bool swapRB=false; |  | 49779 | bool swapRB=false;
| 49828 | PyObject* pyobj_ddepth = NULL; |  | 49780 | PyObject* pyobj_ddepth = NULL;
| 49829 | int ddepth=CV_32F; |  | 49781 | int ddepth=CV_32F;
| 49830 | PyObject* pyobj_datalayout = NULL; |  | 49782 | PyObject* pyobj_datalayout = NULL;
| 49831 | dnn_DataLayout datalayout=DNN_LAYOUT_NCHW; |  | 49783 | dnn_DataLayout datalayout=DNN_LAYOUT_NCHW;
| 49832 | PyObject* pyobj_mode = NULL; |  | 49784 | PyObject* pyobj_mode = NULL;
| 49833 | ImagePaddingMode mode=dnn::DNN_PMODE_NULL; |  | 49785 | ImagePaddingMode mode=dnn::DNN_PMODE_NULL;
| 49834 | PyObject* pyobj_borderValue = NULL; |  | 49786 | PyObject* pyobj_borderValue = NULL;
| 49835 | Scalar borderValue=0.0; |  | 49787 | Scalar borderValue=0.0;
| 49836 |  |  | 49788 |
| 49837 | const char* keywords[] = { "scalefactor", "size", "mean", "swapRB", "ddepth", "datalayout", "mode", "borderValue", NULL }; |  | 49789 | const char* keywords[] = { "scalefactor", "size", "mean", "swapRB", "ddepth", "datalayout", "mode", "borderValue", NULL };
| 49838 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOOO:Image2BlobParams", (char**)keywords, &pyobj_scalefactor, &pyobj_size, &pyobj_mean, &pyobj_swapRB, &pyobj_ddepth, &pyobj_datalayout, &pyobj_mode, &pyobj_borderValue) && |  | 49790 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOOO:Image2BlobParams", (char**)keywords, &pyobj_scalefactor, &pyobj_size, &pyobj_mean, &pyobj_swapRB, &pyobj_ddepth, &pyobj_datalayout, &pyobj_mode, &pyobj_borderValue) &&
| 49839 | pyopencv_to_safe(pyobj_scalefactor, scalefactor, ArgInfo("scalefactor", 0)) && |  | 49791 | pyopencv_to_safe(pyobj_scalefactor, scalefactor, ArgInfo("scalefactor", 0)) &&
| 49840 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 49792 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 49841 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) && |  | 49793 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) &&
| 49842 | pyopencv_to_safe(pyobj_swapRB, swapRB, ArgInfo("swapRB", 0)) && |  | 49794 | pyopencv_to_safe(pyobj_swapRB, swapRB, ArgInfo("swapRB", 0)) &&
| 49843 | pyopencv_to_safe(pyobj_ddepth, ddepth, ArgInfo("ddepth", 0)) && |  | 49795 | pyopencv_to_safe(pyobj_ddepth, ddepth, ArgInfo("ddepth", 0)) &&
| 49844 | pyopencv_to_safe(pyobj_datalayout, datalayout, ArgInfo("datalayout", 0)) && |  | 49796 | pyopencv_to_safe(pyobj_datalayout, datalayout, ArgInfo("datalayout", 0)) &&
| 49845 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) && |  | 49797 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) &&
| 49846 | pyopencv_to_safe(pyobj_borderValue, borderValue, ArgInfo("borderValue", 0)) ) |  | 49798 | pyopencv_to_safe(pyobj_borderValue, borderValue, ArgInfo("borderValue", 0)) )
| 49847 | { |  | 49799 | {
| 49848 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Image2BlobParams(scalefactor, size, mean, swapRB, ddepth, datalayout, mode, borderValue)); |  | 49800 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Image2BlobParams(scalefactor, size, mean, swapRB, ddepth, datalayout, mode, borderValue));
| 49849 | return 0; |  | 49801 | return 0;
| 49850 | } |  | 49802 | }
| 49851 |  |  | 49803 |
| 49852 |  |  | 49804 |
| 49853 | pyPopulateArgumentConversionErrors(); |  | 49805 | pyPopulateArgumentConversionErrors();
| 49854 | } |  | 49806 | }
| 49855 | pyRaiseCVOverloadException("Image2BlobParams"); |  | 49807 | pyRaiseCVOverloadException("Image2BlobParams");
| 49856 |  |  | 49808 |
| 49857 | return -1; |  | 49809 | return -1;
| 49858 | } |  | 49810 | }
| 49859 |  |  | 49811 |
| 49860 | static PyObject* pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectToImageRect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49812 | static PyObject* pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectToImageRect(PyObject* self, PyObject* py_args, PyObject* kw)
| 49861 | { |  | 49813 | {
| 49862 | using namespace cv::dnn; |  | 49814 | using namespace cv::dnn;
| 49863 |  |  | 49815 |
| 49864 |  |  | 49816 |
| 49865 | cv::dnn::Image2BlobParams * self1 = 0; |  | 49817 | cv::dnn::Image2BlobParams * self1 = 0;
| 49866 | if (!pyopencv_dnn_Image2BlobParams_getp(self, self1)) |  | 49818 | if (!pyopencv_dnn_Image2BlobParams_getp(self, self1))
| 49867 | return failmsgp("Incorrect type of self (must be 'dnn_Image2BlobParams' or its derivative)"); |  | 49819 | return failmsgp("Incorrect type of self (must be 'dnn_Image2BlobParams' or its derivative)");
| 49868 | cv::dnn::Image2BlobParams* _self_ = (self1); |  | 49820 | cv::dnn::Image2BlobParams* _self_ = (self1);
| 49869 | PyObject* pyobj_rBlob = NULL; |  | 49821 | PyObject* pyobj_rBlob = NULL;
| 49870 | Rect rBlob; |  | 49822 | Rect rBlob;
| 49871 | PyObject* pyobj_size = NULL; |  | 49823 | PyObject* pyobj_size = NULL;
| 49872 | Size size; |  | 49824 | Size size;
| 49873 | Rect retval; |  | 49825 | Rect retval;
| 49874 |  |  | 49826 |
| 49875 | const char* keywords[] = { "rBlob", "size", NULL }; |  | 49827 | const char* keywords[] = { "rBlob", "size", NULL };
| 49876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Image2BlobParams.blobRectToImageRect", (char**)keywords, &pyobj_rBlob, &pyobj_size) && |  | 49828 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Image2BlobParams.blobRectToImageRect", (char**)keywords, &pyobj_rBlob, &pyobj_size) &&
| 49877 | pyopencv_to_safe(pyobj_rBlob, rBlob, ArgInfo("rBlob", 0)) && |  | 49829 | pyopencv_to_safe(pyobj_rBlob, rBlob, ArgInfo("rBlob", 0)) &&
| 49878 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) ) |  | 49830 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) )
| 49879 | { |  | 49831 | {
| 49880 | ERRWRAP2(retval = _self_->blobRectToImageRect(rBlob, size)); |  | 49832 | ERRWRAP2(retval = _self_->blobRectToImageRect(rBlob, size));
| 49881 | return pyopencv_from(retval); |  | 49833 | return pyopencv_from(retval);
| 49882 | } |  | 49834 | }
| 49883 |  |  | 49835 |
| 49884 | return NULL; |  | 49836 | return NULL;
| 49885 | } |  | 49837 | }
| 49886 |  |  | 49838 |
| 49887 | static PyObject* pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectsToImageRects(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49839 | static PyObject* pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectsToImageRects(PyObject* self, PyObject* py_args, PyObject* kw)
| 49888 | { |  | 49840 | {
| 49889 | using namespace cv::dnn; |  | 49841 | using namespace cv::dnn;
| 49890 |  |  | 49842 |
| 49891 |  |  | 49843 |
| 49892 | cv::dnn::Image2BlobParams * self1 = 0; |  | 49844 | cv::dnn::Image2BlobParams * self1 = 0;
| 49893 | if (!pyopencv_dnn_Image2BlobParams_getp(self, self1)) |  | 49845 | if (!pyopencv_dnn_Image2BlobParams_getp(self, self1))
| 49894 | return failmsgp("Incorrect type of self (must be 'dnn_Image2BlobParams' or its derivative)"); |  | 49846 | return failmsgp("Incorrect type of self (must be 'dnn_Image2BlobParams' or its derivative)");
| 49895 | cv::dnn::Image2BlobParams* _self_ = (self1); |  | 49847 | cv::dnn::Image2BlobParams* _self_ = (self1);
| 49896 | PyObject* pyobj_rBlob = NULL; |  | 49848 | PyObject* pyobj_rBlob = NULL;
| 49897 | vector_Rect rBlob; |  | 49849 | vector_Rect rBlob;
| 49898 | vector_Rect rImg; |  | 49850 | vector_Rect rImg;
| 49899 | PyObject* pyobj_size = NULL; |  | 49851 | PyObject* pyobj_size = NULL;
| 49900 | Size size; |  | 49852 | Size size;
| 49901 |  |  | 49853 |
| 49902 | const char* keywords[] = { "rBlob", "size", NULL }; |  | 49854 | const char* keywords[] = { "rBlob", "size", NULL };
| 49903 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Image2BlobParams.blobRectsToImageRects", (char**)keywords, &pyobj_rBlob, &pyobj_size) && |  | 49855 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Image2BlobParams.blobRectsToImageRects", (char**)keywords, &pyobj_rBlob, &pyobj_size) &&
| 49904 | pyopencv_to_safe(pyobj_rBlob, rBlob, ArgInfo("rBlob", 0)) && |  | 49856 | pyopencv_to_safe(pyobj_rBlob, rBlob, ArgInfo("rBlob", 0)) &&
| 49905 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) ) |  | 49857 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) )
| 49906 | { |  | 49858 | {
| 49907 | ERRWRAP2(_self_->blobRectsToImageRects(rBlob, rImg, size)); |  | 49859 | ERRWRAP2(_self_->blobRectsToImageRects(rBlob, rImg, size));
| 49908 | return pyopencv_from(rImg); |  | 49860 | return pyopencv_from(rImg);
| 49909 | } |  | 49861 | }
| 49910 |  |  | 49862 |
| 49911 | return NULL; |  | 49863 | return NULL;
| 49912 | } |  | 49864 | }
| 49913 |  |  | 49865 |
| 49914 |  |  | 49866 |
| 49915 |  |  | 49867 |
| 49916 | // Tables (dnn_Image2BlobParams) |  | 49868 | // Tables (dnn_Image2BlobParams)
| 49917 |  |  | 49869 |
| 49918 | static PyGetSetDef pyopencv_dnn_Image2BlobParams_getseters[] = |  | 49870 | static PyGetSetDef pyopencv_dnn_Image2BlobParams_getseters[] =
| 49919 | { |  | 49871 | {
| 49920 | {(char*)"borderValue", (getter)pyopencv_dnn_Image2BlobParams_get_borderValue, (setter)pyopencv_dnn_Image2BlobParams_set_borderValue, (char*)"borderValue", NULL}, |  | 49872 | {(char*)"borderValue", (getter)pyopencv_dnn_Image2BlobParams_get_borderValue, (setter)pyopencv_dnn_Image2BlobParams_set_borderValue, (char*)"borderValue", NULL},
| 49921 | {(char*)"datalayout", (getter)pyopencv_dnn_Image2BlobParams_get_datalayout, (setter)pyopencv_dnn_Image2BlobParams_set_datalayout, (char*)"datalayout", NULL}, |  | 49873 | {(char*)"datalayout", (getter)pyopencv_dnn_Image2BlobParams_get_datalayout, (setter)pyopencv_dnn_Image2BlobParams_set_datalayout, (char*)"datalayout", NULL},
| 49922 | {(char*)"ddepth", (getter)pyopencv_dnn_Image2BlobParams_get_ddepth, (setter)pyopencv_dnn_Image2BlobParams_set_ddepth, (char*)"ddepth", NULL}, |  | 49874 | {(char*)"ddepth", (getter)pyopencv_dnn_Image2BlobParams_get_ddepth, (setter)pyopencv_dnn_Image2BlobParams_set_ddepth, (char*)"ddepth", NULL},
| 49923 | {(char*)"mean", (getter)pyopencv_dnn_Image2BlobParams_get_mean, (setter)pyopencv_dnn_Image2BlobParams_set_mean, (char*)"mean", NULL}, |  | 49875 | {(char*)"mean", (getter)pyopencv_dnn_Image2BlobParams_get_mean, (setter)pyopencv_dnn_Image2BlobParams_set_mean, (char*)"mean", NULL},
| 49924 | {(char*)"paddingmode", (getter)pyopencv_dnn_Image2BlobParams_get_paddingmode, (setter)pyopencv_dnn_Image2BlobParams_set_paddingmode, (char*)"paddingmode", NULL}, |  | 49876 | {(char*)"paddingmode", (getter)pyopencv_dnn_Image2BlobParams_get_paddingmode, (setter)pyopencv_dnn_Image2BlobParams_set_paddingmode, (char*)"paddingmode", NULL},
| 49925 | {(char*)"scalefactor", (getter)pyopencv_dnn_Image2BlobParams_get_scalefactor, (setter)pyopencv_dnn_Image2BlobParams_set_scalefactor, (char*)"scalefactor", NULL}, |  | 49877 | {(char*)"scalefactor", (getter)pyopencv_dnn_Image2BlobParams_get_scalefactor, (setter)pyopencv_dnn_Image2BlobParams_set_scalefactor, (char*)"scalefactor", NULL},
| 49926 | {(char*)"size", (getter)pyopencv_dnn_Image2BlobParams_get_size, (setter)pyopencv_dnn_Image2BlobParams_set_size, (char*)"size", NULL}, |  | 49878 | {(char*)"size", (getter)pyopencv_dnn_Image2BlobParams_get_size, (setter)pyopencv_dnn_Image2BlobParams_set_size, (char*)"size", NULL},
| 49927 | {(char*)"swapRB", (getter)pyopencv_dnn_Image2BlobParams_get_swapRB, (setter)pyopencv_dnn_Image2BlobParams_set_swapRB, (char*)"swapRB", NULL}, |  | 49879 | {(char*)"swapRB", (getter)pyopencv_dnn_Image2BlobParams_get_swapRB, (setter)pyopencv_dnn_Image2BlobParams_set_swapRB, (char*)"swapRB", NULL},
| 49928 | {NULL} /* Sentinel */ |  | 49880 | {NULL} /* Sentinel */
| 49929 | }; |  | 49881 | };
| 49930 |  |  | 49882 |
| 49931 | static PyMethodDef pyopencv_dnn_Image2BlobParams_methods[] = |  | 49883 | static PyMethodDef pyopencv_dnn_Image2BlobParams_methods[] =
| 49932 | { |  | 49884 | {
| 49933 | {"blobRectToImageRect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectToImageRect, 0), "blobRectToImageRect(rBlob, size) -> retval\n. @brief Get rectangle coordinates in original image system from rectangle in blob coordinates.\n. * @param rBlob rect in blob coordinates.\n. * @param size original input image size.\n. * @returns rectangle in original image coordinates."}, |  | 49885 | {"blobRectToImageRect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectToImageRect, 0), "blobRectToImageRect(rBlob, size) -> retval\n. @brief Get rectangle coordinates in original image system from rectangle in blob coordinates.\n. * @param rBlob rect in blob coordinates.\n. * @param size original input image size.\n. * @returns rectangle in original image coordinates."},
| 49934 | {"blobRectsToImageRects", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectsToImageRects, 0), "blobRectsToImageRects(rBlob, size) -> rImg\n. @brief Get rectangle coordinates in original image system from rectangle in blob coordinates.\n. * @param rBlob rect in blob coordinates.\n. * @param rImg result rect in image coordinates.\n. * @param size original input image size."}, |  | 49886 | {"blobRectsToImageRects", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Image2BlobParams_blobRectsToImageRects, 0), "blobRectsToImageRects(rBlob, size) -> rImg\n. @brief Get rectangle coordinates in original image system from rectangle in blob coordinates.\n. * @param rBlob rect in blob coordinates.\n. * @param rImg result rect in image coordinates.\n. * @param size original input image size."},
| 49935 |  |  | 49887 |
| 49936 | {NULL, NULL} |  | 49888 | {NULL, NULL}
| 49937 | }; |  | 49889 | };
| 49938 |  |  | 49890 |
| 49939 | // Converter (dnn_Image2BlobParams) |  | 49891 | // Converter (dnn_Image2BlobParams)
| 49940 |  |  | 49892 |
| 49941 | template<> |  | 49893 | template<>
| 49942 | struct PyOpenCV_Converter< cv::dnn::Image2BlobParams > |  | 49894 | struct PyOpenCV_Converter< cv::dnn::Image2BlobParams >
| 49943 | { |  | 49895 | {
| 49944 | static PyObject* from(const cv::dnn::Image2BlobParams& r) |  | 49896 | static PyObject* from(const cv::dnn::Image2BlobParams& r)
| 49945 | { |  | 49897 | {
| 49946 | return pyopencv_dnn_Image2BlobParams_Instance(r); |  | 49898 | return pyopencv_dnn_Image2BlobParams_Instance(r);
| 49947 | } |  | 49899 | }
| 49948 | static bool to(PyObject* src, cv::dnn::Image2BlobParams& dst, const ArgInfo& info) |  | 49900 | static bool to(PyObject* src, cv::dnn::Image2BlobParams& dst, const ArgInfo& info)
| 49949 | { |  | 49901 | {
| 49950 | if(!src || src == Py_None) |  | 49902 | if(!src || src == Py_None)
| 49951 | return true; |  | 49903 | return true;
| 49952 | cv::dnn::Image2BlobParams * dst_; |  | 49904 | cv::dnn::Image2BlobParams * dst_;
| 49953 | if (pyopencv_dnn_Image2BlobParams_getp(src, dst_)) |  | 49905 | if (pyopencv_dnn_Image2BlobParams_getp(src, dst_))
| 49954 | { |  | 49906 | {
| 49955 | dst = *dst_; |  | 49907 | dst = *dst_;
| 49956 | return true; |  | 49908 | return true;
| 49957 | } |  | 49909 | }
| 49958 |  |  | 49910 |
| 49959 | failmsg("Expected cv::dnn::Image2BlobParams for argument '%s'", info.name); |  | 49911 | failmsg("Expected cv::dnn::Image2BlobParams for argument '%s'", info.name);
| 49960 | return false; |  | 49912 | return false;
| 49961 | } |  | 49913 | }
| 49962 | }; |  | 49914 | };
| 49963 |  |  | 49915 |
| 49964 | //================================================================================ |  | 49916 | //================================================================================
| 49965 | // dnn_KeypointsModel (Generic) |  | 49917 | // dnn_KeypointsModel (Generic)
| 49966 | //================================================================================ |  | 49918 | //================================================================================
| 49967 |  |  | 49919 |
| 49968 | // GetSet (dnn_KeypointsModel) |  | 49920 | // GetSet (dnn_KeypointsModel)
| 49969 |  |  | 49921 |
| 49970 |  |  | 49922 |
| 49971 |  |  | 49923 |
| 49972 | // Methods (dnn_KeypointsModel) |  | 49924 | // Methods (dnn_KeypointsModel)
| 49973 |  |  | 49925 |
| 49974 | static int pyopencv_cv_dnn_dnn_KeypointsModel_KeypointsModel(pyopencv_dnn_KeypointsModel_t* self, PyObject* py_args, PyObject* kw) |  | 49926 | static int pyopencv_cv_dnn_dnn_KeypointsModel_KeypointsModel(pyopencv_dnn_KeypointsModel_t* self, PyObject* py_args, PyObject* kw)
| 49975 | { |  | 49927 | {
| 49976 | using namespace cv::dnn; |  | 49928 | using namespace cv::dnn;
| 49977 |  |  | 49929 |
| 49978 | pyPrepareArgumentConversionErrorsStorage(2); |  | 49930 | pyPrepareArgumentConversionErrorsStorage(2);
| 49979 |  |  | 49931 |
| 49980 | { |  | 49932 | {
| 49981 | PyObject* pyobj_model = NULL; |  | 49933 | PyObject* pyobj_model = NULL;
| 49982 | String model; |  | 49934 | String model;
| 49983 | PyObject* pyobj_config = NULL; |  | 49935 | PyObject* pyobj_config = NULL;
| 49984 | String config=""; |  | 49936 | String config="";
| 49985 |  |  | 49937 |
| 49986 | const char* keywords[] = { "model", "config", NULL }; |  | 49938 | const char* keywords[] = { "model", "config", NULL };
| 49987 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:KeypointsModel", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 49939 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:KeypointsModel", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 49988 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 49940 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 49989 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 49941 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 49990 | { |  | 49942 | {
| 49991 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::KeypointsModel(model, config)); |  | 49943 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::KeypointsModel(model, config));
| 49992 | return 0; |  | 49944 | return 0;
| 49993 | } |  | 49945 | }
| 49994 |  |  | 49946 |
| 49995 |  |  | 49947 |
| 49996 | pyPopulateArgumentConversionErrors(); |  | 49948 | pyPopulateArgumentConversionErrors();
| 49997 | } |  | 49949 | }
| 49998 |  |  | 49950 |
| 49999 |  |  | 49951 |
| 50000 | { |  | 49952 | {
| 50001 | PyObject* pyobj_network = NULL; |  | 49953 | PyObject* pyobj_network = NULL;
| 50002 | Net network; |  | 49954 | Net network;
| 50003 |  |  | 49955 |
| 50004 | const char* keywords[] = { "network", NULL }; |  | 49956 | const char* keywords[] = { "network", NULL };
| 50005 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KeypointsModel", (char**)keywords, &pyobj_network) && |  | 49957 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:KeypointsModel", (char**)keywords, &pyobj_network) &&
| 50006 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 49958 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 50007 | { |  | 49959 | {
| 50008 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::KeypointsModel(network)); |  | 49960 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::KeypointsModel(network));
| 50009 | return 0; |  | 49961 | return 0;
| 50010 | } |  | 49962 | }
| 50011 |  |  | 49963 |
| 50012 |  |  | 49964 |
| 50013 | pyPopulateArgumentConversionErrors(); |  | 49965 | pyPopulateArgumentConversionErrors();
| 50014 | } |  | 49966 | }
| 50015 | pyRaiseCVOverloadException("KeypointsModel"); |  | 49967 | pyRaiseCVOverloadException("KeypointsModel");
| 50016 |  |  | 49968 |
| 50017 | return -1; |  | 49969 | return -1;
| 50018 | } |  | 49970 | }
| 50019 |  |  | 49971 |
| 50020 | static PyObject* pyopencv_cv_dnn_dnn_KeypointsModel_estimate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 49972 | static PyObject* pyopencv_cv_dnn_dnn_KeypointsModel_estimate(PyObject* self, PyObject* py_args, PyObject* kw)
| 50021 | { |  | 49973 | {
| 50022 | using namespace cv::dnn; |  | 49974 | using namespace cv::dnn;
| 50023 |  |  | 49975 |
| 50024 |  |  | 49976 |
| 50025 | cv::dnn::KeypointsModel * self1 = 0; |  | 49977 | cv::dnn::KeypointsModel * self1 = 0;
| 50026 | if (!pyopencv_dnn_KeypointsModel_getp(self, self1)) |  | 49978 | if (!pyopencv_dnn_KeypointsModel_getp(self, self1))
| 50027 | return failmsgp("Incorrect type of self (must be 'dnn_KeypointsModel' or its derivative)"); |  | 49979 | return failmsgp("Incorrect type of self (must be 'dnn_KeypointsModel' or its derivative)");
| 50028 | cv::dnn::KeypointsModel* _self_ = (self1); |  | 49980 | cv::dnn::KeypointsModel* _self_ = (self1);
| 50029 | pyPrepareArgumentConversionErrorsStorage(2); |  | 49981 | pyPrepareArgumentConversionErrorsStorage(2);
| 50030 |  |  | 49982 |
| 50031 | { |  | 49983 | {
| 50032 | PyObject* pyobj_frame = NULL; |  | 49984 | PyObject* pyobj_frame = NULL;
| 50033 | Mat frame; |  | 49985 | Mat frame;
| 50034 | PyObject* pyobj_thresh = NULL; |  | 49986 | PyObject* pyobj_thresh = NULL;
| 50035 | float thresh=0.5; |  | 49987 | float thresh=0.5;
| 50036 | std::vector<Point2f> retval; |  | 49988 | std::vector<Point2f> retval;
| 50037 |  |  | 49989 |
| 50038 | const char* keywords[] = { "frame", "thresh", NULL }; |  | 49990 | const char* keywords[] = { "frame", "thresh", NULL };
| 50039 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_KeypointsModel.estimate", (char**)keywords, &pyobj_frame, &pyobj_thresh) && |  | 49991 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_KeypointsModel.estimate", (char**)keywords, &pyobj_frame, &pyobj_thresh) &&
| 50040 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 49992 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 50041 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) ) |  | 49993 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) )
| 50042 | { |  | 49994 | {
| 50043 | ERRWRAP2(retval = _self_->estimate(frame, thresh)); |  | 49995 | ERRWRAP2(retval = _self_->estimate(frame, thresh));
| 50044 | return pyopencv_from(retval); |  | 49996 | return pyopencv_from(retval);
| 50045 | } |  | 49997 | }
| 50046 |  |  | 49998 |
| 50047 |  |  | 49999 |
| 50048 | pyPopulateArgumentConversionErrors(); |  | 50000 | pyPopulateArgumentConversionErrors();
| 50049 | } |  | 50001 | }
| 50050 |  |  | 50002 |
| 50051 |  |  | 50003 |
| 50052 | { |  | 50004 | {
| 50053 | PyObject* pyobj_frame = NULL; |  | 50005 | PyObject* pyobj_frame = NULL;
| 50054 | UMat frame; |  | 50006 | UMat frame;
| 50055 | PyObject* pyobj_thresh = NULL; |  | 50007 | PyObject* pyobj_thresh = NULL;
| 50056 | float thresh=0.5; |  | 50008 | float thresh=0.5;
| 50057 | std::vector<Point2f> retval; |  | 50009 | std::vector<Point2f> retval;
| 50058 |  |  | 50010 |
| 50059 | const char* keywords[] = { "frame", "thresh", NULL }; |  | 50011 | const char* keywords[] = { "frame", "thresh", NULL };
| 50060 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_KeypointsModel.estimate", (char**)keywords, &pyobj_frame, &pyobj_thresh) && |  | 50012 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_KeypointsModel.estimate", (char**)keywords, &pyobj_frame, &pyobj_thresh) &&
| 50061 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 50013 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 50062 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) ) |  | 50014 | pyopencv_to_safe(pyobj_thresh, thresh, ArgInfo("thresh", 0)) )
| 50063 | { |  | 50015 | {
| 50064 | ERRWRAP2(retval = _self_->estimate(frame, thresh)); |  | 50016 | ERRWRAP2(retval = _self_->estimate(frame, thresh));
| 50065 | return pyopencv_from(retval); |  | 50017 | return pyopencv_from(retval);
| 50066 | } |  | 50018 | }
| 50067 |  |  | 50019 |
| 50068 |  |  | 50020 |
| 50069 | pyPopulateArgumentConversionErrors(); |  | 50021 | pyPopulateArgumentConversionErrors();
| 50070 | } |  | 50022 | }
| 50071 | pyRaiseCVOverloadException("estimate"); |  | 50023 | pyRaiseCVOverloadException("estimate");
| 50072 |  |  | 50024 |
| 50073 | return NULL; |  | 50025 | return NULL;
| 50074 | } |  | 50026 | }
| 50075 |  |  | 50027 |
| 50076 |  |  | 50028 |
| 50077 |  |  | 50029 |
| 50078 | // Tables (dnn_KeypointsModel) |  | 50030 | // Tables (dnn_KeypointsModel)
| 50079 |  |  | 50031 |
| 50080 | static PyGetSetDef pyopencv_dnn_KeypointsModel_getseters[] = |  | 50032 | static PyGetSetDef pyopencv_dnn_KeypointsModel_getseters[] =
| 50081 | { |  | 50033 | {
| 50082 | {NULL} /* Sentinel */ |  | 50034 | {NULL} /* Sentinel */
| 50083 | }; |  | 50035 | };
| 50084 |  |  | 50036 |
| 50085 | static PyMethodDef pyopencv_dnn_KeypointsModel_methods[] = |  | 50037 | static PyMethodDef pyopencv_dnn_KeypointsModel_methods[] =
| 50086 | { |  | 50038 | {
| 50087 | {"estimate", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_KeypointsModel_estimate, 0), "estimate(frame[, thresh]) -> retval\n. @brief Given the @p input frame, create input blob, run net\n. * @param[in] frame The input image.\n. * @param thresh minimum confidence threshold to select a keypoint\n. * @returns a vector holding the x and y coordinates of each detected keypoint\n. *"}, |  | 50039 | {"estimate", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_KeypointsModel_estimate, 0), "estimate(frame[, thresh]) -> retval\n. @brief Given the @p input frame, create input blob, run net\n. * @param[in] frame The input image.\n. * @param thresh minimum confidence threshold to select a keypoint\n. * @returns a vector holding the x and y coordinates of each detected keypoint\n. *"},
| 50088 |  |  | 50040 |
| 50089 | {NULL, NULL} |  | 50041 | {NULL, NULL}
| 50090 | }; |  | 50042 | };
| 50091 |  |  | 50043 |
| 50092 | // Converter (dnn_KeypointsModel) |  | 50044 | // Converter (dnn_KeypointsModel)
| 50093 |  |  | 50045 |
| 50094 | template<> |  | 50046 | template<>
| 50095 | struct PyOpenCV_Converter< cv::dnn::KeypointsModel > |  | 50047 | struct PyOpenCV_Converter< cv::dnn::KeypointsModel >
| 50096 | { |  | 50048 | {
| 50097 | static PyObject* from(const cv::dnn::KeypointsModel& r) |  | 50049 | static PyObject* from(const cv::dnn::KeypointsModel& r)
| 50098 | { |  | 50050 | {
| 50099 | return pyopencv_dnn_KeypointsModel_Instance(r); |  | 50051 | return pyopencv_dnn_KeypointsModel_Instance(r);
| 50100 | } |  | 50052 | }
| 50101 | static bool to(PyObject* src, cv::dnn::KeypointsModel& dst, const ArgInfo& info) |  | 50053 | static bool to(PyObject* src, cv::dnn::KeypointsModel& dst, const ArgInfo& info)
| 50102 | { |  | 50054 | {
| 50103 | if(!src || src == Py_None) |  | 50055 | if(!src || src == Py_None)
| 50104 | return true; |  | 50056 | return true;
| 50105 | cv::dnn::KeypointsModel * dst_; |  | 50057 | cv::dnn::KeypointsModel * dst_;
| 50106 | if (pyopencv_dnn_KeypointsModel_getp(src, dst_)) |  | 50058 | if (pyopencv_dnn_KeypointsModel_getp(src, dst_))
| 50107 | { |  | 50059 | {
| 50108 | dst = *dst_; |  | 50060 | dst = *dst_;
| 50109 | return true; |  | 50061 | return true;
| 50110 | } |  | 50062 | }
| 50111 |  |  | 50063 |
| 50112 | failmsg("Expected cv::dnn::KeypointsModel for argument '%s'", info.name); |  | 50064 | failmsg("Expected cv::dnn::KeypointsModel for argument '%s'", info.name);
| 50113 | return false; |  | 50065 | return false;
| 50114 | } |  | 50066 | }
| 50115 | }; |  | 50067 | };
| 50116 |  |  | 50068 |
| 50117 | //================================================================================ |  | 50069 | //================================================================================
| 50118 | // dnn_Layer (Generic) |  | 50070 | // dnn_Layer (Generic)
| 50119 | //================================================================================ |  | 50071 | //================================================================================
| 50120 |  |  | 50072 |
| 50121 | // GetSet (dnn_Layer) |  | 50073 | // GetSet (dnn_Layer)
| 50122 |  |  | 50074 |
| 50123 |  |  | 50075 |
| 50124 | static PyObject* pyopencv_dnn_Layer_get_blobs(pyopencv_dnn_Layer_t* p, void *closure) |  | 50076 | static PyObject* pyopencv_dnn_Layer_get_blobs(pyopencv_dnn_Layer_t* p, void *closure)
| 50125 | { |  | 50077 | {
| 50126 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get()); |  | 50078 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get());
| 50127 | if (!_self_) |  | 50079 | if (!_self_)
| 50128 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)"); |  | 50080 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)");
| 50129 | return pyopencv_from(_self_->blobs); |  | 50081 | return pyopencv_from(_self_->blobs);
| 50130 | } |  | 50082 | }
| 50131 |  |  | 50083 |
| 50132 | static int pyopencv_dnn_Layer_set_blobs(pyopencv_dnn_Layer_t* p, PyObject *value, void *closure) |  | 50084 | static int pyopencv_dnn_Layer_set_blobs(pyopencv_dnn_Layer_t* p, PyObject *value, void *closure)
| 50133 | { |  | 50085 | {
| 50134 | if (!value) |  | 50086 | if (!value)
| 50135 | { |  | 50087 | {
| 50136 | PyErr_SetString(PyExc_TypeError, "Cannot delete the blobs attribute"); |  | 50088 | PyErr_SetString(PyExc_TypeError, "Cannot delete the blobs attribute");
| 50137 | return -1; |  | 50089 | return -1;
| 50138 | } |  | 50090 | }
| 50139 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get()); |  | 50091 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get());
| 50140 | if (!_self_) |  | 50092 | if (!_self_)
| 50141 | { |  | 50093 | {
| 50142 | failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)"); |  | 50094 | failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)");
| 50143 | return -1; |  | 50095 | return -1;
| 50144 | } |  | 50096 | }
| 50145 | return pyopencv_to_safe(value, _self_->blobs, ArgInfo("value", 0)) ? 0 : -1; |  | 50097 | return pyopencv_to_safe(value, _self_->blobs, ArgInfo("value", 0)) ? 0 : -1;
| 50146 | } |  | 50098 | }
| 50147 |  |  | 50099 |
| 50148 | static PyObject* pyopencv_dnn_Layer_get_name(pyopencv_dnn_Layer_t* p, void *closure) |  | 50100 | static PyObject* pyopencv_dnn_Layer_get_name(pyopencv_dnn_Layer_t* p, void *closure)
| 50149 | { |  | 50101 | {
| 50150 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get()); |  | 50102 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get());
| 50151 | if (!_self_) |  | 50103 | if (!_self_)
| 50152 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)"); |  | 50104 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)");
| 50153 | return pyopencv_from(_self_->name); |  | 50105 | return pyopencv_from(_self_->name);
| 50154 | } |  | 50106 | }
| 50155 |  |  | 50107 |
| 50156 | static PyObject* pyopencv_dnn_Layer_get_preferableTarget(pyopencv_dnn_Layer_t* p, void *closure) |  | 50108 | static PyObject* pyopencv_dnn_Layer_get_preferableTarget(pyopencv_dnn_Layer_t* p, void *closure)
| 50157 | { |  | 50109 | {
| 50158 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get()); |  | 50110 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get());
| 50159 | if (!_self_) |  | 50111 | if (!_self_)
| 50160 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)"); |  | 50112 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)");
| 50161 | return pyopencv_from(_self_->preferableTarget); |  | 50113 | return pyopencv_from(_self_->preferableTarget);
| 50162 | } |  | 50114 | }
| 50163 |  |  | 50115 |
| 50164 | static PyObject* pyopencv_dnn_Layer_get_type(pyopencv_dnn_Layer_t* p, void *closure) |  | 50116 | static PyObject* pyopencv_dnn_Layer_get_type(pyopencv_dnn_Layer_t* p, void *closure)
| 50165 | { |  | 50117 | {
| 50166 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get()); |  | 50118 | cv::dnn::Layer* _self_ = dynamic_cast<cv::dnn::Layer*>(p->v.get());
| 50167 | if (!_self_) |  | 50119 | if (!_self_)
| 50168 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)"); |  | 50120 | return failmsgp("Incorrect type of object (must be 'dnn_Layer' or its derivative)");
| 50169 | return pyopencv_from(_self_->type); |  | 50121 | return pyopencv_from(_self_->type);
| 50170 | } |  | 50122 | }
| 50171 |  |  | 50123 |
| 50172 |  |  | 50124 |
| 50173 | // Methods (dnn_Layer) |  | 50125 | // Methods (dnn_Layer)
| 50174 |  |  | 50126 |
| 50175 | static PyObject* pyopencv_cv_dnn_dnn_Layer_finalize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50127 | static PyObject* pyopencv_cv_dnn_dnn_Layer_finalize(PyObject* self, PyObject* py_args, PyObject* kw)
| 50176 | { |  | 50128 | {
| 50177 | using namespace cv::dnn; |  | 50129 | using namespace cv::dnn;
| 50178 |  |  | 50130 |
| 50179 |  |  | 50131 |
| 50180 | Ptr<cv::dnn::Layer> * self1 = 0; |  | 50132 | Ptr<cv::dnn::Layer> * self1 = 0;
| 50181 | if (!pyopencv_dnn_Layer_getp(self, self1)) |  | 50133 | if (!pyopencv_dnn_Layer_getp(self, self1))
| 50182 | return failmsgp("Incorrect type of self (must be 'dnn_Layer' or its derivative)"); |  | 50134 | return failmsgp("Incorrect type of self (must be 'dnn_Layer' or its derivative)");
| 50183 | Ptr<cv::dnn::Layer> _self_ = *(self1); |  | 50135 | Ptr<cv::dnn::Layer> _self_ = *(self1);
| 50184 | pyPrepareArgumentConversionErrorsStorage(2); |  | 50136 | pyPrepareArgumentConversionErrorsStorage(2);
| 50185 |  |  | 50137 |
| 50186 | { |  | 50138 | {
| 50187 | PyObject* pyobj_inputs = NULL; |  | 50139 | PyObject* pyobj_inputs = NULL;
| 50188 | vector_Mat inputs; |  | 50140 | vector_Mat inputs;
| 50189 | PyObject* pyobj_outputs = NULL; |  | 50141 | PyObject* pyobj_outputs = NULL;
| 50190 | vector_Mat outputs; |  | 50142 | vector_Mat outputs;
| 50191 |  |  | 50143 |
| 50192 | const char* keywords[] = { "inputs", "outputs", NULL }; |  | 50144 | const char* keywords[] = { "inputs", "outputs", NULL };
| 50193 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Layer.finalize", (char**)keywords, &pyobj_inputs, &pyobj_outputs) && |  | 50145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Layer.finalize", (char**)keywords, &pyobj_inputs, &pyobj_outputs) &&
| 50194 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) && |  | 50146 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) &&
| 50195 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) ) |  | 50147 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) )
| 50196 | { |  | 50148 | {
| 50197 | ERRWRAP2(_self_->finalize(inputs, outputs)); |  | 50149 | ERRWRAP2(_self_->finalize(inputs, outputs));
| 50198 | return pyopencv_from(outputs); |  | 50150 | return pyopencv_from(outputs);
| 50199 | } |  | 50151 | }
| 50200 |  |  | 50152 |
| 50201 |  |  | 50153 |
| 50202 | pyPopulateArgumentConversionErrors(); |  | 50154 | pyPopulateArgumentConversionErrors();
| 50203 | } |  | 50155 | }
| 50204 |  |  | 50156 |
| 50205 |  |  | 50157 |
| 50206 | { |  | 50158 | {
| 50207 | PyObject* pyobj_inputs = NULL; |  | 50159 | PyObject* pyobj_inputs = NULL;
| 50208 | vector_UMat inputs; |  | 50160 | vector_UMat inputs;
| 50209 | PyObject* pyobj_outputs = NULL; |  | 50161 | PyObject* pyobj_outputs = NULL;
| 50210 | vector_UMat outputs; |  | 50162 | vector_UMat outputs;
| 50211 |  |  | 50163 |
| 50212 | const char* keywords[] = { "inputs", "outputs", NULL }; |  | 50164 | const char* keywords[] = { "inputs", "outputs", NULL };
| 50213 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Layer.finalize", (char**)keywords, &pyobj_inputs, &pyobj_outputs) && |  | 50165 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Layer.finalize", (char**)keywords, &pyobj_inputs, &pyobj_outputs) &&
| 50214 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) && |  | 50166 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) &&
| 50215 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) ) |  | 50167 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) )
| 50216 | { |  | 50168 | {
| 50217 | ERRWRAP2(_self_->finalize(inputs, outputs)); |  | 50169 | ERRWRAP2(_self_->finalize(inputs, outputs));
| 50218 | return pyopencv_from(outputs); |  | 50170 | return pyopencv_from(outputs);
| 50219 | } |  | 50171 | }
| 50220 |  |  | 50172 |
| 50221 |  |  | 50173 |
| 50222 | pyPopulateArgumentConversionErrors(); |  | 50174 | pyPopulateArgumentConversionErrors();
| 50223 | } |  | 50175 | }
| 50224 | pyRaiseCVOverloadException("finalize"); |  | 50176 | pyRaiseCVOverloadException("finalize");
| 50225 |  |  | 50177 |
| 50226 | return NULL; |  | 50178 | return NULL;
| 50227 | } |  | 50179 | }
| 50228 |  |  | 50180 |
| 50229 | static PyObject* pyopencv_cv_dnn_dnn_Layer_outputNameToIndex(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50181 | static PyObject* pyopencv_cv_dnn_dnn_Layer_outputNameToIndex(PyObject* self, PyObject* py_args, PyObject* kw)
| 50230 | { |  | 50182 | {
| 50231 | using namespace cv::dnn; |  | 50183 | using namespace cv::dnn;
| 50232 |  |  | 50184 |
| 50233 |  |  | 50185 |
| 50234 | Ptr<cv::dnn::Layer> * self1 = 0; |  | 50186 | Ptr<cv::dnn::Layer> * self1 = 0;
| 50235 | if (!pyopencv_dnn_Layer_getp(self, self1)) |  | 50187 | if (!pyopencv_dnn_Layer_getp(self, self1))
| 50236 | return failmsgp("Incorrect type of self (must be 'dnn_Layer' or its derivative)"); |  | 50188 | return failmsgp("Incorrect type of self (must be 'dnn_Layer' or its derivative)");
| 50237 | Ptr<cv::dnn::Layer> _self_ = *(self1); |  | 50189 | Ptr<cv::dnn::Layer> _self_ = *(self1);
| 50238 | PyObject* pyobj_outputName = NULL; |  | 50190 | PyObject* pyobj_outputName = NULL;
| 50239 | String outputName; |  | 50191 | String outputName;
| 50240 | int retval; |  | 50192 | int retval;
| 50241 |  |  | 50193 |
| 50242 | const char* keywords[] = { "outputName", NULL }; |  | 50194 | const char* keywords[] = { "outputName", NULL };
| 50243 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Layer.outputNameToIndex", (char**)keywords, &pyobj_outputName) && |  | 50195 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Layer.outputNameToIndex", (char**)keywords, &pyobj_outputName) &&
| 50244 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) ) |  | 50196 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) )
| 50245 | { |  | 50197 | {
| 50246 | ERRWRAP2(retval = _self_->outputNameToIndex(outputName)); |  | 50198 | ERRWRAP2(retval = _self_->outputNameToIndex(outputName));
| 50247 | return pyopencv_from(retval); |  | 50199 | return pyopencv_from(retval);
| 50248 | } |  | 50200 | }
| 50249 |  |  | 50201 |
| 50250 | return NULL; |  | 50202 | return NULL;
| 50251 | } |  | 50203 | }
| 50252 |  |  | 50204 |
| 50253 | static PyObject* pyopencv_cv_dnn_dnn_Layer_run(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50205 | static PyObject* pyopencv_cv_dnn_dnn_Layer_run(PyObject* self, PyObject* py_args, PyObject* kw)
| 50254 | { |  | 50206 | {
| 50255 | using namespace cv::dnn; |  | 50207 | using namespace cv::dnn;
| 50256 |  |  | 50208 |
| 50257 |  |  | 50209 |
| 50258 | Ptr<cv::dnn::Layer> * self1 = 0; |  | 50210 | Ptr<cv::dnn::Layer> * self1 = 0;
| 50259 | if (!pyopencv_dnn_Layer_getp(self, self1)) |  | 50211 | if (!pyopencv_dnn_Layer_getp(self, self1))
| 50260 | return failmsgp("Incorrect type of self (must be 'dnn_Layer' or its derivative)"); |  | 50212 | return failmsgp("Incorrect type of self (must be 'dnn_Layer' or its derivative)");
| 50261 | Ptr<cv::dnn::Layer> _self_ = *(self1); |  | 50213 | Ptr<cv::dnn::Layer> _self_ = *(self1);
| 50262 | PyObject* pyobj_inputs = NULL; |  | 50214 | PyObject* pyobj_inputs = NULL;
| 50263 | vector_Mat inputs; |  | 50215 | vector_Mat inputs;
| 50264 | PyObject* pyobj_outputs = NULL; |  | 50216 | PyObject* pyobj_outputs = NULL;
| 50265 | vector_Mat outputs; |  | 50217 | vector_Mat outputs;
| 50266 | PyObject* pyobj_internals = NULL; |  | 50218 | PyObject* pyobj_internals = NULL;
| 50267 | vector_Mat internals; |  | 50219 | vector_Mat internals;
| 50268 |  |  | 50220 |
| 50269 | const char* keywords[] = { "inputs", "internals", "outputs", NULL }; |  | 50221 | const char* keywords[] = { "inputs", "internals", "outputs", NULL };
| 50270 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:dnn_Layer.run", (char**)keywords, &pyobj_inputs, &pyobj_internals, &pyobj_outputs) && |  | 50222 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:dnn_Layer.run", (char**)keywords, &pyobj_inputs, &pyobj_internals, &pyobj_outputs) &&
| 50271 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) && |  | 50223 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) &&
| 50272 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) && |  | 50224 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) &&
| 50273 | pyopencv_to_safe(pyobj_internals, internals, ArgInfo("internals", 1)) ) |  | 50225 | pyopencv_to_safe(pyobj_internals, internals, ArgInfo("internals", 1)) )
| 50274 | { |  | 50226 | {
| 50275 | ERRWRAP2(_self_->run(inputs, outputs, internals)); |  | 50227 | ERRWRAP2(_self_->run(inputs, outputs, internals));
| 50276 | return Py_BuildValue("(NN)", pyopencv_from(outputs), pyopencv_from(internals)); |  | 50228 | return Py_BuildValue("(NN)", pyopencv_from(outputs), pyopencv_from(internals));
| 50277 | } |  | 50229 | }
| 50278 |  |  | 50230 |
| 50279 | return NULL; |  | 50231 | return NULL;
| 50280 | } |  | 50232 | }
| 50281 |  |  | 50233 |
| 50282 |  |  | 50234 |
| 50283 |  |  | 50235 |
| 50284 | // Tables (dnn_Layer) |  | 50236 | // Tables (dnn_Layer)
| 50285 |  |  | 50237 |
| 50286 | static PyGetSetDef pyopencv_dnn_Layer_getseters[] = |  | 50238 | static PyGetSetDef pyopencv_dnn_Layer_getseters[] =
| 50287 | { |  | 50239 | {
| 50288 | {(char*)"blobs", (getter)pyopencv_dnn_Layer_get_blobs, (setter)pyopencv_dnn_Layer_set_blobs, (char*)"blobs", NULL}, |  | 50240 | {(char*)"blobs", (getter)pyopencv_dnn_Layer_get_blobs, (setter)pyopencv_dnn_Layer_set_blobs, (char*)"blobs", NULL},
| 50289 | {(char*)"name", (getter)pyopencv_dnn_Layer_get_name, NULL, (char*)"name", NULL}, |  | 50241 | {(char*)"name", (getter)pyopencv_dnn_Layer_get_name, NULL, (char*)"name", NULL},
| 50290 | {(char*)"preferableTarget", (getter)pyopencv_dnn_Layer_get_preferableTarget, NULL, (char*)"preferableTarget", NULL}, |  | 50242 | {(char*)"preferableTarget", (getter)pyopencv_dnn_Layer_get_preferableTarget, NULL, (char*)"preferableTarget", NULL},
| 50291 | {(char*)"type", (getter)pyopencv_dnn_Layer_get_type, NULL, (char*)"type", NULL}, |  | 50243 | {(char*)"type", (getter)pyopencv_dnn_Layer_get_type, NULL, (char*)"type", NULL},
| 50292 | {NULL} /* Sentinel */ |  | 50244 | {NULL} /* Sentinel */
| 50293 | }; |  | 50245 | };
| 50294 |  |  | 50246 |
| 50295 | static PyMethodDef pyopencv_dnn_Layer_methods[] = |  | 50247 | static PyMethodDef pyopencv_dnn_Layer_methods[] =
| 50296 | { |  | 50248 | {
| 50297 | {"finalize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Layer_finalize, 0), "finalize(inputs[, outputs]) -> outputs\n. @brief Computes and sets internal parameters according to inputs, outputs and blobs.\n. * @param[in] inputs vector of already allocated input blobs\n. * @param[out] outputs vector of already allocated output blobs\n. *\n. * This method is called after network has allocated all memory for input and output blobs\n. * and before inferencing."}, |  | 50249 | {"finalize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Layer_finalize, 0), "finalize(inputs[, outputs]) -> outputs\n. @brief Computes and sets internal parameters according to inputs, outputs and blobs.\n. * @param[in] inputs vector of already allocated input blobs\n. * @param[out] outputs vector of already allocated output blobs\n. *\n. * This method is called after network has allocated all memory for input and output blobs\n. * and before inferencing."},
| 50298 | {"outputNameToIndex", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Layer_outputNameToIndex, 0), "outputNameToIndex(outputName) -> retval\n. @brief Returns index of output blob in output array.\n. * @see inputNameToIndex()"}, |  | 50250 | {"outputNameToIndex", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Layer_outputNameToIndex, 0), "outputNameToIndex(outputName) -> retval\n. @brief Returns index of output blob in output array.\n. * @see inputNameToIndex()"},
| 50299 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Layer_run, 0), "run(inputs, internals[, outputs]) -> outputs, internals\n. @brief Allocates layer and computes output.\n. * @deprecated This method will be removed in the future release."}, |  | 50251 | {"run", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Layer_run, 0), "run(inputs, internals[, outputs]) -> outputs, internals\n. @brief Allocates layer and computes output.\n. * @deprecated This method will be removed in the future release."},
| 50300 |  |  | 50252 |
| 50301 | {NULL, NULL} |  | 50253 | {NULL, NULL}
| 50302 | }; |  | 50254 | };
| 50303 |  |  | 50255 |
| 50304 | // Converter (dnn_Layer) |  | 50256 | // Converter (dnn_Layer)
| 50305 |  |  | 50257 |
| 50306 | template<> |  | 50258 | template<>
| 50307 | struct PyOpenCV_Converter< Ptr<cv::dnn::Layer> > |  | 50259 | struct PyOpenCV_Converter< Ptr<cv::dnn::Layer> >
| 50308 | { |  | 50260 | {
| 50309 | static PyObject* from(const Ptr<cv::dnn::Layer>& r) |  | 50261 | static PyObject* from(const Ptr<cv::dnn::Layer>& r)
| 50310 | { |  | 50262 | {
| 50311 | return pyopencv_dnn_Layer_Instance(r); |  | 50263 | return pyopencv_dnn_Layer_Instance(r);
| 50312 | } |  | 50264 | }
| 50313 | static bool to(PyObject* src, Ptr<cv::dnn::Layer>& dst, const ArgInfo& info) |  | 50265 | static bool to(PyObject* src, Ptr<cv::dnn::Layer>& dst, const ArgInfo& info)
| 50314 | { |  | 50266 | {
| 50315 | if(!src || src == Py_None) |  | 50267 | if(!src || src == Py_None)
| 50316 | return true; |  | 50268 | return true;
| 50317 | Ptr<cv::dnn::Layer> * dst_; |  | 50269 | Ptr<cv::dnn::Layer> * dst_;
| 50318 | if (pyopencv_dnn_Layer_getp(src, dst_)) |  | 50270 | if (pyopencv_dnn_Layer_getp(src, dst_))
| 50319 | { |  | 50271 | {
| 50320 | dst = *dst_; |  | 50272 | dst = *dst_;
| 50321 | return true; |  | 50273 | return true;
| 50322 | } |  | 50274 | }
| 50323 |  |  | 50275 |
| 50324 | failmsg("Expected Ptr<cv::dnn::Layer> for argument '%s'", info.name); |  | 50276 | failmsg("Expected Ptr<cv::dnn::Layer> for argument '%s'", info.name);
| 50325 | return false; |  | 50277 | return false;
| 50326 | } |  | 50278 | }
| 50327 | }; |  | 50279 | };
| 50328 |  |  | 50280 |
| 50329 | //================================================================================ |  | 50281 | //================================================================================
| 50330 | // dnn_Model (Generic) |  | 50282 | // dnn_Model (Generic)
| 50331 | //================================================================================ |  | 50283 | //================================================================================
| 50332 |  |  | 50284 |
| 50333 | // GetSet (dnn_Model) |  | 50285 | // GetSet (dnn_Model)
| 50334 |  |  | 50286 |
| 50335 |  |  | 50287 |
| 50336 |  |  | 50288 |
| 50337 | // Methods (dnn_Model) |  | 50289 | // Methods (dnn_Model)
| 50338 |  |  | 50290 |
| 50339 | static int pyopencv_cv_dnn_dnn_Model_Model(pyopencv_dnn_Model_t* self, PyObject* py_args, PyObject* kw) |  | 50291 | static int pyopencv_cv_dnn_dnn_Model_Model(pyopencv_dnn_Model_t* self, PyObject* py_args, PyObject* kw)
| 50340 | { |  | 50292 | {
| 50341 | using namespace cv::dnn; |  | 50293 | using namespace cv::dnn;
| 50342 |  |  | 50294 |
| 50343 | pyPrepareArgumentConversionErrorsStorage(2); |  | 50295 | pyPrepareArgumentConversionErrorsStorage(2);
| 50344 |  |  | 50296 |
| 50345 | { |  | 50297 | {
| 50346 | PyObject* pyobj_model = NULL; |  | 50298 | PyObject* pyobj_model = NULL;
| 50347 | String model; |  | 50299 | String model;
| 50348 | PyObject* pyobj_config = NULL; |  | 50300 | PyObject* pyobj_config = NULL;
| 50349 | String config=""; |  | 50301 | String config="";
| 50350 |  |  | 50302 |
| 50351 | const char* keywords[] = { "model", "config", NULL }; |  | 50303 | const char* keywords[] = { "model", "config", NULL };
| 50352 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Model", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 50304 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:Model", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 50353 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 50305 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 50354 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 50306 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 50355 | { |  | 50307 | {
| 50356 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Model(model, config)); |  | 50308 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Model(model, config));
| 50357 | return 0; |  | 50309 | return 0;
| 50358 | } |  | 50310 | }
| 50359 |  |  | 50311 |
| 50360 |  |  | 50312 |
| 50361 | pyPopulateArgumentConversionErrors(); |  | 50313 | pyPopulateArgumentConversionErrors();
| 50362 | } |  | 50314 | }
| 50363 |  |  | 50315 |
| 50364 |  |  | 50316 |
| 50365 | { |  | 50317 | {
| 50366 | PyObject* pyobj_network = NULL; |  | 50318 | PyObject* pyobj_network = NULL;
| 50367 | Net network; |  | 50319 | Net network;
| 50368 |  |  | 50320 |
| 50369 | const char* keywords[] = { "network", NULL }; |  | 50321 | const char* keywords[] = { "network", NULL };
| 50370 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Model", (char**)keywords, &pyobj_network) && |  | 50322 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Model", (char**)keywords, &pyobj_network) &&
| 50371 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 50323 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 50372 | { |  | 50324 | {
| 50373 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Model(network)); |  | 50325 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Model(network));
| 50374 | return 0; |  | 50326 | return 0;
| 50375 | } |  | 50327 | }
| 50376 |  |  | 50328 |
| 50377 |  |  | 50329 |
| 50378 | pyPopulateArgumentConversionErrors(); |  | 50330 | pyPopulateArgumentConversionErrors();
| 50379 | } |  | 50331 | }
| 50380 | pyRaiseCVOverloadException("Model"); |  | 50332 | pyRaiseCVOverloadException("Model");
| 50381 |  |  | 50333 |
| 50382 | return -1; |  | 50334 | return -1;
| 50383 | } |  | 50335 | }
| 50384 |  |  | 50336 |
| 50385 | static PyObject* pyopencv_cv_dnn_dnn_Model_enableWinograd(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50337 | static PyObject* pyopencv_cv_dnn_dnn_Model_enableWinograd(PyObject* self, PyObject* py_args, PyObject* kw)
| 50386 | { |  | 50338 | {
| 50387 | using namespace cv::dnn; |  | 50339 | using namespace cv::dnn;
| 50388 |  |  | 50340 |
| 50389 |  |  | 50341 |
| 50390 | cv::dnn::Model * self1 = 0; |  | 50342 | cv::dnn::Model * self1 = 0;
| 50391 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50343 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50392 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50344 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50393 | cv::dnn::Model* _self_ = (self1); |  | 50345 | cv::dnn::Model* _self_ = (self1);
| 50394 | PyObject* pyobj_useWinograd = NULL; |  | 50346 | PyObject* pyobj_useWinograd = NULL;
| 50395 | bool useWinograd=0; |  | 50347 | bool useWinograd=0;
| 50396 | Model retval; |  | 50348 | Model retval;
| 50397 |  |  | 50349 |
| 50398 | const char* keywords[] = { "useWinograd", NULL }; |  | 50350 | const char* keywords[] = { "useWinograd", NULL };
| 50399 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.enableWinograd", (char**)keywords, &pyobj_useWinograd) && |  | 50351 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.enableWinograd", (char**)keywords, &pyobj_useWinograd) &&
| 50400 | pyopencv_to_safe(pyobj_useWinograd, useWinograd, ArgInfo("useWinograd", 0)) ) |  | 50352 | pyopencv_to_safe(pyobj_useWinograd, useWinograd, ArgInfo("useWinograd", 0)) )
| 50401 | { |  | 50353 | {
| 50402 | ERRWRAP2(retval = _self_->enableWinograd(useWinograd)); |  | 50354 | ERRWRAP2(retval = _self_->enableWinograd(useWinograd));
| 50403 | return pyopencv_from(retval); |  | 50355 | return pyopencv_from(retval);
| 50404 | } |  | 50356 | }
| 50405 |  |  | 50357 |
| 50406 | return NULL; |  | 50358 | return NULL;
| 50407 | } |  | 50359 | }
| 50408 |  |  | 50360 |
| 50409 | static PyObject* pyopencv_cv_dnn_dnn_Model_predict(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50361 | static PyObject* pyopencv_cv_dnn_dnn_Model_predict(PyObject* self, PyObject* py_args, PyObject* kw)
| 50410 | { |  | 50362 | {
| 50411 | using namespace cv::dnn; |  | 50363 | using namespace cv::dnn;
| 50412 |  |  | 50364 |
| 50413 |  |  | 50365 |
| 50414 | cv::dnn::Model * self1 = 0; |  | 50366 | cv::dnn::Model * self1 = 0;
| 50415 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50367 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50416 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50368 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50417 | cv::dnn::Model* _self_ = (self1); |  | 50369 | cv::dnn::Model* _self_ = (self1);
| 50418 | pyPrepareArgumentConversionErrorsStorage(2); |  | 50370 | pyPrepareArgumentConversionErrorsStorage(2);
| 50419 |  |  | 50371 |
| 50420 | { |  | 50372 | {
| 50421 | PyObject* pyobj_frame = NULL; |  | 50373 | PyObject* pyobj_frame = NULL;
| 50422 | Mat frame; |  | 50374 | Mat frame;
| 50423 | PyObject* pyobj_outs = NULL; |  | 50375 | PyObject* pyobj_outs = NULL;
| 50424 | vector_Mat outs; |  | 50376 | vector_Mat outs;
| 50425 |  |  | 50377 |
| 50426 | const char* keywords[] = { "frame", "outs", NULL }; |  | 50378 | const char* keywords[] = { "frame", "outs", NULL };
| 50427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Model.predict", (char**)keywords, &pyobj_frame, &pyobj_outs) && |  | 50379 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Model.predict", (char**)keywords, &pyobj_frame, &pyobj_outs) &&
| 50428 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 50380 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 50429 | pyopencv_to_safe(pyobj_outs, outs, ArgInfo("outs", 1)) ) |  | 50381 | pyopencv_to_safe(pyobj_outs, outs, ArgInfo("outs", 1)) )
| 50430 | { |  | 50382 | {
| 50431 | ERRWRAP2(_self_->predict(frame, outs)); |  | 50383 | ERRWRAP2(_self_->predict(frame, outs));
| 50432 | return pyopencv_from(outs); |  | 50384 | return pyopencv_from(outs);
| 50433 | } |  | 50385 | }
| 50434 |  |  | 50386 |
| 50435 |  |  | 50387 |
| 50436 | pyPopulateArgumentConversionErrors(); |  | 50388 | pyPopulateArgumentConversionErrors();
| 50437 | } |  | 50389 | }
| 50438 |  |  | 50390 |
| 50439 |  |  | 50391 |
| 50440 | { |  | 50392 | {
| 50441 | PyObject* pyobj_frame = NULL; |  | 50393 | PyObject* pyobj_frame = NULL;
| 50442 | UMat frame; |  | 50394 | UMat frame;
| 50443 | PyObject* pyobj_outs = NULL; |  | 50395 | PyObject* pyobj_outs = NULL;
| 50444 | vector_UMat outs; |  | 50396 | vector_UMat outs;
| 50445 |  |  | 50397 |
| 50446 | const char* keywords[] = { "frame", "outs", NULL }; |  | 50398 | const char* keywords[] = { "frame", "outs", NULL };
| 50447 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Model.predict", (char**)keywords, &pyobj_frame, &pyobj_outs) && |  | 50399 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Model.predict", (char**)keywords, &pyobj_frame, &pyobj_outs) &&
| 50448 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 50400 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 50449 | pyopencv_to_safe(pyobj_outs, outs, ArgInfo("outs", 1)) ) |  | 50401 | pyopencv_to_safe(pyobj_outs, outs, ArgInfo("outs", 1)) )
| 50450 | { |  | 50402 | {
| 50451 | ERRWRAP2(_self_->predict(frame, outs)); |  | 50403 | ERRWRAP2(_self_->predict(frame, outs));
| 50452 | return pyopencv_from(outs); |  | 50404 | return pyopencv_from(outs);
| 50453 | } |  | 50405 | }
| 50454 |  |  | 50406 |
| 50455 |  |  | 50407 |
| 50456 | pyPopulateArgumentConversionErrors(); |  | 50408 | pyPopulateArgumentConversionErrors();
| 50457 | } |  | 50409 | }
| 50458 | pyRaiseCVOverloadException("predict"); |  | 50410 | pyRaiseCVOverloadException("predict");
| 50459 |  |  | 50411 |
| 50460 | return NULL; |  | 50412 | return NULL;
| 50461 | } |  | 50413 | }
| 50462 |  |  | 50414 |
| 50463 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputCrop(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50415 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputCrop(PyObject* self, PyObject* py_args, PyObject* kw)
| 50464 | { |  | 50416 | {
| 50465 | using namespace cv::dnn; |  | 50417 | using namespace cv::dnn;
| 50466 |  |  | 50418 |
| 50467 |  |  | 50419 |
| 50468 | cv::dnn::Model * self1 = 0; |  | 50420 | cv::dnn::Model * self1 = 0;
| 50469 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50421 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50470 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50422 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50471 | cv::dnn::Model* _self_ = (self1); |  | 50423 | cv::dnn::Model* _self_ = (self1);
| 50472 | PyObject* pyobj_crop = NULL; |  | 50424 | PyObject* pyobj_crop = NULL;
| 50473 | bool crop=0; |  | 50425 | bool crop=0;
| 50474 | Model retval; |  | 50426 | Model retval;
| 50475 |  |  | 50427 |
| 50476 | const char* keywords[] = { "crop", NULL }; |  | 50428 | const char* keywords[] = { "crop", NULL };
| 50477 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputCrop", (char**)keywords, &pyobj_crop) && |  | 50429 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputCrop", (char**)keywords, &pyobj_crop) &&
| 50478 | pyopencv_to_safe(pyobj_crop, crop, ArgInfo("crop", 0)) ) |  | 50430 | pyopencv_to_safe(pyobj_crop, crop, ArgInfo("crop", 0)) )
| 50479 | { |  | 50431 | {
| 50480 | ERRWRAP2(retval = _self_->setInputCrop(crop)); |  | 50432 | ERRWRAP2(retval = _self_->setInputCrop(crop));
| 50481 | return pyopencv_from(retval); |  | 50433 | return pyopencv_from(retval);
| 50482 | } |  | 50434 | }
| 50483 |  |  | 50435 |
| 50484 | return NULL; |  | 50436 | return NULL;
| 50485 | } |  | 50437 | }
| 50486 |  |  | 50438 |
| 50487 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputMean(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50439 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputMean(PyObject* self, PyObject* py_args, PyObject* kw)
| 50488 | { |  | 50440 | {
| 50489 | using namespace cv::dnn; |  | 50441 | using namespace cv::dnn;
| 50490 |  |  | 50442 |
| 50491 |  |  | 50443 |
| 50492 | cv::dnn::Model * self1 = 0; |  | 50444 | cv::dnn::Model * self1 = 0;
| 50493 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50445 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50494 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50446 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50495 | cv::dnn::Model* _self_ = (self1); |  | 50447 | cv::dnn::Model* _self_ = (self1);
| 50496 | PyObject* pyobj_mean = NULL; |  | 50448 | PyObject* pyobj_mean = NULL;
| 50497 | Scalar mean; |  | 50449 | Scalar mean;
| 50498 | Model retval; |  | 50450 | Model retval;
| 50499 |  |  | 50451 |
| 50500 | const char* keywords[] = { "mean", NULL }; |  | 50452 | const char* keywords[] = { "mean", NULL };
| 50501 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputMean", (char**)keywords, &pyobj_mean) && |  | 50453 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputMean", (char**)keywords, &pyobj_mean) &&
| 50502 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) ) |  | 50454 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) )
| 50503 | { |  | 50455 | {
| 50504 | ERRWRAP2(retval = _self_->setInputMean(mean)); |  | 50456 | ERRWRAP2(retval = _self_->setInputMean(mean));
| 50505 | return pyopencv_from(retval); |  | 50457 | return pyopencv_from(retval);
| 50506 | } |  | 50458 | }
| 50507 |  |  | 50459 |
| 50508 | return NULL; |  | 50460 | return NULL;
| 50509 | } |  | 50461 | }
| 50510 |  |  | 50462 |
| 50511 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputParams(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50463 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputParams(PyObject* self, PyObject* py_args, PyObject* kw)
| 50512 | { |  | 50464 | {
| 50513 | using namespace cv::dnn; |  | 50465 | using namespace cv::dnn;
| 50514 |  |  | 50466 |
| 50515 |  |  | 50467 |
| 50516 | cv::dnn::Model * self1 = 0; |  | 50468 | cv::dnn::Model * self1 = 0;
| 50517 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50469 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50518 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50470 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50519 | cv::dnn::Model* _self_ = (self1); |  | 50471 | cv::dnn::Model* _self_ = (self1);
| 50520 | PyObject* pyobj_scale = NULL; |  | 50472 | PyObject* pyobj_scale = NULL;
| 50521 | double scale=1.0; |  | 50473 | double scale=1.0;
| 50522 | PyObject* pyobj_size = NULL; |  | 50474 | PyObject* pyobj_size = NULL;
| 50523 | Size size; |  | 50475 | Size size;
| 50524 | PyObject* pyobj_mean = NULL; |  | 50476 | PyObject* pyobj_mean = NULL;
| 50525 | Scalar mean; |  | 50477 | Scalar mean;
| 50526 | PyObject* pyobj_swapRB = NULL; |  | 50478 | PyObject* pyobj_swapRB = NULL;
| 50527 | bool swapRB=false; |  | 50479 | bool swapRB=false;
| 50528 | PyObject* pyobj_crop = NULL; |  | 50480 | PyObject* pyobj_crop = NULL;
| 50529 | bool crop=false; |  | 50481 | bool crop=false;
| 50530 |  |  | 50482 |
| 50531 | const char* keywords[] = { "scale", "size", "mean", "swapRB", "crop", NULL }; |  | 50483 | const char* keywords[] = { "scale", "size", "mean", "swapRB", "crop", NULL };
| 50532 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:dnn_Model.setInputParams", (char**)keywords, &pyobj_scale, &pyobj_size, &pyobj_mean, &pyobj_swapRB, &pyobj_crop) && |  | 50484 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:dnn_Model.setInputParams", (char**)keywords, &pyobj_scale, &pyobj_size, &pyobj_mean, &pyobj_swapRB, &pyobj_crop) &&
| 50533 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) && |  | 50485 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) &&
| 50534 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) && |  | 50486 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) &&
| 50535 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) && |  | 50487 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) &&
| 50536 | pyopencv_to_safe(pyobj_swapRB, swapRB, ArgInfo("swapRB", 0)) && |  | 50488 | pyopencv_to_safe(pyobj_swapRB, swapRB, ArgInfo("swapRB", 0)) &&
| 50537 | pyopencv_to_safe(pyobj_crop, crop, ArgInfo("crop", 0)) ) |  | 50489 | pyopencv_to_safe(pyobj_crop, crop, ArgInfo("crop", 0)) )
| 50538 | { |  | 50490 | {
| 50539 | ERRWRAP2(_self_->setInputParams(scale, size, mean, swapRB, crop)); |  | 50491 | ERRWRAP2(_self_->setInputParams(scale, size, mean, swapRB, crop));
| 50540 | Py_RETURN_NONE; |  | 50492 | Py_RETURN_NONE;
| 50541 | } |  | 50493 | }
| 50542 |  |  | 50494 |
| 50543 | return NULL; |  | 50495 | return NULL;
| 50544 | } |  | 50496 | }
| 50545 |  |  | 50497 |
| 50546 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50498 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 50547 | { |  | 50499 | {
| 50548 | using namespace cv::dnn; |  | 50500 | using namespace cv::dnn;
| 50549 |  |  | 50501 |
| 50550 |  |  | 50502 |
| 50551 | cv::dnn::Model * self1 = 0; |  | 50503 | cv::dnn::Model * self1 = 0;
| 50552 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50504 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50553 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50505 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50554 | cv::dnn::Model* _self_ = (self1); |  | 50506 | cv::dnn::Model* _self_ = (self1);
| 50555 | PyObject* pyobj_scale = NULL; |  | 50507 | PyObject* pyobj_scale = NULL;
| 50556 | Scalar scale; |  | 50508 | Scalar scale;
| 50557 | Model retval; |  | 50509 | Model retval;
| 50558 |  |  | 50510 |
| 50559 | const char* keywords[] = { "scale", NULL }; |  | 50511 | const char* keywords[] = { "scale", NULL };
| 50560 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputScale", (char**)keywords, &pyobj_scale) && |  | 50512 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputScale", (char**)keywords, &pyobj_scale) &&
| 50561 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) ) |  | 50513 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) )
| 50562 | { |  | 50514 | {
| 50563 | ERRWRAP2(retval = _self_->setInputScale(scale)); |  | 50515 | ERRWRAP2(retval = _self_->setInputScale(scale));
| 50564 | return pyopencv_from(retval); |  | 50516 | return pyopencv_from(retval);
| 50565 | } |  | 50517 | }
| 50566 |  |  | 50518 |
| 50567 | return NULL; |  | 50519 | return NULL;
| 50568 | } |  | 50520 | }
| 50569 |  |  | 50521 |
| 50570 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50522 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 50571 | { |  | 50523 | {
| 50572 | using namespace cv::dnn; |  | 50524 | using namespace cv::dnn;
| 50573 |  |  | 50525 |
| 50574 |  |  | 50526 |
| 50575 | cv::dnn::Model * self1 = 0; |  | 50527 | cv::dnn::Model * self1 = 0;
| 50576 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50528 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50577 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50529 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50578 | cv::dnn::Model* _self_ = (self1); |  | 50530 | cv::dnn::Model* _self_ = (self1);
| 50579 | pyPrepareArgumentConversionErrorsStorage(2); |  | 50531 | pyPrepareArgumentConversionErrorsStorage(2);
| 50580 |  |  | 50532 |
| 50581 | { |  | 50533 | {
| 50582 | PyObject* pyobj_size = NULL; |  | 50534 | PyObject* pyobj_size = NULL;
| 50583 | Size size; |  | 50535 | Size size;
| 50584 | Model retval; |  | 50536 | Model retval;
| 50585 |  |  | 50537 |
| 50586 | const char* keywords[] = { "size", NULL }; |  | 50538 | const char* keywords[] = { "size", NULL };
| 50587 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputSize", (char**)keywords, &pyobj_size) && |  | 50539 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputSize", (char**)keywords, &pyobj_size) &&
| 50588 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) ) |  | 50540 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) )
| 50589 | { |  | 50541 | {
| 50590 | ERRWRAP2(retval = _self_->setInputSize(size)); |  | 50542 | ERRWRAP2(retval = _self_->setInputSize(size));
| 50591 | return pyopencv_from(retval); |  | 50543 | return pyopencv_from(retval);
| 50592 | } |  | 50544 | }
| 50593 |  |  | 50545 |
| 50594 |  |  | 50546 |
| 50595 | pyPopulateArgumentConversionErrors(); |  | 50547 | pyPopulateArgumentConversionErrors();
| 50596 | } |  | 50548 | }
| 50597 |  |  | 50549 |
| 50598 |  |  | 50550 |
| 50599 | { |  | 50551 | {
| 50600 | PyObject* pyobj_width = NULL; |  | 50552 | PyObject* pyobj_width = NULL;
| 50601 | int width=0; |  | 50553 | int width=0;
| 50602 | PyObject* pyobj_height = NULL; |  | 50554 | PyObject* pyobj_height = NULL;
| 50603 | int height=0; |  | 50555 | int height=0;
| 50604 | Model retval; |  | 50556 | Model retval;
| 50605 |  |  | 50557 |
| 50606 | const char* keywords[] = { "width", "height", NULL }; |  | 50558 | const char* keywords[] = { "width", "height", NULL };
| 50607 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Model.setInputSize", (char**)keywords, &pyobj_width, &pyobj_height) && |  | 50559 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Model.setInputSize", (char**)keywords, &pyobj_width, &pyobj_height) &&
| 50608 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) && |  | 50560 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) &&
| 50609 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) ) |  | 50561 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) )
| 50610 | { |  | 50562 | {
| 50611 | ERRWRAP2(retval = _self_->setInputSize(width, height)); |  | 50563 | ERRWRAP2(retval = _self_->setInputSize(width, height));
| 50612 | return pyopencv_from(retval); |  | 50564 | return pyopencv_from(retval);
| 50613 | } |  | 50565 | }
| 50614 |  |  | 50566 |
| 50615 |  |  | 50567 |
| 50616 | pyPopulateArgumentConversionErrors(); |  | 50568 | pyPopulateArgumentConversionErrors();
| 50617 | } |  | 50569 | }
| 50618 | pyRaiseCVOverloadException("setInputSize"); |  | 50570 | pyRaiseCVOverloadException("setInputSize");
| 50619 |  |  | 50571 |
| 50620 | return NULL; |  | 50572 | return NULL;
| 50621 | } |  | 50573 | }
| 50622 |  |  | 50574 |
| 50623 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputSwapRB(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50575 | static PyObject* pyopencv_cv_dnn_dnn_Model_setInputSwapRB(PyObject* self, PyObject* py_args, PyObject* kw)
| 50624 | { |  | 50576 | {
| 50625 | using namespace cv::dnn; |  | 50577 | using namespace cv::dnn;
| 50626 |  |  | 50578 |
| 50627 |  |  | 50579 |
| 50628 | cv::dnn::Model * self1 = 0; |  | 50580 | cv::dnn::Model * self1 = 0;
| 50629 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50581 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50630 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50582 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50631 | cv::dnn::Model* _self_ = (self1); |  | 50583 | cv::dnn::Model* _self_ = (self1);
| 50632 | PyObject* pyobj_swapRB = NULL; |  | 50584 | PyObject* pyobj_swapRB = NULL;
| 50633 | bool swapRB=0; |  | 50585 | bool swapRB=0;
| 50634 | Model retval; |  | 50586 | Model retval;
| 50635 |  |  | 50587 |
| 50636 | const char* keywords[] = { "swapRB", NULL }; |  | 50588 | const char* keywords[] = { "swapRB", NULL };
| 50637 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputSwapRB", (char**)keywords, &pyobj_swapRB) && |  | 50589 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setInputSwapRB", (char**)keywords, &pyobj_swapRB) &&
| 50638 | pyopencv_to_safe(pyobj_swapRB, swapRB, ArgInfo("swapRB", 0)) ) |  | 50590 | pyopencv_to_safe(pyobj_swapRB, swapRB, ArgInfo("swapRB", 0)) )
| 50639 | { |  | 50591 | {
| 50640 | ERRWRAP2(retval = _self_->setInputSwapRB(swapRB)); |  | 50592 | ERRWRAP2(retval = _self_->setInputSwapRB(swapRB));
| 50641 | return pyopencv_from(retval); |  | 50593 | return pyopencv_from(retval);
| 50642 | } |  | 50594 | }
| 50643 |  |  | 50595 |
| 50644 | return NULL; |  | 50596 | return NULL;
| 50645 | } |  | 50597 | }
| 50646 |  |  | 50598 |
| 50647 | static PyObject* pyopencv_cv_dnn_dnn_Model_setOutputNames(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50599 | static PyObject* pyopencv_cv_dnn_dnn_Model_setOutputNames(PyObject* self, PyObject* py_args, PyObject* kw)
| 50648 | { |  | 50600 | {
| 50649 | using namespace cv::dnn; |  | 50601 | using namespace cv::dnn;
| 50650 |  |  | 50602 |
| 50651 |  |  | 50603 |
| 50652 | cv::dnn::Model * self1 = 0; |  | 50604 | cv::dnn::Model * self1 = 0;
| 50653 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50605 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50654 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50606 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50655 | cv::dnn::Model* _self_ = (self1); |  | 50607 | cv::dnn::Model* _self_ = (self1);
| 50656 | PyObject* pyobj_outNames = NULL; |  | 50608 | PyObject* pyobj_outNames = NULL;
| 50657 | vector_String outNames; |  | 50609 | vector_String outNames;
| 50658 | Model retval; |  | 50610 | Model retval;
| 50659 |  |  | 50611 |
| 50660 | const char* keywords[] = { "outNames", NULL }; |  | 50612 | const char* keywords[] = { "outNames", NULL };
| 50661 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setOutputNames", (char**)keywords, &pyobj_outNames) && |  | 50613 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setOutputNames", (char**)keywords, &pyobj_outNames) &&
| 50662 | pyopencv_to_safe(pyobj_outNames, outNames, ArgInfo("outNames", 0)) ) |  | 50614 | pyopencv_to_safe(pyobj_outNames, outNames, ArgInfo("outNames", 0)) )
| 50663 | { |  | 50615 | {
| 50664 | ERRWRAP2(retval = _self_->setOutputNames(outNames)); |  | 50616 | ERRWRAP2(retval = _self_->setOutputNames(outNames));
| 50665 | return pyopencv_from(retval); |  | 50617 | return pyopencv_from(retval);
| 50666 | } |  | 50618 | }
| 50667 |  |  | 50619 |
| 50668 | return NULL; |  | 50620 | return NULL;
| 50669 | } |  | 50621 | }
| 50670 |  |  | 50622 |
| 50671 | static PyObject* pyopencv_cv_dnn_dnn_Model_setPreferableBackend(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50623 | static PyObject* pyopencv_cv_dnn_dnn_Model_setPreferableBackend(PyObject* self, PyObject* py_args, PyObject* kw)
| 50672 | { |  | 50624 | {
| 50673 | using namespace cv::dnn; |  | 50625 | using namespace cv::dnn;
| 50674 |  |  | 50626 |
| 50675 |  |  | 50627 |
| 50676 | cv::dnn::Model * self1 = 0; |  | 50628 | cv::dnn::Model * self1 = 0;
| 50677 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50629 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50678 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50630 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50679 | cv::dnn::Model* _self_ = (self1); |  | 50631 | cv::dnn::Model* _self_ = (self1);
| 50680 | PyObject* pyobj_backendId = NULL; |  | 50632 | PyObject* pyobj_backendId = NULL;
| 50681 | dnn_Backend backendId=static_cast<dnn_Backend>(0); |  | 50633 | dnn_Backend backendId=static_cast<dnn_Backend>(0);
| 50682 | Model retval; |  | 50634 | Model retval;
| 50683 |  |  | 50635 |
| 50684 | const char* keywords[] = { "backendId", NULL }; |  | 50636 | const char* keywords[] = { "backendId", NULL };
| 50685 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setPreferableBackend", (char**)keywords, &pyobj_backendId) && |  | 50637 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setPreferableBackend", (char**)keywords, &pyobj_backendId) &&
| 50686 | pyopencv_to_safe(pyobj_backendId, backendId, ArgInfo("backendId", 0)) ) |  | 50638 | pyopencv_to_safe(pyobj_backendId, backendId, ArgInfo("backendId", 0)) )
| 50687 | { |  | 50639 | {
| 50688 | ERRWRAP2(retval = _self_->setPreferableBackend(backendId)); |  | 50640 | ERRWRAP2(retval = _self_->setPreferableBackend(backendId));
| 50689 | return pyopencv_from(retval); |  | 50641 | return pyopencv_from(retval);
| 50690 | } |  | 50642 | }
| 50691 |  |  | 50643 |
| 50692 | return NULL; |  | 50644 | return NULL;
| 50693 | } |  | 50645 | }
| 50694 |  |  | 50646 |
| 50695 | static PyObject* pyopencv_cv_dnn_dnn_Model_setPreferableTarget(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50647 | static PyObject* pyopencv_cv_dnn_dnn_Model_setPreferableTarget(PyObject* self, PyObject* py_args, PyObject* kw)
| 50696 | { |  | 50648 | {
| 50697 | using namespace cv::dnn; |  | 50649 | using namespace cv::dnn;
| 50698 |  |  | 50650 |
| 50699 |  |  | 50651 |
| 50700 | cv::dnn::Model * self1 = 0; |  | 50652 | cv::dnn::Model * self1 = 0;
| 50701 | if (!pyopencv_dnn_Model_getp(self, self1)) |  | 50653 | if (!pyopencv_dnn_Model_getp(self, self1))
| 50702 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)"); |  | 50654 | return failmsgp("Incorrect type of self (must be 'dnn_Model' or its derivative)");
| 50703 | cv::dnn::Model* _self_ = (self1); |  | 50655 | cv::dnn::Model* _self_ = (self1);
| 50704 | PyObject* pyobj_targetId = NULL; |  | 50656 | PyObject* pyobj_targetId = NULL;
| 50705 | dnn_Target targetId=static_cast<dnn_Target>(0); |  | 50657 | dnn_Target targetId=static_cast<dnn_Target>(0);
| 50706 | Model retval; |  | 50658 | Model retval;
| 50707 |  |  | 50659 |
| 50708 | const char* keywords[] = { "targetId", NULL }; |  | 50660 | const char* keywords[] = { "targetId", NULL };
| 50709 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setPreferableTarget", (char**)keywords, &pyobj_targetId) && |  | 50661 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Model.setPreferableTarget", (char**)keywords, &pyobj_targetId) &&
| 50710 | pyopencv_to_safe(pyobj_targetId, targetId, ArgInfo("targetId", 0)) ) |  | 50662 | pyopencv_to_safe(pyobj_targetId, targetId, ArgInfo("targetId", 0)) )
| 50711 | { |  | 50663 | {
| 50712 | ERRWRAP2(retval = _self_->setPreferableTarget(targetId)); |  | 50664 | ERRWRAP2(retval = _self_->setPreferableTarget(targetId));
| 50713 | return pyopencv_from(retval); |  | 50665 | return pyopencv_from(retval);
| 50714 | } |  | 50666 | }
| 50715 |  |  | 50667 |
| 50716 | return NULL; |  | 50668 | return NULL;
| 50717 | } |  | 50669 | }
| 50718 |  |  | 50670 |
| 50719 |  |  | 50671 |
| 50720 |  |  | 50672 |
| 50721 | // Tables (dnn_Model) |  | 50673 | // Tables (dnn_Model)
| 50722 |  |  | 50674 |
| 50723 | static PyGetSetDef pyopencv_dnn_Model_getseters[] = |  | 50675 | static PyGetSetDef pyopencv_dnn_Model_getseters[] =
| 50724 | { |  | 50676 | {
| 50725 | {NULL} /* Sentinel */ |  | 50677 | {NULL} /* Sentinel */
| 50726 | }; |  | 50678 | };
| 50727 |  |  | 50679 |
| 50728 | static PyMethodDef pyopencv_dnn_Model_methods[] = |  | 50680 | static PyMethodDef pyopencv_dnn_Model_methods[] =
| 50729 | { |  | 50681 | {
| 50730 | {"enableWinograd", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_enableWinograd, 0), "enableWinograd(useWinograd) -> retval\n."}, |  | 50682 | {"enableWinograd", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_enableWinograd, 0), "enableWinograd(useWinograd) -> retval\n."},
| 50731 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_predict, 0), "predict(frame[, outs]) -> outs\n. @brief Given the @p input frame, create input blob, run net and return the output @p blobs.\n. * @param[in] frame The input image.\n. * @param[out] outs Allocated output blobs, which will store results of the computation."}, |  | 50683 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_predict, 0), "predict(frame[, outs]) -> outs\n. @brief Given the @p input frame, create input blob, run net and return the output @p blobs.\n. * @param[in] frame The input image.\n. * @param[out] outs Allocated output blobs, which will store results of the computation."},
| 50732 | {"setInputCrop", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputCrop, 0), "setInputCrop(crop) -> retval\n. @brief Set flag crop for frame.\n. * @param[in] crop Flag which indicates whether image will be cropped after resize or not."}, |  | 50684 | {"setInputCrop", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputCrop, 0), "setInputCrop(crop) -> retval\n. @brief Set flag crop for frame.\n. * @param[in] crop Flag which indicates whether image will be cropped after resize or not."},
| 50733 | {"setInputMean", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputMean, 0), "setInputMean(mean) -> retval\n. @brief Set mean value for frame.\n. * @param[in] mean Scalar with mean values which are subtracted from channels."}, |  | 50685 | {"setInputMean", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputMean, 0), "setInputMean(mean) -> retval\n. @brief Set mean value for frame.\n. * @param[in] mean Scalar with mean values which are subtracted from channels."},
| 50734 | {"setInputParams", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputParams, 0), "setInputParams([, scale[, size[, mean[, swapRB[, crop]]]]]) -> None\n. @brief Set preprocessing parameters for frame.\n. * @param[in] size New input size.\n. * @param[in] mean Scalar with mean values which are subtracted from channels.\n. * @param[in] scale Multiplier for frame values.\n. * @param[in] swapRB Flag which indicates that swap first and last channels.\n. * @param[in] crop Flag which indicates whether image will be cropped after resize or not.\n. * blob(n, c, y, x) = scale * resize( frame(y, x, c) ) - mean(c) )"}, |  | 50686 | {"setInputParams", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputParams, 0), "setInputParams([, scale[, size[, mean[, swapRB[, crop]]]]]) -> None\n. @brief Set preprocessing parameters for frame.\n. * @param[in] size New input size.\n. * @param[in] mean Scalar with mean values which are subtracted from channels.\n. * @param[in] scale Multiplier for frame values.\n. * @param[in] swapRB Flag which indicates that swap first and last channels.\n. * @param[in] crop Flag which indicates whether image will be cropped after resize or not.\n. * blob(n, c, y, x) = scale * resize( frame(y, x, c) ) - mean(c) )"},
| 50735 | {"setInputScale", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputScale, 0), "setInputScale(scale) -> retval\n. @brief Set scalefactor value for frame.\n. * @param[in] scale Multiplier for frame values."}, |  | 50687 | {"setInputScale", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputScale, 0), "setInputScale(scale) -> retval\n. @brief Set scalefactor value for frame.\n. * @param[in] scale Multiplier for frame values."},
| 50736 | {"setInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputSize, 0), "setInputSize(size) -> retval\n. @brief Set input size for frame.\n. * @param[in] size New input size.\n. * @note If shape of the new blob less than 0, then frame size not change.\n\n\n\nsetInputSize(width, height) -> retval\n. @overload\n. * @param[in] width New input width.\n. * @param[in] height New input height."}, |  | 50688 | {"setInputSize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputSize, 0), "setInputSize(size) -> retval\n. @brief Set input size for frame.\n. * @param[in] size New input size.\n. * @note If shape of the new blob less than 0, then frame size not change.\n\n\n\nsetInputSize(width, height) -> retval\n. @overload\n. * @param[in] width New input width.\n. * @param[in] height New input height."},
| 50737 | {"setInputSwapRB", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputSwapRB, 0), "setInputSwapRB(swapRB) -> retval\n. @brief Set flag swapRB for frame.\n. * @param[in] swapRB Flag which indicates that swap first and last channels."}, |  | 50689 | {"setInputSwapRB", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setInputSwapRB, 0), "setInputSwapRB(swapRB) -> retval\n. @brief Set flag swapRB for frame.\n. * @param[in] swapRB Flag which indicates that swap first and last channels."},
| 50738 | {"setOutputNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setOutputNames, 0), "setOutputNames(outNames) -> retval\n. @brief Set output names for frame.\n. * @param[in] outNames Names for output layers."}, |  | 50690 | {"setOutputNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setOutputNames, 0), "setOutputNames(outNames) -> retval\n. @brief Set output names for frame.\n. * @param[in] outNames Names for output layers."},
| 50739 | {"setPreferableBackend", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setPreferableBackend, 0), "setPreferableBackend(backendId) -> retval\n."}, |  | 50691 | {"setPreferableBackend", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setPreferableBackend, 0), "setPreferableBackend(backendId) -> retval\n."},
| 50740 | {"setPreferableTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setPreferableTarget, 0), "setPreferableTarget(targetId) -> retval\n."}, |  | 50692 | {"setPreferableTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Model_setPreferableTarget, 0), "setPreferableTarget(targetId) -> retval\n."},
| 50741 |  |  | 50693 |
| 50742 | {NULL, NULL} |  | 50694 | {NULL, NULL}
| 50743 | }; |  | 50695 | };
| 50744 |  |  | 50696 |
| 50745 | // Converter (dnn_Model) |  | 50697 | // Converter (dnn_Model)
| 50746 |  |  | 50698 |
| 50747 | template<> |  | 50699 | template<>
| 50748 | struct PyOpenCV_Converter< cv::dnn::Model > |  | 50700 | struct PyOpenCV_Converter< cv::dnn::Model >
| 50749 | { |  | 50701 | {
| 50750 | static PyObject* from(const cv::dnn::Model& r) |  | 50702 | static PyObject* from(const cv::dnn::Model& r)
| 50751 | { |  | 50703 | {
| 50752 | return pyopencv_dnn_Model_Instance(r); |  | 50704 | return pyopencv_dnn_Model_Instance(r);
| 50753 | } |  | 50705 | }
| 50754 | static bool to(PyObject* src, cv::dnn::Model& dst, const ArgInfo& info) |  | 50706 | static bool to(PyObject* src, cv::dnn::Model& dst, const ArgInfo& info)
| 50755 | { |  | 50707 | {
| 50756 | if(!src || src == Py_None) |  | 50708 | if(!src || src == Py_None)
| 50757 | return true; |  | 50709 | return true;
| 50758 | cv::dnn::Model * dst_; |  | 50710 | cv::dnn::Model * dst_;
| 50759 | if (pyopencv_dnn_Model_getp(src, dst_)) |  | 50711 | if (pyopencv_dnn_Model_getp(src, dst_))
| 50760 | { |  | 50712 | {
| 50761 | dst = *dst_; |  | 50713 | dst = *dst_;
| 50762 | return true; |  | 50714 | return true;
| 50763 | } |  | 50715 | }
| 50764 |  |  | 50716 |
| 50765 | failmsg("Expected cv::dnn::Model for argument '%s'", info.name); |  | 50717 | failmsg("Expected cv::dnn::Model for argument '%s'", info.name);
| 50766 | return false; |  | 50718 | return false;
| 50767 | } |  | 50719 | }
| 50768 | }; |  | 50720 | };
| 50769 |  |  | 50721 |
| 50770 | //================================================================================ |  | 50722 | //================================================================================
| 50771 | // dnn_Net (Generic) |  | 50723 | // dnn_Net (Generic)
| 50772 | //================================================================================ |  | 50724 | //================================================================================
| 50773 |  |  | 50725 |
| 50774 | // GetSet (dnn_Net) |  | 50726 | // GetSet (dnn_Net)
| 50775 |  |  | 50727 |
| 50776 |  |  | 50728 |
| 50777 |  |  | 50729 |
| 50778 | // Methods (dnn_Net) |  | 50730 | // Methods (dnn_Net)
| 50779 |  |  | 50731 |
| 50780 | static int pyopencv_cv_dnn_dnn_Net_Net(pyopencv_dnn_Net_t* self, PyObject* py_args, PyObject* kw) |  | 50732 | static int pyopencv_cv_dnn_dnn_Net_Net(pyopencv_dnn_Net_t* self, PyObject* py_args, PyObject* kw)
| 50781 | { |  | 50733 | {
| 50782 | using namespace cv::dnn; |  | 50734 | using namespace cv::dnn;
| 50783 |  |  | 50735 |
| 50784 |  |  | 50736 |
| 50785 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 50737 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 50786 | { |  | 50738 | {
| 50787 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Net()); |  | 50739 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::Net());
| 50788 | return 0; |  | 50740 | return 0;
| 50789 | } |  | 50741 | }
| 50790 |  |  | 50742 |
| 50791 | return -1; |  | 50743 | return -1;
| 50792 | } |  | 50744 | }
| 50793 |  |  | 50745 |
| 50794 | static PyObject* pyopencv_cv_dnn_dnn_Net_addLayer(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50746 | static PyObject* pyopencv_cv_dnn_dnn_Net_addLayer(PyObject* self, PyObject* py_args, PyObject* kw)
| 50795 | { |  | 50747 | {
| 50796 | using namespace cv::dnn; |  | 50748 | using namespace cv::dnn;
| 50797 |  |  | 50749 |
| 50798 |  |  | 50750 |
| 50799 | cv::dnn::Net * self1 = 0; |  | 50751 | cv::dnn::Net * self1 = 0;
| 50800 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50752 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50801 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50753 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50802 | cv::dnn::Net* _self_ = (self1); |  | 50754 | cv::dnn::Net* _self_ = (self1);
| 50803 | PyObject* pyobj_name = NULL; |  | 50755 | PyObject* pyobj_name = NULL;
| 50804 | String name; |  | 50756 | String name;
| 50805 | PyObject* pyobj_type = NULL; |  | 50757 | PyObject* pyobj_type = NULL;
| 50806 | String type; |  | 50758 | String type;
| 50807 | PyObject* pyobj_dtype = NULL; |  | 50759 | PyObject* pyobj_dtype = NULL;
| 50808 | int dtype=0; |  | 50760 | int dtype=0;
| 50809 | PyObject* pyobj_params = NULL; |  | 50761 | PyObject* pyobj_params = NULL;
| 50810 | LayerParams params; |  | 50762 | LayerParams params;
| 50811 | int retval; |  | 50763 | int retval;
| 50812 |  |  | 50764 |
| 50813 | const char* keywords[] = { "name", "type", "dtype", "params", NULL }; |  | 50765 | const char* keywords[] = { "name", "type", "dtype", "params", NULL };
| 50814 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_Net.addLayer", (char**)keywords, &pyobj_name, &pyobj_type, &pyobj_dtype, &pyobj_params) && |  | 50766 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_Net.addLayer", (char**)keywords, &pyobj_name, &pyobj_type, &pyobj_dtype, &pyobj_params) &&
| 50815 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 50767 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 50816 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 50768 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 50817 | pyopencv_to_safe(pyobj_dtype, dtype, ArgInfo("dtype", 0)) && |  | 50769 | pyopencv_to_safe(pyobj_dtype, dtype, ArgInfo("dtype", 0)) &&
| 50818 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 50770 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 50819 | { |  | 50771 | {
| 50820 | ERRWRAP2(retval = _self_->addLayer(name, type, dtype, params)); |  | 50772 | ERRWRAP2(retval = _self_->addLayer(name, type, dtype, params));
| 50821 | return pyopencv_from(retval); |  | 50773 | return pyopencv_from(retval);
| 50822 | } |  | 50774 | }
| 50823 |  |  | 50775 |
| 50824 | return NULL; |  | 50776 | return NULL;
| 50825 | } |  | 50777 | }
| 50826 |  |  | 50778 |
| 50827 | static PyObject* pyopencv_cv_dnn_dnn_Net_addLayerToPrev(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50779 | static PyObject* pyopencv_cv_dnn_dnn_Net_addLayerToPrev(PyObject* self, PyObject* py_args, PyObject* kw)
| 50828 | { |  | 50780 | {
| 50829 | using namespace cv::dnn; |  | 50781 | using namespace cv::dnn;
| 50830 |  |  | 50782 |
| 50831 |  |  | 50783 |
| 50832 | cv::dnn::Net * self1 = 0; |  | 50784 | cv::dnn::Net * self1 = 0;
| 50833 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50785 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50834 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50786 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50835 | cv::dnn::Net* _self_ = (self1); |  | 50787 | cv::dnn::Net* _self_ = (self1);
| 50836 | PyObject* pyobj_name = NULL; |  | 50788 | PyObject* pyobj_name = NULL;
| 50837 | String name; |  | 50789 | String name;
| 50838 | PyObject* pyobj_type = NULL; |  | 50790 | PyObject* pyobj_type = NULL;
| 50839 | String type; |  | 50791 | String type;
| 50840 | PyObject* pyobj_dtype = NULL; |  | 50792 | PyObject* pyobj_dtype = NULL;
| 50841 | int dtype=0; |  | 50793 | int dtype=0;
| 50842 | PyObject* pyobj_params = NULL; |  | 50794 | PyObject* pyobj_params = NULL;
| 50843 | LayerParams params; |  | 50795 | LayerParams params;
| 50844 | int retval; |  | 50796 | int retval;
| 50845 |  |  | 50797 |
| 50846 | const char* keywords[] = { "name", "type", "dtype", "params", NULL }; |  | 50798 | const char* keywords[] = { "name", "type", "dtype", "params", NULL };
| 50847 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_Net.addLayerToPrev", (char**)keywords, &pyobj_name, &pyobj_type, &pyobj_dtype, &pyobj_params) && |  | 50799 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_Net.addLayerToPrev", (char**)keywords, &pyobj_name, &pyobj_type, &pyobj_dtype, &pyobj_params) &&
| 50848 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 50800 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 50849 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 50801 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 50850 | pyopencv_to_safe(pyobj_dtype, dtype, ArgInfo("dtype", 0)) && |  | 50802 | pyopencv_to_safe(pyobj_dtype, dtype, ArgInfo("dtype", 0)) &&
| 50851 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 50803 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 50852 | { |  | 50804 | {
| 50853 | ERRWRAP2(retval = _self_->addLayerToPrev(name, type, dtype, params)); |  | 50805 | ERRWRAP2(retval = _self_->addLayerToPrev(name, type, dtype, params));
| 50854 | return pyopencv_from(retval); |  | 50806 | return pyopencv_from(retval);
| 50855 | } |  | 50807 | }
| 50856 |  |  | 50808 |
| 50857 | return NULL; |  | 50809 | return NULL;
| 50858 | } |  | 50810 | }
| 50859 |  |  | 50811 |
| 50860 | static PyObject* pyopencv_cv_dnn_dnn_Net_connect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50812 | static PyObject* pyopencv_cv_dnn_dnn_Net_connect(PyObject* self, PyObject* py_args, PyObject* kw)
| 50861 | { |  | 50813 | {
| 50862 | using namespace cv::dnn; |  | 50814 | using namespace cv::dnn;
| 50863 |  |  | 50815 |
| 50864 |  |  | 50816 |
| 50865 | cv::dnn::Net * self1 = 0; |  | 50817 | cv::dnn::Net * self1 = 0;
| 50866 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50818 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50867 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50819 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50868 | cv::dnn::Net* _self_ = (self1); |  | 50820 | cv::dnn::Net* _self_ = (self1);
| 50869 | PyObject* pyobj_outPin = NULL; |  | 50821 | PyObject* pyobj_outPin = NULL;
| 50870 | String outPin; |  | 50822 | String outPin;
| 50871 | PyObject* pyobj_inpPin = NULL; |  | 50823 | PyObject* pyobj_inpPin = NULL;
| 50872 | String inpPin; |  | 50824 | String inpPin;
| 50873 |  |  | 50825 |
| 50874 | const char* keywords[] = { "outPin", "inpPin", NULL }; |  | 50826 | const char* keywords[] = { "outPin", "inpPin", NULL };
| 50875 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.connect", (char**)keywords, &pyobj_outPin, &pyobj_inpPin) && |  | 50827 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.connect", (char**)keywords, &pyobj_outPin, &pyobj_inpPin) &&
| 50876 | pyopencv_to_safe(pyobj_outPin, outPin, ArgInfo("outPin", 0)) && |  | 50828 | pyopencv_to_safe(pyobj_outPin, outPin, ArgInfo("outPin", 0)) &&
| 50877 | pyopencv_to_safe(pyobj_inpPin, inpPin, ArgInfo("inpPin", 0)) ) |  | 50829 | pyopencv_to_safe(pyobj_inpPin, inpPin, ArgInfo("inpPin", 0)) )
| 50878 | { |  | 50830 | {
| 50879 | ERRWRAP2(_self_->connect(outPin, inpPin)); |  | 50831 | ERRWRAP2(_self_->connect(outPin, inpPin));
| 50880 | Py_RETURN_NONE; |  | 50832 | Py_RETURN_NONE;
| 50881 | } |  | 50833 | }
| 50882 |  |  | 50834 |
| 50883 | return NULL; |  | 50835 | return NULL;
| 50884 | } |  | 50836 | }
| 50885 |  |  | 50837 |
| 50886 | static PyObject* pyopencv_cv_dnn_dnn_Net_dump(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50838 | static PyObject* pyopencv_cv_dnn_dnn_Net_dump(PyObject* self, PyObject* py_args, PyObject* kw)
| 50887 | { |  | 50839 | {
| 50888 | using namespace cv::dnn; |  | 50840 | using namespace cv::dnn;
| 50889 |  |  | 50841 |
| 50890 |  |  | 50842 |
| 50891 | cv::dnn::Net * self1 = 0; |  | 50843 | cv::dnn::Net * self1 = 0;
| 50892 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50844 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50893 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50845 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50894 | cv::dnn::Net* _self_ = (self1); |  | 50846 | cv::dnn::Net* _self_ = (self1);
| 50895 | String retval; |  | 50847 | String retval;
| 50896 |  |  | 50848 |
| 50897 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 50849 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 50898 | { |  | 50850 | {
| 50899 | ERRWRAP2(retval = _self_->dump()); |  | 50851 | ERRWRAP2(retval = _self_->dump());
| 50900 | return pyopencv_from(retval); |  | 50852 | return pyopencv_from(retval);
| 50901 | } |  | 50853 | }
| 50902 |  |  | 50854 |
| 50903 | return NULL; |  | 50855 | return NULL;
| 50904 | } |  | 50856 | }
| 50905 |  |  | 50857 |
| 50906 | static PyObject* pyopencv_cv_dnn_dnn_Net_dumpToFile(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50858 | static PyObject* pyopencv_cv_dnn_dnn_Net_dumpToFile(PyObject* self, PyObject* py_args, PyObject* kw)
| 50907 | { |  | 50859 | {
| 50908 | using namespace cv::dnn; |  | 50860 | using namespace cv::dnn;
| 50909 |  |  | 50861 |
| 50910 |  |  | 50862 |
| 50911 | cv::dnn::Net * self1 = 0; |  | 50863 | cv::dnn::Net * self1 = 0;
| 50912 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50864 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50913 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50865 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50914 | cv::dnn::Net* _self_ = (self1); |  | 50866 | cv::dnn::Net* _self_ = (self1);
| 50915 | PyObject* pyobj_path = NULL; |  | 50867 | PyObject* pyobj_path = NULL;
| 50916 | String path; |  | 50868 | String path;
| 50917 |  |  | 50869 |
| 50918 | const char* keywords[] = { "path", NULL }; |  | 50870 | const char* keywords[] = { "path", NULL };
| 50919 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.dumpToFile", (char**)keywords, &pyobj_path) && |  | 50871 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.dumpToFile", (char**)keywords, &pyobj_path) &&
| 50920 | pyopencv_to_safe(pyobj_path, path, ArgInfo("path", 4)) ) |  | 50872 | pyopencv_to_safe(pyobj_path, path, ArgInfo("path", 4)) )
| 50921 | { |  | 50873 | {
| 50922 | ERRWRAP2(_self_->dumpToFile(path)); |  | 50874 | ERRWRAP2(_self_->dumpToFile(path));
| 50923 | Py_RETURN_NONE; |  | 50875 | Py_RETURN_NONE;
| 50924 | } |  | 50876 | }
| 50925 |  |  | 50877 |
| 50926 | return NULL; |  | 50878 | return NULL;
| 50927 | } |  | 50879 | }
| 50928 |  |  | 50880 |
| 50929 | static PyObject* pyopencv_cv_dnn_dnn_Net_dumpToPbtxt(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50881 | static PyObject* pyopencv_cv_dnn_dnn_Net_dumpToPbtxt(PyObject* self, PyObject* py_args, PyObject* kw)
| 50930 | { |  | 50882 | {
| 50931 | using namespace cv::dnn; |  | 50883 | using namespace cv::dnn;
| 50932 |  |  | 50884 |
| 50933 |  |  | 50885 |
| 50934 | cv::dnn::Net * self1 = 0; |  | 50886 | cv::dnn::Net * self1 = 0;
| 50935 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50887 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50936 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50888 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50937 | cv::dnn::Net* _self_ = (self1); |  | 50889 | cv::dnn::Net* _self_ = (self1);
| 50938 | PyObject* pyobj_path = NULL; |  | 50890 | PyObject* pyobj_path = NULL;
| 50939 | String path; |  | 50891 | String path;
| 50940 |  |  | 50892 |
| 50941 | const char* keywords[] = { "path", NULL }; |  | 50893 | const char* keywords[] = { "path", NULL };
| 50942 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.dumpToPbtxt", (char**)keywords, &pyobj_path) && |  | 50894 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.dumpToPbtxt", (char**)keywords, &pyobj_path) &&
| 50943 | pyopencv_to_safe(pyobj_path, path, ArgInfo("path", 4)) ) |  | 50895 | pyopencv_to_safe(pyobj_path, path, ArgInfo("path", 4)) )
| 50944 | { |  | 50896 | {
| 50945 | ERRWRAP2(_self_->dumpToPbtxt(path)); |  | 50897 | ERRWRAP2(_self_->dumpToPbtxt(path));
| 50946 | Py_RETURN_NONE; |  | 50898 | Py_RETURN_NONE;
| 50947 | } |  | 50899 | }
| 50948 |  |  | 50900 |
| 50949 | return NULL; |  | 50901 | return NULL;
| 50950 | } |  | 50902 | }
| 50951 |  |  | 50903 |
| 50952 | static PyObject* pyopencv_cv_dnn_dnn_Net_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50904 | static PyObject* pyopencv_cv_dnn_dnn_Net_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 50953 | { |  | 50905 | {
| 50954 | using namespace cv::dnn; |  | 50906 | using namespace cv::dnn;
| 50955 |  |  | 50907 |
| 50956 |  |  | 50908 |
| 50957 | cv::dnn::Net * self1 = 0; |  | 50909 | cv::dnn::Net * self1 = 0;
| 50958 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50910 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50959 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50911 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50960 | cv::dnn::Net* _self_ = (self1); |  | 50912 | cv::dnn::Net* _self_ = (self1);
| 50961 | bool retval; |  | 50913 | bool retval;
| 50962 |  |  | 50914 |
| 50963 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 50915 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 50964 | { |  | 50916 | {
| 50965 | ERRWRAP2(retval = _self_->empty()); |  | 50917 | ERRWRAP2(retval = _self_->empty());
| 50966 | return pyopencv_from(retval); |  | 50918 | return pyopencv_from(retval);
| 50967 | } |  | 50919 | }
| 50968 |  |  | 50920 |
| 50969 | return NULL; |  | 50921 | return NULL;
| 50970 | } |  | 50922 | }
| 50971 |  |  | 50923 |
| 50972 | static PyObject* pyopencv_cv_dnn_dnn_Net_enableFusion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50924 | static PyObject* pyopencv_cv_dnn_dnn_Net_enableFusion(PyObject* self, PyObject* py_args, PyObject* kw)
| 50973 | { |  | 50925 | {
| 50974 | using namespace cv::dnn; |  | 50926 | using namespace cv::dnn;
| 50975 |  |  | 50927 |
| 50976 |  |  | 50928 |
| 50977 | cv::dnn::Net * self1 = 0; |  | 50929 | cv::dnn::Net * self1 = 0;
| 50978 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50930 | if (!pyopencv_dnn_Net_getp(self, self1))
| 50979 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50931 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 50980 | cv::dnn::Net* _self_ = (self1); |  | 50932 | cv::dnn::Net* _self_ = (self1);
| 50981 | PyObject* pyobj_fusion = NULL; |  | 50933 | PyObject* pyobj_fusion = NULL;
| 50982 | bool fusion=0; |  | 50934 | bool fusion=0;
| 50983 |  |  | 50935 |
| 50984 | const char* keywords[] = { "fusion", NULL }; |  | 50936 | const char* keywords[] = { "fusion", NULL };
| 50985 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.enableFusion", (char**)keywords, &pyobj_fusion) && |  | 50937 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.enableFusion", (char**)keywords, &pyobj_fusion) &&
| 50986 | pyopencv_to_safe(pyobj_fusion, fusion, ArgInfo("fusion", 0)) ) |  | 50938 | pyopencv_to_safe(pyobj_fusion, fusion, ArgInfo("fusion", 0)) )
| 50987 | { |  | 50939 | {
| 50988 | ERRWRAP2(_self_->enableFusion(fusion)); |  | 50940 | ERRWRAP2(_self_->enableFusion(fusion));
| 50989 | Py_RETURN_NONE; |  | 50941 | Py_RETURN_NONE;
| 50990 | } |  | 50942 | }
| 50991 |  |  | 50943 |
| 50992 | return NULL; |  | 50944 | return NULL;
| 50993 | } |  | 50945 | }
| 50994 |  |  | 50946 |
| 50995 | static PyObject* pyopencv_cv_dnn_dnn_Net_enableWinograd(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50947 | static PyObject* pyopencv_cv_dnn_dnn_Net_enableWinograd(PyObject* self, PyObject* py_args, PyObject* kw)
| 50996 | { |  | 50948 | {
| 50997 | using namespace cv::dnn; |  | 50949 | using namespace cv::dnn;
| 50998 |  |  | 50950 |
| 50999 |  |  | 50951 |
| 51000 | cv::dnn::Net * self1 = 0; |  | 50952 | cv::dnn::Net * self1 = 0;
| 51001 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50953 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51002 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50954 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51003 | cv::dnn::Net* _self_ = (self1); |  | 50955 | cv::dnn::Net* _self_ = (self1);
| 51004 | PyObject* pyobj_useWinograd = NULL; |  | 50956 | PyObject* pyobj_useWinograd = NULL;
| 51005 | bool useWinograd=0; |  | 50957 | bool useWinograd=0;
| 51006 |  |  | 50958 |
| 51007 | const char* keywords[] = { "useWinograd", NULL }; |  | 50959 | const char* keywords[] = { "useWinograd", NULL };
| 51008 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.enableWinograd", (char**)keywords, &pyobj_useWinograd) && |  | 50960 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.enableWinograd", (char**)keywords, &pyobj_useWinograd) &&
| 51009 | pyopencv_to_safe(pyobj_useWinograd, useWinograd, ArgInfo("useWinograd", 0)) ) |  | 50961 | pyopencv_to_safe(pyobj_useWinograd, useWinograd, ArgInfo("useWinograd", 0)) )
| 51010 | { |  | 50962 | {
| 51011 | ERRWRAP2(_self_->enableWinograd(useWinograd)); |  | 50963 | ERRWRAP2(_self_->enableWinograd(useWinograd));
| 51012 | Py_RETURN_NONE; |  | 50964 | Py_RETURN_NONE;
| 51013 | } |  | 50965 | }
| 51014 |  |  | 50966 |
| 51015 | return NULL; |  | 50967 | return NULL;
| 51016 | } |  | 50968 | }
| 51017 |  |  | 50969 |
| 51018 | static PyObject* pyopencv_cv_dnn_dnn_Net_forward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 50970 | static PyObject* pyopencv_cv_dnn_dnn_Net_forward(PyObject* self, PyObject* py_args, PyObject* kw)
| 51019 | { |  | 50971 | {
| 51020 | using namespace cv::dnn; |  | 50972 | using namespace cv::dnn;
| 51021 |  |  | 50973 |
| 51022 |  |  | 50974 |
| 51023 | cv::dnn::Net * self1 = 0; |  | 50975 | cv::dnn::Net * self1 = 0;
| 51024 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 50976 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51025 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 50977 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51026 | cv::dnn::Net* _self_ = (self1); |  | 50978 | cv::dnn::Net* _self_ = (self1);
| 51027 | pyPrepareArgumentConversionErrorsStorage(5); |  | 50979 | pyPrepareArgumentConversionErrorsStorage(5);
| 51028 |  |  | 50980 |
| 51029 | { |  | 50981 | {
| 51030 | PyObject* pyobj_outputName = NULL; |  | 50982 | PyObject* pyobj_outputName = NULL;
| 51031 | String outputName; |  | 50983 | String outputName;
| 51032 | Mat retval; |  | 50984 | Mat retval;
| 51033 |  |  | 50985 |
| 51034 | const char* keywords[] = { "outputName", NULL }; |  | 50986 | const char* keywords[] = { "outputName", NULL };
| 51035 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_Net.forward", (char**)keywords, &pyobj_outputName) && |  | 50987 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_Net.forward", (char**)keywords, &pyobj_outputName) &&
| 51036 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) ) |  | 50988 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) )
| 51037 | { |  | 50989 | {
| 51038 | ERRWRAP2(retval = _self_->forward(outputName)); |  | 50990 | ERRWRAP2(retval = _self_->forward(outputName));
| 51039 | return pyopencv_from(retval); |  | 50991 | return pyopencv_from(retval);
| 51040 | } |  | 50992 | }
| 51041 |  |  | 50993 |
| 51042 |  |  | 50994 |
| 51043 | pyPopulateArgumentConversionErrors(); |  | 50995 | pyPopulateArgumentConversionErrors();
| 51044 | } |  | 50996 | }
| 51045 |  |  | 50997 |
| 51046 |  |  | 50998 |
| 51047 | { |  | 50999 | {
| 51048 | PyObject* pyobj_outputBlobs = NULL; |  | 51000 | PyObject* pyobj_outputBlobs = NULL;
| 51049 | vector_Mat outputBlobs; |  | 51001 | vector_Mat outputBlobs;
| 51050 | PyObject* pyobj_outputName = NULL; |  | 51002 | PyObject* pyobj_outputName = NULL;
| 51051 | String outputName; |  | 51003 | String outputName;
| 51052 |  |  | 51004 |
| 51053 | const char* keywords[] = { "outputBlobs", "outputName", NULL }; |  | 51005 | const char* keywords[] = { "outputBlobs", "outputName", NULL };
| 51054 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dnn_Net.forward", (char**)keywords, &pyobj_outputBlobs, &pyobj_outputName) && |  | 51006 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dnn_Net.forward", (char**)keywords, &pyobj_outputBlobs, &pyobj_outputName) &&
| 51055 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) && |  | 51007 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) &&
| 51056 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) ) |  | 51008 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) )
| 51057 | { |  | 51009 | {
| 51058 | ERRWRAP2(_self_->forward(outputBlobs, outputName)); |  | 51010 | ERRWRAP2(_self_->forward(outputBlobs, outputName));
| 51059 | return pyopencv_from(outputBlobs); |  | 51011 | return pyopencv_from(outputBlobs);
| 51060 | } |  | 51012 | }
| 51061 |  |  | 51013 |
| 51062 |  |  | 51014 |
| 51063 | pyPopulateArgumentConversionErrors(); |  | 51015 | pyPopulateArgumentConversionErrors();
| 51064 | } |  | 51016 | }
| 51065 |  |  | 51017 |
| 51066 |  |  | 51018 |
| 51067 | { |  | 51019 | {
| 51068 | PyObject* pyobj_outputBlobs = NULL; |  | 51020 | PyObject* pyobj_outputBlobs = NULL;
| 51069 | vector_Mat outputBlobs; |  | 51021 | vector_Mat outputBlobs;
| 51070 | PyObject* pyobj_outBlobNames = NULL; |  | 51022 | PyObject* pyobj_outBlobNames = NULL;
| 51071 | vector_String outBlobNames; |  | 51023 | vector_String outBlobNames;
| 51072 |  |  | 51024 |
| 51073 | const char* keywords[] = { "outBlobNames", "outputBlobs", NULL }; |  | 51025 | const char* keywords[] = { "outBlobNames", "outputBlobs", NULL };
| 51074 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.forward", (char**)keywords, &pyobj_outBlobNames, &pyobj_outputBlobs) && |  | 51026 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.forward", (char**)keywords, &pyobj_outBlobNames, &pyobj_outputBlobs) &&
| 51075 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) && |  | 51027 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) &&
| 51076 | pyopencv_to_safe(pyobj_outBlobNames, outBlobNames, ArgInfo("outBlobNames", 0)) ) |  | 51028 | pyopencv_to_safe(pyobj_outBlobNames, outBlobNames, ArgInfo("outBlobNames", 0)) )
| 51077 | { |  | 51029 | {
| 51078 | ERRWRAP2(_self_->forward(outputBlobs, outBlobNames)); |  | 51030 | ERRWRAP2(_self_->forward(outputBlobs, outBlobNames));
| 51079 | return pyopencv_from(outputBlobs); |  | 51031 | return pyopencv_from(outputBlobs);
| 51080 | } |  | 51032 | }
| 51081 |  |  | 51033 |
| 51082 |  |  | 51034 |
| 51083 | pyPopulateArgumentConversionErrors(); |  | 51035 | pyPopulateArgumentConversionErrors();
| 51084 | } |  | 51036 | }
| 51085 |  |  | 51037 |
| 51086 |  |  | 51038 |
| 51087 | { |  | 51039 | {
| 51088 | PyObject* pyobj_outputBlobs = NULL; |  | 51040 | PyObject* pyobj_outputBlobs = NULL;
| 51089 | vector_UMat outputBlobs; |  | 51041 | vector_UMat outputBlobs;
| 51090 | PyObject* pyobj_outputName = NULL; |  | 51042 | PyObject* pyobj_outputName = NULL;
| 51091 | String outputName; |  | 51043 | String outputName;
| 51092 |  |  | 51044 |
| 51093 | const char* keywords[] = { "outputBlobs", "outputName", NULL }; |  | 51045 | const char* keywords[] = { "outputBlobs", "outputName", NULL };
| 51094 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dnn_Net.forward", (char**)keywords, &pyobj_outputBlobs, &pyobj_outputName) && |  | 51046 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dnn_Net.forward", (char**)keywords, &pyobj_outputBlobs, &pyobj_outputName) &&
| 51095 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) && |  | 51047 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) &&
| 51096 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) ) |  | 51048 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) )
| 51097 | { |  | 51049 | {
| 51098 | ERRWRAP2(_self_->forward(outputBlobs, outputName)); |  | 51050 | ERRWRAP2(_self_->forward(outputBlobs, outputName));
| 51099 | return pyopencv_from(outputBlobs); |  | 51051 | return pyopencv_from(outputBlobs);
| 51100 | } |  | 51052 | }
| 51101 |  |  | 51053 |
| 51102 |  |  | 51054 |
| 51103 | pyPopulateArgumentConversionErrors(); |  | 51055 | pyPopulateArgumentConversionErrors();
| 51104 | } |  | 51056 | }
| 51105 |  |  | 51057 |
| 51106 |  |  | 51058 |
| 51107 | { |  | 51059 | {
| 51108 | PyObject* pyobj_outputBlobs = NULL; |  | 51060 | PyObject* pyobj_outputBlobs = NULL;
| 51109 | vector_UMat outputBlobs; |  | 51061 | vector_UMat outputBlobs;
| 51110 | PyObject* pyobj_outBlobNames = NULL; |  | 51062 | PyObject* pyobj_outBlobNames = NULL;
| 51111 | vector_String outBlobNames; |  | 51063 | vector_String outBlobNames;
| 51112 |  |  | 51064 |
| 51113 | const char* keywords[] = { "outBlobNames", "outputBlobs", NULL }; |  | 51065 | const char* keywords[] = { "outBlobNames", "outputBlobs", NULL };
| 51114 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.forward", (char**)keywords, &pyobj_outBlobNames, &pyobj_outputBlobs) && |  | 51066 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.forward", (char**)keywords, &pyobj_outBlobNames, &pyobj_outputBlobs) &&
| 51115 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) && |  | 51067 | pyopencv_to_safe(pyobj_outputBlobs, outputBlobs, ArgInfo("outputBlobs", 9)) &&
| 51116 | pyopencv_to_safe(pyobj_outBlobNames, outBlobNames, ArgInfo("outBlobNames", 0)) ) |  | 51068 | pyopencv_to_safe(pyobj_outBlobNames, outBlobNames, ArgInfo("outBlobNames", 0)) )
| 51117 | { |  | 51069 | {
| 51118 | ERRWRAP2(_self_->forward(outputBlobs, outBlobNames)); |  | 51070 | ERRWRAP2(_self_->forward(outputBlobs, outBlobNames));
| 51119 | return pyopencv_from(outputBlobs); |  | 51071 | return pyopencv_from(outputBlobs);
| 51120 | } |  | 51072 | }
| 51121 |  |  | 51073 |
| 51122 |  |  | 51074 |
| 51123 | pyPopulateArgumentConversionErrors(); |  | 51075 | pyPopulateArgumentConversionErrors();
| 51124 | } |  | 51076 | }
| 51125 | pyRaiseCVOverloadException("forward"); |  | 51077 | pyRaiseCVOverloadException("forward");
| 51126 |  |  | 51078 |
| 51127 | return NULL; |  | 51079 | return NULL;
| 51128 | } |  | 51080 | }
| 51129 |  |  | 51081 |
| 51130 | static PyObject* pyopencv_cv_dnn_dnn_Net_forwardAndRetrieve(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51082 | static PyObject* pyopencv_cv_dnn_dnn_Net_forwardAndRetrieve(PyObject* self, PyObject* py_args, PyObject* kw)
| 51131 | { |  | 51083 | {
| 51132 | using namespace cv::dnn; |  | 51084 | using namespace cv::dnn;
| 51133 |  |  | 51085 |
| 51134 |  |  | 51086 |
| 51135 | cv::dnn::Net * self1 = 0; |  | 51087 | cv::dnn::Net * self1 = 0;
| 51136 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51088 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51137 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51089 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51138 | cv::dnn::Net* _self_ = (self1); |  | 51090 | cv::dnn::Net* _self_ = (self1);
| 51139 | vector_vector_Mat outputBlobs; |  | 51091 | vector_vector_Mat outputBlobs;
| 51140 | PyObject* pyobj_outBlobNames = NULL; |  | 51092 | PyObject* pyobj_outBlobNames = NULL;
| 51141 | vector_String outBlobNames; |  | 51093 | vector_String outBlobNames;
| 51142 |  |  | 51094 |
| 51143 | const char* keywords[] = { "outBlobNames", NULL }; |  | 51095 | const char* keywords[] = { "outBlobNames", NULL };
| 51144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.forwardAndRetrieve", (char**)keywords, &pyobj_outBlobNames) && |  | 51096 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.forwardAndRetrieve", (char**)keywords, &pyobj_outBlobNames) &&
| 51145 | pyopencv_to_safe(pyobj_outBlobNames, outBlobNames, ArgInfo("outBlobNames", 0)) ) |  | 51097 | pyopencv_to_safe(pyobj_outBlobNames, outBlobNames, ArgInfo("outBlobNames", 0)) )
| 51146 | { |  | 51098 | {
| 51147 | ERRWRAP2(_self_->forward(outputBlobs, outBlobNames)); |  | 51099 | ERRWRAP2(_self_->forward(outputBlobs, outBlobNames));
| 51148 | return pyopencv_from(outputBlobs); |  | 51100 | return pyopencv_from(outputBlobs);
| 51149 | } |  | 51101 | }
| 51150 |  |  | 51102 |
| 51151 | return NULL; |  | 51103 | return NULL;
| 51152 | } |  | 51104 | }
| 51153 |  |  | 51105 |
| 51154 | static PyObject* pyopencv_cv_dnn_dnn_Net_forwardAsync(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51106 | static PyObject* pyopencv_cv_dnn_dnn_Net_forwardAsync(PyObject* self, PyObject* py_args, PyObject* kw)
| 51155 | { |  | 51107 | {
| 51156 | using namespace cv::dnn; |  | 51108 | using namespace cv::dnn;
| 51157 |  |  | 51109 |
| 51158 |  |  | 51110 |
| 51159 | cv::dnn::Net * self1 = 0; |  | 51111 | cv::dnn::Net * self1 = 0;
| 51160 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51112 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51161 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51113 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51162 | cv::dnn::Net* _self_ = (self1); |  | 51114 | cv::dnn::Net* _self_ = (self1);
| 51163 | PyObject* pyobj_outputName = NULL; |  | 51115 | PyObject* pyobj_outputName = NULL;
| 51164 | String outputName; |  | 51116 | String outputName;
| 51165 | AsyncArray retval; |  | 51117 | AsyncArray retval;
| 51166 |  |  | 51118 |
| 51167 | const char* keywords[] = { "outputName", NULL }; |  | 51119 | const char* keywords[] = { "outputName", NULL };
| 51168 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_Net.forwardAsync", (char**)keywords, &pyobj_outputName) && |  | 51120 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dnn_Net.forwardAsync", (char**)keywords, &pyobj_outputName) &&
| 51169 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) ) |  | 51121 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) )
| 51170 | { |  | 51122 | {
| 51171 | ERRWRAP2(retval = _self_->forwardAsync(outputName)); |  | 51123 | ERRWRAP2(retval = _self_->forwardAsync(outputName));
| 51172 | return pyopencv_from(retval); |  | 51124 | return pyopencv_from(retval);
| 51173 | } |  | 51125 | }
| 51174 |  |  | 51126 |
| 51175 | return NULL; |  | 51127 | return NULL;
| 51176 | } |  | 51128 | }
| 51177 |  |  | 51129 |
| 51178 | static PyObject* pyopencv_cv_dnn_dnn_Net_getFLOPS(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51130 | static PyObject* pyopencv_cv_dnn_dnn_Net_getFLOPS(PyObject* self, PyObject* py_args, PyObject* kw)
| 51179 | { |  | 51131 | {
| 51180 | using namespace cv::dnn; |  | 51132 | using namespace cv::dnn;
| 51181 |  |  | 51133 |
| 51182 |  |  | 51134 |
| 51183 | cv::dnn::Net * self1 = 0; |  | 51135 | cv::dnn::Net * self1 = 0;
| 51184 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51136 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51185 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51137 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51186 | cv::dnn::Net* _self_ = (self1); |  | 51138 | cv::dnn::Net* _self_ = (self1);
| 51187 | pyPrepareArgumentConversionErrorsStorage(4); |  | 51139 | pyPrepareArgumentConversionErrorsStorage(4);
| 51188 |  |  | 51140 |
| 51189 | { |  | 51141 | {
| 51190 | PyObject* pyobj_netInputShapes = NULL; |  | 51142 | PyObject* pyobj_netInputShapes = NULL;
| 51191 | vector_MatShape netInputShapes; |  | 51143 | vector_MatShape netInputShapes;
| 51192 | int64 retval; |  | 51144 | int64 retval;
| 51193 |  |  | 51145 |
| 51194 | const char* keywords[] = { "netInputShapes", NULL }; |  | 51146 | const char* keywords[] = { "netInputShapes", NULL };
| 51195 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getFLOPS", (char**)keywords, &pyobj_netInputShapes) && |  | 51147 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getFLOPS", (char**)keywords, &pyobj_netInputShapes) &&
| 51196 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) ) |  | 51148 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) )
| 51197 | { |  | 51149 | {
| 51198 | ERRWRAP2(retval = _self_->getFLOPS(netInputShapes)); |  | 51150 | ERRWRAP2(retval = _self_->getFLOPS(netInputShapes));
| 51199 | return pyopencv_from(retval); |  | 51151 | return pyopencv_from(retval);
| 51200 | } |  | 51152 | }
| 51201 |  |  | 51153 |
| 51202 |  |  | 51154 |
| 51203 | pyPopulateArgumentConversionErrors(); |  | 51155 | pyPopulateArgumentConversionErrors();
| 51204 | } |  | 51156 | }
| 51205 |  |  | 51157 |
| 51206 |  |  | 51158 |
| 51207 | { |  | 51159 | {
| 51208 | PyObject* pyobj_netInputShape = NULL; |  | 51160 | PyObject* pyobj_netInputShape = NULL;
| 51209 | MatShape netInputShape; |  | 51161 | MatShape netInputShape;
| 51210 | int64 retval; |  | 51162 | int64 retval;
| 51211 |  |  | 51163 |
| 51212 | const char* keywords[] = { "netInputShape", NULL }; |  | 51164 | const char* keywords[] = { "netInputShape", NULL };
| 51213 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getFLOPS", (char**)keywords, &pyobj_netInputShape) && |  | 51165 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getFLOPS", (char**)keywords, &pyobj_netInputShape) &&
| 51214 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) ) |  | 51166 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) )
| 51215 | { |  | 51167 | {
| 51216 | ERRWRAP2(retval = _self_->getFLOPS(netInputShape)); |  | 51168 | ERRWRAP2(retval = _self_->getFLOPS(netInputShape));
| 51217 | return pyopencv_from(retval); |  | 51169 | return pyopencv_from(retval);
| 51218 | } |  | 51170 | }
| 51219 |  |  | 51171 |
| 51220 |  |  | 51172 |
| 51221 | pyPopulateArgumentConversionErrors(); |  | 51173 | pyPopulateArgumentConversionErrors();
| 51222 | } |  | 51174 | }
| 51223 |  |  | 51175 |
| 51224 |  |  | 51176 |
| 51225 | { |  | 51177 | {
| 51226 | PyObject* pyobj_layerId = NULL; |  | 51178 | PyObject* pyobj_layerId = NULL;
| 51227 | int layerId=0; |  | 51179 | int layerId=0;
| 51228 | PyObject* pyobj_netInputShapes = NULL; |  | 51180 | PyObject* pyobj_netInputShapes = NULL;
| 51229 | vector_MatShape netInputShapes; |  | 51181 | vector_MatShape netInputShapes;
| 51230 | int64 retval; |  | 51182 | int64 retval;
| 51231 |  |  | 51183 |
| 51232 | const char* keywords[] = { "layerId", "netInputShapes", NULL }; |  | 51184 | const char* keywords[] = { "layerId", "netInputShapes", NULL };
| 51233 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getFLOPS", (char**)keywords, &pyobj_layerId, &pyobj_netInputShapes) && |  | 51185 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getFLOPS", (char**)keywords, &pyobj_layerId, &pyobj_netInputShapes) &&
| 51234 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) && |  | 51186 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) &&
| 51235 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) ) |  | 51187 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) )
| 51236 | { |  | 51188 | {
| 51237 | ERRWRAP2(retval = _self_->getFLOPS(layerId, netInputShapes)); |  | 51189 | ERRWRAP2(retval = _self_->getFLOPS(layerId, netInputShapes));
| 51238 | return pyopencv_from(retval); |  | 51190 | return pyopencv_from(retval);
| 51239 | } |  | 51191 | }
| 51240 |  |  | 51192 |
| 51241 |  |  | 51193 |
| 51242 | pyPopulateArgumentConversionErrors(); |  | 51194 | pyPopulateArgumentConversionErrors();
| 51243 | } |  | 51195 | }
| 51244 |  |  | 51196 |
| 51245 |  |  | 51197 |
| 51246 | { |  | 51198 | {
| 51247 | PyObject* pyobj_layerId = NULL; |  | 51199 | PyObject* pyobj_layerId = NULL;
| 51248 | int layerId=0; |  | 51200 | int layerId=0;
| 51249 | PyObject* pyobj_netInputShape = NULL; |  | 51201 | PyObject* pyobj_netInputShape = NULL;
| 51250 | MatShape netInputShape; |  | 51202 | MatShape netInputShape;
| 51251 | int64 retval; |  | 51203 | int64 retval;
| 51252 |  |  | 51204 |
| 51253 | const char* keywords[] = { "layerId", "netInputShape", NULL }; |  | 51205 | const char* keywords[] = { "layerId", "netInputShape", NULL };
| 51254 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getFLOPS", (char**)keywords, &pyobj_layerId, &pyobj_netInputShape) && |  | 51206 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getFLOPS", (char**)keywords, &pyobj_layerId, &pyobj_netInputShape) &&
| 51255 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) && |  | 51207 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) &&
| 51256 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) ) |  | 51208 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) )
| 51257 | { |  | 51209 | {
| 51258 | ERRWRAP2(retval = _self_->getFLOPS(layerId, netInputShape)); |  | 51210 | ERRWRAP2(retval = _self_->getFLOPS(layerId, netInputShape));
| 51259 | return pyopencv_from(retval); |  | 51211 | return pyopencv_from(retval);
| 51260 | } |  | 51212 | }
| 51261 |  |  | 51213 |
| 51262 |  |  | 51214 |
| 51263 | pyPopulateArgumentConversionErrors(); |  | 51215 | pyPopulateArgumentConversionErrors();
| 51264 | } |  | 51216 | }
| 51265 | pyRaiseCVOverloadException("getFLOPS"); |  | 51217 | pyRaiseCVOverloadException("getFLOPS");
| 51266 |  |  | 51218 |
| 51267 | return NULL; |  | 51219 | return NULL;
| 51268 | } |  | 51220 | }
| 51269 |  |  | 51221 |
| 51270 | static PyObject* pyopencv_cv_dnn_dnn_Net_getInputDetails(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51222 | static PyObject* pyopencv_cv_dnn_dnn_Net_getInputDetails(PyObject* self, PyObject* py_args, PyObject* kw)
| 51271 | { |  | 51223 | {
| 51272 | using namespace cv::dnn; |  | 51224 | using namespace cv::dnn;
| 51273 |  |  | 51225 |
| 51274 |  |  | 51226 |
| 51275 | cv::dnn::Net * self1 = 0; |  | 51227 | cv::dnn::Net * self1 = 0;
| 51276 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51228 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51277 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51229 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51278 | cv::dnn::Net* _self_ = (self1); |  | 51230 | cv::dnn::Net* _self_ = (self1);
| 51279 | vector_float scales; |  | 51231 | vector_float scales;
| 51280 | vector_int zeropoints; |  | 51232 | vector_int zeropoints;
| 51281 |  |  | 51233 |
| 51282 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 51234 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 51283 | { |  | 51235 | {
| 51284 | ERRWRAP2(_self_->getInputDetails(scales, zeropoints)); |  | 51236 | ERRWRAP2(_self_->getInputDetails(scales, zeropoints));
| 51285 | return Py_BuildValue("(NN)", pyopencv_from(scales), pyopencv_from(zeropoints)); |  | 51237 | return Py_BuildValue("(NN)", pyopencv_from(scales), pyopencv_from(zeropoints));
| 51286 | } |  | 51238 | }
| 51287 |  |  | 51239 |
| 51288 | return NULL; |  | 51240 | return NULL;
| 51289 | } |  | 51241 | }
| 51290 |  |  | 51242 |
| 51291 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayer(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51243 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayer(PyObject* self, PyObject* py_args, PyObject* kw)
| 51292 | { |  | 51244 | {
| 51293 | using namespace cv::dnn; |  | 51245 | using namespace cv::dnn;
| 51294 |  |  | 51246 |
| 51295 |  |  | 51247 |
| 51296 | cv::dnn::Net * self1 = 0; |  | 51248 | cv::dnn::Net * self1 = 0;
| 51297 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51249 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51298 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51250 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51299 | cv::dnn::Net* _self_ = (self1); |  | 51251 | cv::dnn::Net* _self_ = (self1);
| 51300 | pyPrepareArgumentConversionErrorsStorage(3); |  | 51252 | pyPrepareArgumentConversionErrorsStorage(3);
| 51301 |  |  | 51253 |
| 51302 | { |  | 51254 | {
| 51303 | PyObject* pyobj_layerId = NULL; |  | 51255 | PyObject* pyobj_layerId = NULL;
| 51304 | int layerId=0; |  | 51256 | int layerId=0;
| 51305 | Ptr<Layer> retval; |  | 51257 | Ptr<Layer> retval;
| 51306 |  |  | 51258 |
| 51307 | const char* keywords[] = { "layerId", NULL }; |  | 51259 | const char* keywords[] = { "layerId", NULL };
| 51308 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayer", (char**)keywords, &pyobj_layerId) && |  | 51260 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayer", (char**)keywords, &pyobj_layerId) &&
| 51309 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) ) |  | 51261 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) )
| 51310 | { |  | 51262 | {
| 51311 | ERRWRAP2(retval = _self_->getLayer(layerId)); |  | 51263 | ERRWRAP2(retval = _self_->getLayer(layerId));
| 51312 | return pyopencv_from(retval); |  | 51264 | return pyopencv_from(retval);
| 51313 | } |  | 51265 | }
| 51314 |  |  | 51266 |
| 51315 |  |  | 51267 |
| 51316 | pyPopulateArgumentConversionErrors(); |  | 51268 | pyPopulateArgumentConversionErrors();
| 51317 | } |  | 51269 | }
| 51318 |  |  | 51270 |
| 51319 |  |  | 51271 |
| 51320 | { |  | 51272 | {
| 51321 | PyObject* pyobj_layerName = NULL; |  | 51273 | PyObject* pyobj_layerName = NULL;
| 51322 | String layerName; |  | 51274 | String layerName;
| 51323 | Ptr<Layer> retval; |  | 51275 | Ptr<Layer> retval;
| 51324 |  |  | 51276 |
| 51325 | const char* keywords[] = { "layerName", NULL }; |  | 51277 | const char* keywords[] = { "layerName", NULL };
| 51326 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayer", (char**)keywords, &pyobj_layerName) && |  | 51278 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayer", (char**)keywords, &pyobj_layerName) &&
| 51327 | pyopencv_to_safe(pyobj_layerName, layerName, ArgInfo("layerName", 0)) ) |  | 51279 | pyopencv_to_safe(pyobj_layerName, layerName, ArgInfo("layerName", 0)) )
| 51328 | { |  | 51280 | {
| 51329 | ERRWRAP2(retval = _self_->getLayer(layerName)); |  | 51281 | ERRWRAP2(retval = _self_->getLayer(layerName));
| 51330 | return pyopencv_from(retval); |  | 51282 | return pyopencv_from(retval);
| 51331 | } |  | 51283 | }
| 51332 |  |  | 51284 |
| 51333 |  |  | 51285 |
| 51334 | pyPopulateArgumentConversionErrors(); |  | 51286 | pyPopulateArgumentConversionErrors();
| 51335 | } |  | 51287 | }
| 51336 |  |  | 51288 |
| 51337 |  |  | 51289 |
| 51338 | { |  | 51290 | {
| 51339 | PyObject* pyobj_layerId = NULL; |  | 51291 | PyObject* pyobj_layerId = NULL;
| 51340 | LayerId layerId; |  | 51292 | LayerId layerId;
| 51341 | Ptr<Layer> retval; |  | 51293 | Ptr<Layer> retval;
| 51342 |  |  | 51294 |
| 51343 | const char* keywords[] = { "layerId", NULL }; |  | 51295 | const char* keywords[] = { "layerId", NULL };
| 51344 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayer", (char**)keywords, &pyobj_layerId) && |  | 51296 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayer", (char**)keywords, &pyobj_layerId) &&
| 51345 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) ) |  | 51297 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) )
| 51346 | { |  | 51298 | {
| 51347 | ERRWRAP2(retval = _self_->getLayer(layerId)); |  | 51299 | ERRWRAP2(retval = _self_->getLayer(layerId));
| 51348 | return pyopencv_from(retval); |  | 51300 | return pyopencv_from(retval);
| 51349 | } |  | 51301 | }
| 51350 |  |  | 51302 |
| 51351 |  |  | 51303 |
| 51352 | pyPopulateArgumentConversionErrors(); |  | 51304 | pyPopulateArgumentConversionErrors();
| 51353 | } |  | 51305 | }
| 51354 | pyRaiseCVOverloadException("getLayer"); |  | 51306 | pyRaiseCVOverloadException("getLayer");
| 51355 |  |  | 51307 |
| 51356 | return NULL; |  | 51308 | return NULL;
| 51357 | } |  | 51309 | }
| 51358 |  |  | 51310 |
| 51359 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayerId(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51311 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayerId(PyObject* self, PyObject* py_args, PyObject* kw)
| 51360 | { |  | 51312 | {
| 51361 | using namespace cv::dnn; |  | 51313 | using namespace cv::dnn;
| 51362 |  |  | 51314 |
| 51363 |  |  | 51315 |
| 51364 | cv::dnn::Net * self1 = 0; |  | 51316 | cv::dnn::Net * self1 = 0;
| 51365 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51317 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51366 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51318 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51367 | cv::dnn::Net* _self_ = (self1); |  | 51319 | cv::dnn::Net* _self_ = (self1);
| 51368 | PyObject* pyobj_layer = NULL; |  | 51320 | PyObject* pyobj_layer = NULL;
| 51369 | String layer; |  | 51321 | String layer;
| 51370 | int retval; |  | 51322 | int retval;
| 51371 |  |  | 51323 |
| 51372 | const char* keywords[] = { "layer", NULL }; |  | 51324 | const char* keywords[] = { "layer", NULL };
| 51373 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayerId", (char**)keywords, &pyobj_layer) && |  | 51325 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayerId", (char**)keywords, &pyobj_layer) &&
| 51374 | pyopencv_to_safe(pyobj_layer, layer, ArgInfo("layer", 0)) ) |  | 51326 | pyopencv_to_safe(pyobj_layer, layer, ArgInfo("layer", 0)) )
| 51375 | { |  | 51327 | {
| 51376 | ERRWRAP2(retval = _self_->getLayerId(layer)); |  | 51328 | ERRWRAP2(retval = _self_->getLayerId(layer));
| 51377 | return pyopencv_from(retval); |  | 51329 | return pyopencv_from(retval);
| 51378 | } |  | 51330 | }
| 51379 |  |  | 51331 |
| 51380 | return NULL; |  | 51332 | return NULL;
| 51381 | } |  | 51333 | }
| 51382 |  |  | 51334 |
| 51383 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayerNames(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51335 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayerNames(PyObject* self, PyObject* py_args, PyObject* kw)
| 51384 | { |  | 51336 | {
| 51385 | using namespace cv::dnn; |  | 51337 | using namespace cv::dnn;
| 51386 |  |  | 51338 |
| 51387 |  |  | 51339 |
| 51388 | cv::dnn::Net * self1 = 0; |  | 51340 | cv::dnn::Net * self1 = 0;
| 51389 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51341 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51390 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51342 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51391 | cv::dnn::Net* _self_ = (self1); |  | 51343 | cv::dnn::Net* _self_ = (self1);
| 51392 | std::vector<String> retval; |  | 51344 | std::vector<String> retval;
| 51393 |  |  | 51345 |
| 51394 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 51346 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 51395 | { |  | 51347 | {
| 51396 | ERRWRAP2(retval = _self_->getLayerNames()); |  | 51348 | ERRWRAP2(retval = _self_->getLayerNames());
| 51397 | return pyopencv_from(retval); |  | 51349 | return pyopencv_from(retval);
| 51398 | } |  | 51350 | }
| 51399 |  |  | 51351 |
| 51400 | return NULL; |  | 51352 | return NULL;
| 51401 | } |  | 51353 | }
| 51402 |  |  | 51354 |
| 51403 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayerTypes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51355 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayerTypes(PyObject* self, PyObject* py_args, PyObject* kw)
| 51404 | { |  | 51356 | {
| 51405 | using namespace cv::dnn; |  | 51357 | using namespace cv::dnn;
| 51406 |  |  | 51358 |
| 51407 |  |  | 51359 |
| 51408 | cv::dnn::Net * self1 = 0; |  | 51360 | cv::dnn::Net * self1 = 0;
| 51409 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51361 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51410 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51362 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51411 | cv::dnn::Net* _self_ = (self1); |  | 51363 | cv::dnn::Net* _self_ = (self1);
| 51412 | vector_String layersTypes; |  | 51364 | vector_String layersTypes;
| 51413 |  |  | 51365 |
| 51414 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 51366 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 51415 | { |  | 51367 | {
| 51416 | ERRWRAP2(_self_->getLayerTypes(layersTypes)); |  | 51368 | ERRWRAP2(_self_->getLayerTypes(layersTypes));
| 51417 | return pyopencv_from(layersTypes); |  | 51369 | return pyopencv_from(layersTypes);
| 51418 | } |  | 51370 | }
| 51419 |  |  | 51371 |
| 51420 | return NULL; |  | 51372 | return NULL;
| 51421 | } |  | 51373 | }
| 51422 |  |  | 51374 |
| 51423 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayersCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51375 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayersCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 51424 | { |  | 51376 | {
| 51425 | using namespace cv::dnn; |  | 51377 | using namespace cv::dnn;
| 51426 |  |  | 51378 |
| 51427 |  |  | 51379 |
| 51428 | cv::dnn::Net * self1 = 0; |  | 51380 | cv::dnn::Net * self1 = 0;
| 51429 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51381 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51430 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51382 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51431 | cv::dnn::Net* _self_ = (self1); |  | 51383 | cv::dnn::Net* _self_ = (self1);
| 51432 | PyObject* pyobj_layerType = NULL; |  | 51384 | PyObject* pyobj_layerType = NULL;
| 51433 | String layerType; |  | 51385 | String layerType;
| 51434 | int retval; |  | 51386 | int retval;
| 51435 |  |  | 51387 |
| 51436 | const char* keywords[] = { "layerType", NULL }; |  | 51388 | const char* keywords[] = { "layerType", NULL };
| 51437 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayersCount", (char**)keywords, &pyobj_layerType) && |  | 51389 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayersCount", (char**)keywords, &pyobj_layerType) &&
| 51438 | pyopencv_to_safe(pyobj_layerType, layerType, ArgInfo("layerType", 0)) ) |  | 51390 | pyopencv_to_safe(pyobj_layerType, layerType, ArgInfo("layerType", 0)) )
| 51439 | { |  | 51391 | {
| 51440 | ERRWRAP2(retval = _self_->getLayersCount(layerType)); |  | 51392 | ERRWRAP2(retval = _self_->getLayersCount(layerType));
| 51441 | return pyopencv_from(retval); |  | 51393 | return pyopencv_from(retval);
| 51442 | } |  | 51394 | }
| 51443 |  |  | 51395 |
| 51444 | return NULL; |  | 51396 | return NULL;
| 51445 | } |  | 51397 | }
| 51446 |  |  | 51398 |
| 51447 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayersShapes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51399 | static PyObject* pyopencv_cv_dnn_dnn_Net_getLayersShapes(PyObject* self, PyObject* py_args, PyObject* kw)
| 51448 | { |  | 51400 | {
| 51449 | using namespace cv::dnn; |  | 51401 | using namespace cv::dnn;
| 51450 |  |  | 51402 |
| 51451 |  |  | 51403 |
| 51452 | cv::dnn::Net * self1 = 0; |  | 51404 | cv::dnn::Net * self1 = 0;
| 51453 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51405 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51454 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51406 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51455 | cv::dnn::Net* _self_ = (self1); |  | 51407 | cv::dnn::Net* _self_ = (self1);
| 51456 | pyPrepareArgumentConversionErrorsStorage(2); |  | 51408 | pyPrepareArgumentConversionErrorsStorage(2);
| 51457 |  |  | 51409 |
| 51458 | { |  | 51410 | {
| 51459 | PyObject* pyobj_netInputShapes = NULL; |  | 51411 | PyObject* pyobj_netInputShapes = NULL;
| 51460 | vector_MatShape netInputShapes; |  | 51412 | vector_MatShape netInputShapes;
| 51461 | vector_int layersIds; |  | 51413 | vector_int layersIds;
| 51462 | vector_vector_MatShape inLayersShapes; |  | 51414 | vector_vector_MatShape inLayersShapes;
| 51463 | vector_vector_MatShape outLayersShapes; |  | 51415 | vector_vector_MatShape outLayersShapes;
| 51464 |  |  | 51416 |
| 51465 | const char* keywords[] = { "netInputShapes", NULL }; |  | 51417 | const char* keywords[] = { "netInputShapes", NULL };
| 51466 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayersShapes", (char**)keywords, &pyobj_netInputShapes) && |  | 51418 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayersShapes", (char**)keywords, &pyobj_netInputShapes) &&
| 51467 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) ) |  | 51419 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) )
| 51468 | { |  | 51420 | {
| 51469 | ERRWRAP2(_self_->getLayersShapes(netInputShapes, layersIds, inLayersShapes, outLayersShapes)); |  | 51421 | ERRWRAP2(_self_->getLayersShapes(netInputShapes, layersIds, inLayersShapes, outLayersShapes));
| 51470 | return Py_BuildValue("(NNN)", pyopencv_from(layersIds), pyopencv_from(inLayersShapes), pyopencv_from(outLayersShapes)); |  | 51422 | return Py_BuildValue("(NNN)", pyopencv_from(layersIds), pyopencv_from(inLayersShapes), pyopencv_from(outLayersShapes));
| 51471 | } |  | 51423 | }
| 51472 |  |  | 51424 |
| 51473 |  |  | 51425 |
| 51474 | pyPopulateArgumentConversionErrors(); |  | 51426 | pyPopulateArgumentConversionErrors();
| 51475 | } |  | 51427 | }
| 51476 |  |  | 51428 |
| 51477 |  |  | 51429 |
| 51478 | { |  | 51430 | {
| 51479 | PyObject* pyobj_netInputShape = NULL; |  | 51431 | PyObject* pyobj_netInputShape = NULL;
| 51480 | MatShape netInputShape; |  | 51432 | MatShape netInputShape;
| 51481 | vector_int layersIds; |  | 51433 | vector_int layersIds;
| 51482 | vector_vector_MatShape inLayersShapes; |  | 51434 | vector_vector_MatShape inLayersShapes;
| 51483 | vector_vector_MatShape outLayersShapes; |  | 51435 | vector_vector_MatShape outLayersShapes;
| 51484 |  |  | 51436 |
| 51485 | const char* keywords[] = { "netInputShape", NULL }; |  | 51437 | const char* keywords[] = { "netInputShape", NULL };
| 51486 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayersShapes", (char**)keywords, &pyobj_netInputShape) && |  | 51438 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getLayersShapes", (char**)keywords, &pyobj_netInputShape) &&
| 51487 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) ) |  | 51439 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) )
| 51488 | { |  | 51440 | {
| 51489 | ERRWRAP2(_self_->getLayersShapes(netInputShape, layersIds, inLayersShapes, outLayersShapes)); |  | 51441 | ERRWRAP2(_self_->getLayersShapes(netInputShape, layersIds, inLayersShapes, outLayersShapes));
| 51490 | return Py_BuildValue("(NNN)", pyopencv_from(layersIds), pyopencv_from(inLayersShapes), pyopencv_from(outLayersShapes)); |  | 51442 | return Py_BuildValue("(NNN)", pyopencv_from(layersIds), pyopencv_from(inLayersShapes), pyopencv_from(outLayersShapes));
| 51491 | } |  | 51443 | }
| 51492 |  |  | 51444 |
| 51493 |  |  | 51445 |
| 51494 | pyPopulateArgumentConversionErrors(); |  | 51446 | pyPopulateArgumentConversionErrors();
| 51495 | } |  | 51447 | }
| 51496 | pyRaiseCVOverloadException("getLayersShapes"); |  | 51448 | pyRaiseCVOverloadException("getLayersShapes");
| 51497 |  |  | 51449 |
| 51498 | return NULL; |  | 51450 | return NULL;
| 51499 | } |  | 51451 | }
| 51500 |  |  | 51452 |
| 51501 | static PyObject* pyopencv_cv_dnn_dnn_Net_getMemoryConsumption(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51453 | static PyObject* pyopencv_cv_dnn_dnn_Net_getMemoryConsumption(PyObject* self, PyObject* py_args, PyObject* kw)
| 51502 | { |  | 51454 | {
| 51503 | using namespace cv::dnn; |  | 51455 | using namespace cv::dnn;
| 51504 |  |  | 51456 |
| 51505 |  |  | 51457 |
| 51506 | cv::dnn::Net * self1 = 0; |  | 51458 | cv::dnn::Net * self1 = 0;
| 51507 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51459 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51508 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51460 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51509 | cv::dnn::Net* _self_ = (self1); |  | 51461 | cv::dnn::Net* _self_ = (self1);
| 51510 | pyPrepareArgumentConversionErrorsStorage(3); |  | 51462 | pyPrepareArgumentConversionErrorsStorage(3);
| 51511 |  |  | 51463 |
| 51512 | { |  | 51464 | {
| 51513 | PyObject* pyobj_netInputShape = NULL; |  | 51465 | PyObject* pyobj_netInputShape = NULL;
| 51514 | MatShape netInputShape; |  | 51466 | MatShape netInputShape;
| 51515 | size_t weights; |  | 51467 | size_t weights;
| 51516 | size_t blobs; |  | 51468 | size_t blobs;
| 51517 |  |  | 51469 |
| 51518 | const char* keywords[] = { "netInputShape", NULL }; |  | 51470 | const char* keywords[] = { "netInputShape", NULL };
| 51519 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getMemoryConsumption", (char**)keywords, &pyobj_netInputShape) && |  | 51471 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.getMemoryConsumption", (char**)keywords, &pyobj_netInputShape) &&
| 51520 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) ) |  | 51472 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) )
| 51521 | { |  | 51473 | {
| 51522 | ERRWRAP2(_self_->getMemoryConsumption(netInputShape, weights, blobs)); |  | 51474 | ERRWRAP2(_self_->getMemoryConsumption(netInputShape, weights, blobs));
| 51523 | return Py_BuildValue("(NN)", pyopencv_from(weights), pyopencv_from(blobs)); |  | 51475 | return Py_BuildValue("(NN)", pyopencv_from(weights), pyopencv_from(blobs));
| 51524 | } |  | 51476 | }
| 51525 |  |  | 51477 |
| 51526 |  |  | 51478 |
| 51527 | pyPopulateArgumentConversionErrors(); |  | 51479 | pyPopulateArgumentConversionErrors();
| 51528 | } |  | 51480 | }
| 51529 |  |  | 51481 |
| 51530 |  |  | 51482 |
| 51531 | { |  | 51483 | {
| 51532 | PyObject* pyobj_layerId = NULL; |  | 51484 | PyObject* pyobj_layerId = NULL;
| 51533 | int layerId=0; |  | 51485 | int layerId=0;
| 51534 | PyObject* pyobj_netInputShapes = NULL; |  | 51486 | PyObject* pyobj_netInputShapes = NULL;
| 51535 | vector_MatShape netInputShapes; |  | 51487 | vector_MatShape netInputShapes;
| 51536 | size_t weights; |  | 51488 | size_t weights;
| 51537 | size_t blobs; |  | 51489 | size_t blobs;
| 51538 |  |  | 51490 |
| 51539 | const char* keywords[] = { "layerId", "netInputShapes", NULL }; |  | 51491 | const char* keywords[] = { "layerId", "netInputShapes", NULL };
| 51540 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getMemoryConsumption", (char**)keywords, &pyobj_layerId, &pyobj_netInputShapes) && |  | 51492 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getMemoryConsumption", (char**)keywords, &pyobj_layerId, &pyobj_netInputShapes) &&
| 51541 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) && |  | 51493 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) &&
| 51542 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) ) |  | 51494 | pyopencv_to_safe(pyobj_netInputShapes, netInputShapes, ArgInfo("netInputShapes", 0)) )
| 51543 | { |  | 51495 | {
| 51544 | ERRWRAP2(_self_->getMemoryConsumption(layerId, netInputShapes, weights, blobs)); |  | 51496 | ERRWRAP2(_self_->getMemoryConsumption(layerId, netInputShapes, weights, blobs));
| 51545 | return Py_BuildValue("(NN)", pyopencv_from(weights), pyopencv_from(blobs)); |  | 51497 | return Py_BuildValue("(NN)", pyopencv_from(weights), pyopencv_from(blobs));
| 51546 | } |  | 51498 | }
| 51547 |  |  | 51499 |
| 51548 |  |  | 51500 |
| 51549 | pyPopulateArgumentConversionErrors(); |  | 51501 | pyPopulateArgumentConversionErrors();
| 51550 | } |  | 51502 | }
| 51551 |  |  | 51503 |
| 51552 |  |  | 51504 |
| 51553 | { |  | 51505 | {
| 51554 | PyObject* pyobj_layerId = NULL; |  | 51506 | PyObject* pyobj_layerId = NULL;
| 51555 | int layerId=0; |  | 51507 | int layerId=0;
| 51556 | PyObject* pyobj_netInputShape = NULL; |  | 51508 | PyObject* pyobj_netInputShape = NULL;
| 51557 | MatShape netInputShape; |  | 51509 | MatShape netInputShape;
| 51558 | size_t weights; |  | 51510 | size_t weights;
| 51559 | size_t blobs; |  | 51511 | size_t blobs;
| 51560 |  |  | 51512 |
| 51561 | const char* keywords[] = { "layerId", "netInputShape", NULL }; |  | 51513 | const char* keywords[] = { "layerId", "netInputShape", NULL };
| 51562 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getMemoryConsumption", (char**)keywords, &pyobj_layerId, &pyobj_netInputShape) && |  | 51514 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.getMemoryConsumption", (char**)keywords, &pyobj_layerId, &pyobj_netInputShape) &&
| 51563 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) && |  | 51515 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) &&
| 51564 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) ) |  | 51516 | pyopencv_to_safe(pyobj_netInputShape, netInputShape, ArgInfo("netInputShape", 0)) )
| 51565 | { |  | 51517 | {
| 51566 | ERRWRAP2(_self_->getMemoryConsumption(layerId, netInputShape, weights, blobs)); |  | 51518 | ERRWRAP2(_self_->getMemoryConsumption(layerId, netInputShape, weights, blobs));
| 51567 | return Py_BuildValue("(NN)", pyopencv_from(weights), pyopencv_from(blobs)); |  | 51519 | return Py_BuildValue("(NN)", pyopencv_from(weights), pyopencv_from(blobs));
| 51568 | } |  | 51520 | }
| 51569 |  |  | 51521 |
| 51570 |  |  | 51522 |
| 51571 | pyPopulateArgumentConversionErrors(); |  | 51523 | pyPopulateArgumentConversionErrors();
| 51572 | } |  | 51524 | }
| 51573 | pyRaiseCVOverloadException("getMemoryConsumption"); |  | 51525 | pyRaiseCVOverloadException("getMemoryConsumption");
| 51574 |  |  | 51526 |
| 51575 | return NULL; |  | 51527 | return NULL;
| 51576 | } |  | 51528 | }
| 51577 |  |  | 51529 |
| 51578 | static PyObject* pyopencv_cv_dnn_dnn_Net_getOutputDetails(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51530 | static PyObject* pyopencv_cv_dnn_dnn_Net_getOutputDetails(PyObject* self, PyObject* py_args, PyObject* kw)
| 51579 | { |  | 51531 | {
| 51580 | using namespace cv::dnn; |  | 51532 | using namespace cv::dnn;
| 51581 |  |  | 51533 |
| 51582 |  |  | 51534 |
| 51583 | cv::dnn::Net * self1 = 0; |  | 51535 | cv::dnn::Net * self1 = 0;
| 51584 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51536 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51585 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51537 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51586 | cv::dnn::Net* _self_ = (self1); |  | 51538 | cv::dnn::Net* _self_ = (self1);
| 51587 | vector_float scales; |  | 51539 | vector_float scales;
| 51588 | vector_int zeropoints; |  | 51540 | vector_int zeropoints;
| 51589 |  |  | 51541 |
| 51590 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 51542 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 51591 | { |  | 51543 | {
| 51592 | ERRWRAP2(_self_->getOutputDetails(scales, zeropoints)); |  | 51544 | ERRWRAP2(_self_->getOutputDetails(scales, zeropoints));
| 51593 | return Py_BuildValue("(NN)", pyopencv_from(scales), pyopencv_from(zeropoints)); |  | 51545 | return Py_BuildValue("(NN)", pyopencv_from(scales), pyopencv_from(zeropoints));
| 51594 | } |  | 51546 | }
| 51595 |  |  | 51547 |
| 51596 | return NULL; |  | 51548 | return NULL;
| 51597 | } |  | 51549 | }
| 51598 |  |  | 51550 |
| 51599 | static PyObject* pyopencv_cv_dnn_dnn_Net_getParam(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51551 | static PyObject* pyopencv_cv_dnn_dnn_Net_getParam(PyObject* self, PyObject* py_args, PyObject* kw)
| 51600 | { |  | 51552 | {
| 51601 | using namespace cv::dnn; |  | 51553 | using namespace cv::dnn;
| 51602 |  |  | 51554 |
| 51603 |  |  | 51555 |
| 51604 | cv::dnn::Net * self1 = 0; |  | 51556 | cv::dnn::Net * self1 = 0;
| 51605 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51557 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51606 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51558 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51607 | cv::dnn::Net* _self_ = (self1); |  | 51559 | cv::dnn::Net* _self_ = (self1);
| 51608 | pyPrepareArgumentConversionErrorsStorage(2); |  | 51560 | pyPrepareArgumentConversionErrorsStorage(2);
| 51609 |  |  | 51561 |
| 51610 | { |  | 51562 | {
| 51611 | PyObject* pyobj_layer = NULL; |  | 51563 | PyObject* pyobj_layer = NULL;
| 51612 | int layer=0; |  | 51564 | int layer=0;
| 51613 | PyObject* pyobj_numParam = NULL; |  | 51565 | PyObject* pyobj_numParam = NULL;
| 51614 | int numParam=0; |  | 51566 | int numParam=0;
| 51615 | Mat retval; |  | 51567 | Mat retval;
| 51616 |  |  | 51568 |
| 51617 | const char* keywords[] = { "layer", "numParam", NULL }; |  | 51569 | const char* keywords[] = { "layer", "numParam", NULL };
| 51618 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.getParam", (char**)keywords, &pyobj_layer, &pyobj_numParam) && |  | 51570 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.getParam", (char**)keywords, &pyobj_layer, &pyobj_numParam) &&
| 51619 | pyopencv_to_safe(pyobj_layer, layer, ArgInfo("layer", 0)) && |  | 51571 | pyopencv_to_safe(pyobj_layer, layer, ArgInfo("layer", 0)) &&
| 51620 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) ) |  | 51572 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) )
| 51621 | { |  | 51573 | {
| 51622 | ERRWRAP2(retval = _self_->getParam(layer, numParam)); |  | 51574 | ERRWRAP2(retval = _self_->getParam(layer, numParam));
| 51623 | return pyopencv_from(retval); |  | 51575 | return pyopencv_from(retval);
| 51624 | } |  | 51576 | }
| 51625 |  |  | 51577 |
| 51626 |  |  | 51578 |
| 51627 | pyPopulateArgumentConversionErrors(); |  | 51579 | pyPopulateArgumentConversionErrors();
| 51628 | } |  | 51580 | }
| 51629 |  |  | 51581 |
| 51630 |  |  | 51582 |
| 51631 | { |  | 51583 | {
| 51632 | PyObject* pyobj_layerName = NULL; |  | 51584 | PyObject* pyobj_layerName = NULL;
| 51633 | String layerName; |  | 51585 | String layerName;
| 51634 | PyObject* pyobj_numParam = NULL; |  | 51586 | PyObject* pyobj_numParam = NULL;
| 51635 | int numParam=0; |  | 51587 | int numParam=0;
| 51636 | Mat retval; |  | 51588 | Mat retval;
| 51637 |  |  | 51589 |
| 51638 | const char* keywords[] = { "layerName", "numParam", NULL }; |  | 51590 | const char* keywords[] = { "layerName", "numParam", NULL };
| 51639 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.getParam", (char**)keywords, &pyobj_layerName, &pyobj_numParam) && |  | 51591 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_Net.getParam", (char**)keywords, &pyobj_layerName, &pyobj_numParam) &&
| 51640 | pyopencv_to_safe(pyobj_layerName, layerName, ArgInfo("layerName", 0)) && |  | 51592 | pyopencv_to_safe(pyobj_layerName, layerName, ArgInfo("layerName", 0)) &&
| 51641 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) ) |  | 51593 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) )
| 51642 | { |  | 51594 | {
| 51643 | ERRWRAP2(retval = _self_->getParam(layerName, numParam)); |  | 51595 | ERRWRAP2(retval = _self_->getParam(layerName, numParam));
| 51644 | return pyopencv_from(retval); |  | 51596 | return pyopencv_from(retval);
| 51645 | } |  | 51597 | }
| 51646 |  |  | 51598 |
| 51647 |  |  | 51599 |
| 51648 | pyPopulateArgumentConversionErrors(); |  | 51600 | pyPopulateArgumentConversionErrors();
| 51649 | } |  | 51601 | }
| 51650 | pyRaiseCVOverloadException("getParam"); |  | 51602 | pyRaiseCVOverloadException("getParam");
| 51651 |  |  | 51603 |
| 51652 | return NULL; |  | 51604 | return NULL;
| 51653 | } |  | 51605 | }
| 51654 |  |  | 51606 |
| 51655 | static PyObject* pyopencv_cv_dnn_dnn_Net_getPerfProfile(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51607 | static PyObject* pyopencv_cv_dnn_dnn_Net_getPerfProfile(PyObject* self, PyObject* py_args, PyObject* kw)
| 51656 | { |  | 51608 | {
| 51657 | using namespace cv::dnn; |  | 51609 | using namespace cv::dnn;
| 51658 |  |  | 51610 |
| 51659 |  |  | 51611 |
| 51660 | cv::dnn::Net * self1 = 0; |  | 51612 | cv::dnn::Net * self1 = 0;
| 51661 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51613 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51662 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51614 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51663 | cv::dnn::Net* _self_ = (self1); |  | 51615 | cv::dnn::Net* _self_ = (self1);
| 51664 | vector_double timings; |  | 51616 | vector_double timings;
| 51665 | int64 retval; |  | 51617 | int64 retval;
| 51666 |  |  | 51618 |
| 51667 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 51619 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 51668 | { |  | 51620 | {
| 51669 | ERRWRAP2(retval = _self_->getPerfProfile(timings)); |  | 51621 | ERRWRAP2(retval = _self_->getPerfProfile(timings));
| 51670 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(timings)); |  | 51622 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(timings));
| 51671 | } |  | 51623 | }
| 51672 |  |  | 51624 |
| 51673 | return NULL; |  | 51625 | return NULL;
| 51674 | } |  | 51626 | }
| 51675 |  |  | 51627 |
| 51676 | static PyObject* pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51628 | static PyObject* pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayers(PyObject* self, PyObject* py_args, PyObject* kw)
| 51677 | { |  | 51629 | {
| 51678 | using namespace cv::dnn; |  | 51630 | using namespace cv::dnn;
| 51679 |  |  | 51631 |
| 51680 |  |  | 51632 |
| 51681 | cv::dnn::Net * self1 = 0; |  | 51633 | cv::dnn::Net * self1 = 0;
| 51682 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51634 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51683 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51635 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51684 | cv::dnn::Net* _self_ = (self1); |  | 51636 | cv::dnn::Net* _self_ = (self1);
| 51685 | std::vector<int> retval; |  | 51637 | std::vector<int> retval;
| 51686 |  |  | 51638 |
| 51687 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 51639 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 51688 | { |  | 51640 | {
| 51689 | ERRWRAP2(retval = _self_->getUnconnectedOutLayers()); |  | 51641 | ERRWRAP2(retval = _self_->getUnconnectedOutLayers());
| 51690 | return pyopencv_from(retval); |  | 51642 | return pyopencv_from(retval);
| 51691 | } |  | 51643 | }
| 51692 |  |  | 51644 |
| 51693 | return NULL; |  | 51645 | return NULL;
| 51694 | } |  | 51646 | }
| 51695 |  |  | 51647 |
| 51696 | static PyObject* pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayersNames(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51648 | static PyObject* pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayersNames(PyObject* self, PyObject* py_args, PyObject* kw)
| 51697 | { |  | 51649 | {
| 51698 | using namespace cv::dnn; |  | 51650 | using namespace cv::dnn;
| 51699 |  |  | 51651 |
| 51700 |  |  | 51652 |
| 51701 | cv::dnn::Net * self1 = 0; |  | 51653 | cv::dnn::Net * self1 = 0;
| 51702 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51654 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51703 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51655 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51704 | cv::dnn::Net* _self_ = (self1); |  | 51656 | cv::dnn::Net* _self_ = (self1);
| 51705 | std::vector<String> retval; |  | 51657 | std::vector<String> retval;
| 51706 |  |  | 51658 |
| 51707 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 51659 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 51708 | { |  | 51660 | {
| 51709 | ERRWRAP2(retval = _self_->getUnconnectedOutLayersNames()); |  | 51661 | ERRWRAP2(retval = _self_->getUnconnectedOutLayersNames());
| 51710 | return pyopencv_from(retval); |  | 51662 | return pyopencv_from(retval);
| 51711 | } |  | 51663 | }
| 51712 |  |  | 51664 |
| 51713 | return NULL; |  | 51665 | return NULL;
| 51714 | } |  | 51666 | }
| 51715 |  |  | 51667 |
| 51716 | static PyObject* pyopencv_cv_dnn_dnn_Net_quantize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51668 | static PyObject* pyopencv_cv_dnn_dnn_Net_quantize(PyObject* self, PyObject* py_args, PyObject* kw)
| 51717 | { |  | 51669 | {
| 51718 | using namespace cv::dnn; |  | 51670 | using namespace cv::dnn;
| 51719 |  |  | 51671 |
| 51720 |  |  | 51672 |
| 51721 | cv::dnn::Net * self1 = 0; |  | 51673 | cv::dnn::Net * self1 = 0;
| 51722 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51674 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51723 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51675 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51724 | cv::dnn::Net* _self_ = (self1); |  | 51676 | cv::dnn::Net* _self_ = (self1);
| 51725 | pyPrepareArgumentConversionErrorsStorage(2); |  | 51677 | pyPrepareArgumentConversionErrorsStorage(2);
| 51726 |  |  | 51678 |
| 51727 | { |  | 51679 | {
| 51728 | PyObject* pyobj_calibData = NULL; |  | 51680 | PyObject* pyobj_calibData = NULL;
| 51729 | vector_Mat calibData; |  | 51681 | vector_Mat calibData;
| 51730 | PyObject* pyobj_inputsDtype = NULL; |  | 51682 | PyObject* pyobj_inputsDtype = NULL;
| 51731 | int inputsDtype=0; |  | 51683 | int inputsDtype=0;
| 51732 | PyObject* pyobj_outputsDtype = NULL; |  | 51684 | PyObject* pyobj_outputsDtype = NULL;
| 51733 | int outputsDtype=0; |  | 51685 | int outputsDtype=0;
| 51734 | PyObject* pyobj_perChannel = NULL; |  | 51686 | PyObject* pyobj_perChannel = NULL;
| 51735 | bool perChannel=true; |  | 51687 | bool perChannel=true;
| 51736 | Net retval; |  | 51688 | Net retval;
| 51737 |  |  | 51689 |
| 51738 | const char* keywords[] = { "calibData", "inputsDtype", "outputsDtype", "perChannel", NULL }; |  | 51690 | const char* keywords[] = { "calibData", "inputsDtype", "outputsDtype", "perChannel", NULL };
| 51739 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:dnn_Net.quantize", (char**)keywords, &pyobj_calibData, &pyobj_inputsDtype, &pyobj_outputsDtype, &pyobj_perChannel) && |  | 51691 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:dnn_Net.quantize", (char**)keywords, &pyobj_calibData, &pyobj_inputsDtype, &pyobj_outputsDtype, &pyobj_perChannel) &&
| 51740 | pyopencv_to_safe(pyobj_calibData, calibData, ArgInfo("calibData", 0)) && |  | 51692 | pyopencv_to_safe(pyobj_calibData, calibData, ArgInfo("calibData", 0)) &&
| 51741 | pyopencv_to_safe(pyobj_inputsDtype, inputsDtype, ArgInfo("inputsDtype", 0)) && |  | 51693 | pyopencv_to_safe(pyobj_inputsDtype, inputsDtype, ArgInfo("inputsDtype", 0)) &&
| 51742 | pyopencv_to_safe(pyobj_outputsDtype, outputsDtype, ArgInfo("outputsDtype", 0)) && |  | 51694 | pyopencv_to_safe(pyobj_outputsDtype, outputsDtype, ArgInfo("outputsDtype", 0)) &&
| 51743 | pyopencv_to_safe(pyobj_perChannel, perChannel, ArgInfo("perChannel", 0)) ) |  | 51695 | pyopencv_to_safe(pyobj_perChannel, perChannel, ArgInfo("perChannel", 0)) )
| 51744 | { |  | 51696 | {
| 51745 | ERRWRAP2(retval = _self_->quantize(calibData, inputsDtype, outputsDtype, perChannel)); |  | 51697 | ERRWRAP2(retval = _self_->quantize(calibData, inputsDtype, outputsDtype, perChannel));
| 51746 | return pyopencv_from(retval); |  | 51698 | return pyopencv_from(retval);
| 51747 | } |  | 51699 | }
| 51748 |  |  | 51700 |
| 51749 |  |  | 51701 |
| 51750 | pyPopulateArgumentConversionErrors(); |  | 51702 | pyPopulateArgumentConversionErrors();
| 51751 | } |  | 51703 | }
| 51752 |  |  | 51704 |
| 51753 |  |  | 51705 |
| 51754 | { |  | 51706 | {
| 51755 | PyObject* pyobj_calibData = NULL; |  | 51707 | PyObject* pyobj_calibData = NULL;
| 51756 | vector_UMat calibData; |  | 51708 | vector_UMat calibData;
| 51757 | PyObject* pyobj_inputsDtype = NULL; |  | 51709 | PyObject* pyobj_inputsDtype = NULL;
| 51758 | int inputsDtype=0; |  | 51710 | int inputsDtype=0;
| 51759 | PyObject* pyobj_outputsDtype = NULL; |  | 51711 | PyObject* pyobj_outputsDtype = NULL;
| 51760 | int outputsDtype=0; |  | 51712 | int outputsDtype=0;
| 51761 | PyObject* pyobj_perChannel = NULL; |  | 51713 | PyObject* pyobj_perChannel = NULL;
| 51762 | bool perChannel=true; |  | 51714 | bool perChannel=true;
| 51763 | Net retval; |  | 51715 | Net retval;
| 51764 |  |  | 51716 |
| 51765 | const char* keywords[] = { "calibData", "inputsDtype", "outputsDtype", "perChannel", NULL }; |  | 51717 | const char* keywords[] = { "calibData", "inputsDtype", "outputsDtype", "perChannel", NULL };
| 51766 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:dnn_Net.quantize", (char**)keywords, &pyobj_calibData, &pyobj_inputsDtype, &pyobj_outputsDtype, &pyobj_perChannel) && |  | 51718 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:dnn_Net.quantize", (char**)keywords, &pyobj_calibData, &pyobj_inputsDtype, &pyobj_outputsDtype, &pyobj_perChannel) &&
| 51767 | pyopencv_to_safe(pyobj_calibData, calibData, ArgInfo("calibData", 0)) && |  | 51719 | pyopencv_to_safe(pyobj_calibData, calibData, ArgInfo("calibData", 0)) &&
| 51768 | pyopencv_to_safe(pyobj_inputsDtype, inputsDtype, ArgInfo("inputsDtype", 0)) && |  | 51720 | pyopencv_to_safe(pyobj_inputsDtype, inputsDtype, ArgInfo("inputsDtype", 0)) &&
| 51769 | pyopencv_to_safe(pyobj_outputsDtype, outputsDtype, ArgInfo("outputsDtype", 0)) && |  | 51721 | pyopencv_to_safe(pyobj_outputsDtype, outputsDtype, ArgInfo("outputsDtype", 0)) &&
| 51770 | pyopencv_to_safe(pyobj_perChannel, perChannel, ArgInfo("perChannel", 0)) ) |  | 51722 | pyopencv_to_safe(pyobj_perChannel, perChannel, ArgInfo("perChannel", 0)) )
| 51771 | { |  | 51723 | {
| 51772 | ERRWRAP2(retval = _self_->quantize(calibData, inputsDtype, outputsDtype, perChannel)); |  | 51724 | ERRWRAP2(retval = _self_->quantize(calibData, inputsDtype, outputsDtype, perChannel));
| 51773 | return pyopencv_from(retval); |  | 51725 | return pyopencv_from(retval);
| 51774 | } |  | 51726 | }
| 51775 |  |  | 51727 |
| 51776 |  |  | 51728 |
| 51777 | pyPopulateArgumentConversionErrors(); |  | 51729 | pyPopulateArgumentConversionErrors();
| 51778 | } |  | 51730 | }
| 51779 | pyRaiseCVOverloadException("quantize"); |  | 51731 | pyRaiseCVOverloadException("quantize");
| 51780 |  |  | 51732 |
| 51781 | return NULL; |  | 51733 | return NULL;
| 51782 | } |  | 51734 | }
| 51783 |  |  | 51735 |
| 51784 | static PyObject* pyopencv_cv_dnn_dnn_Net_readFromModelOptimizer_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51736 | static PyObject* pyopencv_cv_dnn_dnn_Net_readFromModelOptimizer_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 51785 | { |  | 51737 | {
| 51786 | using namespace cv::dnn; |  | 51738 | using namespace cv::dnn;
| 51787 |  |  | 51739 |
| 51788 | pyPrepareArgumentConversionErrorsStorage(2); |  | 51740 | pyPrepareArgumentConversionErrorsStorage(2);
| 51789 |  |  | 51741 |
| 51790 | { |  | 51742 | {
| 51791 | PyObject* pyobj_xml = NULL; |  | 51743 | PyObject* pyobj_xml = NULL;
| 51792 | String xml; |  | 51744 | String xml;
| 51793 | PyObject* pyobj_bin = NULL; |  | 51745 | PyObject* pyobj_bin = NULL;
| 51794 | String bin; |  | 51746 | String bin;
| 51795 | Net retval; |  | 51747 | Net retval;
| 51796 |  |  | 51748 |
| 51797 | const char* keywords[] = { "xml", "bin", NULL }; |  | 51749 | const char* keywords[] = { "xml", "bin", NULL };
| 51798 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.readFromModelOptimizer", (char**)keywords, &pyobj_xml, &pyobj_bin) && |  | 51750 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.readFromModelOptimizer", (char**)keywords, &pyobj_xml, &pyobj_bin) &&
| 51799 | pyopencv_to_safe(pyobj_xml, xml, ArgInfo("xml", 4)) && |  | 51751 | pyopencv_to_safe(pyobj_xml, xml, ArgInfo("xml", 4)) &&
| 51800 | pyopencv_to_safe(pyobj_bin, bin, ArgInfo("bin", 4)) ) |  | 51752 | pyopencv_to_safe(pyobj_bin, bin, ArgInfo("bin", 4)) )
| 51801 | { |  | 51753 | {
| 51802 | ERRWRAP2(retval = cv::dnn::Net::readFromModelOptimizer(xml, bin)); |  | 51754 | ERRWRAP2(retval = cv::dnn::Net::readFromModelOptimizer(xml, bin));
| 51803 | return pyopencv_from(retval); |  | 51755 | return pyopencv_from(retval);
| 51804 | } |  | 51756 | }
| 51805 |  |  | 51757 |
| 51806 |  |  | 51758 |
| 51807 | pyPopulateArgumentConversionErrors(); |  | 51759 | pyPopulateArgumentConversionErrors();
| 51808 | } |  | 51760 | }
| 51809 |  |  | 51761 |
| 51810 |  |  | 51762 |
| 51811 | { |  | 51763 | {
| 51812 | PyObject* pyobj_bufferModelConfig = NULL; |  | 51764 | PyObject* pyobj_bufferModelConfig = NULL;
| 51813 | vector_uchar bufferModelConfig; |  | 51765 | vector_uchar bufferModelConfig;
| 51814 | PyObject* pyobj_bufferWeights = NULL; |  | 51766 | PyObject* pyobj_bufferWeights = NULL;
| 51815 | vector_uchar bufferWeights; |  | 51767 | vector_uchar bufferWeights;
| 51816 | Net retval; |  | 51768 | Net retval;
| 51817 |  |  | 51769 |
| 51818 | const char* keywords[] = { "bufferModelConfig", "bufferWeights", NULL }; |  | 51770 | const char* keywords[] = { "bufferModelConfig", "bufferWeights", NULL };
| 51819 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.readFromModelOptimizer", (char**)keywords, &pyobj_bufferModelConfig, &pyobj_bufferWeights) && |  | 51771 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.readFromModelOptimizer", (char**)keywords, &pyobj_bufferModelConfig, &pyobj_bufferWeights) &&
| 51820 | pyopencv_to_safe(pyobj_bufferModelConfig, bufferModelConfig, ArgInfo("bufferModelConfig", 0)) && |  | 51772 | pyopencv_to_safe(pyobj_bufferModelConfig, bufferModelConfig, ArgInfo("bufferModelConfig", 0)) &&
| 51821 | pyopencv_to_safe(pyobj_bufferWeights, bufferWeights, ArgInfo("bufferWeights", 0)) ) |  | 51773 | pyopencv_to_safe(pyobj_bufferWeights, bufferWeights, ArgInfo("bufferWeights", 0)) )
| 51822 | { |  | 51774 | {
| 51823 | ERRWRAP2(retval = cv::dnn::Net::readFromModelOptimizer(bufferModelConfig, bufferWeights)); |  | 51775 | ERRWRAP2(retval = cv::dnn::Net::readFromModelOptimizer(bufferModelConfig, bufferWeights));
| 51824 | return pyopencv_from(retval); |  | 51776 | return pyopencv_from(retval);
| 51825 | } |  | 51777 | }
| 51826 |  |  | 51778 |
| 51827 |  |  | 51779 |
| 51828 | pyPopulateArgumentConversionErrors(); |  | 51780 | pyPopulateArgumentConversionErrors();
| 51829 | } |  | 51781 | }
| 51830 | pyRaiseCVOverloadException("readFromModelOptimizer"); |  | 51782 | pyRaiseCVOverloadException("readFromModelOptimizer");
| 51831 |  |  | 51783 |
| 51832 | return NULL; |  | 51784 | return NULL;
| 51833 | } |  | 51785 | }
| 51834 |  |  | 51786 |
| 51835 | static PyObject* pyopencv_cv_dnn_dnn_Net_registerOutput(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51787 | static PyObject* pyopencv_cv_dnn_dnn_Net_registerOutput(PyObject* self, PyObject* py_args, PyObject* kw)
| 51836 | { |  | 51788 | {
| 51837 | using namespace cv::dnn; |  | 51789 | using namespace cv::dnn;
| 51838 |  |  | 51790 |
| 51839 |  |  | 51791 |
| 51840 | cv::dnn::Net * self1 = 0; |  | 51792 | cv::dnn::Net * self1 = 0;
| 51841 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51793 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51842 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51794 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51843 | cv::dnn::Net* _self_ = (self1); |  | 51795 | cv::dnn::Net* _self_ = (self1);
| 51844 | PyObject* pyobj_outputName = NULL; |  | 51796 | PyObject* pyobj_outputName = NULL;
| 51845 | std::string outputName; |  | 51797 | std::string outputName;
| 51846 | PyObject* pyobj_layerId = NULL; |  | 51798 | PyObject* pyobj_layerId = NULL;
| 51847 | int layerId=0; |  | 51799 | int layerId=0;
| 51848 | PyObject* pyobj_outputPort = NULL; |  | 51800 | PyObject* pyobj_outputPort = NULL;
| 51849 | int outputPort=0; |  | 51801 | int outputPort=0;
| 51850 | int retval; |  | 51802 | int retval;
| 51851 |  |  | 51803 |
| 51852 | const char* keywords[] = { "outputName", "layerId", "outputPort", NULL }; |  | 51804 | const char* keywords[] = { "outputName", "layerId", "outputPort", NULL };
| 51853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:dnn_Net.registerOutput", (char**)keywords, &pyobj_outputName, &pyobj_layerId, &pyobj_outputPort) && |  | 51805 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:dnn_Net.registerOutput", (char**)keywords, &pyobj_outputName, &pyobj_layerId, &pyobj_outputPort) &&
| 51854 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) && |  | 51806 | pyopencv_to_safe(pyobj_outputName, outputName, ArgInfo("outputName", 0)) &&
| 51855 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) && |  | 51807 | pyopencv_to_safe(pyobj_layerId, layerId, ArgInfo("layerId", 0)) &&
| 51856 | pyopencv_to_safe(pyobj_outputPort, outputPort, ArgInfo("outputPort", 0)) ) |  | 51808 | pyopencv_to_safe(pyobj_outputPort, outputPort, ArgInfo("outputPort", 0)) )
| 51857 | { |  | 51809 | {
| 51858 | ERRWRAP2(retval = _self_->registerOutput(outputName, layerId, outputPort)); |  | 51810 | ERRWRAP2(retval = _self_->registerOutput(outputName, layerId, outputPort));
| 51859 | return pyopencv_from(retval); |  | 51811 | return pyopencv_from(retval);
| 51860 | } |  | 51812 | }
| 51861 |  |  | 51813 |
| 51862 | return NULL; |  | 51814 | return NULL;
| 51863 | } |  | 51815 | }
| 51864 |  |  | 51816 |
| 51865 | static PyObject* pyopencv_cv_dnn_dnn_Net_setHalideScheduler(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51817 | static PyObject* pyopencv_cv_dnn_dnn_Net_setHalideScheduler(PyObject* self, PyObject* py_args, PyObject* kw)
| 51866 | { |  | 51818 | {
| 51867 | using namespace cv::dnn; |  | 51819 | using namespace cv::dnn;
| 51868 |  |  | 51820 |
| 51869 |  |  | 51821 |
| 51870 | cv::dnn::Net * self1 = 0; |  | 51822 | cv::dnn::Net * self1 = 0;
| 51871 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51823 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51872 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51824 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51873 | cv::dnn::Net* _self_ = (self1); |  | 51825 | cv::dnn::Net* _self_ = (self1);
| 51874 | PyObject* pyobj_scheduler = NULL; |  | 51826 | PyObject* pyobj_scheduler = NULL;
| 51875 | String scheduler; |  | 51827 | String scheduler;
| 51876 |  |  | 51828 |
| 51877 | const char* keywords[] = { "scheduler", NULL }; |  | 51829 | const char* keywords[] = { "scheduler", NULL };
| 51878 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setHalideScheduler", (char**)keywords, &pyobj_scheduler) && |  | 51830 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setHalideScheduler", (char**)keywords, &pyobj_scheduler) &&
| 51879 | pyopencv_to_safe(pyobj_scheduler, scheduler, ArgInfo("scheduler", 0)) ) |  | 51831 | pyopencv_to_safe(pyobj_scheduler, scheduler, ArgInfo("scheduler", 0)) )
| 51880 | { |  | 51832 | {
| 51881 | ERRWRAP2(_self_->setHalideScheduler(scheduler)); |  | 51833 | ERRWRAP2(_self_->setHalideScheduler(scheduler));
| 51882 | Py_RETURN_NONE; |  | 51834 | Py_RETURN_NONE;
| 51883 | } |  | 51835 | }
| 51884 |  |  | 51836 |
| 51885 | return NULL; |  | 51837 | return NULL;
| 51886 | } |  | 51838 | }
| 51887 |  |  | 51839 |
| 51888 | static PyObject* pyopencv_cv_dnn_dnn_Net_setInput(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51840 | static PyObject* pyopencv_cv_dnn_dnn_Net_setInput(PyObject* self, PyObject* py_args, PyObject* kw)
| 51889 | { |  | 51841 | {
| 51890 | using namespace cv::dnn; |  | 51842 | using namespace cv::dnn;
| 51891 |  |  | 51843 |
| 51892 |  |  | 51844 |
| 51893 | cv::dnn::Net * self1 = 0; |  | 51845 | cv::dnn::Net * self1 = 0;
| 51894 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51846 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51895 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51847 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51896 | cv::dnn::Net* _self_ = (self1); |  | 51848 | cv::dnn::Net* _self_ = (self1);
| 51897 | pyPrepareArgumentConversionErrorsStorage(2); |  | 51849 | pyPrepareArgumentConversionErrorsStorage(2);
| 51898 |  |  | 51850 |
| 51899 | { |  | 51851 | {
| 51900 | PyObject* pyobj_blob = NULL; |  | 51852 | PyObject* pyobj_blob = NULL;
| 51901 | Mat blob; |  | 51853 | Mat blob;
| 51902 | PyObject* pyobj_name = NULL; |  | 51854 | PyObject* pyobj_name = NULL;
| 51903 | String name=""; |  | 51855 | String name="";
| 51904 | PyObject* pyobj_scalefactor = NULL; |  | 51856 | PyObject* pyobj_scalefactor = NULL;
| 51905 | double scalefactor=1.0; |  | 51857 | double scalefactor=1.0;
| 51906 | PyObject* pyobj_mean = NULL; |  | 51858 | PyObject* pyobj_mean = NULL;
| 51907 | Scalar mean; |  | 51859 | Scalar mean;
| 51908 |  |  | 51860 |
| 51909 | const char* keywords[] = { "blob", "name", "scalefactor", "mean", NULL }; |  | 51861 | const char* keywords[] = { "blob", "name", "scalefactor", "mean", NULL };
| 51910 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:dnn_Net.setInput", (char**)keywords, &pyobj_blob, &pyobj_name, &pyobj_scalefactor, &pyobj_mean) && |  | 51862 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:dnn_Net.setInput", (char**)keywords, &pyobj_blob, &pyobj_name, &pyobj_scalefactor, &pyobj_mean) &&
| 51911 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) && |  | 51863 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) &&
| 51912 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 51864 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 51913 | pyopencv_to_safe(pyobj_scalefactor, scalefactor, ArgInfo("scalefactor", 0)) && |  | 51865 | pyopencv_to_safe(pyobj_scalefactor, scalefactor, ArgInfo("scalefactor", 0)) &&
| 51914 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) ) |  | 51866 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) )
| 51915 | { |  | 51867 | {
| 51916 | ERRWRAP2(_self_->setInput(blob, name, scalefactor, mean)); |  | 51868 | ERRWRAP2(_self_->setInput(blob, name, scalefactor, mean));
| 51917 | Py_RETURN_NONE; |  | 51869 | Py_RETURN_NONE;
| 51918 | } |  | 51870 | }
| 51919 |  |  | 51871 |
| 51920 |  |  | 51872 |
| 51921 | pyPopulateArgumentConversionErrors(); |  | 51873 | pyPopulateArgumentConversionErrors();
| 51922 | } |  | 51874 | }
| 51923 |  |  | 51875 |
| 51924 |  |  | 51876 |
| 51925 | { |  | 51877 | {
| 51926 | PyObject* pyobj_blob = NULL; |  | 51878 | PyObject* pyobj_blob = NULL;
| 51927 | UMat blob; |  | 51879 | UMat blob;
| 51928 | PyObject* pyobj_name = NULL; |  | 51880 | PyObject* pyobj_name = NULL;
| 51929 | String name=""; |  | 51881 | String name="";
| 51930 | PyObject* pyobj_scalefactor = NULL; |  | 51882 | PyObject* pyobj_scalefactor = NULL;
| 51931 | double scalefactor=1.0; |  | 51883 | double scalefactor=1.0;
| 51932 | PyObject* pyobj_mean = NULL; |  | 51884 | PyObject* pyobj_mean = NULL;
| 51933 | Scalar mean; |  | 51885 | Scalar mean;
| 51934 |  |  | 51886 |
| 51935 | const char* keywords[] = { "blob", "name", "scalefactor", "mean", NULL }; |  | 51887 | const char* keywords[] = { "blob", "name", "scalefactor", "mean", NULL };
| 51936 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:dnn_Net.setInput", (char**)keywords, &pyobj_blob, &pyobj_name, &pyobj_scalefactor, &pyobj_mean) && |  | 51888 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:dnn_Net.setInput", (char**)keywords, &pyobj_blob, &pyobj_name, &pyobj_scalefactor, &pyobj_mean) &&
| 51937 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) && |  | 51889 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) &&
| 51938 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) && |  | 51890 | pyopencv_to_safe(pyobj_name, name, ArgInfo("name", 0)) &&
| 51939 | pyopencv_to_safe(pyobj_scalefactor, scalefactor, ArgInfo("scalefactor", 0)) && |  | 51891 | pyopencv_to_safe(pyobj_scalefactor, scalefactor, ArgInfo("scalefactor", 0)) &&
| 51940 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) ) |  | 51892 | pyopencv_to_safe(pyobj_mean, mean, ArgInfo("mean", 0)) )
| 51941 | { |  | 51893 | {
| 51942 | ERRWRAP2(_self_->setInput(blob, name, scalefactor, mean)); |  | 51894 | ERRWRAP2(_self_->setInput(blob, name, scalefactor, mean));
| 51943 | Py_RETURN_NONE; |  | 51895 | Py_RETURN_NONE;
| 51944 | } |  | 51896 | }
| 51945 |  |  | 51897 |
| 51946 |  |  | 51898 |
| 51947 | pyPopulateArgumentConversionErrors(); |  | 51899 | pyPopulateArgumentConversionErrors();
| 51948 | } |  | 51900 | }
| 51949 | pyRaiseCVOverloadException("setInput"); |  | 51901 | pyRaiseCVOverloadException("setInput");
| 51950 |  |  | 51902 |
| 51951 | return NULL; |  | 51903 | return NULL;
| 51952 | } |  | 51904 | }
| 51953 |  |  | 51905 |
| 51954 | static PyObject* pyopencv_cv_dnn_dnn_Net_setInputShape(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51906 | static PyObject* pyopencv_cv_dnn_dnn_Net_setInputShape(PyObject* self, PyObject* py_args, PyObject* kw)
| 51955 | { |  | 51907 | {
| 51956 | using namespace cv::dnn; |  | 51908 | using namespace cv::dnn;
| 51957 |  |  | 51909 |
| 51958 |  |  | 51910 |
| 51959 | cv::dnn::Net * self1 = 0; |  | 51911 | cv::dnn::Net * self1 = 0;
| 51960 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51912 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51961 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51913 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51962 | cv::dnn::Net* _self_ = (self1); |  | 51914 | cv::dnn::Net* _self_ = (self1);
| 51963 | PyObject* pyobj_inputName = NULL; |  | 51915 | PyObject* pyobj_inputName = NULL;
| 51964 | String inputName; |  | 51916 | String inputName;
| 51965 | PyObject* pyobj_shape = NULL; |  | 51917 | PyObject* pyobj_shape = NULL;
| 51966 | MatShape shape; |  | 51918 | MatShape shape;
| 51967 |  |  | 51919 |
| 51968 | const char* keywords[] = { "inputName", "shape", NULL }; |  | 51920 | const char* keywords[] = { "inputName", "shape", NULL };
| 51969 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.setInputShape", (char**)keywords, &pyobj_inputName, &pyobj_shape) && |  | 51921 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_Net.setInputShape", (char**)keywords, &pyobj_inputName, &pyobj_shape) &&
| 51970 | pyopencv_to_safe(pyobj_inputName, inputName, ArgInfo("inputName", 0)) && |  | 51922 | pyopencv_to_safe(pyobj_inputName, inputName, ArgInfo("inputName", 0)) &&
| 51971 | pyopencv_to_safe(pyobj_shape, shape, ArgInfo("shape", 0)) ) |  | 51923 | pyopencv_to_safe(pyobj_shape, shape, ArgInfo("shape", 0)) )
| 51972 | { |  | 51924 | {
| 51973 | ERRWRAP2(_self_->setInputShape(inputName, shape)); |  | 51925 | ERRWRAP2(_self_->setInputShape(inputName, shape));
| 51974 | Py_RETURN_NONE; |  | 51926 | Py_RETURN_NONE;
| 51975 | } |  | 51927 | }
| 51976 |  |  | 51928 |
| 51977 | return NULL; |  | 51929 | return NULL;
| 51978 | } |  | 51930 | }
| 51979 |  |  | 51931 |
| 51980 | static PyObject* pyopencv_cv_dnn_dnn_Net_setInputsNames(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51932 | static PyObject* pyopencv_cv_dnn_dnn_Net_setInputsNames(PyObject* self, PyObject* py_args, PyObject* kw)
| 51981 | { |  | 51933 | {
| 51982 | using namespace cv::dnn; |  | 51934 | using namespace cv::dnn;
| 51983 |  |  | 51935 |
| 51984 |  |  | 51936 |
| 51985 | cv::dnn::Net * self1 = 0; |  | 51937 | cv::dnn::Net * self1 = 0;
| 51986 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51938 | if (!pyopencv_dnn_Net_getp(self, self1))
| 51987 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51939 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 51988 | cv::dnn::Net* _self_ = (self1); |  | 51940 | cv::dnn::Net* _self_ = (self1);
| 51989 | PyObject* pyobj_inputBlobNames = NULL; |  | 51941 | PyObject* pyobj_inputBlobNames = NULL;
| 51990 | vector_String inputBlobNames; |  | 51942 | vector_String inputBlobNames;
| 51991 |  |  | 51943 |
| 51992 | const char* keywords[] = { "inputBlobNames", NULL }; |  | 51944 | const char* keywords[] = { "inputBlobNames", NULL };
| 51993 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setInputsNames", (char**)keywords, &pyobj_inputBlobNames) && |  | 51945 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setInputsNames", (char**)keywords, &pyobj_inputBlobNames) &&
| 51994 | pyopencv_to_safe(pyobj_inputBlobNames, inputBlobNames, ArgInfo("inputBlobNames", 0)) ) |  | 51946 | pyopencv_to_safe(pyobj_inputBlobNames, inputBlobNames, ArgInfo("inputBlobNames", 0)) )
| 51995 | { |  | 51947 | {
| 51996 | ERRWRAP2(_self_->setInputsNames(inputBlobNames)); |  | 51948 | ERRWRAP2(_self_->setInputsNames(inputBlobNames));
| 51997 | Py_RETURN_NONE; |  | 51949 | Py_RETURN_NONE;
| 51998 | } |  | 51950 | }
| 51999 |  |  | 51951 |
| 52000 | return NULL; |  | 51952 | return NULL;
| 52001 | } |  | 51953 | }
| 52002 |  |  | 51954 |
| 52003 | static PyObject* pyopencv_cv_dnn_dnn_Net_setParam(PyObject* self, PyObject* py_args, PyObject* kw) |  | 51955 | static PyObject* pyopencv_cv_dnn_dnn_Net_setParam(PyObject* self, PyObject* py_args, PyObject* kw)
| 52004 | { |  | 51956 | {
| 52005 | using namespace cv::dnn; |  | 51957 | using namespace cv::dnn;
| 52006 |  |  | 51958 |
| 52007 |  |  | 51959 |
| 52008 | cv::dnn::Net * self1 = 0; |  | 51960 | cv::dnn::Net * self1 = 0;
| 52009 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 51961 | if (!pyopencv_dnn_Net_getp(self, self1))
| 52010 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 51962 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 52011 | cv::dnn::Net* _self_ = (self1); |  | 51963 | cv::dnn::Net* _self_ = (self1);
| 52012 | pyPrepareArgumentConversionErrorsStorage(2); |  | 51964 | pyPrepareArgumentConversionErrorsStorage(2);
| 52013 |  |  | 51965 |
| 52014 | { |  | 51966 | {
| 52015 | PyObject* pyobj_layer = NULL; |  | 51967 | PyObject* pyobj_layer = NULL;
| 52016 | int layer=0; |  | 51968 | int layer=0;
| 52017 | PyObject* pyobj_numParam = NULL; |  | 51969 | PyObject* pyobj_numParam = NULL;
| 52018 | int numParam=0; |  | 51970 | int numParam=0;
| 52019 | PyObject* pyobj_blob = NULL; |  | 51971 | PyObject* pyobj_blob = NULL;
| 52020 | Mat blob; |  | 51972 | Mat blob;
| 52021 |  |  | 51973 |
| 52022 | const char* keywords[] = { "layer", "numParam", "blob", NULL }; |  | 51974 | const char* keywords[] = { "layer", "numParam", "blob", NULL };
| 52023 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:dnn_Net.setParam", (char**)keywords, &pyobj_layer, &pyobj_numParam, &pyobj_blob) && |  | 51975 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:dnn_Net.setParam", (char**)keywords, &pyobj_layer, &pyobj_numParam, &pyobj_blob) &&
| 52024 | pyopencv_to_safe(pyobj_layer, layer, ArgInfo("layer", 0)) && |  | 51976 | pyopencv_to_safe(pyobj_layer, layer, ArgInfo("layer", 0)) &&
| 52025 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) && |  | 51977 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) &&
| 52026 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) ) |  | 51978 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) )
| 52027 | { |  | 51979 | {
| 52028 | ERRWRAP2(_self_->setParam(layer, numParam, blob)); |  | 51980 | ERRWRAP2(_self_->setParam(layer, numParam, blob));
| 52029 | Py_RETURN_NONE; |  | 51981 | Py_RETURN_NONE;
| 52030 | } |  | 51982 | }
| 52031 |  |  | 51983 |
| 52032 |  |  | 51984 |
| 52033 | pyPopulateArgumentConversionErrors(); |  | 51985 | pyPopulateArgumentConversionErrors();
| 52034 | } |  | 51986 | }
| 52035 |  |  | 51987 |
| 52036 |  |  | 51988 |
| 52037 | { |  | 51989 | {
| 52038 | PyObject* pyobj_layerName = NULL; |  | 51990 | PyObject* pyobj_layerName = NULL;
| 52039 | String layerName; |  | 51991 | String layerName;
| 52040 | PyObject* pyobj_numParam = NULL; |  | 51992 | PyObject* pyobj_numParam = NULL;
| 52041 | int numParam=0; |  | 51993 | int numParam=0;
| 52042 | PyObject* pyobj_blob = NULL; |  | 51994 | PyObject* pyobj_blob = NULL;
| 52043 | Mat blob; |  | 51995 | Mat blob;
| 52044 |  |  | 51996 |
| 52045 | const char* keywords[] = { "layerName", "numParam", "blob", NULL }; |  | 51997 | const char* keywords[] = { "layerName", "numParam", "blob", NULL };
| 52046 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:dnn_Net.setParam", (char**)keywords, &pyobj_layerName, &pyobj_numParam, &pyobj_blob) && |  | 51998 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:dnn_Net.setParam", (char**)keywords, &pyobj_layerName, &pyobj_numParam, &pyobj_blob) &&
| 52047 | pyopencv_to_safe(pyobj_layerName, layerName, ArgInfo("layerName", 0)) && |  | 51999 | pyopencv_to_safe(pyobj_layerName, layerName, ArgInfo("layerName", 0)) &&
| 52048 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) && |  | 52000 | pyopencv_to_safe(pyobj_numParam, numParam, ArgInfo("numParam", 0)) &&
| 52049 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) ) |  | 52001 | pyopencv_to_safe(pyobj_blob, blob, ArgInfo("blob", 8)) )
| 52050 | { |  | 52002 | {
| 52051 | ERRWRAP2(_self_->setParam(layerName, numParam, blob)); |  | 52003 | ERRWRAP2(_self_->setParam(layerName, numParam, blob));
| 52052 | Py_RETURN_NONE; |  | 52004 | Py_RETURN_NONE;
| 52053 | } |  | 52005 | }
| 52054 |  |  | 52006 |
| 52055 |  |  | 52007 |
| 52056 | pyPopulateArgumentConversionErrors(); |  | 52008 | pyPopulateArgumentConversionErrors();
| 52057 | } |  | 52009 | }
| 52058 | pyRaiseCVOverloadException("setParam"); |  | 52010 | pyRaiseCVOverloadException("setParam");
| 52059 |  |  | 52011 |
| 52060 | return NULL; |  | 52012 | return NULL;
| 52061 | } |  | 52013 | }
| 52062 |  |  | 52014 |
| 52063 | static PyObject* pyopencv_cv_dnn_dnn_Net_setPreferableBackend(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52015 | static PyObject* pyopencv_cv_dnn_dnn_Net_setPreferableBackend(PyObject* self, PyObject* py_args, PyObject* kw)
| 52064 | { |  | 52016 | {
| 52065 | using namespace cv::dnn; |  | 52017 | using namespace cv::dnn;
| 52066 |  |  | 52018 |
| 52067 |  |  | 52019 |
| 52068 | cv::dnn::Net * self1 = 0; |  | 52020 | cv::dnn::Net * self1 = 0;
| 52069 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 52021 | if (!pyopencv_dnn_Net_getp(self, self1))
| 52070 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 52022 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 52071 | cv::dnn::Net* _self_ = (self1); |  | 52023 | cv::dnn::Net* _self_ = (self1);
| 52072 | PyObject* pyobj_backendId = NULL; |  | 52024 | PyObject* pyobj_backendId = NULL;
| 52073 | int backendId=0; |  | 52025 | int backendId=0;
| 52074 |  |  | 52026 |
| 52075 | const char* keywords[] = { "backendId", NULL }; |  | 52027 | const char* keywords[] = { "backendId", NULL };
| 52076 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setPreferableBackend", (char**)keywords, &pyobj_backendId) && |  | 52028 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setPreferableBackend", (char**)keywords, &pyobj_backendId) &&
| 52077 | pyopencv_to_safe(pyobj_backendId, backendId, ArgInfo("backendId", 0)) ) |  | 52029 | pyopencv_to_safe(pyobj_backendId, backendId, ArgInfo("backendId", 0)) )
| 52078 | { |  | 52030 | {
| 52079 | ERRWRAP2(_self_->setPreferableBackend(backendId)); |  | 52031 | ERRWRAP2(_self_->setPreferableBackend(backendId));
| 52080 | Py_RETURN_NONE; |  | 52032 | Py_RETURN_NONE;
| 52081 | } |  | 52033 | }
| 52082 |  |  | 52034 |
| 52083 | return NULL; |  | 52035 | return NULL;
| 52084 | } |  | 52036 | }
| 52085 |  |  | 52037 |
| 52086 | static PyObject* pyopencv_cv_dnn_dnn_Net_setPreferableTarget(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52038 | static PyObject* pyopencv_cv_dnn_dnn_Net_setPreferableTarget(PyObject* self, PyObject* py_args, PyObject* kw)
| 52087 | { |  | 52039 | {
| 52088 | using namespace cv::dnn; |  | 52040 | using namespace cv::dnn;
| 52089 |  |  | 52041 |
| 52090 |  |  | 52042 |
| 52091 | cv::dnn::Net * self1 = 0; |  | 52043 | cv::dnn::Net * self1 = 0;
| 52092 | if (!pyopencv_dnn_Net_getp(self, self1)) |  | 52044 | if (!pyopencv_dnn_Net_getp(self, self1))
| 52093 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)"); |  | 52045 | return failmsgp("Incorrect type of self (must be 'dnn_Net' or its derivative)");
| 52094 | cv::dnn::Net* _self_ = (self1); |  | 52046 | cv::dnn::Net* _self_ = (self1);
| 52095 | PyObject* pyobj_targetId = NULL; |  | 52047 | PyObject* pyobj_targetId = NULL;
| 52096 | int targetId=0; |  | 52048 | int targetId=0;
| 52097 |  |  | 52049 |
| 52098 | const char* keywords[] = { "targetId", NULL }; |  | 52050 | const char* keywords[] = { "targetId", NULL };
| 52099 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setPreferableTarget", (char**)keywords, &pyobj_targetId) && |  | 52051 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_Net.setPreferableTarget", (char**)keywords, &pyobj_targetId) &&
| 52100 | pyopencv_to_safe(pyobj_targetId, targetId, ArgInfo("targetId", 0)) ) |  | 52052 | pyopencv_to_safe(pyobj_targetId, targetId, ArgInfo("targetId", 0)) )
| 52101 | { |  | 52053 | {
| 52102 | ERRWRAP2(_self_->setPreferableTarget(targetId)); |  | 52054 | ERRWRAP2(_self_->setPreferableTarget(targetId));
| 52103 | Py_RETURN_NONE; |  | 52055 | Py_RETURN_NONE;
| 52104 | } |  | 52056 | }
| 52105 |  |  | 52057 |
| 52106 | return NULL; |  | 52058 | return NULL;
| 52107 | } |  | 52059 | }
| 52108 |  |  | 52060 |
| 52109 |  |  | 52061 |
| 52110 |  |  | 52062 |
| 52111 | // Tables (dnn_Net) |  | 52063 | // Tables (dnn_Net)
| 52112 |  |  | 52064 |
| 52113 | static PyGetSetDef pyopencv_dnn_Net_getseters[] = |  | 52065 | static PyGetSetDef pyopencv_dnn_Net_getseters[] =
| 52114 | { |  | 52066 | {
| 52115 | {NULL} /* Sentinel */ |  | 52067 | {NULL} /* Sentinel */
| 52116 | }; |  | 52068 | };
| 52117 |  |  | 52069 |
| 52118 | static PyMethodDef pyopencv_dnn_Net_methods[] = |  | 52070 | static PyMethodDef pyopencv_dnn_Net_methods[] =
| 52119 | { |  | 52071 | {
| 52120 | {"addLayer", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_addLayer, 0), "addLayer(name, type, dtype, params) -> retval\n. @brief Adds new layer to the net.\n. * @param name unique name of the adding layer.\n. * @param type typename of the adding layer (type must be registered in LayerRegister).\n. * @param dtype datatype of output blobs.\n. * @param params parameters which will be used to initialize the creating layer.\n. * @returns unique identifier of created layer, or -1 if a failure will happen."}, |  | 52072 | {"addLayer", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_addLayer, 0), "addLayer(name, type, dtype, params) -> retval\n. @brief Adds new layer to the net.\n. * @param name unique name of the adding layer.\n. * @param type typename of the adding layer (type must be registered in LayerRegister).\n. * @param dtype datatype of output blobs.\n. * @param params parameters which will be used to initialize the creating layer.\n. * @returns unique identifier of created layer, or -1 if a failure will happen."},
| 52121 | {"addLayerToPrev", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_addLayerToPrev, 0), "addLayerToPrev(name, type, dtype, params) -> retval\n. @brief Adds new layer and connects its first input to the first output of previously added layer.\n. * @see addLayer()"}, |  | 52073 | {"addLayerToPrev", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_addLayerToPrev, 0), "addLayerToPrev(name, type, dtype, params) -> retval\n. @brief Adds new layer and connects its first input to the first output of previously added layer.\n. * @see addLayer()"},
| 52122 | {"connect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_connect, 0), "connect(outPin, inpPin) -> None\n. @brief Connects output of the first layer to input of the second layer.\n. * @param outPin descriptor of the first layer output.\n. * @param inpPin descriptor of the second layer input.\n. *\n. * Descriptors have the following template <DFN>&lt;layer_name&gt;[.input_number]</DFN>:\n. * - the first part of the template <DFN>layer_name</DFN> is string name of the added layer.\n. * If this part is empty then the network input pseudo layer will be used;\n. * - the second optional part of the template <DFN>input_number</DFN>\n. * is either number of the layer input, either label one.\n. * If this part is omitted then the first layer input will be used.\n. *\n. * @see setNetInputs(), Layer::inputNameToIndex(), Layer::outputNameToIndex()"}, |  | 52074 | {"connect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_connect, 0), "connect(outPin, inpPin) -> None\n. @brief Connects output of the first layer to input of the second layer.\n. * @param outPin descriptor of the first layer output.\n. * @param inpPin descriptor of the second layer input.\n. *\n. * Descriptors have the following template <DFN>&lt;layer_name&gt;[.input_number]</DFN>:\n. * - the first part of the template <DFN>layer_name</DFN> is string name of the added layer.\n. * If this part is empty then the network input pseudo layer will be used;\n. * - the second optional part of the template <DFN>input_number</DFN>\n. * is either number of the layer input, either label one.\n. * If this part is omitted then the first layer input will be used.\n. *\n. * @see setNetInputs(), Layer::inputNameToIndex(), Layer::outputNameToIndex()"},
| 52123 | {"dump", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_dump, 0), "dump() -> retval\n. @brief Dump net to String\n. * @returns String with structure, hyperparameters, backend, target and fusion\n. * Call method after setInput(). To see correct backend, target and fusion run after forward()."}, |  | 52075 | {"dump", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_dump, 0), "dump() -> retval\n. @brief Dump net to String\n. * @returns String with structure, hyperparameters, backend, target and fusion\n. * Call method after setInput(). To see correct backend, target and fusion run after forward()."},
| 52124 | {"dumpToFile", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_dumpToFile, 0), "dumpToFile(path) -> None\n. @brief Dump net structure, hyperparameters, backend, target and fusion to dot file\n. * @param path path to output file with .dot extension\n. * @see dump()"}, |  | 52076 | {"dumpToFile", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_dumpToFile, 0), "dumpToFile(path) -> None\n. @brief Dump net structure, hyperparameters, backend, target and fusion to dot file\n. * @param path path to output file with .dot extension\n. * @see dump()"},
| 52125 | {"dumpToPbtxt", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_dumpToPbtxt, 0), "dumpToPbtxt(path) -> None\n. @brief Dump net structure, hyperparameters, backend, target and fusion to pbtxt file\n. * @param path path to output file with .pbtxt extension\n. *\n. * Use Netron (https://netron.app) to open the target file to visualize the model.\n. * Call method after setInput(). To see correct backend, target and fusion run after forward()."}, |  | 52077 | {"dumpToPbtxt", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_dumpToPbtxt, 0), "dumpToPbtxt(path) -> None\n. @brief Dump net structure, hyperparameters, backend, target and fusion to pbtxt file\n. * @param path path to output file with .pbtxt extension\n. *\n. * Use Netron (https://netron.app) to open the target file to visualize the model.\n. * Call method after setInput(). To see correct backend, target and fusion run after forward()."},
| 52126 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_empty, 0), "empty() -> retval\n. Returns true if there are no layers in the network."}, |  | 52078 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_empty, 0), "empty() -> retval\n. Returns true if there are no layers in the network."},
| 52127 | {"enableFusion", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_enableFusion, 0), "enableFusion(fusion) -> None\n. @brief Enables or disables layer fusion in the network.\n. * @param fusion true to enable the fusion, false to disable. The fusion is enabled by default."}, |  | 52079 | {"enableFusion", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_enableFusion, 0), "enableFusion(fusion) -> None\n. @brief Enables or disables layer fusion in the network.\n. * @param fusion true to enable the fusion, false to disable. The fusion is enabled by default."},
| 52128 | {"enableWinograd", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_enableWinograd, 0), "enableWinograd(useWinograd) -> None\n. @brief Enables or disables the Winograd compute branch. The Winograd compute branch can speed up\n. * 3x3 Convolution at a small loss of accuracy.\n. * @param useWinograd true to enable the Winograd compute branch. The default is true."}, |  | 52080 | {"enableWinograd", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_enableWinograd, 0), "enableWinograd(useWinograd) -> None\n. @brief Enables or disables the Winograd compute branch. The Winograd compute branch can speed up\n. * 3x3 Convolution at a small loss of accuracy.\n. * @param useWinograd true to enable the Winograd compute branch. The default is true."},
| 52129 | {"forward", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_forward, 0), "forward([, outputName]) -> retval\n. @brief Runs forward pass to compute output of layer with name @p outputName.\n. * @param outputName name for layer which output is needed to get\n. * @return blob for first output of specified layer.\n. * @details By default runs forward pass for the whole network.\n\n\n\nforward([, outputBlobs[, outputName]]) -> outputBlobs\n. @brief Runs forward pass to compute output of layer with name @p outputName.\n. * @param outputBlobs contains all output blobs for specified layer.\n. * @param outputName name for layer which output is needed to get\n. * @details If @p outputName is empty, runs forward pass for the whole network.\n\n\n\nforward(outBlobNames[, outputBlobs]) -> outputBlobs\n. @brief Runs forward pass to compute outputs of layers listed in @p outBlobNames.\n. * @param outputBlobs contains blobs for first outputs of specified layers.\n. * @param outBlobNames names for layers which outputs are needed to get"}, |  | 52081 | {"forward", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_forward, 0), "forward([, outputName]) -> retval\n. @brief Runs forward pass to compute output of layer with name @p outputName.\n. * @param outputName name for layer which output is needed to get\n. * @return blob for first output of specified layer.\n. * @details By default runs forward pass for the whole network.\n\n\n\nforward([, outputBlobs[, outputName]]) -> outputBlobs\n. @brief Runs forward pass to compute output of layer with name @p outputName.\n. * @param outputBlobs contains all output blobs for specified layer.\n. * @param outputName name for layer which output is needed to get\n. * @details If @p outputName is empty, runs forward pass for the whole network.\n\n\n\nforward(outBlobNames[, outputBlobs]) -> outputBlobs\n. @brief Runs forward pass to compute outputs of layers listed in @p outBlobNames.\n. * @param outputBlobs contains blobs for first outputs of specified layers.\n. * @param outBlobNames names for layers which outputs are needed to get"},
| 52130 | {"forwardAndRetrieve", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_forwardAndRetrieve, 0), "forwardAndRetrieve(outBlobNames) -> outputBlobs\n. @brief Runs forward pass to compute outputs of layers listed in @p outBlobNames.\n. * @param outputBlobs contains all output blobs for each layer specified in @p outBlobNames.\n. * @param outBlobNames names for layers which outputs are needed to get"}, |  | 52082 | {"forwardAndRetrieve", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_forwardAndRetrieve, 0), "forwardAndRetrieve(outBlobNames) -> outputBlobs\n. @brief Runs forward pass to compute outputs of layers listed in @p outBlobNames.\n. * @param outputBlobs contains all output blobs for each layer specified in @p outBlobNames.\n. * @param outBlobNames names for layers which outputs are needed to get"},
| 52131 | {"forwardAsync", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_forwardAsync, 0), "forwardAsync([, outputName]) -> retval\n. @brief Runs forward pass to compute output of layer with name @p outputName.\n. * @param outputName name for layer which output is needed to get\n. * @details By default runs forward pass for the whole network.\n. *\n. * This is an asynchronous version of forward(const String&).\n. * dnn::DNN_BACKEND_INFERENCE_ENGINE backend is required."}, |  | 52083 | {"forwardAsync", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_forwardAsync, 0), "forwardAsync([, outputName]) -> retval\n. @brief Runs forward pass to compute output of layer with name @p outputName.\n. * @param outputName name for layer which output is needed to get\n. * @details By default runs forward pass for the whole network.\n. *\n. * This is an asynchronous version of forward(const String&).\n. * dnn::DNN_BACKEND_INFERENCE_ENGINE backend is required."},
| 52132 | {"getFLOPS", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getFLOPS, 0), "getFLOPS(netInputShapes) -> retval\n. @brief Computes FLOP for whole loaded model with specified input shapes.\n. * @param netInputShapes vector of shapes for all net inputs.\n. * @returns computed FLOP.\n\n\n\ngetFLOPS(netInputShape) -> retval\n. @overload\n\n\n\ngetFLOPS(layerId, netInputShapes) -> retval\n. @overload\n\n\n\ngetFLOPS(layerId, netInputShape) -> retval\n. @overload"}, |  | 52084 | {"getFLOPS", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getFLOPS, 0), "getFLOPS(netInputShapes) -> retval\n. @brief Computes FLOP for whole loaded model with specified input shapes.\n. * @param netInputShapes vector of shapes for all net inputs.\n. * @returns computed FLOP.\n\n\n\ngetFLOPS(netInputShape) -> retval\n. @overload\n\n\n\ngetFLOPS(layerId, netInputShapes) -> retval\n. @overload\n\n\n\ngetFLOPS(layerId, netInputShape) -> retval\n. @overload"},
| 52133 | {"getInputDetails", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getInputDetails, 0), "getInputDetails() -> scales, zeropoints\n. @brief Returns input scale and zeropoint for a quantized Net.\n. * @param scales output parameter for returning input scales.\n. * @param zeropoints output parameter for returning input zeropoints."}, |  | 52085 | {"getInputDetails", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getInputDetails, 0), "getInputDetails() -> scales, zeropoints\n. @brief Returns input scale and zeropoint for a quantized Net.\n. * @param scales output parameter for returning input scales.\n. * @param zeropoints output parameter for returning input zeropoints."},
| 52134 | {"getLayer", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayer, 0), "getLayer(layerId) -> retval\n. @brief Returns pointer to layer with specified id or name which the network use.\n\n\n\ngetLayer(layerName) -> retval\n. @overload\n. * @deprecated Use int getLayerId(const String &layer)"}, |  | 52086 | {"getLayer", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayer, 0), "getLayer(layerId) -> retval\n. @brief Returns pointer to layer with specified id or name which the network use.\n\n\n\ngetLayer(layerName) -> retval\n. @overload\n. * @deprecated Use int getLayerId(const String &layer)"},
| 52135 | {"getLayerId", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayerId, 0), "getLayerId(layer) -> retval\n. @brief Converts string name of the layer to the integer identifier.\n. * @returns id of the layer, or -1 if the layer wasn't found."}, |  | 52087 | {"getLayerId", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayerId, 0), "getLayerId(layer) -> retval\n. @brief Converts string name of the layer to the integer identifier.\n. * @returns id of the layer, or -1 if the layer wasn't found."},
| 52136 | {"getLayerNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayerNames, 0), "getLayerNames() -> retval\n."}, |  | 52088 | {"getLayerNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayerNames, 0), "getLayerNames() -> retval\n."},
| 52137 | {"getLayerTypes", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayerTypes, 0), "getLayerTypes() -> layersTypes\n. @brief Returns list of types for layer used in model.\n. * @param layersTypes output parameter for returning types."}, |  | 52089 | {"getLayerTypes", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayerTypes, 0), "getLayerTypes() -> layersTypes\n. @brief Returns list of types for layer used in model.\n. * @param layersTypes output parameter for returning types."},
| 52138 | {"getLayersCount", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayersCount, 0), "getLayersCount(layerType) -> retval\n. @brief Returns count of layers of specified type.\n. * @param layerType type.\n. * @returns count of layers"}, |  | 52090 | {"getLayersCount", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayersCount, 0), "getLayersCount(layerType) -> retval\n. @brief Returns count of layers of specified type.\n. * @param layerType type.\n. * @returns count of layers"},
| 52139 | {"getLayersShapes", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayersShapes, 0), "getLayersShapes(netInputShapes) -> layersIds, inLayersShapes, outLayersShapes\n. @brief Returns input and output shapes for all layers in loaded model;\n. * preliminary inferencing isn't necessary.\n. * @param netInputShapes shapes for all input blobs in net input layer.\n. * @param layersIds output parameter for layer IDs.\n. * @param inLayersShapes output parameter for input layers shapes;\n. * order is the same as in layersIds\n. * @param outLayersShapes output parameter for output layers shapes;\n. * order is the same as in layersIds\n\n\n\ngetLayersShapes(netInputShape) -> layersIds, inLayersShapes, outLayersShapes\n. @overload"}, |  | 52091 | {"getLayersShapes", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getLayersShapes, 0), "getLayersShapes(netInputShapes) -> layersIds, inLayersShapes, outLayersShapes\n. @brief Returns input and output shapes for all layers in loaded model;\n. * preliminary inferencing isn't necessary.\n. * @param netInputShapes shapes for all input blobs in net input layer.\n. * @param layersIds output parameter for layer IDs.\n. * @param inLayersShapes output parameter for input layers shapes;\n. * order is the same as in layersIds\n. * @param outLayersShapes output parameter for output layers shapes;\n. * order is the same as in layersIds\n\n\n\ngetLayersShapes(netInputShape) -> layersIds, inLayersShapes, outLayersShapes\n. @overload"},
| 52140 | {"getMemoryConsumption", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getMemoryConsumption, 0), "getMemoryConsumption(netInputShape) -> weights, blobs\n. @overload\n\n\n\ngetMemoryConsumption(layerId, netInputShapes) -> weights, blobs\n. @overload\n\n\n\ngetMemoryConsumption(layerId, netInputShape) -> weights, blobs\n. @overload"}, |  | 52092 | {"getMemoryConsumption", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getMemoryConsumption, 0), "getMemoryConsumption(netInputShape) -> weights, blobs\n. @overload\n\n\n\ngetMemoryConsumption(layerId, netInputShapes) -> weights, blobs\n. @overload\n\n\n\ngetMemoryConsumption(layerId, netInputShape) -> weights, blobs\n. @overload"},
| 52141 | {"getOutputDetails", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getOutputDetails, 0), "getOutputDetails() -> scales, zeropoints\n. @brief Returns output scale and zeropoint for a quantized Net.\n. * @param scales output parameter for returning output scales.\n. * @param zeropoints output parameter for returning output zeropoints."}, |  | 52093 | {"getOutputDetails", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getOutputDetails, 0), "getOutputDetails() -> scales, zeropoints\n. @brief Returns output scale and zeropoint for a quantized Net.\n. * @param scales output parameter for returning output scales.\n. * @param zeropoints output parameter for returning output zeropoints."},
| 52142 | {"getParam", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getParam, 0), "getParam(layer[, numParam]) -> retval\n. @brief Returns parameter blob of the layer.\n. * @param layer name or id of the layer.\n. * @param numParam index of the layer parameter in the Layer::blobs array.\n. * @see Layer::blobs\n\n\n\ngetParam(layerName[, numParam]) -> retval\n."}, |  | 52094 | {"getParam", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getParam, 0), "getParam(layer[, numParam]) -> retval\n. @brief Returns parameter blob of the layer.\n. * @param layer name or id of the layer.\n. * @param numParam index of the layer parameter in the Layer::blobs array.\n. * @see Layer::blobs\n\n\n\ngetParam(layerName[, numParam]) -> retval\n."},
| 52143 | {"getPerfProfile", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getPerfProfile, 0), "getPerfProfile() -> retval, timings\n. @brief Returns overall time for inference and timings (in ticks) for layers.\n. *\n. * Indexes in returned vector correspond to layers ids. Some layers can be fused with others,\n. * in this case zero ticks count will be return for that skipped layers. Supported by DNN_BACKEND_OPENCV on DNN_TARGET_CPU only.\n. *\n. * @param[out] timings vector for tick timings for all layers.\n. * @return overall ticks for model inference."}, |  | 52095 | {"getPerfProfile", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getPerfProfile, 0), "getPerfProfile() -> retval, timings\n. @brief Returns overall time for inference and timings (in ticks) for layers.\n. *\n. * Indexes in returned vector correspond to layers ids. Some layers can be fused with others,\n. * in this case zero ticks count will be return for that skipped layers. Supported by DNN_BACKEND_OPENCV on DNN_TARGET_CPU only.\n. *\n. * @param[out] timings vector for tick timings for all layers.\n. * @return overall ticks for model inference."},
| 52144 | {"getUnconnectedOutLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayers, 0), "getUnconnectedOutLayers() -> retval\n. @brief Returns indexes of layers with unconnected outputs.\n. *\n. * FIXIT: Rework API to registerOutput() approach, deprecate this call"}, |  | 52096 | {"getUnconnectedOutLayers", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayers, 0), "getUnconnectedOutLayers() -> retval\n. @brief Returns indexes of layers with unconnected outputs.\n. *\n. * FIXIT: Rework API to registerOutput() approach, deprecate this call"},
| 52145 | {"getUnconnectedOutLayersNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayersNames, 0), "getUnconnectedOutLayersNames() -> retval\n. @brief Returns names of layers with unconnected outputs.\n. *\n. * FIXIT: Rework API to registerOutput() approach, deprecate this call"}, |  | 52097 | {"getUnconnectedOutLayersNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_getUnconnectedOutLayersNames, 0), "getUnconnectedOutLayersNames() -> retval\n. @brief Returns names of layers with unconnected outputs.\n. *\n. * FIXIT: Rework API to registerOutput() approach, deprecate this call"},
| 52146 | {"quantize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_quantize, 0), "quantize(calibData, inputsDtype, outputsDtype[, perChannel]) -> retval\n. @brief Returns a quantized Net from a floating-point Net.\n. * @param calibData Calibration data to compute the quantization parameters.\n. * @param inputsDtype Datatype of quantized net's inputs. Can be CV_32F or CV_8S.\n. * @param outputsDtype Datatype of quantized net's outputs. Can be CV_32F or CV_8S.\n. * @param perChannel Quantization granularity of quantized Net. The default is true, that means quantize model\n. * in per-channel way (channel-wise). Set it false to quantize model in per-tensor way (or tensor-wise)."}, |  | 52098 | {"quantize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_quantize, 0), "quantize(calibData, inputsDtype, outputsDtype[, perChannel]) -> retval\n. @brief Returns a quantized Net from a floating-point Net.\n. * @param calibData Calibration data to compute the quantization parameters.\n. * @param inputsDtype Datatype of quantized net's inputs. Can be CV_32F or CV_8S.\n. * @param outputsDtype Datatype of quantized net's outputs. Can be CV_32F or CV_8S.\n. * @param perChannel Quantization granularity of quantized Net. The default is true, that means quantize model\n. * in per-channel way (channel-wise). Set it false to quantize model in per-tensor way (or tensor-wise)."},
| 52147 | {"readFromModelOptimizer", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_readFromModelOptimizer_static, METH_STATIC), "readFromModelOptimizer(xml, bin) -> retval\n. @brief Create a network from Intel's Model Optimizer intermediate representation (IR).\n. * @param[in] xml XML configuration file with network's topology.\n. * @param[in] bin Binary file with trained weights.\n. * Networks imported from Intel's Model Optimizer are launched in Intel's Inference Engine\n. * backend.\n\n\n\nreadFromModelOptimizer(bufferModelConfig, bufferWeights) -> retval\n. @brief Create a network from Intel's Model Optimizer in-memory buffers with intermediate representation (IR).\n. * @param[in] bufferModelConfig buffer with model's configuration.\n. * @param[in] bufferWeights buffer with model's trained weights.\n. * @returns Net object."}, |  | 52099 | {"readFromModelOptimizer", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_readFromModelOptimizer_static, METH_STATIC), "readFromModelOptimizer(xml, bin) -> retval\n. @brief Create a network from Intel's Model Optimizer intermediate representation (IR).\n. * @param[in] xml XML configuration file with network's topology.\n. * @param[in] bin Binary file with trained weights.\n. * Networks imported from Intel's Model Optimizer are launched in Intel's Inference Engine\n. * backend.\n\n\n\nreadFromModelOptimizer(bufferModelConfig, bufferWeights) -> retval\n. @brief Create a network from Intel's Model Optimizer in-memory buffers with intermediate representation (IR).\n. * @param[in] bufferModelConfig buffer with model's configuration.\n. * @param[in] bufferWeights buffer with model's trained weights.\n. * @returns Net object."},
| 52148 | {"registerOutput", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_registerOutput, 0), "registerOutput(outputName, layerId, outputPort) -> retval\n. @brief Registers network output with name\n. *\n. * Function may create additional 'Identity' layer.\n. *\n. * @param outputName identifier of the output\n. * @param layerId identifier of the second layer\n. * @param outputPort number of the second layer input\n. *\n. * @returns index of bound layer (the same as layerId or newly created)"}, |  | 52100 | {"registerOutput", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_registerOutput, 0), "registerOutput(outputName, layerId, outputPort) -> retval\n. @brief Registers network output with name\n. *\n. * Function may create additional 'Identity' layer.\n. *\n. * @param outputName identifier of the output\n. * @param layerId identifier of the second layer\n. * @param outputPort number of the second layer input\n. *\n. * @returns index of bound layer (the same as layerId or newly created)"},
| 52149 | {"setHalideScheduler", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setHalideScheduler, 0), "setHalideScheduler(scheduler) -> None\n. * @brief Compile Halide layers.\n. * @param[in] scheduler Path to YAML file with scheduling directives.\n. * @see setPreferableBackend\n. *\n. * Schedule layers that support Halide backend. Then compile them for\n. * specific target. For layers that not represented in scheduling file\n. * or if no manual scheduling used at all, automatic scheduling will be applied."}, |  | 52101 | {"setHalideScheduler", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setHalideScheduler, 0), "setHalideScheduler(scheduler) -> None\n. * @brief Compile Halide layers.\n. * @param[in] scheduler Path to YAML file with scheduling directives.\n. * @see setPreferableBackend\n. *\n. * Schedule layers that support Halide backend. Then compile them for\n. * specific target. For layers that not represented in scheduling file\n. * or if no manual scheduling used at all, automatic scheduling will be applied."},
| 52150 | {"setInput", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setInput, 0), "setInput(blob[, name[, scalefactor[, mean]]]) -> None\n. @brief Sets the new input value for the network\n. * @param blob A new blob. Should have CV_32F or CV_8U depth.\n. * @param name A name of input layer.\n. * @param scalefactor An optional normalization scale.\n. * @param mean An optional mean subtraction values.\n. * @see connect(String, String) to know format of the descriptor.\n. *\n. * If scale or mean values are specified, a final input blob is computed\n. * as:\n. * \\f[input(n,c,h,w) = scalefactor \\times (blob(n,c,h,w) - mean_c)\\f]"}, |  | 52102 | {"setInput", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setInput, 0), "setInput(blob[, name[, scalefactor[, mean]]]) -> None\n. @brief Sets the new input value for the network\n. * @param blob A new blob. Should have CV_32F or CV_8U depth.\n. * @param name A name of input layer.\n. * @param scalefactor An optional normalization scale.\n. * @param mean An optional mean subtraction values.\n. * @see connect(String, String) to know format of the descriptor.\n. *\n. * If scale or mean values are specified, a final input blob is computed\n. * as:\n. * \\f[input(n,c,h,w) = scalefactor \\times (blob(n,c,h,w) - mean_c)\\f]"},
| 52151 | {"setInputShape", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setInputShape, 0), "setInputShape(inputName, shape) -> None\n. @brief Specify shape of network input."}, |  | 52103 | {"setInputShape", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setInputShape, 0), "setInputShape(inputName, shape) -> None\n. @brief Specify shape of network input."},
| 52152 | {"setInputsNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setInputsNames, 0), "setInputsNames(inputBlobNames) -> None\n. @brief Sets outputs names of the network input pseudo layer.\n. *\n. * Each net always has special own the network input pseudo layer with id=0.\n. * This layer stores the user blobs only and don't make any computations.\n. * In fact, this layer provides the only way to pass user data into the network.\n. * As any other layer, this layer can label its outputs and this function provides an easy way to do this."}, |  | 52104 | {"setInputsNames", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setInputsNames, 0), "setInputsNames(inputBlobNames) -> None\n. @brief Sets outputs names of the network input pseudo layer.\n. *\n. * Each net always has special own the network input pseudo layer with id=0.\n. * This layer stores the user blobs only and don't make any computations.\n. * In fact, this layer provides the only way to pass user data into the network.\n. * As any other layer, this layer can label its outputs and this function provides an easy way to do this."},
| 52153 | {"setParam", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setParam, 0), "setParam(layer, numParam, blob) -> None\n. @brief Sets the new value for the learned param of the layer.\n. * @param layer name or id of the layer.\n. * @param numParam index of the layer parameter in the Layer::blobs array.\n. * @param blob the new value.\n. * @see Layer::blobs\n. * @note If shape of the new blob differs from the previous shape,\n. * then the following forward pass may fail.\n\n\n\nsetParam(layerName, numParam, blob) -> None\n."}, |  | 52105 | {"setParam", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setParam, 0), "setParam(layer, numParam, blob) -> None\n. @brief Sets the new value for the learned param of the layer.\n. * @param layer name or id of the layer.\n. * @param numParam index of the layer parameter in the Layer::blobs array.\n. * @param blob the new value.\n. * @see Layer::blobs\n. * @note If shape of the new blob differs from the previous shape,\n. * then the following forward pass may fail.\n\n\n\nsetParam(layerName, numParam, blob) -> None\n."},
| 52154 | {"setPreferableBackend", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setPreferableBackend, 0), "setPreferableBackend(backendId) -> None\n. * @brief Ask network to use specific computation backend where it supported.\n. * @param[in] backendId backend identifier.\n. * @see Backend"}, |  | 52106 | {"setPreferableBackend", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setPreferableBackend, 0), "setPreferableBackend(backendId) -> None\n. * @brief Ask network to use specific computation backend where it supported.\n. * @param[in] backendId backend identifier.\n. * @see Backend"},
| 52155 | {"setPreferableTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setPreferableTarget, 0), "setPreferableTarget(targetId) -> None\n. * @brief Ask network to make computations on specific target device.\n. * @param[in] targetId target identifier.\n. * @see Target\n. *\n. * List of supported combinations backend / target:\n. * | | DNN_BACKEND_OPENCV | DNN_BACKEND_INFERENCE_ENGINE | DNN_BACKEND_HALIDE | DNN_BACKEND_CUDA |\n. * |------------------------|--------------------|------------------------------|--------------------|-------------------|\n. * | DNN_TARGET_CPU | + | + | + | |\n. * | DNN_TARGET_OPENCL | + | + | + | |\n. * | DNN_TARGET_OPENCL_FP16 | + | + | | |\n. * | DNN_TARGET_MYRIAD | | + | | |\n. * | DNN_TARGET_FPGA | | + | | |\n. * | DNN_TARGET_CUDA | | | | + |\n. * | DNN_TARGET_CUDA_FP16 | | | | + |\n. * | DNN_TARGET_HDDL | | + | | |"}, |  | 52107 | {"setPreferableTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_Net_setPreferableTarget, 0), "setPreferableTarget(targetId) -> None\n. * @brief Ask network to make computations on specific target device.\n. * @param[in] targetId target identifier.\n. * @see Target\n. *\n. * List of supported combinations backend / target:\n. * | | DNN_BACKEND_OPENCV | DNN_BACKEND_INFERENCE_ENGINE | DNN_BACKEND_HALIDE | DNN_BACKEND_CUDA |\n. * |------------------------|--------------------|------------------------------|--------------------|-------------------|\n. * | DNN_TARGET_CPU | + | + | + | |\n. * | DNN_TARGET_OPENCL | + | + | + | |\n. * | DNN_TARGET_OPENCL_FP16 | + | + | | |\n. * | DNN_TARGET_MYRIAD | | + | | |\n. * | DNN_TARGET_FPGA | | + | | |\n. * | DNN_TARGET_CUDA | | | | + |\n. * | DNN_TARGET_CUDA_FP16 | | | | + |\n. * | DNN_TARGET_HDDL | | + | | |"},
| 52156 |  |  | 52108 |
| 52157 | {NULL, NULL} |  | 52109 | {NULL, NULL}
| 52158 | }; |  | 52110 | };
| 52159 |  |  | 52111 |
| 52160 | // Converter (dnn_Net) |  | 52112 | // Converter (dnn_Net)
| 52161 |  |  | 52113 |
| 52162 | template<> |  | 52114 | template<>
| 52163 | struct PyOpenCV_Converter< cv::dnn::Net > |  | 52115 | struct PyOpenCV_Converter< cv::dnn::Net >
| 52164 | { |  | 52116 | {
| 52165 | static PyObject* from(const cv::dnn::Net& r) |  | 52117 | static PyObject* from(const cv::dnn::Net& r)
| 52166 | { |  | 52118 | {
| 52167 | return pyopencv_dnn_Net_Instance(r); |  | 52119 | return pyopencv_dnn_Net_Instance(r);
| 52168 | } |  | 52120 | }
| 52169 | static bool to(PyObject* src, cv::dnn::Net& dst, const ArgInfo& info) |  | 52121 | static bool to(PyObject* src, cv::dnn::Net& dst, const ArgInfo& info)
| 52170 | { |  | 52122 | {
| 52171 | if(!src || src == Py_None) |  | 52123 | if(!src || src == Py_None)
| 52172 | return true; |  | 52124 | return true;
| 52173 | cv::dnn::Net * dst_; |  | 52125 | cv::dnn::Net * dst_;
| 52174 | if (pyopencv_dnn_Net_getp(src, dst_)) |  | 52126 | if (pyopencv_dnn_Net_getp(src, dst_))
| 52175 | { |  | 52127 | {
| 52176 | dst = *dst_; |  | 52128 | dst = *dst_;
| 52177 | return true; |  | 52129 | return true;
| 52178 | } |  | 52130 | }
| 52179 |  |  | 52131 |
| 52180 | failmsg("Expected cv::dnn::Net for argument '%s'", info.name); |  | 52132 | failmsg("Expected cv::dnn::Net for argument '%s'", info.name);
| 52181 | return false; |  | 52133 | return false;
| 52182 | } |  | 52134 | }
| 52183 | }; |  | 52135 | };
| 52184 |  |  | 52136 |
| 52185 | //================================================================================ |  | 52137 | //================================================================================
| 52186 | // dnn_SegmentationModel (Generic) |  | 52138 | // dnn_SegmentationModel (Generic)
| 52187 | //================================================================================ |  | 52139 | //================================================================================
| 52188 |  |  | 52140 |
| 52189 | // GetSet (dnn_SegmentationModel) |  | 52141 | // GetSet (dnn_SegmentationModel)
| 52190 |  |  | 52142 |
| 52191 |  |  | 52143 |
| 52192 |  |  | 52144 |
| 52193 | // Methods (dnn_SegmentationModel) |  | 52145 | // Methods (dnn_SegmentationModel)
| 52194 |  |  | 52146 |
| 52195 | static int pyopencv_cv_dnn_dnn_SegmentationModel_SegmentationModel(pyopencv_dnn_SegmentationModel_t* self, PyObject* py_args, PyObject* kw) |  | 52147 | static int pyopencv_cv_dnn_dnn_SegmentationModel_SegmentationModel(pyopencv_dnn_SegmentationModel_t* self, PyObject* py_args, PyObject* kw)
| 52196 | { |  | 52148 | {
| 52197 | using namespace cv::dnn; |  | 52149 | using namespace cv::dnn;
| 52198 |  |  | 52150 |
| 52199 | pyPrepareArgumentConversionErrorsStorage(2); |  | 52151 | pyPrepareArgumentConversionErrorsStorage(2);
| 52200 |  |  | 52152 |
| 52201 | { |  | 52153 | {
| 52202 | PyObject* pyobj_model = NULL; |  | 52154 | PyObject* pyobj_model = NULL;
| 52203 | String model; |  | 52155 | String model;
| 52204 | PyObject* pyobj_config = NULL; |  | 52156 | PyObject* pyobj_config = NULL;
| 52205 | String config=""; |  | 52157 | String config="";
| 52206 |  |  | 52158 |
| 52207 | const char* keywords[] = { "model", "config", NULL }; |  | 52159 | const char* keywords[] = { "model", "config", NULL };
| 52208 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:SegmentationModel", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 52160 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:SegmentationModel", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 52209 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 52161 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 52210 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 52162 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 52211 | { |  | 52163 | {
| 52212 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::SegmentationModel(model, config)); |  | 52164 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::SegmentationModel(model, config));
| 52213 | return 0; |  | 52165 | return 0;
| 52214 | } |  | 52166 | }
| 52215 |  |  | 52167 |
| 52216 |  |  | 52168 |
| 52217 | pyPopulateArgumentConversionErrors(); |  | 52169 | pyPopulateArgumentConversionErrors();
| 52218 | } |  | 52170 | }
| 52219 |  |  | 52171 |
| 52220 |  |  | 52172 |
| 52221 | { |  | 52173 | {
| 52222 | PyObject* pyobj_network = NULL; |  | 52174 | PyObject* pyobj_network = NULL;
| 52223 | Net network; |  | 52175 | Net network;
| 52224 |  |  | 52176 |
| 52225 | const char* keywords[] = { "network", NULL }; |  | 52177 | const char* keywords[] = { "network", NULL };
| 52226 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SegmentationModel", (char**)keywords, &pyobj_network) && |  | 52178 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:SegmentationModel", (char**)keywords, &pyobj_network) &&
| 52227 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 52179 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 52228 | { |  | 52180 | {
| 52229 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::SegmentationModel(network)); |  | 52181 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::SegmentationModel(network));
| 52230 | return 0; |  | 52182 | return 0;
| 52231 | } |  | 52183 | }
| 52232 |  |  | 52184 |
| 52233 |  |  | 52185 |
| 52234 | pyPopulateArgumentConversionErrors(); |  | 52186 | pyPopulateArgumentConversionErrors();
| 52235 | } |  | 52187 | }
| 52236 | pyRaiseCVOverloadException("SegmentationModel"); |  | 52188 | pyRaiseCVOverloadException("SegmentationModel");
| 52237 |  |  | 52189 |
| 52238 | return -1; |  | 52190 | return -1;
| 52239 | } |  | 52191 | }
| 52240 |  |  | 52192 |
| 52241 | static PyObject* pyopencv_cv_dnn_dnn_SegmentationModel_segment(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52193 | static PyObject* pyopencv_cv_dnn_dnn_SegmentationModel_segment(PyObject* self, PyObject* py_args, PyObject* kw)
| 52242 | { |  | 52194 | {
| 52243 | using namespace cv::dnn; |  | 52195 | using namespace cv::dnn;
| 52244 |  |  | 52196 |
| 52245 |  |  | 52197 |
| 52246 | cv::dnn::SegmentationModel * self1 = 0; |  | 52198 | cv::dnn::SegmentationModel * self1 = 0;
| 52247 | if (!pyopencv_dnn_SegmentationModel_getp(self, self1)) |  | 52199 | if (!pyopencv_dnn_SegmentationModel_getp(self, self1))
| 52248 | return failmsgp("Incorrect type of self (must be 'dnn_SegmentationModel' or its derivative)"); |  | 52200 | return failmsgp("Incorrect type of self (must be 'dnn_SegmentationModel' or its derivative)");
| 52249 | cv::dnn::SegmentationModel* _self_ = (self1); |  | 52201 | cv::dnn::SegmentationModel* _self_ = (self1);
| 52250 | pyPrepareArgumentConversionErrorsStorage(2); |  | 52202 | pyPrepareArgumentConversionErrorsStorage(2);
| 52251 |  |  | 52203 |
| 52252 | { |  | 52204 | {
| 52253 | PyObject* pyobj_frame = NULL; |  | 52205 | PyObject* pyobj_frame = NULL;
| 52254 | Mat frame; |  | 52206 | Mat frame;
| 52255 | PyObject* pyobj_mask = NULL; |  | 52207 | PyObject* pyobj_mask = NULL;
| 52256 | Mat mask; |  | 52208 | Mat mask;
| 52257 |  |  | 52209 |
| 52258 | const char* keywords[] = { "frame", "mask", NULL }; |  | 52210 | const char* keywords[] = { "frame", "mask", NULL };
| 52259 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_SegmentationModel.segment", (char**)keywords, &pyobj_frame, &pyobj_mask) && |  | 52211 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_SegmentationModel.segment", (char**)keywords, &pyobj_frame, &pyobj_mask) &&
| 52260 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 52212 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 52261 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) ) |  | 52213 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) )
| 52262 | { |  | 52214 | {
| 52263 | ERRWRAP2(_self_->segment(frame, mask)); |  | 52215 | ERRWRAP2(_self_->segment(frame, mask));
| 52264 | return pyopencv_from(mask); |  | 52216 | return pyopencv_from(mask);
| 52265 | } |  | 52217 | }
| 52266 |  |  | 52218 |
| 52267 |  |  | 52219 |
| 52268 | pyPopulateArgumentConversionErrors(); |  | 52220 | pyPopulateArgumentConversionErrors();
| 52269 | } |  | 52221 | }
| 52270 |  |  | 52222 |
| 52271 |  |  | 52223 |
| 52272 | { |  | 52224 | {
| 52273 | PyObject* pyobj_frame = NULL; |  | 52225 | PyObject* pyobj_frame = NULL;
| 52274 | UMat frame; |  | 52226 | UMat frame;
| 52275 | PyObject* pyobj_mask = NULL; |  | 52227 | PyObject* pyobj_mask = NULL;
| 52276 | UMat mask; |  | 52228 | UMat mask;
| 52277 |  |  | 52229 |
| 52278 | const char* keywords[] = { "frame", "mask", NULL }; |  | 52230 | const char* keywords[] = { "frame", "mask", NULL };
| 52279 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_SegmentationModel.segment", (char**)keywords, &pyobj_frame, &pyobj_mask) && |  | 52231 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_SegmentationModel.segment", (char**)keywords, &pyobj_frame, &pyobj_mask) &&
| 52280 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 52232 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 52281 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) ) |  | 52233 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) )
| 52282 | { |  | 52234 | {
| 52283 | ERRWRAP2(_self_->segment(frame, mask)); |  | 52235 | ERRWRAP2(_self_->segment(frame, mask));
| 52284 | return pyopencv_from(mask); |  | 52236 | return pyopencv_from(mask);
| 52285 | } |  | 52237 | }
| 52286 |  |  | 52238 |
| 52287 |  |  | 52239 |
| 52288 | pyPopulateArgumentConversionErrors(); |  | 52240 | pyPopulateArgumentConversionErrors();
| 52289 | } |  | 52241 | }
| 52290 | pyRaiseCVOverloadException("segment"); |  | 52242 | pyRaiseCVOverloadException("segment");
| 52291 |  |  | 52243 |
| 52292 | return NULL; |  | 52244 | return NULL;
| 52293 | } |  | 52245 | }
| 52294 |  |  | 52246 |
| 52295 |  |  | 52247 |
| 52296 |  |  | 52248 |
| 52297 | // Tables (dnn_SegmentationModel) |  | 52249 | // Tables (dnn_SegmentationModel)
| 52298 |  |  | 52250 |
| 52299 | static PyGetSetDef pyopencv_dnn_SegmentationModel_getseters[] = |  | 52251 | static PyGetSetDef pyopencv_dnn_SegmentationModel_getseters[] =
| 52300 | { |  | 52252 | {
| 52301 | {NULL} /* Sentinel */ |  | 52253 | {NULL} /* Sentinel */
| 52302 | }; |  | 52254 | };
| 52303 |  |  | 52255 |
| 52304 | static PyMethodDef pyopencv_dnn_SegmentationModel_methods[] = |  | 52256 | static PyMethodDef pyopencv_dnn_SegmentationModel_methods[] =
| 52305 | { |  | 52257 | {
| 52306 | {"segment", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_SegmentationModel_segment, 0), "segment(frame[, mask]) -> mask\n. @brief Given the @p input frame, create input blob, run net\n. * @param[in] frame The input image.\n. * @param[out] mask Allocated class prediction for each pixel"}, |  | 52258 | {"segment", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_SegmentationModel_segment, 0), "segment(frame[, mask]) -> mask\n. @brief Given the @p input frame, create input blob, run net\n. * @param[in] frame The input image.\n. * @param[out] mask Allocated class prediction for each pixel"},
| 52307 |  |  | 52259 |
| 52308 | {NULL, NULL} |  | 52260 | {NULL, NULL}
| 52309 | }; |  | 52261 | };
| 52310 |  |  | 52262 |
| 52311 | // Converter (dnn_SegmentationModel) |  | 52263 | // Converter (dnn_SegmentationModel)
| 52312 |  |  | 52264 |
| 52313 | template<> |  | 52265 | template<>
| 52314 | struct PyOpenCV_Converter< cv::dnn::SegmentationModel > |  | 52266 | struct PyOpenCV_Converter< cv::dnn::SegmentationModel >
| 52315 | { |  | 52267 | {
| 52316 | static PyObject* from(const cv::dnn::SegmentationModel& r) |  | 52268 | static PyObject* from(const cv::dnn::SegmentationModel& r)
| 52317 | { |  | 52269 | {
| 52318 | return pyopencv_dnn_SegmentationModel_Instance(r); |  | 52270 | return pyopencv_dnn_SegmentationModel_Instance(r);
| 52319 | } |  | 52271 | }
| 52320 | static bool to(PyObject* src, cv::dnn::SegmentationModel& dst, const ArgInfo& info) |  | 52272 | static bool to(PyObject* src, cv::dnn::SegmentationModel& dst, const ArgInfo& info)
| 52321 | { |  | 52273 | {
| 52322 | if(!src || src == Py_None) |  | 52274 | if(!src || src == Py_None)
| 52323 | return true; |  | 52275 | return true;
| 52324 | cv::dnn::SegmentationModel * dst_; |  | 52276 | cv::dnn::SegmentationModel * dst_;
| 52325 | if (pyopencv_dnn_SegmentationModel_getp(src, dst_)) |  | 52277 | if (pyopencv_dnn_SegmentationModel_getp(src, dst_))
| 52326 | { |  | 52278 | {
| 52327 | dst = *dst_; |  | 52279 | dst = *dst_;
| 52328 | return true; |  | 52280 | return true;
| 52329 | } |  | 52281 | }
| 52330 |  |  | 52282 |
| 52331 | failmsg("Expected cv::dnn::SegmentationModel for argument '%s'", info.name); |  | 52283 | failmsg("Expected cv::dnn::SegmentationModel for argument '%s'", info.name);
| 52332 | return false; |  | 52284 | return false;
| 52333 | } |  | 52285 | }
| 52334 | }; |  | 52286 | };
| 52335 |  |  | 52287 |
| 52336 | //================================================================================ |  | 52288 | //================================================================================
| 52337 | // dnn_TextDetectionModel (Generic) |  | 52289 | // dnn_TextDetectionModel (Generic)
| 52338 | //================================================================================ |  | 52290 | //================================================================================
| 52339 |  |  | 52291 |
| 52340 | // GetSet (dnn_TextDetectionModel) |  | 52292 | // GetSet (dnn_TextDetectionModel)
| 52341 |  |  | 52293 |
| 52342 |  |  | 52294 |
| 52343 |  |  | 52295 |
| 52344 | // Methods (dnn_TextDetectionModel) |  | 52296 | // Methods (dnn_TextDetectionModel)
| 52345 |  |  | 52297 |
| 52346 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52298 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 52347 | { |  | 52299 | {
| 52348 | using namespace cv::dnn; |  | 52300 | using namespace cv::dnn;
| 52349 |  |  | 52301 |
| 52350 |  |  | 52302 |
| 52351 | cv::dnn::TextDetectionModel * self1 = 0; |  | 52303 | cv::dnn::TextDetectionModel * self1 = 0;
| 52352 | if (!pyopencv_dnn_TextDetectionModel_getp(self, self1)) |  | 52304 | if (!pyopencv_dnn_TextDetectionModel_getp(self, self1))
| 52353 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel' or its derivative)"); |  | 52305 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel' or its derivative)");
| 52354 | cv::dnn::TextDetectionModel* _self_ = (self1); |  | 52306 | cv::dnn::TextDetectionModel* _self_ = (self1);
| 52355 | pyPrepareArgumentConversionErrorsStorage(4); |  | 52307 | pyPrepareArgumentConversionErrorsStorage(4);
| 52356 |  |  | 52308 |
| 52357 | { |  | 52309 | {
| 52358 | PyObject* pyobj_frame = NULL; |  | 52310 | PyObject* pyobj_frame = NULL;
| 52359 | Mat frame; |  | 52311 | Mat frame;
| 52360 | vector_vector_Point detections; |  | 52312 | vector_vector_Point detections;
| 52361 | vector_float confidences; |  | 52313 | vector_float confidences;
| 52362 |  |  | 52314 |
| 52363 | const char* keywords[] = { "frame", NULL }; |  | 52315 | const char* keywords[] = { "frame", NULL };
| 52364 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) && |  | 52316 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) &&
| 52365 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52317 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52366 | { |  | 52318 | {
| 52367 | ERRWRAP2(_self_->detect(frame, detections, confidences)); |  | 52319 | ERRWRAP2(_self_->detect(frame, detections, confidences));
| 52368 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences)); |  | 52320 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences));
| 52369 | } |  | 52321 | }
| 52370 |  |  | 52322 |
| 52371 |  |  | 52323 |
| 52372 | pyPopulateArgumentConversionErrors(); |  | 52324 | pyPopulateArgumentConversionErrors();
| 52373 | } |  | 52325 | }
| 52374 |  |  | 52326 |
| 52375 |  |  | 52327 |
| 52376 | { |  | 52328 | {
| 52377 | PyObject* pyobj_frame = NULL; |  | 52329 | PyObject* pyobj_frame = NULL;
| 52378 | Mat frame; |  | 52330 | Mat frame;
| 52379 | vector_vector_Point detections; |  | 52331 | vector_vector_Point detections;
| 52380 |  |  | 52332 |
| 52381 | const char* keywords[] = { "frame", NULL }; |  | 52333 | const char* keywords[] = { "frame", NULL };
| 52382 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) && |  | 52334 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) &&
| 52383 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52335 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52384 | { |  | 52336 | {
| 52385 | ERRWRAP2(_self_->detect(frame, detections)); |  | 52337 | ERRWRAP2(_self_->detect(frame, detections));
| 52386 | return pyopencv_from(detections); |  | 52338 | return pyopencv_from(detections);
| 52387 | } |  | 52339 | }
| 52388 |  |  | 52340 |
| 52389 |  |  | 52341 |
| 52390 | pyPopulateArgumentConversionErrors(); |  | 52342 | pyPopulateArgumentConversionErrors();
| 52391 | } |  | 52343 | }
| 52392 |  |  | 52344 |
| 52393 |  |  | 52345 |
| 52394 | { |  | 52346 | {
| 52395 | PyObject* pyobj_frame = NULL; |  | 52347 | PyObject* pyobj_frame = NULL;
| 52396 | UMat frame; |  | 52348 | UMat frame;
| 52397 | vector_vector_Point detections; |  | 52349 | vector_vector_Point detections;
| 52398 | vector_float confidences; |  | 52350 | vector_float confidences;
| 52399 |  |  | 52351 |
| 52400 | const char* keywords[] = { "frame", NULL }; |  | 52352 | const char* keywords[] = { "frame", NULL };
| 52401 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) && |  | 52353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) &&
| 52402 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52354 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52403 | { |  | 52355 | {
| 52404 | ERRWRAP2(_self_->detect(frame, detections, confidences)); |  | 52356 | ERRWRAP2(_self_->detect(frame, detections, confidences));
| 52405 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences)); |  | 52357 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences));
| 52406 | } |  | 52358 | }
| 52407 |  |  | 52359 |
| 52408 |  |  | 52360 |
| 52409 | pyPopulateArgumentConversionErrors(); |  | 52361 | pyPopulateArgumentConversionErrors();
| 52410 | } |  | 52362 | }
| 52411 |  |  | 52363 |
| 52412 |  |  | 52364 |
| 52413 | { |  | 52365 | {
| 52414 | PyObject* pyobj_frame = NULL; |  | 52366 | PyObject* pyobj_frame = NULL;
| 52415 | UMat frame; |  | 52367 | UMat frame;
| 52416 | vector_vector_Point detections; |  | 52368 | vector_vector_Point detections;
| 52417 |  |  | 52369 |
| 52418 | const char* keywords[] = { "frame", NULL }; |  | 52370 | const char* keywords[] = { "frame", NULL };
| 52419 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) && |  | 52371 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detect", (char**)keywords, &pyobj_frame) &&
| 52420 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52372 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52421 | { |  | 52373 | {
| 52422 | ERRWRAP2(_self_->detect(frame, detections)); |  | 52374 | ERRWRAP2(_self_->detect(frame, detections));
| 52423 | return pyopencv_from(detections); |  | 52375 | return pyopencv_from(detections);
| 52424 | } |  | 52376 | }
| 52425 |  |  | 52377 |
| 52426 |  |  | 52378 |
| 52427 | pyPopulateArgumentConversionErrors(); |  | 52379 | pyPopulateArgumentConversionErrors();
| 52428 | } |  | 52380 | }
| 52429 | pyRaiseCVOverloadException("detect"); |  | 52381 | pyRaiseCVOverloadException("detect");
| 52430 |  |  | 52382 |
| 52431 | return NULL; |  | 52383 | return NULL;
| 52432 | } |  | 52384 | }
| 52433 |  |  | 52385 |
| 52434 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_detectTextRectangles(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52386 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_detectTextRectangles(PyObject* self, PyObject* py_args, PyObject* kw)
| 52435 | { |  | 52387 | {
| 52436 | using namespace cv::dnn; |  | 52388 | using namespace cv::dnn;
| 52437 |  |  | 52389 |
| 52438 |  |  | 52390 |
| 52439 | cv::dnn::TextDetectionModel * self1 = 0; |  | 52391 | cv::dnn::TextDetectionModel * self1 = 0;
| 52440 | if (!pyopencv_dnn_TextDetectionModel_getp(self, self1)) |  | 52392 | if (!pyopencv_dnn_TextDetectionModel_getp(self, self1))
| 52441 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel' or its derivative)"); |  | 52393 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel' or its derivative)");
| 52442 | cv::dnn::TextDetectionModel* _self_ = (self1); |  | 52394 | cv::dnn::TextDetectionModel* _self_ = (self1);
| 52443 | pyPrepareArgumentConversionErrorsStorage(4); |  | 52395 | pyPrepareArgumentConversionErrorsStorage(4);
| 52444 |  |  | 52396 |
| 52445 | { |  | 52397 | {
| 52446 | PyObject* pyobj_frame = NULL; |  | 52398 | PyObject* pyobj_frame = NULL;
| 52447 | Mat frame; |  | 52399 | Mat frame;
| 52448 | vector_RotatedRect detections; |  | 52400 | vector_RotatedRect detections;
| 52449 | vector_float confidences; |  | 52401 | vector_float confidences;
| 52450 |  |  | 52402 |
| 52451 | const char* keywords[] = { "frame", NULL }; |  | 52403 | const char* keywords[] = { "frame", NULL };
| 52452 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) && |  | 52404 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) &&
| 52453 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52405 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52454 | { |  | 52406 | {
| 52455 | ERRWRAP2(_self_->detectTextRectangles(frame, detections, confidences)); |  | 52407 | ERRWRAP2(_self_->detectTextRectangles(frame, detections, confidences));
| 52456 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences)); |  | 52408 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences));
| 52457 | } |  | 52409 | }
| 52458 |  |  | 52410 |
| 52459 |  |  | 52411 |
| 52460 | pyPopulateArgumentConversionErrors(); |  | 52412 | pyPopulateArgumentConversionErrors();
| 52461 | } |  | 52413 | }
| 52462 |  |  | 52414 |
| 52463 |  |  | 52415 |
| 52464 | { |  | 52416 | {
| 52465 | PyObject* pyobj_frame = NULL; |  | 52417 | PyObject* pyobj_frame = NULL;
| 52466 | Mat frame; |  | 52418 | Mat frame;
| 52467 | vector_RotatedRect detections; |  | 52419 | vector_RotatedRect detections;
| 52468 |  |  | 52420 |
| 52469 | const char* keywords[] = { "frame", NULL }; |  | 52421 | const char* keywords[] = { "frame", NULL };
| 52470 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) && |  | 52422 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) &&
| 52471 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52423 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52472 | { |  | 52424 | {
| 52473 | ERRWRAP2(_self_->detectTextRectangles(frame, detections)); |  | 52425 | ERRWRAP2(_self_->detectTextRectangles(frame, detections));
| 52474 | return pyopencv_from(detections); |  | 52426 | return pyopencv_from(detections);
| 52475 | } |  | 52427 | }
| 52476 |  |  | 52428 |
| 52477 |  |  | 52429 |
| 52478 | pyPopulateArgumentConversionErrors(); |  | 52430 | pyPopulateArgumentConversionErrors();
| 52479 | } |  | 52431 | }
| 52480 |  |  | 52432 |
| 52481 |  |  | 52433 |
| 52482 | { |  | 52434 | {
| 52483 | PyObject* pyobj_frame = NULL; |  | 52435 | PyObject* pyobj_frame = NULL;
| 52484 | UMat frame; |  | 52436 | UMat frame;
| 52485 | vector_RotatedRect detections; |  | 52437 | vector_RotatedRect detections;
| 52486 | vector_float confidences; |  | 52438 | vector_float confidences;
| 52487 |  |  | 52439 |
| 52488 | const char* keywords[] = { "frame", NULL }; |  | 52440 | const char* keywords[] = { "frame", NULL };
| 52489 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) && |  | 52441 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) &&
| 52490 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52442 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52491 | { |  | 52443 | {
| 52492 | ERRWRAP2(_self_->detectTextRectangles(frame, detections, confidences)); |  | 52444 | ERRWRAP2(_self_->detectTextRectangles(frame, detections, confidences));
| 52493 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences)); |  | 52445 | return Py_BuildValue("(NN)", pyopencv_from(detections), pyopencv_from(confidences));
| 52494 | } |  | 52446 | }
| 52495 |  |  | 52447 |
| 52496 |  |  | 52448 |
| 52497 | pyPopulateArgumentConversionErrors(); |  | 52449 | pyPopulateArgumentConversionErrors();
| 52498 | } |  | 52450 | }
| 52499 |  |  | 52451 |
| 52500 |  |  | 52452 |
| 52501 | { |  | 52453 | {
| 52502 | PyObject* pyobj_frame = NULL; |  | 52454 | PyObject* pyobj_frame = NULL;
| 52503 | UMat frame; |  | 52455 | UMat frame;
| 52504 | vector_RotatedRect detections; |  | 52456 | vector_RotatedRect detections;
| 52505 |  |  | 52457 |
| 52506 | const char* keywords[] = { "frame", NULL }; |  | 52458 | const char* keywords[] = { "frame", NULL };
| 52507 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) && |  | 52459 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel.detectTextRectangles", (char**)keywords, &pyobj_frame) &&
| 52508 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 52460 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 52509 | { |  | 52461 | {
| 52510 | ERRWRAP2(_self_->detectTextRectangles(frame, detections)); |  | 52462 | ERRWRAP2(_self_->detectTextRectangles(frame, detections));
| 52511 | return pyopencv_from(detections); |  | 52463 | return pyopencv_from(detections);
| 52512 | } |  | 52464 | }
| 52513 |  |  | 52465 |
| 52514 |  |  | 52466 |
| 52515 | pyPopulateArgumentConversionErrors(); |  | 52467 | pyPopulateArgumentConversionErrors();
| 52516 | } |  | 52468 | }
| 52517 | pyRaiseCVOverloadException("detectTextRectangles"); |  | 52469 | pyRaiseCVOverloadException("detectTextRectangles");
| 52518 |  |  | 52470 |
| 52519 | return NULL; |  | 52471 | return NULL;
| 52520 | } |  | 52472 | }
| 52521 |  |  | 52473 |
| 52522 |  |  | 52474 |
| 52523 |  |  | 52475 |
| 52524 | // Tables (dnn_TextDetectionModel) |  | 52476 | // Tables (dnn_TextDetectionModel)
| 52525 |  |  | 52477 |
| 52526 | static PyGetSetDef pyopencv_dnn_TextDetectionModel_getseters[] = |  | 52478 | static PyGetSetDef pyopencv_dnn_TextDetectionModel_getseters[] =
| 52527 | { |  | 52479 | {
| 52528 | {NULL} /* Sentinel */ |  | 52480 | {NULL} /* Sentinel */
| 52529 | }; |  | 52481 | };
| 52530 |  |  | 52482 |
| 52531 | static PyMethodDef pyopencv_dnn_TextDetectionModel_methods[] = |  | 52483 | static PyMethodDef pyopencv_dnn_TextDetectionModel_methods[] =
| 52532 | { |  | 52484 | {
| 52533 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_detect, 0), "detect(frame) -> detections, confidences\n. @brief Performs detection\n. *\n. * Given the input @p frame, prepare network input, run network inference, post-process network output and return result detections.\n. *\n. * Each result is quadrangle's 4 points in this order:\n. * - bottom-left\n. * - top-left\n. * - top-right\n. * - bottom-right\n. *\n. * Use cv::getPerspectiveTransform function to retrieve image region without perspective transformations.\n. *\n. * @note If DL model doesn't support that kind of output then result may be derived from detectTextRectangles() output.\n. *\n. * @param[in] frame The input image\n. * @param[out] detections array with detections' quadrangles (4 points per result)\n. * @param[out] confidences array with detection confidences\n\n\n\ndetect(frame) -> detections\n. @overload"}, |  | 52485 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_detect, 0), "detect(frame) -> detections, confidences\n. @brief Performs detection\n. *\n. * Given the input @p frame, prepare network input, run network inference, post-process network output and return result detections.\n. *\n. * Each result is quadrangle's 4 points in this order:\n. * - bottom-left\n. * - top-left\n. * - top-right\n. * - bottom-right\n. *\n. * Use cv::getPerspectiveTransform function to retrieve image region without perspective transformations.\n. *\n. * @note If DL model doesn't support that kind of output then result may be derived from detectTextRectangles() output.\n. *\n. * @param[in] frame The input image\n. * @param[out] detections array with detections' quadrangles (4 points per result)\n. * @param[out] confidences array with detection confidences\n\n\n\ndetect(frame) -> detections\n. @overload"},
| 52534 | {"detectTextRectangles", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_detectTextRectangles, 0), "detectTextRectangles(frame) -> detections, confidences\n. @brief Performs detection\n. *\n. * Given the input @p frame, prepare network input, run network inference, post-process network output and return result detections.\n. *\n. * Each result is rotated rectangle.\n. *\n. * @note Result may be inaccurate in case of strong perspective transformations.\n. *\n. * @param[in] frame the input image\n. * @param[out] detections array with detections' RotationRect results\n. * @param[out] confidences array with detection confidences\n\n\n\ndetectTextRectangles(frame) -> detections\n. @overload"}, |  | 52486 | {"detectTextRectangles", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_detectTextRectangles, 0), "detectTextRectangles(frame) -> detections, confidences\n. @brief Performs detection\n. *\n. * Given the input @p frame, prepare network input, run network inference, post-process network output and return result detections.\n. *\n. * Each result is rotated rectangle.\n. *\n. * @note Result may be inaccurate in case of strong perspective transformations.\n. *\n. * @param[in] frame the input image\n. * @param[out] detections array with detections' RotationRect results\n. * @param[out] confidences array with detection confidences\n\n\n\ndetectTextRectangles(frame) -> detections\n. @overload"},
| 52535 |  |  | 52487 |
| 52536 | {NULL, NULL} |  | 52488 | {NULL, NULL}
| 52537 | }; |  | 52489 | };
| 52538 |  |  | 52490 |
| 52539 | // Converter (dnn_TextDetectionModel) |  | 52491 | // Converter (dnn_TextDetectionModel)
| 52540 |  |  | 52492 |
| 52541 | template<> |  | 52493 | template<>
| 52542 | struct PyOpenCV_Converter< cv::dnn::TextDetectionModel > |  | 52494 | struct PyOpenCV_Converter< cv::dnn::TextDetectionModel >
| 52543 | { |  | 52495 | {
| 52544 | static PyObject* from(const cv::dnn::TextDetectionModel& r) |  | 52496 | static PyObject* from(const cv::dnn::TextDetectionModel& r)
| 52545 | { |  | 52497 | {
| 52546 | return pyopencv_dnn_TextDetectionModel_Instance(r); |  | 52498 | return pyopencv_dnn_TextDetectionModel_Instance(r);
| 52547 | } |  | 52499 | }
| 52548 | static bool to(PyObject* src, cv::dnn::TextDetectionModel& dst, const ArgInfo& info) |  | 52500 | static bool to(PyObject* src, cv::dnn::TextDetectionModel& dst, const ArgInfo& info)
| 52549 | { |  | 52501 | {
| 52550 | if(!src || src == Py_None) |  | 52502 | if(!src || src == Py_None)
| 52551 | return true; |  | 52503 | return true;
| 52552 | cv::dnn::TextDetectionModel * dst_; |  | 52504 | cv::dnn::TextDetectionModel * dst_;
| 52553 | if (pyopencv_dnn_TextDetectionModel_getp(src, dst_)) |  | 52505 | if (pyopencv_dnn_TextDetectionModel_getp(src, dst_))
| 52554 | { |  | 52506 | {
| 52555 | dst = *dst_; |  | 52507 | dst = *dst_;
| 52556 | return true; |  | 52508 | return true;
| 52557 | } |  | 52509 | }
| 52558 |  |  | 52510 |
| 52559 | failmsg("Expected cv::dnn::TextDetectionModel for argument '%s'", info.name); |  | 52511 | failmsg("Expected cv::dnn::TextDetectionModel for argument '%s'", info.name);
| 52560 | return false; |  | 52512 | return false;
| 52561 | } |  | 52513 | }
| 52562 | }; |  | 52514 | };
| 52563 |  |  | 52515 |
| 52564 | //================================================================================ |  | 52516 | //================================================================================
| 52565 | // dnn_TextDetectionModel_DB (Generic) |  | 52517 | // dnn_TextDetectionModel_DB (Generic)
| 52566 | //================================================================================ |  | 52518 | //================================================================================
| 52567 |  |  | 52519 |
| 52568 | // GetSet (dnn_TextDetectionModel_DB) |  | 52520 | // GetSet (dnn_TextDetectionModel_DB)
| 52569 |  |  | 52521 |
| 52570 |  |  | 52522 |
| 52571 |  |  | 52523 |
| 52572 | // Methods (dnn_TextDetectionModel_DB) |  | 52524 | // Methods (dnn_TextDetectionModel_DB)
| 52573 |  |  | 52525 |
| 52574 | static int pyopencv_cv_dnn_dnn_TextDetectionModel_DB_TextDetectionModel_DB(pyopencv_dnn_TextDetectionModel_DB_t* self, PyObject* py_args, PyObject* kw) |  | 52526 | static int pyopencv_cv_dnn_dnn_TextDetectionModel_DB_TextDetectionModel_DB(pyopencv_dnn_TextDetectionModel_DB_t* self, PyObject* py_args, PyObject* kw)
| 52575 | { |  | 52527 | {
| 52576 | using namespace cv::dnn; |  | 52528 | using namespace cv::dnn;
| 52577 |  |  | 52529 |
| 52578 | pyPrepareArgumentConversionErrorsStorage(2); |  | 52530 | pyPrepareArgumentConversionErrorsStorage(2);
| 52579 |  |  | 52531 |
| 52580 | { |  | 52532 | {
| 52581 | PyObject* pyobj_network = NULL; |  | 52533 | PyObject* pyobj_network = NULL;
| 52582 | Net network; |  | 52534 | Net network;
| 52583 |  |  | 52535 |
| 52584 | const char* keywords[] = { "network", NULL }; |  | 52536 | const char* keywords[] = { "network", NULL };
| 52585 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TextDetectionModel_DB", (char**)keywords, &pyobj_network) && |  | 52537 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TextDetectionModel_DB", (char**)keywords, &pyobj_network) &&
| 52586 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 52538 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 52587 | { |  | 52539 | {
| 52588 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_DB(network)); |  | 52540 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_DB(network));
| 52589 | return 0; |  | 52541 | return 0;
| 52590 | } |  | 52542 | }
| 52591 |  |  | 52543 |
| 52592 |  |  | 52544 |
| 52593 | pyPopulateArgumentConversionErrors(); |  | 52545 | pyPopulateArgumentConversionErrors();
| 52594 | } |  | 52546 | }
| 52595 |  |  | 52547 |
| 52596 |  |  | 52548 |
| 52597 | { |  | 52549 | {
| 52598 | PyObject* pyobj_model = NULL; |  | 52550 | PyObject* pyobj_model = NULL;
| 52599 | std::string model; |  | 52551 | std::string model;
| 52600 | PyObject* pyobj_config = NULL; |  | 52552 | PyObject* pyobj_config = NULL;
| 52601 | std::string config=""; |  | 52553 | std::string config="";
| 52602 |  |  | 52554 |
| 52603 | const char* keywords[] = { "model", "config", NULL }; |  | 52555 | const char* keywords[] = { "model", "config", NULL };
| 52604 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:TextDetectionModel_DB", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 52556 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:TextDetectionModel_DB", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 52605 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 52557 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 52606 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 52558 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 52607 | { |  | 52559 | {
| 52608 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_DB(model, config)); |  | 52560 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_DB(model, config));
| 52609 | return 0; |  | 52561 | return 0;
| 52610 | } |  | 52562 | }
| 52611 |  |  | 52563 |
| 52612 |  |  | 52564 |
| 52613 | pyPopulateArgumentConversionErrors(); |  | 52565 | pyPopulateArgumentConversionErrors();
| 52614 | } |  | 52566 | }
| 52615 | pyRaiseCVOverloadException("TextDetectionModel_DB"); |  | 52567 | pyRaiseCVOverloadException("TextDetectionModel_DB");
| 52616 |  |  | 52568 |
| 52617 | return -1; |  | 52569 | return -1;
| 52618 | } |  | 52570 | }
| 52619 |  |  | 52571 |
| 52620 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getBinaryThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52572 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getBinaryThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52621 | { |  | 52573 | {
| 52622 | using namespace cv::dnn; |  | 52574 | using namespace cv::dnn;
| 52623 |  |  | 52575 |
| 52624 |  |  | 52576 |
| 52625 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52577 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52626 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52578 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52627 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52579 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52628 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52580 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52629 | float retval; |  | 52581 | float retval;
| 52630 |  |  | 52582 |
| 52631 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 52583 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 52632 | { |  | 52584 | {
| 52633 | ERRWRAP2(retval = _self_->getBinaryThreshold()); |  | 52585 | ERRWRAP2(retval = _self_->getBinaryThreshold());
| 52634 | return pyopencv_from(retval); |  | 52586 | return pyopencv_from(retval);
| 52635 | } |  | 52587 | }
| 52636 |  |  | 52588 |
| 52637 | return NULL; |  | 52589 | return NULL;
| 52638 | } |  | 52590 | }
| 52639 |  |  | 52591 |
| 52640 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getMaxCandidates(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52592 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getMaxCandidates(PyObject* self, PyObject* py_args, PyObject* kw)
| 52641 | { |  | 52593 | {
| 52642 | using namespace cv::dnn; |  | 52594 | using namespace cv::dnn;
| 52643 |  |  | 52595 |
| 52644 |  |  | 52596 |
| 52645 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52597 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52646 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52598 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52647 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52599 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52648 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52600 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52649 | int retval; |  | 52601 | int retval;
| 52650 |  |  | 52602 |
| 52651 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 52603 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 52652 | { |  | 52604 | {
| 52653 | ERRWRAP2(retval = _self_->getMaxCandidates()); |  | 52605 | ERRWRAP2(retval = _self_->getMaxCandidates());
| 52654 | return pyopencv_from(retval); |  | 52606 | return pyopencv_from(retval);
| 52655 | } |  | 52607 | }
| 52656 |  |  | 52608 |
| 52657 | return NULL; |  | 52609 | return NULL;
| 52658 | } |  | 52610 | }
| 52659 |  |  | 52611 |
| 52660 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getPolygonThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52612 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getPolygonThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52661 | { |  | 52613 | {
| 52662 | using namespace cv::dnn; |  | 52614 | using namespace cv::dnn;
| 52663 |  |  | 52615 |
| 52664 |  |  | 52616 |
| 52665 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52617 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52666 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52618 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52667 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52619 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52668 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52620 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52669 | float retval; |  | 52621 | float retval;
| 52670 |  |  | 52622 |
| 52671 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 52623 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 52672 | { |  | 52624 | {
| 52673 | ERRWRAP2(retval = _self_->getPolygonThreshold()); |  | 52625 | ERRWRAP2(retval = _self_->getPolygonThreshold());
| 52674 | return pyopencv_from(retval); |  | 52626 | return pyopencv_from(retval);
| 52675 | } |  | 52627 | }
| 52676 |  |  | 52628 |
| 52677 | return NULL; |  | 52629 | return NULL;
| 52678 | } |  | 52630 | }
| 52679 |  |  | 52631 |
| 52680 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getUnclipRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52632 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getUnclipRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 52681 | { |  | 52633 | {
| 52682 | using namespace cv::dnn; |  | 52634 | using namespace cv::dnn;
| 52683 |  |  | 52635 |
| 52684 |  |  | 52636 |
| 52685 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52637 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52686 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52638 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52687 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52639 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52688 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52640 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52689 | double retval; |  | 52641 | double retval;
| 52690 |  |  | 52642 |
| 52691 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 52643 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 52692 | { |  | 52644 | {
| 52693 | ERRWRAP2(retval = _self_->getUnclipRatio()); |  | 52645 | ERRWRAP2(retval = _self_->getUnclipRatio());
| 52694 | return pyopencv_from(retval); |  | 52646 | return pyopencv_from(retval);
| 52695 | } |  | 52647 | }
| 52696 |  |  | 52648 |
| 52697 | return NULL; |  | 52649 | return NULL;
| 52698 | } |  | 52650 | }
| 52699 |  |  | 52651 |
| 52700 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setBinaryThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52652 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setBinaryThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52701 | { |  | 52653 | {
| 52702 | using namespace cv::dnn; |  | 52654 | using namespace cv::dnn;
| 52703 |  |  | 52655 |
| 52704 |  |  | 52656 |
| 52705 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52657 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52706 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52658 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52707 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52659 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52708 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52660 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52709 | PyObject* pyobj_binaryThreshold = NULL; |  | 52661 | PyObject* pyobj_binaryThreshold = NULL;
| 52710 | float binaryThreshold=0.f; |  | 52662 | float binaryThreshold=0.f;
| 52711 | TextDetectionModel_DB retval; |  | 52663 | TextDetectionModel_DB retval;
| 52712 |  |  | 52664 |
| 52713 | const char* keywords[] = { "binaryThreshold", NULL }; |  | 52665 | const char* keywords[] = { "binaryThreshold", NULL };
| 52714 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setBinaryThreshold", (char**)keywords, &pyobj_binaryThreshold) && |  | 52666 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setBinaryThreshold", (char**)keywords, &pyobj_binaryThreshold) &&
| 52715 | pyopencv_to_safe(pyobj_binaryThreshold, binaryThreshold, ArgInfo("binaryThreshold", 0)) ) |  | 52667 | pyopencv_to_safe(pyobj_binaryThreshold, binaryThreshold, ArgInfo("binaryThreshold", 0)) )
| 52716 | { |  | 52668 | {
| 52717 | ERRWRAP2(retval = _self_->setBinaryThreshold(binaryThreshold)); |  | 52669 | ERRWRAP2(retval = _self_->setBinaryThreshold(binaryThreshold));
| 52718 | return pyopencv_from(retval); |  | 52670 | return pyopencv_from(retval);
| 52719 | } |  | 52671 | }
| 52720 |  |  | 52672 |
| 52721 | return NULL; |  | 52673 | return NULL;
| 52722 | } |  | 52674 | }
| 52723 |  |  | 52675 |
| 52724 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setMaxCandidates(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52676 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setMaxCandidates(PyObject* self, PyObject* py_args, PyObject* kw)
| 52725 | { |  | 52677 | {
| 52726 | using namespace cv::dnn; |  | 52678 | using namespace cv::dnn;
| 52727 |  |  | 52679 |
| 52728 |  |  | 52680 |
| 52729 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52681 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52730 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52682 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52731 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52683 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52732 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52684 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52733 | PyObject* pyobj_maxCandidates = NULL; |  | 52685 | PyObject* pyobj_maxCandidates = NULL;
| 52734 | int maxCandidates=0; |  | 52686 | int maxCandidates=0;
| 52735 | TextDetectionModel_DB retval; |  | 52687 | TextDetectionModel_DB retval;
| 52736 |  |  | 52688 |
| 52737 | const char* keywords[] = { "maxCandidates", NULL }; |  | 52689 | const char* keywords[] = { "maxCandidates", NULL };
| 52738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setMaxCandidates", (char**)keywords, &pyobj_maxCandidates) && |  | 52690 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setMaxCandidates", (char**)keywords, &pyobj_maxCandidates) &&
| 52739 | pyopencv_to_safe(pyobj_maxCandidates, maxCandidates, ArgInfo("maxCandidates", 0)) ) |  | 52691 | pyopencv_to_safe(pyobj_maxCandidates, maxCandidates, ArgInfo("maxCandidates", 0)) )
| 52740 | { |  | 52692 | {
| 52741 | ERRWRAP2(retval = _self_->setMaxCandidates(maxCandidates)); |  | 52693 | ERRWRAP2(retval = _self_->setMaxCandidates(maxCandidates));
| 52742 | return pyopencv_from(retval); |  | 52694 | return pyopencv_from(retval);
| 52743 | } |  | 52695 | }
| 52744 |  |  | 52696 |
| 52745 | return NULL; |  | 52697 | return NULL;
| 52746 | } |  | 52698 | }
| 52747 |  |  | 52699 |
| 52748 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setPolygonThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52700 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setPolygonThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52749 | { |  | 52701 | {
| 52750 | using namespace cv::dnn; |  | 52702 | using namespace cv::dnn;
| 52751 |  |  | 52703 |
| 52752 |  |  | 52704 |
| 52753 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52705 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52754 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52706 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52755 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52707 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52756 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52708 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52757 | PyObject* pyobj_polygonThreshold = NULL; |  | 52709 | PyObject* pyobj_polygonThreshold = NULL;
| 52758 | float polygonThreshold=0.f; |  | 52710 | float polygonThreshold=0.f;
| 52759 | TextDetectionModel_DB retval; |  | 52711 | TextDetectionModel_DB retval;
| 52760 |  |  | 52712 |
| 52761 | const char* keywords[] = { "polygonThreshold", NULL }; |  | 52713 | const char* keywords[] = { "polygonThreshold", NULL };
| 52762 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setPolygonThreshold", (char**)keywords, &pyobj_polygonThreshold) && |  | 52714 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setPolygonThreshold", (char**)keywords, &pyobj_polygonThreshold) &&
| 52763 | pyopencv_to_safe(pyobj_polygonThreshold, polygonThreshold, ArgInfo("polygonThreshold", 0)) ) |  | 52715 | pyopencv_to_safe(pyobj_polygonThreshold, polygonThreshold, ArgInfo("polygonThreshold", 0)) )
| 52764 | { |  | 52716 | {
| 52765 | ERRWRAP2(retval = _self_->setPolygonThreshold(polygonThreshold)); |  | 52717 | ERRWRAP2(retval = _self_->setPolygonThreshold(polygonThreshold));
| 52766 | return pyopencv_from(retval); |  | 52718 | return pyopencv_from(retval);
| 52767 | } |  | 52719 | }
| 52768 |  |  | 52720 |
| 52769 | return NULL; |  | 52721 | return NULL;
| 52770 | } |  | 52722 | }
| 52771 |  |  | 52723 |
| 52772 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setUnclipRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52724 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setUnclipRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 52773 | { |  | 52725 | {
| 52774 | using namespace cv::dnn; |  | 52726 | using namespace cv::dnn;
| 52775 |  |  | 52727 |
| 52776 |  |  | 52728 |
| 52777 | cv::dnn::TextDetectionModel_DB * self1 = 0; |  | 52729 | cv::dnn::TextDetectionModel_DB * self1 = 0;
| 52778 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1)) |  | 52730 | if (!pyopencv_dnn_TextDetectionModel_DB_getp(self, self1))
| 52779 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)"); |  | 52731 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_DB' or its derivative)");
| 52780 | cv::dnn::TextDetectionModel_DB* _self_ = (self1); |  | 52732 | cv::dnn::TextDetectionModel_DB* _self_ = (self1);
| 52781 | PyObject* pyobj_unclipRatio = NULL; |  | 52733 | PyObject* pyobj_unclipRatio = NULL;
| 52782 | double unclipRatio=0; |  | 52734 | double unclipRatio=0;
| 52783 | TextDetectionModel_DB retval; |  | 52735 | TextDetectionModel_DB retval;
| 52784 |  |  | 52736 |
| 52785 | const char* keywords[] = { "unclipRatio", NULL }; |  | 52737 | const char* keywords[] = { "unclipRatio", NULL };
| 52786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setUnclipRatio", (char**)keywords, &pyobj_unclipRatio) && |  | 52738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_DB.setUnclipRatio", (char**)keywords, &pyobj_unclipRatio) &&
| 52787 | pyopencv_to_safe(pyobj_unclipRatio, unclipRatio, ArgInfo("unclipRatio", 0)) ) |  | 52739 | pyopencv_to_safe(pyobj_unclipRatio, unclipRatio, ArgInfo("unclipRatio", 0)) )
| 52788 | { |  | 52740 | {
| 52789 | ERRWRAP2(retval = _self_->setUnclipRatio(unclipRatio)); |  | 52741 | ERRWRAP2(retval = _self_->setUnclipRatio(unclipRatio));
| 52790 | return pyopencv_from(retval); |  | 52742 | return pyopencv_from(retval);
| 52791 | } |  | 52743 | }
| 52792 |  |  | 52744 |
| 52793 | return NULL; |  | 52745 | return NULL;
| 52794 | } |  | 52746 | }
| 52795 |  |  | 52747 |
| 52796 |  |  | 52748 |
| 52797 |  |  | 52749 |
| 52798 | // Tables (dnn_TextDetectionModel_DB) |  | 52750 | // Tables (dnn_TextDetectionModel_DB)
| 52799 |  |  | 52751 |
| 52800 | static PyGetSetDef pyopencv_dnn_TextDetectionModel_DB_getseters[] = |  | 52752 | static PyGetSetDef pyopencv_dnn_TextDetectionModel_DB_getseters[] =
| 52801 | { |  | 52753 | {
| 52802 | {NULL} /* Sentinel */ |  | 52754 | {NULL} /* Sentinel */
| 52803 | }; |  | 52755 | };
| 52804 |  |  | 52756 |
| 52805 | static PyMethodDef pyopencv_dnn_TextDetectionModel_DB_methods[] = |  | 52757 | static PyMethodDef pyopencv_dnn_TextDetectionModel_DB_methods[] =
| 52806 | { |  | 52758 | {
| 52807 | {"getBinaryThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getBinaryThreshold, 0), "getBinaryThreshold() -> retval\n."}, |  | 52759 | {"getBinaryThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getBinaryThreshold, 0), "getBinaryThreshold() -> retval\n."},
| 52808 | {"getMaxCandidates", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getMaxCandidates, 0), "getMaxCandidates() -> retval\n."}, |  | 52760 | {"getMaxCandidates", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getMaxCandidates, 0), "getMaxCandidates() -> retval\n."},
| 52809 | {"getPolygonThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getPolygonThreshold, 0), "getPolygonThreshold() -> retval\n."}, |  | 52761 | {"getPolygonThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getPolygonThreshold, 0), "getPolygonThreshold() -> retval\n."},
| 52810 | {"getUnclipRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getUnclipRatio, 0), "getUnclipRatio() -> retval\n."}, |  | 52762 | {"getUnclipRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_getUnclipRatio, 0), "getUnclipRatio() -> retval\n."},
| 52811 | {"setBinaryThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setBinaryThreshold, 0), "setBinaryThreshold(binaryThreshold) -> retval\n."}, |  | 52763 | {"setBinaryThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setBinaryThreshold, 0), "setBinaryThreshold(binaryThreshold) -> retval\n."},
| 52812 | {"setMaxCandidates", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setMaxCandidates, 0), "setMaxCandidates(maxCandidates) -> retval\n."}, |  | 52764 | {"setMaxCandidates", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setMaxCandidates, 0), "setMaxCandidates(maxCandidates) -> retval\n."},
| 52813 | {"setPolygonThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setPolygonThreshold, 0), "setPolygonThreshold(polygonThreshold) -> retval\n."}, |  | 52765 | {"setPolygonThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setPolygonThreshold, 0), "setPolygonThreshold(polygonThreshold) -> retval\n."},
| 52814 | {"setUnclipRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setUnclipRatio, 0), "setUnclipRatio(unclipRatio) -> retval\n."}, |  | 52766 | {"setUnclipRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_DB_setUnclipRatio, 0), "setUnclipRatio(unclipRatio) -> retval\n."},
| 52815 |  |  | 52767 |
| 52816 | {NULL, NULL} |  | 52768 | {NULL, NULL}
| 52817 | }; |  | 52769 | };
| 52818 |  |  | 52770 |
| 52819 | // Converter (dnn_TextDetectionModel_DB) |  | 52771 | // Converter (dnn_TextDetectionModel_DB)
| 52820 |  |  | 52772 |
| 52821 | template<> |  | 52773 | template<>
| 52822 | struct PyOpenCV_Converter< cv::dnn::TextDetectionModel_DB > |  | 52774 | struct PyOpenCV_Converter< cv::dnn::TextDetectionModel_DB >
| 52823 | { |  | 52775 | {
| 52824 | static PyObject* from(const cv::dnn::TextDetectionModel_DB& r) |  | 52776 | static PyObject* from(const cv::dnn::TextDetectionModel_DB& r)
| 52825 | { |  | 52777 | {
| 52826 | return pyopencv_dnn_TextDetectionModel_DB_Instance(r); |  | 52778 | return pyopencv_dnn_TextDetectionModel_DB_Instance(r);
| 52827 | } |  | 52779 | }
| 52828 | static bool to(PyObject* src, cv::dnn::TextDetectionModel_DB& dst, const ArgInfo& info) |  | 52780 | static bool to(PyObject* src, cv::dnn::TextDetectionModel_DB& dst, const ArgInfo& info)
| 52829 | { |  | 52781 | {
| 52830 | if(!src || src == Py_None) |  | 52782 | if(!src || src == Py_None)
| 52831 | return true; |  | 52783 | return true;
| 52832 | cv::dnn::TextDetectionModel_DB * dst_; |  | 52784 | cv::dnn::TextDetectionModel_DB * dst_;
| 52833 | if (pyopencv_dnn_TextDetectionModel_DB_getp(src, dst_)) |  | 52785 | if (pyopencv_dnn_TextDetectionModel_DB_getp(src, dst_))
| 52834 | { |  | 52786 | {
| 52835 | dst = *dst_; |  | 52787 | dst = *dst_;
| 52836 | return true; |  | 52788 | return true;
| 52837 | } |  | 52789 | }
| 52838 |  |  | 52790 |
| 52839 | failmsg("Expected cv::dnn::TextDetectionModel_DB for argument '%s'", info.name); |  | 52791 | failmsg("Expected cv::dnn::TextDetectionModel_DB for argument '%s'", info.name);
| 52840 | return false; |  | 52792 | return false;
| 52841 | } |  | 52793 | }
| 52842 | }; |  | 52794 | };
| 52843 |  |  | 52795 |
| 52844 | //================================================================================ |  | 52796 | //================================================================================
| 52845 | // dnn_TextDetectionModel_EAST (Generic) |  | 52797 | // dnn_TextDetectionModel_EAST (Generic)
| 52846 | //================================================================================ |  | 52798 | //================================================================================
| 52847 |  |  | 52799 |
| 52848 | // GetSet (dnn_TextDetectionModel_EAST) |  | 52800 | // GetSet (dnn_TextDetectionModel_EAST)
| 52849 |  |  | 52801 |
| 52850 |  |  | 52802 |
| 52851 |  |  | 52803 |
| 52852 | // Methods (dnn_TextDetectionModel_EAST) |  | 52804 | // Methods (dnn_TextDetectionModel_EAST)
| 52853 |  |  | 52805 |
| 52854 | static int pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_TextDetectionModel_EAST(pyopencv_dnn_TextDetectionModel_EAST_t* self, PyObject* py_args, PyObject* kw) |  | 52806 | static int pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_TextDetectionModel_EAST(pyopencv_dnn_TextDetectionModel_EAST_t* self, PyObject* py_args, PyObject* kw)
| 52855 | { |  | 52807 | {
| 52856 | using namespace cv::dnn; |  | 52808 | using namespace cv::dnn;
| 52857 |  |  | 52809 |
| 52858 | pyPrepareArgumentConversionErrorsStorage(2); |  | 52810 | pyPrepareArgumentConversionErrorsStorage(2);
| 52859 |  |  | 52811 |
| 52860 | { |  | 52812 | {
| 52861 | PyObject* pyobj_network = NULL; |  | 52813 | PyObject* pyobj_network = NULL;
| 52862 | Net network; |  | 52814 | Net network;
| 52863 |  |  | 52815 |
| 52864 | const char* keywords[] = { "network", NULL }; |  | 52816 | const char* keywords[] = { "network", NULL };
| 52865 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TextDetectionModel_EAST", (char**)keywords, &pyobj_network) && |  | 52817 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TextDetectionModel_EAST", (char**)keywords, &pyobj_network) &&
| 52866 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 52818 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 52867 | { |  | 52819 | {
| 52868 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_EAST(network)); |  | 52820 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_EAST(network));
| 52869 | return 0; |  | 52821 | return 0;
| 52870 | } |  | 52822 | }
| 52871 |  |  | 52823 |
| 52872 |  |  | 52824 |
| 52873 | pyPopulateArgumentConversionErrors(); |  | 52825 | pyPopulateArgumentConversionErrors();
| 52874 | } |  | 52826 | }
| 52875 |  |  | 52827 |
| 52876 |  |  | 52828 |
| 52877 | { |  | 52829 | {
| 52878 | PyObject* pyobj_model = NULL; |  | 52830 | PyObject* pyobj_model = NULL;
| 52879 | std::string model; |  | 52831 | std::string model;
| 52880 | PyObject* pyobj_config = NULL; |  | 52832 | PyObject* pyobj_config = NULL;
| 52881 | std::string config=""; |  | 52833 | std::string config="";
| 52882 |  |  | 52834 |
| 52883 | const char* keywords[] = { "model", "config", NULL }; |  | 52835 | const char* keywords[] = { "model", "config", NULL };
| 52884 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:TextDetectionModel_EAST", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 52836 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:TextDetectionModel_EAST", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 52885 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 52837 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 52886 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 52838 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 52887 | { |  | 52839 | {
| 52888 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_EAST(model, config)); |  | 52840 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextDetectionModel_EAST(model, config));
| 52889 | return 0; |  | 52841 | return 0;
| 52890 | } |  | 52842 | }
| 52891 |  |  | 52843 |
| 52892 |  |  | 52844 |
| 52893 | pyPopulateArgumentConversionErrors(); |  | 52845 | pyPopulateArgumentConversionErrors();
| 52894 | } |  | 52846 | }
| 52895 | pyRaiseCVOverloadException("TextDetectionModel_EAST"); |  | 52847 | pyRaiseCVOverloadException("TextDetectionModel_EAST");
| 52896 |  |  | 52848 |
| 52897 | return -1; |  | 52849 | return -1;
| 52898 | } |  | 52850 | }
| 52899 |  |  | 52851 |
| 52900 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getConfidenceThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52852 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getConfidenceThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52901 | { |  | 52853 | {
| 52902 | using namespace cv::dnn; |  | 52854 | using namespace cv::dnn;
| 52903 |  |  | 52855 |
| 52904 |  |  | 52856 |
| 52905 | cv::dnn::TextDetectionModel_EAST * self1 = 0; |  | 52857 | cv::dnn::TextDetectionModel_EAST * self1 = 0;
| 52906 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1)) |  | 52858 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1))
| 52907 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)"); |  | 52859 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)");
| 52908 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1); |  | 52860 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1);
| 52909 | float retval; |  | 52861 | float retval;
| 52910 |  |  | 52862 |
| 52911 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 52863 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 52912 | { |  | 52864 | {
| 52913 | ERRWRAP2(retval = _self_->getConfidenceThreshold()); |  | 52865 | ERRWRAP2(retval = _self_->getConfidenceThreshold());
| 52914 | return pyopencv_from(retval); |  | 52866 | return pyopencv_from(retval);
| 52915 | } |  | 52867 | }
| 52916 |  |  | 52868 |
| 52917 | return NULL; |  | 52869 | return NULL;
| 52918 | } |  | 52870 | }
| 52919 |  |  | 52871 |
| 52920 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52872 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52921 | { |  | 52873 | {
| 52922 | using namespace cv::dnn; |  | 52874 | using namespace cv::dnn;
| 52923 |  |  | 52875 |
| 52924 |  |  | 52876 |
| 52925 | cv::dnn::TextDetectionModel_EAST * self1 = 0; |  | 52877 | cv::dnn::TextDetectionModel_EAST * self1 = 0;
| 52926 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1)) |  | 52878 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1))
| 52927 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)"); |  | 52879 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)");
| 52928 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1); |  | 52880 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1);
| 52929 | float retval; |  | 52881 | float retval;
| 52930 |  |  | 52882 |
| 52931 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 52883 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 52932 | { |  | 52884 | {
| 52933 | ERRWRAP2(retval = _self_->getNMSThreshold()); |  | 52885 | ERRWRAP2(retval = _self_->getNMSThreshold());
| 52934 | return pyopencv_from(retval); |  | 52886 | return pyopencv_from(retval);
| 52935 | } |  | 52887 | }
| 52936 |  |  | 52888 |
| 52937 | return NULL; |  | 52889 | return NULL;
| 52938 | } |  | 52890 | }
| 52939 |  |  | 52891 |
| 52940 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setConfidenceThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52892 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setConfidenceThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52941 | { |  | 52893 | {
| 52942 | using namespace cv::dnn; |  | 52894 | using namespace cv::dnn;
| 52943 |  |  | 52895 |
| 52944 |  |  | 52896 |
| 52945 | cv::dnn::TextDetectionModel_EAST * self1 = 0; |  | 52897 | cv::dnn::TextDetectionModel_EAST * self1 = 0;
| 52946 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1)) |  | 52898 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1))
| 52947 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)"); |  | 52899 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)");
| 52948 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1); |  | 52900 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1);
| 52949 | PyObject* pyobj_confThreshold = NULL; |  | 52901 | PyObject* pyobj_confThreshold = NULL;
| 52950 | float confThreshold=0.f; |  | 52902 | float confThreshold=0.f;
| 52951 | TextDetectionModel_EAST retval; |  | 52903 | TextDetectionModel_EAST retval;
| 52952 |  |  | 52904 |
| 52953 | const char* keywords[] = { "confThreshold", NULL }; |  | 52905 | const char* keywords[] = { "confThreshold", NULL };
| 52954 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_EAST.setConfidenceThreshold", (char**)keywords, &pyobj_confThreshold) && |  | 52906 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_EAST.setConfidenceThreshold", (char**)keywords, &pyobj_confThreshold) &&
| 52955 | pyopencv_to_safe(pyobj_confThreshold, confThreshold, ArgInfo("confThreshold", 0)) ) |  | 52907 | pyopencv_to_safe(pyobj_confThreshold, confThreshold, ArgInfo("confThreshold", 0)) )
| 52956 | { |  | 52908 | {
| 52957 | ERRWRAP2(retval = _self_->setConfidenceThreshold(confThreshold)); |  | 52909 | ERRWRAP2(retval = _self_->setConfidenceThreshold(confThreshold));
| 52958 | return pyopencv_from(retval); |  | 52910 | return pyopencv_from(retval);
| 52959 | } |  | 52911 | }
| 52960 |  |  | 52912 |
| 52961 | return NULL; |  | 52913 | return NULL;
| 52962 | } |  | 52914 | }
| 52963 |  |  | 52915 |
| 52964 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 52916 | static PyObject* pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setNMSThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 52965 | { |  | 52917 | {
| 52966 | using namespace cv::dnn; |  | 52918 | using namespace cv::dnn;
| 52967 |  |  | 52919 |
| 52968 |  |  | 52920 |
| 52969 | cv::dnn::TextDetectionModel_EAST * self1 = 0; |  | 52921 | cv::dnn::TextDetectionModel_EAST * self1 = 0;
| 52970 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1)) |  | 52922 | if (!pyopencv_dnn_TextDetectionModel_EAST_getp(self, self1))
| 52971 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)"); |  | 52923 | return failmsgp("Incorrect type of self (must be 'dnn_TextDetectionModel_EAST' or its derivative)");
| 52972 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1); |  | 52924 | cv::dnn::TextDetectionModel_EAST* _self_ = (self1);
| 52973 | PyObject* pyobj_nmsThreshold = NULL; |  | 52925 | PyObject* pyobj_nmsThreshold = NULL;
| 52974 | float nmsThreshold=0.f; |  | 52926 | float nmsThreshold=0.f;
| 52975 | TextDetectionModel_EAST retval; |  | 52927 | TextDetectionModel_EAST retval;
| 52976 |  |  | 52928 |
| 52977 | const char* keywords[] = { "nmsThreshold", NULL }; |  | 52929 | const char* keywords[] = { "nmsThreshold", NULL };
| 52978 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_EAST.setNMSThreshold", (char**)keywords, &pyobj_nmsThreshold) && |  | 52930 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextDetectionModel_EAST.setNMSThreshold", (char**)keywords, &pyobj_nmsThreshold) &&
| 52979 | pyopencv_to_safe(pyobj_nmsThreshold, nmsThreshold, ArgInfo("nmsThreshold", 0)) ) |  | 52931 | pyopencv_to_safe(pyobj_nmsThreshold, nmsThreshold, ArgInfo("nmsThreshold", 0)) )
| 52980 | { |  | 52932 | {
| 52981 | ERRWRAP2(retval = _self_->setNMSThreshold(nmsThreshold)); |  | 52933 | ERRWRAP2(retval = _self_->setNMSThreshold(nmsThreshold));
| 52982 | return pyopencv_from(retval); |  | 52934 | return pyopencv_from(retval);
| 52983 | } |  | 52935 | }
| 52984 |  |  | 52936 |
| 52985 | return NULL; |  | 52937 | return NULL;
| 52986 | } |  | 52938 | }
| 52987 |  |  | 52939 |
| 52988 |  |  | 52940 |
| 52989 |  |  | 52941 |
| 52990 | // Tables (dnn_TextDetectionModel_EAST) |  | 52942 | // Tables (dnn_TextDetectionModel_EAST)
| 52991 |  |  | 52943 |
| 52992 | static PyGetSetDef pyopencv_dnn_TextDetectionModel_EAST_getseters[] = |  | 52944 | static PyGetSetDef pyopencv_dnn_TextDetectionModel_EAST_getseters[] =
| 52993 | { |  | 52945 | {
| 52994 | {NULL} /* Sentinel */ |  | 52946 | {NULL} /* Sentinel */
| 52995 | }; |  | 52947 | };
| 52996 |  |  | 52948 |
| 52997 | static PyMethodDef pyopencv_dnn_TextDetectionModel_EAST_methods[] = |  | 52949 | static PyMethodDef pyopencv_dnn_TextDetectionModel_EAST_methods[] =
| 52998 | { |  | 52950 | {
| 52999 | {"getConfidenceThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getConfidenceThreshold, 0), "getConfidenceThreshold() -> retval\n. * @brief Get the detection confidence threshold"}, |  | 52951 | {"getConfidenceThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getConfidenceThreshold, 0), "getConfidenceThreshold() -> retval\n. * @brief Get the detection confidence threshold"},
| 53000 | {"getNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getNMSThreshold, 0), "getNMSThreshold() -> retval\n. * @brief Get the detection confidence threshold"}, |  | 52952 | {"getNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_getNMSThreshold, 0), "getNMSThreshold() -> retval\n. * @brief Get the detection confidence threshold"},
| 53001 | {"setConfidenceThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setConfidenceThreshold, 0), "setConfidenceThreshold(confThreshold) -> retval\n. * @brief Set the detection confidence threshold\n. * @param[in] confThreshold A threshold used to filter boxes by confidences"}, |  | 52953 | {"setConfidenceThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setConfidenceThreshold, 0), "setConfidenceThreshold(confThreshold) -> retval\n. * @brief Set the detection confidence threshold\n. * @param[in] confThreshold A threshold used to filter boxes by confidences"},
| 53002 | {"setNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setNMSThreshold, 0), "setNMSThreshold(nmsThreshold) -> retval\n. * @brief Set the detection NMS filter threshold\n. * @param[in] nmsThreshold A threshold used in non maximum suppression"}, |  | 52954 | {"setNMSThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextDetectionModel_EAST_setNMSThreshold, 0), "setNMSThreshold(nmsThreshold) -> retval\n. * @brief Set the detection NMS filter threshold\n. * @param[in] nmsThreshold A threshold used in non maximum suppression"},
| 53003 |  |  | 52955 |
| 53004 | {NULL, NULL} |  | 52956 | {NULL, NULL}
| 53005 | }; |  | 52957 | };
| 53006 |  |  | 52958 |
| 53007 | // Converter (dnn_TextDetectionModel_EAST) |  | 52959 | // Converter (dnn_TextDetectionModel_EAST)
| 53008 |  |  | 52960 |
| 53009 | template<> |  | 52961 | template<>
| 53010 | struct PyOpenCV_Converter< cv::dnn::TextDetectionModel_EAST > |  | 52962 | struct PyOpenCV_Converter< cv::dnn::TextDetectionModel_EAST >
| 53011 | { |  | 52963 | {
| 53012 | static PyObject* from(const cv::dnn::TextDetectionModel_EAST& r) |  | 52964 | static PyObject* from(const cv::dnn::TextDetectionModel_EAST& r)
| 53013 | { |  | 52965 | {
| 53014 | return pyopencv_dnn_TextDetectionModel_EAST_Instance(r); |  | 52966 | return pyopencv_dnn_TextDetectionModel_EAST_Instance(r);
| 53015 | } |  | 52967 | }
| 53016 | static bool to(PyObject* src, cv::dnn::TextDetectionModel_EAST& dst, const ArgInfo& info) |  | 52968 | static bool to(PyObject* src, cv::dnn::TextDetectionModel_EAST& dst, const ArgInfo& info)
| 53017 | { |  | 52969 | {
| 53018 | if(!src || src == Py_None) |  | 52970 | if(!src || src == Py_None)
| 53019 | return true; |  | 52971 | return true;
| 53020 | cv::dnn::TextDetectionModel_EAST * dst_; |  | 52972 | cv::dnn::TextDetectionModel_EAST * dst_;
| 53021 | if (pyopencv_dnn_TextDetectionModel_EAST_getp(src, dst_)) |  | 52973 | if (pyopencv_dnn_TextDetectionModel_EAST_getp(src, dst_))
| 53022 | { |  | 52974 | {
| 53023 | dst = *dst_; |  | 52975 | dst = *dst_;
| 53024 | return true; |  | 52976 | return true;
| 53025 | } |  | 52977 | }
| 53026 |  |  | 52978 |
| 53027 | failmsg("Expected cv::dnn::TextDetectionModel_EAST for argument '%s'", info.name); |  | 52979 | failmsg("Expected cv::dnn::TextDetectionModel_EAST for argument '%s'", info.name);
| 53028 | return false; |  | 52980 | return false;
| 53029 | } |  | 52981 | }
| 53030 | }; |  | 52982 | };
| 53031 |  |  | 52983 |
| 53032 | //================================================================================ |  | 52984 | //================================================================================
| 53033 | // dnn_TextRecognitionModel (Generic) |  | 52985 | // dnn_TextRecognitionModel (Generic)
| 53034 | //================================================================================ |  | 52986 | //================================================================================
| 53035 |  |  | 52987 |
| 53036 | // GetSet (dnn_TextRecognitionModel) |  | 52988 | // GetSet (dnn_TextRecognitionModel)
| 53037 |  |  | 52989 |
| 53038 |  |  | 52990 |
| 53039 |  |  | 52991 |
| 53040 | // Methods (dnn_TextRecognitionModel) |  | 52992 | // Methods (dnn_TextRecognitionModel)
| 53041 |  |  | 52993 |
| 53042 | static int pyopencv_cv_dnn_dnn_TextRecognitionModel_TextRecognitionModel(pyopencv_dnn_TextRecognitionModel_t* self, PyObject* py_args, PyObject* kw) |  | 52994 | static int pyopencv_cv_dnn_dnn_TextRecognitionModel_TextRecognitionModel(pyopencv_dnn_TextRecognitionModel_t* self, PyObject* py_args, PyObject* kw)
| 53043 | { |  | 52995 | {
| 53044 | using namespace cv::dnn; |  | 52996 | using namespace cv::dnn;
| 53045 |  |  | 52997 |
| 53046 | pyPrepareArgumentConversionErrorsStorage(2); |  | 52998 | pyPrepareArgumentConversionErrorsStorage(2);
| 53047 |  |  | 52999 |
| 53048 | { |  | 53000 | {
| 53049 | PyObject* pyobj_network = NULL; |  | 53001 | PyObject* pyobj_network = NULL;
| 53050 | Net network; |  | 53002 | Net network;
| 53051 |  |  | 53003 |
| 53052 | const char* keywords[] = { "network", NULL }; |  | 53004 | const char* keywords[] = { "network", NULL };
| 53053 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TextRecognitionModel", (char**)keywords, &pyobj_network) && |  | 53005 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TextRecognitionModel", (char**)keywords, &pyobj_network) &&
| 53054 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) ) |  | 53006 | pyopencv_to_safe(pyobj_network, network, ArgInfo("network", 0)) )
| 53055 | { |  | 53007 | {
| 53056 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextRecognitionModel(network)); |  | 53008 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextRecognitionModel(network));
| 53057 | return 0; |  | 53009 | return 0;
| 53058 | } |  | 53010 | }
| 53059 |  |  | 53011 |
| 53060 |  |  | 53012 |
| 53061 | pyPopulateArgumentConversionErrors(); |  | 53013 | pyPopulateArgumentConversionErrors();
| 53062 | } |  | 53014 | }
| 53063 |  |  | 53015 |
| 53064 |  |  | 53016 |
| 53065 | { |  | 53017 | {
| 53066 | PyObject* pyobj_model = NULL; |  | 53018 | PyObject* pyobj_model = NULL;
| 53067 | std::string model; |  | 53019 | std::string model;
| 53068 | PyObject* pyobj_config = NULL; |  | 53020 | PyObject* pyobj_config = NULL;
| 53069 | std::string config=""; |  | 53021 | std::string config="";
| 53070 |  |  | 53022 |
| 53071 | const char* keywords[] = { "model", "config", NULL }; |  | 53023 | const char* keywords[] = { "model", "config", NULL };
| 53072 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:TextRecognitionModel", (char**)keywords, &pyobj_model, &pyobj_config) && |  | 53024 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:TextRecognitionModel", (char**)keywords, &pyobj_model, &pyobj_config) &&
| 53073 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) && |  | 53025 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 4)) &&
| 53074 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) ) |  | 53026 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 4)) )
| 53075 | { |  | 53027 | {
| 53076 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextRecognitionModel(model, config)); |  | 53028 | if(self) ERRWRAP2(new (&(self->v)) cv::dnn::TextRecognitionModel(model, config));
| 53077 | return 0; |  | 53029 | return 0;
| 53078 | } |  | 53030 | }
| 53079 |  |  | 53031 |
| 53080 |  |  | 53032 |
| 53081 | pyPopulateArgumentConversionErrors(); |  | 53033 | pyPopulateArgumentConversionErrors();
| 53082 | } |  | 53034 | }
| 53083 | pyRaiseCVOverloadException("TextRecognitionModel"); |  | 53035 | pyRaiseCVOverloadException("TextRecognitionModel");
| 53084 |  |  | 53036 |
| 53085 | return -1; |  | 53037 | return -1;
| 53086 | } |  | 53038 | }
| 53087 |  |  | 53039 |
| 53088 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_getDecodeType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53040 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_getDecodeType(PyObject* self, PyObject* py_args, PyObject* kw)
| 53089 | { |  | 53041 | {
| 53090 | using namespace cv::dnn; |  | 53042 | using namespace cv::dnn;
| 53091 |  |  | 53043 |
| 53092 |  |  | 53044 |
| 53093 | cv::dnn::TextRecognitionModel * self1 = 0; |  | 53045 | cv::dnn::TextRecognitionModel * self1 = 0;
| 53094 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1)) |  | 53046 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1))
| 53095 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)"); |  | 53047 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)");
| 53096 | cv::dnn::TextRecognitionModel* _self_ = (self1); |  | 53048 | cv::dnn::TextRecognitionModel* _self_ = (self1);
| 53097 | std::string retval; |  | 53049 | std::string retval;
| 53098 |  |  | 53050 |
| 53099 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 53051 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 53100 | { |  | 53052 | {
| 53101 | ERRWRAP2(retval = _self_->getDecodeType()); |  | 53053 | ERRWRAP2(retval = _self_->getDecodeType());
| 53102 | return pyopencv_from(retval); |  | 53054 | return pyopencv_from(retval);
| 53103 | } |  | 53055 | }
| 53104 |  |  | 53056 |
| 53105 | return NULL; |  | 53057 | return NULL;
| 53106 | } |  | 53058 | }
| 53107 |  |  | 53059 |
| 53108 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_getVocabulary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53060 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_getVocabulary(PyObject* self, PyObject* py_args, PyObject* kw)
| 53109 | { |  | 53061 | {
| 53110 | using namespace cv::dnn; |  | 53062 | using namespace cv::dnn;
| 53111 |  |  | 53063 |
| 53112 |  |  | 53064 |
| 53113 | cv::dnn::TextRecognitionModel * self1 = 0; |  | 53065 | cv::dnn::TextRecognitionModel * self1 = 0;
| 53114 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1)) |  | 53066 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1))
| 53115 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)"); |  | 53067 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)");
| 53116 | cv::dnn::TextRecognitionModel* _self_ = (self1); |  | 53068 | cv::dnn::TextRecognitionModel* _self_ = (self1);
| 53117 | std::vector<std::string> retval; |  | 53069 | std::vector<std::string> retval;
| 53118 |  |  | 53070 |
| 53119 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 53071 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 53120 | { |  | 53072 | {
| 53121 | ERRWRAP2(retval = _self_->getVocabulary()); |  | 53073 | ERRWRAP2(retval = _self_->getVocabulary());
| 53122 | return pyopencv_from(retval); |  | 53074 | return pyopencv_from(retval);
| 53123 | } |  | 53075 | }
| 53124 |  |  | 53076 |
| 53125 | return NULL; |  | 53077 | return NULL;
| 53126 | } |  | 53078 | }
| 53127 |  |  | 53079 |
| 53128 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_recognize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53080 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_recognize(PyObject* self, PyObject* py_args, PyObject* kw)
| 53129 | { |  | 53081 | {
| 53130 | using namespace cv::dnn; |  | 53082 | using namespace cv::dnn;
| 53131 |  |  | 53083 |
| 53132 |  |  | 53084 |
| 53133 | cv::dnn::TextRecognitionModel * self1 = 0; |  | 53085 | cv::dnn::TextRecognitionModel * self1 = 0;
| 53134 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1)) |  | 53086 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1))
| 53135 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)"); |  | 53087 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)");
| 53136 | cv::dnn::TextRecognitionModel* _self_ = (self1); |  | 53088 | cv::dnn::TextRecognitionModel* _self_ = (self1);
| 53137 | pyPrepareArgumentConversionErrorsStorage(4); |  | 53089 | pyPrepareArgumentConversionErrorsStorage(4);
| 53138 |  |  | 53090 |
| 53139 | { |  | 53091 | {
| 53140 | PyObject* pyobj_frame = NULL; |  | 53092 | PyObject* pyobj_frame = NULL;
| 53141 | Mat frame; |  | 53093 | Mat frame;
| 53142 | std::string retval; |  | 53094 | std::string retval;
| 53143 |  |  | 53095 |
| 53144 | const char* keywords[] = { "frame", NULL }; |  | 53096 | const char* keywords[] = { "frame", NULL };
| 53145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame) && |  | 53097 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame) &&
| 53146 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 53098 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 53147 | { |  | 53099 | {
| 53148 | ERRWRAP2(retval = _self_->recognize(frame)); |  | 53100 | ERRWRAP2(retval = _self_->recognize(frame));
| 53149 | return pyopencv_from(retval); |  | 53101 | return pyopencv_from(retval);
| 53150 | } |  | 53102 | }
| 53151 |  |  | 53103 |
| 53152 |  |  | 53104 |
| 53153 | pyPopulateArgumentConversionErrors(); |  | 53105 | pyPopulateArgumentConversionErrors();
| 53154 | } |  | 53106 | }
| 53155 |  |  | 53107 |
| 53156 |  |  | 53108 |
| 53157 | { |  | 53109 | {
| 53158 | PyObject* pyobj_frame = NULL; |  | 53110 | PyObject* pyobj_frame = NULL;
| 53159 | Mat frame; |  | 53111 | Mat frame;
| 53160 | PyObject* pyobj_roiRects = NULL; |  | 53112 | PyObject* pyobj_roiRects = NULL;
| 53161 | vector_Mat roiRects; |  | 53113 | vector_Mat roiRects;
| 53162 | vector_string results; |  | 53114 | vector_string results;
| 53163 |  |  | 53115 |
| 53164 | const char* keywords[] = { "frame", "roiRects", NULL }; |  | 53116 | const char* keywords[] = { "frame", "roiRects", NULL };
| 53165 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame, &pyobj_roiRects) && |  | 53117 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame, &pyobj_roiRects) &&
| 53166 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 53118 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 53167 | pyopencv_to_safe(pyobj_roiRects, roiRects, ArgInfo("roiRects", 0)) ) |  | 53119 | pyopencv_to_safe(pyobj_roiRects, roiRects, ArgInfo("roiRects", 0)) )
| 53168 | { |  | 53120 | {
| 53169 | ERRWRAP2(_self_->recognize(frame, roiRects, results)); |  | 53121 | ERRWRAP2(_self_->recognize(frame, roiRects, results));
| 53170 | return pyopencv_from(results); |  | 53122 | return pyopencv_from(results);
| 53171 | } |  | 53123 | }
| 53172 |  |  | 53124 |
| 53173 |  |  | 53125 |
| 53174 | pyPopulateArgumentConversionErrors(); |  | 53126 | pyPopulateArgumentConversionErrors();
| 53175 | } |  | 53127 | }
| 53176 |  |  | 53128 |
| 53177 |  |  | 53129 |
| 53178 | { |  | 53130 | {
| 53179 | PyObject* pyobj_frame = NULL; |  | 53131 | PyObject* pyobj_frame = NULL;
| 53180 | UMat frame; |  | 53132 | UMat frame;
| 53181 | std::string retval; |  | 53133 | std::string retval;
| 53182 |  |  | 53134 |
| 53183 | const char* keywords[] = { "frame", NULL }; |  | 53135 | const char* keywords[] = { "frame", NULL };
| 53184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame) && |  | 53136 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame) &&
| 53185 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) ) |  | 53137 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) )
| 53186 | { |  | 53138 | {
| 53187 | ERRWRAP2(retval = _self_->recognize(frame)); |  | 53139 | ERRWRAP2(retval = _self_->recognize(frame));
| 53188 | return pyopencv_from(retval); |  | 53140 | return pyopencv_from(retval);
| 53189 | } |  | 53141 | }
| 53190 |  |  | 53142 |
| 53191 |  |  | 53143 |
| 53192 | pyPopulateArgumentConversionErrors(); |  | 53144 | pyPopulateArgumentConversionErrors();
| 53193 | } |  | 53145 | }
| 53194 |  |  | 53146 |
| 53195 |  |  | 53147 |
| 53196 | { |  | 53148 | {
| 53197 | PyObject* pyobj_frame = NULL; |  | 53149 | PyObject* pyobj_frame = NULL;
| 53198 | UMat frame; |  | 53150 | UMat frame;
| 53199 | PyObject* pyobj_roiRects = NULL; |  | 53151 | PyObject* pyobj_roiRects = NULL;
| 53200 | vector_UMat roiRects; |  | 53152 | vector_UMat roiRects;
| 53201 | vector_string results; |  | 53153 | vector_string results;
| 53202 |  |  | 53154 |
| 53203 | const char* keywords[] = { "frame", "roiRects", NULL }; |  | 53155 | const char* keywords[] = { "frame", "roiRects", NULL };
| 53204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame, &pyobj_roiRects) && |  | 53156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_TextRecognitionModel.recognize", (char**)keywords, &pyobj_frame, &pyobj_roiRects) &&
| 53205 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 53157 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 53206 | pyopencv_to_safe(pyobj_roiRects, roiRects, ArgInfo("roiRects", 0)) ) |  | 53158 | pyopencv_to_safe(pyobj_roiRects, roiRects, ArgInfo("roiRects", 0)) )
| 53207 | { |  | 53159 | {
| 53208 | ERRWRAP2(_self_->recognize(frame, roiRects, results)); |  | 53160 | ERRWRAP2(_self_->recognize(frame, roiRects, results));
| 53209 | return pyopencv_from(results); |  | 53161 | return pyopencv_from(results);
| 53210 | } |  | 53162 | }
| 53211 |  |  | 53163 |
| 53212 |  |  | 53164 |
| 53213 | pyPopulateArgumentConversionErrors(); |  | 53165 | pyPopulateArgumentConversionErrors();
| 53214 | } |  | 53166 | }
| 53215 | pyRaiseCVOverloadException("recognize"); |  | 53167 | pyRaiseCVOverloadException("recognize");
| 53216 |  |  | 53168 |
| 53217 | return NULL; |  | 53169 | return NULL;
| 53218 | } |  | 53170 | }
| 53219 |  |  | 53171 |
| 53220 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeOptsCTCPrefixBeamSearch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53172 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeOptsCTCPrefixBeamSearch(PyObject* self, PyObject* py_args, PyObject* kw)
| 53221 | { |  | 53173 | {
| 53222 | using namespace cv::dnn; |  | 53174 | using namespace cv::dnn;
| 53223 |  |  | 53175 |
| 53224 |  |  | 53176 |
| 53225 | cv::dnn::TextRecognitionModel * self1 = 0; |  | 53177 | cv::dnn::TextRecognitionModel * self1 = 0;
| 53226 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1)) |  | 53178 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1))
| 53227 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)"); |  | 53179 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)");
| 53228 | cv::dnn::TextRecognitionModel* _self_ = (self1); |  | 53180 | cv::dnn::TextRecognitionModel* _self_ = (self1);
| 53229 | PyObject* pyobj_beamSize = NULL; |  | 53181 | PyObject* pyobj_beamSize = NULL;
| 53230 | int beamSize=0; |  | 53182 | int beamSize=0;
| 53231 | PyObject* pyobj_vocPruneSize = NULL; |  | 53183 | PyObject* pyobj_vocPruneSize = NULL;
| 53232 | int vocPruneSize=0; |  | 53184 | int vocPruneSize=0;
| 53233 | TextRecognitionModel retval; |  | 53185 | TextRecognitionModel retval;
| 53234 |  |  | 53186 |
| 53235 | const char* keywords[] = { "beamSize", "vocPruneSize", NULL }; |  | 53187 | const char* keywords[] = { "beamSize", "vocPruneSize", NULL };
| 53236 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_TextRecognitionModel.setDecodeOptsCTCPrefixBeamSearch", (char**)keywords, &pyobj_beamSize, &pyobj_vocPruneSize) && |  | 53188 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_TextRecognitionModel.setDecodeOptsCTCPrefixBeamSearch", (char**)keywords, &pyobj_beamSize, &pyobj_vocPruneSize) &&
| 53237 | pyopencv_to_safe(pyobj_beamSize, beamSize, ArgInfo("beamSize", 0)) && |  | 53189 | pyopencv_to_safe(pyobj_beamSize, beamSize, ArgInfo("beamSize", 0)) &&
| 53238 | pyopencv_to_safe(pyobj_vocPruneSize, vocPruneSize, ArgInfo("vocPruneSize", 0)) ) |  | 53190 | pyopencv_to_safe(pyobj_vocPruneSize, vocPruneSize, ArgInfo("vocPruneSize", 0)) )
| 53239 | { |  | 53191 | {
| 53240 | ERRWRAP2(retval = _self_->setDecodeOptsCTCPrefixBeamSearch(beamSize, vocPruneSize)); |  | 53192 | ERRWRAP2(retval = _self_->setDecodeOptsCTCPrefixBeamSearch(beamSize, vocPruneSize));
| 53241 | return pyopencv_from(retval); |  | 53193 | return pyopencv_from(retval);
| 53242 | } |  | 53194 | }
| 53243 |  |  | 53195 |
| 53244 | return NULL; |  | 53196 | return NULL;
| 53245 | } |  | 53197 | }
| 53246 |  |  | 53198 |
| 53247 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53199 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeType(PyObject* self, PyObject* py_args, PyObject* kw)
| 53248 | { |  | 53200 | {
| 53249 | using namespace cv::dnn; |  | 53201 | using namespace cv::dnn;
| 53250 |  |  | 53202 |
| 53251 |  |  | 53203 |
| 53252 | cv::dnn::TextRecognitionModel * self1 = 0; |  | 53204 | cv::dnn::TextRecognitionModel * self1 = 0;
| 53253 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1)) |  | 53205 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1))
| 53254 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)"); |  | 53206 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)");
| 53255 | cv::dnn::TextRecognitionModel* _self_ = (self1); |  | 53207 | cv::dnn::TextRecognitionModel* _self_ = (self1);
| 53256 | PyObject* pyobj_decodeType = NULL; |  | 53208 | PyObject* pyobj_decodeType = NULL;
| 53257 | std::string decodeType; |  | 53209 | std::string decodeType;
| 53258 | TextRecognitionModel retval; |  | 53210 | TextRecognitionModel retval;
| 53259 |  |  | 53211 |
| 53260 | const char* keywords[] = { "decodeType", NULL }; |  | 53212 | const char* keywords[] = { "decodeType", NULL };
| 53261 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.setDecodeType", (char**)keywords, &pyobj_decodeType) && |  | 53213 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.setDecodeType", (char**)keywords, &pyobj_decodeType) &&
| 53262 | pyopencv_to_safe(pyobj_decodeType, decodeType, ArgInfo("decodeType", 0)) ) |  | 53214 | pyopencv_to_safe(pyobj_decodeType, decodeType, ArgInfo("decodeType", 0)) )
| 53263 | { |  | 53215 | {
| 53264 | ERRWRAP2(retval = _self_->setDecodeType(decodeType)); |  | 53216 | ERRWRAP2(retval = _self_->setDecodeType(decodeType));
| 53265 | return pyopencv_from(retval); |  | 53217 | return pyopencv_from(retval);
| 53266 | } |  | 53218 | }
| 53267 |  |  | 53219 |
| 53268 | return NULL; |  | 53220 | return NULL;
| 53269 | } |  | 53221 | }
| 53270 |  |  | 53222 |
| 53271 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_setVocabulary(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53223 | static PyObject* pyopencv_cv_dnn_dnn_TextRecognitionModel_setVocabulary(PyObject* self, PyObject* py_args, PyObject* kw)
| 53272 | { |  | 53224 | {
| 53273 | using namespace cv::dnn; |  | 53225 | using namespace cv::dnn;
| 53274 |  |  | 53226 |
| 53275 |  |  | 53227 |
| 53276 | cv::dnn::TextRecognitionModel * self1 = 0; |  | 53228 | cv::dnn::TextRecognitionModel * self1 = 0;
| 53277 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1)) |  | 53229 | if (!pyopencv_dnn_TextRecognitionModel_getp(self, self1))
| 53278 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)"); |  | 53230 | return failmsgp("Incorrect type of self (must be 'dnn_TextRecognitionModel' or its derivative)");
| 53279 | cv::dnn::TextRecognitionModel* _self_ = (self1); |  | 53231 | cv::dnn::TextRecognitionModel* _self_ = (self1);
| 53280 | PyObject* pyobj_vocabulary = NULL; |  | 53232 | PyObject* pyobj_vocabulary = NULL;
| 53281 | vector_string vocabulary; |  | 53233 | vector_string vocabulary;
| 53282 | TextRecognitionModel retval; |  | 53234 | TextRecognitionModel retval;
| 53283 |  |  | 53235 |
| 53284 | const char* keywords[] = { "vocabulary", NULL }; |  | 53236 | const char* keywords[] = { "vocabulary", NULL };
| 53285 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.setVocabulary", (char**)keywords, &pyobj_vocabulary) && |  | 53237 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_TextRecognitionModel.setVocabulary", (char**)keywords, &pyobj_vocabulary) &&
| 53286 | pyopencv_to_safe(pyobj_vocabulary, vocabulary, ArgInfo("vocabulary", 0)) ) |  | 53238 | pyopencv_to_safe(pyobj_vocabulary, vocabulary, ArgInfo("vocabulary", 0)) )
| 53287 | { |  | 53239 | {
| 53288 | ERRWRAP2(retval = _self_->setVocabulary(vocabulary)); |  | 53240 | ERRWRAP2(retval = _self_->setVocabulary(vocabulary));
| 53289 | return pyopencv_from(retval); |  | 53241 | return pyopencv_from(retval);
| 53290 | } |  | 53242 | }
| 53291 |  |  | 53243 |
| 53292 | return NULL; |  | 53244 | return NULL;
| 53293 | } |  | 53245 | }
| 53294 |  |  | 53246 |
| 53295 |  |  | 53247 |
| 53296 |  |  | 53248 |
| 53297 | // Tables (dnn_TextRecognitionModel) |  | 53249 | // Tables (dnn_TextRecognitionModel)
| 53298 |  |  | 53250 |
| 53299 | static PyGetSetDef pyopencv_dnn_TextRecognitionModel_getseters[] = |  | 53251 | static PyGetSetDef pyopencv_dnn_TextRecognitionModel_getseters[] =
| 53300 | { |  | 53252 | {
| 53301 | {NULL} /* Sentinel */ |  | 53253 | {NULL} /* Sentinel */
| 53302 | }; |  | 53254 | };
| 53303 |  |  | 53255 |
| 53304 | static PyMethodDef pyopencv_dnn_TextRecognitionModel_methods[] = |  | 53256 | static PyMethodDef pyopencv_dnn_TextRecognitionModel_methods[] =
| 53305 | { |  | 53257 | {
| 53306 | {"getDecodeType", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_getDecodeType, 0), "getDecodeType() -> retval\n. * @brief Get the decoding method\n. * @return the decoding method"}, |  | 53258 | {"getDecodeType", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_getDecodeType, 0), "getDecodeType() -> retval\n. * @brief Get the decoding method\n. * @return the decoding method"},
| 53307 | {"getVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_getVocabulary, 0), "getVocabulary() -> retval\n. * @brief Get the vocabulary for recognition.\n. * @return vocabulary the associated vocabulary"}, |  | 53259 | {"getVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_getVocabulary, 0), "getVocabulary() -> retval\n. * @brief Get the vocabulary for recognition.\n. * @return vocabulary the associated vocabulary"},
| 53308 | {"recognize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_recognize, 0), "recognize(frame) -> retval\n. * @brief Given the @p input frame, create input blob, run net and return recognition result\n. * @param[in] frame The input image\n. * @return The text recognition result\n\n\n\nrecognize(frame, roiRects) -> results\n. * @brief Given the @p input frame, create input blob, run net and return recognition result\n. * @param[in] frame The input image\n. * @param[in] roiRects List of text detection regions of interest (cv::Rect, CV_32SC4). ROIs is be cropped as the network inputs\n. * @param[out] results A set of text recognition results."}, |  | 53260 | {"recognize", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_recognize, 0), "recognize(frame) -> retval\n. * @brief Given the @p input frame, create input blob, run net and return recognition result\n. * @param[in] frame The input image\n. * @return The text recognition result\n\n\n\nrecognize(frame, roiRects) -> results\n. * @brief Given the @p input frame, create input blob, run net and return recognition result\n. * @param[in] frame The input image\n. * @param[in] roiRects List of text detection regions of interest (cv::Rect, CV_32SC4). ROIs is be cropped as the network inputs\n. * @param[out] results A set of text recognition results."},
| 53309 | {"setDecodeOptsCTCPrefixBeamSearch", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeOptsCTCPrefixBeamSearch, 0), "setDecodeOptsCTCPrefixBeamSearch(beamSize[, vocPruneSize]) -> retval\n. * @brief Set the decoding method options for `\"CTC-prefix-beam-search\"` decode usage\n. * @param[in] beamSize Beam size for search\n. * @param[in] vocPruneSize Parameter to optimize big vocabulary search,\n. * only take top @p vocPruneSize tokens in each search step, @p vocPruneSize <= 0 stands for disable this prune."}, |  | 53261 | {"setDecodeOptsCTCPrefixBeamSearch", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeOptsCTCPrefixBeamSearch, 0), "setDecodeOptsCTCPrefixBeamSearch(beamSize[, vocPruneSize]) -> retval\n. * @brief Set the decoding method options for `\"CTC-prefix-beam-search\"` decode usage\n. * @param[in] beamSize Beam size for search\n. * @param[in] vocPruneSize Parameter to optimize big vocabulary search,\n. * only take top @p vocPruneSize tokens in each search step, @p vocPruneSize <= 0 stands for disable this prune."},
| 53310 | {"setDecodeType", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeType, 0), "setDecodeType(decodeType) -> retval\n. * @brief Set the decoding method of translating the network output into string\n. * @param[in] decodeType The decoding method of translating the network output into string, currently supported type:\n. * - `\"CTC-greedy\"` greedy decoding for the output of CTC-based methods\n. * - `\"CTC-prefix-beam-search\"` Prefix beam search decoding for the output of CTC-based methods"}, |  | 53262 | {"setDecodeType", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_setDecodeType, 0), "setDecodeType(decodeType) -> retval\n. * @brief Set the decoding method of translating the network output into string\n. * @param[in] decodeType The decoding method of translating the network output into string, currently supported type:\n. * - `\"CTC-greedy\"` greedy decoding for the output of CTC-based methods\n. * - `\"CTC-prefix-beam-search\"` Prefix beam search decoding for the output of CTC-based methods"},
| 53311 | {"setVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_setVocabulary, 0), "setVocabulary(vocabulary) -> retval\n. * @brief Set the vocabulary for recognition.\n. * @param[in] vocabulary the associated vocabulary of the network."}, |  | 53263 | {"setVocabulary", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_dnn_TextRecognitionModel_setVocabulary, 0), "setVocabulary(vocabulary) -> retval\n. * @brief Set the vocabulary for recognition.\n. * @param[in] vocabulary the associated vocabulary of the network."},
| 53312 |  |  | 53264 |
| 53313 | {NULL, NULL} |  | 53265 | {NULL, NULL}
| 53314 | }; |  | 53266 | };
| 53315 |  |  | 53267 |
| 53316 | // Converter (dnn_TextRecognitionModel) |  | 53268 | // Converter (dnn_TextRecognitionModel)
| 53317 |  |  | 53269 |
| 53318 | template<> |  | 53270 | template<>
| 53319 | struct PyOpenCV_Converter< cv::dnn::TextRecognitionModel > |  | 53271 | struct PyOpenCV_Converter< cv::dnn::TextRecognitionModel >
| 53320 | { |  | 53272 | {
| 53321 | static PyObject* from(const cv::dnn::TextRecognitionModel& r) |  | 53273 | static PyObject* from(const cv::dnn::TextRecognitionModel& r)
| 53322 | { |  | 53274 | {
| 53323 | return pyopencv_dnn_TextRecognitionModel_Instance(r); |  | 53275 | return pyopencv_dnn_TextRecognitionModel_Instance(r);
| 53324 | } |  | 53276 | }
| 53325 | static bool to(PyObject* src, cv::dnn::TextRecognitionModel& dst, const ArgInfo& info) |  | 53277 | static bool to(PyObject* src, cv::dnn::TextRecognitionModel& dst, const ArgInfo& info)
| 53326 | { |  | 53278 | {
| 53327 | if(!src || src == Py_None) |  | 53279 | if(!src || src == Py_None)
| 53328 | return true; |  | 53280 | return true;
| 53329 | cv::dnn::TextRecognitionModel * dst_; |  | 53281 | cv::dnn::TextRecognitionModel * dst_;
| 53330 | if (pyopencv_dnn_TextRecognitionModel_getp(src, dst_)) |  | 53282 | if (pyopencv_dnn_TextRecognitionModel_getp(src, dst_))
| 53331 | { |  | 53283 | {
| 53332 | dst = *dst_; |  | 53284 | dst = *dst_;
| 53333 | return true; |  | 53285 | return true;
| 53334 | } |  | 53286 | }
| 53335 |  |  | 53287 |
| 53336 | failmsg("Expected cv::dnn::TextRecognitionModel for argument '%s'", info.name); |  | 53288 | failmsg("Expected cv::dnn::TextRecognitionModel for argument '%s'", info.name);
| 53337 | return false; |  | 53289 | return false;
| 53338 | } |  | 53290 | }
| 53339 | }; |  | 53291 | };
| 53340 |  |  | 53292 |
| 53341 | //================================================================================ |  | 53293 | //================================================================================
| 53342 | // dnn_superres_DnnSuperResImpl (Generic) |  | 53294 | // dnn_superres_DnnSuperResImpl (Generic)
| 53343 | //================================================================================ |  | 53295 | //================================================================================
| 53344 |  |  | 53296 |
| 53345 | // GetSet (dnn_superres_DnnSuperResImpl) |  | 53297 | // GetSet (dnn_superres_DnnSuperResImpl)
| 53346 |  |  | 53298 |
| 53347 |  |  | 53299 |
| 53348 |  |  | 53300 |
| 53349 | // Methods (dnn_superres_DnnSuperResImpl) |  | 53301 | // Methods (dnn_superres_DnnSuperResImpl)
| 53350 |  |  | 53302 |
| 53351 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53303 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 53352 | { |  | 53304 | {
| 53353 | using namespace cv::dnn_superres; |  | 53305 | using namespace cv::dnn_superres;
| 53354 |  |  | 53306 |
| 53355 | Ptr<DnnSuperResImpl> retval; |  | 53307 | Ptr<DnnSuperResImpl> retval;
| 53356 |  |  | 53308 |
| 53357 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 53309 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 53358 | { |  | 53310 | {
| 53359 | ERRWRAP2(retval = cv::dnn_superres::DnnSuperResImpl::create()); |  | 53311 | ERRWRAP2(retval = cv::dnn_superres::DnnSuperResImpl::create());
| 53360 | return pyopencv_from(retval); |  | 53312 | return pyopencv_from(retval);
| 53361 | } |  | 53313 | }
| 53362 |  |  | 53314 |
| 53363 | return NULL; |  | 53315 | return NULL;
| 53364 | } |  | 53316 | }
| 53365 |  |  | 53317 |
| 53366 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53318 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw)
| 53367 | { |  | 53319 | {
| 53368 | using namespace cv::dnn_superres; |  | 53320 | using namespace cv::dnn_superres;
| 53369 |  |  | 53321 |
| 53370 |  |  | 53322 |
| 53371 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53323 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53372 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53324 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53373 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53325 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53374 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53326 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53375 | String retval; |  | 53327 | String retval;
| 53376 |  |  | 53328 |
| 53377 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 53329 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 53378 | { |  | 53330 | {
| 53379 | ERRWRAP2(retval = _self_->getAlgorithm()); |  | 53331 | ERRWRAP2(retval = _self_->getAlgorithm());
| 53380 | return pyopencv_from(retval); |  | 53332 | return pyopencv_from(retval);
| 53381 | } |  | 53333 | }
| 53382 |  |  | 53334 |
| 53383 | return NULL; |  | 53335 | return NULL;
| 53384 | } |  | 53336 | }
| 53385 |  |  | 53337 |
| 53386 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53338 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 53387 | { |  | 53339 | {
| 53388 | using namespace cv::dnn_superres; |  | 53340 | using namespace cv::dnn_superres;
| 53389 |  |  | 53341 |
| 53390 |  |  | 53342 |
| 53391 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53343 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53392 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53344 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53393 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53345 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53394 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53346 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53395 | int retval; |  | 53347 | int retval;
| 53396 |  |  | 53348 |
| 53397 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 53349 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 53398 | { |  | 53350 | {
| 53399 | ERRWRAP2(retval = _self_->getScale()); |  | 53351 | ERRWRAP2(retval = _self_->getScale());
| 53400 | return pyopencv_from(retval); |  | 53352 | return pyopencv_from(retval);
| 53401 | } |  | 53353 | }
| 53402 |  |  | 53354 |
| 53403 | return NULL; |  | 53355 | return NULL;
| 53404 | } |  | 53356 | }
| 53405 |  |  | 53357 |
| 53406 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_readModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53358 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_readModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 53407 | { |  | 53359 | {
| 53408 | using namespace cv::dnn_superres; |  | 53360 | using namespace cv::dnn_superres;
| 53409 |  |  | 53361 |
| 53410 |  |  | 53362 |
| 53411 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53363 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53412 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53364 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53413 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53365 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53414 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53366 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53415 | PyObject* pyobj_path = NULL; |  | 53367 | PyObject* pyobj_path = NULL;
| 53416 | String path; |  | 53368 | String path;
| 53417 |  |  | 53369 |
| 53418 | const char* keywords[] = { "path", NULL }; |  | 53370 | const char* keywords[] = { "path", NULL };
| 53419 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_superres_DnnSuperResImpl.readModel", (char**)keywords, &pyobj_path) && |  | 53371 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_superres_DnnSuperResImpl.readModel", (char**)keywords, &pyobj_path) &&
| 53420 | pyopencv_to_safe(pyobj_path, path, ArgInfo("path", 0)) ) |  | 53372 | pyopencv_to_safe(pyobj_path, path, ArgInfo("path", 0)) )
| 53421 | { |  | 53373 | {
| 53422 | ERRWRAP2(_self_->readModel(path)); |  | 53374 | ERRWRAP2(_self_->readModel(path));
| 53423 | Py_RETURN_NONE; |  | 53375 | Py_RETURN_NONE;
| 53424 | } |  | 53376 | }
| 53425 |  |  | 53377 |
| 53426 | return NULL; |  | 53378 | return NULL;
| 53427 | } |  | 53379 | }
| 53428 |  |  | 53380 |
| 53429 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53381 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 53430 | { |  | 53382 | {
| 53431 | using namespace cv::dnn_superres; |  | 53383 | using namespace cv::dnn_superres;
| 53432 |  |  | 53384 |
| 53433 |  |  | 53385 |
| 53434 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53386 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53435 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53387 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53436 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53388 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53437 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53389 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53438 | PyObject* pyobj_algo = NULL; |  | 53390 | PyObject* pyobj_algo = NULL;
| 53439 | String algo; |  | 53391 | String algo;
| 53440 | PyObject* pyobj_scale = NULL; |  | 53392 | PyObject* pyobj_scale = NULL;
| 53441 | int scale=0; |  | 53393 | int scale=0;
| 53442 |  |  | 53394 |
| 53443 | const char* keywords[] = { "algo", "scale", NULL }; |  | 53395 | const char* keywords[] = { "algo", "scale", NULL };
| 53444 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_superres_DnnSuperResImpl.setModel", (char**)keywords, &pyobj_algo, &pyobj_scale) && |  | 53396 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:dnn_superres_DnnSuperResImpl.setModel", (char**)keywords, &pyobj_algo, &pyobj_scale) &&
| 53445 | pyopencv_to_safe(pyobj_algo, algo, ArgInfo("algo", 0)) && |  | 53397 | pyopencv_to_safe(pyobj_algo, algo, ArgInfo("algo", 0)) &&
| 53446 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) ) |  | 53398 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) )
| 53447 | { |  | 53399 | {
| 53448 | ERRWRAP2(_self_->setModel(algo, scale)); |  | 53400 | ERRWRAP2(_self_->setModel(algo, scale));
| 53449 | Py_RETURN_NONE; |  | 53401 | Py_RETURN_NONE;
| 53450 | } |  | 53402 | }
| 53451 |  |  | 53403 |
| 53452 | return NULL; |  | 53404 | return NULL;
| 53453 | } |  | 53405 | }
| 53454 |  |  | 53406 |
| 53455 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableBackend(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53407 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableBackend(PyObject* self, PyObject* py_args, PyObject* kw)
| 53456 | { |  | 53408 | {
| 53457 | using namespace cv::dnn_superres; |  | 53409 | using namespace cv::dnn_superres;
| 53458 |  |  | 53410 |
| 53459 |  |  | 53411 |
| 53460 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53412 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53461 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53413 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53462 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53414 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53463 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53415 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53464 | PyObject* pyobj_backendId = NULL; |  | 53416 | PyObject* pyobj_backendId = NULL;
| 53465 | int backendId=0; |  | 53417 | int backendId=0;
| 53466 |  |  | 53418 |
| 53467 | const char* keywords[] = { "backendId", NULL }; |  | 53419 | const char* keywords[] = { "backendId", NULL };
| 53468 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_superres_DnnSuperResImpl.setPreferableBackend", (char**)keywords, &pyobj_backendId) && |  | 53420 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_superres_DnnSuperResImpl.setPreferableBackend", (char**)keywords, &pyobj_backendId) &&
| 53469 | pyopencv_to_safe(pyobj_backendId, backendId, ArgInfo("backendId", 0)) ) |  | 53421 | pyopencv_to_safe(pyobj_backendId, backendId, ArgInfo("backendId", 0)) )
| 53470 | { |  | 53422 | {
| 53471 | ERRWRAP2(_self_->setPreferableBackend(backendId)); |  | 53423 | ERRWRAP2(_self_->setPreferableBackend(backendId));
| 53472 | Py_RETURN_NONE; |  | 53424 | Py_RETURN_NONE;
| 53473 | } |  | 53425 | }
| 53474 |  |  | 53426 |
| 53475 | return NULL; |  | 53427 | return NULL;
| 53476 | } |  | 53428 | }
| 53477 |  |  | 53429 |
| 53478 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableTarget(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53430 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableTarget(PyObject* self, PyObject* py_args, PyObject* kw)
| 53479 | { |  | 53431 | {
| 53480 | using namespace cv::dnn_superres; |  | 53432 | using namespace cv::dnn_superres;
| 53481 |  |  | 53433 |
| 53482 |  |  | 53434 |
| 53483 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53435 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53484 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53436 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53485 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53437 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53486 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53438 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53487 | PyObject* pyobj_targetId = NULL; |  | 53439 | PyObject* pyobj_targetId = NULL;
| 53488 | int targetId=0; |  | 53440 | int targetId=0;
| 53489 |  |  | 53441 |
| 53490 | const char* keywords[] = { "targetId", NULL }; |  | 53442 | const char* keywords[] = { "targetId", NULL };
| 53491 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_superres_DnnSuperResImpl.setPreferableTarget", (char**)keywords, &pyobj_targetId) && |  | 53443 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dnn_superres_DnnSuperResImpl.setPreferableTarget", (char**)keywords, &pyobj_targetId) &&
| 53492 | pyopencv_to_safe(pyobj_targetId, targetId, ArgInfo("targetId", 0)) ) |  | 53444 | pyopencv_to_safe(pyobj_targetId, targetId, ArgInfo("targetId", 0)) )
| 53493 | { |  | 53445 | {
| 53494 | ERRWRAP2(_self_->setPreferableTarget(targetId)); |  | 53446 | ERRWRAP2(_self_->setPreferableTarget(targetId));
| 53495 | Py_RETURN_NONE; |  | 53447 | Py_RETURN_NONE;
| 53496 | } |  | 53448 | }
| 53497 |  |  | 53449 |
| 53498 | return NULL; |  | 53450 | return NULL;
| 53499 | } |  | 53451 | }
| 53500 |  |  | 53452 |
| 53501 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsample(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53453 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsample(PyObject* self, PyObject* py_args, PyObject* kw)
| 53502 | { |  | 53454 | {
| 53503 | using namespace cv::dnn_superres; |  | 53455 | using namespace cv::dnn_superres;
| 53504 |  |  | 53456 |
| 53505 |  |  | 53457 |
| 53506 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53458 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53507 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53459 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53508 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53460 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53509 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53461 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53510 | pyPrepareArgumentConversionErrorsStorage(2); |  | 53462 | pyPrepareArgumentConversionErrorsStorage(2);
| 53511 |  |  | 53463 |
| 53512 | { |  | 53464 | {
| 53513 | PyObject* pyobj_img = NULL; |  | 53465 | PyObject* pyobj_img = NULL;
| 53514 | Mat img; |  | 53466 | Mat img;
| 53515 | PyObject* pyobj_result = NULL; |  | 53467 | PyObject* pyobj_result = NULL;
| 53516 | Mat result; |  | 53468 | Mat result;
| 53517 |  |  | 53469 |
| 53518 | const char* keywords[] = { "img", "result", NULL }; |  | 53470 | const char* keywords[] = { "img", "result", NULL };
| 53519 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_superres_DnnSuperResImpl.upsample", (char**)keywords, &pyobj_img, &pyobj_result) && |  | 53471 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_superres_DnnSuperResImpl.upsample", (char**)keywords, &pyobj_img, &pyobj_result) &&
| 53520 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 53472 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 53521 | pyopencv_to_safe(pyobj_result, result, ArgInfo("result", 1)) ) |  | 53473 | pyopencv_to_safe(pyobj_result, result, ArgInfo("result", 1)) )
| 53522 | { |  | 53474 | {
| 53523 | ERRWRAP2(_self_->upsample(img, result)); |  | 53475 | ERRWRAP2(_self_->upsample(img, result));
| 53524 | return pyopencv_from(result); |  | 53476 | return pyopencv_from(result);
| 53525 | } |  | 53477 | }
| 53526 |  |  | 53478 |
| 53527 |  |  | 53479 |
| 53528 | pyPopulateArgumentConversionErrors(); |  | 53480 | pyPopulateArgumentConversionErrors();
| 53529 | } |  | 53481 | }
| 53530 |  |  | 53482 |
| 53531 |  |  | 53483 |
| 53532 | { |  | 53484 | {
| 53533 | PyObject* pyobj_img = NULL; |  | 53485 | PyObject* pyobj_img = NULL;
| 53534 | UMat img; |  | 53486 | UMat img;
| 53535 | PyObject* pyobj_result = NULL; |  | 53487 | PyObject* pyobj_result = NULL;
| 53536 | UMat result; |  | 53488 | UMat result;
| 53537 |  |  | 53489 |
| 53538 | const char* keywords[] = { "img", "result", NULL }; |  | 53490 | const char* keywords[] = { "img", "result", NULL };
| 53539 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_superres_DnnSuperResImpl.upsample", (char**)keywords, &pyobj_img, &pyobj_result) && |  | 53491 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dnn_superres_DnnSuperResImpl.upsample", (char**)keywords, &pyobj_img, &pyobj_result) &&
| 53540 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 53492 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 53541 | pyopencv_to_safe(pyobj_result, result, ArgInfo("result", 1)) ) |  | 53493 | pyopencv_to_safe(pyobj_result, result, ArgInfo("result", 1)) )
| 53542 | { |  | 53494 | {
| 53543 | ERRWRAP2(_self_->upsample(img, result)); |  | 53495 | ERRWRAP2(_self_->upsample(img, result));
| 53544 | return pyopencv_from(result); |  | 53496 | return pyopencv_from(result);
| 53545 | } |  | 53497 | }
| 53546 |  |  | 53498 |
| 53547 |  |  | 53499 |
| 53548 | pyPopulateArgumentConversionErrors(); |  | 53500 | pyPopulateArgumentConversionErrors();
| 53549 | } |  | 53501 | }
| 53550 | pyRaiseCVOverloadException("upsample"); |  | 53502 | pyRaiseCVOverloadException("upsample");
| 53551 |  |  | 53503 |
| 53552 | return NULL; |  | 53504 | return NULL;
| 53553 | } |  | 53505 | }
| 53554 |  |  | 53506 |
| 53555 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsampleMultioutput(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53507 | static PyObject* pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsampleMultioutput(PyObject* self, PyObject* py_args, PyObject* kw)
| 53556 | { |  | 53508 | {
| 53557 | using namespace cv::dnn_superres; |  | 53509 | using namespace cv::dnn_superres;
| 53558 |  |  | 53510 |
| 53559 |  |  | 53511 |
| 53560 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0; |  | 53512 | Ptr<cv::dnn_superres::DnnSuperResImpl> * self1 = 0;
| 53561 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1)) |  | 53513 | if (!pyopencv_dnn_superres_DnnSuperResImpl_getp(self, self1))
| 53562 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)"); |  | 53514 | return failmsgp("Incorrect type of self (must be 'dnn_superres_DnnSuperResImpl' or its derivative)");
| 53563 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1); |  | 53515 | Ptr<cv::dnn_superres::DnnSuperResImpl> _self_ = *(self1);
| 53564 | pyPrepareArgumentConversionErrorsStorage(2); |  | 53516 | pyPrepareArgumentConversionErrorsStorage(2);
| 53565 |  |  | 53517 |
| 53566 | { |  | 53518 | {
| 53567 | PyObject* pyobj_img = NULL; |  | 53519 | PyObject* pyobj_img = NULL;
| 53568 | Mat img; |  | 53520 | Mat img;
| 53569 | PyObject* pyobj_imgs_new = NULL; |  | 53521 | PyObject* pyobj_imgs_new = NULL;
| 53570 | vector_Mat imgs_new; |  | 53522 | vector_Mat imgs_new;
| 53571 | PyObject* pyobj_scale_factors = NULL; |  | 53523 | PyObject* pyobj_scale_factors = NULL;
| 53572 | vector_int scale_factors; |  | 53524 | vector_int scale_factors;
| 53573 | PyObject* pyobj_node_names = NULL; |  | 53525 | PyObject* pyobj_node_names = NULL;
| 53574 | vector_String node_names; |  | 53526 | vector_String node_names;
| 53575 |  |  | 53527 |
| 53576 | const char* keywords[] = { "img", "imgs_new", "scale_factors", "node_names", NULL }; |  | 53528 | const char* keywords[] = { "img", "imgs_new", "scale_factors", "node_names", NULL };
| 53577 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_superres_DnnSuperResImpl.upsampleMultioutput", (char**)keywords, &pyobj_img, &pyobj_imgs_new, &pyobj_scale_factors, &pyobj_node_names) && |  | 53529 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_superres_DnnSuperResImpl.upsampleMultioutput", (char**)keywords, &pyobj_img, &pyobj_imgs_new, &pyobj_scale_factors, &pyobj_node_names) &&
| 53578 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 53530 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 53579 | pyopencv_to_safe(pyobj_imgs_new, imgs_new, ArgInfo("imgs_new", 0)) && |  | 53531 | pyopencv_to_safe(pyobj_imgs_new, imgs_new, ArgInfo("imgs_new", 0)) &&
| 53580 | pyopencv_to_safe(pyobj_scale_factors, scale_factors, ArgInfo("scale_factors", 0)) && |  | 53532 | pyopencv_to_safe(pyobj_scale_factors, scale_factors, ArgInfo("scale_factors", 0)) &&
| 53581 | pyopencv_to_safe(pyobj_node_names, node_names, ArgInfo("node_names", 0)) ) |  | 53533 | pyopencv_to_safe(pyobj_node_names, node_names, ArgInfo("node_names", 0)) )
| 53582 | { |  | 53534 | {
| 53583 | ERRWRAP2(_self_->upsampleMultioutput(img, imgs_new, scale_factors, node_names)); |  | 53535 | ERRWRAP2(_self_->upsampleMultioutput(img, imgs_new, scale_factors, node_names));
| 53584 | Py_RETURN_NONE; |  | 53536 | Py_RETURN_NONE;
| 53585 | } |  | 53537 | }
| 53586 |  |  | 53538 |
| 53587 |  |  | 53539 |
| 53588 | pyPopulateArgumentConversionErrors(); |  | 53540 | pyPopulateArgumentConversionErrors();
| 53589 | } |  | 53541 | }
| 53590 |  |  | 53542 |
| 53591 |  |  | 53543 |
| 53592 | { |  | 53544 | {
| 53593 | PyObject* pyobj_img = NULL; |  | 53545 | PyObject* pyobj_img = NULL;
| 53594 | UMat img; |  | 53546 | UMat img;
| 53595 | PyObject* pyobj_imgs_new = NULL; |  | 53547 | PyObject* pyobj_imgs_new = NULL;
| 53596 | vector_Mat imgs_new; |  | 53548 | vector_Mat imgs_new;
| 53597 | PyObject* pyobj_scale_factors = NULL; |  | 53549 | PyObject* pyobj_scale_factors = NULL;
| 53598 | vector_int scale_factors; |  | 53550 | vector_int scale_factors;
| 53599 | PyObject* pyobj_node_names = NULL; |  | 53551 | PyObject* pyobj_node_names = NULL;
| 53600 | vector_String node_names; |  | 53552 | vector_String node_names;
| 53601 |  |  | 53553 |
| 53602 | const char* keywords[] = { "img", "imgs_new", "scale_factors", "node_names", NULL }; |  | 53554 | const char* keywords[] = { "img", "imgs_new", "scale_factors", "node_names", NULL };
| 53603 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_superres_DnnSuperResImpl.upsampleMultioutput", (char**)keywords, &pyobj_img, &pyobj_imgs_new, &pyobj_scale_factors, &pyobj_node_names) && |  | 53555 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:dnn_superres_DnnSuperResImpl.upsampleMultioutput", (char**)keywords, &pyobj_img, &pyobj_imgs_new, &pyobj_scale_factors, &pyobj_node_names) &&
| 53604 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 53556 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 53605 | pyopencv_to_safe(pyobj_imgs_new, imgs_new, ArgInfo("imgs_new", 0)) && |  | 53557 | pyopencv_to_safe(pyobj_imgs_new, imgs_new, ArgInfo("imgs_new", 0)) &&
| 53606 | pyopencv_to_safe(pyobj_scale_factors, scale_factors, ArgInfo("scale_factors", 0)) && |  | 53558 | pyopencv_to_safe(pyobj_scale_factors, scale_factors, ArgInfo("scale_factors", 0)) &&
| 53607 | pyopencv_to_safe(pyobj_node_names, node_names, ArgInfo("node_names", 0)) ) |  | 53559 | pyopencv_to_safe(pyobj_node_names, node_names, ArgInfo("node_names", 0)) )
| 53608 | { |  | 53560 | {
| 53609 | ERRWRAP2(_self_->upsampleMultioutput(img, imgs_new, scale_factors, node_names)); |  | 53561 | ERRWRAP2(_self_->upsampleMultioutput(img, imgs_new, scale_factors, node_names));
| 53610 | Py_RETURN_NONE; |  | 53562 | Py_RETURN_NONE;
| 53611 | } |  | 53563 | }
| 53612 |  |  | 53564 |
| 53613 |  |  | 53565 |
| 53614 | pyPopulateArgumentConversionErrors(); |  | 53566 | pyPopulateArgumentConversionErrors();
| 53615 | } |  | 53567 | }
| 53616 | pyRaiseCVOverloadException("upsampleMultioutput"); |  | 53568 | pyRaiseCVOverloadException("upsampleMultioutput");
| 53617 |  |  | 53569 |
| 53618 | return NULL; |  | 53570 | return NULL;
| 53619 | } |  | 53571 | }
| 53620 |  |  | 53572 |
| 53621 |  |  | 53573 |
| 53622 |  |  | 53574 |
| 53623 | // Tables (dnn_superres_DnnSuperResImpl) |  | 53575 | // Tables (dnn_superres_DnnSuperResImpl)
| 53624 |  |  | 53576 |
| 53625 | static PyGetSetDef pyopencv_dnn_superres_DnnSuperResImpl_getseters[] = |  | 53577 | static PyGetSetDef pyopencv_dnn_superres_DnnSuperResImpl_getseters[] =
| 53626 | { |  | 53578 | {
| 53627 | {NULL} /* Sentinel */ |  | 53579 | {NULL} /* Sentinel */
| 53628 | }; |  | 53580 | };
| 53629 |  |  | 53581 |
| 53630 | static PyMethodDef pyopencv_dnn_superres_DnnSuperResImpl_methods[] = |  | 53582 | static PyMethodDef pyopencv_dnn_superres_DnnSuperResImpl_methods[] =
| 53631 | { |  | 53583 | {
| 53632 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_create_static, METH_STATIC), "create() -> retval\n. @brief Empty constructor for python"}, |  | 53584 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_create_static, METH_STATIC), "create() -> retval\n. @brief Empty constructor for python"},
| 53633 | {"getAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getAlgorithm, 0), "getAlgorithm() -> retval\n. @brief Returns the scale factor of the model:\n. @return Current algorithm."}, |  | 53585 | {"getAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getAlgorithm, 0), "getAlgorithm() -> retval\n. @brief Returns the scale factor of the model:\n. @return Current algorithm."},
| 53634 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getScale, 0), "getScale() -> retval\n. @brief Returns the scale factor of the model:\n. @return Current scale factor."}, |  | 53586 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_getScale, 0), "getScale() -> retval\n. @brief Returns the scale factor of the model:\n. @return Current scale factor."},
| 53635 | {"readModel", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_readModel, 0), "readModel(path) -> None\n. @brief Read the model from the given path\n. @param path Path to the model file."}, |  | 53587 | {"readModel", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_readModel, 0), "readModel(path) -> None\n. @brief Read the model from the given path\n. @param path Path to the model file."},
| 53636 | {"setModel", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setModel, 0), "setModel(algo, scale) -> None\n. @brief Set desired model\n. @param algo String containing one of the desired models:\n. - __edsr__\n. - __espcn__\n. - __fsrcnn__\n. - __lapsrn__\n. @param scale Integer specifying the upscale factor"}, |  | 53588 | {"setModel", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setModel, 0), "setModel(algo, scale) -> None\n. @brief Set desired model\n. @param algo String containing one of the desired models:\n. - __edsr__\n. - __espcn__\n. - __fsrcnn__\n. - __lapsrn__\n. @param scale Integer specifying the upscale factor"},
| 53637 | {"setPreferableBackend", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableBackend, 0), "setPreferableBackend(backendId) -> None\n. @brief Set computation backend"}, |  | 53589 | {"setPreferableBackend", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableBackend, 0), "setPreferableBackend(backendId) -> None\n. @brief Set computation backend"},
| 53638 | {"setPreferableTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableTarget, 0), "setPreferableTarget(targetId) -> None\n. @brief Set computation target"}, |  | 53590 | {"setPreferableTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_setPreferableTarget, 0), "setPreferableTarget(targetId) -> None\n. @brief Set computation target"},
| 53639 | {"upsample", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsample, 0), "upsample(img[, result]) -> result\n. @brief Upsample via neural network\n. @param img Image to upscale\n. @param result Destination upscaled image"}, |  | 53591 | {"upsample", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsample, 0), "upsample(img[, result]) -> result\n. @brief Upsample via neural network\n. @param img Image to upscale\n. @param result Destination upscaled image"},
| 53640 | {"upsampleMultioutput", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsampleMultioutput, 0), "upsampleMultioutput(img, imgs_new, scale_factors, node_names) -> None\n. @brief Upsample via neural network of multiple outputs\n. @param img Image to upscale\n. @param imgs_new Destination upscaled images\n. @param scale_factors Scaling factors of the output nodes\n. @param node_names Names of the output nodes in the neural network"}, |  | 53592 | {"upsampleMultioutput", CV_PY_FN_WITH_KW_(pyopencv_cv_dnn_superres_dnn_superres_DnnSuperResImpl_upsampleMultioutput, 0), "upsampleMultioutput(img, imgs_new, scale_factors, node_names) -> None\n. @brief Upsample via neural network of multiple outputs\n. @param img Image to upscale\n. @param imgs_new Destination upscaled images\n. @param scale_factors Scaling factors of the output nodes\n. @param node_names Names of the output nodes in the neural network"},
| 53641 |  |  | 53593 |
| 53642 | {NULL, NULL} |  | 53594 | {NULL, NULL}
| 53643 | }; |  | 53595 | };
| 53644 |  |  | 53596 |
| 53645 | // Converter (dnn_superres_DnnSuperResImpl) |  | 53597 | // Converter (dnn_superres_DnnSuperResImpl)
| 53646 |  |  | 53598 |
| 53647 | template<> |  | 53599 | template<>
| 53648 | struct PyOpenCV_Converter< Ptr<cv::dnn_superres::DnnSuperResImpl> > |  | 53600 | struct PyOpenCV_Converter< Ptr<cv::dnn_superres::DnnSuperResImpl> >
| 53649 | { |  | 53601 | {
| 53650 | static PyObject* from(const Ptr<cv::dnn_superres::DnnSuperResImpl>& r) |  | 53602 | static PyObject* from(const Ptr<cv::dnn_superres::DnnSuperResImpl>& r)
| 53651 | { |  | 53603 | {
| 53652 | return pyopencv_dnn_superres_DnnSuperResImpl_Instance(r); |  | 53604 | return pyopencv_dnn_superres_DnnSuperResImpl_Instance(r);
| 53653 | } |  | 53605 | }
| 53654 | static bool to(PyObject* src, Ptr<cv::dnn_superres::DnnSuperResImpl>& dst, const ArgInfo& info) |  | 53606 | static bool to(PyObject* src, Ptr<cv::dnn_superres::DnnSuperResImpl>& dst, const ArgInfo& info)
| 53655 | { |  | 53607 | {
| 53656 | if(!src || src == Py_None) |  | 53608 | if(!src || src == Py_None)
| 53657 | return true; |  | 53609 | return true;
| 53658 | Ptr<cv::dnn_superres::DnnSuperResImpl> * dst_; |  | 53610 | Ptr<cv::dnn_superres::DnnSuperResImpl> * dst_;
| 53659 | if (pyopencv_dnn_superres_DnnSuperResImpl_getp(src, dst_)) |  | 53611 | if (pyopencv_dnn_superres_DnnSuperResImpl_getp(src, dst_))
| 53660 | { |  | 53612 | {
| 53661 | dst = *dst_; |  | 53613 | dst = *dst_;
| 53662 | return true; |  | 53614 | return true;
| 53663 | } |  | 53615 | }
| 53664 |  |  | 53616 |
| 53665 | failmsg("Expected Ptr<cv::dnn_superres::DnnSuperResImpl> for argument '%s'", info.name); |  | 53617 | failmsg("Expected Ptr<cv::dnn_superres::DnnSuperResImpl> for argument '%s'", info.name);
| 53666 | return false; |  | 53618 | return false;
| 53667 | } |  | 53619 | }
| 53668 | }; |  | 53620 | };
| 53669 |  |  | 53621 |
| 53670 | //================================================================================ |  | 53622 | //================================================================================
| 53671 | // dpm_DPMDetector (Generic) |  | 53623 | // dpm_DPMDetector (Generic)
| 53672 | //================================================================================ |  | 53624 | //================================================================================
| 53673 |  |  | 53625 |
| 53674 | // GetSet (dpm_DPMDetector) |  | 53626 | // GetSet (dpm_DPMDetector)
| 53675 |  |  | 53627 |
| 53676 |  |  | 53628 |
| 53677 |  |  | 53629 |
| 53678 | // Methods (dpm_DPMDetector) |  | 53630 | // Methods (dpm_DPMDetector)
| 53679 |  |  | 53631 |
| 53680 |  |  | 53632 |
| 53681 |  |  | 53633 |
| 53682 | // Tables (dpm_DPMDetector) |  | 53634 | // Tables (dpm_DPMDetector)
| 53683 |  |  | 53635 |
| 53684 | static PyGetSetDef pyopencv_dpm_DPMDetector_getseters[] = |  | 53636 | static PyGetSetDef pyopencv_dpm_DPMDetector_getseters[] =
| 53685 | { |  | 53637 | {
| 53686 | {NULL} /* Sentinel */ |  | 53638 | {NULL} /* Sentinel */
| 53687 | }; |  | 53639 | };
| 53688 |  |  | 53640 |
| 53689 | static PyMethodDef pyopencv_dpm_DPMDetector_methods[] = |  | 53641 | static PyMethodDef pyopencv_dpm_DPMDetector_methods[] =
| 53690 | { |  | 53642 | {
| 53691 |  |  | 53643 |
| 53692 | {NULL, NULL} |  | 53644 | {NULL, NULL}
| 53693 | }; |  | 53645 | };
| 53694 |  |  | 53646 |
| 53695 | // Converter (dpm_DPMDetector) |  | 53647 | // Converter (dpm_DPMDetector)
| 53696 |  |  | 53648 |
| 53697 | template<> |  | 53649 | template<>
| 53698 | struct PyOpenCV_Converter< Ptr<cv::dpm::DPMDetector> > |  | 53650 | struct PyOpenCV_Converter< Ptr<cv::dpm::DPMDetector> >
| 53699 | { |  | 53651 | {
| 53700 | static PyObject* from(const Ptr<cv::dpm::DPMDetector>& r) |  | 53652 | static PyObject* from(const Ptr<cv::dpm::DPMDetector>& r)
| 53701 | { |  | 53653 | {
| 53702 | return pyopencv_dpm_DPMDetector_Instance(r); |  | 53654 | return pyopencv_dpm_DPMDetector_Instance(r);
| 53703 | } |  | 53655 | }
| 53704 | static bool to(PyObject* src, Ptr<cv::dpm::DPMDetector>& dst, const ArgInfo& info) |  | 53656 | static bool to(PyObject* src, Ptr<cv::dpm::DPMDetector>& dst, const ArgInfo& info)
| 53705 | { |  | 53657 | {
| 53706 | if(!src || src == Py_None) |  | 53658 | if(!src || src == Py_None)
| 53707 | return true; |  | 53659 | return true;
| 53708 | Ptr<cv::dpm::DPMDetector> * dst_; |  | 53660 | Ptr<cv::dpm::DPMDetector> * dst_;
| 53709 | if (pyopencv_dpm_DPMDetector_getp(src, dst_)) |  | 53661 | if (pyopencv_dpm_DPMDetector_getp(src, dst_))
| 53710 | { |  | 53662 | {
| 53711 | dst = *dst_; |  | 53663 | dst = *dst_;
| 53712 | return true; |  | 53664 | return true;
| 53713 | } |  | 53665 | }
| 53714 |  |  | 53666 |
| 53715 | failmsg("Expected Ptr<cv::dpm::DPMDetector> for argument '%s'", info.name); |  | 53667 | failmsg("Expected Ptr<cv::dpm::DPMDetector> for argument '%s'", info.name);
| 53716 | return false; |  | 53668 | return false;
| 53717 | } |  | 53669 | }
| 53718 | }; |  | 53670 | };
| 53719 |  |  | 53671 |
| 53720 | //================================================================================ |  | 53672 | //================================================================================
| 53721 | // dpm_DPMDetector_ObjectDetection (Generic) |  | 53673 | // dpm_DPMDetector_ObjectDetection (Generic)
| 53722 | //================================================================================ |  | 53674 | //================================================================================
| 53723 |  |  | 53675 |
| 53724 | // GetSet (dpm_DPMDetector_ObjectDetection) |  | 53676 | // GetSet (dpm_DPMDetector_ObjectDetection)
| 53725 |  |  | 53677 |
| 53726 |  |  | 53678 |
| 53727 |  |  | 53679 |
| 53728 | // Methods (dpm_DPMDetector_ObjectDetection) |  | 53680 | // Methods (dpm_DPMDetector_ObjectDetection)
| 53729 |  |  | 53681 |
| 53730 |  |  | 53682 |
| 53731 |  |  | 53683 |
| 53732 | // Tables (dpm_DPMDetector_ObjectDetection) |  | 53684 | // Tables (dpm_DPMDetector_ObjectDetection)
| 53733 |  |  | 53685 |
| 53734 | static PyGetSetDef pyopencv_dpm_DPMDetector_ObjectDetection_getseters[] = |  | 53686 | static PyGetSetDef pyopencv_dpm_DPMDetector_ObjectDetection_getseters[] =
| 53735 | { |  | 53687 | {
| 53736 | {NULL} /* Sentinel */ |  | 53688 | {NULL} /* Sentinel */
| 53737 | }; |  | 53689 | };
| 53738 |  |  | 53690 |
| 53739 | static PyMethodDef pyopencv_dpm_DPMDetector_ObjectDetection_methods[] = |  | 53691 | static PyMethodDef pyopencv_dpm_DPMDetector_ObjectDetection_methods[] =
| 53740 | { |  | 53692 | {
| 53741 |  |  | 53693 |
| 53742 | {NULL, NULL} |  | 53694 | {NULL, NULL}
| 53743 | }; |  | 53695 | };
| 53744 |  |  | 53696 |
| 53745 | // Converter (dpm_DPMDetector_ObjectDetection) |  | 53697 | // Converter (dpm_DPMDetector_ObjectDetection)
| 53746 |  |  | 53698 |
| 53747 | template<> |  | 53699 | template<>
| 53748 | struct PyOpenCV_Converter< Ptr<cv::dpm::DPMDetector::ObjectDetection> > |  | 53700 | struct PyOpenCV_Converter< Ptr<cv::dpm::DPMDetector::ObjectDetection> >
| 53749 | { |  | 53701 | {
| 53750 | static PyObject* from(const Ptr<cv::dpm::DPMDetector::ObjectDetection>& r) |  | 53702 | static PyObject* from(const Ptr<cv::dpm::DPMDetector::ObjectDetection>& r)
| 53751 | { |  | 53703 | {
| 53752 | return pyopencv_dpm_DPMDetector_ObjectDetection_Instance(r); |  | 53704 | return pyopencv_dpm_DPMDetector_ObjectDetection_Instance(r);
| 53753 | } |  | 53705 | }
| 53754 | static bool to(PyObject* src, Ptr<cv::dpm::DPMDetector::ObjectDetection>& dst, const ArgInfo& info) |  | 53706 | static bool to(PyObject* src, Ptr<cv::dpm::DPMDetector::ObjectDetection>& dst, const ArgInfo& info)
| 53755 | { |  | 53707 | {
| 53756 | if(!src || src == Py_None) |  | 53708 | if(!src || src == Py_None)
| 53757 | return true; |  | 53709 | return true;
| 53758 | Ptr<cv::dpm::DPMDetector::ObjectDetection> * dst_; |  | 53710 | Ptr<cv::dpm::DPMDetector::ObjectDetection> * dst_;
| 53759 | if (pyopencv_dpm_DPMDetector_ObjectDetection_getp(src, dst_)) |  | 53711 | if (pyopencv_dpm_DPMDetector_ObjectDetection_getp(src, dst_))
| 53760 | { |  | 53712 | {
| 53761 | dst = *dst_; |  | 53713 | dst = *dst_;
| 53762 | return true; |  | 53714 | return true;
| 53763 | } |  | 53715 | }
| 53764 |  |  | 53716 |
| 53765 | failmsg("Expected Ptr<cv::dpm::DPMDetector::ObjectDetection> for argument '%s'", info.name); |  | 53717 | failmsg("Expected Ptr<cv::dpm::DPMDetector::ObjectDetection> for argument '%s'", info.name);
| 53766 | return false; |  | 53718 | return false;
| 53767 | } |  | 53719 | }
| 53768 | }; |  | 53720 | };
| 53769 |  |  | 53721 |
| 53770 | //================================================================================ |  | 53722 | //================================================================================
| 53771 | // dynafu_DynaFu (Generic) |  | 53723 | // dynafu_DynaFu (Generic)
| 53772 | //================================================================================ |  | 53724 | //================================================================================
| 53773 |  |  | 53725 |
| 53774 | // GetSet (dynafu_DynaFu) |  | 53726 | // GetSet (dynafu_DynaFu)
| 53775 |  |  | 53727 |
| 53776 |  |  | 53728 |
| 53777 |  |  | 53729 |
| 53778 | // Methods (dynafu_DynaFu) |  | 53730 | // Methods (dynafu_DynaFu)
| 53779 |  |  | 53731 |
| 53780 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53732 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 53781 | { |  | 53733 | {
| 53782 | using namespace cv::dynafu; |  | 53734 | using namespace cv::dynafu;
| 53783 |  |  | 53735 |
| 53784 | PyObject* pyobj__params = NULL; |  | 53736 | PyObject* pyobj__params = NULL;
| 53785 | Ptr<kinfu::Params> _params; |  | 53737 | Ptr<kinfu::Params> _params;
| 53786 | Ptr<DynaFu> retval; |  | 53738 | Ptr<DynaFu> retval;
| 53787 |  |  | 53739 |
| 53788 | const char* keywords[] = { "_params", NULL }; |  | 53740 | const char* keywords[] = { "_params", NULL };
| 53789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dynafu_DynaFu.create", (char**)keywords, &pyobj__params) && |  | 53741 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dynafu_DynaFu.create", (char**)keywords, &pyobj__params) &&
| 53790 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) ) |  | 53742 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) )
| 53791 | { |  | 53743 | {
| 53792 | ERRWRAP2(retval = cv::dynafu::DynaFu::create(_params)); |  | 53744 | ERRWRAP2(retval = cv::dynafu::DynaFu::create(_params));
| 53793 | return pyopencv_from(retval); |  | 53745 | return pyopencv_from(retval);
| 53794 | } |  | 53746 | }
| 53795 |  |  | 53747 |
| 53796 | return NULL; |  | 53748 | return NULL;
| 53797 | } |  | 53749 | }
| 53798 |  |  | 53750 |
| 53799 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53751 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw)
| 53800 | { |  | 53752 | {
| 53801 | using namespace cv::dynafu; |  | 53753 | using namespace cv::dynafu;
| 53802 |  |  | 53754 |
| 53803 |  |  | 53755 |
| 53804 | Ptr<cv::dynafu::DynaFu> * self1 = 0; |  | 53756 | Ptr<cv::dynafu::DynaFu> * self1 = 0;
| 53805 | if (!pyopencv_dynafu_DynaFu_getp(self, self1)) |  | 53757 | if (!pyopencv_dynafu_DynaFu_getp(self, self1))
| 53806 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)"); |  | 53758 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)");
| 53807 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1); |  | 53759 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1);
| 53808 | pyPrepareArgumentConversionErrorsStorage(2); |  | 53760 | pyPrepareArgumentConversionErrorsStorage(2);
| 53809 |  |  | 53761 |
| 53810 | { |  | 53762 | {
| 53811 | PyObject* pyobj_points = NULL; |  | 53763 | PyObject* pyobj_points = NULL;
| 53812 | Mat points; |  | 53764 | Mat points;
| 53813 | PyObject* pyobj_normals = NULL; |  | 53765 | PyObject* pyobj_normals = NULL;
| 53814 | Mat normals; |  | 53766 | Mat normals;
| 53815 |  |  | 53767 |
| 53816 | const char* keywords[] = { "points", "normals", NULL }; |  | 53768 | const char* keywords[] = { "points", "normals", NULL };
| 53817 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 53769 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 53818 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 53770 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 53819 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 53771 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 53820 | { |  | 53772 | {
| 53821 | ERRWRAP2(_self_->getCloud(points, normals)); |  | 53773 | ERRWRAP2(_self_->getCloud(points, normals));
| 53822 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals)); |  | 53774 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals));
| 53823 | } |  | 53775 | }
| 53824 |  |  | 53776 |
| 53825 |  |  | 53777 |
| 53826 | pyPopulateArgumentConversionErrors(); |  | 53778 | pyPopulateArgumentConversionErrors();
| 53827 | } |  | 53779 | }
| 53828 |  |  | 53780 |
| 53829 |  |  | 53781 |
| 53830 | { |  | 53782 | {
| 53831 | PyObject* pyobj_points = NULL; |  | 53783 | PyObject* pyobj_points = NULL;
| 53832 | UMat points; |  | 53784 | UMat points;
| 53833 | PyObject* pyobj_normals = NULL; |  | 53785 | PyObject* pyobj_normals = NULL;
| 53834 | UMat normals; |  | 53786 | UMat normals;
| 53835 |  |  | 53787 |
| 53836 | const char* keywords[] = { "points", "normals", NULL }; |  | 53788 | const char* keywords[] = { "points", "normals", NULL };
| 53837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 53789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 53838 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 53790 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 53839 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 53791 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 53840 | { |  | 53792 | {
| 53841 | ERRWRAP2(_self_->getCloud(points, normals)); |  | 53793 | ERRWRAP2(_self_->getCloud(points, normals));
| 53842 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals)); |  | 53794 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals));
| 53843 | } |  | 53795 | }
| 53844 |  |  | 53796 |
| 53845 |  |  | 53797 |
| 53846 | pyPopulateArgumentConversionErrors(); |  | 53798 | pyPopulateArgumentConversionErrors();
| 53847 | } |  | 53799 | }
| 53848 | pyRaiseCVOverloadException("getCloud"); |  | 53800 | pyRaiseCVOverloadException("getCloud");
| 53849 |  |  | 53801 |
| 53850 | return NULL; |  | 53802 | return NULL;
| 53851 | } |  | 53803 | }
| 53852 |  |  | 53804 |
| 53853 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53805 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw)
| 53854 | { |  | 53806 | {
| 53855 | using namespace cv::dynafu; |  | 53807 | using namespace cv::dynafu;
| 53856 |  |  | 53808 |
| 53857 |  |  | 53809 |
| 53858 | Ptr<cv::dynafu::DynaFu> * self1 = 0; |  | 53810 | Ptr<cv::dynafu::DynaFu> * self1 = 0;
| 53859 | if (!pyopencv_dynafu_DynaFu_getp(self, self1)) |  | 53811 | if (!pyopencv_dynafu_DynaFu_getp(self, self1))
| 53860 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)"); |  | 53812 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)");
| 53861 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1); |  | 53813 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1);
| 53862 | pyPrepareArgumentConversionErrorsStorage(2); |  | 53814 | pyPrepareArgumentConversionErrorsStorage(2);
| 53863 |  |  | 53815 |
| 53864 | { |  | 53816 | {
| 53865 | PyObject* pyobj_points = NULL; |  | 53817 | PyObject* pyobj_points = NULL;
| 53866 | Mat points; |  | 53818 | Mat points;
| 53867 | PyObject* pyobj_normals = NULL; |  | 53819 | PyObject* pyobj_normals = NULL;
| 53868 | Mat normals; |  | 53820 | Mat normals;
| 53869 |  |  | 53821 |
| 53870 | const char* keywords[] = { "points", "normals", NULL }; |  | 53822 | const char* keywords[] = { "points", "normals", NULL };
| 53871 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dynafu_DynaFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 53823 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dynafu_DynaFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 53872 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 53824 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 53873 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 53825 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 53874 | { |  | 53826 | {
| 53875 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 53827 | ERRWRAP2(_self_->getNormals(points, normals));
| 53876 | return pyopencv_from(normals); |  | 53828 | return pyopencv_from(normals);
| 53877 | } |  | 53829 | }
| 53878 |  |  | 53830 |
| 53879 |  |  | 53831 |
| 53880 | pyPopulateArgumentConversionErrors(); |  | 53832 | pyPopulateArgumentConversionErrors();
| 53881 | } |  | 53833 | }
| 53882 |  |  | 53834 |
| 53883 |  |  | 53835 |
| 53884 | { |  | 53836 | {
| 53885 | PyObject* pyobj_points = NULL; |  | 53837 | PyObject* pyobj_points = NULL;
| 53886 | UMat points; |  | 53838 | UMat points;
| 53887 | PyObject* pyobj_normals = NULL; |  | 53839 | PyObject* pyobj_normals = NULL;
| 53888 | UMat normals; |  | 53840 | UMat normals;
| 53889 |  |  | 53841 |
| 53890 | const char* keywords[] = { "points", "normals", NULL }; |  | 53842 | const char* keywords[] = { "points", "normals", NULL };
| 53891 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dynafu_DynaFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 53843 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:dynafu_DynaFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 53892 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 53844 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 53893 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 53845 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 53894 | { |  | 53846 | {
| 53895 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 53847 | ERRWRAP2(_self_->getNormals(points, normals));
| 53896 | return pyopencv_from(normals); |  | 53848 | return pyopencv_from(normals);
| 53897 | } |  | 53849 | }
| 53898 |  |  | 53850 |
| 53899 |  |  | 53851 |
| 53900 | pyPopulateArgumentConversionErrors(); |  | 53852 | pyPopulateArgumentConversionErrors();
| 53901 | } |  | 53853 | }
| 53902 | pyRaiseCVOverloadException("getNormals"); |  | 53854 | pyRaiseCVOverloadException("getNormals");
| 53903 |  |  | 53855 |
| 53904 | return NULL; |  | 53856 | return NULL;
| 53905 | } |  | 53857 | }
| 53906 |  |  | 53858 |
| 53907 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53859 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 53908 | { |  | 53860 | {
| 53909 | using namespace cv::dynafu; |  | 53861 | using namespace cv::dynafu;
| 53910 |  |  | 53862 |
| 53911 |  |  | 53863 |
| 53912 | Ptr<cv::dynafu::DynaFu> * self1 = 0; |  | 53864 | Ptr<cv::dynafu::DynaFu> * self1 = 0;
| 53913 | if (!pyopencv_dynafu_DynaFu_getp(self, self1)) |  | 53865 | if (!pyopencv_dynafu_DynaFu_getp(self, self1))
| 53914 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)"); |  | 53866 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)");
| 53915 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1); |  | 53867 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1);
| 53916 | pyPrepareArgumentConversionErrorsStorage(2); |  | 53868 | pyPrepareArgumentConversionErrorsStorage(2);
| 53917 |  |  | 53869 |
| 53918 | { |  | 53870 | {
| 53919 | PyObject* pyobj_points = NULL; |  | 53871 | PyObject* pyobj_points = NULL;
| 53920 | Mat points; |  | 53872 | Mat points;
| 53921 |  |  | 53873 |
| 53922 | const char* keywords[] = { "points", NULL }; |  | 53874 | const char* keywords[] = { "points", NULL };
| 53923 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dynafu_DynaFu.getPoints", (char**)keywords, &pyobj_points) && |  | 53875 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dynafu_DynaFu.getPoints", (char**)keywords, &pyobj_points) &&
| 53924 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 53876 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 53925 | { |  | 53877 | {
| 53926 | ERRWRAP2(_self_->getPoints(points)); |  | 53878 | ERRWRAP2(_self_->getPoints(points));
| 53927 | return pyopencv_from(points); |  | 53879 | return pyopencv_from(points);
| 53928 | } |  | 53880 | }
| 53929 |  |  | 53881 |
| 53930 |  |  | 53882 |
| 53931 | pyPopulateArgumentConversionErrors(); |  | 53883 | pyPopulateArgumentConversionErrors();
| 53932 | } |  | 53884 | }
| 53933 |  |  | 53885 |
| 53934 |  |  | 53886 |
| 53935 | { |  | 53887 | {
| 53936 | PyObject* pyobj_points = NULL; |  | 53888 | PyObject* pyobj_points = NULL;
| 53937 | UMat points; |  | 53889 | UMat points;
| 53938 |  |  | 53890 |
| 53939 | const char* keywords[] = { "points", NULL }; |  | 53891 | const char* keywords[] = { "points", NULL };
| 53940 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dynafu_DynaFu.getPoints", (char**)keywords, &pyobj_points) && |  | 53892 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:dynafu_DynaFu.getPoints", (char**)keywords, &pyobj_points) &&
| 53941 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 53893 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 53942 | { |  | 53894 | {
| 53943 | ERRWRAP2(_self_->getPoints(points)); |  | 53895 | ERRWRAP2(_self_->getPoints(points));
| 53944 | return pyopencv_from(points); |  | 53896 | return pyopencv_from(points);
| 53945 | } |  | 53897 | }
| 53946 |  |  | 53898 |
| 53947 |  |  | 53899 |
| 53948 | pyPopulateArgumentConversionErrors(); |  | 53900 | pyPopulateArgumentConversionErrors();
| 53949 | } |  | 53901 | }
| 53950 | pyRaiseCVOverloadException("getPoints"); |  | 53902 | pyRaiseCVOverloadException("getPoints");
| 53951 |  |  | 53903 |
| 53952 | return NULL; |  | 53904 | return NULL;
| 53953 | } |  | 53905 | }
| 53954 |  |  | 53906 |
| 53955 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_render(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53907 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_render(PyObject* self, PyObject* py_args, PyObject* kw)
| 53956 | { |  | 53908 | {
| 53957 | using namespace cv::dynafu; |  | 53909 | using namespace cv::dynafu;
| 53958 |  |  | 53910 |
| 53959 |  |  | 53911 |
| 53960 | Ptr<cv::dynafu::DynaFu> * self1 = 0; |  | 53912 | Ptr<cv::dynafu::DynaFu> * self1 = 0;
| 53961 | if (!pyopencv_dynafu_DynaFu_getp(self, self1)) |  | 53913 | if (!pyopencv_dynafu_DynaFu_getp(self, self1))
| 53962 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)"); |  | 53914 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)");
| 53963 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1); |  | 53915 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1);
| 53964 | pyPrepareArgumentConversionErrorsStorage(2); |  | 53916 | pyPrepareArgumentConversionErrorsStorage(2);
| 53965 |  |  | 53917 |
| 53966 | { |  | 53918 | {
| 53967 | PyObject* pyobj_image = NULL; |  | 53919 | PyObject* pyobj_image = NULL;
| 53968 | Mat image; |  | 53920 | Mat image;
| 53969 | PyObject* pyobj_cameraPose = NULL; |  | 53921 | PyObject* pyobj_cameraPose = NULL;
| 53970 | Matx44f cameraPose=Matx44f::eye(); |  | 53922 | Matx44f cameraPose=Matx44f::eye();
| 53971 |  |  | 53923 |
| 53972 | const char* keywords[] = { "image", "cameraPose", NULL }; |  | 53924 | const char* keywords[] = { "image", "cameraPose", NULL };
| 53973 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.render", (char**)keywords, &pyobj_image, &pyobj_cameraPose) && |  | 53925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.render", (char**)keywords, &pyobj_image, &pyobj_cameraPose) &&
| 53974 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 53926 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 53975 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 53927 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 53976 | { |  | 53928 | {
| 53977 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 53929 | ERRWRAP2(_self_->render(image, cameraPose));
| 53978 | return pyopencv_from(image); |  | 53930 | return pyopencv_from(image);
| 53979 | } |  | 53931 | }
| 53980 |  |  | 53932 |
| 53981 |  |  | 53933 |
| 53982 | pyPopulateArgumentConversionErrors(); |  | 53934 | pyPopulateArgumentConversionErrors();
| 53983 | } |  | 53935 | }
| 53984 |  |  | 53936 |
| 53985 |  |  | 53937 |
| 53986 | { |  | 53938 | {
| 53987 | PyObject* pyobj_image = NULL; |  | 53939 | PyObject* pyobj_image = NULL;
| 53988 | UMat image; |  | 53940 | UMat image;
| 53989 | PyObject* pyobj_cameraPose = NULL; |  | 53941 | PyObject* pyobj_cameraPose = NULL;
| 53990 | Matx44f cameraPose=Matx44f::eye(); |  | 53942 | Matx44f cameraPose=Matx44f::eye();
| 53991 |  |  | 53943 |
| 53992 | const char* keywords[] = { "image", "cameraPose", NULL }; |  | 53944 | const char* keywords[] = { "image", "cameraPose", NULL };
| 53993 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.render", (char**)keywords, &pyobj_image, &pyobj_cameraPose) && |  | 53945 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:dynafu_DynaFu.render", (char**)keywords, &pyobj_image, &pyobj_cameraPose) &&
| 53994 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 53946 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 53995 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 53947 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 53996 | { |  | 53948 | {
| 53997 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 53949 | ERRWRAP2(_self_->render(image, cameraPose));
| 53998 | return pyopencv_from(image); |  | 53950 | return pyopencv_from(image);
| 53999 | } |  | 53951 | }
| 54000 |  |  | 53952 |
| 54001 |  |  | 53953 |
| 54002 | pyPopulateArgumentConversionErrors(); |  | 53954 | pyPopulateArgumentConversionErrors();
| 54003 | } |  | 53955 | }
| 54004 | pyRaiseCVOverloadException("render"); |  | 53956 | pyRaiseCVOverloadException("render");
| 54005 |  |  | 53957 |
| 54006 | return NULL; |  | 53958 | return NULL;
| 54007 | } |  | 53959 | }
| 54008 |  |  | 53960 |
| 54009 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_reset(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53961 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_reset(PyObject* self, PyObject* py_args, PyObject* kw)
| 54010 | { |  | 53962 | {
| 54011 | using namespace cv::dynafu; |  | 53963 | using namespace cv::dynafu;
| 54012 |  |  | 53964 |
| 54013 |  |  | 53965 |
| 54014 | Ptr<cv::dynafu::DynaFu> * self1 = 0; |  | 53966 | Ptr<cv::dynafu::DynaFu> * self1 = 0;
| 54015 | if (!pyopencv_dynafu_DynaFu_getp(self, self1)) |  | 53967 | if (!pyopencv_dynafu_DynaFu_getp(self, self1))
| 54016 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)"); |  | 53968 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)");
| 54017 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1); |  | 53969 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1);
| 54018 |  |  | 53970 |
| 54019 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 53971 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54020 | { |  | 53972 | {
| 54021 | ERRWRAP2(_self_->reset()); |  | 53973 | ERRWRAP2(_self_->reset());
| 54022 | Py_RETURN_NONE; |  | 53974 | Py_RETURN_NONE;
| 54023 | } |  | 53975 | }
| 54024 |  |  | 53976 |
| 54025 | return NULL; |  | 53977 | return NULL;
| 54026 | } |  | 53978 | }
| 54027 |  |  | 53979 |
| 54028 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 53980 | static PyObject* pyopencv_cv_dynafu_dynafu_DynaFu_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 54029 | { |  | 53981 | {
| 54030 | using namespace cv::dynafu; |  | 53982 | using namespace cv::dynafu;
| 54031 |  |  | 53983 |
| 54032 |  |  | 53984 |
| 54033 | Ptr<cv::dynafu::DynaFu> * self1 = 0; |  | 53985 | Ptr<cv::dynafu::DynaFu> * self1 = 0;
| 54034 | if (!pyopencv_dynafu_DynaFu_getp(self, self1)) |  | 53986 | if (!pyopencv_dynafu_DynaFu_getp(self, self1))
| 54035 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)"); |  | 53987 | return failmsgp("Incorrect type of self (must be 'dynafu_DynaFu' or its derivative)");
| 54036 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1); |  | 53988 | Ptr<cv::dynafu::DynaFu> _self_ = *(self1);
| 54037 | pyPrepareArgumentConversionErrorsStorage(2); |  | 53989 | pyPrepareArgumentConversionErrorsStorage(2);
| 54038 |  |  | 53990 |
| 54039 | { |  | 53991 | {
| 54040 | PyObject* pyobj_depth = NULL; |  | 53992 | PyObject* pyobj_depth = NULL;
| 54041 | Mat depth; |  | 53993 | Mat depth;
| 54042 | bool retval; |  | 53994 | bool retval;
| 54043 |  |  | 53995 |
| 54044 | const char* keywords[] = { "depth", NULL }; |  | 53996 | const char* keywords[] = { "depth", NULL };
| 54045 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dynafu_DynaFu.update", (char**)keywords, &pyobj_depth) && |  | 53997 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dynafu_DynaFu.update", (char**)keywords, &pyobj_depth) &&
| 54046 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) ) |  | 53998 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) )
| 54047 | { |  | 53999 | {
| 54048 | ERRWRAP2(retval = _self_->update(depth)); |  | 54000 | ERRWRAP2(retval = _self_->update(depth));
| 54049 | return pyopencv_from(retval); |  | 54001 | return pyopencv_from(retval);
| 54050 | } |  | 54002 | }
| 54051 |  |  | 54003 |
| 54052 |  |  | 54004 |
| 54053 | pyPopulateArgumentConversionErrors(); |  | 54005 | pyPopulateArgumentConversionErrors();
| 54054 | } |  | 54006 | }
| 54055 |  |  | 54007 |
| 54056 |  |  | 54008 |
| 54057 | { |  | 54009 | {
| 54058 | PyObject* pyobj_depth = NULL; |  | 54010 | PyObject* pyobj_depth = NULL;
| 54059 | UMat depth; |  | 54011 | UMat depth;
| 54060 | bool retval; |  | 54012 | bool retval;
| 54061 |  |  | 54013 |
| 54062 | const char* keywords[] = { "depth", NULL }; |  | 54014 | const char* keywords[] = { "depth", NULL };
| 54063 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dynafu_DynaFu.update", (char**)keywords, &pyobj_depth) && |  | 54015 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:dynafu_DynaFu.update", (char**)keywords, &pyobj_depth) &&
| 54064 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) ) |  | 54016 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) )
| 54065 | { |  | 54017 | {
| 54066 | ERRWRAP2(retval = _self_->update(depth)); |  | 54018 | ERRWRAP2(retval = _self_->update(depth));
| 54067 | return pyopencv_from(retval); |  | 54019 | return pyopencv_from(retval);
| 54068 | } |  | 54020 | }
| 54069 |  |  | 54021 |
| 54070 |  |  | 54022 |
| 54071 | pyPopulateArgumentConversionErrors(); |  | 54023 | pyPopulateArgumentConversionErrors();
| 54072 | } |  | 54024 | }
| 54073 | pyRaiseCVOverloadException("update"); |  | 54025 | pyRaiseCVOverloadException("update");
| 54074 |  |  | 54026 |
| 54075 | return NULL; |  | 54027 | return NULL;
| 54076 | } |  | 54028 | }
| 54077 |  |  | 54029 |
| 54078 |  |  | 54030 |
| 54079 |  |  | 54031 |
| 54080 | // Tables (dynafu_DynaFu) |  | 54032 | // Tables (dynafu_DynaFu)
| 54081 |  |  | 54033 |
| 54082 | static PyGetSetDef pyopencv_dynafu_DynaFu_getseters[] = |  | 54034 | static PyGetSetDef pyopencv_dynafu_DynaFu_getseters[] =
| 54083 | { |  | 54035 | {
| 54084 | {NULL} /* Sentinel */ |  | 54036 | {NULL} /* Sentinel */
| 54085 | }; |  | 54037 | };
| 54086 |  |  | 54038 |
| 54087 | static PyMethodDef pyopencv_dynafu_DynaFu_methods[] = |  | 54039 | static PyMethodDef pyopencv_dynafu_DynaFu_methods[] =
| 54088 | { |  | 54040 | {
| 54089 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_create_static, METH_STATIC), "create(_params) -> retval\n."}, |  | 54041 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_create_static, METH_STATIC), "create(_params) -> retval\n."},
| 54090 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_getCloud, 0), "getCloud([, points[, normals]]) -> points, normals\n. @brief Gets points and normals of current 3d mesh\n. \n. The order of normals corresponds to order of points.\n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors\n. @param normals vector of normals which are 4-float vectors"}, |  | 54042 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_getCloud, 0), "getCloud([, points[, normals]]) -> points, normals\n. @brief Gets points and normals of current 3d mesh\n. \n. The order of normals corresponds to order of points.\n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors\n. @param normals vector of normals which are 4-float vectors"},
| 54091 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_getNormals, 0), "getNormals(points[, normals]) -> normals\n. @brief Calculates normals for given points\n. @param points input vector of points which are 4-float vectors\n. @param normals output vector of corresponding normals which are 4-float vectors"}, |  | 54043 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_getNormals, 0), "getNormals(points[, normals]) -> normals\n. @brief Calculates normals for given points\n. @param points input vector of points which are 4-float vectors\n. @param normals output vector of corresponding normals which are 4-float vectors"},
| 54092 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_getPoints, 0), "getPoints([, points]) -> points\n. @brief Gets points of current 3d mesh\n. \n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors"}, |  | 54044 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_getPoints, 0), "getPoints([, points]) -> points\n. @brief Gets points of current 3d mesh\n. \n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors"},
| 54093 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_render, 0), "render([, image[, cameraPose]]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in DynaFu params.\n. \n. @param image resulting image\n. @param cameraPose pose of camera to render from. If empty then render from current pose\n. which is a last frame camera pose."}, |  | 54045 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_render, 0), "render([, image[, cameraPose]]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in DynaFu params.\n. \n. @param image resulting image\n. @param cameraPose pose of camera to render from. If empty then render from current pose\n. which is a last frame camera pose."},
| 54094 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_reset, 0), "reset() -> None\n. @brief Resets the algorithm\n. \n. Clears current model and resets a pose."}, |  | 54046 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_reset, 0), "reset() -> None\n. @brief Resets the algorithm\n. \n. Clears current model and resets a pose."},
| 54095 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_update, 0), "update(depth) -> retval\n. @brief Process next depth frame\n. \n. Integrates depth into voxel space with respect to its ICP-calculated pose.\n. Input image is converted to CV_32F internally if has another type.\n. \n. @param depth one-channel image which size and depth scale is described in algorithm's parameters\n. @return true if succeeded to align new frame with current scene, false if opposite"}, |  | 54047 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_dynafu_dynafu_DynaFu_update, 0), "update(depth) -> retval\n. @brief Process next depth frame\n. \n. Integrates depth into voxel space with respect to its ICP-calculated pose.\n. Input image is converted to CV_32F internally if has another type.\n. \n. @param depth one-channel image which size and depth scale is described in algorithm's parameters\n. @return true if succeeded to align new frame with current scene, false if opposite"},
| 54096 |  |  | 54048 |
| 54097 | {NULL, NULL} |  | 54049 | {NULL, NULL}
| 54098 | }; |  | 54050 | };
| 54099 |  |  | 54051 |
| 54100 | // Converter (dynafu_DynaFu) |  | 54052 | // Converter (dynafu_DynaFu)
| 54101 |  |  | 54053 |
| 54102 | template<> |  | 54054 | template<>
| 54103 | struct PyOpenCV_Converter< Ptr<cv::dynafu::DynaFu> > |  | 54055 | struct PyOpenCV_Converter< Ptr<cv::dynafu::DynaFu> >
| 54104 | { |  | 54056 | {
| 54105 | static PyObject* from(const Ptr<cv::dynafu::DynaFu>& r) |  | 54057 | static PyObject* from(const Ptr<cv::dynafu::DynaFu>& r)
| 54106 | { |  | 54058 | {
| 54107 | return pyopencv_dynafu_DynaFu_Instance(r); |  | 54059 | return pyopencv_dynafu_DynaFu_Instance(r);
| 54108 | } |  | 54060 | }
| 54109 | static bool to(PyObject* src, Ptr<cv::dynafu::DynaFu>& dst, const ArgInfo& info) |  | 54061 | static bool to(PyObject* src, Ptr<cv::dynafu::DynaFu>& dst, const ArgInfo& info)
| 54110 | { |  | 54062 | {
| 54111 | if(!src || src == Py_None) |  | 54063 | if(!src || src == Py_None)
| 54112 | return true; |  | 54064 | return true;
| 54113 | Ptr<cv::dynafu::DynaFu> * dst_; |  | 54065 | Ptr<cv::dynafu::DynaFu> * dst_;
| 54114 | if (pyopencv_dynafu_DynaFu_getp(src, dst_)) |  | 54066 | if (pyopencv_dynafu_DynaFu_getp(src, dst_))
| 54115 | { |  | 54067 | {
| 54116 | dst = *dst_; |  | 54068 | dst = *dst_;
| 54117 | return true; |  | 54069 | return true;
| 54118 | } |  | 54070 | }
| 54119 |  |  | 54071 |
| 54120 | failmsg("Expected Ptr<cv::dynafu::DynaFu> for argument '%s'", info.name); |  | 54072 | failmsg("Expected Ptr<cv::dynafu::DynaFu> for argument '%s'", info.name);
| 54121 | return false; |  | 54073 | return false;
| 54122 | } |  | 54074 | }
| 54123 | }; |  | 54075 | };
| 54124 |  |  | 54076 |
| 54125 | //================================================================================ |  | 54077 | //================================================================================
| 54126 | // face_BIF (Generic) |  | 54078 | // face_BIF (Generic)
| 54127 | //================================================================================ |  | 54079 | //================================================================================
| 54128 |  |  | 54080 |
| 54129 | // GetSet (face_BIF) |  | 54081 | // GetSet (face_BIF)
| 54130 |  |  | 54082 |
| 54131 |  |  | 54083 |
| 54132 |  |  | 54084 |
| 54133 | // Methods (face_BIF) |  | 54085 | // Methods (face_BIF)
| 54134 |  |  | 54086 |
| 54135 | static PyObject* pyopencv_cv_face_face_BIF_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54087 | static PyObject* pyopencv_cv_face_face_BIF_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 54136 | { |  | 54088 | {
| 54137 | using namespace cv::face; |  | 54089 | using namespace cv::face;
| 54138 |  |  | 54090 |
| 54139 |  |  | 54091 |
| 54140 | Ptr<cv::face::BIF> * self1 = 0; |  | 54092 | Ptr<cv::face::BIF> * self1 = 0;
| 54141 | if (!pyopencv_face_BIF_getp(self, self1)) |  | 54093 | if (!pyopencv_face_BIF_getp(self, self1))
| 54142 | return failmsgp("Incorrect type of self (must be 'face_BIF' or its derivative)"); |  | 54094 | return failmsgp("Incorrect type of self (must be 'face_BIF' or its derivative)");
| 54143 | Ptr<cv::face::BIF> _self_ = *(self1); |  | 54095 | Ptr<cv::face::BIF> _self_ = *(self1);
| 54144 | pyPrepareArgumentConversionErrorsStorage(2); |  | 54096 | pyPrepareArgumentConversionErrorsStorage(2);
| 54145 |  |  | 54097 |
| 54146 | { |  | 54098 | {
| 54147 | PyObject* pyobj_image = NULL; |  | 54099 | PyObject* pyobj_image = NULL;
| 54148 | Mat image; |  | 54100 | Mat image;
| 54149 | PyObject* pyobj_features = NULL; |  | 54101 | PyObject* pyobj_features = NULL;
| 54150 | Mat features; |  | 54102 | Mat features;
| 54151 |  |  | 54103 |
| 54152 | const char* keywords[] = { "image", "features", NULL }; |  | 54104 | const char* keywords[] = { "image", "features", NULL };
| 54153 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:face_BIF.compute", (char**)keywords, &pyobj_image, &pyobj_features) && |  | 54105 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:face_BIF.compute", (char**)keywords, &pyobj_image, &pyobj_features) &&
| 54154 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 54106 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 54155 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) ) |  | 54107 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) )
| 54156 | { |  | 54108 | {
| 54157 | ERRWRAP2(_self_->compute(image, features)); |  | 54109 | ERRWRAP2(_self_->compute(image, features));
| 54158 | return pyopencv_from(features); |  | 54110 | return pyopencv_from(features);
| 54159 | } |  | 54111 | }
| 54160 |  |  | 54112 |
| 54161 |  |  | 54113 |
| 54162 | pyPopulateArgumentConversionErrors(); |  | 54114 | pyPopulateArgumentConversionErrors();
| 54163 | } |  | 54115 | }
| 54164 |  |  | 54116 |
| 54165 |  |  | 54117 |
| 54166 | { |  | 54118 | {
| 54167 | PyObject* pyobj_image = NULL; |  | 54119 | PyObject* pyobj_image = NULL;
| 54168 | UMat image; |  | 54120 | UMat image;
| 54169 | PyObject* pyobj_features = NULL; |  | 54121 | PyObject* pyobj_features = NULL;
| 54170 | UMat features; |  | 54122 | UMat features;
| 54171 |  |  | 54123 |
| 54172 | const char* keywords[] = { "image", "features", NULL }; |  | 54124 | const char* keywords[] = { "image", "features", NULL };
| 54173 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:face_BIF.compute", (char**)keywords, &pyobj_image, &pyobj_features) && |  | 54125 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:face_BIF.compute", (char**)keywords, &pyobj_image, &pyobj_features) &&
| 54174 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 54126 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 54175 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) ) |  | 54127 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) )
| 54176 | { |  | 54128 | {
| 54177 | ERRWRAP2(_self_->compute(image, features)); |  | 54129 | ERRWRAP2(_self_->compute(image, features));
| 54178 | return pyopencv_from(features); |  | 54130 | return pyopencv_from(features);
| 54179 | } |  | 54131 | }
| 54180 |  |  | 54132 |
| 54181 |  |  | 54133 |
| 54182 | pyPopulateArgumentConversionErrors(); |  | 54134 | pyPopulateArgumentConversionErrors();
| 54183 | } |  | 54135 | }
| 54184 | pyRaiseCVOverloadException("compute"); |  | 54136 | pyRaiseCVOverloadException("compute");
| 54185 |  |  | 54137 |
| 54186 | return NULL; |  | 54138 | return NULL;
| 54187 | } |  | 54139 | }
| 54188 |  |  | 54140 |
| 54189 | static PyObject* pyopencv_cv_face_face_BIF_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54141 | static PyObject* pyopencv_cv_face_face_BIF_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 54190 | { |  | 54142 | {
| 54191 | using namespace cv::face; |  | 54143 | using namespace cv::face;
| 54192 |  |  | 54144 |
| 54193 | PyObject* pyobj_num_bands = NULL; |  | 54145 | PyObject* pyobj_num_bands = NULL;
| 54194 | int num_bands=8; |  | 54146 | int num_bands=8;
| 54195 | PyObject* pyobj_num_rotations = NULL; |  | 54147 | PyObject* pyobj_num_rotations = NULL;
| 54196 | int num_rotations=12; |  | 54148 | int num_rotations=12;
| 54197 | Ptr<BIF> retval; |  | 54149 | Ptr<BIF> retval;
| 54198 |  |  | 54150 |
| 54199 | const char* keywords[] = { "num_bands", "num_rotations", NULL }; |  | 54151 | const char* keywords[] = { "num_bands", "num_rotations", NULL };
| 54200 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:face_BIF.create", (char**)keywords, &pyobj_num_bands, &pyobj_num_rotations) && |  | 54152 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:face_BIF.create", (char**)keywords, &pyobj_num_bands, &pyobj_num_rotations) &&
| 54201 | pyopencv_to_safe(pyobj_num_bands, num_bands, ArgInfo("num_bands", 0)) && |  | 54153 | pyopencv_to_safe(pyobj_num_bands, num_bands, ArgInfo("num_bands", 0)) &&
| 54202 | pyopencv_to_safe(pyobj_num_rotations, num_rotations, ArgInfo("num_rotations", 0)) ) |  | 54154 | pyopencv_to_safe(pyobj_num_rotations, num_rotations, ArgInfo("num_rotations", 0)) )
| 54203 | { |  | 54155 | {
| 54204 | ERRWRAP2(retval = cv::face::BIF::create(num_bands, num_rotations)); |  | 54156 | ERRWRAP2(retval = cv::face::BIF::create(num_bands, num_rotations));
| 54205 | return pyopencv_from(retval); |  | 54157 | return pyopencv_from(retval);
| 54206 | } |  | 54158 | }
| 54207 |  |  | 54159 |
| 54208 | return NULL; |  | 54160 | return NULL;
| 54209 | } |  | 54161 | }
| 54210 |  |  | 54162 |
| 54211 | static PyObject* pyopencv_cv_face_face_BIF_getNumBands(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54163 | static PyObject* pyopencv_cv_face_face_BIF_getNumBands(PyObject* self, PyObject* py_args, PyObject* kw)
| 54212 | { |  | 54164 | {
| 54213 | using namespace cv::face; |  | 54165 | using namespace cv::face;
| 54214 |  |  | 54166 |
| 54215 |  |  | 54167 |
| 54216 | Ptr<cv::face::BIF> * self1 = 0; |  | 54168 | Ptr<cv::face::BIF> * self1 = 0;
| 54217 | if (!pyopencv_face_BIF_getp(self, self1)) |  | 54169 | if (!pyopencv_face_BIF_getp(self, self1))
| 54218 | return failmsgp("Incorrect type of self (must be 'face_BIF' or its derivative)"); |  | 54170 | return failmsgp("Incorrect type of self (must be 'face_BIF' or its derivative)");
| 54219 | Ptr<cv::face::BIF> _self_ = *(self1); |  | 54171 | Ptr<cv::face::BIF> _self_ = *(self1);
| 54220 | int retval; |  | 54172 | int retval;
| 54221 |  |  | 54173 |
| 54222 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54174 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54223 | { |  | 54175 | {
| 54224 | ERRWRAP2(retval = _self_->getNumBands()); |  | 54176 | ERRWRAP2(retval = _self_->getNumBands());
| 54225 | return pyopencv_from(retval); |  | 54177 | return pyopencv_from(retval);
| 54226 | } |  | 54178 | }
| 54227 |  |  | 54179 |
| 54228 | return NULL; |  | 54180 | return NULL;
| 54229 | } |  | 54181 | }
| 54230 |  |  | 54182 |
| 54231 | static PyObject* pyopencv_cv_face_face_BIF_getNumRotations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54183 | static PyObject* pyopencv_cv_face_face_BIF_getNumRotations(PyObject* self, PyObject* py_args, PyObject* kw)
| 54232 | { |  | 54184 | {
| 54233 | using namespace cv::face; |  | 54185 | using namespace cv::face;
| 54234 |  |  | 54186 |
| 54235 |  |  | 54187 |
| 54236 | Ptr<cv::face::BIF> * self1 = 0; |  | 54188 | Ptr<cv::face::BIF> * self1 = 0;
| 54237 | if (!pyopencv_face_BIF_getp(self, self1)) |  | 54189 | if (!pyopencv_face_BIF_getp(self, self1))
| 54238 | return failmsgp("Incorrect type of self (must be 'face_BIF' or its derivative)"); |  | 54190 | return failmsgp("Incorrect type of self (must be 'face_BIF' or its derivative)");
| 54239 | Ptr<cv::face::BIF> _self_ = *(self1); |  | 54191 | Ptr<cv::face::BIF> _self_ = *(self1);
| 54240 | int retval; |  | 54192 | int retval;
| 54241 |  |  | 54193 |
| 54242 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54194 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54243 | { |  | 54195 | {
| 54244 | ERRWRAP2(retval = _self_->getNumRotations()); |  | 54196 | ERRWRAP2(retval = _self_->getNumRotations());
| 54245 | return pyopencv_from(retval); |  | 54197 | return pyopencv_from(retval);
| 54246 | } |  | 54198 | }
| 54247 |  |  | 54199 |
| 54248 | return NULL; |  | 54200 | return NULL;
| 54249 | } |  | 54201 | }
| 54250 |  |  | 54202 |
| 54251 |  |  | 54203 |
| 54252 |  |  | 54204 |
| 54253 | // Tables (face_BIF) |  | 54205 | // Tables (face_BIF)
| 54254 |  |  | 54206 |
| 54255 | static PyGetSetDef pyopencv_face_BIF_getseters[] = |  | 54207 | static PyGetSetDef pyopencv_face_BIF_getseters[] =
| 54256 | { |  | 54208 | {
| 54257 | {NULL} /* Sentinel */ |  | 54209 | {NULL} /* Sentinel */
| 54258 | }; |  | 54210 | };
| 54259 |  |  | 54211 |
| 54260 | static PyMethodDef pyopencv_face_BIF_methods[] = |  | 54212 | static PyMethodDef pyopencv_face_BIF_methods[] =
| 54261 | { |  | 54213 | {
| 54262 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_compute, 0), "compute(image[, features]) -> features\n. Computes features sby input image.\n. * @param image Input image (CV_32FC1).\n. * @param features Feature vector (CV_32FC1)."}, |  | 54214 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_compute, 0), "compute(image[, features]) -> features\n. Computes features sby input image.\n. * @param image Input image (CV_32FC1).\n. * @param features Feature vector (CV_32FC1)."},
| 54263 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_create_static, METH_STATIC), "create([, num_bands[, num_rotations]]) -> retval\n. * @param num_bands The number of filter bands (<=8) used for computing BIF.\n. * @param num_rotations The number of image rotations for computing BIF.\n. * @returns Object for computing BIF."}, |  | 54215 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_create_static, METH_STATIC), "create([, num_bands[, num_rotations]]) -> retval\n. * @param num_bands The number of filter bands (<=8) used for computing BIF.\n. * @param num_rotations The number of image rotations for computing BIF.\n. * @returns Object for computing BIF."},
| 54264 | {"getNumBands", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_getNumBands, 0), "getNumBands() -> retval\n. @returns The number of filter bands used for computing BIF."}, |  | 54216 | {"getNumBands", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_getNumBands, 0), "getNumBands() -> retval\n. @returns The number of filter bands used for computing BIF."},
| 54265 | {"getNumRotations", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_getNumRotations, 0), "getNumRotations() -> retval\n. @returns The number of image rotations."}, |  | 54217 | {"getNumRotations", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BIF_getNumRotations, 0), "getNumRotations() -> retval\n. @returns The number of image rotations."},
| 54266 |  |  | 54218 |
| 54267 | {NULL, NULL} |  | 54219 | {NULL, NULL}
| 54268 | }; |  | 54220 | };
| 54269 |  |  | 54221 |
| 54270 | // Converter (face_BIF) |  | 54222 | // Converter (face_BIF)
| 54271 |  |  | 54223 |
| 54272 | template<> |  | 54224 | template<>
| 54273 | struct PyOpenCV_Converter< Ptr<cv::face::BIF> > |  | 54225 | struct PyOpenCV_Converter< Ptr<cv::face::BIF> >
| 54274 | { |  | 54226 | {
| 54275 | static PyObject* from(const Ptr<cv::face::BIF>& r) |  | 54227 | static PyObject* from(const Ptr<cv::face::BIF>& r)
| 54276 | { |  | 54228 | {
| 54277 | return pyopencv_face_BIF_Instance(r); |  | 54229 | return pyopencv_face_BIF_Instance(r);
| 54278 | } |  | 54230 | }
| 54279 | static bool to(PyObject* src, Ptr<cv::face::BIF>& dst, const ArgInfo& info) |  | 54231 | static bool to(PyObject* src, Ptr<cv::face::BIF>& dst, const ArgInfo& info)
| 54280 | { |  | 54232 | {
| 54281 | if(!src || src == Py_None) |  | 54233 | if(!src || src == Py_None)
| 54282 | return true; |  | 54234 | return true;
| 54283 | Ptr<cv::face::BIF> * dst_; |  | 54235 | Ptr<cv::face::BIF> * dst_;
| 54284 | if (pyopencv_face_BIF_getp(src, dst_)) |  | 54236 | if (pyopencv_face_BIF_getp(src, dst_))
| 54285 | { |  | 54237 | {
| 54286 | dst = *dst_; |  | 54238 | dst = *dst_;
| 54287 | return true; |  | 54239 | return true;
| 54288 | } |  | 54240 | }
| 54289 |  |  | 54241 |
| 54290 | failmsg("Expected Ptr<cv::face::BIF> for argument '%s'", info.name); |  | 54242 | failmsg("Expected Ptr<cv::face::BIF> for argument '%s'", info.name);
| 54291 | return false; |  | 54243 | return false;
| 54292 | } |  | 54244 | }
| 54293 | }; |  | 54245 | };
| 54294 |  |  | 54246 |
| 54295 | //================================================================================ |  | 54247 | //================================================================================
| 54296 | // face_BasicFaceRecognizer (Generic) |  | 54248 | // face_BasicFaceRecognizer (Generic)
| 54297 | //================================================================================ |  | 54249 | //================================================================================
| 54298 |  |  | 54250 |
| 54299 | // GetSet (face_BasicFaceRecognizer) |  | 54251 | // GetSet (face_BasicFaceRecognizer)
| 54300 |  |  | 54252 |
| 54301 |  |  | 54253 |
| 54302 |  |  | 54254 |
| 54303 | // Methods (face_BasicFaceRecognizer) |  | 54255 | // Methods (face_BasicFaceRecognizer)
| 54304 |  |  | 54256 |
| 54305 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getEigenValues(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54257 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getEigenValues(PyObject* self, PyObject* py_args, PyObject* kw)
| 54306 | { |  | 54258 | {
| 54307 | using namespace cv::face; |  | 54259 | using namespace cv::face;
| 54308 |  |  | 54260 |
| 54309 |  |  | 54261 |
| 54310 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54262 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54311 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54263 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54312 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54264 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54313 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54265 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54314 | cv::Mat retval; |  | 54266 | cv::Mat retval;
| 54315 |  |  | 54267 |
| 54316 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54268 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54317 | { |  | 54269 | {
| 54318 | ERRWRAP2(retval = _self_->getEigenValues()); |  | 54270 | ERRWRAP2(retval = _self_->getEigenValues());
| 54319 | return pyopencv_from(retval); |  | 54271 | return pyopencv_from(retval);
| 54320 | } |  | 54272 | }
| 54321 |  |  | 54273 |
| 54322 | return NULL; |  | 54274 | return NULL;
| 54323 | } |  | 54275 | }
| 54324 |  |  | 54276 |
| 54325 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getEigenVectors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54277 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getEigenVectors(PyObject* self, PyObject* py_args, PyObject* kw)
| 54326 | { |  | 54278 | {
| 54327 | using namespace cv::face; |  | 54279 | using namespace cv::face;
| 54328 |  |  | 54280 |
| 54329 |  |  | 54281 |
| 54330 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54282 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54331 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54283 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54332 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54284 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54333 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54285 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54334 | cv::Mat retval; |  | 54286 | cv::Mat retval;
| 54335 |  |  | 54287 |
| 54336 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54288 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54337 | { |  | 54289 | {
| 54338 | ERRWRAP2(retval = _self_->getEigenVectors()); |  | 54290 | ERRWRAP2(retval = _self_->getEigenVectors());
| 54339 | return pyopencv_from(retval); |  | 54291 | return pyopencv_from(retval);
| 54340 | } |  | 54292 | }
| 54341 |  |  | 54293 |
| 54342 | return NULL; |  | 54294 | return NULL;
| 54343 | } |  | 54295 | }
| 54344 |  |  | 54296 |
| 54345 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getLabels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54297 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getLabels(PyObject* self, PyObject* py_args, PyObject* kw)
| 54346 | { |  | 54298 | {
| 54347 | using namespace cv::face; |  | 54299 | using namespace cv::face;
| 54348 |  |  | 54300 |
| 54349 |  |  | 54301 |
| 54350 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54302 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54351 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54303 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54352 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54304 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54353 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54305 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54354 | cv::Mat retval; |  | 54306 | cv::Mat retval;
| 54355 |  |  | 54307 |
| 54356 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54308 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54357 | { |  | 54309 | {
| 54358 | ERRWRAP2(retval = _self_->getLabels()); |  | 54310 | ERRWRAP2(retval = _self_->getLabels());
| 54359 | return pyopencv_from(retval); |  | 54311 | return pyopencv_from(retval);
| 54360 | } |  | 54312 | }
| 54361 |  |  | 54313 |
| 54362 | return NULL; |  | 54314 | return NULL;
| 54363 | } |  | 54315 | }
| 54364 |  |  | 54316 |
| 54365 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getMean(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54317 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getMean(PyObject* self, PyObject* py_args, PyObject* kw)
| 54366 | { |  | 54318 | {
| 54367 | using namespace cv::face; |  | 54319 | using namespace cv::face;
| 54368 |  |  | 54320 |
| 54369 |  |  | 54321 |
| 54370 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54322 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54371 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54323 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54372 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54324 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54373 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54325 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54374 | cv::Mat retval; |  | 54326 | cv::Mat retval;
| 54375 |  |  | 54327 |
| 54376 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54328 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54377 | { |  | 54329 | {
| 54378 | ERRWRAP2(retval = _self_->getMean()); |  | 54330 | ERRWRAP2(retval = _self_->getMean());
| 54379 | return pyopencv_from(retval); |  | 54331 | return pyopencv_from(retval);
| 54380 | } |  | 54332 | }
| 54381 |  |  | 54333 |
| 54382 | return NULL; |  | 54334 | return NULL;
| 54383 | } |  | 54335 | }
| 54384 |  |  | 54336 |
| 54385 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getNumComponents(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54337 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getNumComponents(PyObject* self, PyObject* py_args, PyObject* kw)
| 54386 | { |  | 54338 | {
| 54387 | using namespace cv::face; |  | 54339 | using namespace cv::face;
| 54388 |  |  | 54340 |
| 54389 |  |  | 54341 |
| 54390 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54342 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54391 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54343 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54392 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54344 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54393 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54345 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54394 | int retval; |  | 54346 | int retval;
| 54395 |  |  | 54347 |
| 54396 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54348 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54397 | { |  | 54349 | {
| 54398 | ERRWRAP2(retval = _self_->getNumComponents()); |  | 54350 | ERRWRAP2(retval = _self_->getNumComponents());
| 54399 | return pyopencv_from(retval); |  | 54351 | return pyopencv_from(retval);
| 54400 | } |  | 54352 | }
| 54401 |  |  | 54353 |
| 54402 | return NULL; |  | 54354 | return NULL;
| 54403 | } |  | 54355 | }
| 54404 |  |  | 54356 |
| 54405 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getProjections(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54357 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getProjections(PyObject* self, PyObject* py_args, PyObject* kw)
| 54406 | { |  | 54358 | {
| 54407 | using namespace cv::face; |  | 54359 | using namespace cv::face;
| 54408 |  |  | 54360 |
| 54409 |  |  | 54361 |
| 54410 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54362 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54411 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54363 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54412 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54364 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54413 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54365 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54414 | std::vector<cv::Mat> retval; |  | 54366 | std::vector<cv::Mat> retval;
| 54415 |  |  | 54367 |
| 54416 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54368 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54417 | { |  | 54369 | {
| 54418 | ERRWRAP2(retval = _self_->getProjections()); |  | 54370 | ERRWRAP2(retval = _self_->getProjections());
| 54419 | return pyopencv_from(retval); |  | 54371 | return pyopencv_from(retval);
| 54420 | } |  | 54372 | }
| 54421 |  |  | 54373 |
| 54422 | return NULL; |  | 54374 | return NULL;
| 54423 | } |  | 54375 | }
| 54424 |  |  | 54376 |
| 54425 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54377 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 54426 | { |  | 54378 | {
| 54427 | using namespace cv::face; |  | 54379 | using namespace cv::face;
| 54428 |  |  | 54380 |
| 54429 |  |  | 54381 |
| 54430 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54382 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54431 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54383 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54432 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54384 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54433 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54385 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54434 | double retval; |  | 54386 | double retval;
| 54435 |  |  | 54387 |
| 54436 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 54388 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 54437 | { |  | 54389 | {
| 54438 | ERRWRAP2(retval = _self_->getThreshold()); |  | 54390 | ERRWRAP2(retval = _self_->getThreshold());
| 54439 | return pyopencv_from(retval); |  | 54391 | return pyopencv_from(retval);
| 54440 | } |  | 54392 | }
| 54441 |  |  | 54393 |
| 54442 | return NULL; |  | 54394 | return NULL;
| 54443 | } |  | 54395 | }
| 54444 |  |  | 54396 |
| 54445 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_setNumComponents(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54397 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_setNumComponents(PyObject* self, PyObject* py_args, PyObject* kw)
| 54446 | { |  | 54398 | {
| 54447 | using namespace cv::face; |  | 54399 | using namespace cv::face;
| 54448 |  |  | 54400 |
| 54449 |  |  | 54401 |
| 54450 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54402 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54451 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54403 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54452 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54404 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54453 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54405 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54454 | PyObject* pyobj_val = NULL; |  | 54406 | PyObject* pyobj_val = NULL;
| 54455 | int val=0; |  | 54407 | int val=0;
| 54456 |  |  | 54408 |
| 54457 | const char* keywords[] = { "val", NULL }; |  | 54409 | const char* keywords[] = { "val", NULL };
| 54458 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_BasicFaceRecognizer.setNumComponents", (char**)keywords, &pyobj_val) && |  | 54410 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_BasicFaceRecognizer.setNumComponents", (char**)keywords, &pyobj_val) &&
| 54459 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 54411 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 54460 | { |  | 54412 | {
| 54461 | ERRWRAP2(_self_->setNumComponents(val)); |  | 54413 | ERRWRAP2(_self_->setNumComponents(val));
| 54462 | Py_RETURN_NONE; |  | 54414 | Py_RETURN_NONE;
| 54463 | } |  | 54415 | }
| 54464 |  |  | 54416 |
| 54465 | return NULL; |  | 54417 | return NULL;
| 54466 | } |  | 54418 | }
| 54467 |  |  | 54419 |
| 54468 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54420 | static PyObject* pyopencv_cv_face_face_BasicFaceRecognizer_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 54469 | { |  | 54421 | {
| 54470 | using namespace cv::face; |  | 54422 | using namespace cv::face;
| 54471 |  |  | 54423 |
| 54472 |  |  | 54424 |
| 54473 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0; |  | 54425 | Ptr<cv::face::BasicFaceRecognizer> * self1 = 0;
| 54474 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1)) |  | 54426 | if (!pyopencv_face_BasicFaceRecognizer_getp(self, self1))
| 54475 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)"); |  | 54427 | return failmsgp("Incorrect type of self (must be 'face_BasicFaceRecognizer' or its derivative)");
| 54476 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1); |  | 54428 | Ptr<cv::face::BasicFaceRecognizer> _self_ = *(self1);
| 54477 | PyObject* pyobj_val = NULL; |  | 54429 | PyObject* pyobj_val = NULL;
| 54478 | double val=0; |  | 54430 | double val=0;
| 54479 |  |  | 54431 |
| 54480 | const char* keywords[] = { "val", NULL }; |  | 54432 | const char* keywords[] = { "val", NULL };
| 54481 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_BasicFaceRecognizer.setThreshold", (char**)keywords, &pyobj_val) && |  | 54433 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_BasicFaceRecognizer.setThreshold", (char**)keywords, &pyobj_val) &&
| 54482 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 54434 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 54483 | { |  | 54435 | {
| 54484 | ERRWRAP2(_self_->setThreshold(val)); |  | 54436 | ERRWRAP2(_self_->setThreshold(val));
| 54485 | Py_RETURN_NONE; |  | 54437 | Py_RETURN_NONE;
| 54486 | } |  | 54438 | }
| 54487 |  |  | 54439 |
| 54488 | return NULL; |  | 54440 | return NULL;
| 54489 | } |  | 54441 | }
| 54490 |  |  | 54442 |
| 54491 |  |  | 54443 |
| 54492 |  |  | 54444 |
| 54493 | // Tables (face_BasicFaceRecognizer) |  | 54445 | // Tables (face_BasicFaceRecognizer)
| 54494 |  |  | 54446 |
| 54495 | static PyGetSetDef pyopencv_face_BasicFaceRecognizer_getseters[] = |  | 54447 | static PyGetSetDef pyopencv_face_BasicFaceRecognizer_getseters[] =
| 54496 | { |  | 54448 | {
| 54497 | {NULL} /* Sentinel */ |  | 54449 | {NULL} /* Sentinel */
| 54498 | }; |  | 54450 | };
| 54499 |  |  | 54451 |
| 54500 | static PyMethodDef pyopencv_face_BasicFaceRecognizer_methods[] = |  | 54452 | static PyMethodDef pyopencv_face_BasicFaceRecognizer_methods[] =
| 54501 | { |  | 54453 | {
| 54502 | {"getEigenValues", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getEigenValues, 0), "getEigenValues() -> retval\n."}, |  | 54454 | {"getEigenValues", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getEigenValues, 0), "getEigenValues() -> retval\n."},
| 54503 | {"getEigenVectors", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getEigenVectors, 0), "getEigenVectors() -> retval\n."}, |  | 54455 | {"getEigenVectors", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getEigenVectors, 0), "getEigenVectors() -> retval\n."},
| 54504 | {"getLabels", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getLabels, 0), "getLabels() -> retval\n."}, |  | 54456 | {"getLabels", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getLabels, 0), "getLabels() -> retval\n."},
| 54505 | {"getMean", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getMean, 0), "getMean() -> retval\n."}, |  | 54457 | {"getMean", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getMean, 0), "getMean() -> retval\n."},
| 54506 | {"getNumComponents", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getNumComponents, 0), "getNumComponents() -> retval\n. @see setNumComponents"}, |  | 54458 | {"getNumComponents", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getNumComponents, 0), "getNumComponents() -> retval\n. @see setNumComponents"},
| 54507 | {"getProjections", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getProjections, 0), "getProjections() -> retval\n."}, |  | 54459 | {"getProjections", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getProjections, 0), "getProjections() -> retval\n."},
| 54508 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getThreshold, 0), "getThreshold() -> retval\n. @see setThreshold"}, |  | 54460 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_getThreshold, 0), "getThreshold() -> retval\n. @see setThreshold"},
| 54509 | {"setNumComponents", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_setNumComponents, 0), "setNumComponents(val) -> None\n. @copybrief getNumComponents @see getNumComponents"}, |  | 54461 | {"setNumComponents", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_setNumComponents, 0), "setNumComponents(val) -> None\n. @copybrief getNumComponents @see getNumComponents"},
| 54510 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_setThreshold, 0), "setThreshold(val) -> None\n. @copybrief getThreshold @see getThreshold"}, |  | 54462 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_BasicFaceRecognizer_setThreshold, 0), "setThreshold(val) -> None\n. @copybrief getThreshold @see getThreshold"},
| 54511 |  |  | 54463 |
| 54512 | {NULL, NULL} |  | 54464 | {NULL, NULL}
| 54513 | }; |  | 54465 | };
| 54514 |  |  | 54466 |
| 54515 | // Converter (face_BasicFaceRecognizer) |  | 54467 | // Converter (face_BasicFaceRecognizer)
| 54516 |  |  | 54468 |
| 54517 | template<> |  | 54469 | template<>
| 54518 | struct PyOpenCV_Converter< Ptr<cv::face::BasicFaceRecognizer> > |  | 54470 | struct PyOpenCV_Converter< Ptr<cv::face::BasicFaceRecognizer> >
| 54519 | { |  | 54471 | {
| 54520 | static PyObject* from(const Ptr<cv::face::BasicFaceRecognizer>& r) |  | 54472 | static PyObject* from(const Ptr<cv::face::BasicFaceRecognizer>& r)
| 54521 | { |  | 54473 | {
| 54522 | return pyopencv_face_BasicFaceRecognizer_Instance(r); |  | 54474 | return pyopencv_face_BasicFaceRecognizer_Instance(r);
| 54523 | } |  | 54475 | }
| 54524 | static bool to(PyObject* src, Ptr<cv::face::BasicFaceRecognizer>& dst, const ArgInfo& info) |  | 54476 | static bool to(PyObject* src, Ptr<cv::face::BasicFaceRecognizer>& dst, const ArgInfo& info)
| 54525 | { |  | 54477 | {
| 54526 | if(!src || src == Py_None) |  | 54478 | if(!src || src == Py_None)
| 54527 | return true; |  | 54479 | return true;
| 54528 | Ptr<cv::face::BasicFaceRecognizer> * dst_; |  | 54480 | Ptr<cv::face::BasicFaceRecognizer> * dst_;
| 54529 | if (pyopencv_face_BasicFaceRecognizer_getp(src, dst_)) |  | 54481 | if (pyopencv_face_BasicFaceRecognizer_getp(src, dst_))
| 54530 | { |  | 54482 | {
| 54531 | dst = *dst_; |  | 54483 | dst = *dst_;
| 54532 | return true; |  | 54484 | return true;
| 54533 | } |  | 54485 | }
| 54534 |  |  | 54486 |
| 54535 | failmsg("Expected Ptr<cv::face::BasicFaceRecognizer> for argument '%s'", info.name); |  | 54487 | failmsg("Expected Ptr<cv::face::BasicFaceRecognizer> for argument '%s'", info.name);
| 54536 | return false; |  | 54488 | return false;
| 54537 | } |  | 54489 | }
| 54538 | }; |  | 54490 | };
| 54539 |  |  | 54491 |
| 54540 | //================================================================================ |  | 54492 | //================================================================================
| 54541 | // face_EigenFaceRecognizer (Generic) |  | 54493 | // face_EigenFaceRecognizer (Generic)
| 54542 | //================================================================================ |  | 54494 | //================================================================================
| 54543 |  |  | 54495 |
| 54544 | // GetSet (face_EigenFaceRecognizer) |  | 54496 | // GetSet (face_EigenFaceRecognizer)
| 54545 |  |  | 54497 |
| 54546 |  |  | 54498 |
| 54547 |  |  | 54499 |
| 54548 | // Methods (face_EigenFaceRecognizer) |  | 54500 | // Methods (face_EigenFaceRecognizer)
| 54549 |  |  | 54501 |
| 54550 | static PyObject* pyopencv_cv_face_face_EigenFaceRecognizer_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54502 | static PyObject* pyopencv_cv_face_face_EigenFaceRecognizer_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 54551 | { |  | 54503 | {
| 54552 | using namespace cv::face; |  | 54504 | using namespace cv::face;
| 54553 |  |  | 54505 |
| 54554 | PyObject* pyobj_num_components = NULL; |  | 54506 | PyObject* pyobj_num_components = NULL;
| 54555 | int num_components=0; |  | 54507 | int num_components=0;
| 54556 | PyObject* pyobj_threshold = NULL; |  | 54508 | PyObject* pyobj_threshold = NULL;
| 54557 | double threshold=DBL_MAX; |  | 54509 | double threshold=DBL_MAX;
| 54558 | Ptr<EigenFaceRecognizer> retval; |  | 54510 | Ptr<EigenFaceRecognizer> retval;
| 54559 |  |  | 54511 |
| 54560 | const char* keywords[] = { "num_components", "threshold", NULL }; |  | 54512 | const char* keywords[] = { "num_components", "threshold", NULL };
| 54561 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:face_EigenFaceRecognizer.create", (char**)keywords, &pyobj_num_components, &pyobj_threshold) && |  | 54513 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:face_EigenFaceRecognizer.create", (char**)keywords, &pyobj_num_components, &pyobj_threshold) &&
| 54562 | pyopencv_to_safe(pyobj_num_components, num_components, ArgInfo("num_components", 0)) && |  | 54514 | pyopencv_to_safe(pyobj_num_components, num_components, ArgInfo("num_components", 0)) &&
| 54563 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 54515 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 54564 | { |  | 54516 | {
| 54565 | ERRWRAP2(retval = cv::face::EigenFaceRecognizer::create(num_components, threshold)); |  | 54517 | ERRWRAP2(retval = cv::face::EigenFaceRecognizer::create(num_components, threshold));
| 54566 | return pyopencv_from(retval); |  | 54518 | return pyopencv_from(retval);
| 54567 | } |  | 54519 | }
| 54568 |  |  | 54520 |
| 54569 | return NULL; |  | 54521 | return NULL;
| 54570 | } |  | 54522 | }
| 54571 |  |  | 54523 |
| 54572 |  |  | 54524 |
| 54573 |  |  | 54525 |
| 54574 | // Tables (face_EigenFaceRecognizer) |  | 54526 | // Tables (face_EigenFaceRecognizer)
| 54575 |  |  | 54527 |
| 54576 | static PyGetSetDef pyopencv_face_EigenFaceRecognizer_getseters[] = |  | 54528 | static PyGetSetDef pyopencv_face_EigenFaceRecognizer_getseters[] =
| 54577 | { |  | 54529 | {
| 54578 | {NULL} /* Sentinel */ |  | 54530 | {NULL} /* Sentinel */
| 54579 | }; |  | 54531 | };
| 54580 |  |  | 54532 |
| 54581 | static PyMethodDef pyopencv_face_EigenFaceRecognizer_methods[] = |  | 54533 | static PyMethodDef pyopencv_face_EigenFaceRecognizer_methods[] =
| 54582 | { |  | 54534 | {
| 54583 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_EigenFaceRecognizer_create_static, METH_STATIC), "create([, num_components[, threshold]]) -> retval\n. @param num_components The number of components (read: Eigenfaces) kept for this Principal\n. Component Analysis. As a hint: There's no rule how many components (read: Eigenfaces) should be\n. kept for good reconstruction capabilities. It is based on your input data, so experiment with the\n. number. Keeping 80 components should almost always be sufficient.\n. @param threshold The threshold applied in the prediction.\n. \n. ### Notes:\n. \n. - Training and prediction must be done on grayscale images, use cvtColor to convert between the\n. color spaces.\n. - **THE EIGENFACES METHOD MAKES THE ASSUMPTION, THAT THE TRAINING AND TEST IMAGES ARE OF EQUAL\n. SIZE.** (caps-lock, because I got so many mails asking for this). You have to make sure your\n. input data has the correct shape, else a meaningful exception is thrown. Use resize to resize\n. the images.\n. - This model does not support updating.\n. \n. ### Model internal data:\n. \n. - num_components see EigenFaceRecognizer::create.\n. - threshold see EigenFaceRecognizer::create.\n. - eigenvalues The eigenvalues for this Principal Component Analysis (ordered descending).\n. - eigenvectors The eigenvectors for this Principal Component Analysis (ordered by their\n. eigenvalue).\n. - mean The sample mean calculated from the training data.\n. - projections The projections of the training data.\n. - labels The threshold applied in the prediction. If the distance to the nearest neighbor is\n. larger than the threshold, this method returns -1."}, |  | 54535 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_EigenFaceRecognizer_create_static, METH_STATIC), "create([, num_components[, threshold]]) -> retval\n. @param num_components The number of components (read: Eigenfaces) kept for this Principal\n. Component Analysis. As a hint: There's no rule how many components (read: Eigenfaces) should be\n. kept for good reconstruction capabilities. It is based on your input data, so experiment with the\n. number. Keeping 80 components should almost always be sufficient.\n. @param threshold The threshold applied in the prediction.\n. \n. ### Notes:\n. \n. - Training and prediction must be done on grayscale images, use cvtColor to convert between the\n. color spaces.\n. - **THE EIGENFACES METHOD MAKES THE ASSUMPTION, THAT THE TRAINING AND TEST IMAGES ARE OF EQUAL\n. SIZE.** (caps-lock, because I got so many mails asking for this). You have to make sure your\n. input data has the correct shape, else a meaningful exception is thrown. Use resize to resize\n. the images.\n. - This model does not support updating.\n. \n. ### Model internal data:\n. \n. - num_components see EigenFaceRecognizer::create.\n. - threshold see EigenFaceRecognizer::create.\n. - eigenvalues The eigenvalues for this Principal Component Analysis (ordered descending).\n. - eigenvectors The eigenvectors for this Principal Component Analysis (ordered by their\n. eigenvalue).\n. - mean The sample mean calculated from the training data.\n. - projections The projections of the training data.\n. - labels The threshold applied in the prediction. If the distance to the nearest neighbor is\n. larger than the threshold, this method returns -1."},
| 54584 |  |  | 54536 |
| 54585 | {NULL, NULL} |  | 54537 | {NULL, NULL}
| 54586 | }; |  | 54538 | };
| 54587 |  |  | 54539 |
| 54588 | // Converter (face_EigenFaceRecognizer) |  | 54540 | // Converter (face_EigenFaceRecognizer)
| 54589 |  |  | 54541 |
| 54590 | template<> |  | 54542 | template<>
| 54591 | struct PyOpenCV_Converter< Ptr<cv::face::EigenFaceRecognizer> > |  | 54543 | struct PyOpenCV_Converter< Ptr<cv::face::EigenFaceRecognizer> >
| 54592 | { |  | 54544 | {
| 54593 | static PyObject* from(const Ptr<cv::face::EigenFaceRecognizer>& r) |  | 54545 | static PyObject* from(const Ptr<cv::face::EigenFaceRecognizer>& r)
| 54594 | { |  | 54546 | {
| 54595 | return pyopencv_face_EigenFaceRecognizer_Instance(r); |  | 54547 | return pyopencv_face_EigenFaceRecognizer_Instance(r);
| 54596 | } |  | 54548 | }
| 54597 | static bool to(PyObject* src, Ptr<cv::face::EigenFaceRecognizer>& dst, const ArgInfo& info) |  | 54549 | static bool to(PyObject* src, Ptr<cv::face::EigenFaceRecognizer>& dst, const ArgInfo& info)
| 54598 | { |  | 54550 | {
| 54599 | if(!src || src == Py_None) |  | 54551 | if(!src || src == Py_None)
| 54600 | return true; |  | 54552 | return true;
| 54601 | Ptr<cv::face::EigenFaceRecognizer> * dst_; |  | 54553 | Ptr<cv::face::EigenFaceRecognizer> * dst_;
| 54602 | if (pyopencv_face_EigenFaceRecognizer_getp(src, dst_)) |  | 54554 | if (pyopencv_face_EigenFaceRecognizer_getp(src, dst_))
| 54603 | { |  | 54555 | {
| 54604 | dst = *dst_; |  | 54556 | dst = *dst_;
| 54605 | return true; |  | 54557 | return true;
| 54606 | } |  | 54558 | }
| 54607 |  |  | 54559 |
| 54608 | failmsg("Expected Ptr<cv::face::EigenFaceRecognizer> for argument '%s'", info.name); |  | 54560 | failmsg("Expected Ptr<cv::face::EigenFaceRecognizer> for argument '%s'", info.name);
| 54609 | return false; |  | 54561 | return false;
| 54610 | } |  | 54562 | }
| 54611 | }; |  | 54563 | };
| 54612 |  |  | 54564 |
| 54613 | //================================================================================ |  | 54565 | //================================================================================
| 54614 | // face_FaceRecognizer (Generic) |  | 54566 | // face_FaceRecognizer (Generic)
| 54615 | //================================================================================ |  | 54567 | //================================================================================
| 54616 |  |  | 54568 |
| 54617 | // GetSet (face_FaceRecognizer) |  | 54569 | // GetSet (face_FaceRecognizer)
| 54618 |  |  | 54570 |
| 54619 |  |  | 54571 |
| 54620 |  |  | 54572 |
| 54621 | // Methods (face_FaceRecognizer) |  | 54573 | // Methods (face_FaceRecognizer)
| 54622 |  |  | 54574 |
| 54623 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_getLabelInfo(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54575 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_getLabelInfo(PyObject* self, PyObject* py_args, PyObject* kw)
| 54624 | { |  | 54576 | {
| 54625 | using namespace cv::face; |  | 54577 | using namespace cv::face;
| 54626 |  |  | 54578 |
| 54627 |  |  | 54579 |
| 54628 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54580 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54629 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54581 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54630 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54582 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54631 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54583 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54632 | PyObject* pyobj_label = NULL; |  | 54584 | PyObject* pyobj_label = NULL;
| 54633 | int label=0; |  | 54585 | int label=0;
| 54634 | String retval; |  | 54586 | String retval;
| 54635 |  |  | 54587 |
| 54636 | const char* keywords[] = { "label", NULL }; |  | 54588 | const char* keywords[] = { "label", NULL };
| 54637 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.getLabelInfo", (char**)keywords, &pyobj_label) && |  | 54589 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.getLabelInfo", (char**)keywords, &pyobj_label) &&
| 54638 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) ) |  | 54590 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) )
| 54639 | { |  | 54591 | {
| 54640 | ERRWRAP2(retval = _self_->getLabelInfo(label)); |  | 54592 | ERRWRAP2(retval = _self_->getLabelInfo(label));
| 54641 | return pyopencv_from(retval); |  | 54593 | return pyopencv_from(retval);
| 54642 | } |  | 54594 | }
| 54643 |  |  | 54595 |
| 54644 | return NULL; |  | 54596 | return NULL;
| 54645 | } |  | 54597 | }
| 54646 |  |  | 54598 |
| 54647 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_getLabelsByString(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54599 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_getLabelsByString(PyObject* self, PyObject* py_args, PyObject* kw)
| 54648 | { |  | 54600 | {
| 54649 | using namespace cv::face; |  | 54601 | using namespace cv::face;
| 54650 |  |  | 54602 |
| 54651 |  |  | 54603 |
| 54652 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54604 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54653 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54605 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54654 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54606 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54655 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54607 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54656 | PyObject* pyobj_str = NULL; |  | 54608 | PyObject* pyobj_str = NULL;
| 54657 | String str; |  | 54609 | String str;
| 54658 | std::vector<int> retval; |  | 54610 | std::vector<int> retval;
| 54659 |  |  | 54611 |
| 54660 | const char* keywords[] = { "str", NULL }; |  | 54612 | const char* keywords[] = { "str", NULL };
| 54661 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.getLabelsByString", (char**)keywords, &pyobj_str) && |  | 54613 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.getLabelsByString", (char**)keywords, &pyobj_str) &&
| 54662 | pyopencv_to_safe(pyobj_str, str, ArgInfo("str", 0)) ) |  | 54614 | pyopencv_to_safe(pyobj_str, str, ArgInfo("str", 0)) )
| 54663 | { |  | 54615 | {
| 54664 | ERRWRAP2(retval = _self_->getLabelsByString(str)); |  | 54616 | ERRWRAP2(retval = _self_->getLabelsByString(str));
| 54665 | return pyopencv_from(retval); |  | 54617 | return pyopencv_from(retval);
| 54666 | } |  | 54618 | }
| 54667 |  |  | 54619 |
| 54668 | return NULL; |  | 54620 | return NULL;
| 54669 | } |  | 54621 | }
| 54670 |  |  | 54622 |
| 54671 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_predict(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54623 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_predict(PyObject* self, PyObject* py_args, PyObject* kw)
| 54672 | { |  | 54624 | {
| 54673 | using namespace cv::face; |  | 54625 | using namespace cv::face;
| 54674 |  |  | 54626 |
| 54675 |  |  | 54627 |
| 54676 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54628 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54677 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54629 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54678 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54630 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54679 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54631 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54680 | pyPrepareArgumentConversionErrorsStorage(2); |  | 54632 | pyPrepareArgumentConversionErrorsStorage(2);
| 54681 |  |  | 54633 |
| 54682 | { |  | 54634 | {
| 54683 | PyObject* pyobj_src = NULL; |  | 54635 | PyObject* pyobj_src = NULL;
| 54684 | Mat src; |  | 54636 | Mat src;
| 54685 | int label; |  | 54637 | int label;
| 54686 | double confidence; |  | 54638 | double confidence;
| 54687 |  |  | 54639 |
| 54688 | const char* keywords[] = { "src", NULL }; |  | 54640 | const char* keywords[] = { "src", NULL };
| 54689 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict", (char**)keywords, &pyobj_src) && |  | 54641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict", (char**)keywords, &pyobj_src) &&
| 54690 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) ) |  | 54642 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) )
| 54691 | { |  | 54643 | {
| 54692 | ERRWRAP2(_self_->predict(src, label, confidence)); |  | 54644 | ERRWRAP2(_self_->predict(src, label, confidence));
| 54693 | return Py_BuildValue("(NN)", pyopencv_from(label), pyopencv_from(confidence)); |  | 54645 | return Py_BuildValue("(NN)", pyopencv_from(label), pyopencv_from(confidence));
| 54694 | } |  | 54646 | }
| 54695 |  |  | 54647 |
| 54696 |  |  | 54648 |
| 54697 | pyPopulateArgumentConversionErrors(); |  | 54649 | pyPopulateArgumentConversionErrors();
| 54698 | } |  | 54650 | }
| 54699 |  |  | 54651 |
| 54700 |  |  | 54652 |
| 54701 | { |  | 54653 | {
| 54702 | PyObject* pyobj_src = NULL; |  | 54654 | PyObject* pyobj_src = NULL;
| 54703 | UMat src; |  | 54655 | UMat src;
| 54704 | int label; |  | 54656 | int label;
| 54705 | double confidence; |  | 54657 | double confidence;
| 54706 |  |  | 54658 |
| 54707 | const char* keywords[] = { "src", NULL }; |  | 54659 | const char* keywords[] = { "src", NULL };
| 54708 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict", (char**)keywords, &pyobj_src) && |  | 54660 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict", (char**)keywords, &pyobj_src) &&
| 54709 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) ) |  | 54661 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) )
| 54710 | { |  | 54662 | {
| 54711 | ERRWRAP2(_self_->predict(src, label, confidence)); |  | 54663 | ERRWRAP2(_self_->predict(src, label, confidence));
| 54712 | return Py_BuildValue("(NN)", pyopencv_from(label), pyopencv_from(confidence)); |  | 54664 | return Py_BuildValue("(NN)", pyopencv_from(label), pyopencv_from(confidence));
| 54713 | } |  | 54665 | }
| 54714 |  |  | 54666 |
| 54715 |  |  | 54667 |
| 54716 | pyPopulateArgumentConversionErrors(); |  | 54668 | pyPopulateArgumentConversionErrors();
| 54717 | } |  | 54669 | }
| 54718 | pyRaiseCVOverloadException("predict"); |  | 54670 | pyRaiseCVOverloadException("predict");
| 54719 |  |  | 54671 |
| 54720 | return NULL; |  | 54672 | return NULL;
| 54721 | } |  | 54673 | }
| 54722 |  |  | 54674 |
| 54723 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_predict_collect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54675 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_predict_collect(PyObject* self, PyObject* py_args, PyObject* kw)
| 54724 | { |  | 54676 | {
| 54725 | using namespace cv::face; |  | 54677 | using namespace cv::face;
| 54726 |  |  | 54678 |
| 54727 |  |  | 54679 |
| 54728 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54680 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54729 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54681 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54730 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54682 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54731 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54683 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54732 | pyPrepareArgumentConversionErrorsStorage(2); |  | 54684 | pyPrepareArgumentConversionErrorsStorage(2);
| 54733 |  |  | 54685 |
| 54734 | { |  | 54686 | {
| 54735 | PyObject* pyobj_src = NULL; |  | 54687 | PyObject* pyobj_src = NULL;
| 54736 | Mat src; |  | 54688 | Mat src;
| 54737 | PyObject* pyobj_collector = NULL; |  | 54689 | PyObject* pyobj_collector = NULL;
| 54738 | Ptr<PredictCollector> collector; |  | 54690 | Ptr<PredictCollector> collector;
| 54739 |  |  | 54691 |
| 54740 | const char* keywords[] = { "src", "collector", NULL }; |  | 54692 | const char* keywords[] = { "src", "collector", NULL };
| 54741 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.predict_collect", (char**)keywords, &pyobj_src, &pyobj_collector) && |  | 54693 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.predict_collect", (char**)keywords, &pyobj_src, &pyobj_collector) &&
| 54742 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 54694 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 54743 | pyopencv_to_safe(pyobj_collector, collector, ArgInfo("collector", 0)) ) |  | 54695 | pyopencv_to_safe(pyobj_collector, collector, ArgInfo("collector", 0)) )
| 54744 | { |  | 54696 | {
| 54745 | ERRWRAP2(_self_->predict(src, collector)); |  | 54697 | ERRWRAP2(_self_->predict(src, collector));
| 54746 | Py_RETURN_NONE; |  | 54698 | Py_RETURN_NONE;
| 54747 | } |  | 54699 | }
| 54748 |  |  | 54700 |
| 54749 |  |  | 54701 |
| 54750 | pyPopulateArgumentConversionErrors(); |  | 54702 | pyPopulateArgumentConversionErrors();
| 54751 | } |  | 54703 | }
| 54752 |  |  | 54704 |
| 54753 |  |  | 54705 |
| 54754 | { |  | 54706 | {
| 54755 | PyObject* pyobj_src = NULL; |  | 54707 | PyObject* pyobj_src = NULL;
| 54756 | UMat src; |  | 54708 | UMat src;
| 54757 | PyObject* pyobj_collector = NULL; |  | 54709 | PyObject* pyobj_collector = NULL;
| 54758 | Ptr<PredictCollector> collector; |  | 54710 | Ptr<PredictCollector> collector;
| 54759 |  |  | 54711 |
| 54760 | const char* keywords[] = { "src", "collector", NULL }; |  | 54712 | const char* keywords[] = { "src", "collector", NULL };
| 54761 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.predict_collect", (char**)keywords, &pyobj_src, &pyobj_collector) && |  | 54713 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.predict_collect", (char**)keywords, &pyobj_src, &pyobj_collector) &&
| 54762 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 54714 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 54763 | pyopencv_to_safe(pyobj_collector, collector, ArgInfo("collector", 0)) ) |  | 54715 | pyopencv_to_safe(pyobj_collector, collector, ArgInfo("collector", 0)) )
| 54764 | { |  | 54716 | {
| 54765 | ERRWRAP2(_self_->predict(src, collector)); |  | 54717 | ERRWRAP2(_self_->predict(src, collector));
| 54766 | Py_RETURN_NONE; |  | 54718 | Py_RETURN_NONE;
| 54767 | } |  | 54719 | }
| 54768 |  |  | 54720 |
| 54769 |  |  | 54721 |
| 54770 | pyPopulateArgumentConversionErrors(); |  | 54722 | pyPopulateArgumentConversionErrors();
| 54771 | } |  | 54723 | }
| 54772 | pyRaiseCVOverloadException("predict_collect"); |  | 54724 | pyRaiseCVOverloadException("predict_collect");
| 54773 |  |  | 54725 |
| 54774 | return NULL; |  | 54726 | return NULL;
| 54775 | } |  | 54727 | }
| 54776 |  |  | 54728 |
| 54777 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_predict_label(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54729 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_predict_label(PyObject* self, PyObject* py_args, PyObject* kw)
| 54778 | { |  | 54730 | {
| 54779 | using namespace cv::face; |  | 54731 | using namespace cv::face;
| 54780 |  |  | 54732 |
| 54781 |  |  | 54733 |
| 54782 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54734 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54783 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54735 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54784 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54736 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54785 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54737 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54786 | pyPrepareArgumentConversionErrorsStorage(2); |  | 54738 | pyPrepareArgumentConversionErrorsStorage(2);
| 54787 |  |  | 54739 |
| 54788 | { |  | 54740 | {
| 54789 | PyObject* pyobj_src = NULL; |  | 54741 | PyObject* pyobj_src = NULL;
| 54790 | Mat src; |  | 54742 | Mat src;
| 54791 | int retval; |  | 54743 | int retval;
| 54792 |  |  | 54744 |
| 54793 | const char* keywords[] = { "src", NULL }; |  | 54745 | const char* keywords[] = { "src", NULL };
| 54794 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict_label", (char**)keywords, &pyobj_src) && |  | 54746 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict_label", (char**)keywords, &pyobj_src) &&
| 54795 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) ) |  | 54747 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) )
| 54796 | { |  | 54748 | {
| 54797 | ERRWRAP2(retval = _self_->predict(src)); |  | 54749 | ERRWRAP2(retval = _self_->predict(src));
| 54798 | return pyopencv_from(retval); |  | 54750 | return pyopencv_from(retval);
| 54799 | } |  | 54751 | }
| 54800 |  |  | 54752 |
| 54801 |  |  | 54753 |
| 54802 | pyPopulateArgumentConversionErrors(); |  | 54754 | pyPopulateArgumentConversionErrors();
| 54803 | } |  | 54755 | }
| 54804 |  |  | 54756 |
| 54805 |  |  | 54757 |
| 54806 | { |  | 54758 | {
| 54807 | PyObject* pyobj_src = NULL; |  | 54759 | PyObject* pyobj_src = NULL;
| 54808 | UMat src; |  | 54760 | UMat src;
| 54809 | int retval; |  | 54761 | int retval;
| 54810 |  |  | 54762 |
| 54811 | const char* keywords[] = { "src", NULL }; |  | 54763 | const char* keywords[] = { "src", NULL };
| 54812 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict_label", (char**)keywords, &pyobj_src) && |  | 54764 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.predict_label", (char**)keywords, &pyobj_src) &&
| 54813 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) ) |  | 54765 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) )
| 54814 | { |  | 54766 | {
| 54815 | ERRWRAP2(retval = _self_->predict(src)); |  | 54767 | ERRWRAP2(retval = _self_->predict(src));
| 54816 | return pyopencv_from(retval); |  | 54768 | return pyopencv_from(retval);
| 54817 | } |  | 54769 | }
| 54818 |  |  | 54770 |
| 54819 |  |  | 54771 |
| 54820 | pyPopulateArgumentConversionErrors(); |  | 54772 | pyPopulateArgumentConversionErrors();
| 54821 | } |  | 54773 | }
| 54822 | pyRaiseCVOverloadException("predict_label"); |  | 54774 | pyRaiseCVOverloadException("predict_label");
| 54823 |  |  | 54775 |
| 54824 | return NULL; |  | 54776 | return NULL;
| 54825 | } |  | 54777 | }
| 54826 |  |  | 54778 |
| 54827 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54779 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 54828 | { |  | 54780 | {
| 54829 | using namespace cv::face; |  | 54781 | using namespace cv::face;
| 54830 |  |  | 54782 |
| 54831 |  |  | 54783 |
| 54832 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54784 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54833 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54785 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54834 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54786 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54835 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54787 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54836 | PyObject* pyobj_filename = NULL; |  | 54788 | PyObject* pyobj_filename = NULL;
| 54837 | String filename; |  | 54789 | String filename;
| 54838 |  |  | 54790 |
| 54839 | const char* keywords[] = { "filename", NULL }; |  | 54791 | const char* keywords[] = { "filename", NULL };
| 54840 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.read", (char**)keywords, &pyobj_filename) && |  | 54792 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.read", (char**)keywords, &pyobj_filename) &&
| 54841 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 54793 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 54842 | { |  | 54794 | {
| 54843 | ERRWRAP2(_self_->read(filename)); |  | 54795 | ERRWRAP2(_self_->read(filename));
| 54844 | Py_RETURN_NONE; |  | 54796 | Py_RETURN_NONE;
| 54845 | } |  | 54797 | }
| 54846 |  |  | 54798 |
| 54847 | return NULL; |  | 54799 | return NULL;
| 54848 | } |  | 54800 | }
| 54849 |  |  | 54801 |
| 54850 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_setLabelInfo(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54802 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_setLabelInfo(PyObject* self, PyObject* py_args, PyObject* kw)
| 54851 | { |  | 54803 | {
| 54852 | using namespace cv::face; |  | 54804 | using namespace cv::face;
| 54853 |  |  | 54805 |
| 54854 |  |  | 54806 |
| 54855 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54807 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54856 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54808 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54857 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54809 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54858 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54810 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54859 | PyObject* pyobj_label = NULL; |  | 54811 | PyObject* pyobj_label = NULL;
| 54860 | int label=0; |  | 54812 | int label=0;
| 54861 | PyObject* pyobj_strInfo = NULL; |  | 54813 | PyObject* pyobj_strInfo = NULL;
| 54862 | String strInfo; |  | 54814 | String strInfo;
| 54863 |  |  | 54815 |
| 54864 | const char* keywords[] = { "label", "strInfo", NULL }; |  | 54816 | const char* keywords[] = { "label", "strInfo", NULL };
| 54865 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.setLabelInfo", (char**)keywords, &pyobj_label, &pyobj_strInfo) && |  | 54817 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.setLabelInfo", (char**)keywords, &pyobj_label, &pyobj_strInfo) &&
| 54866 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) && |  | 54818 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) &&
| 54867 | pyopencv_to_safe(pyobj_strInfo, strInfo, ArgInfo("strInfo", 0)) ) |  | 54819 | pyopencv_to_safe(pyobj_strInfo, strInfo, ArgInfo("strInfo", 0)) )
| 54868 | { |  | 54820 | {
| 54869 | ERRWRAP2(_self_->setLabelInfo(label, strInfo)); |  | 54821 | ERRWRAP2(_self_->setLabelInfo(label, strInfo));
| 54870 | Py_RETURN_NONE; |  | 54822 | Py_RETURN_NONE;
| 54871 | } |  | 54823 | }
| 54872 |  |  | 54824 |
| 54873 | return NULL; |  | 54825 | return NULL;
| 54874 | } |  | 54826 | }
| 54875 |  |  | 54827 |
| 54876 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_train(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54828 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_train(PyObject* self, PyObject* py_args, PyObject* kw)
| 54877 | { |  | 54829 | {
| 54878 | using namespace cv::face; |  | 54830 | using namespace cv::face;
| 54879 |  |  | 54831 |
| 54880 |  |  | 54832 |
| 54881 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54833 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54882 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54834 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54883 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54835 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54884 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54836 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54885 | pyPrepareArgumentConversionErrorsStorage(2); |  | 54837 | pyPrepareArgumentConversionErrorsStorage(2);
| 54886 |  |  | 54838 |
| 54887 | { |  | 54839 | {
| 54888 | PyObject* pyobj_src = NULL; |  | 54840 | PyObject* pyobj_src = NULL;
| 54889 | vector_Mat src; |  | 54841 | vector_Mat src;
| 54890 | PyObject* pyobj_labels = NULL; |  | 54842 | PyObject* pyobj_labels = NULL;
| 54891 | Mat labels; |  | 54843 | Mat labels;
| 54892 |  |  | 54844 |
| 54893 | const char* keywords[] = { "src", "labels", NULL }; |  | 54845 | const char* keywords[] = { "src", "labels", NULL };
| 54894 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.train", (char**)keywords, &pyobj_src, &pyobj_labels) && |  | 54846 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.train", (char**)keywords, &pyobj_src, &pyobj_labels) &&
| 54895 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 54847 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 54896 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) ) |  | 54848 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) )
| 54897 | { |  | 54849 | {
| 54898 | ERRWRAP2(_self_->train(src, labels)); |  | 54850 | ERRWRAP2(_self_->train(src, labels));
| 54899 | Py_RETURN_NONE; |  | 54851 | Py_RETURN_NONE;
| 54900 | } |  | 54852 | }
| 54901 |  |  | 54853 |
| 54902 |  |  | 54854 |
| 54903 | pyPopulateArgumentConversionErrors(); |  | 54855 | pyPopulateArgumentConversionErrors();
| 54904 | } |  | 54856 | }
| 54905 |  |  | 54857 |
| 54906 |  |  | 54858 |
| 54907 | { |  | 54859 | {
| 54908 | PyObject* pyobj_src = NULL; |  | 54860 | PyObject* pyobj_src = NULL;
| 54909 | vector_UMat src; |  | 54861 | vector_UMat src;
| 54910 | PyObject* pyobj_labels = NULL; |  | 54862 | PyObject* pyobj_labels = NULL;
| 54911 | UMat labels; |  | 54863 | UMat labels;
| 54912 |  |  | 54864 |
| 54913 | const char* keywords[] = { "src", "labels", NULL }; |  | 54865 | const char* keywords[] = { "src", "labels", NULL };
| 54914 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.train", (char**)keywords, &pyobj_src, &pyobj_labels) && |  | 54866 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.train", (char**)keywords, &pyobj_src, &pyobj_labels) &&
| 54915 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 54867 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 54916 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) ) |  | 54868 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) )
| 54917 | { |  | 54869 | {
| 54918 | ERRWRAP2(_self_->train(src, labels)); |  | 54870 | ERRWRAP2(_self_->train(src, labels));
| 54919 | Py_RETURN_NONE; |  | 54871 | Py_RETURN_NONE;
| 54920 | } |  | 54872 | }
| 54921 |  |  | 54873 |
| 54922 |  |  | 54874 |
| 54923 | pyPopulateArgumentConversionErrors(); |  | 54875 | pyPopulateArgumentConversionErrors();
| 54924 | } |  | 54876 | }
| 54925 | pyRaiseCVOverloadException("train"); |  | 54877 | pyRaiseCVOverloadException("train");
| 54926 |  |  | 54878 |
| 54927 | return NULL; |  | 54879 | return NULL;
| 54928 | } |  | 54880 | }
| 54929 |  |  | 54881 |
| 54930 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54882 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 54931 | { |  | 54883 | {
| 54932 | using namespace cv::face; |  | 54884 | using namespace cv::face;
| 54933 |  |  | 54885 |
| 54934 |  |  | 54886 |
| 54935 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54887 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54936 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54888 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54937 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54889 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54938 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54890 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54939 | pyPrepareArgumentConversionErrorsStorage(2); |  | 54891 | pyPrepareArgumentConversionErrorsStorage(2);
| 54940 |  |  | 54892 |
| 54941 | { |  | 54893 | {
| 54942 | PyObject* pyobj_src = NULL; |  | 54894 | PyObject* pyobj_src = NULL;
| 54943 | vector_Mat src; |  | 54895 | vector_Mat src;
| 54944 | PyObject* pyobj_labels = NULL; |  | 54896 | PyObject* pyobj_labels = NULL;
| 54945 | Mat labels; |  | 54897 | Mat labels;
| 54946 |  |  | 54898 |
| 54947 | const char* keywords[] = { "src", "labels", NULL }; |  | 54899 | const char* keywords[] = { "src", "labels", NULL };
| 54948 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.update", (char**)keywords, &pyobj_src, &pyobj_labels) && |  | 54900 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.update", (char**)keywords, &pyobj_src, &pyobj_labels) &&
| 54949 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 54901 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 54950 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) ) |  | 54902 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) )
| 54951 | { |  | 54903 | {
| 54952 | ERRWRAP2(_self_->update(src, labels)); |  | 54904 | ERRWRAP2(_self_->update(src, labels));
| 54953 | Py_RETURN_NONE; |  | 54905 | Py_RETURN_NONE;
| 54954 | } |  | 54906 | }
| 54955 |  |  | 54907 |
| 54956 |  |  | 54908 |
| 54957 | pyPopulateArgumentConversionErrors(); |  | 54909 | pyPopulateArgumentConversionErrors();
| 54958 | } |  | 54910 | }
| 54959 |  |  | 54911 |
| 54960 |  |  | 54912 |
| 54961 | { |  | 54913 | {
| 54962 | PyObject* pyobj_src = NULL; |  | 54914 | PyObject* pyobj_src = NULL;
| 54963 | vector_UMat src; |  | 54915 | vector_UMat src;
| 54964 | PyObject* pyobj_labels = NULL; |  | 54916 | PyObject* pyobj_labels = NULL;
| 54965 | UMat labels; |  | 54917 | UMat labels;
| 54966 |  |  | 54918 |
| 54967 | const char* keywords[] = { "src", "labels", NULL }; |  | 54919 | const char* keywords[] = { "src", "labels", NULL };
| 54968 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.update", (char**)keywords, &pyobj_src, &pyobj_labels) && |  | 54920 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:face_FaceRecognizer.update", (char**)keywords, &pyobj_src, &pyobj_labels) &&
| 54969 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 54921 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 54970 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) ) |  | 54922 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 0)) )
| 54971 | { |  | 54923 | {
| 54972 | ERRWRAP2(_self_->update(src, labels)); |  | 54924 | ERRWRAP2(_self_->update(src, labels));
| 54973 | Py_RETURN_NONE; |  | 54925 | Py_RETURN_NONE;
| 54974 | } |  | 54926 | }
| 54975 |  |  | 54927 |
| 54976 |  |  | 54928 |
| 54977 | pyPopulateArgumentConversionErrors(); |  | 54929 | pyPopulateArgumentConversionErrors();
| 54978 | } |  | 54930 | }
| 54979 | pyRaiseCVOverloadException("update"); |  | 54931 | pyRaiseCVOverloadException("update");
| 54980 |  |  | 54932 |
| 54981 | return NULL; |  | 54933 | return NULL;
| 54982 | } |  | 54934 | }
| 54983 |  |  | 54935 |
| 54984 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 54936 | static PyObject* pyopencv_cv_face_face_FaceRecognizer_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 54985 | { |  | 54937 | {
| 54986 | using namespace cv::face; |  | 54938 | using namespace cv::face;
| 54987 |  |  | 54939 |
| 54988 |  |  | 54940 |
| 54989 | Ptr<cv::face::FaceRecognizer> * self1 = 0; |  | 54941 | Ptr<cv::face::FaceRecognizer> * self1 = 0;
| 54990 | if (!pyopencv_face_FaceRecognizer_getp(self, self1)) |  | 54942 | if (!pyopencv_face_FaceRecognizer_getp(self, self1))
| 54991 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)"); |  | 54943 | return failmsgp("Incorrect type of self (must be 'face_FaceRecognizer' or its derivative)");
| 54992 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1); |  | 54944 | Ptr<cv::face::FaceRecognizer> _self_ = *(self1);
| 54993 | PyObject* pyobj_filename = NULL; |  | 54945 | PyObject* pyobj_filename = NULL;
| 54994 | String filename; |  | 54946 | String filename;
| 54995 |  |  | 54947 |
| 54996 | const char* keywords[] = { "filename", NULL }; |  | 54948 | const char* keywords[] = { "filename", NULL };
| 54997 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.write", (char**)keywords, &pyobj_filename) && |  | 54949 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_FaceRecognizer.write", (char**)keywords, &pyobj_filename) &&
| 54998 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 54950 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 54999 | { |  | 54951 | {
| 55000 | ERRWRAP2(_self_->write(filename)); |  | 54952 | ERRWRAP2(_self_->write(filename));
| 55001 | Py_RETURN_NONE; |  | 54953 | Py_RETURN_NONE;
| 55002 | } |  | 54954 | }
| 55003 |  |  | 54955 |
| 55004 | return NULL; |  | 54956 | return NULL;
| 55005 | } |  | 54957 | }
| 55006 |  |  | 54958 |
| 55007 |  |  | 54959 |
| 55008 |  |  | 54960 |
| 55009 | // Tables (face_FaceRecognizer) |  | 54961 | // Tables (face_FaceRecognizer)
| 55010 |  |  | 54962 |
| 55011 | static PyGetSetDef pyopencv_face_FaceRecognizer_getseters[] = |  | 54963 | static PyGetSetDef pyopencv_face_FaceRecognizer_getseters[] =
| 55012 | { |  | 54964 | {
| 55013 | {NULL} /* Sentinel */ |  | 54965 | {NULL} /* Sentinel */
| 55014 | }; |  | 54966 | };
| 55015 |  |  | 54967 |
| 55016 | static PyMethodDef pyopencv_face_FaceRecognizer_methods[] = |  | 54968 | static PyMethodDef pyopencv_face_FaceRecognizer_methods[] =
| 55017 | { |  | 54969 | {
| 55018 | {"getLabelInfo", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_getLabelInfo, 0), "getLabelInfo(label) -> retval\n. @brief Gets string information by label.\n. \n. If an unknown label id is provided or there is no label information associated with the specified\n. label id the method returns an empty string."}, |  | 54970 | {"getLabelInfo", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_getLabelInfo, 0), "getLabelInfo(label) -> retval\n. @brief Gets string information by label.\n. \n. If an unknown label id is provided or there is no label information associated with the specified\n. label id the method returns an empty string."},
| 55019 | {"getLabelsByString", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_getLabelsByString, 0), "getLabelsByString(str) -> retval\n. @brief Gets vector of labels by string.\n. \n. The function searches for the labels containing the specified sub-string in the associated string\n. info."}, |  | 54971 | {"getLabelsByString", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_getLabelsByString, 0), "getLabelsByString(str) -> retval\n. @brief Gets vector of labels by string.\n. \n. The function searches for the labels containing the specified sub-string in the associated string\n. info."},
| 55020 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_predict, 0), "predict(src) -> label, confidence\n. @brief Predicts a label and associated confidence (e.g. distance) for a given input image.\n. \n. @param src Sample image to get a prediction from.\n. @param label The predicted label for the given image.\n. @param confidence Associated confidence (e.g. distance) for the predicted label.\n. \n. The suffix const means that prediction does not affect the internal model state, so the method can\n. be safely called from within different threads.\n. \n. The following example shows how to get a prediction from a trained model:\n. \n. @code\n. using namespace cv;\n. // Do your initialization here (create the cv::FaceRecognizer model) ...\n. // ...\n. // Read in a sample image:\n. Mat img = imread(\"person1/3.jpg\", IMREAD_GRAYSCALE);\n. // And get a prediction from the cv::FaceRecognizer:\n. int predicted = model->predict(img);\n. @endcode\n. \n. Or to get a prediction and the associated confidence (e.g. distance):\n. \n. @code\n. using namespace cv;\n. // Do your initialization here (create the cv::FaceRecognizer model) ...\n. // ...\n. Mat img = imread(\"person1/3.jpg\", IMREAD_GRAYSCALE);\n. // Some variables for the predicted label and associated confidence (e.g. distance):\n. int predicted_label = -1;\n. double predicted_confidence = 0.0;\n. // Get the prediction and associated confidence from the model\n. model->predict(img, predicted_label, predicted_confidence);\n. @endcode"}, |  | 54972 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_predict, 0), "predict(src) -> label, confidence\n. @brief Predicts a label and associated confidence (e.g. distance) for a given input image.\n. \n. @param src Sample image to get a prediction from.\n. @param label The predicted label for the given image.\n. @param confidence Associated confidence (e.g. distance) for the predicted label.\n. \n. The suffix const means that prediction does not affect the internal model state, so the method can\n. be safely called from within different threads.\n. \n. The following example shows how to get a prediction from a trained model:\n. \n. @code\n. using namespace cv;\n. // Do your initialization here (create the cv::FaceRecognizer model) ...\n. // ...\n. // Read in a sample image:\n. Mat img = imread(\"person1/3.jpg\", IMREAD_GRAYSCALE);\n. // And get a prediction from the cv::FaceRecognizer:\n. int predicted = model->predict(img);\n. @endcode\n. \n. Or to get a prediction and the associated confidence (e.g. distance):\n. \n. @code\n. using namespace cv;\n. // Do your initialization here (create the cv::FaceRecognizer model) ...\n. // ...\n. Mat img = imread(\"person1/3.jpg\", IMREAD_GRAYSCALE);\n. // Some variables for the predicted label and associated confidence (e.g. distance):\n. int predicted_label = -1;\n. double predicted_confidence = 0.0;\n. // Get the prediction and associated confidence from the model\n. model->predict(img, predicted_label, predicted_confidence);\n. @endcode"},
| 55021 | {"predict_collect", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_predict_collect, 0), "predict_collect(src, collector) -> None\n. @brief - if implemented - send all result of prediction to collector that can be used for somehow custom result handling\n. @param src Sample image to get a prediction from.\n. @param collector User-defined collector object that accepts all results\n. \n. To implement this method u just have to do same internal cycle as in predict(InputArray src, CV_OUT int &label, CV_OUT double &confidence) but\n. not try to get \"best@ result, just resend it to caller side with given collector"}, |  | 54973 | {"predict_collect", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_predict_collect, 0), "predict_collect(src, collector) -> None\n. @brief - if implemented - send all result of prediction to collector that can be used for somehow custom result handling\n. @param src Sample image to get a prediction from.\n. @param collector User-defined collector object that accepts all results\n. \n. To implement this method u just have to do same internal cycle as in predict(InputArray src, CV_OUT int &label, CV_OUT double &confidence) but\n. not try to get \"best@ result, just resend it to caller side with given collector"},
| 55022 | {"predict_label", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_predict_label, 0), "predict_label(src) -> retval\n. @overload"}, |  | 54974 | {"predict_label", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_predict_label, 0), "predict_label(src) -> retval\n. @overload"},
| 55023 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_read, 0), "read(filename) -> None\n. @brief Loads a FaceRecognizer and its model state.\n. \n. Loads a persisted model and state from a given XML or YAML file . Every FaceRecognizer has to\n. overwrite FaceRecognizer::load(FileStorage& fs) to enable loading the model state.\n. FaceRecognizer::load(FileStorage& fs) in turn gets called by\n. FaceRecognizer::load(const String& filename), to ease saving a model."}, |  | 54975 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_read, 0), "read(filename) -> None\n. @brief Loads a FaceRecognizer and its model state.\n. \n. Loads a persisted model and state from a given XML or YAML file . Every FaceRecognizer has to\n. overwrite FaceRecognizer::load(FileStorage& fs) to enable loading the model state.\n. FaceRecognizer::load(FileStorage& fs) in turn gets called by\n. FaceRecognizer::load(const String& filename), to ease saving a model."},
| 55024 | {"setLabelInfo", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_setLabelInfo, 0), "setLabelInfo(label, strInfo) -> None\n. @brief Sets string info for the specified model's label.\n. \n. The string info is replaced by the provided value if it was set before for the specified label."}, |  | 54976 | {"setLabelInfo", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_setLabelInfo, 0), "setLabelInfo(label, strInfo) -> None\n. @brief Sets string info for the specified model's label.\n. \n. The string info is replaced by the provided value if it was set before for the specified label."},
| 55025 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_train, 0), "train(src, labels) -> None\n. @brief Trains a FaceRecognizer with given data and associated labels.\n. \n. @param src The training images, that means the faces you want to learn. The data has to be\n. given as a vector\\<Mat\\>.\n. @param labels The labels corresponding to the images have to be given either as a vector\\<int\\>\n. or a Mat of type CV_32SC1.\n. \n. The following source code snippet shows you how to learn a Fisherfaces model on a given set of\n. images. The images are read with imread and pushed into a std::vector\\<Mat\\>. The labels of each\n. image are stored within a std::vector\\<int\\> (you could also use a Mat of type CV_32SC1). Think of\n. the label as the subject (the person) this image belongs to, so same subjects (persons) should have\n. the same label. For the available FaceRecognizer you don't have to pay any attention to the order of\n. the labels, just make sure same persons have the same label:\n. \n. @code\n. // holds images and labels\n. vector<Mat> images;\n. vector<int> labels;\n. // using Mat of type CV_32SC1\n. // Mat labels(number_of_samples, 1, CV_32SC1);\n. // images for first person\n. images.push_back(imread(\"person0/0.jpg\", IMREAD_GRAYSCALE)); labels.push_back(0);\n. images.push_back(imread(\"person0/1.jpg\", IMREAD_GRAYSCALE)); labels.push_back(0);\n. images.push_back(imread(\"person0/2.jpg\", IMREAD_GRAYSCALE)); labels.push_back(0);\n. // images for second person\n. images.push_back(imread(\"person1/0.jpg\", IMREAD_GRAYSCALE)); labels.push_back(1);\n. images.push_back(imread(\"person1/1.jpg\", IMREAD_GRAYSCALE)); labels.push_back(1);\n. images.push_back(imread(\"person1/2.jpg\", IMREAD_GRAYSCALE)); labels.push_back(1);\n. @endcode\n. \n. Now that you have read some images, we can create a new FaceRecognizer. In this example I'll create\n. a Fisherfaces model and decide to keep all of the possible Fisherfaces:\n. \n. @code\n. // Create a new Fisherfaces model and retain all available Fisherfaces,\n. // this is the most common usage of this specific FaceRecognizer:\n. //\n. Ptr<FaceRecognizer> model = FisherFaceRecognizer::create();\n. @endcode\n. \n. And finally train it on the given dataset (the face images and labels):\n. \n. @code\n. // This is the common interface to train all of the available cv::FaceRecognizer\n. // implementations:\n. //\n. model->train(images, labels);\n. @endcode"}, |  | 54977 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_train, 0), "train(src, labels) -> None\n. @brief Trains a FaceRecognizer with given data and associated labels.\n. \n. @param src The training images, that means the faces you want to learn. The data has to be\n. given as a vector\\<Mat\\>.\n. @param labels The labels corresponding to the images have to be given either as a vector\\<int\\>\n. or a Mat of type CV_32SC1.\n. \n. The following source code snippet shows you how to learn a Fisherfaces model on a given set of\n. images. The images are read with imread and pushed into a std::vector\\<Mat\\>. The labels of each\n. image are stored within a std::vector\\<int\\> (you could also use a Mat of type CV_32SC1). Think of\n. the label as the subject (the person) this image belongs to, so same subjects (persons) should have\n. the same label. For the available FaceRecognizer you don't have to pay any attention to the order of\n. the labels, just make sure same persons have the same label:\n. \n. @code\n. // holds images and labels\n. vector<Mat> images;\n. vector<int> labels;\n. // using Mat of type CV_32SC1\n. // Mat labels(number_of_samples, 1, CV_32SC1);\n. // images for first person\n. images.push_back(imread(\"person0/0.jpg\", IMREAD_GRAYSCALE)); labels.push_back(0);\n. images.push_back(imread(\"person0/1.jpg\", IMREAD_GRAYSCALE)); labels.push_back(0);\n. images.push_back(imread(\"person0/2.jpg\", IMREAD_GRAYSCALE)); labels.push_back(0);\n. // images for second person\n. images.push_back(imread(\"person1/0.jpg\", IMREAD_GRAYSCALE)); labels.push_back(1);\n. images.push_back(imread(\"person1/1.jpg\", IMREAD_GRAYSCALE)); labels.push_back(1);\n. images.push_back(imread(\"person1/2.jpg\", IMREAD_GRAYSCALE)); labels.push_back(1);\n. @endcode\n. \n. Now that you have read some images, we can create a new FaceRecognizer. In this example I'll create\n. a Fisherfaces model and decide to keep all of the possible Fisherfaces:\n. \n. @code\n. // Create a new Fisherfaces model and retain all available Fisherfaces,\n. // this is the most common usage of this specific FaceRecognizer:\n. //\n. Ptr<FaceRecognizer> model = FisherFaceRecognizer::create();\n. @endcode\n. \n. And finally train it on the given dataset (the face images and labels):\n. \n. @code\n. // This is the common interface to train all of the available cv::FaceRecognizer\n. // implementations:\n. //\n. model->train(images, labels);\n. @endcode"},
| 55026 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_update, 0), "update(src, labels) -> None\n. @brief Updates a FaceRecognizer with given data and associated labels.\n. \n. @param src The training images, that means the faces you want to learn. The data has to be given\n. as a vector\\<Mat\\>.\n. @param labels The labels corresponding to the images have to be given either as a vector\\<int\\> or\n. a Mat of type CV_32SC1.\n. \n. This method updates a (probably trained) FaceRecognizer, but only if the algorithm supports it. The\n. Local Binary Patterns Histograms (LBPH) recognizer (see createLBPHFaceRecognizer) can be updated.\n. For the Eigenfaces and Fisherfaces method, this is algorithmically not possible and you have to\n. re-estimate the model with FaceRecognizer::train. In any case, a call to train empties the existing\n. model and learns a new model, while update does not delete any model data.\n. \n. @code\n. // Create a new LBPH model (it can be updated) and use the default parameters,\n. // this is the most common usage of this specific FaceRecognizer:\n. //\n. Ptr<FaceRecognizer> model = LBPHFaceRecognizer::create();\n. // This is the common interface to train all of the available cv::FaceRecognizer\n. // implementations:\n. //\n. model->train(images, labels);\n. // Some containers to hold new image:\n. vector<Mat> newImages;\n. vector<int> newLabels;\n. // You should add some images to the containers:\n. //\n. // ...\n. //\n. // Now updating the model is as easy as calling:\n. model->update(newImages,newLabels);\n. // This will preserve the old model data and extend the existing model\n. // with the new features extracted from newImages!\n. @endcode\n. \n. Calling update on an Eigenfaces model (see EigenFaceRecognizer::create), which doesn't support\n. updating, will throw an error similar to:\n. \n. @code\n. OpenCV Error: The function/feature is not implemented (This FaceRecognizer (FaceRecognizer.Eigenfaces) does not support updating, you have to use FaceRecognizer::train to update it.) in update, file /home/philipp/git/opencv/modules/contrib/src/facerec.cpp, line 305\n. terminate called after throwing an instance of 'cv::Exception'\n. @endcode\n. \n. @note The FaceRecognizer does not store your training images, because this would be very\n. memory intense and it's not the responsibility of te FaceRecognizer to do so. The caller is\n. responsible for maintaining the dataset, he want to work with."}, |  | 54978 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_update, 0), "update(src, labels) -> None\n. @brief Updates a FaceRecognizer with given data and associated labels.\n. \n. @param src The training images, that means the faces you want to learn. The data has to be given\n. as a vector\\<Mat\\>.\n. @param labels The labels corresponding to the images have to be given either as a vector\\<int\\> or\n. a Mat of type CV_32SC1.\n. \n. This method updates a (probably trained) FaceRecognizer, but only if the algorithm supports it. The\n. Local Binary Patterns Histograms (LBPH) recognizer (see createLBPHFaceRecognizer) can be updated.\n. For the Eigenfaces and Fisherfaces method, this is algorithmically not possible and you have to\n. re-estimate the model with FaceRecognizer::train. In any case, a call to train empties the existing\n. model and learns a new model, while update does not delete any model data.\n. \n. @code\n. // Create a new LBPH model (it can be updated) and use the default parameters,\n. // this is the most common usage of this specific FaceRecognizer:\n. //\n. Ptr<FaceRecognizer> model = LBPHFaceRecognizer::create();\n. // This is the common interface to train all of the available cv::FaceRecognizer\n. // implementations:\n. //\n. model->train(images, labels);\n. // Some containers to hold new image:\n. vector<Mat> newImages;\n. vector<int> newLabels;\n. // You should add some images to the containers:\n. //\n. // ...\n. //\n. // Now updating the model is as easy as calling:\n. model->update(newImages,newLabels);\n. // This will preserve the old model data and extend the existing model\n. // with the new features extracted from newImages!\n. @endcode\n. \n. Calling update on an Eigenfaces model (see EigenFaceRecognizer::create), which doesn't support\n. updating, will throw an error similar to:\n. \n. @code\n. OpenCV Error: The function/feature is not implemented (This FaceRecognizer (FaceRecognizer.Eigenfaces) does not support updating, you have to use FaceRecognizer::train to update it.) in update, file /home/philipp/git/opencv/modules/contrib/src/facerec.cpp, line 305\n. terminate called after throwing an instance of 'cv::Exception'\n. @endcode\n. \n. @note The FaceRecognizer does not store your training images, because this would be very\n. memory intense and it's not the responsibility of te FaceRecognizer to do so. The caller is\n. responsible for maintaining the dataset, he want to work with."},
| 55027 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_write, 0), "write(filename) -> None\n. @brief Saves a FaceRecognizer and its model state.\n. \n. Saves this model to a given filename, either as XML or YAML.\n. @param filename The filename to store this FaceRecognizer to (either XML/YAML).\n. \n. Every FaceRecognizer overwrites FaceRecognizer::save(FileStorage& fs) to save the internal model\n. state. FaceRecognizer::save(const String& filename) saves the state of a model to the given\n. filename.\n. \n. The suffix const means that prediction does not affect the internal model state, so the method can\n. be safely called from within different threads."}, |  | 54979 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FaceRecognizer_write, 0), "write(filename) -> None\n. @brief Saves a FaceRecognizer and its model state.\n. \n. Saves this model to a given filename, either as XML or YAML.\n. @param filename The filename to store this FaceRecognizer to (either XML/YAML).\n. \n. Every FaceRecognizer overwrites FaceRecognizer::save(FileStorage& fs) to save the internal model\n. state. FaceRecognizer::save(const String& filename) saves the state of a model to the given\n. filename.\n. \n. The suffix const means that prediction does not affect the internal model state, so the method can\n. be safely called from within different threads."},
| 55028 |  |  | 54980 |
| 55029 | {NULL, NULL} |  | 54981 | {NULL, NULL}
| 55030 | }; |  | 54982 | };
| 55031 |  |  | 54983 |
| 55032 | // Converter (face_FaceRecognizer) |  | 54984 | // Converter (face_FaceRecognizer)
| 55033 |  |  | 54985 |
| 55034 | template<> |  | 54986 | template<>
| 55035 | struct PyOpenCV_Converter< Ptr<cv::face::FaceRecognizer> > |  | 54987 | struct PyOpenCV_Converter< Ptr<cv::face::FaceRecognizer> >
| 55036 | { |  | 54988 | {
| 55037 | static PyObject* from(const Ptr<cv::face::FaceRecognizer>& r) |  | 54989 | static PyObject* from(const Ptr<cv::face::FaceRecognizer>& r)
| 55038 | { |  | 54990 | {
| 55039 | return pyopencv_face_FaceRecognizer_Instance(r); |  | 54991 | return pyopencv_face_FaceRecognizer_Instance(r);
| 55040 | } |  | 54992 | }
| 55041 | static bool to(PyObject* src, Ptr<cv::face::FaceRecognizer>& dst, const ArgInfo& info) |  | 54993 | static bool to(PyObject* src, Ptr<cv::face::FaceRecognizer>& dst, const ArgInfo& info)
| 55042 | { |  | 54994 | {
| 55043 | if(!src || src == Py_None) |  | 54995 | if(!src || src == Py_None)
| 55044 | return true; |  | 54996 | return true;
| 55045 | Ptr<cv::face::FaceRecognizer> * dst_; |  | 54997 | Ptr<cv::face::FaceRecognizer> * dst_;
| 55046 | if (pyopencv_face_FaceRecognizer_getp(src, dst_)) |  | 54998 | if (pyopencv_face_FaceRecognizer_getp(src, dst_))
| 55047 | { |  | 54999 | {
| 55048 | dst = *dst_; |  | 55000 | dst = *dst_;
| 55049 | return true; |  | 55001 | return true;
| 55050 | } |  | 55002 | }
| 55051 |  |  | 55003 |
| 55052 | failmsg("Expected Ptr<cv::face::FaceRecognizer> for argument '%s'", info.name); |  | 55004 | failmsg("Expected Ptr<cv::face::FaceRecognizer> for argument '%s'", info.name);
| 55053 | return false; |  | 55005 | return false;
| 55054 | } |  | 55006 | }
| 55055 | }; |  | 55007 | };
| 55056 |  |  | 55008 |
| 55057 | //================================================================================ |  | 55009 | //================================================================================
| 55058 | // face_Facemark (Generic) |  | 55010 | // face_Facemark (Generic)
| 55059 | //================================================================================ |  | 55011 | //================================================================================
| 55060 |  |  | 55012 |
| 55061 | // GetSet (face_Facemark) |  | 55013 | // GetSet (face_Facemark)
| 55062 |  |  | 55014 |
| 55063 |  |  | 55015 |
| 55064 |  |  | 55016 |
| 55065 | // Methods (face_Facemark) |  | 55017 | // Methods (face_Facemark)
| 55066 |  |  | 55018 |
| 55067 | static PyObject* pyopencv_cv_face_face_Facemark_fit(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55019 | static PyObject* pyopencv_cv_face_face_Facemark_fit(PyObject* self, PyObject* py_args, PyObject* kw)
| 55068 | { |  | 55020 | {
| 55069 | using namespace cv::face; |  | 55021 | using namespace cv::face;
| 55070 |  |  | 55022 |
| 55071 |  |  | 55023 |
| 55072 | Ptr<cv::face::Facemark> * self1 = 0; |  | 55024 | Ptr<cv::face::Facemark> * self1 = 0;
| 55073 | if (!pyopencv_face_Facemark_getp(self, self1)) |  | 55025 | if (!pyopencv_face_Facemark_getp(self, self1))
| 55074 | return failmsgp("Incorrect type of self (must be 'face_Facemark' or its derivative)"); |  | 55026 | return failmsgp("Incorrect type of self (must be 'face_Facemark' or its derivative)");
| 55075 | Ptr<cv::face::Facemark> _self_ = *(self1); |  | 55027 | Ptr<cv::face::Facemark> _self_ = *(self1);
| 55076 | pyPrepareArgumentConversionErrorsStorage(2); |  | 55028 | pyPrepareArgumentConversionErrorsStorage(2);
| 55077 |  |  | 55029 |
| 55078 | { |  | 55030 | {
| 55079 | PyObject* pyobj_image = NULL; |  | 55031 | PyObject* pyobj_image = NULL;
| 55080 | Mat image; |  | 55032 | Mat image;
| 55081 | PyObject* pyobj_faces = NULL; |  | 55033 | PyObject* pyobj_faces = NULL;
| 55082 | Mat faces; |  | 55034 | Mat faces;
| 55083 | PyObject* pyobj_landmarks = NULL; |  | 55035 | PyObject* pyobj_landmarks = NULL;
| 55084 | vector_Mat landmarks; |  | 55036 | vector_Mat landmarks;
| 55085 | bool retval; |  | 55037 | bool retval;
| 55086 |  |  | 55038 |
| 55087 | const char* keywords[] = { "image", "faces", "landmarks", NULL }; |  | 55039 | const char* keywords[] = { "image", "faces", "landmarks", NULL };
| 55088 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:face_Facemark.fit", (char**)keywords, &pyobj_image, &pyobj_faces, &pyobj_landmarks) && |  | 55040 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:face_Facemark.fit", (char**)keywords, &pyobj_image, &pyobj_faces, &pyobj_landmarks) &&
| 55089 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 55041 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 55090 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 0)) && |  | 55042 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 0)) &&
| 55091 | pyopencv_to_safe(pyobj_landmarks, landmarks, ArgInfo("landmarks", 1)) ) |  | 55043 | pyopencv_to_safe(pyobj_landmarks, landmarks, ArgInfo("landmarks", 1)) )
| 55092 | { |  | 55044 | {
| 55093 | ERRWRAP2(retval = _self_->fit(image, faces, landmarks)); |  | 55045 | ERRWRAP2(retval = _self_->fit(image, faces, landmarks));
| 55094 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(landmarks)); |  | 55046 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(landmarks));
| 55095 | } |  | 55047 | }
| 55096 |  |  | 55048 |
| 55097 |  |  | 55049 |
| 55098 | pyPopulateArgumentConversionErrors(); |  | 55050 | pyPopulateArgumentConversionErrors();
| 55099 | } |  | 55051 | }
| 55100 |  |  | 55052 |
| 55101 |  |  | 55053 |
| 55102 | { |  | 55054 | {
| 55103 | PyObject* pyobj_image = NULL; |  | 55055 | PyObject* pyobj_image = NULL;
| 55104 | UMat image; |  | 55056 | UMat image;
| 55105 | PyObject* pyobj_faces = NULL; |  | 55057 | PyObject* pyobj_faces = NULL;
| 55106 | UMat faces; |  | 55058 | UMat faces;
| 55107 | PyObject* pyobj_landmarks = NULL; |  | 55059 | PyObject* pyobj_landmarks = NULL;
| 55108 | vector_UMat landmarks; |  | 55060 | vector_UMat landmarks;
| 55109 | bool retval; |  | 55061 | bool retval;
| 55110 |  |  | 55062 |
| 55111 | const char* keywords[] = { "image", "faces", "landmarks", NULL }; |  | 55063 | const char* keywords[] = { "image", "faces", "landmarks", NULL };
| 55112 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:face_Facemark.fit", (char**)keywords, &pyobj_image, &pyobj_faces, &pyobj_landmarks) && |  | 55064 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:face_Facemark.fit", (char**)keywords, &pyobj_image, &pyobj_faces, &pyobj_landmarks) &&
| 55113 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 55065 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 55114 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 0)) && |  | 55066 | pyopencv_to_safe(pyobj_faces, faces, ArgInfo("faces", 0)) &&
| 55115 | pyopencv_to_safe(pyobj_landmarks, landmarks, ArgInfo("landmarks", 1)) ) |  | 55067 | pyopencv_to_safe(pyobj_landmarks, landmarks, ArgInfo("landmarks", 1)) )
| 55116 | { |  | 55068 | {
| 55117 | ERRWRAP2(retval = _self_->fit(image, faces, landmarks)); |  | 55069 | ERRWRAP2(retval = _self_->fit(image, faces, landmarks));
| 55118 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(landmarks)); |  | 55070 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(landmarks));
| 55119 | } |  | 55071 | }
| 55120 |  |  | 55072 |
| 55121 |  |  | 55073 |
| 55122 | pyPopulateArgumentConversionErrors(); |  | 55074 | pyPopulateArgumentConversionErrors();
| 55123 | } |  | 55075 | }
| 55124 | pyRaiseCVOverloadException("fit"); |  | 55076 | pyRaiseCVOverloadException("fit");
| 55125 |  |  | 55077 |
| 55126 | return NULL; |  | 55078 | return NULL;
| 55127 | } |  | 55079 | }
| 55128 |  |  | 55080 |
| 55129 | static PyObject* pyopencv_cv_face_face_Facemark_loadModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55081 | static PyObject* pyopencv_cv_face_face_Facemark_loadModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 55130 | { |  | 55082 | {
| 55131 | using namespace cv::face; |  | 55083 | using namespace cv::face;
| 55132 |  |  | 55084 |
| 55133 |  |  | 55085 |
| 55134 | Ptr<cv::face::Facemark> * self1 = 0; |  | 55086 | Ptr<cv::face::Facemark> * self1 = 0;
| 55135 | if (!pyopencv_face_Facemark_getp(self, self1)) |  | 55087 | if (!pyopencv_face_Facemark_getp(self, self1))
| 55136 | return failmsgp("Incorrect type of self (must be 'face_Facemark' or its derivative)"); |  | 55088 | return failmsgp("Incorrect type of self (must be 'face_Facemark' or its derivative)");
| 55137 | Ptr<cv::face::Facemark> _self_ = *(self1); |  | 55089 | Ptr<cv::face::Facemark> _self_ = *(self1);
| 55138 | PyObject* pyobj_model = NULL; |  | 55090 | PyObject* pyobj_model = NULL;
| 55139 | String model; |  | 55091 | String model;
| 55140 |  |  | 55092 |
| 55141 | const char* keywords[] = { "model", NULL }; |  | 55093 | const char* keywords[] = { "model", NULL };
| 55142 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_Facemark.loadModel", (char**)keywords, &pyobj_model) && |  | 55094 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_Facemark.loadModel", (char**)keywords, &pyobj_model) &&
| 55143 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) ) |  | 55095 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) )
| 55144 | { |  | 55096 | {
| 55145 | ERRWRAP2(_self_->loadModel(model)); |  | 55097 | ERRWRAP2(_self_->loadModel(model));
| 55146 | Py_RETURN_NONE; |  | 55098 | Py_RETURN_NONE;
| 55147 | } |  | 55099 | }
| 55148 |  |  | 55100 |
| 55149 | return NULL; |  | 55101 | return NULL;
| 55150 | } |  | 55102 | }
| 55151 |  |  | 55103 |
| 55152 |  |  | 55104 |
| 55153 |  |  | 55105 |
| 55154 | // Tables (face_Facemark) |  | 55106 | // Tables (face_Facemark)
| 55155 |  |  | 55107 |
| 55156 | static PyGetSetDef pyopencv_face_Facemark_getseters[] = |  | 55108 | static PyGetSetDef pyopencv_face_Facemark_getseters[] =
| 55157 | { |  | 55109 | {
| 55158 | {NULL} /* Sentinel */ |  | 55110 | {NULL} /* Sentinel */
| 55159 | }; |  | 55111 | };
| 55160 |  |  | 55112 |
| 55161 | static PyMethodDef pyopencv_face_Facemark_methods[] = |  | 55113 | static PyMethodDef pyopencv_face_Facemark_methods[] =
| 55162 | { |  | 55114 | {
| 55163 | {"fit", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_Facemark_fit, 0), "fit(image, faces[, landmarks]) -> retval, landmarks\n. @brief Detect facial landmarks from an image.\n. @param image Input image.\n. @param faces Output of the function which represent region of interest of the detected faces.\n. Each face is stored in cv::Rect container.\n. @param landmarks The detected landmark points for each faces.\n. \n. <B>Example of usage</B>\n. @code\n. Mat image = imread(\"image.jpg\");\n. std::vector<Rect> faces;\n. std::vector<std::vector<Point2f> > landmarks;\n. facemark->fit(image, faces, landmarks);\n. @endcode"}, |  | 55115 | {"fit", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_Facemark_fit, 0), "fit(image, faces[, landmarks]) -> retval, landmarks\n. @brief Detect facial landmarks from an image.\n. @param image Input image.\n. @param faces Output of the function which represent region of interest of the detected faces.\n. Each face is stored in cv::Rect container.\n. @param landmarks The detected landmark points for each faces.\n. \n. <B>Example of usage</B>\n. @code\n. Mat image = imread(\"image.jpg\");\n. std::vector<Rect> faces;\n. std::vector<std::vector<Point2f> > landmarks;\n. facemark->fit(image, faces, landmarks);\n. @endcode"},
| 55164 | {"loadModel", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_Facemark_loadModel, 0), "loadModel(model) -> None\n. @brief A function to load the trained model before the fitting process.\n. @param model A string represent the filename of a trained model.\n. \n. <B>Example of usage</B>\n. @code\n. facemark->loadModel(\"../data/lbf.model\");\n. @endcode"}, |  | 55116 | {"loadModel", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_Facemark_loadModel, 0), "loadModel(model) -> None\n. @brief A function to load the trained model before the fitting process.\n. @param model A string represent the filename of a trained model.\n. \n. <B>Example of usage</B>\n. @code\n. facemark->loadModel(\"../data/lbf.model\");\n. @endcode"},
| 55165 |  |  | 55117 |
| 55166 | {NULL, NULL} |  | 55118 | {NULL, NULL}
| 55167 | }; |  | 55119 | };
| 55168 |  |  | 55120 |
| 55169 | // Converter (face_Facemark) |  | 55121 | // Converter (face_Facemark)
| 55170 |  |  | 55122 |
| 55171 | template<> |  | 55123 | template<>
| 55172 | struct PyOpenCV_Converter< Ptr<cv::face::Facemark> > |  | 55124 | struct PyOpenCV_Converter< Ptr<cv::face::Facemark> >
| 55173 | { |  | 55125 | {
| 55174 | static PyObject* from(const Ptr<cv::face::Facemark>& r) |  | 55126 | static PyObject* from(const Ptr<cv::face::Facemark>& r)
| 55175 | { |  | 55127 | {
| 55176 | return pyopencv_face_Facemark_Instance(r); |  | 55128 | return pyopencv_face_Facemark_Instance(r);
| 55177 | } |  | 55129 | }
| 55178 | static bool to(PyObject* src, Ptr<cv::face::Facemark>& dst, const ArgInfo& info) |  | 55130 | static bool to(PyObject* src, Ptr<cv::face::Facemark>& dst, const ArgInfo& info)
| 55179 | { |  | 55131 | {
| 55180 | if(!src || src == Py_None) |  | 55132 | if(!src || src == Py_None)
| 55181 | return true; |  | 55133 | return true;
| 55182 | Ptr<cv::face::Facemark> * dst_; |  | 55134 | Ptr<cv::face::Facemark> * dst_;
| 55183 | if (pyopencv_face_Facemark_getp(src, dst_)) |  | 55135 | if (pyopencv_face_Facemark_getp(src, dst_))
| 55184 | { |  | 55136 | {
| 55185 | dst = *dst_; |  | 55137 | dst = *dst_;
| 55186 | return true; |  | 55138 | return true;
| 55187 | } |  | 55139 | }
| 55188 |  |  | 55140 |
| 55189 | failmsg("Expected Ptr<cv::face::Facemark> for argument '%s'", info.name); |  | 55141 | failmsg("Expected Ptr<cv::face::Facemark> for argument '%s'", info.name);
| 55190 | return false; |  | 55142 | return false;
| 55191 | } |  | 55143 | }
| 55192 | }; |  | 55144 | };
| 55193 |  |  | 55145 |
| 55194 | //================================================================================ |  | 55146 | //================================================================================
| 55195 | // face_FacemarkAAM (Generic) |  | 55147 | // face_FacemarkAAM (Generic)
| 55196 | //================================================================================ |  | 55148 | //================================================================================
| 55197 |  |  | 55149 |
| 55198 | // GetSet (face_FacemarkAAM) |  | 55150 | // GetSet (face_FacemarkAAM)
| 55199 |  |  | 55151 |
| 55200 |  |  | 55152 |
| 55201 |  |  | 55153 |
| 55202 | // Methods (face_FacemarkAAM) |  | 55154 | // Methods (face_FacemarkAAM)
| 55203 |  |  | 55155 |
| 55204 |  |  | 55156 |
| 55205 |  |  | 55157 |
| 55206 | // Tables (face_FacemarkAAM) |  | 55158 | // Tables (face_FacemarkAAM)
| 55207 |  |  | 55159 |
| 55208 | static PyGetSetDef pyopencv_face_FacemarkAAM_getseters[] = |  | 55160 | static PyGetSetDef pyopencv_face_FacemarkAAM_getseters[] =
| 55209 | { |  | 55161 | {
| 55210 | {NULL} /* Sentinel */ |  | 55162 | {NULL} /* Sentinel */
| 55211 | }; |  | 55163 | };
| 55212 |  |  | 55164 |
| 55213 | static PyMethodDef pyopencv_face_FacemarkAAM_methods[] = |  | 55165 | static PyMethodDef pyopencv_face_FacemarkAAM_methods[] =
| 55214 | { |  | 55166 | {
| 55215 |  |  | 55167 |
| 55216 | {NULL, NULL} |  | 55168 | {NULL, NULL}
| 55217 | }; |  | 55169 | };
| 55218 |  |  | 55170 |
| 55219 | // Converter (face_FacemarkAAM) |  | 55171 | // Converter (face_FacemarkAAM)
| 55220 |  |  | 55172 |
| 55221 | template<> |  | 55173 | template<>
| 55222 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkAAM> > |  | 55174 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkAAM> >
| 55223 | { |  | 55175 | {
| 55224 | static PyObject* from(const Ptr<cv::face::FacemarkAAM>& r) |  | 55176 | static PyObject* from(const Ptr<cv::face::FacemarkAAM>& r)
| 55225 | { |  | 55177 | {
| 55226 | return pyopencv_face_FacemarkAAM_Instance(r); |  | 55178 | return pyopencv_face_FacemarkAAM_Instance(r);
| 55227 | } |  | 55179 | }
| 55228 | static bool to(PyObject* src, Ptr<cv::face::FacemarkAAM>& dst, const ArgInfo& info) |  | 55180 | static bool to(PyObject* src, Ptr<cv::face::FacemarkAAM>& dst, const ArgInfo& info)
| 55229 | { |  | 55181 | {
| 55230 | if(!src || src == Py_None) |  | 55182 | if(!src || src == Py_None)
| 55231 | return true; |  | 55183 | return true;
| 55232 | Ptr<cv::face::FacemarkAAM> * dst_; |  | 55184 | Ptr<cv::face::FacemarkAAM> * dst_;
| 55233 | if (pyopencv_face_FacemarkAAM_getp(src, dst_)) |  | 55185 | if (pyopencv_face_FacemarkAAM_getp(src, dst_))
| 55234 | { |  | 55186 | {
| 55235 | dst = *dst_; |  | 55187 | dst = *dst_;
| 55236 | return true; |  | 55188 | return true;
| 55237 | } |  | 55189 | }
| 55238 |  |  | 55190 |
| 55239 | failmsg("Expected Ptr<cv::face::FacemarkAAM> for argument '%s'", info.name); |  | 55191 | failmsg("Expected Ptr<cv::face::FacemarkAAM> for argument '%s'", info.name);
| 55240 | return false; |  | 55192 | return false;
| 55241 | } |  | 55193 | }
| 55242 | }; |  | 55194 | };
| 55243 |  |  | 55195 |
| 55244 | //================================================================================ |  | 55196 | //================================================================================
| 55245 | // face_FacemarkKazemi (Generic) |  | 55197 | // face_FacemarkKazemi (Generic)
| 55246 | //================================================================================ |  | 55198 | //================================================================================
| 55247 |  |  | 55199 |
| 55248 | // GetSet (face_FacemarkKazemi) |  | 55200 | // GetSet (face_FacemarkKazemi)
| 55249 |  |  | 55201 |
| 55250 |  |  | 55202 |
| 55251 |  |  | 55203 |
| 55252 | // Methods (face_FacemarkKazemi) |  | 55204 | // Methods (face_FacemarkKazemi)
| 55253 |  |  | 55205 |
| 55254 |  |  | 55206 |
| 55255 |  |  | 55207 |
| 55256 | // Tables (face_FacemarkKazemi) |  | 55208 | // Tables (face_FacemarkKazemi)
| 55257 |  |  | 55209 |
| 55258 | static PyGetSetDef pyopencv_face_FacemarkKazemi_getseters[] = |  | 55210 | static PyGetSetDef pyopencv_face_FacemarkKazemi_getseters[] =
| 55259 | { |  | 55211 | {
| 55260 | {NULL} /* Sentinel */ |  | 55212 | {NULL} /* Sentinel */
| 55261 | }; |  | 55213 | };
| 55262 |  |  | 55214 |
| 55263 | static PyMethodDef pyopencv_face_FacemarkKazemi_methods[] = |  | 55215 | static PyMethodDef pyopencv_face_FacemarkKazemi_methods[] =
| 55264 | { |  | 55216 | {
| 55265 |  |  | 55217 |
| 55266 | {NULL, NULL} |  | 55218 | {NULL, NULL}
| 55267 | }; |  | 55219 | };
| 55268 |  |  | 55220 |
| 55269 | // Converter (face_FacemarkKazemi) |  | 55221 | // Converter (face_FacemarkKazemi)
| 55270 |  |  | 55222 |
| 55271 | template<> |  | 55223 | template<>
| 55272 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkKazemi> > |  | 55224 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkKazemi> >
| 55273 | { |  | 55225 | {
| 55274 | static PyObject* from(const Ptr<cv::face::FacemarkKazemi>& r) |  | 55226 | static PyObject* from(const Ptr<cv::face::FacemarkKazemi>& r)
| 55275 | { |  | 55227 | {
| 55276 | return pyopencv_face_FacemarkKazemi_Instance(r); |  | 55228 | return pyopencv_face_FacemarkKazemi_Instance(r);
| 55277 | } |  | 55229 | }
| 55278 | static bool to(PyObject* src, Ptr<cv::face::FacemarkKazemi>& dst, const ArgInfo& info) |  | 55230 | static bool to(PyObject* src, Ptr<cv::face::FacemarkKazemi>& dst, const ArgInfo& info)
| 55279 | { |  | 55231 | {
| 55280 | if(!src || src == Py_None) |  | 55232 | if(!src || src == Py_None)
| 55281 | return true; |  | 55233 | return true;
| 55282 | Ptr<cv::face::FacemarkKazemi> * dst_; |  | 55234 | Ptr<cv::face::FacemarkKazemi> * dst_;
| 55283 | if (pyopencv_face_FacemarkKazemi_getp(src, dst_)) |  | 55235 | if (pyopencv_face_FacemarkKazemi_getp(src, dst_))
| 55284 | { |  | 55236 | {
| 55285 | dst = *dst_; |  | 55237 | dst = *dst_;
| 55286 | return true; |  | 55238 | return true;
| 55287 | } |  | 55239 | }
| 55288 |  |  | 55240 |
| 55289 | failmsg("Expected Ptr<cv::face::FacemarkKazemi> for argument '%s'", info.name); |  | 55241 | failmsg("Expected Ptr<cv::face::FacemarkKazemi> for argument '%s'", info.name);
| 55290 | return false; |  | 55242 | return false;
| 55291 | } |  | 55243 | }
| 55292 | }; |  | 55244 | };
| 55293 |  |  | 55245 |
| 55294 | //================================================================================ |  | 55246 | //================================================================================
| 55295 | // face_FacemarkLBF (Generic) |  | 55247 | // face_FacemarkLBF (Generic)
| 55296 | //================================================================================ |  | 55248 | //================================================================================
| 55297 |  |  | 55249 |
| 55298 | // GetSet (face_FacemarkLBF) |  | 55250 | // GetSet (face_FacemarkLBF)
| 55299 |  |  | 55251 |
| 55300 |  |  | 55252 |
| 55301 |  |  | 55253 |
| 55302 | // Methods (face_FacemarkLBF) |  | 55254 | // Methods (face_FacemarkLBF)
| 55303 |  |  | 55255 |
| 55304 |  |  | 55256 |
| 55305 |  |  | 55257 |
| 55306 | // Tables (face_FacemarkLBF) |  | 55258 | // Tables (face_FacemarkLBF)
| 55307 |  |  | 55259 |
| 55308 | static PyGetSetDef pyopencv_face_FacemarkLBF_getseters[] = |  | 55260 | static PyGetSetDef pyopencv_face_FacemarkLBF_getseters[] =
| 55309 | { |  | 55261 | {
| 55310 | {NULL} /* Sentinel */ |  | 55262 | {NULL} /* Sentinel */
| 55311 | }; |  | 55263 | };
| 55312 |  |  | 55264 |
| 55313 | static PyMethodDef pyopencv_face_FacemarkLBF_methods[] = |  | 55265 | static PyMethodDef pyopencv_face_FacemarkLBF_methods[] =
| 55314 | { |  | 55266 | {
| 55315 |  |  | 55267 |
| 55316 | {NULL, NULL} |  | 55268 | {NULL, NULL}
| 55317 | }; |  | 55269 | };
| 55318 |  |  | 55270 |
| 55319 | // Converter (face_FacemarkLBF) |  | 55271 | // Converter (face_FacemarkLBF)
| 55320 |  |  | 55272 |
| 55321 | template<> |  | 55273 | template<>
| 55322 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkLBF> > |  | 55274 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkLBF> >
| 55323 | { |  | 55275 | {
| 55324 | static PyObject* from(const Ptr<cv::face::FacemarkLBF>& r) |  | 55276 | static PyObject* from(const Ptr<cv::face::FacemarkLBF>& r)
| 55325 | { |  | 55277 | {
| 55326 | return pyopencv_face_FacemarkLBF_Instance(r); |  | 55278 | return pyopencv_face_FacemarkLBF_Instance(r);
| 55327 | } |  | 55279 | }
| 55328 | static bool to(PyObject* src, Ptr<cv::face::FacemarkLBF>& dst, const ArgInfo& info) |  | 55280 | static bool to(PyObject* src, Ptr<cv::face::FacemarkLBF>& dst, const ArgInfo& info)
| 55329 | { |  | 55281 | {
| 55330 | if(!src || src == Py_None) |  | 55282 | if(!src || src == Py_None)
| 55331 | return true; |  | 55283 | return true;
| 55332 | Ptr<cv::face::FacemarkLBF> * dst_; |  | 55284 | Ptr<cv::face::FacemarkLBF> * dst_;
| 55333 | if (pyopencv_face_FacemarkLBF_getp(src, dst_)) |  | 55285 | if (pyopencv_face_FacemarkLBF_getp(src, dst_))
| 55334 | { |  | 55286 | {
| 55335 | dst = *dst_; |  | 55287 | dst = *dst_;
| 55336 | return true; |  | 55288 | return true;
| 55337 | } |  | 55289 | }
| 55338 |  |  | 55290 |
| 55339 | failmsg("Expected Ptr<cv::face::FacemarkLBF> for argument '%s'", info.name); |  | 55291 | failmsg("Expected Ptr<cv::face::FacemarkLBF> for argument '%s'", info.name);
| 55340 | return false; |  | 55292 | return false;
| 55341 | } |  | 55293 | }
| 55342 | }; |  | 55294 | };
| 55343 |  |  | 55295 |
| 55344 | //================================================================================ |  | 55296 | //================================================================================
| 55345 | // face_FacemarkTrain (Generic) |  | 55297 | // face_FacemarkTrain (Generic)
| 55346 | //================================================================================ |  | 55298 | //================================================================================
| 55347 |  |  | 55299 |
| 55348 | // GetSet (face_FacemarkTrain) |  | 55300 | // GetSet (face_FacemarkTrain)
| 55349 |  |  | 55301 |
| 55350 |  |  | 55302 |
| 55351 |  |  | 55303 |
| 55352 | // Methods (face_FacemarkTrain) |  | 55304 | // Methods (face_FacemarkTrain)
| 55353 |  |  | 55305 |
| 55354 |  |  | 55306 |
| 55355 |  |  | 55307 |
| 55356 | // Tables (face_FacemarkTrain) |  | 55308 | // Tables (face_FacemarkTrain)
| 55357 |  |  | 55309 |
| 55358 | static PyGetSetDef pyopencv_face_FacemarkTrain_getseters[] = |  | 55310 | static PyGetSetDef pyopencv_face_FacemarkTrain_getseters[] =
| 55359 | { |  | 55311 | {
| 55360 | {NULL} /* Sentinel */ |  | 55312 | {NULL} /* Sentinel */
| 55361 | }; |  | 55313 | };
| 55362 |  |  | 55314 |
| 55363 | static PyMethodDef pyopencv_face_FacemarkTrain_methods[] = |  | 55315 | static PyMethodDef pyopencv_face_FacemarkTrain_methods[] =
| 55364 | { |  | 55316 | {
| 55365 |  |  | 55317 |
| 55366 | {NULL, NULL} |  | 55318 | {NULL, NULL}
| 55367 | }; |  | 55319 | };
| 55368 |  |  | 55320 |
| 55369 | // Converter (face_FacemarkTrain) |  | 55321 | // Converter (face_FacemarkTrain)
| 55370 |  |  | 55322 |
| 55371 | template<> |  | 55323 | template<>
| 55372 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkTrain> > |  | 55324 | struct PyOpenCV_Converter< Ptr<cv::face::FacemarkTrain> >
| 55373 | { |  | 55325 | {
| 55374 | static PyObject* from(const Ptr<cv::face::FacemarkTrain>& r) |  | 55326 | static PyObject* from(const Ptr<cv::face::FacemarkTrain>& r)
| 55375 | { |  | 55327 | {
| 55376 | return pyopencv_face_FacemarkTrain_Instance(r); |  | 55328 | return pyopencv_face_FacemarkTrain_Instance(r);
| 55377 | } |  | 55329 | }
| 55378 | static bool to(PyObject* src, Ptr<cv::face::FacemarkTrain>& dst, const ArgInfo& info) |  | 55330 | static bool to(PyObject* src, Ptr<cv::face::FacemarkTrain>& dst, const ArgInfo& info)
| 55379 | { |  | 55331 | {
| 55380 | if(!src || src == Py_None) |  | 55332 | if(!src || src == Py_None)
| 55381 | return true; |  | 55333 | return true;
| 55382 | Ptr<cv::face::FacemarkTrain> * dst_; |  | 55334 | Ptr<cv::face::FacemarkTrain> * dst_;
| 55383 | if (pyopencv_face_FacemarkTrain_getp(src, dst_)) |  | 55335 | if (pyopencv_face_FacemarkTrain_getp(src, dst_))
| 55384 | { |  | 55336 | {
| 55385 | dst = *dst_; |  | 55337 | dst = *dst_;
| 55386 | return true; |  | 55338 | return true;
| 55387 | } |  | 55339 | }
| 55388 |  |  | 55340 |
| 55389 | failmsg("Expected Ptr<cv::face::FacemarkTrain> for argument '%s'", info.name); |  | 55341 | failmsg("Expected Ptr<cv::face::FacemarkTrain> for argument '%s'", info.name);
| 55390 | return false; |  | 55342 | return false;
| 55391 | } |  | 55343 | }
| 55392 | }; |  | 55344 | };
| 55393 |  |  | 55345 |
| 55394 | //================================================================================ |  | 55346 | //================================================================================
| 55395 | // face_FisherFaceRecognizer (Generic) |  | 55347 | // face_FisherFaceRecognizer (Generic)
| 55396 | //================================================================================ |  | 55348 | //================================================================================
| 55397 |  |  | 55349 |
| 55398 | // GetSet (face_FisherFaceRecognizer) |  | 55350 | // GetSet (face_FisherFaceRecognizer)
| 55399 |  |  | 55351 |
| 55400 |  |  | 55352 |
| 55401 |  |  | 55353 |
| 55402 | // Methods (face_FisherFaceRecognizer) |  | 55354 | // Methods (face_FisherFaceRecognizer)
| 55403 |  |  | 55355 |
| 55404 | static PyObject* pyopencv_cv_face_face_FisherFaceRecognizer_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55356 | static PyObject* pyopencv_cv_face_face_FisherFaceRecognizer_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 55405 | { |  | 55357 | {
| 55406 | using namespace cv::face; |  | 55358 | using namespace cv::face;
| 55407 |  |  | 55359 |
| 55408 | PyObject* pyobj_num_components = NULL; |  | 55360 | PyObject* pyobj_num_components = NULL;
| 55409 | int num_components=0; |  | 55361 | int num_components=0;
| 55410 | PyObject* pyobj_threshold = NULL; |  | 55362 | PyObject* pyobj_threshold = NULL;
| 55411 | double threshold=DBL_MAX; |  | 55363 | double threshold=DBL_MAX;
| 55412 | Ptr<FisherFaceRecognizer> retval; |  | 55364 | Ptr<FisherFaceRecognizer> retval;
| 55413 |  |  | 55365 |
| 55414 | const char* keywords[] = { "num_components", "threshold", NULL }; |  | 55366 | const char* keywords[] = { "num_components", "threshold", NULL };
| 55415 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:face_FisherFaceRecognizer.create", (char**)keywords, &pyobj_num_components, &pyobj_threshold) && |  | 55367 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:face_FisherFaceRecognizer.create", (char**)keywords, &pyobj_num_components, &pyobj_threshold) &&
| 55416 | pyopencv_to_safe(pyobj_num_components, num_components, ArgInfo("num_components", 0)) && |  | 55368 | pyopencv_to_safe(pyobj_num_components, num_components, ArgInfo("num_components", 0)) &&
| 55417 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 55369 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 55418 | { |  | 55370 | {
| 55419 | ERRWRAP2(retval = cv::face::FisherFaceRecognizer::create(num_components, threshold)); |  | 55371 | ERRWRAP2(retval = cv::face::FisherFaceRecognizer::create(num_components, threshold));
| 55420 | return pyopencv_from(retval); |  | 55372 | return pyopencv_from(retval);
| 55421 | } |  | 55373 | }
| 55422 |  |  | 55374 |
| 55423 | return NULL; |  | 55375 | return NULL;
| 55424 | } |  | 55376 | }
| 55425 |  |  | 55377 |
| 55426 |  |  | 55378 |
| 55427 |  |  | 55379 |
| 55428 | // Tables (face_FisherFaceRecognizer) |  | 55380 | // Tables (face_FisherFaceRecognizer)
| 55429 |  |  | 55381 |
| 55430 | static PyGetSetDef pyopencv_face_FisherFaceRecognizer_getseters[] = |  | 55382 | static PyGetSetDef pyopencv_face_FisherFaceRecognizer_getseters[] =
| 55431 | { |  | 55383 | {
| 55432 | {NULL} /* Sentinel */ |  | 55384 | {NULL} /* Sentinel */
| 55433 | }; |  | 55385 | };
| 55434 |  |  | 55386 |
| 55435 | static PyMethodDef pyopencv_face_FisherFaceRecognizer_methods[] = |  | 55387 | static PyMethodDef pyopencv_face_FisherFaceRecognizer_methods[] =
| 55436 | { |  | 55388 | {
| 55437 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FisherFaceRecognizer_create_static, METH_STATIC), "create([, num_components[, threshold]]) -> retval\n. @param num_components The number of components (read: Fisherfaces) kept for this Linear\n. Discriminant Analysis with the Fisherfaces criterion. It's useful to keep all components, that\n. means the number of your classes c (read: subjects, persons you want to recognize). If you leave\n. this at the default (0) or set it to a value less-equal 0 or greater (c-1), it will be set to the\n. correct number (c-1) automatically.\n. @param threshold The threshold applied in the prediction. If the distance to the nearest neighbor\n. is larger than the threshold, this method returns -1.\n. \n. ### Notes:\n. \n. - Training and prediction must be done on grayscale images, use cvtColor to convert between the\n. color spaces.\n. - **THE FISHERFACES METHOD MAKES THE ASSUMPTION, THAT THE TRAINING AND TEST IMAGES ARE OF EQUAL\n. SIZE.** (caps-lock, because I got so many mails asking for this). You have to make sure your\n. input data has the correct shape, else a meaningful exception is thrown. Use resize to resize\n. the images.\n. - This model does not support updating.\n. \n. ### Model internal data:\n. \n. - num_components see FisherFaceRecognizer::create.\n. - threshold see FisherFaceRecognizer::create.\n. - eigenvalues The eigenvalues for this Linear Discriminant Analysis (ordered descending).\n. - eigenvectors The eigenvectors for this Linear Discriminant Analysis (ordered by their\n. eigenvalue).\n. - mean The sample mean calculated from the training data.\n. - projections The projections of the training data.\n. - labels The labels corresponding to the projections."}, |  | 55389 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_FisherFaceRecognizer_create_static, METH_STATIC), "create([, num_components[, threshold]]) -> retval\n. @param num_components The number of components (read: Fisherfaces) kept for this Linear\n. Discriminant Analysis with the Fisherfaces criterion. It's useful to keep all components, that\n. means the number of your classes c (read: subjects, persons you want to recognize). If you leave\n. this at the default (0) or set it to a value less-equal 0 or greater (c-1), it will be set to the\n. correct number (c-1) automatically.\n. @param threshold The threshold applied in the prediction. If the distance to the nearest neighbor\n. is larger than the threshold, this method returns -1.\n. \n. ### Notes:\n. \n. - Training and prediction must be done on grayscale images, use cvtColor to convert between the\n. color spaces.\n. - **THE FISHERFACES METHOD MAKES THE ASSUMPTION, THAT THE TRAINING AND TEST IMAGES ARE OF EQUAL\n. SIZE.** (caps-lock, because I got so many mails asking for this). You have to make sure your\n. input data has the correct shape, else a meaningful exception is thrown. Use resize to resize\n. the images.\n. - This model does not support updating.\n. \n. ### Model internal data:\n. \n. - num_components see FisherFaceRecognizer::create.\n. - threshold see FisherFaceRecognizer::create.\n. - eigenvalues The eigenvalues for this Linear Discriminant Analysis (ordered descending).\n. - eigenvectors The eigenvectors for this Linear Discriminant Analysis (ordered by their\n. eigenvalue).\n. - mean The sample mean calculated from the training data.\n. - projections The projections of the training data.\n. - labels The labels corresponding to the projections."},
| 55438 |  |  | 55390 |
| 55439 | {NULL, NULL} |  | 55391 | {NULL, NULL}
| 55440 | }; |  | 55392 | };
| 55441 |  |  | 55393 |
| 55442 | // Converter (face_FisherFaceRecognizer) |  | 55394 | // Converter (face_FisherFaceRecognizer)
| 55443 |  |  | 55395 |
| 55444 | template<> |  | 55396 | template<>
| 55445 | struct PyOpenCV_Converter< Ptr<cv::face::FisherFaceRecognizer> > |  | 55397 | struct PyOpenCV_Converter< Ptr<cv::face::FisherFaceRecognizer> >
| 55446 | { |  | 55398 | {
| 55447 | static PyObject* from(const Ptr<cv::face::FisherFaceRecognizer>& r) |  | 55399 | static PyObject* from(const Ptr<cv::face::FisherFaceRecognizer>& r)
| 55448 | { |  | 55400 | {
| 55449 | return pyopencv_face_FisherFaceRecognizer_Instance(r); |  | 55401 | return pyopencv_face_FisherFaceRecognizer_Instance(r);
| 55450 | } |  | 55402 | }
| 55451 | static bool to(PyObject* src, Ptr<cv::face::FisherFaceRecognizer>& dst, const ArgInfo& info) |  | 55403 | static bool to(PyObject* src, Ptr<cv::face::FisherFaceRecognizer>& dst, const ArgInfo& info)
| 55452 | { |  | 55404 | {
| 55453 | if(!src || src == Py_None) |  | 55405 | if(!src || src == Py_None)
| 55454 | return true; |  | 55406 | return true;
| 55455 | Ptr<cv::face::FisherFaceRecognizer> * dst_; |  | 55407 | Ptr<cv::face::FisherFaceRecognizer> * dst_;
| 55456 | if (pyopencv_face_FisherFaceRecognizer_getp(src, dst_)) |  | 55408 | if (pyopencv_face_FisherFaceRecognizer_getp(src, dst_))
| 55457 | { |  | 55409 | {
| 55458 | dst = *dst_; |  | 55410 | dst = *dst_;
| 55459 | return true; |  | 55411 | return true;
| 55460 | } |  | 55412 | }
| 55461 |  |  | 55413 |
| 55462 | failmsg("Expected Ptr<cv::face::FisherFaceRecognizer> for argument '%s'", info.name); |  | 55414 | failmsg("Expected Ptr<cv::face::FisherFaceRecognizer> for argument '%s'", info.name);
| 55463 | return false; |  | 55415 | return false;
| 55464 | } |  | 55416 | }
| 55465 | }; |  | 55417 | };
| 55466 |  |  | 55418 |
| 55467 | //================================================================================ |  | 55419 | //================================================================================
| 55468 | // face_LBPHFaceRecognizer (Generic) |  | 55420 | // face_LBPHFaceRecognizer (Generic)
| 55469 | //================================================================================ |  | 55421 | //================================================================================
| 55470 |  |  | 55422 |
| 55471 | // GetSet (face_LBPHFaceRecognizer) |  | 55423 | // GetSet (face_LBPHFaceRecognizer)
| 55472 |  |  | 55424 |
| 55473 |  |  | 55425 |
| 55474 |  |  | 55426 |
| 55475 | // Methods (face_LBPHFaceRecognizer) |  | 55427 | // Methods (face_LBPHFaceRecognizer)
| 55476 |  |  | 55428 |
| 55477 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55429 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 55478 | { |  | 55430 | {
| 55479 | using namespace cv::face; |  | 55431 | using namespace cv::face;
| 55480 |  |  | 55432 |
| 55481 | PyObject* pyobj_radius = NULL; |  | 55433 | PyObject* pyobj_radius = NULL;
| 55482 | int radius=1; |  | 55434 | int radius=1;
| 55483 | PyObject* pyobj_neighbors = NULL; |  | 55435 | PyObject* pyobj_neighbors = NULL;
| 55484 | int neighbors=8; |  | 55436 | int neighbors=8;
| 55485 | PyObject* pyobj_grid_x = NULL; |  | 55437 | PyObject* pyobj_grid_x = NULL;
| 55486 | int grid_x=8; |  | 55438 | int grid_x=8;
| 55487 | PyObject* pyobj_grid_y = NULL; |  | 55439 | PyObject* pyobj_grid_y = NULL;
| 55488 | int grid_y=8; |  | 55440 | int grid_y=8;
| 55489 | PyObject* pyobj_threshold = NULL; |  | 55441 | PyObject* pyobj_threshold = NULL;
| 55490 | double threshold=DBL_MAX; |  | 55442 | double threshold=DBL_MAX;
| 55491 | Ptr<LBPHFaceRecognizer> retval; |  | 55443 | Ptr<LBPHFaceRecognizer> retval;
| 55492 |  |  | 55444 |
| 55493 | const char* keywords[] = { "radius", "neighbors", "grid_x", "grid_y", "threshold", NULL }; |  | 55445 | const char* keywords[] = { "radius", "neighbors", "grid_x", "grid_y", "threshold", NULL };
| 55494 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:face_LBPHFaceRecognizer.create", (char**)keywords, &pyobj_radius, &pyobj_neighbors, &pyobj_grid_x, &pyobj_grid_y, &pyobj_threshold) && |  | 55446 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:face_LBPHFaceRecognizer.create", (char**)keywords, &pyobj_radius, &pyobj_neighbors, &pyobj_grid_x, &pyobj_grid_y, &pyobj_threshold) &&
| 55495 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) && |  | 55447 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) &&
| 55496 | pyopencv_to_safe(pyobj_neighbors, neighbors, ArgInfo("neighbors", 0)) && |  | 55448 | pyopencv_to_safe(pyobj_neighbors, neighbors, ArgInfo("neighbors", 0)) &&
| 55497 | pyopencv_to_safe(pyobj_grid_x, grid_x, ArgInfo("grid_x", 0)) && |  | 55449 | pyopencv_to_safe(pyobj_grid_x, grid_x, ArgInfo("grid_x", 0)) &&
| 55498 | pyopencv_to_safe(pyobj_grid_y, grid_y, ArgInfo("grid_y", 0)) && |  | 55450 | pyopencv_to_safe(pyobj_grid_y, grid_y, ArgInfo("grid_y", 0)) &&
| 55499 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 55451 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 55500 | { |  | 55452 | {
| 55501 | ERRWRAP2(retval = cv::face::LBPHFaceRecognizer::create(radius, neighbors, grid_x, grid_y, threshold)); |  | 55453 | ERRWRAP2(retval = cv::face::LBPHFaceRecognizer::create(radius, neighbors, grid_x, grid_y, threshold));
| 55502 | return pyopencv_from(retval); |  | 55454 | return pyopencv_from(retval);
| 55503 | } |  | 55455 | }
| 55504 |  |  | 55456 |
| 55505 | return NULL; |  | 55457 | return NULL;
| 55506 | } |  | 55458 | }
| 55507 |  |  | 55459 |
| 55508 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getGridX(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55460 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getGridX(PyObject* self, PyObject* py_args, PyObject* kw)
| 55509 | { |  | 55461 | {
| 55510 | using namespace cv::face; |  | 55462 | using namespace cv::face;
| 55511 |  |  | 55463 |
| 55512 |  |  | 55464 |
| 55513 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55465 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55514 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55466 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55515 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55467 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55516 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55468 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55517 | int retval; |  | 55469 | int retval;
| 55518 |  |  | 55470 |
| 55519 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 55471 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 55520 | { |  | 55472 | {
| 55521 | ERRWRAP2(retval = _self_->getGridX()); |  | 55473 | ERRWRAP2(retval = _self_->getGridX());
| 55522 | return pyopencv_from(retval); |  | 55474 | return pyopencv_from(retval);
| 55523 | } |  | 55475 | }
| 55524 |  |  | 55476 |
| 55525 | return NULL; |  | 55477 | return NULL;
| 55526 | } |  | 55478 | }
| 55527 |  |  | 55479 |
| 55528 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getGridY(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55480 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getGridY(PyObject* self, PyObject* py_args, PyObject* kw)
| 55529 | { |  | 55481 | {
| 55530 | using namespace cv::face; |  | 55482 | using namespace cv::face;
| 55531 |  |  | 55483 |
| 55532 |  |  | 55484 |
| 55533 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55485 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55534 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55486 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55535 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55487 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55536 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55488 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55537 | int retval; |  | 55489 | int retval;
| 55538 |  |  | 55490 |
| 55539 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 55491 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 55540 | { |  | 55492 | {
| 55541 | ERRWRAP2(retval = _self_->getGridY()); |  | 55493 | ERRWRAP2(retval = _self_->getGridY());
| 55542 | return pyopencv_from(retval); |  | 55494 | return pyopencv_from(retval);
| 55543 | } |  | 55495 | }
| 55544 |  |  | 55496 |
| 55545 | return NULL; |  | 55497 | return NULL;
| 55546 | } |  | 55498 | }
| 55547 |  |  | 55499 |
| 55548 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getHistograms(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55500 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getHistograms(PyObject* self, PyObject* py_args, PyObject* kw)
| 55549 | { |  | 55501 | {
| 55550 | using namespace cv::face; |  | 55502 | using namespace cv::face;
| 55551 |  |  | 55503 |
| 55552 |  |  | 55504 |
| 55553 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55505 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55554 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55506 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55555 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55507 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55556 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55508 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55557 | std::vector<cv::Mat> retval; |  | 55509 | std::vector<cv::Mat> retval;
| 55558 |  |  | 55510 |
| 55559 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 55511 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 55560 | { |  | 55512 | {
| 55561 | ERRWRAP2(retval = _self_->getHistograms()); |  | 55513 | ERRWRAP2(retval = _self_->getHistograms());
| 55562 | return pyopencv_from(retval); |  | 55514 | return pyopencv_from(retval);
| 55563 | } |  | 55515 | }
| 55564 |  |  | 55516 |
| 55565 | return NULL; |  | 55517 | return NULL;
| 55566 | } |  | 55518 | }
| 55567 |  |  | 55519 |
| 55568 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getLabels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55520 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getLabels(PyObject* self, PyObject* py_args, PyObject* kw)
| 55569 | { |  | 55521 | {
| 55570 | using namespace cv::face; |  | 55522 | using namespace cv::face;
| 55571 |  |  | 55523 |
| 55572 |  |  | 55524 |
| 55573 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55525 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55574 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55526 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55575 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55527 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55576 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55528 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55577 | cv::Mat retval; |  | 55529 | cv::Mat retval;
| 55578 |  |  | 55530 |
| 55579 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 55531 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 55580 | { |  | 55532 | {
| 55581 | ERRWRAP2(retval = _self_->getLabels()); |  | 55533 | ERRWRAP2(retval = _self_->getLabels());
| 55582 | return pyopencv_from(retval); |  | 55534 | return pyopencv_from(retval);
| 55583 | } |  | 55535 | }
| 55584 |  |  | 55536 |
| 55585 | return NULL; |  | 55537 | return NULL;
| 55586 | } |  | 55538 | }
| 55587 |  |  | 55539 |
| 55588 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getNeighbors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55540 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getNeighbors(PyObject* self, PyObject* py_args, PyObject* kw)
| 55589 | { |  | 55541 | {
| 55590 | using namespace cv::face; |  | 55542 | using namespace cv::face;
| 55591 |  |  | 55543 |
| 55592 |  |  | 55544 |
| 55593 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55545 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55594 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55546 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55595 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55547 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55596 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55548 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55597 | int retval; |  | 55549 | int retval;
| 55598 |  |  | 55550 |
| 55599 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 55551 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 55600 | { |  | 55552 | {
| 55601 | ERRWRAP2(retval = _self_->getNeighbors()); |  | 55553 | ERRWRAP2(retval = _self_->getNeighbors());
| 55602 | return pyopencv_from(retval); |  | 55554 | return pyopencv_from(retval);
| 55603 | } |  | 55555 | }
| 55604 |  |  | 55556 |
| 55605 | return NULL; |  | 55557 | return NULL;
| 55606 | } |  | 55558 | }
| 55607 |  |  | 55559 |
| 55608 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55560 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 55609 | { |  | 55561 | {
| 55610 | using namespace cv::face; |  | 55562 | using namespace cv::face;
| 55611 |  |  | 55563 |
| 55612 |  |  | 55564 |
| 55613 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55565 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55614 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55566 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55615 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55567 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55616 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55568 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55617 | int retval; |  | 55569 | int retval;
| 55618 |  |  | 55570 |
| 55619 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 55571 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 55620 | { |  | 55572 | {
| 55621 | ERRWRAP2(retval = _self_->getRadius()); |  | 55573 | ERRWRAP2(retval = _self_->getRadius());
| 55622 | return pyopencv_from(retval); |  | 55574 | return pyopencv_from(retval);
| 55623 | } |  | 55575 | }
| 55624 |  |  | 55576 |
| 55625 | return NULL; |  | 55577 | return NULL;
| 55626 | } |  | 55578 | }
| 55627 |  |  | 55579 |
| 55628 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55580 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 55629 | { |  | 55581 | {
| 55630 | using namespace cv::face; |  | 55582 | using namespace cv::face;
| 55631 |  |  | 55583 |
| 55632 |  |  | 55584 |
| 55633 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55585 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55634 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55586 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55635 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55587 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55636 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55588 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55637 | double retval; |  | 55589 | double retval;
| 55638 |  |  | 55590 |
| 55639 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 55591 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 55640 | { |  | 55592 | {
| 55641 | ERRWRAP2(retval = _self_->getThreshold()); |  | 55593 | ERRWRAP2(retval = _self_->getThreshold());
| 55642 | return pyopencv_from(retval); |  | 55594 | return pyopencv_from(retval);
| 55643 | } |  | 55595 | }
| 55644 |  |  | 55596 |
| 55645 | return NULL; |  | 55597 | return NULL;
| 55646 | } |  | 55598 | }
| 55647 |  |  | 55599 |
| 55648 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setGridX(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55600 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setGridX(PyObject* self, PyObject* py_args, PyObject* kw)
| 55649 | { |  | 55601 | {
| 55650 | using namespace cv::face; |  | 55602 | using namespace cv::face;
| 55651 |  |  | 55603 |
| 55652 |  |  | 55604 |
| 55653 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55605 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55654 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55606 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55655 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55607 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55656 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55608 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55657 | PyObject* pyobj_val = NULL; |  | 55609 | PyObject* pyobj_val = NULL;
| 55658 | int val=0; |  | 55610 | int val=0;
| 55659 |  |  | 55611 |
| 55660 | const char* keywords[] = { "val", NULL }; |  | 55612 | const char* keywords[] = { "val", NULL };
| 55661 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setGridX", (char**)keywords, &pyobj_val) && |  | 55613 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setGridX", (char**)keywords, &pyobj_val) &&
| 55662 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 55614 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 55663 | { |  | 55615 | {
| 55664 | ERRWRAP2(_self_->setGridX(val)); |  | 55616 | ERRWRAP2(_self_->setGridX(val));
| 55665 | Py_RETURN_NONE; |  | 55617 | Py_RETURN_NONE;
| 55666 | } |  | 55618 | }
| 55667 |  |  | 55619 |
| 55668 | return NULL; |  | 55620 | return NULL;
| 55669 | } |  | 55621 | }
| 55670 |  |  | 55622 |
| 55671 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setGridY(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55623 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setGridY(PyObject* self, PyObject* py_args, PyObject* kw)
| 55672 | { |  | 55624 | {
| 55673 | using namespace cv::face; |  | 55625 | using namespace cv::face;
| 55674 |  |  | 55626 |
| 55675 |  |  | 55627 |
| 55676 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55628 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55677 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55629 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55678 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55630 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55679 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55631 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55680 | PyObject* pyobj_val = NULL; |  | 55632 | PyObject* pyobj_val = NULL;
| 55681 | int val=0; |  | 55633 | int val=0;
| 55682 |  |  | 55634 |
| 55683 | const char* keywords[] = { "val", NULL }; |  | 55635 | const char* keywords[] = { "val", NULL };
| 55684 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setGridY", (char**)keywords, &pyobj_val) && |  | 55636 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setGridY", (char**)keywords, &pyobj_val) &&
| 55685 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 55637 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 55686 | { |  | 55638 | {
| 55687 | ERRWRAP2(_self_->setGridY(val)); |  | 55639 | ERRWRAP2(_self_->setGridY(val));
| 55688 | Py_RETURN_NONE; |  | 55640 | Py_RETURN_NONE;
| 55689 | } |  | 55641 | }
| 55690 |  |  | 55642 |
| 55691 | return NULL; |  | 55643 | return NULL;
| 55692 | } |  | 55644 | }
| 55693 |  |  | 55645 |
| 55694 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setNeighbors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55646 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setNeighbors(PyObject* self, PyObject* py_args, PyObject* kw)
| 55695 | { |  | 55647 | {
| 55696 | using namespace cv::face; |  | 55648 | using namespace cv::face;
| 55697 |  |  | 55649 |
| 55698 |  |  | 55650 |
| 55699 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55651 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55700 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55652 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55701 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55653 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55702 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55654 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55703 | PyObject* pyobj_val = NULL; |  | 55655 | PyObject* pyobj_val = NULL;
| 55704 | int val=0; |  | 55656 | int val=0;
| 55705 |  |  | 55657 |
| 55706 | const char* keywords[] = { "val", NULL }; |  | 55658 | const char* keywords[] = { "val", NULL };
| 55707 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setNeighbors", (char**)keywords, &pyobj_val) && |  | 55659 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setNeighbors", (char**)keywords, &pyobj_val) &&
| 55708 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 55660 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 55709 | { |  | 55661 | {
| 55710 | ERRWRAP2(_self_->setNeighbors(val)); |  | 55662 | ERRWRAP2(_self_->setNeighbors(val));
| 55711 | Py_RETURN_NONE; |  | 55663 | Py_RETURN_NONE;
| 55712 | } |  | 55664 | }
| 55713 |  |  | 55665 |
| 55714 | return NULL; |  | 55666 | return NULL;
| 55715 | } |  | 55667 | }
| 55716 |  |  | 55668 |
| 55717 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setRadius(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55669 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setRadius(PyObject* self, PyObject* py_args, PyObject* kw)
| 55718 | { |  | 55670 | {
| 55719 | using namespace cv::face; |  | 55671 | using namespace cv::face;
| 55720 |  |  | 55672 |
| 55721 |  |  | 55673 |
| 55722 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55674 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55723 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55675 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55724 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55676 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55725 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55677 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55726 | PyObject* pyobj_val = NULL; |  | 55678 | PyObject* pyobj_val = NULL;
| 55727 | int val=0; |  | 55679 | int val=0;
| 55728 |  |  | 55680 |
| 55729 | const char* keywords[] = { "val", NULL }; |  | 55681 | const char* keywords[] = { "val", NULL };
| 55730 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setRadius", (char**)keywords, &pyobj_val) && |  | 55682 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setRadius", (char**)keywords, &pyobj_val) &&
| 55731 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 55683 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 55732 | { |  | 55684 | {
| 55733 | ERRWRAP2(_self_->setRadius(val)); |  | 55685 | ERRWRAP2(_self_->setRadius(val));
| 55734 | Py_RETURN_NONE; |  | 55686 | Py_RETURN_NONE;
| 55735 | } |  | 55687 | }
| 55736 |  |  | 55688 |
| 55737 | return NULL; |  | 55689 | return NULL;
| 55738 | } |  | 55690 | }
| 55739 |  |  | 55691 |
| 55740 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55692 | static PyObject* pyopencv_cv_face_face_LBPHFaceRecognizer_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 55741 | { |  | 55693 | {
| 55742 | using namespace cv::face; |  | 55694 | using namespace cv::face;
| 55743 |  |  | 55695 |
| 55744 |  |  | 55696 |
| 55745 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0; |  | 55697 | Ptr<cv::face::LBPHFaceRecognizer> * self1 = 0;
| 55746 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1)) |  | 55698 | if (!pyopencv_face_LBPHFaceRecognizer_getp(self, self1))
| 55747 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)"); |  | 55699 | return failmsgp("Incorrect type of self (must be 'face_LBPHFaceRecognizer' or its derivative)");
| 55748 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1); |  | 55700 | Ptr<cv::face::LBPHFaceRecognizer> _self_ = *(self1);
| 55749 | PyObject* pyobj_val = NULL; |  | 55701 | PyObject* pyobj_val = NULL;
| 55750 | double val=0; |  | 55702 | double val=0;
| 55751 |  |  | 55703 |
| 55752 | const char* keywords[] = { "val", NULL }; |  | 55704 | const char* keywords[] = { "val", NULL };
| 55753 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setThreshold", (char**)keywords, &pyobj_val) && |  | 55705 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_LBPHFaceRecognizer.setThreshold", (char**)keywords, &pyobj_val) &&
| 55754 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 55706 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 55755 | { |  | 55707 | {
| 55756 | ERRWRAP2(_self_->setThreshold(val)); |  | 55708 | ERRWRAP2(_self_->setThreshold(val));
| 55757 | Py_RETURN_NONE; |  | 55709 | Py_RETURN_NONE;
| 55758 | } |  | 55710 | }
| 55759 |  |  | 55711 |
| 55760 | return NULL; |  | 55712 | return NULL;
| 55761 | } |  | 55713 | }
| 55762 |  |  | 55714 |
| 55763 |  |  | 55715 |
| 55764 |  |  | 55716 |
| 55765 | // Tables (face_LBPHFaceRecognizer) |  | 55717 | // Tables (face_LBPHFaceRecognizer)
| 55766 |  |  | 55718 |
| 55767 | static PyGetSetDef pyopencv_face_LBPHFaceRecognizer_getseters[] = |  | 55719 | static PyGetSetDef pyopencv_face_LBPHFaceRecognizer_getseters[] =
| 55768 | { |  | 55720 | {
| 55769 | {NULL} /* Sentinel */ |  | 55721 | {NULL} /* Sentinel */
| 55770 | }; |  | 55722 | };
| 55771 |  |  | 55723 |
| 55772 | static PyMethodDef pyopencv_face_LBPHFaceRecognizer_methods[] = |  | 55724 | static PyMethodDef pyopencv_face_LBPHFaceRecognizer_methods[] =
| 55773 | { |  | 55725 | {
| 55774 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_create_static, METH_STATIC), "create([, radius[, neighbors[, grid_x[, grid_y[, threshold]]]]]) -> retval\n. @param radius The radius used for building the Circular Local Binary Pattern. The greater the\n. radius, the smoother the image but more spatial information you can get.\n. @param neighbors The number of sample points to build a Circular Local Binary Pattern from. An\n. appropriate value is to use `8` sample points. Keep in mind: the more sample points you include,\n. the higher the computational cost.\n. @param grid_x The number of cells in the horizontal direction, 8 is a common value used in\n. publications. The more cells, the finer the grid, the higher the dimensionality of the resulting\n. feature vector.\n. @param grid_y The number of cells in the vertical direction, 8 is a common value used in\n. publications. The more cells, the finer the grid, the higher the dimensionality of the resulting\n. feature vector.\n. @param threshold The threshold applied in the prediction. If the distance to the nearest neighbor\n. is larger than the threshold, this method returns -1.\n. \n. ### Notes:\n. \n. - The Circular Local Binary Patterns (used in training and prediction) expect the data given as\n. grayscale images, use cvtColor to convert between the color spaces.\n. - This model supports updating.\n. \n. ### Model internal data:\n. \n. - radius see LBPHFaceRecognizer::create.\n. - neighbors see LBPHFaceRecognizer::create.\n. - grid_x see LLBPHFaceRecognizer::create.\n. - grid_y see LBPHFaceRecognizer::create.\n. - threshold see LBPHFaceRecognizer::create.\n. - histograms Local Binary Patterns Histograms calculated from the given training data (empty if\n. none was given).\n. - labels Labels corresponding to the calculated Local Binary Patterns Histograms."}, |  | 55726 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_create_static, METH_STATIC), "create([, radius[, neighbors[, grid_x[, grid_y[, threshold]]]]]) -> retval\n. @param radius The radius used for building the Circular Local Binary Pattern. The greater the\n. radius, the smoother the image but more spatial information you can get.\n. @param neighbors The number of sample points to build a Circular Local Binary Pattern from. An\n. appropriate value is to use `8` sample points. Keep in mind: the more sample points you include,\n. the higher the computational cost.\n. @param grid_x The number of cells in the horizontal direction, 8 is a common value used in\n. publications. The more cells, the finer the grid, the higher the dimensionality of the resulting\n. feature vector.\n. @param grid_y The number of cells in the vertical direction, 8 is a common value used in\n. publications. The more cells, the finer the grid, the higher the dimensionality of the resulting\n. feature vector.\n. @param threshold The threshold applied in the prediction. If the distance to the nearest neighbor\n. is larger than the threshold, this method returns -1.\n. \n. ### Notes:\n. \n. - The Circular Local Binary Patterns (used in training and prediction) expect the data given as\n. grayscale images, use cvtColor to convert between the color spaces.\n. - This model supports updating.\n. \n. ### Model internal data:\n. \n. - radius see LBPHFaceRecognizer::create.\n. - neighbors see LBPHFaceRecognizer::create.\n. - grid_x see LLBPHFaceRecognizer::create.\n. - grid_y see LBPHFaceRecognizer::create.\n. - threshold see LBPHFaceRecognizer::create.\n. - histograms Local Binary Patterns Histograms calculated from the given training data (empty if\n. none was given).\n. - labels Labels corresponding to the calculated Local Binary Patterns Histograms."},
| 55775 | {"getGridX", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getGridX, 0), "getGridX() -> retval\n. @see setGridX"}, |  | 55727 | {"getGridX", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getGridX, 0), "getGridX() -> retval\n. @see setGridX"},
| 55776 | {"getGridY", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getGridY, 0), "getGridY() -> retval\n. @see setGridY"}, |  | 55728 | {"getGridY", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getGridY, 0), "getGridY() -> retval\n. @see setGridY"},
| 55777 | {"getHistograms", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getHistograms, 0), "getHistograms() -> retval\n."}, |  | 55729 | {"getHistograms", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getHistograms, 0), "getHistograms() -> retval\n."},
| 55778 | {"getLabels", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getLabels, 0), "getLabels() -> retval\n."}, |  | 55730 | {"getLabels", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getLabels, 0), "getLabels() -> retval\n."},
| 55779 | {"getNeighbors", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getNeighbors, 0), "getNeighbors() -> retval\n. @see setNeighbors"}, |  | 55731 | {"getNeighbors", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getNeighbors, 0), "getNeighbors() -> retval\n. @see setNeighbors"},
| 55780 | {"getRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getRadius, 0), "getRadius() -> retval\n. @see setRadius"}, |  | 55732 | {"getRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getRadius, 0), "getRadius() -> retval\n. @see setRadius"},
| 55781 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getThreshold, 0), "getThreshold() -> retval\n. @see setThreshold"}, |  | 55733 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_getThreshold, 0), "getThreshold() -> retval\n. @see setThreshold"},
| 55782 | {"setGridX", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setGridX, 0), "setGridX(val) -> None\n. @copybrief getGridX @see getGridX"}, |  | 55734 | {"setGridX", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setGridX, 0), "setGridX(val) -> None\n. @copybrief getGridX @see getGridX"},
| 55783 | {"setGridY", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setGridY, 0), "setGridY(val) -> None\n. @copybrief getGridY @see getGridY"}, |  | 55735 | {"setGridY", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setGridY, 0), "setGridY(val) -> None\n. @copybrief getGridY @see getGridY"},
| 55784 | {"setNeighbors", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setNeighbors, 0), "setNeighbors(val) -> None\n. @copybrief getNeighbors @see getNeighbors"}, |  | 55736 | {"setNeighbors", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setNeighbors, 0), "setNeighbors(val) -> None\n. @copybrief getNeighbors @see getNeighbors"},
| 55785 | {"setRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setRadius, 0), "setRadius(val) -> None\n. @copybrief getRadius @see getRadius"}, |  | 55737 | {"setRadius", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setRadius, 0), "setRadius(val) -> None\n. @copybrief getRadius @see getRadius"},
| 55786 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setThreshold, 0), "setThreshold(val) -> None\n. @copybrief getThreshold @see getThreshold"}, |  | 55738 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_LBPHFaceRecognizer_setThreshold, 0), "setThreshold(val) -> None\n. @copybrief getThreshold @see getThreshold"},
| 55787 |  |  | 55739 |
| 55788 | {NULL, NULL} |  | 55740 | {NULL, NULL}
| 55789 | }; |  | 55741 | };
| 55790 |  |  | 55742 |
| 55791 | // Converter (face_LBPHFaceRecognizer) |  | 55743 | // Converter (face_LBPHFaceRecognizer)
| 55792 |  |  | 55744 |
| 55793 | template<> |  | 55745 | template<>
| 55794 | struct PyOpenCV_Converter< Ptr<cv::face::LBPHFaceRecognizer> > |  | 55746 | struct PyOpenCV_Converter< Ptr<cv::face::LBPHFaceRecognizer> >
| 55795 | { |  | 55747 | {
| 55796 | static PyObject* from(const Ptr<cv::face::LBPHFaceRecognizer>& r) |  | 55748 | static PyObject* from(const Ptr<cv::face::LBPHFaceRecognizer>& r)
| 55797 | { |  | 55749 | {
| 55798 | return pyopencv_face_LBPHFaceRecognizer_Instance(r); |  | 55750 | return pyopencv_face_LBPHFaceRecognizer_Instance(r);
| 55799 | } |  | 55751 | }
| 55800 | static bool to(PyObject* src, Ptr<cv::face::LBPHFaceRecognizer>& dst, const ArgInfo& info) |  | 55752 | static bool to(PyObject* src, Ptr<cv::face::LBPHFaceRecognizer>& dst, const ArgInfo& info)
| 55801 | { |  | 55753 | {
| 55802 | if(!src || src == Py_None) |  | 55754 | if(!src || src == Py_None)
| 55803 | return true; |  | 55755 | return true;
| 55804 | Ptr<cv::face::LBPHFaceRecognizer> * dst_; |  | 55756 | Ptr<cv::face::LBPHFaceRecognizer> * dst_;
| 55805 | if (pyopencv_face_LBPHFaceRecognizer_getp(src, dst_)) |  | 55757 | if (pyopencv_face_LBPHFaceRecognizer_getp(src, dst_))
| 55806 | { |  | 55758 | {
| 55807 | dst = *dst_; |  | 55759 | dst = *dst_;
| 55808 | return true; |  | 55760 | return true;
| 55809 | } |  | 55761 | }
| 55810 |  |  | 55762 |
| 55811 | failmsg("Expected Ptr<cv::face::LBPHFaceRecognizer> for argument '%s'", info.name); |  | 55763 | failmsg("Expected Ptr<cv::face::LBPHFaceRecognizer> for argument '%s'", info.name);
| 55812 | return false; |  | 55764 | return false;
| 55813 | } |  | 55765 | }
| 55814 | }; |  | 55766 | };
| 55815 |  |  | 55767 |
| 55816 | //================================================================================ |  | 55768 | //================================================================================
| 55817 | // face_MACE (Generic) |  | 55769 | // face_MACE (Generic)
| 55818 | //================================================================================ |  | 55770 | //================================================================================
| 55819 |  |  | 55771 |
| 55820 | // GetSet (face_MACE) |  | 55772 | // GetSet (face_MACE)
| 55821 |  |  | 55773 |
| 55822 |  |  | 55774 |
| 55823 |  |  | 55775 |
| 55824 | // Methods (face_MACE) |  | 55776 | // Methods (face_MACE)
| 55825 |  |  | 55777 |
| 55826 | static PyObject* pyopencv_cv_face_face_MACE_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55778 | static PyObject* pyopencv_cv_face_face_MACE_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 55827 | { |  | 55779 | {
| 55828 | using namespace cv::face; |  | 55780 | using namespace cv::face;
| 55829 |  |  | 55781 |
| 55830 | PyObject* pyobj_IMGSIZE = NULL; |  | 55782 | PyObject* pyobj_IMGSIZE = NULL;
| 55831 | int IMGSIZE=64; |  | 55783 | int IMGSIZE=64;
| 55832 | cv::Ptr<MACE> retval; |  | 55784 | cv::Ptr<MACE> retval;
| 55833 |  |  | 55785 |
| 55834 | const char* keywords[] = { "IMGSIZE", NULL }; |  | 55786 | const char* keywords[] = { "IMGSIZE", NULL };
| 55835 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:face_MACE.create", (char**)keywords, &pyobj_IMGSIZE) && |  | 55787 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:face_MACE.create", (char**)keywords, &pyobj_IMGSIZE) &&
| 55836 | pyopencv_to_safe(pyobj_IMGSIZE, IMGSIZE, ArgInfo("IMGSIZE", 0)) ) |  | 55788 | pyopencv_to_safe(pyobj_IMGSIZE, IMGSIZE, ArgInfo("IMGSIZE", 0)) )
| 55837 | { |  | 55789 | {
| 55838 | ERRWRAP2(retval = cv::face::MACE::create(IMGSIZE)); |  | 55790 | ERRWRAP2(retval = cv::face::MACE::create(IMGSIZE));
| 55839 | return pyopencv_from(retval); |  | 55791 | return pyopencv_from(retval);
| 55840 | } |  | 55792 | }
| 55841 |  |  | 55793 |
| 55842 | return NULL; |  | 55794 | return NULL;
| 55843 | } |  | 55795 | }
| 55844 |  |  | 55796 |
| 55845 | static PyObject* pyopencv_cv_face_face_MACE_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55797 | static PyObject* pyopencv_cv_face_face_MACE_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 55846 | { |  | 55798 | {
| 55847 | using namespace cv::face; |  | 55799 | using namespace cv::face;
| 55848 |  |  | 55800 |
| 55849 | PyObject* pyobj_filename = NULL; |  | 55801 | PyObject* pyobj_filename = NULL;
| 55850 | String filename; |  | 55802 | String filename;
| 55851 | PyObject* pyobj_objname = NULL; |  | 55803 | PyObject* pyobj_objname = NULL;
| 55852 | String objname; |  | 55804 | String objname;
| 55853 | cv::Ptr<MACE> retval; |  | 55805 | cv::Ptr<MACE> retval;
| 55854 |  |  | 55806 |
| 55855 | const char* keywords[] = { "filename", "objname", NULL }; |  | 55807 | const char* keywords[] = { "filename", "objname", NULL };
| 55856 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:face_MACE.load", (char**)keywords, &pyobj_filename, &pyobj_objname) && |  | 55808 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:face_MACE.load", (char**)keywords, &pyobj_filename, &pyobj_objname) &&
| 55857 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) && |  | 55809 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) &&
| 55858 | pyopencv_to_safe(pyobj_objname, objname, ArgInfo("objname", 0)) ) |  | 55810 | pyopencv_to_safe(pyobj_objname, objname, ArgInfo("objname", 0)) )
| 55859 | { |  | 55811 | {
| 55860 | ERRWRAP2(retval = cv::face::MACE::load(filename, objname)); |  | 55812 | ERRWRAP2(retval = cv::face::MACE::load(filename, objname));
| 55861 | return pyopencv_from(retval); |  | 55813 | return pyopencv_from(retval);
| 55862 | } |  | 55814 | }
| 55863 |  |  | 55815 |
| 55864 | return NULL; |  | 55816 | return NULL;
| 55865 | } |  | 55817 | }
| 55866 |  |  | 55818 |
| 55867 | static PyObject* pyopencv_cv_face_face_MACE_salt(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55819 | static PyObject* pyopencv_cv_face_face_MACE_salt(PyObject* self, PyObject* py_args, PyObject* kw)
| 55868 | { |  | 55820 | {
| 55869 | using namespace cv::face; |  | 55821 | using namespace cv::face;
| 55870 |  |  | 55822 |
| 55871 |  |  | 55823 |
| 55872 | Ptr<cv::face::MACE> * self1 = 0; |  | 55824 | Ptr<cv::face::MACE> * self1 = 0;
| 55873 | if (!pyopencv_face_MACE_getp(self, self1)) |  | 55825 | if (!pyopencv_face_MACE_getp(self, self1))
| 55874 | return failmsgp("Incorrect type of self (must be 'face_MACE' or its derivative)"); |  | 55826 | return failmsgp("Incorrect type of self (must be 'face_MACE' or its derivative)");
| 55875 | Ptr<cv::face::MACE> _self_ = *(self1); |  | 55827 | Ptr<cv::face::MACE> _self_ = *(self1);
| 55876 | PyObject* pyobj_passphrase = NULL; |  | 55828 | PyObject* pyobj_passphrase = NULL;
| 55877 | String passphrase; |  | 55829 | String passphrase;
| 55878 |  |  | 55830 |
| 55879 | const char* keywords[] = { "passphrase", NULL }; |  | 55831 | const char* keywords[] = { "passphrase", NULL };
| 55880 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.salt", (char**)keywords, &pyobj_passphrase) && |  | 55832 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.salt", (char**)keywords, &pyobj_passphrase) &&
| 55881 | pyopencv_to_safe(pyobj_passphrase, passphrase, ArgInfo("passphrase", 0)) ) |  | 55833 | pyopencv_to_safe(pyobj_passphrase, passphrase, ArgInfo("passphrase", 0)) )
| 55882 | { |  | 55834 | {
| 55883 | ERRWRAP2(_self_->salt(passphrase)); |  | 55835 | ERRWRAP2(_self_->salt(passphrase));
| 55884 | Py_RETURN_NONE; |  | 55836 | Py_RETURN_NONE;
| 55885 | } |  | 55837 | }
| 55886 |  |  | 55838 |
| 55887 | return NULL; |  | 55839 | return NULL;
| 55888 | } |  | 55840 | }
| 55889 |  |  | 55841 |
| 55890 | static PyObject* pyopencv_cv_face_face_MACE_same(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55842 | static PyObject* pyopencv_cv_face_face_MACE_same(PyObject* self, PyObject* py_args, PyObject* kw)
| 55891 | { |  | 55843 | {
| 55892 | using namespace cv::face; |  | 55844 | using namespace cv::face;
| 55893 |  |  | 55845 |
| 55894 |  |  | 55846 |
| 55895 | Ptr<cv::face::MACE> * self1 = 0; |  | 55847 | Ptr<cv::face::MACE> * self1 = 0;
| 55896 | if (!pyopencv_face_MACE_getp(self, self1)) |  | 55848 | if (!pyopencv_face_MACE_getp(self, self1))
| 55897 | return failmsgp("Incorrect type of self (must be 'face_MACE' or its derivative)"); |  | 55849 | return failmsgp("Incorrect type of self (must be 'face_MACE' or its derivative)");
| 55898 | Ptr<cv::face::MACE> _self_ = *(self1); |  | 55850 | Ptr<cv::face::MACE> _self_ = *(self1);
| 55899 | pyPrepareArgumentConversionErrorsStorage(2); |  | 55851 | pyPrepareArgumentConversionErrorsStorage(2);
| 55900 |  |  | 55852 |
| 55901 | { |  | 55853 | {
| 55902 | PyObject* pyobj_query = NULL; |  | 55854 | PyObject* pyobj_query = NULL;
| 55903 | Mat query; |  | 55855 | Mat query;
| 55904 | bool retval; |  | 55856 | bool retval;
| 55905 |  |  | 55857 |
| 55906 | const char* keywords[] = { "query", NULL }; |  | 55858 | const char* keywords[] = { "query", NULL };
| 55907 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.same", (char**)keywords, &pyobj_query) && |  | 55859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.same", (char**)keywords, &pyobj_query) &&
| 55908 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) ) |  | 55860 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) )
| 55909 | { |  | 55861 | {
| 55910 | ERRWRAP2(retval = _self_->same(query)); |  | 55862 | ERRWRAP2(retval = _self_->same(query));
| 55911 | return pyopencv_from(retval); |  | 55863 | return pyopencv_from(retval);
| 55912 | } |  | 55864 | }
| 55913 |  |  | 55865 |
| 55914 |  |  | 55866 |
| 55915 | pyPopulateArgumentConversionErrors(); |  | 55867 | pyPopulateArgumentConversionErrors();
| 55916 | } |  | 55868 | }
| 55917 |  |  | 55869 |
| 55918 |  |  | 55870 |
| 55919 | { |  | 55871 | {
| 55920 | PyObject* pyobj_query = NULL; |  | 55872 | PyObject* pyobj_query = NULL;
| 55921 | UMat query; |  | 55873 | UMat query;
| 55922 | bool retval; |  | 55874 | bool retval;
| 55923 |  |  | 55875 |
| 55924 | const char* keywords[] = { "query", NULL }; |  | 55876 | const char* keywords[] = { "query", NULL };
| 55925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.same", (char**)keywords, &pyobj_query) && |  | 55877 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.same", (char**)keywords, &pyobj_query) &&
| 55926 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) ) |  | 55878 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) )
| 55927 | { |  | 55879 | {
| 55928 | ERRWRAP2(retval = _self_->same(query)); |  | 55880 | ERRWRAP2(retval = _self_->same(query));
| 55929 | return pyopencv_from(retval); |  | 55881 | return pyopencv_from(retval);
| 55930 | } |  | 55882 | }
| 55931 |  |  | 55883 |
| 55932 |  |  | 55884 |
| 55933 | pyPopulateArgumentConversionErrors(); |  | 55885 | pyPopulateArgumentConversionErrors();
| 55934 | } |  | 55886 | }
| 55935 | pyRaiseCVOverloadException("same"); |  | 55887 | pyRaiseCVOverloadException("same");
| 55936 |  |  | 55888 |
| 55937 | return NULL; |  | 55889 | return NULL;
| 55938 | } |  | 55890 | }
| 55939 |  |  | 55891 |
| 55940 | static PyObject* pyopencv_cv_face_face_MACE_train(PyObject* self, PyObject* py_args, PyObject* kw) |  | 55892 | static PyObject* pyopencv_cv_face_face_MACE_train(PyObject* self, PyObject* py_args, PyObject* kw)
| 55941 | { |  | 55893 | {
| 55942 | using namespace cv::face; |  | 55894 | using namespace cv::face;
| 55943 |  |  | 55895 |
| 55944 |  |  | 55896 |
| 55945 | Ptr<cv::face::MACE> * self1 = 0; |  | 55897 | Ptr<cv::face::MACE> * self1 = 0;
| 55946 | if (!pyopencv_face_MACE_getp(self, self1)) |  | 55898 | if (!pyopencv_face_MACE_getp(self, self1))
| 55947 | return failmsgp("Incorrect type of self (must be 'face_MACE' or its derivative)"); |  | 55899 | return failmsgp("Incorrect type of self (must be 'face_MACE' or its derivative)");
| 55948 | Ptr<cv::face::MACE> _self_ = *(self1); |  | 55900 | Ptr<cv::face::MACE> _self_ = *(self1);
| 55949 | pyPrepareArgumentConversionErrorsStorage(2); |  | 55901 | pyPrepareArgumentConversionErrorsStorage(2);
| 55950 |  |  | 55902 |
| 55951 | { |  | 55903 | {
| 55952 | PyObject* pyobj_images = NULL; |  | 55904 | PyObject* pyobj_images = NULL;
| 55953 | vector_Mat images; |  | 55905 | vector_Mat images;
| 55954 |  |  | 55906 |
| 55955 | const char* keywords[] = { "images", NULL }; |  | 55907 | const char* keywords[] = { "images", NULL };
| 55956 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.train", (char**)keywords, &pyobj_images) && |  | 55908 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.train", (char**)keywords, &pyobj_images) &&
| 55957 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) ) |  | 55909 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) )
| 55958 | { |  | 55910 | {
| 55959 | ERRWRAP2(_self_->train(images)); |  | 55911 | ERRWRAP2(_self_->train(images));
| 55960 | Py_RETURN_NONE; |  | 55912 | Py_RETURN_NONE;
| 55961 | } |  | 55913 | }
| 55962 |  |  | 55914 |
| 55963 |  |  | 55915 |
| 55964 | pyPopulateArgumentConversionErrors(); |  | 55916 | pyPopulateArgumentConversionErrors();
| 55965 | } |  | 55917 | }
| 55966 |  |  | 55918 |
| 55967 |  |  | 55919 |
| 55968 | { |  | 55920 | {
| 55969 | PyObject* pyobj_images = NULL; |  | 55921 | PyObject* pyobj_images = NULL;
| 55970 | vector_UMat images; |  | 55922 | vector_UMat images;
| 55971 |  |  | 55923 |
| 55972 | const char* keywords[] = { "images", NULL }; |  | 55924 | const char* keywords[] = { "images", NULL };
| 55973 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.train", (char**)keywords, &pyobj_images) && |  | 55925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:face_MACE.train", (char**)keywords, &pyobj_images) &&
| 55974 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) ) |  | 55926 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) )
| 55975 | { |  | 55927 | {
| 55976 | ERRWRAP2(_self_->train(images)); |  | 55928 | ERRWRAP2(_self_->train(images));
| 55977 | Py_RETURN_NONE; |  | 55929 | Py_RETURN_NONE;
| 55978 | } |  | 55930 | }
| 55979 |  |  | 55931 |
| 55980 |  |  | 55932 |
| 55981 | pyPopulateArgumentConversionErrors(); |  | 55933 | pyPopulateArgumentConversionErrors();
| 55982 | } |  | 55934 | }
| 55983 | pyRaiseCVOverloadException("train"); |  | 55935 | pyRaiseCVOverloadException("train");
| 55984 |  |  | 55936 |
| 55985 | return NULL; |  | 55937 | return NULL;
| 55986 | } |  | 55938 | }
| 55987 |  |  | 55939 |
| 55988 |  |  | 55940 |
| 55989 |  |  | 55941 |
| 55990 | // Tables (face_MACE) |  | 55942 | // Tables (face_MACE)
| 55991 |  |  | 55943 |
| 55992 | static PyGetSetDef pyopencv_face_MACE_getseters[] = |  | 55944 | static PyGetSetDef pyopencv_face_MACE_getseters[] =
| 55993 | { |  | 55945 | {
| 55994 | {NULL} /* Sentinel */ |  | 55946 | {NULL} /* Sentinel */
| 55995 | }; |  | 55947 | };
| 55996 |  |  | 55948 |
| 55997 | static PyMethodDef pyopencv_face_MACE_methods[] = |  | 55949 | static PyMethodDef pyopencv_face_MACE_methods[] =
| 55998 | { |  | 55950 | {
| 55999 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_create_static, METH_STATIC), "create([, IMGSIZE]) -> retval\n. @brief constructor\n. @param IMGSIZE images will get resized to this (should be an even number)"}, |  | 55951 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_create_static, METH_STATIC), "create([, IMGSIZE]) -> retval\n. @brief constructor\n. @param IMGSIZE images will get resized to this (should be an even number)"},
| 56000 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_load_static, METH_STATIC), "load(filename[, objname]) -> retval\n. @brief constructor\n. @param filename build a new MACE instance from a pre-serialized FileStorage\n. @param objname (optional) top-level node in the FileStorage"}, |  | 55952 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_load_static, METH_STATIC), "load(filename[, objname]) -> retval\n. @brief constructor\n. @param filename build a new MACE instance from a pre-serialized FileStorage\n. @param objname (optional) top-level node in the FileStorage"},
| 56001 | {"salt", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_salt, 0), "salt(passphrase) -> None\n. @brief optionally encrypt images with random convolution\n. @param passphrase a crc64 random seed will get generated from this"}, |  | 55953 | {"salt", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_salt, 0), "salt(passphrase) -> None\n. @brief optionally encrypt images with random convolution\n. @param passphrase a crc64 random seed will get generated from this"},
| 56002 | {"same", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_same, 0), "same(query) -> retval\n. @brief correlate query img and threshold to min class value\n. @param query a Mat with query image"}, |  | 55954 | {"same", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_same, 0), "same(query) -> retval\n. @brief correlate query img and threshold to min class value\n. @param query a Mat with query image"},
| 56003 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_train, 0), "train(images) -> None\n. @brief train it on positive features\n. compute the mace filter: `h = D(-1) * X * (X(+) * D(-1) * X)(-1) * C`\n. also calculate a minimal threshold for this class, the smallest self-similarity from the train images\n. @param images a vector<Mat> with the train images"}, |  | 55955 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_MACE_train, 0), "train(images) -> None\n. @brief train it on positive features\n. compute the mace filter: `h = D(-1) * X * (X(+) * D(-1) * X)(-1) * C`\n. also calculate a minimal threshold for this class, the smallest self-similarity from the train images\n. @param images a vector<Mat> with the train images"},
| 56004 |  |  | 55956 |
| 56005 | {NULL, NULL} |  | 55957 | {NULL, NULL}
| 56006 | }; |  | 55958 | };
| 56007 |  |  | 55959 |
| 56008 | // Converter (face_MACE) |  | 55960 | // Converter (face_MACE)
| 56009 |  |  | 55961 |
| 56010 | template<> |  | 55962 | template<>
| 56011 | struct PyOpenCV_Converter< Ptr<cv::face::MACE> > |  | 55963 | struct PyOpenCV_Converter< Ptr<cv::face::MACE> >
| 56012 | { |  | 55964 | {
| 56013 | static PyObject* from(const Ptr<cv::face::MACE>& r) |  | 55965 | static PyObject* from(const Ptr<cv::face::MACE>& r)
| 56014 | { |  | 55966 | {
| 56015 | return pyopencv_face_MACE_Instance(r); |  | 55967 | return pyopencv_face_MACE_Instance(r);
| 56016 | } |  | 55968 | }
| 56017 | static bool to(PyObject* src, Ptr<cv::face::MACE>& dst, const ArgInfo& info) |  | 55969 | static bool to(PyObject* src, Ptr<cv::face::MACE>& dst, const ArgInfo& info)
| 56018 | { |  | 55970 | {
| 56019 | if(!src || src == Py_None) |  | 55971 | if(!src || src == Py_None)
| 56020 | return true; |  | 55972 | return true;
| 56021 | Ptr<cv::face::MACE> * dst_; |  | 55973 | Ptr<cv::face::MACE> * dst_;
| 56022 | if (pyopencv_face_MACE_getp(src, dst_)) |  | 55974 | if (pyopencv_face_MACE_getp(src, dst_))
| 56023 | { |  | 55975 | {
| 56024 | dst = *dst_; |  | 55976 | dst = *dst_;
| 56025 | return true; |  | 55977 | return true;
| 56026 | } |  | 55978 | }
| 56027 |  |  | 55979 |
| 56028 | failmsg("Expected Ptr<cv::face::MACE> for argument '%s'", info.name); |  | 55980 | failmsg("Expected Ptr<cv::face::MACE> for argument '%s'", info.name);
| 56029 | return false; |  | 55981 | return false;
| 56030 | } |  | 55982 | }
| 56031 | }; |  | 55983 | };
| 56032 |  |  | 55984 |
| 56033 | //================================================================================ |  | 55985 | //================================================================================
| 56034 | // face_PredictCollector (Generic) |  | 55986 | // face_PredictCollector (Generic)
| 56035 | //================================================================================ |  | 55987 | //================================================================================
| 56036 |  |  | 55988 |
| 56037 | // GetSet (face_PredictCollector) |  | 55989 | // GetSet (face_PredictCollector)
| 56038 |  |  | 55990 |
| 56039 |  |  | 55991 |
| 56040 |  |  | 55992 |
| 56041 | // Methods (face_PredictCollector) |  | 55993 | // Methods (face_PredictCollector)
| 56042 |  |  | 55994 |
| 56043 |  |  | 55995 |
| 56044 |  |  | 55996 |
| 56045 | // Tables (face_PredictCollector) |  | 55997 | // Tables (face_PredictCollector)
| 56046 |  |  | 55998 |
| 56047 | static PyGetSetDef pyopencv_face_PredictCollector_getseters[] = |  | 55999 | static PyGetSetDef pyopencv_face_PredictCollector_getseters[] =
| 56048 | { |  | 56000 | {
| 56049 | {NULL} /* Sentinel */ |  | 56001 | {NULL} /* Sentinel */
| 56050 | }; |  | 56002 | };
| 56051 |  |  | 56003 |
| 56052 | static PyMethodDef pyopencv_face_PredictCollector_methods[] = |  | 56004 | static PyMethodDef pyopencv_face_PredictCollector_methods[] =
| 56053 | { |  | 56005 | {
| 56054 |  |  | 56006 |
| 56055 | {NULL, NULL} |  | 56007 | {NULL, NULL}
| 56056 | }; |  | 56008 | };
| 56057 |  |  | 56009 |
| 56058 | // Converter (face_PredictCollector) |  | 56010 | // Converter (face_PredictCollector)
| 56059 |  |  | 56011 |
| 56060 | template<> |  | 56012 | template<>
| 56061 | struct PyOpenCV_Converter< Ptr<cv::face::PredictCollector> > |  | 56013 | struct PyOpenCV_Converter< Ptr<cv::face::PredictCollector> >
| 56062 | { |  | 56014 | {
| 56063 | static PyObject* from(const Ptr<cv::face::PredictCollector>& r) |  | 56015 | static PyObject* from(const Ptr<cv::face::PredictCollector>& r)
| 56064 | { |  | 56016 | {
| 56065 | return pyopencv_face_PredictCollector_Instance(r); |  | 56017 | return pyopencv_face_PredictCollector_Instance(r);
| 56066 | } |  | 56018 | }
| 56067 | static bool to(PyObject* src, Ptr<cv::face::PredictCollector>& dst, const ArgInfo& info) |  | 56019 | static bool to(PyObject* src, Ptr<cv::face::PredictCollector>& dst, const ArgInfo& info)
| 56068 | { |  | 56020 | {
| 56069 | if(!src || src == Py_None) |  | 56021 | if(!src || src == Py_None)
| 56070 | return true; |  | 56022 | return true;
| 56071 | Ptr<cv::face::PredictCollector> * dst_; |  | 56023 | Ptr<cv::face::PredictCollector> * dst_;
| 56072 | if (pyopencv_face_PredictCollector_getp(src, dst_)) |  | 56024 | if (pyopencv_face_PredictCollector_getp(src, dst_))
| 56073 | { |  | 56025 | {
| 56074 | dst = *dst_; |  | 56026 | dst = *dst_;
| 56075 | return true; |  | 56027 | return true;
| 56076 | } |  | 56028 | }
| 56077 |  |  | 56029 |
| 56078 | failmsg("Expected Ptr<cv::face::PredictCollector> for argument '%s'", info.name); |  | 56030 | failmsg("Expected Ptr<cv::face::PredictCollector> for argument '%s'", info.name);
| 56079 | return false; |  | 56031 | return false;
| 56080 | } |  | 56032 | }
| 56081 | }; |  | 56033 | };
| 56082 |  |  | 56034 |
| 56083 | //================================================================================ |  | 56035 | //================================================================================
| 56084 | // face_StandardCollector (Generic) |  | 56036 | // face_StandardCollector (Generic)
| 56085 | //================================================================================ |  | 56037 | //================================================================================
| 56086 |  |  | 56038 |
| 56087 | // GetSet (face_StandardCollector) |  | 56039 | // GetSet (face_StandardCollector)
| 56088 |  |  | 56040 |
| 56089 |  |  | 56041 |
| 56090 |  |  | 56042 |
| 56091 | // Methods (face_StandardCollector) |  | 56043 | // Methods (face_StandardCollector)
| 56092 |  |  | 56044 |
| 56093 | static PyObject* pyopencv_cv_face_face_StandardCollector_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56045 | static PyObject* pyopencv_cv_face_face_StandardCollector_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 56094 | { |  | 56046 | {
| 56095 | using namespace cv::face; |  | 56047 | using namespace cv::face;
| 56096 |  |  | 56048 |
| 56097 | PyObject* pyobj_threshold = NULL; |  | 56049 | PyObject* pyobj_threshold = NULL;
| 56098 | double threshold=DBL_MAX; |  | 56050 | double threshold=DBL_MAX;
| 56099 | Ptr<StandardCollector> retval; |  | 56051 | Ptr<StandardCollector> retval;
| 56100 |  |  | 56052 |
| 56101 | const char* keywords[] = { "threshold", NULL }; |  | 56053 | const char* keywords[] = { "threshold", NULL };
| 56102 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:face_StandardCollector.create", (char**)keywords, &pyobj_threshold) && |  | 56054 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:face_StandardCollector.create", (char**)keywords, &pyobj_threshold) &&
| 56103 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) ) |  | 56055 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) )
| 56104 | { |  | 56056 | {
| 56105 | ERRWRAP2(retval = cv::face::StandardCollector::create(threshold)); |  | 56057 | ERRWRAP2(retval = cv::face::StandardCollector::create(threshold));
| 56106 | return pyopencv_from(retval); |  | 56058 | return pyopencv_from(retval);
| 56107 | } |  | 56059 | }
| 56108 |  |  | 56060 |
| 56109 | return NULL; |  | 56061 | return NULL;
| 56110 | } |  | 56062 | }
| 56111 |  |  | 56063 |
| 56112 | static PyObject* pyopencv_cv_face_face_StandardCollector_getMinDist(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56064 | static PyObject* pyopencv_cv_face_face_StandardCollector_getMinDist(PyObject* self, PyObject* py_args, PyObject* kw)
| 56113 | { |  | 56065 | {
| 56114 | using namespace cv::face; |  | 56066 | using namespace cv::face;
| 56115 |  |  | 56067 |
| 56116 |  |  | 56068 |
| 56117 | Ptr<cv::face::StandardCollector> * self1 = 0; |  | 56069 | Ptr<cv::face::StandardCollector> * self1 = 0;
| 56118 | if (!pyopencv_face_StandardCollector_getp(self, self1)) |  | 56070 | if (!pyopencv_face_StandardCollector_getp(self, self1))
| 56119 | return failmsgp("Incorrect type of self (must be 'face_StandardCollector' or its derivative)"); |  | 56071 | return failmsgp("Incorrect type of self (must be 'face_StandardCollector' or its derivative)");
| 56120 | Ptr<cv::face::StandardCollector> _self_ = *(self1); |  | 56072 | Ptr<cv::face::StandardCollector> _self_ = *(self1);
| 56121 | double retval; |  | 56073 | double retval;
| 56122 |  |  | 56074 |
| 56123 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 56075 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 56124 | { |  | 56076 | {
| 56125 | ERRWRAP2(retval = _self_->getMinDist()); |  | 56077 | ERRWRAP2(retval = _self_->getMinDist());
| 56126 | return pyopencv_from(retval); |  | 56078 | return pyopencv_from(retval);
| 56127 | } |  | 56079 | }
| 56128 |  |  | 56080 |
| 56129 | return NULL; |  | 56081 | return NULL;
| 56130 | } |  | 56082 | }
| 56131 |  |  | 56083 |
| 56132 | static PyObject* pyopencv_cv_face_face_StandardCollector_getMinLabel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56084 | static PyObject* pyopencv_cv_face_face_StandardCollector_getMinLabel(PyObject* self, PyObject* py_args, PyObject* kw)
| 56133 | { |  | 56085 | {
| 56134 | using namespace cv::face; |  | 56086 | using namespace cv::face;
| 56135 |  |  | 56087 |
| 56136 |  |  | 56088 |
| 56137 | Ptr<cv::face::StandardCollector> * self1 = 0; |  | 56089 | Ptr<cv::face::StandardCollector> * self1 = 0;
| 56138 | if (!pyopencv_face_StandardCollector_getp(self, self1)) |  | 56090 | if (!pyopencv_face_StandardCollector_getp(self, self1))
| 56139 | return failmsgp("Incorrect type of self (must be 'face_StandardCollector' or its derivative)"); |  | 56091 | return failmsgp("Incorrect type of self (must be 'face_StandardCollector' or its derivative)");
| 56140 | Ptr<cv::face::StandardCollector> _self_ = *(self1); |  | 56092 | Ptr<cv::face::StandardCollector> _self_ = *(self1);
| 56141 | int retval; |  | 56093 | int retval;
| 56142 |  |  | 56094 |
| 56143 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 56095 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 56144 | { |  | 56096 | {
| 56145 | ERRWRAP2(retval = _self_->getMinLabel()); |  | 56097 | ERRWRAP2(retval = _self_->getMinLabel());
| 56146 | return pyopencv_from(retval); |  | 56098 | return pyopencv_from(retval);
| 56147 | } |  | 56099 | }
| 56148 |  |  | 56100 |
| 56149 | return NULL; |  | 56101 | return NULL;
| 56150 | } |  | 56102 | }
| 56151 |  |  | 56103 |
| 56152 | static PyObject* pyopencv_cv_face_face_StandardCollector_getResults(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56104 | static PyObject* pyopencv_cv_face_face_StandardCollector_getResults(PyObject* self, PyObject* py_args, PyObject* kw)
| 56153 | { |  | 56105 | {
| 56154 | using namespace cv::face; |  | 56106 | using namespace cv::face;
| 56155 |  |  | 56107 |
| 56156 |  |  | 56108 |
| 56157 | Ptr<cv::face::StandardCollector> * self1 = 0; |  | 56109 | Ptr<cv::face::StandardCollector> * self1 = 0;
| 56158 | if (!pyopencv_face_StandardCollector_getp(self, self1)) |  | 56110 | if (!pyopencv_face_StandardCollector_getp(self, self1))
| 56159 | return failmsgp("Incorrect type of self (must be 'face_StandardCollector' or its derivative)"); |  | 56111 | return failmsgp("Incorrect type of self (must be 'face_StandardCollector' or its derivative)");
| 56160 | Ptr<cv::face::StandardCollector> _self_ = *(self1); |  | 56112 | Ptr<cv::face::StandardCollector> _self_ = *(self1);
| 56161 | PyObject* pyobj_sorted = NULL; |  | 56113 | PyObject* pyobj_sorted = NULL;
| 56162 | bool sorted=false; |  | 56114 | bool sorted=false;
| 56163 | std::vector< std::pair<int, double> > retval; |  | 56115 | std::vector< std::pair<int, double> > retval;
| 56164 |  |  | 56116 |
| 56165 | const char* keywords[] = { "sorted", NULL }; |  | 56117 | const char* keywords[] = { "sorted", NULL };
| 56166 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:face_StandardCollector.getResults", (char**)keywords, &pyobj_sorted) && |  | 56118 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:face_StandardCollector.getResults", (char**)keywords, &pyobj_sorted) &&
| 56167 | pyopencv_to_safe(pyobj_sorted, sorted, ArgInfo("sorted", 0)) ) |  | 56119 | pyopencv_to_safe(pyobj_sorted, sorted, ArgInfo("sorted", 0)) )
| 56168 | { |  | 56120 | {
| 56169 | ERRWRAP2(retval = _self_->getResults(sorted)); |  | 56121 | ERRWRAP2(retval = _self_->getResults(sorted));
| 56170 | return pyopencv_from(retval); |  | 56122 | return pyopencv_from(retval);
| 56171 | } |  | 56123 | }
| 56172 |  |  | 56124 |
| 56173 | return NULL; |  | 56125 | return NULL;
| 56174 | } |  | 56126 | }
| 56175 |  |  | 56127 |
| 56176 |  |  | 56128 |
| 56177 |  |  | 56129 |
| 56178 | // Tables (face_StandardCollector) |  | 56130 | // Tables (face_StandardCollector)
| 56179 |  |  | 56131 |
| 56180 | static PyGetSetDef pyopencv_face_StandardCollector_getseters[] = |  | 56132 | static PyGetSetDef pyopencv_face_StandardCollector_getseters[] =
| 56181 | { |  | 56133 | {
| 56182 | {NULL} /* Sentinel */ |  | 56134 | {NULL} /* Sentinel */
| 56183 | }; |  | 56135 | };
| 56184 |  |  | 56136 |
| 56185 | static PyMethodDef pyopencv_face_StandardCollector_methods[] = |  | 56137 | static PyMethodDef pyopencv_face_StandardCollector_methods[] =
| 56186 | { |  | 56138 | {
| 56187 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_create_static, METH_STATIC), "create([, threshold]) -> retval\n. @brief Static constructor\n. @param threshold set threshold"}, |  | 56139 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_create_static, METH_STATIC), "create([, threshold]) -> retval\n. @brief Static constructor\n. @param threshold set threshold"},
| 56188 | {"getMinDist", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_getMinDist, 0), "getMinDist() -> retval\n. @brief Returns minimal distance value"}, |  | 56140 | {"getMinDist", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_getMinDist, 0), "getMinDist() -> retval\n. @brief Returns minimal distance value"},
| 56189 | {"getMinLabel", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_getMinLabel, 0), "getMinLabel() -> retval\n. @brief Returns label with minimal distance"}, |  | 56141 | {"getMinLabel", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_getMinLabel, 0), "getMinLabel() -> retval\n. @brief Returns label with minimal distance"},
| 56190 | {"getResults", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_getResults, 0), "getResults([, sorted]) -> retval\n. @brief Return results as vector\n. @param sorted If set, results will be sorted by distance\n. Each values is a pair of label and distance."}, |  | 56142 | {"getResults", CV_PY_FN_WITH_KW_(pyopencv_cv_face_face_StandardCollector_getResults, 0), "getResults([, sorted]) -> retval\n. @brief Return results as vector\n. @param sorted If set, results will be sorted by distance\n. Each values is a pair of label and distance."},
| 56191 |  |  | 56143 |
| 56192 | {NULL, NULL} |  | 56144 | {NULL, NULL}
| 56193 | }; |  | 56145 | };
| 56194 |  |  | 56146 |
| 56195 | // Converter (face_StandardCollector) |  | 56147 | // Converter (face_StandardCollector)
| 56196 |  |  | 56148 |
| 56197 | template<> |  | 56149 | template<>
| 56198 | struct PyOpenCV_Converter< Ptr<cv::face::StandardCollector> > |  | 56150 | struct PyOpenCV_Converter< Ptr<cv::face::StandardCollector> >
| 56199 | { |  | 56151 | {
| 56200 | static PyObject* from(const Ptr<cv::face::StandardCollector>& r) |  | 56152 | static PyObject* from(const Ptr<cv::face::StandardCollector>& r)
| 56201 | { |  | 56153 | {
| 56202 | return pyopencv_face_StandardCollector_Instance(r); |  | 56154 | return pyopencv_face_StandardCollector_Instance(r);
| 56203 | } |  | 56155 | }
| 56204 | static bool to(PyObject* src, Ptr<cv::face::StandardCollector>& dst, const ArgInfo& info) |  | 56156 | static bool to(PyObject* src, Ptr<cv::face::StandardCollector>& dst, const ArgInfo& info)
| 56205 | { |  | 56157 | {
| 56206 | if(!src || src == Py_None) |  | 56158 | if(!src || src == Py_None)
| 56207 | return true; |  | 56159 | return true;
| 56208 | Ptr<cv::face::StandardCollector> * dst_; |  | 56160 | Ptr<cv::face::StandardCollector> * dst_;
| 56209 | if (pyopencv_face_StandardCollector_getp(src, dst_)) |  | 56161 | if (pyopencv_face_StandardCollector_getp(src, dst_))
| 56210 | { |  | 56162 | {
| 56211 | dst = *dst_; |  | 56163 | dst = *dst_;
| 56212 | return true; |  | 56164 | return true;
| 56213 | } |  | 56165 | }
| 56214 |  |  | 56166 |
| 56215 | failmsg("Expected Ptr<cv::face::StandardCollector> for argument '%s'", info.name); |  | 56167 | failmsg("Expected Ptr<cv::face::StandardCollector> for argument '%s'", info.name);
| 56216 | return false; |  | 56168 | return false;
| 56217 | } |  | 56169 | }
| 56218 | }; |  | 56170 | };
| 56219 |  |  | 56171 |
| 56220 | //================================================================================ |  | 56172 | //================================================================================
| 56221 | // flann_Index (Generic) |  | 56173 | // flann_Index (Generic)
| 56222 | //================================================================================ |  | 56174 | //================================================================================
| 56223 |  |  | 56175 |
| 56224 | // GetSet (flann_Index) |  | 56176 | // GetSet (flann_Index)
| 56225 |  |  | 56177 |
| 56226 |  |  | 56178 |
| 56227 |  |  | 56179 |
| 56228 | // Methods (flann_Index) |  | 56180 | // Methods (flann_Index)
| 56229 |  |  | 56181 |
| 56230 | static int pyopencv_cv_flann_flann_Index_Index(pyopencv_flann_Index_t* self, PyObject* py_args, PyObject* kw) |  | 56182 | static int pyopencv_cv_flann_flann_Index_Index(pyopencv_flann_Index_t* self, PyObject* py_args, PyObject* kw)
| 56231 | { |  | 56183 | {
| 56232 | using namespace cv::flann; |  | 56184 | using namespace cv::flann;
| 56233 |  |  | 56185 |
| 56234 | pyPrepareArgumentConversionErrorsStorage(3); |  | 56186 | pyPrepareArgumentConversionErrorsStorage(3);
| 56235 |  |  | 56187 |
| 56236 | { |  | 56188 | {
| 56237 |  |  | 56189 |
| 56238 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 56190 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 56239 | { |  | 56191 | {
| 56240 | new (&(self->v)) Ptr<cv::flann::Index>(); // init Ptr with placement new |  | 56192 | new (&(self->v)) Ptr<cv::flann::Index>(); // init Ptr with placement new
| 56241 | if(self) ERRWRAP2(self->v.reset(new cv::flann::Index())); |  | 56193 | if(self) ERRWRAP2(self->v.reset(new cv::flann::Index()));
| 56242 | return 0; |  | 56194 | return 0;
| 56243 | } |  | 56195 | }
| 56244 |  |  | 56196 |
| 56245 |  |  | 56197 |
| 56246 | pyPopulateArgumentConversionErrors(); |  | 56198 | pyPopulateArgumentConversionErrors();
| 56247 | } |  | 56199 | }
| 56248 |  |  | 56200 |
| 56249 |  |  | 56201 |
| 56250 | { |  | 56202 | {
| 56251 | PyObject* pyobj_features = NULL; |  | 56203 | PyObject* pyobj_features = NULL;
| 56252 | Mat features; |  | 56204 | Mat features;
| 56253 | PyObject* pyobj_params = NULL; |  | 56205 | PyObject* pyobj_params = NULL;
| 56254 | IndexParams params; |  | 56206 | IndexParams params;
| 56255 | PyObject* pyobj_distType = NULL; |  | 56207 | PyObject* pyobj_distType = NULL;
| 56256 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2; |  | 56208 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2;
| 56257 |  |  | 56209 |
| 56258 | const char* keywords[] = { "features", "params", "distType", NULL }; |  | 56210 | const char* keywords[] = { "features", "params", "distType", NULL };
| 56259 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Index", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) && |  | 56211 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Index", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) &&
| 56260 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 56212 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 56261 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) && |  | 56213 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) &&
| 56262 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) ) |  | 56214 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) )
| 56263 | { |  | 56215 | {
| 56264 | new (&(self->v)) Ptr<cv::flann::Index>(); // init Ptr with placement new |  | 56216 | new (&(self->v)) Ptr<cv::flann::Index>(); // init Ptr with placement new
| 56265 | if(self) ERRWRAP2(self->v.reset(new cv::flann::Index(features, params, distType))); |  | 56217 | if(self) ERRWRAP2(self->v.reset(new cv::flann::Index(features, params, distType)));
| 56266 | return 0; |  | 56218 | return 0;
| 56267 | } |  | 56219 | }
| 56268 |  |  | 56220 |
| 56269 |  |  | 56221 |
| 56270 | pyPopulateArgumentConversionErrors(); |  | 56222 | pyPopulateArgumentConversionErrors();
| 56271 | } |  | 56223 | }
| 56272 |  |  | 56224 |
| 56273 |  |  | 56225 |
| 56274 | { |  | 56226 | {
| 56275 | PyObject* pyobj_features = NULL; |  | 56227 | PyObject* pyobj_features = NULL;
| 56276 | UMat features; |  | 56228 | UMat features;
| 56277 | PyObject* pyobj_params = NULL; |  | 56229 | PyObject* pyobj_params = NULL;
| 56278 | IndexParams params; |  | 56230 | IndexParams params;
| 56279 | PyObject* pyobj_distType = NULL; |  | 56231 | PyObject* pyobj_distType = NULL;
| 56280 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2; |  | 56232 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2;
| 56281 |  |  | 56233 |
| 56282 | const char* keywords[] = { "features", "params", "distType", NULL }; |  | 56234 | const char* keywords[] = { "features", "params", "distType", NULL };
| 56283 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Index", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) && |  | 56235 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:Index", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) &&
| 56284 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 56236 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 56285 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) && |  | 56237 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) &&
| 56286 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) ) |  | 56238 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) )
| 56287 | { |  | 56239 | {
| 56288 | new (&(self->v)) Ptr<cv::flann::Index>(); // init Ptr with placement new |  | 56240 | new (&(self->v)) Ptr<cv::flann::Index>(); // init Ptr with placement new
| 56289 | if(self) ERRWRAP2(self->v.reset(new cv::flann::Index(features, params, distType))); |  | 56241 | if(self) ERRWRAP2(self->v.reset(new cv::flann::Index(features, params, distType)));
| 56290 | return 0; |  | 56242 | return 0;
| 56291 | } |  | 56243 | }
| 56292 |  |  | 56244 |
| 56293 |  |  | 56245 |
| 56294 | pyPopulateArgumentConversionErrors(); |  | 56246 | pyPopulateArgumentConversionErrors();
| 56295 | } |  | 56247 | }
| 56296 | pyRaiseCVOverloadException("Index"); |  | 56248 | pyRaiseCVOverloadException("Index");
| 56297 |  |  | 56249 |
| 56298 | return -1; |  | 56250 | return -1;
| 56299 | } |  | 56251 | }
| 56300 |  |  | 56252 |
| 56301 | static PyObject* pyopencv_cv_flann_flann_Index_build(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56253 | static PyObject* pyopencv_cv_flann_flann_Index_build(PyObject* self, PyObject* py_args, PyObject* kw)
| 56302 | { |  | 56254 | {
| 56303 | using namespace cv::flann; |  | 56255 | using namespace cv::flann;
| 56304 |  |  | 56256 |
| 56305 |  |  | 56257 |
| 56306 | Ptr<cv::flann::Index> * self1 = 0; |  | 56258 | Ptr<cv::flann::Index> * self1 = 0;
| 56307 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56259 | if (!pyopencv_flann_Index_getp(self, self1))
| 56308 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56260 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56309 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56261 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56310 | pyPrepareArgumentConversionErrorsStorage(2); |  | 56262 | pyPrepareArgumentConversionErrorsStorage(2);
| 56311 |  |  | 56263 |
| 56312 | { |  | 56264 | {
| 56313 | PyObject* pyobj_features = NULL; |  | 56265 | PyObject* pyobj_features = NULL;
| 56314 | Mat features; |  | 56266 | Mat features;
| 56315 | PyObject* pyobj_params = NULL; |  | 56267 | PyObject* pyobj_params = NULL;
| 56316 | IndexParams params; |  | 56268 | IndexParams params;
| 56317 | PyObject* pyobj_distType = NULL; |  | 56269 | PyObject* pyobj_distType = NULL;
| 56318 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2; |  | 56270 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2;
| 56319 |  |  | 56271 |
| 56320 | const char* keywords[] = { "features", "params", "distType", NULL }; |  | 56272 | const char* keywords[] = { "features", "params", "distType", NULL };
| 56321 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:flann_Index.build", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) && |  | 56273 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:flann_Index.build", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) &&
| 56322 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 56274 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 56323 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) && |  | 56275 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) &&
| 56324 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) ) |  | 56276 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) )
| 56325 | { |  | 56277 | {
| 56326 | ERRWRAP2(_self_->build(features, params, distType)); |  | 56278 | ERRWRAP2(_self_->build(features, params, distType));
| 56327 | Py_RETURN_NONE; |  | 56279 | Py_RETURN_NONE;
| 56328 | } |  | 56280 | }
| 56329 |  |  | 56281 |
| 56330 |  |  | 56282 |
| 56331 | pyPopulateArgumentConversionErrors(); |  | 56283 | pyPopulateArgumentConversionErrors();
| 56332 | } |  | 56284 | }
| 56333 |  |  | 56285 |
| 56334 |  |  | 56286 |
| 56335 | { |  | 56287 | {
| 56336 | PyObject* pyobj_features = NULL; |  | 56288 | PyObject* pyobj_features = NULL;
| 56337 | UMat features; |  | 56289 | UMat features;
| 56338 | PyObject* pyobj_params = NULL; |  | 56290 | PyObject* pyobj_params = NULL;
| 56339 | IndexParams params; |  | 56291 | IndexParams params;
| 56340 | PyObject* pyobj_distType = NULL; |  | 56292 | PyObject* pyobj_distType = NULL;
| 56341 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2; |  | 56293 | cvflann_flann_distance_t distType=cvflann::FLANN_DIST_L2;
| 56342 |  |  | 56294 |
| 56343 | const char* keywords[] = { "features", "params", "distType", NULL }; |  | 56295 | const char* keywords[] = { "features", "params", "distType", NULL };
| 56344 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:flann_Index.build", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) && |  | 56296 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:flann_Index.build", (char**)keywords, &pyobj_features, &pyobj_params, &pyobj_distType) &&
| 56345 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 56297 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 56346 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) && |  | 56298 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) &&
| 56347 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) ) |  | 56299 | pyopencv_to_safe(pyobj_distType, distType, ArgInfo("distType", 0)) )
| 56348 | { |  | 56300 | {
| 56349 | ERRWRAP2(_self_->build(features, params, distType)); |  | 56301 | ERRWRAP2(_self_->build(features, params, distType));
| 56350 | Py_RETURN_NONE; |  | 56302 | Py_RETURN_NONE;
| 56351 | } |  | 56303 | }
| 56352 |  |  | 56304 |
| 56353 |  |  | 56305 |
| 56354 | pyPopulateArgumentConversionErrors(); |  | 56306 | pyPopulateArgumentConversionErrors();
| 56355 | } |  | 56307 | }
| 56356 | pyRaiseCVOverloadException("build"); |  | 56308 | pyRaiseCVOverloadException("build");
| 56357 |  |  | 56309 |
| 56358 | return NULL; |  | 56310 | return NULL;
| 56359 | } |  | 56311 | }
| 56360 |  |  | 56312 |
| 56361 | static PyObject* pyopencv_cv_flann_flann_Index_getAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56313 | static PyObject* pyopencv_cv_flann_flann_Index_getAlgorithm(PyObject* self, PyObject* py_args, PyObject* kw)
| 56362 | { |  | 56314 | {
| 56363 | using namespace cv::flann; |  | 56315 | using namespace cv::flann;
| 56364 |  |  | 56316 |
| 56365 |  |  | 56317 |
| 56366 | Ptr<cv::flann::Index> * self1 = 0; |  | 56318 | Ptr<cv::flann::Index> * self1 = 0;
| 56367 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56319 | if (!pyopencv_flann_Index_getp(self, self1))
| 56368 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56320 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56369 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56321 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56370 | cvflann::flann_algorithm_t retval; |  | 56322 | cvflann::flann_algorithm_t retval;
| 56371 |  |  | 56323 |
| 56372 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 56324 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 56373 | { |  | 56325 | {
| 56374 | ERRWRAP2(retval = _self_->getAlgorithm()); |  | 56326 | ERRWRAP2(retval = _self_->getAlgorithm());
| 56375 | return pyopencv_from(retval); |  | 56327 | return pyopencv_from(retval);
| 56376 | } |  | 56328 | }
| 56377 |  |  | 56329 |
| 56378 | return NULL; |  | 56330 | return NULL;
| 56379 | } |  | 56331 | }
| 56380 |  |  | 56332 |
| 56381 | static PyObject* pyopencv_cv_flann_flann_Index_getDistance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56333 | static PyObject* pyopencv_cv_flann_flann_Index_getDistance(PyObject* self, PyObject* py_args, PyObject* kw)
| 56382 | { |  | 56334 | {
| 56383 | using namespace cv::flann; |  | 56335 | using namespace cv::flann;
| 56384 |  |  | 56336 |
| 56385 |  |  | 56337 |
| 56386 | Ptr<cv::flann::Index> * self1 = 0; |  | 56338 | Ptr<cv::flann::Index> * self1 = 0;
| 56387 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56339 | if (!pyopencv_flann_Index_getp(self, self1))
| 56388 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56340 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56389 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56341 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56390 | cvflann::flann_distance_t retval; |  | 56342 | cvflann::flann_distance_t retval;
| 56391 |  |  | 56343 |
| 56392 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 56344 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 56393 | { |  | 56345 | {
| 56394 | ERRWRAP2(retval = _self_->getDistance()); |  | 56346 | ERRWRAP2(retval = _self_->getDistance());
| 56395 | return pyopencv_from(retval); |  | 56347 | return pyopencv_from(retval);
| 56396 | } |  | 56348 | }
| 56397 |  |  | 56349 |
| 56398 | return NULL; |  | 56350 | return NULL;
| 56399 | } |  | 56351 | }
| 56400 |  |  | 56352 |
| 56401 | static PyObject* pyopencv_cv_flann_flann_Index_knnSearch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56353 | static PyObject* pyopencv_cv_flann_flann_Index_knnSearch(PyObject* self, PyObject* py_args, PyObject* kw)
| 56402 | { |  | 56354 | {
| 56403 | using namespace cv::flann; |  | 56355 | using namespace cv::flann;
| 56404 |  |  | 56356 |
| 56405 |  |  | 56357 |
| 56406 | Ptr<cv::flann::Index> * self1 = 0; |  | 56358 | Ptr<cv::flann::Index> * self1 = 0;
| 56407 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56359 | if (!pyopencv_flann_Index_getp(self, self1))
| 56408 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56360 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56409 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56361 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56410 | pyPrepareArgumentConversionErrorsStorage(2); |  | 56362 | pyPrepareArgumentConversionErrorsStorage(2);
| 56411 |  |  | 56363 |
| 56412 | { |  | 56364 | {
| 56413 | PyObject* pyobj_query = NULL; |  | 56365 | PyObject* pyobj_query = NULL;
| 56414 | Mat query; |  | 56366 | Mat query;
| 56415 | PyObject* pyobj_indices = NULL; |  | 56367 | PyObject* pyobj_indices = NULL;
| 56416 | Mat indices; |  | 56368 | Mat indices;
| 56417 | PyObject* pyobj_dists = NULL; |  | 56369 | PyObject* pyobj_dists = NULL;
| 56418 | Mat dists; |  | 56370 | Mat dists;
| 56419 | PyObject* pyobj_knn = NULL; |  | 56371 | PyObject* pyobj_knn = NULL;
| 56420 | int knn=0; |  | 56372 | int knn=0;
| 56421 | PyObject* pyobj_params = NULL; |  | 56373 | PyObject* pyobj_params = NULL;
| 56422 | SearchParams params; |  | 56374 | SearchParams params;
| 56423 |  |  | 56375 |
| 56424 | const char* keywords[] = { "query", "knn", "indices", "dists", "params", NULL }; |  | 56376 | const char* keywords[] = { "query", "knn", "indices", "dists", "params", NULL };
| 56425 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:flann_Index.knnSearch", (char**)keywords, &pyobj_query, &pyobj_knn, &pyobj_indices, &pyobj_dists, &pyobj_params) && |  | 56377 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:flann_Index.knnSearch", (char**)keywords, &pyobj_query, &pyobj_knn, &pyobj_indices, &pyobj_dists, &pyobj_params) &&
| 56426 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) && |  | 56378 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) &&
| 56427 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) && |  | 56379 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) &&
| 56428 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) && |  | 56380 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) &&
| 56429 | pyopencv_to_safe(pyobj_knn, knn, ArgInfo("knn", 0)) && |  | 56381 | pyopencv_to_safe(pyobj_knn, knn, ArgInfo("knn", 0)) &&
| 56430 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 56382 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 56431 | { |  | 56383 | {
| 56432 | ERRWRAP2(_self_->knnSearch(query, indices, dists, knn, params)); |  | 56384 | ERRWRAP2(_self_->knnSearch(query, indices, dists, knn, params));
| 56433 | return Py_BuildValue("(NN)", pyopencv_from(indices), pyopencv_from(dists)); |  | 56385 | return Py_BuildValue("(NN)", pyopencv_from(indices), pyopencv_from(dists));
| 56434 | } |  | 56386 | }
| 56435 |  |  | 56387 |
| 56436 |  |  | 56388 |
| 56437 | pyPopulateArgumentConversionErrors(); |  | 56389 | pyPopulateArgumentConversionErrors();
| 56438 | } |  | 56390 | }
| 56439 |  |  | 56391 |
| 56440 |  |  | 56392 |
| 56441 | { |  | 56393 | {
| 56442 | PyObject* pyobj_query = NULL; |  | 56394 | PyObject* pyobj_query = NULL;
| 56443 | UMat query; |  | 56395 | UMat query;
| 56444 | PyObject* pyobj_indices = NULL; |  | 56396 | PyObject* pyobj_indices = NULL;
| 56445 | UMat indices; |  | 56397 | UMat indices;
| 56446 | PyObject* pyobj_dists = NULL; |  | 56398 | PyObject* pyobj_dists = NULL;
| 56447 | UMat dists; |  | 56399 | UMat dists;
| 56448 | PyObject* pyobj_knn = NULL; |  | 56400 | PyObject* pyobj_knn = NULL;
| 56449 | int knn=0; |  | 56401 | int knn=0;
| 56450 | PyObject* pyobj_params = NULL; |  | 56402 | PyObject* pyobj_params = NULL;
| 56451 | SearchParams params; |  | 56403 | SearchParams params;
| 56452 |  |  | 56404 |
| 56453 | const char* keywords[] = { "query", "knn", "indices", "dists", "params", NULL }; |  | 56405 | const char* keywords[] = { "query", "knn", "indices", "dists", "params", NULL };
| 56454 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:flann_Index.knnSearch", (char**)keywords, &pyobj_query, &pyobj_knn, &pyobj_indices, &pyobj_dists, &pyobj_params) && |  | 56406 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:flann_Index.knnSearch", (char**)keywords, &pyobj_query, &pyobj_knn, &pyobj_indices, &pyobj_dists, &pyobj_params) &&
| 56455 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) && |  | 56407 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) &&
| 56456 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) && |  | 56408 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) &&
| 56457 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) && |  | 56409 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) &&
| 56458 | pyopencv_to_safe(pyobj_knn, knn, ArgInfo("knn", 0)) && |  | 56410 | pyopencv_to_safe(pyobj_knn, knn, ArgInfo("knn", 0)) &&
| 56459 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 56411 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 56460 | { |  | 56412 | {
| 56461 | ERRWRAP2(_self_->knnSearch(query, indices, dists, knn, params)); |  | 56413 | ERRWRAP2(_self_->knnSearch(query, indices, dists, knn, params));
| 56462 | return Py_BuildValue("(NN)", pyopencv_from(indices), pyopencv_from(dists)); |  | 56414 | return Py_BuildValue("(NN)", pyopencv_from(indices), pyopencv_from(dists));
| 56463 | } |  | 56415 | }
| 56464 |  |  | 56416 |
| 56465 |  |  | 56417 |
| 56466 | pyPopulateArgumentConversionErrors(); |  | 56418 | pyPopulateArgumentConversionErrors();
| 56467 | } |  | 56419 | }
| 56468 | pyRaiseCVOverloadException("knnSearch"); |  | 56420 | pyRaiseCVOverloadException("knnSearch");
| 56469 |  |  | 56421 |
| 56470 | return NULL; |  | 56422 | return NULL;
| 56471 | } |  | 56423 | }
| 56472 |  |  | 56424 |
| 56473 | static PyObject* pyopencv_cv_flann_flann_Index_load(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56425 | static PyObject* pyopencv_cv_flann_flann_Index_load(PyObject* self, PyObject* py_args, PyObject* kw)
| 56474 | { |  | 56426 | {
| 56475 | using namespace cv::flann; |  | 56427 | using namespace cv::flann;
| 56476 |  |  | 56428 |
| 56477 |  |  | 56429 |
| 56478 | Ptr<cv::flann::Index> * self1 = 0; |  | 56430 | Ptr<cv::flann::Index> * self1 = 0;
| 56479 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56431 | if (!pyopencv_flann_Index_getp(self, self1))
| 56480 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56432 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56481 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56433 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56482 | pyPrepareArgumentConversionErrorsStorage(2); |  | 56434 | pyPrepareArgumentConversionErrorsStorage(2);
| 56483 |  |  | 56435 |
| 56484 | { |  | 56436 | {
| 56485 | PyObject* pyobj_features = NULL; |  | 56437 | PyObject* pyobj_features = NULL;
| 56486 | Mat features; |  | 56438 | Mat features;
| 56487 | PyObject* pyobj_filename = NULL; |  | 56439 | PyObject* pyobj_filename = NULL;
| 56488 | String filename; |  | 56440 | String filename;
| 56489 | bool retval; |  | 56441 | bool retval;
| 56490 |  |  | 56442 |
| 56491 | const char* keywords[] = { "features", "filename", NULL }; |  | 56443 | const char* keywords[] = { "features", "filename", NULL };
| 56492 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:flann_Index.load", (char**)keywords, &pyobj_features, &pyobj_filename) && |  | 56444 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:flann_Index.load", (char**)keywords, &pyobj_features, &pyobj_filename) &&
| 56493 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 56445 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 56494 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 56446 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 56495 | { |  | 56447 | {
| 56496 | ERRWRAP2(retval = _self_->load(features, filename)); |  | 56448 | ERRWRAP2(retval = _self_->load(features, filename));
| 56497 | return pyopencv_from(retval); |  | 56449 | return pyopencv_from(retval);
| 56498 | } |  | 56450 | }
| 56499 |  |  | 56451 |
| 56500 |  |  | 56452 |
| 56501 | pyPopulateArgumentConversionErrors(); |  | 56453 | pyPopulateArgumentConversionErrors();
| 56502 | } |  | 56454 | }
| 56503 |  |  | 56455 |
| 56504 |  |  | 56456 |
| 56505 | { |  | 56457 | {
| 56506 | PyObject* pyobj_features = NULL; |  | 56458 | PyObject* pyobj_features = NULL;
| 56507 | UMat features; |  | 56459 | UMat features;
| 56508 | PyObject* pyobj_filename = NULL; |  | 56460 | PyObject* pyobj_filename = NULL;
| 56509 | String filename; |  | 56461 | String filename;
| 56510 | bool retval; |  | 56462 | bool retval;
| 56511 |  |  | 56463 |
| 56512 | const char* keywords[] = { "features", "filename", NULL }; |  | 56464 | const char* keywords[] = { "features", "filename", NULL };
| 56513 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:flann_Index.load", (char**)keywords, &pyobj_features, &pyobj_filename) && |  | 56465 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:flann_Index.load", (char**)keywords, &pyobj_features, &pyobj_filename) &&
| 56514 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) && |  | 56466 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 0)) &&
| 56515 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 56467 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 56516 | { |  | 56468 | {
| 56517 | ERRWRAP2(retval = _self_->load(features, filename)); |  | 56469 | ERRWRAP2(retval = _self_->load(features, filename));
| 56518 | return pyopencv_from(retval); |  | 56470 | return pyopencv_from(retval);
| 56519 | } |  | 56471 | }
| 56520 |  |  | 56472 |
| 56521 |  |  | 56473 |
| 56522 | pyPopulateArgumentConversionErrors(); |  | 56474 | pyPopulateArgumentConversionErrors();
| 56523 | } |  | 56475 | }
| 56524 | pyRaiseCVOverloadException("load"); |  | 56476 | pyRaiseCVOverloadException("load");
| 56525 |  |  | 56477 |
| 56526 | return NULL; |  | 56478 | return NULL;
| 56527 | } |  | 56479 | }
| 56528 |  |  | 56480 |
| 56529 | static PyObject* pyopencv_cv_flann_flann_Index_radiusSearch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56481 | static PyObject* pyopencv_cv_flann_flann_Index_radiusSearch(PyObject* self, PyObject* py_args, PyObject* kw)
| 56530 | { |  | 56482 | {
| 56531 | using namespace cv::flann; |  | 56483 | using namespace cv::flann;
| 56532 |  |  | 56484 |
| 56533 |  |  | 56485 |
| 56534 | Ptr<cv::flann::Index> * self1 = 0; |  | 56486 | Ptr<cv::flann::Index> * self1 = 0;
| 56535 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56487 | if (!pyopencv_flann_Index_getp(self, self1))
| 56536 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56488 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56537 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56489 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56538 | pyPrepareArgumentConversionErrorsStorage(2); |  | 56490 | pyPrepareArgumentConversionErrorsStorage(2);
| 56539 |  |  | 56491 |
| 56540 | { |  | 56492 | {
| 56541 | PyObject* pyobj_query = NULL; |  | 56493 | PyObject* pyobj_query = NULL;
| 56542 | Mat query; |  | 56494 | Mat query;
| 56543 | PyObject* pyobj_indices = NULL; |  | 56495 | PyObject* pyobj_indices = NULL;
| 56544 | Mat indices; |  | 56496 | Mat indices;
| 56545 | PyObject* pyobj_dists = NULL; |  | 56497 | PyObject* pyobj_dists = NULL;
| 56546 | Mat dists; |  | 56498 | Mat dists;
| 56547 | PyObject* pyobj_radius = NULL; |  | 56499 | PyObject* pyobj_radius = NULL;
| 56548 | double radius=0; |  | 56500 | double radius=0;
| 56549 | PyObject* pyobj_maxResults = NULL; |  | 56501 | PyObject* pyobj_maxResults = NULL;
| 56550 | int maxResults=0; |  | 56502 | int maxResults=0;
| 56551 | PyObject* pyobj_params = NULL; |  | 56503 | PyObject* pyobj_params = NULL;
| 56552 | SearchParams params; |  | 56504 | SearchParams params;
| 56553 | int retval; |  | 56505 | int retval;
| 56554 |  |  | 56506 |
| 56555 | const char* keywords[] = { "query", "radius", "maxResults", "indices", "dists", "params", NULL }; |  | 56507 | const char* keywords[] = { "query", "radius", "maxResults", "indices", "dists", "params", NULL };
| 56556 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:flann_Index.radiusSearch", (char**)keywords, &pyobj_query, &pyobj_radius, &pyobj_maxResults, &pyobj_indices, &pyobj_dists, &pyobj_params) && |  | 56508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:flann_Index.radiusSearch", (char**)keywords, &pyobj_query, &pyobj_radius, &pyobj_maxResults, &pyobj_indices, &pyobj_dists, &pyobj_params) &&
| 56557 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) && |  | 56509 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) &&
| 56558 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) && |  | 56510 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) &&
| 56559 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) && |  | 56511 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) &&
| 56560 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) && |  | 56512 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) &&
| 56561 | pyopencv_to_safe(pyobj_maxResults, maxResults, ArgInfo("maxResults", 0)) && |  | 56513 | pyopencv_to_safe(pyobj_maxResults, maxResults, ArgInfo("maxResults", 0)) &&
| 56562 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 56514 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 56563 | { |  | 56515 | {
| 56564 | ERRWRAP2(retval = _self_->radiusSearch(query, indices, dists, radius, maxResults, params)); |  | 56516 | ERRWRAP2(retval = _self_->radiusSearch(query, indices, dists, radius, maxResults, params));
| 56565 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(indices), pyopencv_from(dists)); |  | 56517 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(indices), pyopencv_from(dists));
| 56566 | } |  | 56518 | }
| 56567 |  |  | 56519 |
| 56568 |  |  | 56520 |
| 56569 | pyPopulateArgumentConversionErrors(); |  | 56521 | pyPopulateArgumentConversionErrors();
| 56570 | } |  | 56522 | }
| 56571 |  |  | 56523 |
| 56572 |  |  | 56524 |
| 56573 | { |  | 56525 | {
| 56574 | PyObject* pyobj_query = NULL; |  | 56526 | PyObject* pyobj_query = NULL;
| 56575 | UMat query; |  | 56527 | UMat query;
| 56576 | PyObject* pyobj_indices = NULL; |  | 56528 | PyObject* pyobj_indices = NULL;
| 56577 | UMat indices; |  | 56529 | UMat indices;
| 56578 | PyObject* pyobj_dists = NULL; |  | 56530 | PyObject* pyobj_dists = NULL;
| 56579 | UMat dists; |  | 56531 | UMat dists;
| 56580 | PyObject* pyobj_radius = NULL; |  | 56532 | PyObject* pyobj_radius = NULL;
| 56581 | double radius=0; |  | 56533 | double radius=0;
| 56582 | PyObject* pyobj_maxResults = NULL; |  | 56534 | PyObject* pyobj_maxResults = NULL;
| 56583 | int maxResults=0; |  | 56535 | int maxResults=0;
| 56584 | PyObject* pyobj_params = NULL; |  | 56536 | PyObject* pyobj_params = NULL;
| 56585 | SearchParams params; |  | 56537 | SearchParams params;
| 56586 | int retval; |  | 56538 | int retval;
| 56587 |  |  | 56539 |
| 56588 | const char* keywords[] = { "query", "radius", "maxResults", "indices", "dists", "params", NULL }; |  | 56540 | const char* keywords[] = { "query", "radius", "maxResults", "indices", "dists", "params", NULL };
| 56589 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:flann_Index.radiusSearch", (char**)keywords, &pyobj_query, &pyobj_radius, &pyobj_maxResults, &pyobj_indices, &pyobj_dists, &pyobj_params) && |  | 56541 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:flann_Index.radiusSearch", (char**)keywords, &pyobj_query, &pyobj_radius, &pyobj_maxResults, &pyobj_indices, &pyobj_dists, &pyobj_params) &&
| 56590 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) && |  | 56542 | pyopencv_to_safe(pyobj_query, query, ArgInfo("query", 0)) &&
| 56591 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) && |  | 56543 | pyopencv_to_safe(pyobj_indices, indices, ArgInfo("indices", 1)) &&
| 56592 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) && |  | 56544 | pyopencv_to_safe(pyobj_dists, dists, ArgInfo("dists", 1)) &&
| 56593 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) && |  | 56545 | pyopencv_to_safe(pyobj_radius, radius, ArgInfo("radius", 0)) &&
| 56594 | pyopencv_to_safe(pyobj_maxResults, maxResults, ArgInfo("maxResults", 0)) && |  | 56546 | pyopencv_to_safe(pyobj_maxResults, maxResults, ArgInfo("maxResults", 0)) &&
| 56595 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 56547 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 56596 | { |  | 56548 | {
| 56597 | ERRWRAP2(retval = _self_->radiusSearch(query, indices, dists, radius, maxResults, params)); |  | 56549 | ERRWRAP2(retval = _self_->radiusSearch(query, indices, dists, radius, maxResults, params));
| 56598 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(indices), pyopencv_from(dists)); |  | 56550 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(indices), pyopencv_from(dists));
| 56599 | } |  | 56551 | }
| 56600 |  |  | 56552 |
| 56601 |  |  | 56553 |
| 56602 | pyPopulateArgumentConversionErrors(); |  | 56554 | pyPopulateArgumentConversionErrors();
| 56603 | } |  | 56555 | }
| 56604 | pyRaiseCVOverloadException("radiusSearch"); |  | 56556 | pyRaiseCVOverloadException("radiusSearch");
| 56605 |  |  | 56557 |
| 56606 | return NULL; |  | 56558 | return NULL;
| 56607 | } |  | 56559 | }
| 56608 |  |  | 56560 |
| 56609 | static PyObject* pyopencv_cv_flann_flann_Index_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56561 | static PyObject* pyopencv_cv_flann_flann_Index_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 56610 | { |  | 56562 | {
| 56611 | using namespace cv::flann; |  | 56563 | using namespace cv::flann;
| 56612 |  |  | 56564 |
| 56613 |  |  | 56565 |
| 56614 | Ptr<cv::flann::Index> * self1 = 0; |  | 56566 | Ptr<cv::flann::Index> * self1 = 0;
| 56615 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56567 | if (!pyopencv_flann_Index_getp(self, self1))
| 56616 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56568 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56617 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56569 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56618 |  |  | 56570 |
| 56619 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 56571 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 56620 | { |  | 56572 | {
| 56621 | ERRWRAP2(_self_->release()); |  | 56573 | ERRWRAP2(_self_->release());
| 56622 | Py_RETURN_NONE; |  | 56574 | Py_RETURN_NONE;
| 56623 | } |  | 56575 | }
| 56624 |  |  | 56576 |
| 56625 | return NULL; |  | 56577 | return NULL;
| 56626 | } |  | 56578 | }
| 56627 |  |  | 56579 |
| 56628 | static PyObject* pyopencv_cv_flann_flann_Index_save(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56580 | static PyObject* pyopencv_cv_flann_flann_Index_save(PyObject* self, PyObject* py_args, PyObject* kw)
| 56629 | { |  | 56581 | {
| 56630 | using namespace cv::flann; |  | 56582 | using namespace cv::flann;
| 56631 |  |  | 56583 |
| 56632 |  |  | 56584 |
| 56633 | Ptr<cv::flann::Index> * self1 = 0; |  | 56585 | Ptr<cv::flann::Index> * self1 = 0;
| 56634 | if (!pyopencv_flann_Index_getp(self, self1)) |  | 56586 | if (!pyopencv_flann_Index_getp(self, self1))
| 56635 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)"); |  | 56587 | return failmsgp("Incorrect type of self (must be 'flann_Index' or its derivative)");
| 56636 | Ptr<cv::flann::Index> _self_ = *(self1); |  | 56588 | Ptr<cv::flann::Index> _self_ = *(self1);
| 56637 | PyObject* pyobj_filename = NULL; |  | 56589 | PyObject* pyobj_filename = NULL;
| 56638 | String filename; |  | 56590 | String filename;
| 56639 |  |  | 56591 |
| 56640 | const char* keywords[] = { "filename", NULL }; |  | 56592 | const char* keywords[] = { "filename", NULL };
| 56641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:flann_Index.save", (char**)keywords, &pyobj_filename) && |  | 56593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:flann_Index.save", (char**)keywords, &pyobj_filename) &&
| 56642 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) ) |  | 56594 | pyopencv_to_safe(pyobj_filename, filename, ArgInfo("filename", 4)) )
| 56643 | { |  | 56595 | {
| 56644 | ERRWRAP2(_self_->save(filename)); |  | 56596 | ERRWRAP2(_self_->save(filename));
| 56645 | Py_RETURN_NONE; |  | 56597 | Py_RETURN_NONE;
| 56646 | } |  | 56598 | }
| 56647 |  |  | 56599 |
| 56648 | return NULL; |  | 56600 | return NULL;
| 56649 | } |  | 56601 | }
| 56650 |  |  | 56602 |
| 56651 |  |  | 56603 |
| 56652 |  |  | 56604 |
| 56653 | // Tables (flann_Index) |  | 56605 | // Tables (flann_Index)
| 56654 |  |  | 56606 |
| 56655 | static PyGetSetDef pyopencv_flann_Index_getseters[] = |  | 56607 | static PyGetSetDef pyopencv_flann_Index_getseters[] =
| 56656 | { |  | 56608 | {
| 56657 | {NULL} /* Sentinel */ |  | 56609 | {NULL} /* Sentinel */
| 56658 | }; |  | 56610 | };
| 56659 |  |  | 56611 |
| 56660 | static PyMethodDef pyopencv_flann_Index_methods[] = |  | 56612 | static PyMethodDef pyopencv_flann_Index_methods[] =
| 56661 | { |  | 56613 | {
| 56662 | {"build", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_build, 0), "build(features, params[, distType]) -> None\n."}, |  | 56614 | {"build", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_build, 0), "build(features, params[, distType]) -> None\n."},
| 56663 | {"getAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_getAlgorithm, 0), "getAlgorithm() -> retval\n."}, |  | 56615 | {"getAlgorithm", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_getAlgorithm, 0), "getAlgorithm() -> retval\n."},
| 56664 | {"getDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_getDistance, 0), "getDistance() -> retval\n."}, |  | 56616 | {"getDistance", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_getDistance, 0), "getDistance() -> retval\n."},
| 56665 | {"knnSearch", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_knnSearch, 0), "knnSearch(query, knn[, indices[, dists[, params]]]) -> indices, dists\n."}, |  | 56617 | {"knnSearch", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_knnSearch, 0), "knnSearch(query, knn[, indices[, dists[, params]]]) -> indices, dists\n."},
| 56666 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_load, 0), "load(features, filename) -> retval\n."}, |  | 56618 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_load, 0), "load(features, filename) -> retval\n."},
| 56667 | {"radiusSearch", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_radiusSearch, 0), "radiusSearch(query, radius, maxResults[, indices[, dists[, params]]]) -> retval, indices, dists\n."}, |  | 56619 | {"radiusSearch", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_radiusSearch, 0), "radiusSearch(query, radius, maxResults[, indices[, dists[, params]]]) -> retval, indices, dists\n."},
| 56668 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_release, 0), "release() -> None\n."}, |  | 56620 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_release, 0), "release() -> None\n."},
| 56669 | {"save", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_save, 0), "save(filename) -> None\n."}, |  | 56621 | {"save", CV_PY_FN_WITH_KW_(pyopencv_cv_flann_flann_Index_save, 0), "save(filename) -> None\n."},
| 56670 |  |  | 56622 |
| 56671 | {NULL, NULL} |  | 56623 | {NULL, NULL}
| 56672 | }; |  | 56624 | };
| 56673 |  |  | 56625 |
| 56674 | // Converter (flann_Index) |  | 56626 | // Converter (flann_Index)
| 56675 |  |  | 56627 |
| 56676 | template<> |  | 56628 | template<>
| 56677 | struct PyOpenCV_Converter< Ptr<cv::flann::Index> > |  | 56629 | struct PyOpenCV_Converter< Ptr<cv::flann::Index> >
| 56678 | { |  | 56630 | {
| 56679 | static PyObject* from(const Ptr<cv::flann::Index>& r) |  | 56631 | static PyObject* from(const Ptr<cv::flann::Index>& r)
| 56680 | { |  | 56632 | {
| 56681 | return pyopencv_flann_Index_Instance(r); |  | 56633 | return pyopencv_flann_Index_Instance(r);
| 56682 | } |  | 56634 | }
| 56683 | static bool to(PyObject* src, Ptr<cv::flann::Index>& dst, const ArgInfo& info) |  | 56635 | static bool to(PyObject* src, Ptr<cv::flann::Index>& dst, const ArgInfo& info)
| 56684 | { |  | 56636 | {
| 56685 | if(!src || src == Py_None) |  | 56637 | if(!src || src == Py_None)
| 56686 | return true; |  | 56638 | return true;
| 56687 | Ptr<cv::flann::Index> * dst_; |  | 56639 | Ptr<cv::flann::Index> * dst_;
| 56688 | if (pyopencv_flann_Index_getp(src, dst_)) |  | 56640 | if (pyopencv_flann_Index_getp(src, dst_))
| 56689 | { |  | 56641 | {
| 56690 | dst = *dst_; |  | 56642 | dst = *dst_;
| 56691 | return true; |  | 56643 | return true;
| 56692 | } |  | 56644 | }
| 56693 |  |  | 56645 |
| 56694 | failmsg("Expected Ptr<cv::flann::Index> for argument '%s'", info.name); |  | 56646 | failmsg("Expected Ptr<cv::flann::Index> for argument '%s'", info.name);
| 56695 | return false; |  | 56647 | return false;
| 56696 | } |  | 56648 | }
| 56697 | }; |  | 56649 | };
| 56698 |  |  | 56650 |
| 56699 | //================================================================================ |  | 56651 | //================================================================================
| 56700 | // freetype_FreeType2 (Generic) |  | 56652 | // freetype_FreeType2 (Generic)
| 56701 | //================================================================================ |  | 56653 | //================================================================================
| 56702 |  |  | 56654 |
| 56703 | // GetSet (freetype_FreeType2) |  | 56655 | // GetSet (freetype_FreeType2)
| 56704 |  |  | 56656 |
| 56705 |  |  | 56657 |
| 56706 |  |  | 56658 |
| 56707 | // Methods (freetype_FreeType2) |  | 56659 | // Methods (freetype_FreeType2)
| 56708 |  |  | 56660 |
| 56709 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_getTextSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56661 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_getTextSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 56710 | { |  | 56662 | {
| 56711 | using namespace cv::freetype; |  | 56663 | using namespace cv::freetype;
| 56712 |  |  | 56664 |
| 56713 |  |  | 56665 |
| 56714 | Ptr<cv::freetype::FreeType2> * self1 = 0; |  | 56666 | Ptr<cv::freetype::FreeType2> * self1 = 0;
| 56715 | if (!pyopencv_freetype_FreeType2_getp(self, self1)) |  | 56667 | if (!pyopencv_freetype_FreeType2_getp(self, self1))
| 56716 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)"); |  | 56668 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)");
| 56717 | Ptr<cv::freetype::FreeType2> _self_ = *(self1); |  | 56669 | Ptr<cv::freetype::FreeType2> _self_ = *(self1);
| 56718 | PyObject* pyobj_text = NULL; |  | 56670 | PyObject* pyobj_text = NULL;
| 56719 | String text; |  | 56671 | String text;
| 56720 | PyObject* pyobj_fontHeight = NULL; |  | 56672 | PyObject* pyobj_fontHeight = NULL;
| 56721 | int fontHeight=0; |  | 56673 | int fontHeight=0;
| 56722 | PyObject* pyobj_thickness = NULL; |  | 56674 | PyObject* pyobj_thickness = NULL;
| 56723 | int thickness=0; |  | 56675 | int thickness=0;
| 56724 | int baseLine; |  | 56676 | int baseLine;
| 56725 | Size retval; |  | 56677 | Size retval;
| 56726 |  |  | 56678 |
| 56727 | const char* keywords[] = { "text", "fontHeight", "thickness", NULL }; |  | 56679 | const char* keywords[] = { "text", "fontHeight", "thickness", NULL };
| 56728 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:freetype_FreeType2.getTextSize", (char**)keywords, &pyobj_text, &pyobj_fontHeight, &pyobj_thickness) && |  | 56680 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:freetype_FreeType2.getTextSize", (char**)keywords, &pyobj_text, &pyobj_fontHeight, &pyobj_thickness) &&
| 56729 | pyopencv_to_safe(pyobj_text, text, ArgInfo("text", 0)) && |  | 56681 | pyopencv_to_safe(pyobj_text, text, ArgInfo("text", 0)) &&
| 56730 | pyopencv_to_safe(pyobj_fontHeight, fontHeight, ArgInfo("fontHeight", 0)) && |  | 56682 | pyopencv_to_safe(pyobj_fontHeight, fontHeight, ArgInfo("fontHeight", 0)) &&
| 56731 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) ) |  | 56683 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) )
| 56732 | { |  | 56684 | {
| 56733 | ERRWRAP2(retval = _self_->getTextSize(text, fontHeight, thickness, &baseLine)); |  | 56685 | ERRWRAP2(retval = _self_->getTextSize(text, fontHeight, thickness, &baseLine));
| 56734 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(baseLine)); |  | 56686 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(baseLine));
| 56735 | } |  | 56687 | }
| 56736 |  |  | 56688 |
| 56737 | return NULL; |  | 56689 | return NULL;
| 56738 | } |  | 56690 | }
| 56739 |  |  | 56691 |
| 56740 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_loadFontData(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56692 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_loadFontData(PyObject* self, PyObject* py_args, PyObject* kw)
| 56741 | { |  | 56693 | {
| 56742 | using namespace cv::freetype; |  | 56694 | using namespace cv::freetype;
| 56743 |  |  | 56695 |
| 56744 |  |  | 56696 |
| 56745 | Ptr<cv::freetype::FreeType2> * self1 = 0; |  | 56697 | Ptr<cv::freetype::FreeType2> * self1 = 0;
| 56746 | if (!pyopencv_freetype_FreeType2_getp(self, self1)) |  | 56698 | if (!pyopencv_freetype_FreeType2_getp(self, self1))
| 56747 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)"); |  | 56699 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)");
| 56748 | Ptr<cv::freetype::FreeType2> _self_ = *(self1); |  | 56700 | Ptr<cv::freetype::FreeType2> _self_ = *(self1);
| 56749 | pyPrepareArgumentConversionErrorsStorage(2); |  | 56701 | pyPrepareArgumentConversionErrorsStorage(2);
| 56750 |  |  | 56702 |
| 56751 | { |  | 56703 | {
| 56752 | PyObject* pyobj_fontFileName = NULL; |  | 56704 | PyObject* pyobj_fontFileName = NULL;
| 56753 | String fontFileName; |  | 56705 | String fontFileName;
| 56754 | PyObject* pyobj_idx = NULL; |  | 56706 | PyObject* pyobj_idx = NULL;
| 56755 | int idx=0; |  | 56707 | int idx=0;
| 56756 |  |  | 56708 |
| 56757 | const char* keywords[] = { "fontFileName", "idx", NULL }; |  | 56709 | const char* keywords[] = { "fontFileName", "idx", NULL };
| 56758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:freetype_FreeType2.loadFontData", (char**)keywords, &pyobj_fontFileName, &pyobj_idx) && |  | 56710 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:freetype_FreeType2.loadFontData", (char**)keywords, &pyobj_fontFileName, &pyobj_idx) &&
| 56759 | pyopencv_to_safe(pyobj_fontFileName, fontFileName, ArgInfo("fontFileName", 0)) && |  | 56711 | pyopencv_to_safe(pyobj_fontFileName, fontFileName, ArgInfo("fontFileName", 0)) &&
| 56760 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) ) |  | 56712 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) )
| 56761 | { |  | 56713 | {
| 56762 | ERRWRAP2(_self_->loadFontData(fontFileName, idx)); |  | 56714 | ERRWRAP2(_self_->loadFontData(fontFileName, idx));
| 56763 | Py_RETURN_NONE; |  | 56715 | Py_RETURN_NONE;
| 56764 | } |  | 56716 | }
| 56765 |  |  | 56717 |
| 56766 |  |  | 56718 |
| 56767 | pyPopulateArgumentConversionErrors(); |  | 56719 | pyPopulateArgumentConversionErrors();
| 56768 | } |  | 56720 | }
| 56769 |  |  | 56721 |
| 56770 |  |  | 56722 |
| 56771 | { |  | 56723 | {
| 56772 | char* pBuf=(char*)""; |  | 56724 | char* pBuf=(char*)"";
| 56773 | PyObject* pyobj_bufSize = NULL; |  | 56725 | PyObject* pyobj_bufSize = NULL;
| 56774 | size_t bufSize=0; |  | 56726 | size_t bufSize=0;
| 56775 | PyObject* pyobj_idx = NULL; |  | 56727 | PyObject* pyobj_idx = NULL;
| 56776 | int idx=0; |  | 56728 | int idx=0;
| 56777 |  |  | 56729 |
| 56778 | const char* keywords[] = { "pBuf", "bufSize", "idx", NULL }; |  | 56730 | const char* keywords[] = { "pBuf", "bufSize", "idx", NULL };
| 56779 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "sOO:freetype_FreeType2.loadFontData", (char**)keywords, &pBuf, &pyobj_bufSize, &pyobj_idx) && |  | 56731 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "sOO:freetype_FreeType2.loadFontData", (char**)keywords, &pBuf, &pyobj_bufSize, &pyobj_idx) &&
| 56780 | pyopencv_to_safe(pyobj_bufSize, bufSize, ArgInfo("bufSize", 0)) && |  | 56732 | pyopencv_to_safe(pyobj_bufSize, bufSize, ArgInfo("bufSize", 0)) &&
| 56781 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) ) |  | 56733 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) )
| 56782 | { |  | 56734 | {
| 56783 | ERRWRAP2(_self_->loadFontData(pBuf, bufSize, idx)); |  | 56735 | ERRWRAP2(_self_->loadFontData(pBuf, bufSize, idx));
| 56784 | Py_RETURN_NONE; |  | 56736 | Py_RETURN_NONE;
| 56785 | } |  | 56737 | }
| 56786 |  |  | 56738 |
| 56787 |  |  | 56739 |
| 56788 | pyPopulateArgumentConversionErrors(); |  | 56740 | pyPopulateArgumentConversionErrors();
| 56789 | } |  | 56741 | }
| 56790 | pyRaiseCVOverloadException("loadFontData"); |  | 56742 | pyRaiseCVOverloadException("loadFontData");
| 56791 |  |  | 56743 |
| 56792 | return NULL; |  | 56744 | return NULL;
| 56793 | } |  | 56745 | }
| 56794 |  |  | 56746 |
| 56795 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_putText(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56747 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_putText(PyObject* self, PyObject* py_args, PyObject* kw)
| 56796 | { |  | 56748 | {
| 56797 | using namespace cv::freetype; |  | 56749 | using namespace cv::freetype;
| 56798 |  |  | 56750 |
| 56799 |  |  | 56751 |
| 56800 | Ptr<cv::freetype::FreeType2> * self1 = 0; |  | 56752 | Ptr<cv::freetype::FreeType2> * self1 = 0;
| 56801 | if (!pyopencv_freetype_FreeType2_getp(self, self1)) |  | 56753 | if (!pyopencv_freetype_FreeType2_getp(self, self1))
| 56802 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)"); |  | 56754 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)");
| 56803 | Ptr<cv::freetype::FreeType2> _self_ = *(self1); |  | 56755 | Ptr<cv::freetype::FreeType2> _self_ = *(self1);
| 56804 | pyPrepareArgumentConversionErrorsStorage(2); |  | 56756 | pyPrepareArgumentConversionErrorsStorage(2);
| 56805 |  |  | 56757 |
| 56806 | { |  | 56758 | {
| 56807 | PyObject* pyobj_img = NULL; |  | 56759 | PyObject* pyobj_img = NULL;
| 56808 | Mat img; |  | 56760 | Mat img;
| 56809 | PyObject* pyobj_text = NULL; |  | 56761 | PyObject* pyobj_text = NULL;
| 56810 | String text; |  | 56762 | String text;
| 56811 | PyObject* pyobj_org = NULL; |  | 56763 | PyObject* pyobj_org = NULL;
| 56812 | Point org; |  | 56764 | Point org;
| 56813 | PyObject* pyobj_fontHeight = NULL; |  | 56765 | PyObject* pyobj_fontHeight = NULL;
| 56814 | int fontHeight=0; |  | 56766 | int fontHeight=0;
| 56815 | PyObject* pyobj_color = NULL; |  | 56767 | PyObject* pyobj_color = NULL;
| 56816 | Scalar color; |  | 56768 | Scalar color;
| 56817 | PyObject* pyobj_thickness = NULL; |  | 56769 | PyObject* pyobj_thickness = NULL;
| 56818 | int thickness=0; |  | 56770 | int thickness=0;
| 56819 | PyObject* pyobj_line_type = NULL; |  | 56771 | PyObject* pyobj_line_type = NULL;
| 56820 | int line_type=0; |  | 56772 | int line_type=0;
| 56821 | PyObject* pyobj_bottomLeftOrigin = NULL; |  | 56773 | PyObject* pyobj_bottomLeftOrigin = NULL;
| 56822 | bool bottomLeftOrigin=0; |  | 56774 | bool bottomLeftOrigin=0;
| 56823 |  |  | 56775 |
| 56824 | const char* keywords[] = { "img", "text", "org", "fontHeight", "color", "thickness", "line_type", "bottomLeftOrigin", NULL }; |  | 56776 | const char* keywords[] = { "img", "text", "org", "fontHeight", "color", "thickness", "line_type", "bottomLeftOrigin", NULL };
| 56825 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOOOO:freetype_FreeType2.putText", (char**)keywords, &pyobj_img, &pyobj_text, &pyobj_org, &pyobj_fontHeight, &pyobj_color, &pyobj_thickness, &pyobj_line_type, &pyobj_bottomLeftOrigin) && |  | 56777 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOOOO:freetype_FreeType2.putText", (char**)keywords, &pyobj_img, &pyobj_text, &pyobj_org, &pyobj_fontHeight, &pyobj_color, &pyobj_thickness, &pyobj_line_type, &pyobj_bottomLeftOrigin) &&
| 56826 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) && |  | 56778 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) &&
| 56827 | pyopencv_to_safe(pyobj_text, text, ArgInfo("text", 0)) && |  | 56779 | pyopencv_to_safe(pyobj_text, text, ArgInfo("text", 0)) &&
| 56828 | pyopencv_to_safe(pyobj_org, org, ArgInfo("org", 0)) && |  | 56780 | pyopencv_to_safe(pyobj_org, org, ArgInfo("org", 0)) &&
| 56829 | pyopencv_to_safe(pyobj_fontHeight, fontHeight, ArgInfo("fontHeight", 0)) && |  | 56781 | pyopencv_to_safe(pyobj_fontHeight, fontHeight, ArgInfo("fontHeight", 0)) &&
| 56830 | pyopencv_to_safe(pyobj_color, color, ArgInfo("color", 0)) && |  | 56782 | pyopencv_to_safe(pyobj_color, color, ArgInfo("color", 0)) &&
| 56831 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) && |  | 56783 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) &&
| 56832 | pyopencv_to_safe(pyobj_line_type, line_type, ArgInfo("line_type", 0)) && |  | 56784 | pyopencv_to_safe(pyobj_line_type, line_type, ArgInfo("line_type", 0)) &&
| 56833 | pyopencv_to_safe(pyobj_bottomLeftOrigin, bottomLeftOrigin, ArgInfo("bottomLeftOrigin", 0)) ) |  | 56785 | pyopencv_to_safe(pyobj_bottomLeftOrigin, bottomLeftOrigin, ArgInfo("bottomLeftOrigin", 0)) )
| 56834 | { |  | 56786 | {
| 56835 | ERRWRAP2(_self_->putText(img, text, org, fontHeight, color, thickness, line_type, bottomLeftOrigin)); |  | 56787 | ERRWRAP2(_self_->putText(img, text, org, fontHeight, color, thickness, line_type, bottomLeftOrigin));
| 56836 | return pyopencv_from(img); |  | 56788 | return pyopencv_from(img);
| 56837 | } |  | 56789 | }
| 56838 |  |  | 56790 |
| 56839 |  |  | 56791 |
| 56840 | pyPopulateArgumentConversionErrors(); |  | 56792 | pyPopulateArgumentConversionErrors();
| 56841 | } |  | 56793 | }
| 56842 |  |  | 56794 |
| 56843 |  |  | 56795 |
| 56844 | { |  | 56796 | {
| 56845 | PyObject* pyobj_img = NULL; |  | 56797 | PyObject* pyobj_img = NULL;
| 56846 | UMat img; |  | 56798 | UMat img;
| 56847 | PyObject* pyobj_text = NULL; |  | 56799 | PyObject* pyobj_text = NULL;
| 56848 | String text; |  | 56800 | String text;
| 56849 | PyObject* pyobj_org = NULL; |  | 56801 | PyObject* pyobj_org = NULL;
| 56850 | Point org; |  | 56802 | Point org;
| 56851 | PyObject* pyobj_fontHeight = NULL; |  | 56803 | PyObject* pyobj_fontHeight = NULL;
| 56852 | int fontHeight=0; |  | 56804 | int fontHeight=0;
| 56853 | PyObject* pyobj_color = NULL; |  | 56805 | PyObject* pyobj_color = NULL;
| 56854 | Scalar color; |  | 56806 | Scalar color;
| 56855 | PyObject* pyobj_thickness = NULL; |  | 56807 | PyObject* pyobj_thickness = NULL;
| 56856 | int thickness=0; |  | 56808 | int thickness=0;
| 56857 | PyObject* pyobj_line_type = NULL; |  | 56809 | PyObject* pyobj_line_type = NULL;
| 56858 | int line_type=0; |  | 56810 | int line_type=0;
| 56859 | PyObject* pyobj_bottomLeftOrigin = NULL; |  | 56811 | PyObject* pyobj_bottomLeftOrigin = NULL;
| 56860 | bool bottomLeftOrigin=0; |  | 56812 | bool bottomLeftOrigin=0;
| 56861 |  |  | 56813 |
| 56862 | const char* keywords[] = { "img", "text", "org", "fontHeight", "color", "thickness", "line_type", "bottomLeftOrigin", NULL }; |  | 56814 | const char* keywords[] = { "img", "text", "org", "fontHeight", "color", "thickness", "line_type", "bottomLeftOrigin", NULL };
| 56863 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOOOO:freetype_FreeType2.putText", (char**)keywords, &pyobj_img, &pyobj_text, &pyobj_org, &pyobj_fontHeight, &pyobj_color, &pyobj_thickness, &pyobj_line_type, &pyobj_bottomLeftOrigin) && |  | 56815 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOOOO:freetype_FreeType2.putText", (char**)keywords, &pyobj_img, &pyobj_text, &pyobj_org, &pyobj_fontHeight, &pyobj_color, &pyobj_thickness, &pyobj_line_type, &pyobj_bottomLeftOrigin) &&
| 56864 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) && |  | 56816 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) &&
| 56865 | pyopencv_to_safe(pyobj_text, text, ArgInfo("text", 0)) && |  | 56817 | pyopencv_to_safe(pyobj_text, text, ArgInfo("text", 0)) &&
| 56866 | pyopencv_to_safe(pyobj_org, org, ArgInfo("org", 0)) && |  | 56818 | pyopencv_to_safe(pyobj_org, org, ArgInfo("org", 0)) &&
| 56867 | pyopencv_to_safe(pyobj_fontHeight, fontHeight, ArgInfo("fontHeight", 0)) && |  | 56819 | pyopencv_to_safe(pyobj_fontHeight, fontHeight, ArgInfo("fontHeight", 0)) &&
| 56868 | pyopencv_to_safe(pyobj_color, color, ArgInfo("color", 0)) && |  | 56820 | pyopencv_to_safe(pyobj_color, color, ArgInfo("color", 0)) &&
| 56869 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) && |  | 56821 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) &&
| 56870 | pyopencv_to_safe(pyobj_line_type, line_type, ArgInfo("line_type", 0)) && |  | 56822 | pyopencv_to_safe(pyobj_line_type, line_type, ArgInfo("line_type", 0)) &&
| 56871 | pyopencv_to_safe(pyobj_bottomLeftOrigin, bottomLeftOrigin, ArgInfo("bottomLeftOrigin", 0)) ) |  | 56823 | pyopencv_to_safe(pyobj_bottomLeftOrigin, bottomLeftOrigin, ArgInfo("bottomLeftOrigin", 0)) )
| 56872 | { |  | 56824 | {
| 56873 | ERRWRAP2(_self_->putText(img, text, org, fontHeight, color, thickness, line_type, bottomLeftOrigin)); |  | 56825 | ERRWRAP2(_self_->putText(img, text, org, fontHeight, color, thickness, line_type, bottomLeftOrigin));
| 56874 | return pyopencv_from(img); |  | 56826 | return pyopencv_from(img);
| 56875 | } |  | 56827 | }
| 56876 |  |  | 56828 |
| 56877 |  |  | 56829 |
| 56878 | pyPopulateArgumentConversionErrors(); |  | 56830 | pyPopulateArgumentConversionErrors();
| 56879 | } |  | 56831 | }
| 56880 | pyRaiseCVOverloadException("putText"); |  | 56832 | pyRaiseCVOverloadException("putText");
| 56881 |  |  | 56833 |
| 56882 | return NULL; |  | 56834 | return NULL;
| 56883 | } |  | 56835 | }
| 56884 |  |  | 56836 |
| 56885 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_setSplitNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 56837 | static PyObject* pyopencv_cv_freetype_freetype_FreeType2_setSplitNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 56886 | { |  | 56838 | {
| 56887 | using namespace cv::freetype; |  | 56839 | using namespace cv::freetype;
| 56888 |  |  | 56840 |
| 56889 |  |  | 56841 |
| 56890 | Ptr<cv::freetype::FreeType2> * self1 = 0; |  | 56842 | Ptr<cv::freetype::FreeType2> * self1 = 0;
| 56891 | if (!pyopencv_freetype_FreeType2_getp(self, self1)) |  | 56843 | if (!pyopencv_freetype_FreeType2_getp(self, self1))
| 56892 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)"); |  | 56844 | return failmsgp("Incorrect type of self (must be 'freetype_FreeType2' or its derivative)");
| 56893 | Ptr<cv::freetype::FreeType2> _self_ = *(self1); |  | 56845 | Ptr<cv::freetype::FreeType2> _self_ = *(self1);
| 56894 | PyObject* pyobj_num = NULL; |  | 56846 | PyObject* pyobj_num = NULL;
| 56895 | int num=0; |  | 56847 | int num=0;
| 56896 |  |  | 56848 |
| 56897 | const char* keywords[] = { "num", NULL }; |  | 56849 | const char* keywords[] = { "num", NULL };
| 56898 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:freetype_FreeType2.setSplitNumber", (char**)keywords, &pyobj_num) && |  | 56850 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:freetype_FreeType2.setSplitNumber", (char**)keywords, &pyobj_num) &&
| 56899 | pyopencv_to_safe(pyobj_num, num, ArgInfo("num", 0)) ) |  | 56851 | pyopencv_to_safe(pyobj_num, num, ArgInfo("num", 0)) )
| 56900 | { |  | 56852 | {
| 56901 | ERRWRAP2(_self_->setSplitNumber(num)); |  | 56853 | ERRWRAP2(_self_->setSplitNumber(num));
| 56902 | Py_RETURN_NONE; |  | 56854 | Py_RETURN_NONE;
| 56903 | } |  | 56855 | }
| 56904 |  |  | 56856 |
| 56905 | return NULL; |  | 56857 | return NULL;
| 56906 | } |  | 56858 | }
| 56907 |  |  | 56859 |
| 56908 |  |  | 56860 |
| 56909 |  |  | 56861 |
| 56910 | // Tables (freetype_FreeType2) |  | 56862 | // Tables (freetype_FreeType2)
| 56911 |  |  | 56863 |
| 56912 | static PyGetSetDef pyopencv_freetype_FreeType2_getseters[] = |  | 56864 | static PyGetSetDef pyopencv_freetype_FreeType2_getseters[] =
| 56913 | { |  | 56865 | {
| 56914 | {NULL} /* Sentinel */ |  | 56866 | {NULL} /* Sentinel */
| 56915 | }; |  | 56867 | };
| 56916 |  |  | 56868 |
| 56917 | static PyMethodDef pyopencv_freetype_FreeType2_methods[] = |  | 56869 | static PyMethodDef pyopencv_freetype_FreeType2_methods[] =
| 56918 | { |  | 56870 | {
| 56919 | {"getTextSize", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_getTextSize, 0), "getTextSize(text, fontHeight, thickness) -> retval, baseLine\n. @brief Calculates the width and height of a text string.\n. \n. The function getTextSize calculates and returns the approximate size of a box that contains the specified text.\n. That is, the following code renders some text, the tight box surrounding it, and the baseline: :\n. @code\n. String text = \"Funny text inside the box\";\n. int fontHeight = 60;\n. int thickness = -1;\n. int linestyle = LINE_8;\n. \n. Mat img(600, 800, CV_8UC3, Scalar::all(0));\n. \n. int baseline=0;\n. \n. cv::Ptr<cv::freetype::FreeType2> ft2;\n. ft2 = cv::freetype::createFreeType2();\n. ft2->loadFontData( \"./mplus-1p-regular.ttf\", 0 );\n. \n. Size textSize = ft2->getTextSize(text,\n. fontHeight,\n. thickness,\n. &baseline);\n. \n. if(thickness > 0){\n. baseline += thickness;\n. }\n. \n. // center the text\n. Point textOrg((img.cols - textSize.width) / 2,\n. (img.rows + textSize.height) / 2);\n. \n. // draw the box\n. rectangle(img, textOrg + Point(0, baseline),\n. textOrg + Point(textSize.width, -textSize.height),\n. Scalar(0,255,0),1,8);\n. \n. // ... and the baseline first\n. line(img, textOrg + Point(0, thickness),\n. textOrg + Point(textSize.width, thickness),\n. Scalar(0, 0, 255),1,8);\n. \n. // then put the text itself\n. ft2->putText(img, text, textOrg, fontHeight,\n. Scalar::all(255), thickness, linestyle, true );\n. @endcode\n. \n. @param text Input text string.\n. @param fontHeight Drawing font size by pixel unit.\n. @param thickness Thickness of lines used to render the text. See putText for details.\n. @param[out] baseLine y-coordinate of the baseline relative to the bottom-most text\n. point.\n. @return The size of a box that contains the specified text.\n. \n. @see cv::putText"}, |  | 56871 | {"getTextSize", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_getTextSize, 0), "getTextSize(text, fontHeight, thickness) -> retval, baseLine\n. @brief Calculates the width and height of a text string.\n. \n. The function getTextSize calculates and returns the approximate size of a box that contains the specified text.\n. That is, the following code renders some text, the tight box surrounding it, and the baseline: :\n. @code\n. String text = \"Funny text inside the box\";\n. int fontHeight = 60;\n. int thickness = -1;\n. int linestyle = LINE_8;\n. \n. Mat img(600, 800, CV_8UC3, Scalar::all(0));\n. \n. int baseline=0;\n. \n. cv::Ptr<cv::freetype::FreeType2> ft2;\n. ft2 = cv::freetype::createFreeType2();\n. ft2->loadFontData( \"./mplus-1p-regular.ttf\", 0 );\n. \n. Size textSize = ft2->getTextSize(text,\n. fontHeight,\n. thickness,\n. &baseline);\n. \n. if(thickness > 0){\n. baseline += thickness;\n. }\n. \n. // center the text\n. Point textOrg((img.cols - textSize.width) / 2,\n. (img.rows + textSize.height) / 2);\n. \n. // draw the box\n. rectangle(img, textOrg + Point(0, baseline),\n. textOrg + Point(textSize.width, -textSize.height),\n. Scalar(0,255,0),1,8);\n. \n. // ... and the baseline first\n. line(img, textOrg + Point(0, thickness),\n. textOrg + Point(textSize.width, thickness),\n. Scalar(0, 0, 255),1,8);\n. \n. // then put the text itself\n. ft2->putText(img, text, textOrg, fontHeight,\n. Scalar::all(255), thickness, linestyle, true );\n. @endcode\n. \n. @param text Input text string.\n. @param fontHeight Drawing font size by pixel unit.\n. @param thickness Thickness of lines used to render the text. See putText for details.\n. @param[out] baseLine y-coordinate of the baseline relative to the bottom-most text\n. point.\n. @return The size of a box that contains the specified text.\n. \n. @see cv::putText"},
| 56920 | {"loadFontData", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_loadFontData, 0), "loadFontData(fontFileName, idx) -> None\n. @brief Load font data.\n. \n. The function loadFontData loads font data from file.\n. \n. @param fontFileName FontFile Name\n. @param idx face_index to select a font faces in a single file.\n\n\n\nloadFontData(pBuf, bufSize, idx) -> None\n. @brief Load font data.\n. \n. The function loadFontData loads font data from memory.\n. The data is not copied, the user needs to make sure the data lives at least as long as FreeType2.\n. After the FreeType2 object is destroyed, the buffer can be safely deallocated.\n. \n. @param pBuf pointer to buffer containing font data\n. @param bufSize size of buffer\n. @param idx face_index to select a font faces in a single file."}, |  | 56872 | {"loadFontData", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_loadFontData, 0), "loadFontData(fontFileName, idx) -> None\n. @brief Load font data.\n. \n. The function loadFontData loads font data from file.\n. \n. @param fontFileName FontFile Name\n. @param idx face_index to select a font faces in a single file.\n\n\n\nloadFontData(pBuf, bufSize, idx) -> None\n. @brief Load font data.\n. \n. The function loadFontData loads font data from memory.\n. The data is not copied, the user needs to make sure the data lives at least as long as FreeType2.\n. After the FreeType2 object is destroyed, the buffer can be safely deallocated.\n. \n. @param pBuf pointer to buffer containing font data\n. @param bufSize size of buffer\n. @param idx face_index to select a font faces in a single file."},
| 56921 | {"putText", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_putText, 0), "putText(img, text, org, fontHeight, color, thickness, line_type, bottomLeftOrigin) -> img\n. @brief Draws a text string.\n. \n. The function putText renders the specified text string in the image. Symbols that cannot be rendered using the specified font are replaced by \"Tofu\" or non-drawn.\n. \n. @param img Image. (Only 8UC1/8UC3/8UC4 2D mat is supported.)\n. @param text Text string to be drawn.\n. @param org Bottom-left/Top-left corner of the text string in the image.\n. @param fontHeight Drawing font size by pixel unit.\n. @param color Text color.\n. @param thickness Thickness of the lines used to draw a text when negative, the glyph is filled. Otherwise, the glyph is drawn with this thickness.\n. @param line_type Line type. See the line for details.\n. @param bottomLeftOrigin When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner."}, |  | 56873 | {"putText", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_putText, 0), "putText(img, text, org, fontHeight, color, thickness, line_type, bottomLeftOrigin) -> img\n. @brief Draws a text string.\n. \n. The function putText renders the specified text string in the image. Symbols that cannot be rendered using the specified font are replaced by \"Tofu\" or non-drawn.\n. \n. @param img Image. (Only 8UC1/8UC3/8UC4 2D mat is supported.)\n. @param text Text string to be drawn.\n. @param org Bottom-left/Top-left corner of the text string in the image.\n. @param fontHeight Drawing font size by pixel unit.\n. @param color Text color.\n. @param thickness Thickness of the lines used to draw a text when negative, the glyph is filled. Otherwise, the glyph is drawn with this thickness.\n. @param line_type Line type. See the line for details.\n. @param bottomLeftOrigin When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner."},
| 56922 | {"setSplitNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_setSplitNumber, 0), "setSplitNumber(num) -> None\n. @brief Set Split Number from Bezier-curve to line\n. \n. The function setSplitNumber set the number of split points from bezier-curve to line.\n. If you want to draw large glyph, large is better.\n. If you want to draw small glyph, small is better.\n. \n. @param num number of split points from bezier-curve to line"}, |  | 56874 | {"setSplitNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_freetype_freetype_FreeType2_setSplitNumber, 0), "setSplitNumber(num) -> None\n. @brief Set Split Number from Bezier-curve to line\n. \n. The function setSplitNumber set the number of split points from bezier-curve to line.\n. If you want to draw large glyph, large is better.\n. If you want to draw small glyph, small is better.\n. \n. @param num number of split points from bezier-curve to line"},
| 56923 |  |  | 56875 |
| 56924 | {NULL, NULL} |  | 56876 | {NULL, NULL}
| 56925 | }; |  | 56877 | };
| 56926 |  |  | 56878 |
| 56927 | // Converter (freetype_FreeType2) |  | 56879 | // Converter (freetype_FreeType2)
| 56928 |  |  | 56880 |
| 56929 | template<> |  | 56881 | template<>
| 56930 | struct PyOpenCV_Converter< Ptr<cv::freetype::FreeType2> > |  | 56882 | struct PyOpenCV_Converter< Ptr<cv::freetype::FreeType2> >
| 56931 | { |  | 56883 | {
| 56932 | static PyObject* from(const Ptr<cv::freetype::FreeType2>& r) |  | 56884 | static PyObject* from(const Ptr<cv::freetype::FreeType2>& r)
| 56933 | { |  | 56885 | {
| 56934 | return pyopencv_freetype_FreeType2_Instance(r); |  | 56886 | return pyopencv_freetype_FreeType2_Instance(r);
| 56935 | } |  | 56887 | }
| 56936 | static bool to(PyObject* src, Ptr<cv::freetype::FreeType2>& dst, const ArgInfo& info) |  | 56888 | static bool to(PyObject* src, Ptr<cv::freetype::FreeType2>& dst, const ArgInfo& info)
| 56937 | { |  | 56889 | {
| 56938 | if(!src || src == Py_None) |  | 56890 | if(!src || src == Py_None)
| 56939 | return true; |  | 56891 | return true;
| 56940 | Ptr<cv::freetype::FreeType2> * dst_; |  | 56892 | Ptr<cv::freetype::FreeType2> * dst_;
| 56941 | if (pyopencv_freetype_FreeType2_getp(src, dst_)) |  | 56893 | if (pyopencv_freetype_FreeType2_getp(src, dst_))
| 56942 | { |  | 56894 | {
| 56943 | dst = *dst_; |  | 56895 | dst = *dst_;
| 56944 | return true; |  | 56896 | return true;
| 56945 | } |  | 56897 | }
| 56946 |  |  | 56898 |
| 56947 | failmsg("Expected Ptr<cv::freetype::FreeType2> for argument '%s'", info.name); |  | 56899 | failmsg("Expected Ptr<cv::freetype::FreeType2> for argument '%s'", info.name);
| 56948 | return false; |  | 56900 | return false;
| 56949 | } |  | 56901 | }
| 56950 | }; |  | 56902 | };
| 56951 |  |  | 56903 |
| 56952 | //================================================================================ |  | 56904 | //================================================================================
| 56953 | // gapi_GNetPackage (Generic) |  | 56905 | // gapi_GNetPackage (Generic)
| 56954 | //================================================================================ |  | 56906 | //================================================================================
| 56955 |  |  | 56907 |
| 56956 | // GetSet (gapi_GNetPackage) |  | 56908 | // GetSet (gapi_GNetPackage)
| 56957 |  |  | 56909 |
| 56958 |  |  | 56910 |
| 56959 |  |  | 56911 |
| 56960 | // Methods (gapi_GNetPackage) |  | 56912 | // Methods (gapi_GNetPackage)
| 56961 |  |  | 56913 |
| 56962 | static int pyopencv_cv_gapi_gapi_GNetPackage_GNetPackage(pyopencv_gapi_GNetPackage_t* self, PyObject* py_args, PyObject* kw) |  | 56914 | static int pyopencv_cv_gapi_gapi_GNetPackage_GNetPackage(pyopencv_gapi_GNetPackage_t* self, PyObject* py_args, PyObject* kw)
| 56963 | { |  | 56915 | {
| 56964 | using namespace cv::gapi; |  | 56916 | using namespace cv::gapi;
| 56965 |  |  | 56917 |
| 56966 | pyPrepareArgumentConversionErrorsStorage(2); |  | 56918 | pyPrepareArgumentConversionErrorsStorage(2);
| 56967 |  |  | 56919 |
| 56968 | { |  | 56920 | {
| 56969 |  |  | 56921 |
| 56970 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 56922 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 56971 | { |  | 56923 | {
| 56972 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::GNetPackage()); |  | 56924 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::GNetPackage());
| 56973 | return 0; |  | 56925 | return 0;
| 56974 | } |  | 56926 | }
| 56975 |  |  | 56927 |
| 56976 |  |  | 56928 |
| 56977 | pyPopulateArgumentConversionErrors(); |  | 56929 | pyPopulateArgumentConversionErrors();
| 56978 | } |  | 56930 | }
| 56979 |  |  | 56931 |
| 56980 |  |  | 56932 |
| 56981 | { |  | 56933 | {
| 56982 | PyObject* pyobj_nets = NULL; |  | 56934 | PyObject* pyobj_nets = NULL;
| 56983 | vector_GNetParam nets; |  | 56935 | vector_GNetParam nets;
| 56984 |  |  | 56936 |
| 56985 | const char* keywords[] = { "nets", NULL }; |  | 56937 | const char* keywords[] = { "nets", NULL };
| 56986 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GNetPackage", (char**)keywords, &pyobj_nets) && |  | 56938 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GNetPackage", (char**)keywords, &pyobj_nets) &&
| 56987 | pyopencv_to_safe(pyobj_nets, nets, ArgInfo("nets", 0)) ) |  | 56939 | pyopencv_to_safe(pyobj_nets, nets, ArgInfo("nets", 0)) )
| 56988 | { |  | 56940 | {
| 56989 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::GNetPackage(nets)); |  | 56941 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::GNetPackage(nets));
| 56990 | return 0; |  | 56942 | return 0;
| 56991 | } |  | 56943 | }
| 56992 |  |  | 56944 |
| 56993 |  |  | 56945 |
| 56994 | pyPopulateArgumentConversionErrors(); |  | 56946 | pyPopulateArgumentConversionErrors();
| 56995 | } |  | 56947 | }
| 56996 | pyRaiseCVOverloadException("GNetPackage"); |  | 56948 | pyRaiseCVOverloadException("GNetPackage");
| 56997 |  |  | 56949 |
| 56998 | return -1; |  | 56950 | return -1;
| 56999 | } |  | 56951 | }
| 57000 |  |  | 56952 |
| 57001 |  |  | 56953 |
| 57002 |  |  | 56954 |
| 57003 | // Tables (gapi_GNetPackage) |  | 56955 | // Tables (gapi_GNetPackage)
| 57004 |  |  | 56956 |
| 57005 | static PyGetSetDef pyopencv_gapi_GNetPackage_getseters[] = |  | 56957 | static PyGetSetDef pyopencv_gapi_GNetPackage_getseters[] =
| 57006 | { |  | 56958 | {
| 57007 | {NULL} /* Sentinel */ |  | 56959 | {NULL} /* Sentinel */
| 57008 | }; |  | 56960 | };
| 57009 |  |  | 56961 |
| 57010 | static PyMethodDef pyopencv_gapi_GNetPackage_methods[] = |  | 56962 | static PyMethodDef pyopencv_gapi_GNetPackage_methods[] =
| 57011 | { |  | 56963 | {
| 57012 |  |  | 56964 |
| 57013 | {NULL, NULL} |  | 56965 | {NULL, NULL}
| 57014 | }; |  | 56966 | };
| 57015 |  |  | 56967 |
| 57016 | // Converter (gapi_GNetPackage) |  | 56968 | // Converter (gapi_GNetPackage)
| 57017 |  |  | 56969 |
| 57018 | template<> |  | 56970 | template<>
| 57019 | struct PyOpenCV_Converter< cv::gapi::GNetPackage > |  | 56971 | struct PyOpenCV_Converter< cv::gapi::GNetPackage >
| 57020 | { |  | 56972 | {
| 57021 | static PyObject* from(const cv::gapi::GNetPackage& r) |  | 56973 | static PyObject* from(const cv::gapi::GNetPackage& r)
| 57022 | { |  | 56974 | {
| 57023 | return pyopencv_gapi_GNetPackage_Instance(r); |  | 56975 | return pyopencv_gapi_GNetPackage_Instance(r);
| 57024 | } |  | 56976 | }
| 57025 | static bool to(PyObject* src, cv::gapi::GNetPackage& dst, const ArgInfo& info) |  | 56977 | static bool to(PyObject* src, cv::gapi::GNetPackage& dst, const ArgInfo& info)
| 57026 | { |  | 56978 | {
| 57027 | if(!src || src == Py_None) |  | 56979 | if(!src || src == Py_None)
| 57028 | return true; |  | 56980 | return true;
| 57029 | cv::gapi::GNetPackage * dst_; |  | 56981 | cv::gapi::GNetPackage * dst_;
| 57030 | if (pyopencv_gapi_GNetPackage_getp(src, dst_)) |  | 56982 | if (pyopencv_gapi_GNetPackage_getp(src, dst_))
| 57031 | { |  | 56983 | {
| 57032 | dst = *dst_; |  | 56984 | dst = *dst_;
| 57033 | return true; |  | 56985 | return true;
| 57034 | } |  | 56986 | }
| 57035 |  |  | 56987 |
| 57036 | failmsg("Expected cv::gapi::GNetPackage for argument '%s'", info.name); |  | 56988 | failmsg("Expected cv::gapi::GNetPackage for argument '%s'", info.name);
| 57037 | return false; |  | 56989 | return false;
| 57038 | } |  | 56990 | }
| 57039 | }; |  | 56991 | };
| 57040 |  |  | 56992 |
| 57041 | //================================================================================ |  | 56993 | //================================================================================
| 57042 | // gapi_GNetParam (Generic) |  | 56994 | // gapi_GNetParam (Generic)
| 57043 | //================================================================================ |  | 56995 | //================================================================================
| 57044 |  |  | 56996 |
| 57045 | // GetSet (gapi_GNetParam) |  | 56997 | // GetSet (gapi_GNetParam)
| 57046 |  |  | 56998 |
| 57047 |  |  | 56999 |
| 57048 |  |  | 57000 |
| 57049 | // Methods (gapi_GNetParam) |  | 57001 | // Methods (gapi_GNetParam)
| 57050 |  |  | 57002 |
| 57051 |  |  | 57003 |
| 57052 |  |  | 57004 |
| 57053 | // Tables (gapi_GNetParam) |  | 57005 | // Tables (gapi_GNetParam)
| 57054 |  |  | 57006 |
| 57055 | static PyGetSetDef pyopencv_gapi_GNetParam_getseters[] = |  | 57007 | static PyGetSetDef pyopencv_gapi_GNetParam_getseters[] =
| 57056 | { |  | 57008 | {
| 57057 | {NULL} /* Sentinel */ |  | 57009 | {NULL} /* Sentinel */
| 57058 | }; |  | 57010 | };
| 57059 |  |  | 57011 |
| 57060 | static PyMethodDef pyopencv_gapi_GNetParam_methods[] = |  | 57012 | static PyMethodDef pyopencv_gapi_GNetParam_methods[] =
| 57061 | { |  | 57013 | {
| 57062 |  |  | 57014 |
| 57063 | {NULL, NULL} |  | 57015 | {NULL, NULL}
| 57064 | }; |  | 57016 | };
| 57065 |  |  | 57017 |
| 57066 | // Converter (gapi_GNetParam) |  | 57018 | // Converter (gapi_GNetParam)
| 57067 |  |  | 57019 |
| 57068 | template<> |  | 57020 | template<>
| 57069 | struct PyOpenCV_Converter< cv::gapi::GNetParam > |  | 57021 | struct PyOpenCV_Converter< cv::gapi::GNetParam >
| 57070 | { |  | 57022 | {
| 57071 | static PyObject* from(const cv::gapi::GNetParam& r) |  | 57023 | static PyObject* from(const cv::gapi::GNetParam& r)
| 57072 | { |  | 57024 | {
| 57073 | return pyopencv_gapi_GNetParam_Instance(r); |  | 57025 | return pyopencv_gapi_GNetParam_Instance(r);
| 57074 | } |  | 57026 | }
| 57075 | static bool to(PyObject* src, cv::gapi::GNetParam& dst, const ArgInfo& info) |  | 57027 | static bool to(PyObject* src, cv::gapi::GNetParam& dst, const ArgInfo& info)
| 57076 | { |  | 57028 | {
| 57077 | if(!src || src == Py_None) |  | 57029 | if(!src || src == Py_None)
| 57078 | return true; |  | 57030 | return true;
| 57079 | cv::gapi::GNetParam * dst_; |  | 57031 | cv::gapi::GNetParam * dst_;
| 57080 | if (pyopencv_gapi_GNetParam_getp(src, dst_)) |  | 57032 | if (pyopencv_gapi_GNetParam_getp(src, dst_))
| 57081 | { |  | 57033 | {
| 57082 | dst = *dst_; |  | 57034 | dst = *dst_;
| 57083 | return true; |  | 57035 | return true;
| 57084 | } |  | 57036 | }
| 57085 |  |  | 57037 |
| 57086 | failmsg("Expected cv::gapi::GNetParam for argument '%s'", info.name); |  | 57038 | failmsg("Expected cv::gapi::GNetParam for argument '%s'", info.name);
| 57087 | return false; |  | 57039 | return false;
| 57088 | } |  | 57040 | }
| 57089 | }; |  | 57041 | };
| 57090 |  |  | 57042 |
| 57091 | //================================================================================ |  | 57043 | //================================================================================
| 57092 | // gapi_ie_PyParams (Generic) |  | 57044 | // gapi_ie_PyParams (Generic)
| 57093 | //================================================================================ |  | 57045 | //================================================================================
| 57094 |  |  | 57046 |
| 57095 | // GetSet (gapi_ie_PyParams) |  | 57047 | // GetSet (gapi_ie_PyParams)
| 57096 |  |  | 57048 |
| 57097 |  |  | 57049 |
| 57098 |  |  | 57050 |
| 57099 | // Methods (gapi_ie_PyParams) |  | 57051 | // Methods (gapi_ie_PyParams)
| 57100 |  |  | 57052 |
| 57101 | static int pyopencv_cv_gapi_ie_gapi_ie_PyParams_PyParams(pyopencv_gapi_ie_PyParams_t* self, PyObject* py_args, PyObject* kw) |  | 57053 | static int pyopencv_cv_gapi_ie_gapi_ie_PyParams_PyParams(pyopencv_gapi_ie_PyParams_t* self, PyObject* py_args, PyObject* kw)
| 57102 | { |  | 57054 | {
| 57103 | using namespace cv::gapi::ie; |  | 57055 | using namespace cv::gapi::ie;
| 57104 |  |  | 57056 |
| 57105 | pyPrepareArgumentConversionErrorsStorage(3); |  | 57057 | pyPrepareArgumentConversionErrorsStorage(3);
| 57106 |  |  | 57058 |
| 57107 | { |  | 57059 | {
| 57108 |  |  | 57060 |
| 57109 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57061 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57110 | { |  | 57062 | {
| 57111 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ie::PyParams()); |  | 57063 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ie::PyParams());
| 57112 | return 0; |  | 57064 | return 0;
| 57113 | } |  | 57065 | }
| 57114 |  |  | 57066 |
| 57115 |  |  | 57067 |
| 57116 | pyPopulateArgumentConversionErrors(); |  | 57068 | pyPopulateArgumentConversionErrors();
| 57117 | } |  | 57069 | }
| 57118 |  |  | 57070 |
| 57119 |  |  | 57071 |
| 57120 | { |  | 57072 | {
| 57121 | PyObject* pyobj_tag = NULL; |  | 57073 | PyObject* pyobj_tag = NULL;
| 57122 | std::string tag; |  | 57074 | std::string tag;
| 57123 | PyObject* pyobj_model = NULL; |  | 57075 | PyObject* pyobj_model = NULL;
| 57124 | std::string model; |  | 57076 | std::string model;
| 57125 | PyObject* pyobj_weights = NULL; |  | 57077 | PyObject* pyobj_weights = NULL;
| 57126 | std::string weights; |  | 57078 | std::string weights;
| 57127 | PyObject* pyobj_device = NULL; |  | 57079 | PyObject* pyobj_device = NULL;
| 57128 | std::string device; |  | 57080 | std::string device;
| 57129 |  |  | 57081 |
| 57130 | const char* keywords[] = { "tag", "model", "weights", "device", NULL }; |  | 57082 | const char* keywords[] = { "tag", "model", "weights", "device", NULL };
| 57131 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model, &pyobj_weights, &pyobj_device) && |  | 57083 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model, &pyobj_weights, &pyobj_device) &&
| 57132 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) && |  | 57084 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) &&
| 57133 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) && |  | 57085 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) &&
| 57134 | pyopencv_to_safe(pyobj_weights, weights, ArgInfo("weights", 0)) && |  | 57086 | pyopencv_to_safe(pyobj_weights, weights, ArgInfo("weights", 0)) &&
| 57135 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) ) |  | 57087 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) )
| 57136 | { |  | 57088 | {
| 57137 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ie::PyParams(tag, model, weights, device)); |  | 57089 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ie::PyParams(tag, model, weights, device));
| 57138 | return 0; |  | 57090 | return 0;
| 57139 | } |  | 57091 | }
| 57140 |  |  | 57092 |
| 57141 |  |  | 57093 |
| 57142 | pyPopulateArgumentConversionErrors(); |  | 57094 | pyPopulateArgumentConversionErrors();
| 57143 | } |  | 57095 | }
| 57144 |  |  | 57096 |
| 57145 |  |  | 57097 |
| 57146 | { |  | 57098 | {
| 57147 | PyObject* pyobj_tag = NULL; |  | 57099 | PyObject* pyobj_tag = NULL;
| 57148 | std::string tag; |  | 57100 | std::string tag;
| 57149 | PyObject* pyobj_model = NULL; |  | 57101 | PyObject* pyobj_model = NULL;
| 57150 | std::string model; |  | 57102 | std::string model;
| 57151 | PyObject* pyobj_device = NULL; |  | 57103 | PyObject* pyobj_device = NULL;
| 57152 | std::string device; |  | 57104 | std::string device;
| 57153 |  |  | 57105 |
| 57154 | const char* keywords[] = { "tag", "model", "device", NULL }; |  | 57106 | const char* keywords[] = { "tag", "model", "device", NULL };
| 57155 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model, &pyobj_device) && |  | 57107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model, &pyobj_device) &&
| 57156 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) && |  | 57108 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) &&
| 57157 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) && |  | 57109 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) &&
| 57158 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) ) |  | 57110 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) )
| 57159 | { |  | 57111 | {
| 57160 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ie::PyParams(tag, model, device)); |  | 57112 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ie::PyParams(tag, model, device));
| 57161 | return 0; |  | 57113 | return 0;
| 57162 | } |  | 57114 | }
| 57163 |  |  | 57115 |
| 57164 |  |  | 57116 |
| 57165 | pyPopulateArgumentConversionErrors(); |  | 57117 | pyPopulateArgumentConversionErrors();
| 57166 | } |  | 57118 | }
| 57167 | pyRaiseCVOverloadException("PyParams"); |  | 57119 | pyRaiseCVOverloadException("PyParams");
| 57168 |  |  | 57120 |
| 57169 | return -1; |  | 57121 | return -1;
| 57170 | } |  | 57122 | }
| 57171 |  |  | 57123 |
| 57172 | static PyObject* pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgBatchSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57124 | static PyObject* pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgBatchSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 57173 | { |  | 57125 | {
| 57174 | using namespace cv::gapi::ie; |  | 57126 | using namespace cv::gapi::ie;
| 57175 |  |  | 57127 |
| 57176 |  |  | 57128 |
| 57177 | cv::gapi::ie::PyParams * self1 = 0; |  | 57129 | cv::gapi::ie::PyParams * self1 = 0;
| 57178 | if (!pyopencv_gapi_ie_PyParams_getp(self, self1)) |  | 57130 | if (!pyopencv_gapi_ie_PyParams_getp(self, self1))
| 57179 | return failmsgp("Incorrect type of self (must be 'gapi_ie_PyParams' or its derivative)"); |  | 57131 | return failmsgp("Incorrect type of self (must be 'gapi_ie_PyParams' or its derivative)");
| 57180 | cv::gapi::ie::PyParams* _self_ = (self1); |  | 57132 | cv::gapi::ie::PyParams* _self_ = (self1);
| 57181 | PyObject* pyobj_size = NULL; |  | 57133 | PyObject* pyobj_size = NULL;
| 57182 | size_t size=0; |  | 57134 | size_t size=0;
| 57183 | PyParams retval; |  | 57135 | PyParams retval;
| 57184 |  |  | 57136 |
| 57185 | const char* keywords[] = { "size", NULL }; |  | 57137 | const char* keywords[] = { "size", NULL };
| 57186 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ie_PyParams.cfgBatchSize", (char**)keywords, &pyobj_size) && |  | 57138 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ie_PyParams.cfgBatchSize", (char**)keywords, &pyobj_size) &&
| 57187 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) ) |  | 57139 | pyopencv_to_safe(pyobj_size, size, ArgInfo("size", 0)) )
| 57188 | { |  | 57140 | {
| 57189 | ERRWRAP2(retval = _self_->cfgBatchSize(size)); |  | 57141 | ERRWRAP2(retval = _self_->cfgBatchSize(size));
| 57190 | return pyopencv_from(retval); |  | 57142 | return pyopencv_from(retval);
| 57191 | } |  | 57143 | }
| 57192 |  |  | 57144 |
| 57193 | return NULL; |  | 57145 | return NULL;
| 57194 | } |  | 57146 | }
| 57195 |  |  | 57147 |
| 57196 | static PyObject* pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgNumRequests(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57148 | static PyObject* pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgNumRequests(PyObject* self, PyObject* py_args, PyObject* kw)
| 57197 | { |  | 57149 | {
| 57198 | using namespace cv::gapi::ie; |  | 57150 | using namespace cv::gapi::ie;
| 57199 |  |  | 57151 |
| 57200 |  |  | 57152 |
| 57201 | cv::gapi::ie::PyParams * self1 = 0; |  | 57153 | cv::gapi::ie::PyParams * self1 = 0;
| 57202 | if (!pyopencv_gapi_ie_PyParams_getp(self, self1)) |  | 57154 | if (!pyopencv_gapi_ie_PyParams_getp(self, self1))
| 57203 | return failmsgp("Incorrect type of self (must be 'gapi_ie_PyParams' or its derivative)"); |  | 57155 | return failmsgp("Incorrect type of self (must be 'gapi_ie_PyParams' or its derivative)");
| 57204 | cv::gapi::ie::PyParams* _self_ = (self1); |  | 57156 | cv::gapi::ie::PyParams* _self_ = (self1);
| 57205 | PyObject* pyobj_nireq = NULL; |  | 57157 | PyObject* pyobj_nireq = NULL;
| 57206 | size_t nireq=0; |  | 57158 | size_t nireq=0;
| 57207 | PyParams retval; |  | 57159 | PyParams retval;
| 57208 |  |  | 57160 |
| 57209 | const char* keywords[] = { "nireq", NULL }; |  | 57161 | const char* keywords[] = { "nireq", NULL };
| 57210 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ie_PyParams.cfgNumRequests", (char**)keywords, &pyobj_nireq) && |  | 57162 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ie_PyParams.cfgNumRequests", (char**)keywords, &pyobj_nireq) &&
| 57211 | pyopencv_to_safe(pyobj_nireq, nireq, ArgInfo("nireq", 0)) ) |  | 57163 | pyopencv_to_safe(pyobj_nireq, nireq, ArgInfo("nireq", 0)) )
| 57212 | { |  | 57164 | {
| 57213 | ERRWRAP2(retval = _self_->cfgNumRequests(nireq)); |  | 57165 | ERRWRAP2(retval = _self_->cfgNumRequests(nireq));
| 57214 | return pyopencv_from(retval); |  | 57166 | return pyopencv_from(retval);
| 57215 | } |  | 57167 | }
| 57216 |  |  | 57168 |
| 57217 | return NULL; |  | 57169 | return NULL;
| 57218 | } |  | 57170 | }
| 57219 |  |  | 57171 |
| 57220 | static PyObject* pyopencv_cv_gapi_ie_gapi_ie_PyParams_constInput(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57172 | static PyObject* pyopencv_cv_gapi_ie_gapi_ie_PyParams_constInput(PyObject* self, PyObject* py_args, PyObject* kw)
| 57221 | { |  | 57173 | {
| 57222 | using namespace cv::gapi::ie; |  | 57174 | using namespace cv::gapi::ie;
| 57223 |  |  | 57175 |
| 57224 |  |  | 57176 |
| 57225 | cv::gapi::ie::PyParams * self1 = 0; |  | 57177 | cv::gapi::ie::PyParams * self1 = 0;
| 57226 | if (!pyopencv_gapi_ie_PyParams_getp(self, self1)) |  | 57178 | if (!pyopencv_gapi_ie_PyParams_getp(self, self1))
| 57227 | return failmsgp("Incorrect type of self (must be 'gapi_ie_PyParams' or its derivative)"); |  | 57179 | return failmsgp("Incorrect type of self (must be 'gapi_ie_PyParams' or its derivative)");
| 57228 | cv::gapi::ie::PyParams* _self_ = (self1); |  | 57180 | cv::gapi::ie::PyParams* _self_ = (self1);
| 57229 | PyObject* pyobj_layer_name = NULL; |  | 57181 | PyObject* pyobj_layer_name = NULL;
| 57230 | std::string layer_name; |  | 57182 | std::string layer_name;
| 57231 | PyObject* pyobj_data = NULL; |  | 57183 | PyObject* pyobj_data = NULL;
| 57232 | Mat data; |  | 57184 | Mat data;
| 57233 | PyObject* pyobj_hint = NULL; |  | 57185 | PyObject* pyobj_hint = NULL;
| 57234 | TraitAs hint=TraitAs::TENSOR; |  | 57186 | TraitAs hint=TraitAs::TENSOR;
| 57235 | PyParams retval; |  | 57187 | PyParams retval;
| 57236 |  |  | 57188 |
| 57237 | const char* keywords[] = { "layer_name", "data", "hint", NULL }; |  | 57189 | const char* keywords[] = { "layer_name", "data", "hint", NULL };
| 57238 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:gapi_ie_PyParams.constInput", (char**)keywords, &pyobj_layer_name, &pyobj_data, &pyobj_hint) && |  | 57190 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:gapi_ie_PyParams.constInput", (char**)keywords, &pyobj_layer_name, &pyobj_data, &pyobj_hint) &&
| 57239 | pyopencv_to_safe(pyobj_layer_name, layer_name, ArgInfo("layer_name", 0)) && |  | 57191 | pyopencv_to_safe(pyobj_layer_name, layer_name, ArgInfo("layer_name", 0)) &&
| 57240 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) && |  | 57192 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) &&
| 57241 | pyopencv_to_safe(pyobj_hint, hint, ArgInfo("hint", 0)) ) |  | 57193 | pyopencv_to_safe(pyobj_hint, hint, ArgInfo("hint", 0)) )
| 57242 | { |  | 57194 | {
| 57243 | ERRWRAP2(retval = _self_->constInput(layer_name, data, hint)); |  | 57195 | ERRWRAP2(retval = _self_->constInput(layer_name, data, hint));
| 57244 | return pyopencv_from(retval); |  | 57196 | return pyopencv_from(retval);
| 57245 | } |  | 57197 | }
| 57246 |  |  | 57198 |
| 57247 | return NULL; |  | 57199 | return NULL;
| 57248 | } |  | 57200 | }
| 57249 |  |  | 57201 |
| 57250 |  |  | 57202 |
| 57251 |  |  | 57203 |
| 57252 | // Tables (gapi_ie_PyParams) |  | 57204 | // Tables (gapi_ie_PyParams)
| 57253 |  |  | 57205 |
| 57254 | static PyGetSetDef pyopencv_gapi_ie_PyParams_getseters[] = |  | 57206 | static PyGetSetDef pyopencv_gapi_ie_PyParams_getseters[] =
| 57255 | { |  | 57207 | {
| 57256 | {NULL} /* Sentinel */ |  | 57208 | {NULL} /* Sentinel */
| 57257 | }; |  | 57209 | };
| 57258 |  |  | 57210 |
| 57259 | static PyMethodDef pyopencv_gapi_ie_PyParams_methods[] = |  | 57211 | static PyMethodDef pyopencv_gapi_ie_PyParams_methods[] =
| 57260 | { |  | 57212 | {
| 57261 | {"cfgBatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgBatchSize, 0), "cfgBatchSize(size) -> retval\n."}, |  | 57213 | {"cfgBatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgBatchSize, 0), "cfgBatchSize(size) -> retval\n."},
| 57262 | {"cfgNumRequests", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgNumRequests, 0), "cfgNumRequests(nireq) -> retval\n."}, |  | 57214 | {"cfgNumRequests", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ie_gapi_ie_PyParams_cfgNumRequests, 0), "cfgNumRequests(nireq) -> retval\n."},
| 57263 | {"constInput", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ie_gapi_ie_PyParams_constInput, 0), "constInput(layer_name, data[, hint]) -> retval\n."}, |  | 57215 | {"constInput", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ie_gapi_ie_PyParams_constInput, 0), "constInput(layer_name, data[, hint]) -> retval\n."},
| 57264 |  |  | 57216 |
| 57265 | {NULL, NULL} |  | 57217 | {NULL, NULL}
| 57266 | }; |  | 57218 | };
| 57267 |  |  | 57219 |
| 57268 | // Converter (gapi_ie_PyParams) |  | 57220 | // Converter (gapi_ie_PyParams)
| 57269 |  |  | 57221 |
| 57270 | template<> |  | 57222 | template<>
| 57271 | struct PyOpenCV_Converter< cv::gapi::ie::PyParams > |  | 57223 | struct PyOpenCV_Converter< cv::gapi::ie::PyParams >
| 57272 | { |  | 57224 | {
| 57273 | static PyObject* from(const cv::gapi::ie::PyParams& r) |  | 57225 | static PyObject* from(const cv::gapi::ie::PyParams& r)
| 57274 | { |  | 57226 | {
| 57275 | return pyopencv_gapi_ie_PyParams_Instance(r); |  | 57227 | return pyopencv_gapi_ie_PyParams_Instance(r);
| 57276 | } |  | 57228 | }
| 57277 | static bool to(PyObject* src, cv::gapi::ie::PyParams& dst, const ArgInfo& info) |  | 57229 | static bool to(PyObject* src, cv::gapi::ie::PyParams& dst, const ArgInfo& info)
| 57278 | { |  | 57230 | {
| 57279 | if(!src || src == Py_None) |  | 57231 | if(!src || src == Py_None)
| 57280 | return true; |  | 57232 | return true;
| 57281 | cv::gapi::ie::PyParams * dst_; |  | 57233 | cv::gapi::ie::PyParams * dst_;
| 57282 | if (pyopencv_gapi_ie_PyParams_getp(src, dst_)) |  | 57234 | if (pyopencv_gapi_ie_PyParams_getp(src, dst_))
| 57283 | { |  | 57235 | {
| 57284 | dst = *dst_; |  | 57236 | dst = *dst_;
| 57285 | return true; |  | 57237 | return true;
| 57286 | } |  | 57238 | }
| 57287 |  |  | 57239 |
| 57288 | failmsg("Expected cv::gapi::ie::PyParams for argument '%s'", info.name); |  | 57240 | failmsg("Expected cv::gapi::ie::PyParams for argument '%s'", info.name);
| 57289 | return false; |  | 57241 | return false;
| 57290 | } |  | 57242 | }
| 57291 | }; |  | 57243 | };
| 57292 |  |  | 57244 |
| 57293 | //================================================================================ |  | 57245 | //================================================================================
| 57294 | // gapi_onnx_PyParams (Generic) |  | 57246 | // gapi_onnx_PyParams (Generic)
| 57295 | //================================================================================ |  | 57247 | //================================================================================
| 57296 |  |  | 57248 |
| 57297 | // GetSet (gapi_onnx_PyParams) |  | 57249 | // GetSet (gapi_onnx_PyParams)
| 57298 |  |  | 57250 |
| 57299 |  |  | 57251 |
| 57300 |  |  | 57252 |
| 57301 | // Methods (gapi_onnx_PyParams) |  | 57253 | // Methods (gapi_onnx_PyParams)
| 57302 |  |  | 57254 |
| 57303 | static int pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_PyParams(pyopencv_gapi_onnx_PyParams_t* self, PyObject* py_args, PyObject* kw) |  | 57255 | static int pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_PyParams(pyopencv_gapi_onnx_PyParams_t* self, PyObject* py_args, PyObject* kw)
| 57304 | { |  | 57256 | {
| 57305 | using namespace cv::gapi::onnx; |  | 57257 | using namespace cv::gapi::onnx;
| 57306 |  |  | 57258 |
| 57307 | pyPrepareArgumentConversionErrorsStorage(2); |  | 57259 | pyPrepareArgumentConversionErrorsStorage(2);
| 57308 |  |  | 57260 |
| 57309 | { |  | 57261 | {
| 57310 |  |  | 57262 |
| 57311 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57263 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57312 | { |  | 57264 | {
| 57313 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::PyParams()); |  | 57265 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::PyParams());
| 57314 | return 0; |  | 57266 | return 0;
| 57315 | } |  | 57267 | }
| 57316 |  |  | 57268 |
| 57317 |  |  | 57269 |
| 57318 | pyPopulateArgumentConversionErrors(); |  | 57270 | pyPopulateArgumentConversionErrors();
| 57319 | } |  | 57271 | }
| 57320 |  |  | 57272 |
| 57321 |  |  | 57273 |
| 57322 | { |  | 57274 | {
| 57323 | PyObject* pyobj_tag = NULL; |  | 57275 | PyObject* pyobj_tag = NULL;
| 57324 | std::string tag; |  | 57276 | std::string tag;
| 57325 | PyObject* pyobj_model_path = NULL; |  | 57277 | PyObject* pyobj_model_path = NULL;
| 57326 | std::string model_path; |  | 57278 | std::string model_path;
| 57327 |  |  | 57279 |
| 57328 | const char* keywords[] = { "tag", "model_path", NULL }; |  | 57280 | const char* keywords[] = { "tag", "model_path", NULL };
| 57329 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model_path) && |  | 57281 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model_path) &&
| 57330 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) && |  | 57282 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) &&
| 57331 | pyopencv_to_safe(pyobj_model_path, model_path, ArgInfo("model_path", 0)) ) |  | 57283 | pyopencv_to_safe(pyobj_model_path, model_path, ArgInfo("model_path", 0)) )
| 57332 | { |  | 57284 | {
| 57333 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::PyParams(tag, model_path)); |  | 57285 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::PyParams(tag, model_path));
| 57334 | return 0; |  | 57286 | return 0;
| 57335 | } |  | 57287 | }
| 57336 |  |  | 57288 |
| 57337 |  |  | 57289 |
| 57338 | pyPopulateArgumentConversionErrors(); |  | 57290 | pyPopulateArgumentConversionErrors();
| 57339 | } |  | 57291 | }
| 57340 | pyRaiseCVOverloadException("PyParams"); |  | 57292 | pyRaiseCVOverloadException("PyParams");
| 57341 |  |  | 57293 |
| 57342 | return -1; |  | 57294 | return -1;
| 57343 | } |  | 57295 | }
| 57344 |  |  | 57296 |
| 57345 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgAddExecutionProvider(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57297 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgAddExecutionProvider(PyObject* self, PyObject* py_args, PyObject* kw)
| 57346 | { |  | 57298 | {
| 57347 | using namespace cv::gapi::onnx; |  | 57299 | using namespace cv::gapi::onnx;
| 57348 |  |  | 57300 |
| 57349 |  |  | 57301 |
| 57350 | cv::gapi::onnx::PyParams * self1 = 0; |  | 57302 | cv::gapi::onnx::PyParams * self1 = 0;
| 57351 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1)) |  | 57303 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1))
| 57352 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)"); |  | 57304 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)");
| 57353 | cv::gapi::onnx::PyParams* _self_ = (self1); |  | 57305 | cv::gapi::onnx::PyParams* _self_ = (self1);
| 57354 | pyPrepareArgumentConversionErrorsStorage(5); |  | 57306 | pyPrepareArgumentConversionErrorsStorage(5);
| 57355 |  |  | 57307 |
| 57356 | { |  | 57308 | {
| 57357 | PyObject* pyobj_ep = NULL; |  | 57309 | PyObject* pyobj_ep = NULL;
| 57358 | ep_OpenVINO ep; |  | 57310 | ep_OpenVINO ep;
| 57359 | PyParams retval; |  | 57311 | PyParams retval;
| 57360 |  |  | 57312 |
| 57361 | const char* keywords[] = { "ep", NULL }; |  | 57313 | const char* keywords[] = { "ep", NULL };
| 57362 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) && |  | 57314 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) &&
| 57363 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) ) |  | 57315 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) )
| 57364 | { |  | 57316 | {
| 57365 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep)); |  | 57317 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep));
| 57366 | return pyopencv_from(retval); |  | 57318 | return pyopencv_from(retval);
| 57367 | } |  | 57319 | }
| 57368 |  |  | 57320 |
| 57369 |  |  | 57321 |
| 57370 | pyPopulateArgumentConversionErrors(); |  | 57322 | pyPopulateArgumentConversionErrors();
| 57371 | } |  | 57323 | }
| 57372 |  |  | 57324 |
| 57373 |  |  | 57325 |
| 57374 | { |  | 57326 | {
| 57375 | PyObject* pyobj_ep = NULL; |  | 57327 | PyObject* pyobj_ep = NULL;
| 57376 | ep_DirectML ep; |  | 57328 | ep_DirectML ep;
| 57377 | PyParams retval; |  | 57329 | PyParams retval;
| 57378 |  |  | 57330 |
| 57379 | const char* keywords[] = { "ep", NULL }; |  | 57331 | const char* keywords[] = { "ep", NULL };
| 57380 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) && |  | 57332 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) &&
| 57381 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) ) |  | 57333 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) )
| 57382 | { |  | 57334 | {
| 57383 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep)); |  | 57335 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep));
| 57384 | return pyopencv_from(retval); |  | 57336 | return pyopencv_from(retval);
| 57385 | } |  | 57337 | }
| 57386 |  |  | 57338 |
| 57387 |  |  | 57339 |
| 57388 | pyPopulateArgumentConversionErrors(); |  | 57340 | pyPopulateArgumentConversionErrors();
| 57389 | } |  | 57341 | }
| 57390 |  |  | 57342 |
| 57391 |  |  | 57343 |
| 57392 | { |  | 57344 | {
| 57393 | PyObject* pyobj_ep = NULL; |  | 57345 | PyObject* pyobj_ep = NULL;
| 57394 | ep_CoreML ep; |  | 57346 | ep_CoreML ep;
| 57395 | PyParams retval; |  | 57347 | PyParams retval;
| 57396 |  |  | 57348 |
| 57397 | const char* keywords[] = { "ep", NULL }; |  | 57349 | const char* keywords[] = { "ep", NULL };
| 57398 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) && |  | 57350 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) &&
| 57399 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) ) |  | 57351 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) )
| 57400 | { |  | 57352 | {
| 57401 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep)); |  | 57353 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep));
| 57402 | return pyopencv_from(retval); |  | 57354 | return pyopencv_from(retval);
| 57403 | } |  | 57355 | }
| 57404 |  |  | 57356 |
| 57405 |  |  | 57357 |
| 57406 | pyPopulateArgumentConversionErrors(); |  | 57358 | pyPopulateArgumentConversionErrors();
| 57407 | } |  | 57359 | }
| 57408 |  |  | 57360 |
| 57409 |  |  | 57361 |
| 57410 | { |  | 57362 | {
| 57411 | PyObject* pyobj_ep = NULL; |  | 57363 | PyObject* pyobj_ep = NULL;
| 57412 | ep_CUDA ep; |  | 57364 | ep_CUDA ep;
| 57413 | PyParams retval; |  | 57365 | PyParams retval;
| 57414 |  |  | 57366 |
| 57415 | const char* keywords[] = { "ep", NULL }; |  | 57367 | const char* keywords[] = { "ep", NULL };
| 57416 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) && |  | 57368 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) &&
| 57417 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) ) |  | 57369 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) )
| 57418 | { |  | 57370 | {
| 57419 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep)); |  | 57371 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep));
| 57420 | return pyopencv_from(retval); |  | 57372 | return pyopencv_from(retval);
| 57421 | } |  | 57373 | }
| 57422 |  |  | 57374 |
| 57423 |  |  | 57375 |
| 57424 | pyPopulateArgumentConversionErrors(); |  | 57376 | pyPopulateArgumentConversionErrors();
| 57425 | } |  | 57377 | }
| 57426 |  |  | 57378 |
| 57427 |  |  | 57379 |
| 57428 | { |  | 57380 | {
| 57429 | PyObject* pyobj_ep = NULL; |  | 57381 | PyObject* pyobj_ep = NULL;
| 57430 | ep_TensorRT ep; |  | 57382 | ep_TensorRT ep;
| 57431 | PyParams retval; |  | 57383 | PyParams retval;
| 57432 |  |  | 57384 |
| 57433 | const char* keywords[] = { "ep", NULL }; |  | 57385 | const char* keywords[] = { "ep", NULL };
| 57434 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) && |  | 57386 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgAddExecutionProvider", (char**)keywords, &pyobj_ep) &&
| 57435 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) ) |  | 57387 | pyopencv_to_safe(pyobj_ep, ep, ArgInfo("ep", 0)) )
| 57436 | { |  | 57388 | {
| 57437 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep)); |  | 57389 | ERRWRAP2(retval = _self_->cfgAddExecutionProvider(ep));
| 57438 | return pyopencv_from(retval); |  | 57390 | return pyopencv_from(retval);
| 57439 | } |  | 57391 | }
| 57440 |  |  | 57392 |
| 57441 |  |  | 57393 |
| 57442 | pyPopulateArgumentConversionErrors(); |  | 57394 | pyPopulateArgumentConversionErrors();
| 57443 | } |  | 57395 | }
| 57444 | pyRaiseCVOverloadException("cfgAddExecutionProvider"); |  | 57396 | pyRaiseCVOverloadException("cfgAddExecutionProvider");
| 57445 |  |  | 57397 |
| 57446 | return NULL; |  | 57398 | return NULL;
| 57447 | } |  | 57399 | }
| 57448 |  |  | 57400 |
| 57449 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgDisableMemPattern(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57401 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgDisableMemPattern(PyObject* self, PyObject* py_args, PyObject* kw)
| 57450 | { |  | 57402 | {
| 57451 | using namespace cv::gapi::onnx; |  | 57403 | using namespace cv::gapi::onnx;
| 57452 |  |  | 57404 |
| 57453 |  |  | 57405 |
| 57454 | cv::gapi::onnx::PyParams * self1 = 0; |  | 57406 | cv::gapi::onnx::PyParams * self1 = 0;
| 57455 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1)) |  | 57407 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1))
| 57456 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)"); |  | 57408 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)");
| 57457 | cv::gapi::onnx::PyParams* _self_ = (self1); |  | 57409 | cv::gapi::onnx::PyParams* _self_ = (self1);
| 57458 | PyParams retval; |  | 57410 | PyParams retval;
| 57459 |  |  | 57411 |
| 57460 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57412 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57461 | { |  | 57413 | {
| 57462 | ERRWRAP2(retval = _self_->cfgDisableMemPattern()); |  | 57414 | ERRWRAP2(retval = _self_->cfgDisableMemPattern());
| 57463 | return pyopencv_from(retval); |  | 57415 | return pyopencv_from(retval);
| 57464 | } |  | 57416 | }
| 57465 |  |  | 57417 |
| 57466 | return NULL; |  | 57418 | return NULL;
| 57467 | } |  | 57419 | }
| 57468 |  |  | 57420 |
| 57469 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgMeanStd(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57421 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgMeanStd(PyObject* self, PyObject* py_args, PyObject* kw)
| 57470 | { |  | 57422 | {
| 57471 | using namespace cv::gapi::onnx; |  | 57423 | using namespace cv::gapi::onnx;
| 57472 |  |  | 57424 |
| 57473 |  |  | 57425 |
| 57474 | cv::gapi::onnx::PyParams * self1 = 0; |  | 57426 | cv::gapi::onnx::PyParams * self1 = 0;
| 57475 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1)) |  | 57427 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1))
| 57476 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)"); |  | 57428 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)");
| 57477 | cv::gapi::onnx::PyParams* _self_ = (self1); |  | 57429 | cv::gapi::onnx::PyParams* _self_ = (self1);
| 57478 | PyObject* pyobj_layer_name = NULL; |  | 57430 | PyObject* pyobj_layer_name = NULL;
| 57479 | std::string layer_name; |  | 57431 | std::string layer_name;
| 57480 | PyObject* pyobj_m = NULL; |  | 57432 | PyObject* pyobj_m = NULL;
| 57481 | Scalar m; |  | 57433 | Scalar m;
| 57482 | PyObject* pyobj_s = NULL; |  | 57434 | PyObject* pyobj_s = NULL;
| 57483 | Scalar s; |  | 57435 | Scalar s;
| 57484 | PyParams retval; |  | 57436 | PyParams retval;
| 57485 |  |  | 57437 |
| 57486 | const char* keywords[] = { "layer_name", "m", "s", NULL }; |  | 57438 | const char* keywords[] = { "layer_name", "m", "s", NULL };
| 57487 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:gapi_onnx_PyParams.cfgMeanStd", (char**)keywords, &pyobj_layer_name, &pyobj_m, &pyobj_s) && |  | 57439 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:gapi_onnx_PyParams.cfgMeanStd", (char**)keywords, &pyobj_layer_name, &pyobj_m, &pyobj_s) &&
| 57488 | pyopencv_to_safe(pyobj_layer_name, layer_name, ArgInfo("layer_name", 0)) && |  | 57440 | pyopencv_to_safe(pyobj_layer_name, layer_name, ArgInfo("layer_name", 0)) &&
| 57489 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) && |  | 57441 | pyopencv_to_safe(pyobj_m, m, ArgInfo("m", 0)) &&
| 57490 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) ) |  | 57442 | pyopencv_to_safe(pyobj_s, s, ArgInfo("s", 0)) )
| 57491 | { |  | 57443 | {
| 57492 | ERRWRAP2(retval = _self_->cfgMeanStd(layer_name, m, s)); |  | 57444 | ERRWRAP2(retval = _self_->cfgMeanStd(layer_name, m, s));
| 57493 | return pyopencv_from(retval); |  | 57445 | return pyopencv_from(retval);
| 57494 | } |  | 57446 | }
| 57495 |  |  | 57447 |
| 57496 | return NULL; |  | 57448 | return NULL;
| 57497 | } |  | 57449 | }
| 57498 |  |  | 57450 |
| 57499 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgNormalize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57451 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgNormalize(PyObject* self, PyObject* py_args, PyObject* kw)
| 57500 | { |  | 57452 | {
| 57501 | using namespace cv::gapi::onnx; |  | 57453 | using namespace cv::gapi::onnx;
| 57502 |  |  | 57454 |
| 57503 |  |  | 57455 |
| 57504 | cv::gapi::onnx::PyParams * self1 = 0; |  | 57456 | cv::gapi::onnx::PyParams * self1 = 0;
| 57505 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1)) |  | 57457 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1))
| 57506 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)"); |  | 57458 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)");
| 57507 | cv::gapi::onnx::PyParams* _self_ = (self1); |  | 57459 | cv::gapi::onnx::PyParams* _self_ = (self1);
| 57508 | PyObject* pyobj_layer_name = NULL; |  | 57460 | PyObject* pyobj_layer_name = NULL;
| 57509 | std::string layer_name; |  | 57461 | std::string layer_name;
| 57510 | PyObject* pyobj_flag = NULL; |  | 57462 | PyObject* pyobj_flag = NULL;
| 57511 | bool flag=0; |  | 57463 | bool flag=0;
| 57512 | PyParams retval; |  | 57464 | PyParams retval;
| 57513 |  |  | 57465 |
| 57514 | const char* keywords[] = { "layer_name", "flag", NULL }; |  | 57466 | const char* keywords[] = { "layer_name", "flag", NULL };
| 57515 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:gapi_onnx_PyParams.cfgNormalize", (char**)keywords, &pyobj_layer_name, &pyobj_flag) && |  | 57467 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:gapi_onnx_PyParams.cfgNormalize", (char**)keywords, &pyobj_layer_name, &pyobj_flag) &&
| 57516 | pyopencv_to_safe(pyobj_layer_name, layer_name, ArgInfo("layer_name", 0)) && |  | 57468 | pyopencv_to_safe(pyobj_layer_name, layer_name, ArgInfo("layer_name", 0)) &&
| 57517 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) ) |  | 57469 | pyopencv_to_safe(pyobj_flag, flag, ArgInfo("flag", 0)) )
| 57518 | { |  | 57470 | {
| 57519 | ERRWRAP2(retval = _self_->cfgNormalize(layer_name, flag)); |  | 57471 | ERRWRAP2(retval = _self_->cfgNormalize(layer_name, flag));
| 57520 | return pyopencv_from(retval); |  | 57472 | return pyopencv_from(retval);
| 57521 | } |  | 57473 | }
| 57522 |  |  | 57474 |
| 57523 | return NULL; |  | 57475 | return NULL;
| 57524 | } |  | 57476 | }
| 57525 |  |  | 57477 |
| 57526 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgOptLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57478 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgOptLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 57527 | { |  | 57479 | {
| 57528 | using namespace cv::gapi::onnx; |  | 57480 | using namespace cv::gapi::onnx;
| 57529 |  |  | 57481 |
| 57530 |  |  | 57482 |
| 57531 | cv::gapi::onnx::PyParams * self1 = 0; |  | 57483 | cv::gapi::onnx::PyParams * self1 = 0;
| 57532 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1)) |  | 57484 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1))
| 57533 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)"); |  | 57485 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)");
| 57534 | cv::gapi::onnx::PyParams* _self_ = (self1); |  | 57486 | cv::gapi::onnx::PyParams* _self_ = (self1);
| 57535 | PyObject* pyobj_opt_level = NULL; |  | 57487 | PyObject* pyobj_opt_level = NULL;
| 57536 | int opt_level=0; |  | 57488 | int opt_level=0;
| 57537 | PyParams retval; |  | 57489 | PyParams retval;
| 57538 |  |  | 57490 |
| 57539 | const char* keywords[] = { "opt_level", NULL }; |  | 57491 | const char* keywords[] = { "opt_level", NULL };
| 57540 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgOptLevel", (char**)keywords, &pyobj_opt_level) && |  | 57492 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgOptLevel", (char**)keywords, &pyobj_opt_level) &&
| 57541 | pyopencv_to_safe(pyobj_opt_level, opt_level, ArgInfo("opt_level", 0)) ) |  | 57493 | pyopencv_to_safe(pyobj_opt_level, opt_level, ArgInfo("opt_level", 0)) )
| 57542 | { |  | 57494 | {
| 57543 | ERRWRAP2(retval = _self_->cfgOptLevel(opt_level)); |  | 57495 | ERRWRAP2(retval = _self_->cfgOptLevel(opt_level));
| 57544 | return pyopencv_from(retval); |  | 57496 | return pyopencv_from(retval);
| 57545 | } |  | 57497 | }
| 57546 |  |  | 57498 |
| 57547 | return NULL; |  | 57499 | return NULL;
| 57548 | } |  | 57500 | }
| 57549 |  |  | 57501 |
| 57550 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgSessionOptions(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57502 | static PyObject* pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgSessionOptions(PyObject* self, PyObject* py_args, PyObject* kw)
| 57551 | { |  | 57503 | {
| 57552 | using namespace cv::gapi::onnx; |  | 57504 | using namespace cv::gapi::onnx;
| 57553 |  |  | 57505 |
| 57554 |  |  | 57506 |
| 57555 | cv::gapi::onnx::PyParams * self1 = 0; |  | 57507 | cv::gapi::onnx::PyParams * self1 = 0;
| 57556 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1)) |  | 57508 | if (!pyopencv_gapi_onnx_PyParams_getp(self, self1))
| 57557 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)"); |  | 57509 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_PyParams' or its derivative)");
| 57558 | cv::gapi::onnx::PyParams* _self_ = (self1); |  | 57510 | cv::gapi::onnx::PyParams* _self_ = (self1);
| 57559 | PyObject* pyobj_options = NULL; |  | 57511 | PyObject* pyobj_options = NULL;
| 57560 | map_string_and_string options; |  | 57512 | map_string_and_string options;
| 57561 | PyParams retval; |  | 57513 | PyParams retval;
| 57562 |  |  | 57514 |
| 57563 | const char* keywords[] = { "options", NULL }; |  | 57515 | const char* keywords[] = { "options", NULL };
| 57564 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgSessionOptions", (char**)keywords, &pyobj_options) && |  | 57516 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_PyParams.cfgSessionOptions", (char**)keywords, &pyobj_options) &&
| 57565 | pyopencv_to_safe(pyobj_options, options, ArgInfo("options", 0)) ) |  | 57517 | pyopencv_to_safe(pyobj_options, options, ArgInfo("options", 0)) )
| 57566 | { |  | 57518 | {
| 57567 | ERRWRAP2(retval = _self_->cfgSessionOptions(options)); |  | 57519 | ERRWRAP2(retval = _self_->cfgSessionOptions(options));
| 57568 | return pyopencv_from(retval); |  | 57520 | return pyopencv_from(retval);
| 57569 | } |  | 57521 | }
| 57570 |  |  | 57522 |
| 57571 | return NULL; |  | 57523 | return NULL;
| 57572 | } |  | 57524 | }
| 57573 |  |  | 57525 |
| 57574 |  |  | 57526 |
| 57575 |  |  | 57527 |
| 57576 | // Tables (gapi_onnx_PyParams) |  | 57528 | // Tables (gapi_onnx_PyParams)
| 57577 |  |  | 57529 |
| 57578 | static PyGetSetDef pyopencv_gapi_onnx_PyParams_getseters[] = |  | 57530 | static PyGetSetDef pyopencv_gapi_onnx_PyParams_getseters[] =
| 57579 | { |  | 57531 | {
| 57580 | {NULL} /* Sentinel */ |  | 57532 | {NULL} /* Sentinel */
| 57581 | }; |  | 57533 | };
| 57582 |  |  | 57534 |
| 57583 | static PyMethodDef pyopencv_gapi_onnx_PyParams_methods[] = |  | 57535 | static PyMethodDef pyopencv_gapi_onnx_PyParams_methods[] =
| 57584 | { |  | 57536 | {
| 57585 | {"cfgAddExecutionProvider", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgAddExecutionProvider, 0), "cfgAddExecutionProvider(ep) -> retval\n."}, |  | 57537 | {"cfgAddExecutionProvider", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgAddExecutionProvider, 0), "cfgAddExecutionProvider(ep) -> retval\n."},
| 57586 | {"cfgDisableMemPattern", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgDisableMemPattern, 0), "cfgDisableMemPattern() -> retval\n."}, |  | 57538 | {"cfgDisableMemPattern", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgDisableMemPattern, 0), "cfgDisableMemPattern() -> retval\n."},
| 57587 | {"cfgMeanStd", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgMeanStd, 0), "cfgMeanStd(layer_name, m, s) -> retval\n."}, |  | 57539 | {"cfgMeanStd", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgMeanStd, 0), "cfgMeanStd(layer_name, m, s) -> retval\n."},
| 57588 | {"cfgNormalize", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgNormalize, 0), "cfgNormalize(layer_name, flag) -> retval\n."}, |  | 57540 | {"cfgNormalize", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgNormalize, 0), "cfgNormalize(layer_name, flag) -> retval\n."},
| 57589 | {"cfgOptLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgOptLevel, 0), "cfgOptLevel(opt_level) -> retval\n."}, |  | 57541 | {"cfgOptLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgOptLevel, 0), "cfgOptLevel(opt_level) -> retval\n."},
| 57590 | {"cfgSessionOptions", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgSessionOptions, 0), "cfgSessionOptions(options) -> retval\n."}, |  | 57542 | {"cfgSessionOptions", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_gapi_onnx_PyParams_cfgSessionOptions, 0), "cfgSessionOptions(options) -> retval\n."},
| 57591 |  |  | 57543 |
| 57592 | {NULL, NULL} |  | 57544 | {NULL, NULL}
| 57593 | }; |  | 57545 | };
| 57594 |  |  | 57546 |
| 57595 | // Converter (gapi_onnx_PyParams) |  | 57547 | // Converter (gapi_onnx_PyParams)
| 57596 |  |  | 57548 |
| 57597 | template<> |  | 57549 | template<>
| 57598 | struct PyOpenCV_Converter< cv::gapi::onnx::PyParams > |  | 57550 | struct PyOpenCV_Converter< cv::gapi::onnx::PyParams >
| 57599 | { |  | 57551 | {
| 57600 | static PyObject* from(const cv::gapi::onnx::PyParams& r) |  | 57552 | static PyObject* from(const cv::gapi::onnx::PyParams& r)
| 57601 | { |  | 57553 | {
| 57602 | return pyopencv_gapi_onnx_PyParams_Instance(r); |  | 57554 | return pyopencv_gapi_onnx_PyParams_Instance(r);
| 57603 | } |  | 57555 | }
| 57604 | static bool to(PyObject* src, cv::gapi::onnx::PyParams& dst, const ArgInfo& info) |  | 57556 | static bool to(PyObject* src, cv::gapi::onnx::PyParams& dst, const ArgInfo& info)
| 57605 | { |  | 57557 | {
| 57606 | if(!src || src == Py_None) |  | 57558 | if(!src || src == Py_None)
| 57607 | return true; |  | 57559 | return true;
| 57608 | cv::gapi::onnx::PyParams * dst_; |  | 57560 | cv::gapi::onnx::PyParams * dst_;
| 57609 | if (pyopencv_gapi_onnx_PyParams_getp(src, dst_)) |  | 57561 | if (pyopencv_gapi_onnx_PyParams_getp(src, dst_))
| 57610 | { |  | 57562 | {
| 57611 | dst = *dst_; |  | 57563 | dst = *dst_;
| 57612 | return true; |  | 57564 | return true;
| 57613 | } |  | 57565 | }
| 57614 |  |  | 57566 |
| 57615 | failmsg("Expected cv::gapi::onnx::PyParams for argument '%s'", info.name); |  | 57567 | failmsg("Expected cv::gapi::onnx::PyParams for argument '%s'", info.name);
| 57616 | return false; |  | 57568 | return false;
| 57617 | } |  | 57569 | }
| 57618 | }; |  | 57570 | };
| 57619 |  |  | 57571 |
| 57620 | //================================================================================ |  | 57572 | //================================================================================
| 57621 | // gapi_onnx_ep_CUDA (Generic) |  | 57573 | // gapi_onnx_ep_CUDA (Generic)
| 57622 | //================================================================================ |  | 57574 | //================================================================================
| 57623 |  |  | 57575 |
| 57624 | // GetSet (gapi_onnx_ep_CUDA) |  | 57576 | // GetSet (gapi_onnx_ep_CUDA)
| 57625 |  |  | 57577 |
| 57626 |  |  | 57578 |
| 57627 |  |  | 57579 |
| 57628 | // Methods (gapi_onnx_ep_CUDA) |  | 57580 | // Methods (gapi_onnx_ep_CUDA)
| 57629 |  |  | 57581 |
| 57630 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CUDA_CUDA(pyopencv_gapi_onnx_ep_CUDA_t* self, PyObject* py_args, PyObject* kw) |  | 57582 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CUDA_CUDA(pyopencv_gapi_onnx_ep_CUDA_t* self, PyObject* py_args, PyObject* kw)
| 57631 | { |  | 57583 | {
| 57632 | using namespace cv::gapi::onnx::ep; |  | 57584 | using namespace cv::gapi::onnx::ep;
| 57633 |  |  | 57585 |
| 57634 | pyPrepareArgumentConversionErrorsStorage(2); |  | 57586 | pyPrepareArgumentConversionErrorsStorage(2);
| 57635 |  |  | 57587 |
| 57636 | { |  | 57588 | {
| 57637 |  |  | 57589 |
| 57638 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57590 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57639 | { |  | 57591 | {
| 57640 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::CUDA()); |  | 57592 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::CUDA());
| 57641 | return 0; |  | 57593 | return 0;
| 57642 | } |  | 57594 | }
| 57643 |  |  | 57595 |
| 57644 |  |  | 57596 |
| 57645 | pyPopulateArgumentConversionErrors(); |  | 57597 | pyPopulateArgumentConversionErrors();
| 57646 | } |  | 57598 | }
| 57647 |  |  | 57599 |
| 57648 |  |  | 57600 |
| 57649 | { |  | 57601 | {
| 57650 | PyObject* pyobj_dev_id = NULL; |  | 57602 | PyObject* pyobj_dev_id = NULL;
| 57651 | int dev_id=0; |  | 57603 | int dev_id=0;
| 57652 |  |  | 57604 |
| 57653 | const char* keywords[] = { "dev_id", NULL }; |  | 57605 | const char* keywords[] = { "dev_id", NULL };
| 57654 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CUDA", (char**)keywords, &pyobj_dev_id) && |  | 57606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:CUDA", (char**)keywords, &pyobj_dev_id) &&
| 57655 | pyopencv_to_safe(pyobj_dev_id, dev_id, ArgInfo("dev_id", 0)) ) |  | 57607 | pyopencv_to_safe(pyobj_dev_id, dev_id, ArgInfo("dev_id", 0)) )
| 57656 | { |  | 57608 | {
| 57657 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::CUDA(dev_id)); |  | 57609 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::CUDA(dev_id));
| 57658 | return 0; |  | 57610 | return 0;
| 57659 | } |  | 57611 | }
| 57660 |  |  | 57612 |
| 57661 |  |  | 57613 |
| 57662 | pyPopulateArgumentConversionErrors(); |  | 57614 | pyPopulateArgumentConversionErrors();
| 57663 | } |  | 57615 | }
| 57664 | pyRaiseCVOverloadException("CUDA"); |  | 57616 | pyRaiseCVOverloadException("CUDA");
| 57665 |  |  | 57617 |
| 57666 | return -1; |  | 57618 | return -1;
| 57667 | } |  | 57619 | }
| 57668 |  |  | 57620 |
| 57669 |  |  | 57621 |
| 57670 |  |  | 57622 |
| 57671 | // Tables (gapi_onnx_ep_CUDA) |  | 57623 | // Tables (gapi_onnx_ep_CUDA)
| 57672 |  |  | 57624 |
| 57673 | static PyGetSetDef pyopencv_gapi_onnx_ep_CUDA_getseters[] = |  | 57625 | static PyGetSetDef pyopencv_gapi_onnx_ep_CUDA_getseters[] =
| 57674 | { |  | 57626 | {
| 57675 | {NULL} /* Sentinel */ |  | 57627 | {NULL} /* Sentinel */
| 57676 | }; |  | 57628 | };
| 57677 |  |  | 57629 |
| 57678 | static PyMethodDef pyopencv_gapi_onnx_ep_CUDA_methods[] = |  | 57630 | static PyMethodDef pyopencv_gapi_onnx_ep_CUDA_methods[] =
| 57679 | { |  | 57631 | {
| 57680 |  |  | 57632 |
| 57681 | {NULL, NULL} |  | 57633 | {NULL, NULL}
| 57682 | }; |  | 57634 | };
| 57683 |  |  | 57635 |
| 57684 | // Converter (gapi_onnx_ep_CUDA) |  | 57636 | // Converter (gapi_onnx_ep_CUDA)
| 57685 |  |  | 57637 |
| 57686 | template<> |  | 57638 | template<>
| 57687 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::CUDA > |  | 57639 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::CUDA >
| 57688 | { |  | 57640 | {
| 57689 | static PyObject* from(const cv::gapi::onnx::ep::CUDA& r) |  | 57641 | static PyObject* from(const cv::gapi::onnx::ep::CUDA& r)
| 57690 | { |  | 57642 | {
| 57691 | return pyopencv_gapi_onnx_ep_CUDA_Instance(r); |  | 57643 | return pyopencv_gapi_onnx_ep_CUDA_Instance(r);
| 57692 | } |  | 57644 | }
| 57693 | static bool to(PyObject* src, cv::gapi::onnx::ep::CUDA& dst, const ArgInfo& info) |  | 57645 | static bool to(PyObject* src, cv::gapi::onnx::ep::CUDA& dst, const ArgInfo& info)
| 57694 | { |  | 57646 | {
| 57695 | if(!src || src == Py_None) |  | 57647 | if(!src || src == Py_None)
| 57696 | return true; |  | 57648 | return true;
| 57697 | cv::gapi::onnx::ep::CUDA * dst_; |  | 57649 | cv::gapi::onnx::ep::CUDA * dst_;
| 57698 | if (pyopencv_gapi_onnx_ep_CUDA_getp(src, dst_)) |  | 57650 | if (pyopencv_gapi_onnx_ep_CUDA_getp(src, dst_))
| 57699 | { |  | 57651 | {
| 57700 | dst = *dst_; |  | 57652 | dst = *dst_;
| 57701 | return true; |  | 57653 | return true;
| 57702 | } |  | 57654 | }
| 57703 |  |  | 57655 |
| 57704 | failmsg("Expected cv::gapi::onnx::ep::CUDA for argument '%s'", info.name); |  | 57656 | failmsg("Expected cv::gapi::onnx::ep::CUDA for argument '%s'", info.name);
| 57705 | return false; |  | 57657 | return false;
| 57706 | } |  | 57658 | }
| 57707 | }; |  | 57659 | };
| 57708 |  |  | 57660 |
| 57709 | //================================================================================ |  | 57661 | //================================================================================
| 57710 | // gapi_onnx_ep_CoreML (Generic) |  | 57662 | // gapi_onnx_ep_CoreML (Generic)
| 57711 | //================================================================================ |  | 57663 | //================================================================================
| 57712 |  |  | 57664 |
| 57713 | // GetSet (gapi_onnx_ep_CoreML) |  | 57665 | // GetSet (gapi_onnx_ep_CoreML)
| 57714 |  |  | 57666 |
| 57715 |  |  | 57667 |
| 57716 |  |  | 57668 |
| 57717 | // Methods (gapi_onnx_ep_CoreML) |  | 57669 | // Methods (gapi_onnx_ep_CoreML)
| 57718 |  |  | 57670 |
| 57719 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_CoreML(pyopencv_gapi_onnx_ep_CoreML_t* self, PyObject* py_args, PyObject* kw) |  | 57671 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_CoreML(pyopencv_gapi_onnx_ep_CoreML_t* self, PyObject* py_args, PyObject* kw)
| 57720 | { |  | 57672 | {
| 57721 | using namespace cv::gapi::onnx::ep; |  | 57673 | using namespace cv::gapi::onnx::ep;
| 57722 |  |  | 57674 |
| 57723 |  |  | 57675 |
| 57724 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57676 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57725 | { |  | 57677 | {
| 57726 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::CoreML()); |  | 57678 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::CoreML());
| 57727 | return 0; |  | 57679 | return 0;
| 57728 | } |  | 57680 | }
| 57729 |  |  | 57681 |
| 57730 | return -1; |  | 57682 | return -1;
| 57731 | } |  | 57683 | }
| 57732 |  |  | 57684 |
| 57733 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnSubgraph(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57685 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnSubgraph(PyObject* self, PyObject* py_args, PyObject* kw)
| 57734 | { |  | 57686 | {
| 57735 | using namespace cv::gapi::onnx::ep; |  | 57687 | using namespace cv::gapi::onnx::ep;
| 57736 |  |  | 57688 |
| 57737 |  |  | 57689 |
| 57738 | cv::gapi::onnx::ep::CoreML * self1 = 0; |  | 57690 | cv::gapi::onnx::ep::CoreML * self1 = 0;
| 57739 | if (!pyopencv_gapi_onnx_ep_CoreML_getp(self, self1)) |  | 57691 | if (!pyopencv_gapi_onnx_ep_CoreML_getp(self, self1))
| 57740 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_CoreML' or its derivative)"); |  | 57692 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_CoreML' or its derivative)");
| 57741 | cv::gapi::onnx::ep::CoreML* _self_ = (self1); |  | 57693 | cv::gapi::onnx::ep::CoreML* _self_ = (self1);
| 57742 | CoreML retval; |  | 57694 | CoreML retval;
| 57743 |  |  | 57695 |
| 57744 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57696 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57745 | { |  | 57697 | {
| 57746 | ERRWRAP2(retval = _self_->cfgEnableOnSubgraph()); |  | 57698 | ERRWRAP2(retval = _self_->cfgEnableOnSubgraph());
| 57747 | return pyopencv_from(retval); |  | 57699 | return pyopencv_from(retval);
| 57748 | } |  | 57700 | }
| 57749 |  |  | 57701 |
| 57750 | return NULL; |  | 57702 | return NULL;
| 57751 | } |  | 57703 | }
| 57752 |  |  | 57704 |
| 57753 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnlyNeuralEngine(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57705 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnlyNeuralEngine(PyObject* self, PyObject* py_args, PyObject* kw)
| 57754 | { |  | 57706 | {
| 57755 | using namespace cv::gapi::onnx::ep; |  | 57707 | using namespace cv::gapi::onnx::ep;
| 57756 |  |  | 57708 |
| 57757 |  |  | 57709 |
| 57758 | cv::gapi::onnx::ep::CoreML * self1 = 0; |  | 57710 | cv::gapi::onnx::ep::CoreML * self1 = 0;
| 57759 | if (!pyopencv_gapi_onnx_ep_CoreML_getp(self, self1)) |  | 57711 | if (!pyopencv_gapi_onnx_ep_CoreML_getp(self, self1))
| 57760 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_CoreML' or its derivative)"); |  | 57712 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_CoreML' or its derivative)");
| 57761 | cv::gapi::onnx::ep::CoreML* _self_ = (self1); |  | 57713 | cv::gapi::onnx::ep::CoreML* _self_ = (self1);
| 57762 | CoreML retval; |  | 57714 | CoreML retval;
| 57763 |  |  | 57715 |
| 57764 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57716 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57765 | { |  | 57717 | {
| 57766 | ERRWRAP2(retval = _self_->cfgEnableOnlyNeuralEngine()); |  | 57718 | ERRWRAP2(retval = _self_->cfgEnableOnlyNeuralEngine());
| 57767 | return pyopencv_from(retval); |  | 57719 | return pyopencv_from(retval);
| 57768 | } |  | 57720 | }
| 57769 |  |  | 57721 |
| 57770 | return NULL; |  | 57722 | return NULL;
| 57771 | } |  | 57723 | }
| 57772 |  |  | 57724 |
| 57773 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgUseCPUOnly(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57725 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgUseCPUOnly(PyObject* self, PyObject* py_args, PyObject* kw)
| 57774 | { |  | 57726 | {
| 57775 | using namespace cv::gapi::onnx::ep; |  | 57727 | using namespace cv::gapi::onnx::ep;
| 57776 |  |  | 57728 |
| 57777 |  |  | 57729 |
| 57778 | cv::gapi::onnx::ep::CoreML * self1 = 0; |  | 57730 | cv::gapi::onnx::ep::CoreML * self1 = 0;
| 57779 | if (!pyopencv_gapi_onnx_ep_CoreML_getp(self, self1)) |  | 57731 | if (!pyopencv_gapi_onnx_ep_CoreML_getp(self, self1))
| 57780 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_CoreML' or its derivative)"); |  | 57732 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_CoreML' or its derivative)");
| 57781 | cv::gapi::onnx::ep::CoreML* _self_ = (self1); |  | 57733 | cv::gapi::onnx::ep::CoreML* _self_ = (self1);
| 57782 | CoreML retval; |  | 57734 | CoreML retval;
| 57783 |  |  | 57735 |
| 57784 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57736 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57785 | { |  | 57737 | {
| 57786 | ERRWRAP2(retval = _self_->cfgUseCPUOnly()); |  | 57738 | ERRWRAP2(retval = _self_->cfgUseCPUOnly());
| 57787 | return pyopencv_from(retval); |  | 57739 | return pyopencv_from(retval);
| 57788 | } |  | 57740 | }
| 57789 |  |  | 57741 |
| 57790 | return NULL; |  | 57742 | return NULL;
| 57791 | } |  | 57743 | }
| 57792 |  |  | 57744 |
| 57793 |  |  | 57745 |
| 57794 |  |  | 57746 |
| 57795 | // Tables (gapi_onnx_ep_CoreML) |  | 57747 | // Tables (gapi_onnx_ep_CoreML)
| 57796 |  |  | 57748 |
| 57797 | static PyGetSetDef pyopencv_gapi_onnx_ep_CoreML_getseters[] = |  | 57749 | static PyGetSetDef pyopencv_gapi_onnx_ep_CoreML_getseters[] =
| 57798 | { |  | 57750 | {
| 57799 | {NULL} /* Sentinel */ |  | 57751 | {NULL} /* Sentinel */
| 57800 | }; |  | 57752 | };
| 57801 |  |  | 57753 |
| 57802 | static PyMethodDef pyopencv_gapi_onnx_ep_CoreML_methods[] = |  | 57754 | static PyMethodDef pyopencv_gapi_onnx_ep_CoreML_methods[] =
| 57803 | { |  | 57755 | {
| 57804 | {"cfgEnableOnSubgraph", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnSubgraph, 0), "cfgEnableOnSubgraph() -> retval\n. @brief Enable CoreML EP to run on a subgraph in the body of a control flow ONNX operator (i.e. a Loop, Scan or If operator).\n. \n. This function is used to enable CoreML EP to run on\n. a subgraph of a control flow of ONNX operation.\n. Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_enable_on_subgraph\n. \n. @return reference to this parameter structure."}, |  | 57756 | {"cfgEnableOnSubgraph", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnSubgraph, 0), "cfgEnableOnSubgraph() -> retval\n. @brief Enable CoreML EP to run on a subgraph in the body of a control flow ONNX operator (i.e. a Loop, Scan or If operator).\n. \n. This function is used to enable CoreML EP to run on\n. a subgraph of a control flow of ONNX operation.\n. Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_enable_on_subgraph\n. \n. @return reference to this parameter structure."},
| 57805 | {"cfgEnableOnlyNeuralEngine", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnlyNeuralEngine, 0), "cfgEnableOnlyNeuralEngine() -> retval\n. @brief Enable CoreML EP to run only on Apple Neural Engine.\n. \n. This function is used to enable CoreML EP to run only on Apple Neural Engine.\n. Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_only_enable_device_with_ane\n. \n. @return reference to this parameter structure."}, |  | 57757 | {"cfgEnableOnlyNeuralEngine", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgEnableOnlyNeuralEngine, 0), "cfgEnableOnlyNeuralEngine() -> retval\n. @brief Enable CoreML EP to run only on Apple Neural Engine.\n. \n. This function is used to enable CoreML EP to run only on Apple Neural Engine.\n. Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_only_enable_device_with_ane\n. \n. @return reference to this parameter structure."},
| 57806 | {"cfgUseCPUOnly", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgUseCPUOnly, 0), "cfgUseCPUOnly() -> retval\n. @brief Limit CoreML Execution Provider to run on CPU only.\n. \n. This function is used to limit CoreML to run on CPU only.\n. Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_use_cpu_only\n. \n. @return reference to this parameter structure."}, |  | 57758 | {"cfgUseCPUOnly", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_CoreML_cfgUseCPUOnly, 0), "cfgUseCPUOnly() -> retval\n. @brief Limit CoreML Execution Provider to run on CPU only.\n. \n. This function is used to limit CoreML to run on CPU only.\n. Please follow: https://onnxruntime.ai/docs/execution-providers/CoreML-ExecutionProvider.html#coreml_flag_use_cpu_only\n. \n. @return reference to this parameter structure."},
| 57807 |  |  | 57759 |
| 57808 | {NULL, NULL} |  | 57760 | {NULL, NULL}
| 57809 | }; |  | 57761 | };
| 57810 |  |  | 57762 |
| 57811 | // Converter (gapi_onnx_ep_CoreML) |  | 57763 | // Converter (gapi_onnx_ep_CoreML)
| 57812 |  |  | 57764 |
| 57813 | template<> |  | 57765 | template<>
| 57814 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::CoreML > |  | 57766 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::CoreML >
| 57815 | { |  | 57767 | {
| 57816 | static PyObject* from(const cv::gapi::onnx::ep::CoreML& r) |  | 57768 | static PyObject* from(const cv::gapi::onnx::ep::CoreML& r)
| 57817 | { |  | 57769 | {
| 57818 | return pyopencv_gapi_onnx_ep_CoreML_Instance(r); |  | 57770 | return pyopencv_gapi_onnx_ep_CoreML_Instance(r);
| 57819 | } |  | 57771 | }
| 57820 | static bool to(PyObject* src, cv::gapi::onnx::ep::CoreML& dst, const ArgInfo& info) |  | 57772 | static bool to(PyObject* src, cv::gapi::onnx::ep::CoreML& dst, const ArgInfo& info)
| 57821 | { |  | 57773 | {
| 57822 | if(!src || src == Py_None) |  | 57774 | if(!src || src == Py_None)
| 57823 | return true; |  | 57775 | return true;
| 57824 | cv::gapi::onnx::ep::CoreML * dst_; |  | 57776 | cv::gapi::onnx::ep::CoreML * dst_;
| 57825 | if (pyopencv_gapi_onnx_ep_CoreML_getp(src, dst_)) |  | 57777 | if (pyopencv_gapi_onnx_ep_CoreML_getp(src, dst_))
| 57826 | { |  | 57778 | {
| 57827 | dst = *dst_; |  | 57779 | dst = *dst_;
| 57828 | return true; |  | 57780 | return true;
| 57829 | } |  | 57781 | }
| 57830 |  |  | 57782 |
| 57831 | failmsg("Expected cv::gapi::onnx::ep::CoreML for argument '%s'", info.name); |  | 57783 | failmsg("Expected cv::gapi::onnx::ep::CoreML for argument '%s'", info.name);
| 57832 | return false; |  | 57784 | return false;
| 57833 | } |  | 57785 | }
| 57834 | }; |  | 57786 | };
| 57835 |  |  | 57787 |
| 57836 | //================================================================================ |  | 57788 | //================================================================================
| 57837 | // gapi_onnx_ep_DirectML (Generic) |  | 57789 | // gapi_onnx_ep_DirectML (Generic)
| 57838 | //================================================================================ |  | 57790 | //================================================================================
| 57839 |  |  | 57791 |
| 57840 | // GetSet (gapi_onnx_ep_DirectML) |  | 57792 | // GetSet (gapi_onnx_ep_DirectML)
| 57841 |  |  | 57793 |
| 57842 |  |  | 57794 |
| 57843 |  |  | 57795 |
| 57844 | // Methods (gapi_onnx_ep_DirectML) |  | 57796 | // Methods (gapi_onnx_ep_DirectML)
| 57845 |  |  | 57797 |
| 57846 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_DirectML_DirectML(pyopencv_gapi_onnx_ep_DirectML_t* self, PyObject* py_args, PyObject* kw) |  | 57798 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_DirectML_DirectML(pyopencv_gapi_onnx_ep_DirectML_t* self, PyObject* py_args, PyObject* kw)
| 57847 | { |  | 57799 | {
| 57848 | using namespace cv::gapi::onnx::ep; |  | 57800 | using namespace cv::gapi::onnx::ep;
| 57849 |  |  | 57801 |
| 57850 | pyPrepareArgumentConversionErrorsStorage(3); |  | 57802 | pyPrepareArgumentConversionErrorsStorage(3);
| 57851 |  |  | 57803 |
| 57852 | { |  | 57804 | {
| 57853 |  |  | 57805 |
| 57854 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57806 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57855 | { |  | 57807 | {
| 57856 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::DirectML()); |  | 57808 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::DirectML());
| 57857 | return 0; |  | 57809 | return 0;
| 57858 | } |  | 57810 | }
| 57859 |  |  | 57811 |
| 57860 |  |  | 57812 |
| 57861 | pyPopulateArgumentConversionErrors(); |  | 57813 | pyPopulateArgumentConversionErrors();
| 57862 | } |  | 57814 | }
| 57863 |  |  | 57815 |
| 57864 |  |  | 57816 |
| 57865 | { |  | 57817 | {
| 57866 | PyObject* pyobj_device_id = NULL; |  | 57818 | PyObject* pyobj_device_id = NULL;
| 57867 | int device_id=0; |  | 57819 | int device_id=0;
| 57868 |  |  | 57820 |
| 57869 | const char* keywords[] = { "device_id", NULL }; |  | 57821 | const char* keywords[] = { "device_id", NULL };
| 57870 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DirectML", (char**)keywords, &pyobj_device_id) && |  | 57822 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DirectML", (char**)keywords, &pyobj_device_id) &&
| 57871 | pyopencv_to_safe(pyobj_device_id, device_id, ArgInfo("device_id", 0)) ) |  | 57823 | pyopencv_to_safe(pyobj_device_id, device_id, ArgInfo("device_id", 0)) )
| 57872 | { |  | 57824 | {
| 57873 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::DirectML(device_id)); |  | 57825 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::DirectML(device_id));
| 57874 | return 0; |  | 57826 | return 0;
| 57875 | } |  | 57827 | }
| 57876 |  |  | 57828 |
| 57877 |  |  | 57829 |
| 57878 | pyPopulateArgumentConversionErrors(); |  | 57830 | pyPopulateArgumentConversionErrors();
| 57879 | } |  | 57831 | }
| 57880 |  |  | 57832 |
| 57881 |  |  | 57833 |
| 57882 | { |  | 57834 | {
| 57883 | PyObject* pyobj_adapter_name = NULL; |  | 57835 | PyObject* pyobj_adapter_name = NULL;
| 57884 | std::string adapter_name; |  | 57836 | std::string adapter_name;
| 57885 |  |  | 57837 |
| 57886 | const char* keywords[] = { "adapter_name", NULL }; |  | 57838 | const char* keywords[] = { "adapter_name", NULL };
| 57887 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DirectML", (char**)keywords, &pyobj_adapter_name) && |  | 57839 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:DirectML", (char**)keywords, &pyobj_adapter_name) &&
| 57888 | pyopencv_to_safe(pyobj_adapter_name, adapter_name, ArgInfo("adapter_name", 0)) ) |  | 57840 | pyopencv_to_safe(pyobj_adapter_name, adapter_name, ArgInfo("adapter_name", 0)) )
| 57889 | { |  | 57841 | {
| 57890 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::DirectML(adapter_name)); |  | 57842 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::DirectML(adapter_name));
| 57891 | return 0; |  | 57843 | return 0;
| 57892 | } |  | 57844 | }
| 57893 |  |  | 57845 |
| 57894 |  |  | 57846 |
| 57895 | pyPopulateArgumentConversionErrors(); |  | 57847 | pyPopulateArgumentConversionErrors();
| 57896 | } |  | 57848 | }
| 57897 | pyRaiseCVOverloadException("DirectML"); |  | 57849 | pyRaiseCVOverloadException("DirectML");
| 57898 |  |  | 57850 |
| 57899 | return -1; |  | 57851 | return -1;
| 57900 | } |  | 57852 | }
| 57901 |  |  | 57853 |
| 57902 |  |  | 57854 |
| 57903 |  |  | 57855 |
| 57904 | // Tables (gapi_onnx_ep_DirectML) |  | 57856 | // Tables (gapi_onnx_ep_DirectML)
| 57905 |  |  | 57857 |
| 57906 | static PyGetSetDef pyopencv_gapi_onnx_ep_DirectML_getseters[] = |  | 57858 | static PyGetSetDef pyopencv_gapi_onnx_ep_DirectML_getseters[] =
| 57907 | { |  | 57859 | {
| 57908 | {NULL} /* Sentinel */ |  | 57860 | {NULL} /* Sentinel */
| 57909 | }; |  | 57861 | };
| 57910 |  |  | 57862 |
| 57911 | static PyMethodDef pyopencv_gapi_onnx_ep_DirectML_methods[] = |  | 57863 | static PyMethodDef pyopencv_gapi_onnx_ep_DirectML_methods[] =
| 57912 | { |  | 57864 | {
| 57913 |  |  | 57865 |
| 57914 | {NULL, NULL} |  | 57866 | {NULL, NULL}
| 57915 | }; |  | 57867 | };
| 57916 |  |  | 57868 |
| 57917 | // Converter (gapi_onnx_ep_DirectML) |  | 57869 | // Converter (gapi_onnx_ep_DirectML)
| 57918 |  |  | 57870 |
| 57919 | template<> |  | 57871 | template<>
| 57920 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::DirectML > |  | 57872 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::DirectML >
| 57921 | { |  | 57873 | {
| 57922 | static PyObject* from(const cv::gapi::onnx::ep::DirectML& r) |  | 57874 | static PyObject* from(const cv::gapi::onnx::ep::DirectML& r)
| 57923 | { |  | 57875 | {
| 57924 | return pyopencv_gapi_onnx_ep_DirectML_Instance(r); |  | 57876 | return pyopencv_gapi_onnx_ep_DirectML_Instance(r);
| 57925 | } |  | 57877 | }
| 57926 | static bool to(PyObject* src, cv::gapi::onnx::ep::DirectML& dst, const ArgInfo& info) |  | 57878 | static bool to(PyObject* src, cv::gapi::onnx::ep::DirectML& dst, const ArgInfo& info)
| 57927 | { |  | 57879 | {
| 57928 | if(!src || src == Py_None) |  | 57880 | if(!src || src == Py_None)
| 57929 | return true; |  | 57881 | return true;
| 57930 | cv::gapi::onnx::ep::DirectML * dst_; |  | 57882 | cv::gapi::onnx::ep::DirectML * dst_;
| 57931 | if (pyopencv_gapi_onnx_ep_DirectML_getp(src, dst_)) |  | 57883 | if (pyopencv_gapi_onnx_ep_DirectML_getp(src, dst_))
| 57932 | { |  | 57884 | {
| 57933 | dst = *dst_; |  | 57885 | dst = *dst_;
| 57934 | return true; |  | 57886 | return true;
| 57935 | } |  | 57887 | }
| 57936 |  |  | 57888 |
| 57937 | failmsg("Expected cv::gapi::onnx::ep::DirectML for argument '%s'", info.name); |  | 57889 | failmsg("Expected cv::gapi::onnx::ep::DirectML for argument '%s'", info.name);
| 57938 | return false; |  | 57890 | return false;
| 57939 | } |  | 57891 | }
| 57940 | }; |  | 57892 | };
| 57941 |  |  | 57893 |
| 57942 | //================================================================================ |  | 57894 | //================================================================================
| 57943 | // gapi_onnx_ep_OpenVINO (Generic) |  | 57895 | // gapi_onnx_ep_OpenVINO (Generic)
| 57944 | //================================================================================ |  | 57896 | //================================================================================
| 57945 |  |  | 57897 |
| 57946 | // GetSet (gapi_onnx_ep_OpenVINO) |  | 57898 | // GetSet (gapi_onnx_ep_OpenVINO)
| 57947 |  |  | 57899 |
| 57948 |  |  | 57900 |
| 57949 |  |  | 57901 |
| 57950 | // Methods (gapi_onnx_ep_OpenVINO) |  | 57902 | // Methods (gapi_onnx_ep_OpenVINO)
| 57951 |  |  | 57903 |
| 57952 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_OpenVINO(pyopencv_gapi_onnx_ep_OpenVINO_t* self, PyObject* py_args, PyObject* kw) |  | 57904 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_OpenVINO(pyopencv_gapi_onnx_ep_OpenVINO_t* self, PyObject* py_args, PyObject* kw)
| 57953 | { |  | 57905 | {
| 57954 | using namespace cv::gapi::onnx::ep; |  | 57906 | using namespace cv::gapi::onnx::ep;
| 57955 |  |  | 57907 |
| 57956 | pyPrepareArgumentConversionErrorsStorage(3); |  | 57908 | pyPrepareArgumentConversionErrorsStorage(3);
| 57957 |  |  | 57909 |
| 57958 | { |  | 57910 | {
| 57959 |  |  | 57911 |
| 57960 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57912 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 57961 | { |  | 57913 | {
| 57962 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::OpenVINO()); |  | 57914 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::OpenVINO());
| 57963 | return 0; |  | 57915 | return 0;
| 57964 | } |  | 57916 | }
| 57965 |  |  | 57917 |
| 57966 |  |  | 57918 |
| 57967 | pyPopulateArgumentConversionErrors(); |  | 57919 | pyPopulateArgumentConversionErrors();
| 57968 | } |  | 57920 | }
| 57969 |  |  | 57921 |
| 57970 |  |  | 57922 |
| 57971 | { |  | 57923 | {
| 57972 | PyObject* pyobj_dev_type = NULL; |  | 57924 | PyObject* pyobj_dev_type = NULL;
| 57973 | std::string dev_type; |  | 57925 | std::string dev_type;
| 57974 |  |  | 57926 |
| 57975 | const char* keywords[] = { "dev_type", NULL }; |  | 57927 | const char* keywords[] = { "dev_type", NULL };
| 57976 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:OpenVINO", (char**)keywords, &pyobj_dev_type) && |  | 57928 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:OpenVINO", (char**)keywords, &pyobj_dev_type) &&
| 57977 | pyopencv_to_safe(pyobj_dev_type, dev_type, ArgInfo("dev_type", 0)) ) |  | 57929 | pyopencv_to_safe(pyobj_dev_type, dev_type, ArgInfo("dev_type", 0)) )
| 57978 | { |  | 57930 | {
| 57979 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::OpenVINO(dev_type)); |  | 57931 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::OpenVINO(dev_type));
| 57980 | return 0; |  | 57932 | return 0;
| 57981 | } |  | 57933 | }
| 57982 |  |  | 57934 |
| 57983 |  |  | 57935 |
| 57984 | pyPopulateArgumentConversionErrors(); |  | 57936 | pyPopulateArgumentConversionErrors();
| 57985 | } |  | 57937 | }
| 57986 |  |  | 57938 |
| 57987 |  |  | 57939 |
| 57988 | { |  | 57940 | {
| 57989 | PyObject* pyobj_params = NULL; |  | 57941 | PyObject* pyobj_params = NULL;
| 57990 | map_string_and_string params; |  | 57942 | map_string_and_string params;
| 57991 |  |  | 57943 |
| 57992 | const char* keywords[] = { "params", NULL }; |  | 57944 | const char* keywords[] = { "params", NULL };
| 57993 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:OpenVINO", (char**)keywords, &pyobj_params) && |  | 57945 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:OpenVINO", (char**)keywords, &pyobj_params) &&
| 57994 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 57946 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 57995 | { |  | 57947 | {
| 57996 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::OpenVINO(params)); |  | 57948 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::OpenVINO(params));
| 57997 | return 0; |  | 57949 | return 0;
| 57998 | } |  | 57950 | }
| 57999 |  |  | 57951 |
| 58000 |  |  | 57952 |
| 58001 | pyPopulateArgumentConversionErrors(); |  | 57953 | pyPopulateArgumentConversionErrors();
| 58002 | } |  | 57954 | }
| 58003 | pyRaiseCVOverloadException("OpenVINO"); |  | 57955 | pyRaiseCVOverloadException("OpenVINO");
| 58004 |  |  | 57956 |
| 58005 | return -1; |  | 57957 | return -1;
| 58006 | } |  | 57958 | }
| 58007 |  |  | 57959 |
| 58008 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgCacheDir(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57960 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgCacheDir(PyObject* self, PyObject* py_args, PyObject* kw)
| 58009 | { |  | 57961 | {
| 58010 | using namespace cv::gapi::onnx::ep; |  | 57962 | using namespace cv::gapi::onnx::ep;
| 58011 |  |  | 57963 |
| 58012 |  |  | 57964 |
| 58013 | cv::gapi::onnx::ep::OpenVINO * self1 = 0; |  | 57965 | cv::gapi::onnx::ep::OpenVINO * self1 = 0;
| 58014 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1)) |  | 57966 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1))
| 58015 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)"); |  | 57967 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)");
| 58016 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1); |  | 57968 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1);
| 58017 | PyObject* pyobj_dir = NULL; |  | 57969 | PyObject* pyobj_dir = NULL;
| 58018 | std::string dir; |  | 57970 | std::string dir;
| 58019 | OpenVINO retval; |  | 57971 | OpenVINO retval;
| 58020 |  |  | 57972 |
| 58021 | const char* keywords[] = { "dir", NULL }; |  | 57973 | const char* keywords[] = { "dir", NULL };
| 58022 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_ep_OpenVINO.cfgCacheDir", (char**)keywords, &pyobj_dir) && |  | 57974 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_ep_OpenVINO.cfgCacheDir", (char**)keywords, &pyobj_dir) &&
| 58023 | pyopencv_to_safe(pyobj_dir, dir, ArgInfo("dir", 0)) ) |  | 57975 | pyopencv_to_safe(pyobj_dir, dir, ArgInfo("dir", 0)) )
| 58024 | { |  | 57976 | {
| 58025 | ERRWRAP2(retval = _self_->cfgCacheDir(dir)); |  | 57977 | ERRWRAP2(retval = _self_->cfgCacheDir(dir));
| 58026 | return pyopencv_from(retval); |  | 57978 | return pyopencv_from(retval);
| 58027 | } |  | 57979 | }
| 58028 |  |  | 57980 |
| 58029 | return NULL; |  | 57981 | return NULL;
| 58030 | } |  | 57982 | }
| 58031 |  |  | 57983 |
| 58032 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableDynamicShapes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 57984 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableDynamicShapes(PyObject* self, PyObject* py_args, PyObject* kw)
| 58033 | { |  | 57985 | {
| 58034 | using namespace cv::gapi::onnx::ep; |  | 57986 | using namespace cv::gapi::onnx::ep;
| 58035 |  |  | 57987 |
| 58036 |  |  | 57988 |
| 58037 | cv::gapi::onnx::ep::OpenVINO * self1 = 0; |  | 57989 | cv::gapi::onnx::ep::OpenVINO * self1 = 0;
| 58038 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1)) |  | 57990 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1))
| 58039 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)"); |  | 57991 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)");
| 58040 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1); |  | 57992 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1);
| 58041 | OpenVINO retval; |  | 57993 | OpenVINO retval;
| 58042 |  |  | 57994 |
| 58043 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 57995 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 58044 | { |  | 57996 | {
| 58045 | ERRWRAP2(retval = _self_->cfgEnableDynamicShapes()); |  | 57997 | ERRWRAP2(retval = _self_->cfgEnableDynamicShapes());
| 58046 | return pyopencv_from(retval); |  | 57998 | return pyopencv_from(retval);
| 58047 | } |  | 57999 | }
| 58048 |  |  | 58000 |
| 58049 | return NULL; |  | 58001 | return NULL;
| 58050 | } |  | 58002 | }
| 58051 |  |  | 58003 |
| 58052 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableOpenCLThrottling(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58004 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableOpenCLThrottling(PyObject* self, PyObject* py_args, PyObject* kw)
| 58053 | { |  | 58005 | {
| 58054 | using namespace cv::gapi::onnx::ep; |  | 58006 | using namespace cv::gapi::onnx::ep;
| 58055 |  |  | 58007 |
| 58056 |  |  | 58008 |
| 58057 | cv::gapi::onnx::ep::OpenVINO * self1 = 0; |  | 58009 | cv::gapi::onnx::ep::OpenVINO * self1 = 0;
| 58058 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1)) |  | 58010 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1))
| 58059 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)"); |  | 58011 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)");
| 58060 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1); |  | 58012 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1);
| 58061 | OpenVINO retval; |  | 58013 | OpenVINO retval;
| 58062 |  |  | 58014 |
| 58063 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 58015 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 58064 | { |  | 58016 | {
| 58065 | ERRWRAP2(retval = _self_->cfgEnableOpenCLThrottling()); |  | 58017 | ERRWRAP2(retval = _self_->cfgEnableOpenCLThrottling());
| 58066 | return pyopencv_from(retval); |  | 58018 | return pyopencv_from(retval);
| 58067 | } |  | 58019 | }
| 58068 |  |  | 58020 |
| 58069 | return NULL; |  | 58021 | return NULL;
| 58070 | } |  | 58022 | }
| 58071 |  |  | 58023 |
| 58072 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgNumThreads(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58024 | static PyObject* pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgNumThreads(PyObject* self, PyObject* py_args, PyObject* kw)
| 58073 | { |  | 58025 | {
| 58074 | using namespace cv::gapi::onnx::ep; |  | 58026 | using namespace cv::gapi::onnx::ep;
| 58075 |  |  | 58027 |
| 58076 |  |  | 58028 |
| 58077 | cv::gapi::onnx::ep::OpenVINO * self1 = 0; |  | 58029 | cv::gapi::onnx::ep::OpenVINO * self1 = 0;
| 58078 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1)) |  | 58030 | if (!pyopencv_gapi_onnx_ep_OpenVINO_getp(self, self1))
| 58079 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)"); |  | 58031 | return failmsgp("Incorrect type of self (must be 'gapi_onnx_ep_OpenVINO' or its derivative)");
| 58080 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1); |  | 58032 | cv::gapi::onnx::ep::OpenVINO* _self_ = (self1);
| 58081 | PyObject* pyobj_nthreads = NULL; |  | 58033 | PyObject* pyobj_nthreads = NULL;
| 58082 | size_t nthreads=0; |  | 58034 | size_t nthreads=0;
| 58083 | OpenVINO retval; |  | 58035 | OpenVINO retval;
| 58084 |  |  | 58036 |
| 58085 | const char* keywords[] = { "nthreads", NULL }; |  | 58037 | const char* keywords[] = { "nthreads", NULL };
| 58086 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_ep_OpenVINO.cfgNumThreads", (char**)keywords, &pyobj_nthreads) && |  | 58038 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_onnx_ep_OpenVINO.cfgNumThreads", (char**)keywords, &pyobj_nthreads) &&
| 58087 | pyopencv_to_safe(pyobj_nthreads, nthreads, ArgInfo("nthreads", 0)) ) |  | 58039 | pyopencv_to_safe(pyobj_nthreads, nthreads, ArgInfo("nthreads", 0)) )
| 58088 | { |  | 58040 | {
| 58089 | ERRWRAP2(retval = _self_->cfgNumThreads(nthreads)); |  | 58041 | ERRWRAP2(retval = _self_->cfgNumThreads(nthreads));
| 58090 | return pyopencv_from(retval); |  | 58042 | return pyopencv_from(retval);
| 58091 | } |  | 58043 | }
| 58092 |  |  | 58044 |
| 58093 | return NULL; |  | 58045 | return NULL;
| 58094 | } |  | 58046 | }
| 58095 |  |  | 58047 |
| 58096 |  |  | 58048 |
| 58097 |  |  | 58049 |
| 58098 | // Tables (gapi_onnx_ep_OpenVINO) |  | 58050 | // Tables (gapi_onnx_ep_OpenVINO)
| 58099 |  |  | 58051 |
| 58100 | static PyGetSetDef pyopencv_gapi_onnx_ep_OpenVINO_getseters[] = |  | 58052 | static PyGetSetDef pyopencv_gapi_onnx_ep_OpenVINO_getseters[] =
| 58101 | { |  | 58053 | {
| 58102 | {NULL} /* Sentinel */ |  | 58054 | {NULL} /* Sentinel */
| 58103 | }; |  | 58055 | };
| 58104 |  |  | 58056 |
| 58105 | static PyMethodDef pyopencv_gapi_onnx_ep_OpenVINO_methods[] = |  | 58057 | static PyMethodDef pyopencv_gapi_onnx_ep_OpenVINO_methods[] =
| 58106 | { |  | 58058 | {
| 58107 | {"cfgCacheDir", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgCacheDir, 0), "cfgCacheDir(dir) -> retval\n. @brief Specifies OpenVINO Execution Provider cache dir.\n. \n. This function is used to explicitly specify the path to save and load\n. the blobs enabling model caching feature.\n. \n. @param dir Path to the directory what will be used as cache.\n. @return reference to this parameter structure."}, |  | 58059 | {"cfgCacheDir", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgCacheDir, 0), "cfgCacheDir(dir) -> retval\n. @brief Specifies OpenVINO Execution Provider cache dir.\n. \n. This function is used to explicitly specify the path to save and load\n. the blobs enabling model caching feature.\n. \n. @param dir Path to the directory what will be used as cache.\n. @return reference to this parameter structure."},
| 58108 | {"cfgEnableDynamicShapes", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableDynamicShapes, 0), "cfgEnableDynamicShapes() -> retval\n. @brief Enables OpenVINO Execution Provider dynamic shapes.\n. \n. This function is used to enable OpenCL queue throttling for GPU devices\n. (reduces CPU utilization when using GPU).\n. This function is used to enable work with dynamic shaped models\n. whose shape will be set dynamically based on the infer input\n. image/data shape at run time in CPU.\n. \n. @return reference to this parameter structure."}, |  | 58060 | {"cfgEnableDynamicShapes", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableDynamicShapes, 0), "cfgEnableDynamicShapes() -> retval\n. @brief Enables OpenVINO Execution Provider dynamic shapes.\n. \n. This function is used to enable OpenCL queue throttling for GPU devices\n. (reduces CPU utilization when using GPU).\n. This function is used to enable work with dynamic shaped models\n. whose shape will be set dynamically based on the infer input\n. image/data shape at run time in CPU.\n. \n. @return reference to this parameter structure."},
| 58109 | {"cfgEnableOpenCLThrottling", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableOpenCLThrottling, 0), "cfgEnableOpenCLThrottling() -> retval\n. @brief Enables OpenVINO Execution Provider opencl throttling.\n. \n. This function is used to enable OpenCL queue throttling for GPU devices\n. (reduces CPU utilization when using GPU).\n. \n. @return reference to this parameter structure."}, |  | 58061 | {"cfgEnableOpenCLThrottling", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgEnableOpenCLThrottling, 0), "cfgEnableOpenCLThrottling() -> retval\n. @brief Enables OpenVINO Execution Provider opencl throttling.\n. \n. This function is used to enable OpenCL queue throttling for GPU devices\n. (reduces CPU utilization when using GPU).\n. \n. @return reference to this parameter structure."},
| 58110 | {"cfgNumThreads", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgNumThreads, 0), "cfgNumThreads(nthreads) -> retval\n. @brief Specifies OpenVINO Execution Provider number of threads.\n. \n. This function is used to override the accelerator default value\n. of number of threads with this value at runtime.\n. \n. @param nthreads Number of threads.\n. @return reference to this parameter structure."}, |  | 58062 | {"cfgNumThreads", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_OpenVINO_cfgNumThreads, 0), "cfgNumThreads(nthreads) -> retval\n. @brief Specifies OpenVINO Execution Provider number of threads.\n. \n. This function is used to override the accelerator default value\n. of number of threads with this value at runtime.\n. \n. @param nthreads Number of threads.\n. @return reference to this parameter structure."},
| 58111 |  |  | 58063 |
| 58112 | {NULL, NULL} |  | 58064 | {NULL, NULL}
| 58113 | }; |  | 58065 | };
| 58114 |  |  | 58066 |
| 58115 | // Converter (gapi_onnx_ep_OpenVINO) |  | 58067 | // Converter (gapi_onnx_ep_OpenVINO)
| 58116 |  |  | 58068 |
| 58117 | template<> |  | 58069 | template<>
| 58118 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::OpenVINO > |  | 58070 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::OpenVINO >
| 58119 | { |  | 58071 | {
| 58120 | static PyObject* from(const cv::gapi::onnx::ep::OpenVINO& r) |  | 58072 | static PyObject* from(const cv::gapi::onnx::ep::OpenVINO& r)
| 58121 | { |  | 58073 | {
| 58122 | return pyopencv_gapi_onnx_ep_OpenVINO_Instance(r); |  | 58074 | return pyopencv_gapi_onnx_ep_OpenVINO_Instance(r);
| 58123 | } |  | 58075 | }
| 58124 | static bool to(PyObject* src, cv::gapi::onnx::ep::OpenVINO& dst, const ArgInfo& info) |  | 58076 | static bool to(PyObject* src, cv::gapi::onnx::ep::OpenVINO& dst, const ArgInfo& info)
| 58125 | { |  | 58077 | {
| 58126 | if(!src || src == Py_None) |  | 58078 | if(!src || src == Py_None)
| 58127 | return true; |  | 58079 | return true;
| 58128 | cv::gapi::onnx::ep::OpenVINO * dst_; |  | 58080 | cv::gapi::onnx::ep::OpenVINO * dst_;
| 58129 | if (pyopencv_gapi_onnx_ep_OpenVINO_getp(src, dst_)) |  | 58081 | if (pyopencv_gapi_onnx_ep_OpenVINO_getp(src, dst_))
| 58130 | { |  | 58082 | {
| 58131 | dst = *dst_; |  | 58083 | dst = *dst_;
| 58132 | return true; |  | 58084 | return true;
| 58133 | } |  | 58085 | }
| 58134 |  |  | 58086 |
| 58135 | failmsg("Expected cv::gapi::onnx::ep::OpenVINO for argument '%s'", info.name); |  | 58087 | failmsg("Expected cv::gapi::onnx::ep::OpenVINO for argument '%s'", info.name);
| 58136 | return false; |  | 58088 | return false;
| 58137 | } |  | 58089 | }
| 58138 | }; |  | 58090 | };
| 58139 |  |  | 58091 |
| 58140 | //================================================================================ |  | 58092 | //================================================================================
| 58141 | // gapi_onnx_ep_TensorRT (Generic) |  | 58093 | // gapi_onnx_ep_TensorRT (Generic)
| 58142 | //================================================================================ |  | 58094 | //================================================================================
| 58143 |  |  | 58095 |
| 58144 | // GetSet (gapi_onnx_ep_TensorRT) |  | 58096 | // GetSet (gapi_onnx_ep_TensorRT)
| 58145 |  |  | 58097 |
| 58146 |  |  | 58098 |
| 58147 |  |  | 58099 |
| 58148 | // Methods (gapi_onnx_ep_TensorRT) |  | 58100 | // Methods (gapi_onnx_ep_TensorRT)
| 58149 |  |  | 58101 |
| 58150 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_TensorRT_TensorRT(pyopencv_gapi_onnx_ep_TensorRT_t* self, PyObject* py_args, PyObject* kw) |  | 58102 | static int pyopencv_cv_gapi_onnx_ep_gapi_onnx_ep_TensorRT_TensorRT(pyopencv_gapi_onnx_ep_TensorRT_t* self, PyObject* py_args, PyObject* kw)
| 58151 | { |  | 58103 | {
| 58152 | using namespace cv::gapi::onnx::ep; |  | 58104 | using namespace cv::gapi::onnx::ep;
| 58153 |  |  | 58105 |
| 58154 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58106 | pyPrepareArgumentConversionErrorsStorage(2);
| 58155 |  |  | 58107 |
| 58156 | { |  | 58108 | {
| 58157 |  |  | 58109 |
| 58158 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 58110 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 58159 | { |  | 58111 | {
| 58160 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::TensorRT()); |  | 58112 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::TensorRT());
| 58161 | return 0; |  | 58113 | return 0;
| 58162 | } |  | 58114 | }
| 58163 |  |  | 58115 |
| 58164 |  |  | 58116 |
| 58165 | pyPopulateArgumentConversionErrors(); |  | 58117 | pyPopulateArgumentConversionErrors();
| 58166 | } |  | 58118 | }
| 58167 |  |  | 58119 |
| 58168 |  |  | 58120 |
| 58169 | { |  | 58121 | {
| 58170 | PyObject* pyobj_dev_id = NULL; |  | 58122 | PyObject* pyobj_dev_id = NULL;
| 58171 | int dev_id=0; |  | 58123 | int dev_id=0;
| 58172 |  |  | 58124 |
| 58173 | const char* keywords[] = { "dev_id", NULL }; |  | 58125 | const char* keywords[] = { "dev_id", NULL };
| 58174 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TensorRT", (char**)keywords, &pyobj_dev_id) && |  | 58126 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:TensorRT", (char**)keywords, &pyobj_dev_id) &&
| 58175 | pyopencv_to_safe(pyobj_dev_id, dev_id, ArgInfo("dev_id", 0)) ) |  | 58127 | pyopencv_to_safe(pyobj_dev_id, dev_id, ArgInfo("dev_id", 0)) )
| 58176 | { |  | 58128 | {
| 58177 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::TensorRT(dev_id)); |  | 58129 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::onnx::ep::TensorRT(dev_id));
| 58178 | return 0; |  | 58130 | return 0;
| 58179 | } |  | 58131 | }
| 58180 |  |  | 58132 |
| 58181 |  |  | 58133 |
| 58182 | pyPopulateArgumentConversionErrors(); |  | 58134 | pyPopulateArgumentConversionErrors();
| 58183 | } |  | 58135 | }
| 58184 | pyRaiseCVOverloadException("TensorRT"); |  | 58136 | pyRaiseCVOverloadException("TensorRT");
| 58185 |  |  | 58137 |
| 58186 | return -1; |  | 58138 | return -1;
| 58187 | } |  | 58139 | }
| 58188 |  |  | 58140 |
| 58189 |  |  | 58141 |
| 58190 |  |  | 58142 |
| 58191 | // Tables (gapi_onnx_ep_TensorRT) |  | 58143 | // Tables (gapi_onnx_ep_TensorRT)
| 58192 |  |  | 58144 |
| 58193 | static PyGetSetDef pyopencv_gapi_onnx_ep_TensorRT_getseters[] = |  | 58145 | static PyGetSetDef pyopencv_gapi_onnx_ep_TensorRT_getseters[] =
| 58194 | { |  | 58146 | {
| 58195 | {NULL} /* Sentinel */ |  | 58147 | {NULL} /* Sentinel */
| 58196 | }; |  | 58148 | };
| 58197 |  |  | 58149 |
| 58198 | static PyMethodDef pyopencv_gapi_onnx_ep_TensorRT_methods[] = |  | 58150 | static PyMethodDef pyopencv_gapi_onnx_ep_TensorRT_methods[] =
| 58199 | { |  | 58151 | {
| 58200 |  |  | 58152 |
| 58201 | {NULL, NULL} |  | 58153 | {NULL, NULL}
| 58202 | }; |  | 58154 | };
| 58203 |  |  | 58155 |
| 58204 | // Converter (gapi_onnx_ep_TensorRT) |  | 58156 | // Converter (gapi_onnx_ep_TensorRT)
| 58205 |  |  | 58157 |
| 58206 | template<> |  | 58158 | template<>
| 58207 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::TensorRT > |  | 58159 | struct PyOpenCV_Converter< cv::gapi::onnx::ep::TensorRT >
| 58208 | { |  | 58160 | {
| 58209 | static PyObject* from(const cv::gapi::onnx::ep::TensorRT& r) |  | 58161 | static PyObject* from(const cv::gapi::onnx::ep::TensorRT& r)
| 58210 | { |  | 58162 | {
| 58211 | return pyopencv_gapi_onnx_ep_TensorRT_Instance(r); |  | 58163 | return pyopencv_gapi_onnx_ep_TensorRT_Instance(r);
| 58212 | } |  | 58164 | }
| 58213 | static bool to(PyObject* src, cv::gapi::onnx::ep::TensorRT& dst, const ArgInfo& info) |  | 58165 | static bool to(PyObject* src, cv::gapi::onnx::ep::TensorRT& dst, const ArgInfo& info)
| 58214 | { |  | 58166 | {
| 58215 | if(!src || src == Py_None) |  | 58167 | if(!src || src == Py_None)
| 58216 | return true; |  | 58168 | return true;
| 58217 | cv::gapi::onnx::ep::TensorRT * dst_; |  | 58169 | cv::gapi::onnx::ep::TensorRT * dst_;
| 58218 | if (pyopencv_gapi_onnx_ep_TensorRT_getp(src, dst_)) |  | 58170 | if (pyopencv_gapi_onnx_ep_TensorRT_getp(src, dst_))
| 58219 | { |  | 58171 | {
| 58220 | dst = *dst_; |  | 58172 | dst = *dst_;
| 58221 | return true; |  | 58173 | return true;
| 58222 | } |  | 58174 | }
| 58223 |  |  | 58175 |
| 58224 | failmsg("Expected cv::gapi::onnx::ep::TensorRT for argument '%s'", info.name); |  | 58176 | failmsg("Expected cv::gapi::onnx::ep::TensorRT for argument '%s'", info.name);
| 58225 | return false; |  | 58177 | return false;
| 58226 | } |  | 58178 | }
| 58227 | }; |  | 58179 | };
| 58228 |  |  | 58180 |
| 58229 | //================================================================================ |  | 58181 | //================================================================================
| 58230 | // gapi_ot_ObjectTrackerParams (Generic) |  | 58182 | // gapi_ot_ObjectTrackerParams (Generic)
| 58231 | //================================================================================ |  | 58183 | //================================================================================
| 58232 |  |  | 58184 |
| 58233 | // GetSet (gapi_ot_ObjectTrackerParams) |  | 58185 | // GetSet (gapi_ot_ObjectTrackerParams)
| 58234 |  |  | 58186 |
| 58235 |  |  | 58187 |
| 58236 | static PyObject* pyopencv_gapi_ot_ObjectTrackerParams_get_input_image_format(pyopencv_gapi_ot_ObjectTrackerParams_t* p, void *closure) |  | 58188 | static PyObject* pyopencv_gapi_ot_ObjectTrackerParams_get_input_image_format(pyopencv_gapi_ot_ObjectTrackerParams_t* p, void *closure)
| 58237 | { |  | 58189 | {
| 58238 | return pyopencv_from(p->v.input_image_format); |  | 58190 | return pyopencv_from(p->v.input_image_format);
| 58239 | } |  | 58191 | }
| 58240 |  |  | 58192 |
| 58241 | static int pyopencv_gapi_ot_ObjectTrackerParams_set_input_image_format(pyopencv_gapi_ot_ObjectTrackerParams_t* p, PyObject *value, void *closure) |  | 58193 | static int pyopencv_gapi_ot_ObjectTrackerParams_set_input_image_format(pyopencv_gapi_ot_ObjectTrackerParams_t* p, PyObject *value, void *closure)
| 58242 | { |  | 58194 | {
| 58243 | if (!value) |  | 58195 | if (!value)
| 58244 | { |  | 58196 | {
| 58245 | PyErr_SetString(PyExc_TypeError, "Cannot delete the input_image_format attribute"); |  | 58197 | PyErr_SetString(PyExc_TypeError, "Cannot delete the input_image_format attribute");
| 58246 | return -1; |  | 58198 | return -1;
| 58247 | } |  | 58199 | }
| 58248 | return pyopencv_to_safe(value, p->v.input_image_format, ArgInfo("value", 0)) ? 0 : -1; |  | 58200 | return pyopencv_to_safe(value, p->v.input_image_format, ArgInfo("value", 0)) ? 0 : -1;
| 58249 | } |  | 58201 | }
| 58250 |  |  | 58202 |
| 58251 | static PyObject* pyopencv_gapi_ot_ObjectTrackerParams_get_max_num_objects(pyopencv_gapi_ot_ObjectTrackerParams_t* p, void *closure) |  | 58203 | static PyObject* pyopencv_gapi_ot_ObjectTrackerParams_get_max_num_objects(pyopencv_gapi_ot_ObjectTrackerParams_t* p, void *closure)
| 58252 | { |  | 58204 | {
| 58253 | return pyopencv_from(p->v.max_num_objects); |  | 58205 | return pyopencv_from(p->v.max_num_objects);
| 58254 | } |  | 58206 | }
| 58255 |  |  | 58207 |
| 58256 | static int pyopencv_gapi_ot_ObjectTrackerParams_set_max_num_objects(pyopencv_gapi_ot_ObjectTrackerParams_t* p, PyObject *value, void *closure) |  | 58208 | static int pyopencv_gapi_ot_ObjectTrackerParams_set_max_num_objects(pyopencv_gapi_ot_ObjectTrackerParams_t* p, PyObject *value, void *closure)
| 58257 | { |  | 58209 | {
| 58258 | if (!value) |  | 58210 | if (!value)
| 58259 | { |  | 58211 | {
| 58260 | PyErr_SetString(PyExc_TypeError, "Cannot delete the max_num_objects attribute"); |  | 58212 | PyErr_SetString(PyExc_TypeError, "Cannot delete the max_num_objects attribute");
| 58261 | return -1; |  | 58213 | return -1;
| 58262 | } |  | 58214 | }
| 58263 | return pyopencv_to_safe(value, p->v.max_num_objects, ArgInfo("value", 0)) ? 0 : -1; |  | 58215 | return pyopencv_to_safe(value, p->v.max_num_objects, ArgInfo("value", 0)) ? 0 : -1;
| 58264 | } |  | 58216 | }
| 58265 |  |  | 58217 |
| 58266 | static PyObject* pyopencv_gapi_ot_ObjectTrackerParams_get_tracking_per_class(pyopencv_gapi_ot_ObjectTrackerParams_t* p, void *closure) |  | 58218 | static PyObject* pyopencv_gapi_ot_ObjectTrackerParams_get_tracking_per_class(pyopencv_gapi_ot_ObjectTrackerParams_t* p, void *closure)
| 58267 | { |  | 58219 | {
| 58268 | return pyopencv_from(p->v.tracking_per_class); |  | 58220 | return pyopencv_from(p->v.tracking_per_class);
| 58269 | } |  | 58221 | }
| 58270 |  |  | 58222 |
| 58271 | static int pyopencv_gapi_ot_ObjectTrackerParams_set_tracking_per_class(pyopencv_gapi_ot_ObjectTrackerParams_t* p, PyObject *value, void *closure) |  | 58223 | static int pyopencv_gapi_ot_ObjectTrackerParams_set_tracking_per_class(pyopencv_gapi_ot_ObjectTrackerParams_t* p, PyObject *value, void *closure)
| 58272 | { |  | 58224 | {
| 58273 | if (!value) |  | 58225 | if (!value)
| 58274 | { |  | 58226 | {
| 58275 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tracking_per_class attribute"); |  | 58227 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tracking_per_class attribute");
| 58276 | return -1; |  | 58228 | return -1;
| 58277 | } |  | 58229 | }
| 58278 | return pyopencv_to_safe(value, p->v.tracking_per_class, ArgInfo("value", 0)) ? 0 : -1; |  | 58230 | return pyopencv_to_safe(value, p->v.tracking_per_class, ArgInfo("value", 0)) ? 0 : -1;
| 58279 | } |  | 58231 | }
| 58280 |  |  | 58232 |
| 58281 |  |  | 58233 |
| 58282 | // Methods (gapi_ot_ObjectTrackerParams) |  | 58234 | // Methods (gapi_ot_ObjectTrackerParams)
| 58283 |  |  | 58235 |
| 58284 |  |  | 58236 |
| 58285 |  |  | 58237 |
| 58286 | // Tables (gapi_ot_ObjectTrackerParams) |  | 58238 | // Tables (gapi_ot_ObjectTrackerParams)
| 58287 |  |  | 58239 |
| 58288 | static PyGetSetDef pyopencv_gapi_ot_ObjectTrackerParams_getseters[] = |  | 58240 | static PyGetSetDef pyopencv_gapi_ot_ObjectTrackerParams_getseters[] =
| 58289 | { |  | 58241 | {
| 58290 | {(char*)"input_image_format", (getter)pyopencv_gapi_ot_ObjectTrackerParams_get_input_image_format, (setter)pyopencv_gapi_ot_ObjectTrackerParams_set_input_image_format, (char*)"input_image_format", NULL}, |  | 58242 | {(char*)"input_image_format", (getter)pyopencv_gapi_ot_ObjectTrackerParams_get_input_image_format, (setter)pyopencv_gapi_ot_ObjectTrackerParams_set_input_image_format, (char*)"input_image_format", NULL},
| 58291 | {(char*)"max_num_objects", (getter)pyopencv_gapi_ot_ObjectTrackerParams_get_max_num_objects, (setter)pyopencv_gapi_ot_ObjectTrackerParams_set_max_num_objects, (char*)"max_num_objects", NULL}, |  | 58243 | {(char*)"max_num_objects", (getter)pyopencv_gapi_ot_ObjectTrackerParams_get_max_num_objects, (setter)pyopencv_gapi_ot_ObjectTrackerParams_set_max_num_objects, (char*)"max_num_objects", NULL},
| 58292 | {(char*)"tracking_per_class", (getter)pyopencv_gapi_ot_ObjectTrackerParams_get_tracking_per_class, (setter)pyopencv_gapi_ot_ObjectTrackerParams_set_tracking_per_class, (char*)"tracking_per_class", NULL}, |  | 58244 | {(char*)"tracking_per_class", (getter)pyopencv_gapi_ot_ObjectTrackerParams_get_tracking_per_class, (setter)pyopencv_gapi_ot_ObjectTrackerParams_set_tracking_per_class, (char*)"tracking_per_class", NULL},
| 58293 | {NULL} /* Sentinel */ |  | 58245 | {NULL} /* Sentinel */
| 58294 | }; |  | 58246 | };
| 58295 |  |  | 58247 |
| 58296 | static PyMethodDef pyopencv_gapi_ot_ObjectTrackerParams_methods[] = |  | 58248 | static PyMethodDef pyopencv_gapi_ot_ObjectTrackerParams_methods[] =
| 58297 | { |  | 58249 | {
| 58298 |  |  | 58250 |
| 58299 | {NULL, NULL} |  | 58251 | {NULL, NULL}
| 58300 | }; |  | 58252 | };
| 58301 |  |  | 58253 |
| 58302 | // Converter (gapi_ot_ObjectTrackerParams) |  | 58254 | // Converter (gapi_ot_ObjectTrackerParams)
| 58303 |  |  | 58255 |
| 58304 | template<> |  | 58256 | template<>
| 58305 | struct PyOpenCV_Converter< cv::gapi::ot::ObjectTrackerParams > |  | 58257 | struct PyOpenCV_Converter< cv::gapi::ot::ObjectTrackerParams >
| 58306 | { |  | 58258 | {
| 58307 | static PyObject* from(const cv::gapi::ot::ObjectTrackerParams& r) |  | 58259 | static PyObject* from(const cv::gapi::ot::ObjectTrackerParams& r)
| 58308 | { |  | 58260 | {
| 58309 | return pyopencv_gapi_ot_ObjectTrackerParams_Instance(r); |  | 58261 | return pyopencv_gapi_ot_ObjectTrackerParams_Instance(r);
| 58310 | } |  | 58262 | }
| 58311 | static bool to(PyObject* src, cv::gapi::ot::ObjectTrackerParams& dst, const ArgInfo& info) |  | 58263 | static bool to(PyObject* src, cv::gapi::ot::ObjectTrackerParams& dst, const ArgInfo& info)
| 58312 | { |  | 58264 | {
| 58313 | if(!src || src == Py_None) |  | 58265 | if(!src || src == Py_None)
| 58314 | return true; |  | 58266 | return true;
| 58315 | cv::gapi::ot::ObjectTrackerParams * dst_; |  | 58267 | cv::gapi::ot::ObjectTrackerParams * dst_;
| 58316 | if (pyopencv_gapi_ot_ObjectTrackerParams_getp(src, dst_)) |  | 58268 | if (pyopencv_gapi_ot_ObjectTrackerParams_getp(src, dst_))
| 58317 | { |  | 58269 | {
| 58318 | dst = *dst_; |  | 58270 | dst = *dst_;
| 58319 | return true; |  | 58271 | return true;
| 58320 | } |  | 58272 | }
| 58321 |  |  | 58273 |
| 58322 | failmsg("Expected cv::gapi::ot::ObjectTrackerParams for argument '%s'", info.name); |  | 58274 | failmsg("Expected cv::gapi::ot::ObjectTrackerParams for argument '%s'", info.name);
| 58323 | return false; |  | 58275 | return false;
| 58324 | } |  | 58276 | }
| 58325 | }; |  | 58277 | };
| 58326 |  |  | 58278 |
| 58327 | //================================================================================ |  | 58279 | //================================================================================
| 58328 | // gapi_ov_PyParams (Generic) |  | 58280 | // gapi_ov_PyParams (Generic)
| 58329 | //================================================================================ |  | 58281 | //================================================================================
| 58330 |  |  | 58282 |
| 58331 | // GetSet (gapi_ov_PyParams) |  | 58283 | // GetSet (gapi_ov_PyParams)
| 58332 |  |  | 58284 |
| 58333 |  |  | 58285 |
| 58334 |  |  | 58286 |
| 58335 | // Methods (gapi_ov_PyParams) |  | 58287 | // Methods (gapi_ov_PyParams)
| 58336 |  |  | 58288 |
| 58337 | static int pyopencv_cv_gapi_ov_gapi_ov_PyParams_PyParams(pyopencv_gapi_ov_PyParams_t* self, PyObject* py_args, PyObject* kw) |  | 58289 | static int pyopencv_cv_gapi_ov_gapi_ov_PyParams_PyParams(pyopencv_gapi_ov_PyParams_t* self, PyObject* py_args, PyObject* kw)
| 58338 | { |  | 58290 | {
| 58339 | using namespace cv::gapi::ov; |  | 58291 | using namespace cv::gapi::ov;
| 58340 |  |  | 58292 |
| 58341 | pyPrepareArgumentConversionErrorsStorage(3); |  | 58293 | pyPrepareArgumentConversionErrorsStorage(3);
| 58342 |  |  | 58294 |
| 58343 | { |  | 58295 | {
| 58344 |  |  | 58296 |
| 58345 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 58297 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 58346 | { |  | 58298 | {
| 58347 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ov::PyParams()); |  | 58299 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ov::PyParams());
| 58348 | return 0; |  | 58300 | return 0;
| 58349 | } |  | 58301 | }
| 58350 |  |  | 58302 |
| 58351 |  |  | 58303 |
| 58352 | pyPopulateArgumentConversionErrors(); |  | 58304 | pyPopulateArgumentConversionErrors();
| 58353 | } |  | 58305 | }
| 58354 |  |  | 58306 |
| 58355 |  |  | 58307 |
| 58356 | { |  | 58308 | {
| 58357 | PyObject* pyobj_tag = NULL; |  | 58309 | PyObject* pyobj_tag = NULL;
| 58358 | std::string tag; |  | 58310 | std::string tag;
| 58359 | PyObject* pyobj_model_path = NULL; |  | 58311 | PyObject* pyobj_model_path = NULL;
| 58360 | std::string model_path; |  | 58312 | std::string model_path;
| 58361 | PyObject* pyobj_bin_path = NULL; |  | 58313 | PyObject* pyobj_bin_path = NULL;
| 58362 | std::string bin_path; |  | 58314 | std::string bin_path;
| 58363 | PyObject* pyobj_device = NULL; |  | 58315 | PyObject* pyobj_device = NULL;
| 58364 | std::string device; |  | 58316 | std::string device;
| 58365 |  |  | 58317 |
| 58366 | const char* keywords[] = { "tag", "model_path", "bin_path", "device", NULL }; |  | 58318 | const char* keywords[] = { "tag", "model_path", "bin_path", "device", NULL };
| 58367 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model_path, &pyobj_bin_path, &pyobj_device) && |  | 58319 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_model_path, &pyobj_bin_path, &pyobj_device) &&
| 58368 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) && |  | 58320 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) &&
| 58369 | pyopencv_to_safe(pyobj_model_path, model_path, ArgInfo("model_path", 0)) && |  | 58321 | pyopencv_to_safe(pyobj_model_path, model_path, ArgInfo("model_path", 0)) &&
| 58370 | pyopencv_to_safe(pyobj_bin_path, bin_path, ArgInfo("bin_path", 0)) && |  | 58322 | pyopencv_to_safe(pyobj_bin_path, bin_path, ArgInfo("bin_path", 0)) &&
| 58371 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) ) |  | 58323 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) )
| 58372 | { |  | 58324 | {
| 58373 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ov::PyParams(tag, model_path, bin_path, device)); |  | 58325 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ov::PyParams(tag, model_path, bin_path, device));
| 58374 | return 0; |  | 58326 | return 0;
| 58375 | } |  | 58327 | }
| 58376 |  |  | 58328 |
| 58377 |  |  | 58329 |
| 58378 | pyPopulateArgumentConversionErrors(); |  | 58330 | pyPopulateArgumentConversionErrors();
| 58379 | } |  | 58331 | }
| 58380 |  |  | 58332 |
| 58381 |  |  | 58333 |
| 58382 | { |  | 58334 | {
| 58383 | PyObject* pyobj_tag = NULL; |  | 58335 | PyObject* pyobj_tag = NULL;
| 58384 | std::string tag; |  | 58336 | std::string tag;
| 58385 | PyObject* pyobj_blob_path = NULL; |  | 58337 | PyObject* pyobj_blob_path = NULL;
| 58386 | std::string blob_path; |  | 58338 | std::string blob_path;
| 58387 | PyObject* pyobj_device = NULL; |  | 58339 | PyObject* pyobj_device = NULL;
| 58388 | std::string device; |  | 58340 | std::string device;
| 58389 |  |  | 58341 |
| 58390 | const char* keywords[] = { "tag", "blob_path", "device", NULL }; |  | 58342 | const char* keywords[] = { "tag", "blob_path", "device", NULL };
| 58391 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_blob_path, &pyobj_device) && |  | 58343 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:PyParams", (char**)keywords, &pyobj_tag, &pyobj_blob_path, &pyobj_device) &&
| 58392 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) && |  | 58344 | pyopencv_to_safe(pyobj_tag, tag, ArgInfo("tag", 0)) &&
| 58393 | pyopencv_to_safe(pyobj_blob_path, blob_path, ArgInfo("blob_path", 0)) && |  | 58345 | pyopencv_to_safe(pyobj_blob_path, blob_path, ArgInfo("blob_path", 0)) &&
| 58394 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) ) |  | 58346 | pyopencv_to_safe(pyobj_device, device, ArgInfo("device", 0)) )
| 58395 | { |  | 58347 | {
| 58396 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ov::PyParams(tag, blob_path, device)); |  | 58348 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::ov::PyParams(tag, blob_path, device));
| 58397 | return 0; |  | 58349 | return 0;
| 58398 | } |  | 58350 | }
| 58399 |  |  | 58351 |
| 58400 |  |  | 58352 |
| 58401 | pyPopulateArgumentConversionErrors(); |  | 58353 | pyPopulateArgumentConversionErrors();
| 58402 | } |  | 58354 | }
| 58403 | pyRaiseCVOverloadException("PyParams"); |  | 58355 | pyRaiseCVOverloadException("PyParams");
| 58404 |  |  | 58356 |
| 58405 | return -1; |  | 58357 | return -1;
| 58406 | } |  | 58358 | }
| 58407 |  |  | 58359 |
| 58408 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputModelLayout(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58360 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputModelLayout(PyObject* self, PyObject* py_args, PyObject* kw)
| 58409 | { |  | 58361 | {
| 58410 | using namespace cv::gapi::ov; |  | 58362 | using namespace cv::gapi::ov;
| 58411 |  |  | 58363 |
| 58412 |  |  | 58364 |
| 58413 | cv::gapi::ov::PyParams * self1 = 0; |  | 58365 | cv::gapi::ov::PyParams * self1 = 0;
| 58414 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58366 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58415 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58367 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58416 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58368 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58417 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58369 | pyPrepareArgumentConversionErrorsStorage(2);
| 58418 |  |  | 58370 |
| 58419 | { |  | 58371 | {
| 58420 | PyObject* pyobj_tensor_layout = NULL; |  | 58372 | PyObject* pyobj_tensor_layout = NULL;
| 58421 | std::string tensor_layout; |  | 58373 | std::string tensor_layout;
| 58422 | PyParams retval; |  | 58374 | PyParams retval;
| 58423 |  |  | 58375 |
| 58424 | const char* keywords[] = { "tensor_layout", NULL }; |  | 58376 | const char* keywords[] = { "tensor_layout", NULL };
| 58425 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputModelLayout", (char**)keywords, &pyobj_tensor_layout) && |  | 58377 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputModelLayout", (char**)keywords, &pyobj_tensor_layout) &&
| 58426 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) ) |  | 58378 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) )
| 58427 | { |  | 58379 | {
| 58428 | ERRWRAP2(retval = _self_->cfgInputModelLayout(tensor_layout)); |  | 58380 | ERRWRAP2(retval = _self_->cfgInputModelLayout(tensor_layout));
| 58429 | return pyopencv_from(retval); |  | 58381 | return pyopencv_from(retval);
| 58430 | } |  | 58382 | }
| 58431 |  |  | 58383 |
| 58432 |  |  | 58384 |
| 58433 | pyPopulateArgumentConversionErrors(); |  | 58385 | pyPopulateArgumentConversionErrors();
| 58434 | } |  | 58386 | }
| 58435 |  |  | 58387 |
| 58436 |  |  | 58388 |
| 58437 | { |  | 58389 | {
| 58438 | PyObject* pyobj_layout_map = NULL; |  | 58390 | PyObject* pyobj_layout_map = NULL;
| 58439 | map_string_and_string layout_map; |  | 58391 | map_string_and_string layout_map;
| 58440 | PyParams retval; |  | 58392 | PyParams retval;
| 58441 |  |  | 58393 |
| 58442 | const char* keywords[] = { "layout_map", NULL }; |  | 58394 | const char* keywords[] = { "layout_map", NULL };
| 58443 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputModelLayout", (char**)keywords, &pyobj_layout_map) && |  | 58395 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputModelLayout", (char**)keywords, &pyobj_layout_map) &&
| 58444 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) ) |  | 58396 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) )
| 58445 | { |  | 58397 | {
| 58446 | ERRWRAP2(retval = _self_->cfgInputModelLayout(layout_map)); |  | 58398 | ERRWRAP2(retval = _self_->cfgInputModelLayout(layout_map));
| 58447 | return pyopencv_from(retval); |  | 58399 | return pyopencv_from(retval);
| 58448 | } |  | 58400 | }
| 58449 |  |  | 58401 |
| 58450 |  |  | 58402 |
| 58451 | pyPopulateArgumentConversionErrors(); |  | 58403 | pyPopulateArgumentConversionErrors();
| 58452 | } |  | 58404 | }
| 58453 | pyRaiseCVOverloadException("cfgInputModelLayout"); |  | 58405 | pyRaiseCVOverloadException("cfgInputModelLayout");
| 58454 |  |  | 58406 |
| 58455 | return NULL; |  | 58407 | return NULL;
| 58456 | } |  | 58408 | }
| 58457 |  |  | 58409 |
| 58458 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputTensorLayout(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58410 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputTensorLayout(PyObject* self, PyObject* py_args, PyObject* kw)
| 58459 | { |  | 58411 | {
| 58460 | using namespace cv::gapi::ov; |  | 58412 | using namespace cv::gapi::ov;
| 58461 |  |  | 58413 |
| 58462 |  |  | 58414 |
| 58463 | cv::gapi::ov::PyParams * self1 = 0; |  | 58415 | cv::gapi::ov::PyParams * self1 = 0;
| 58464 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58416 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58465 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58417 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58466 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58418 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58467 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58419 | pyPrepareArgumentConversionErrorsStorage(2);
| 58468 |  |  | 58420 |
| 58469 | { |  | 58421 | {
| 58470 | PyObject* pyobj_tensor_layout = NULL; |  | 58422 | PyObject* pyobj_tensor_layout = NULL;
| 58471 | std::string tensor_layout; |  | 58423 | std::string tensor_layout;
| 58472 | PyParams retval; |  | 58424 | PyParams retval;
| 58473 |  |  | 58425 |
| 58474 | const char* keywords[] = { "tensor_layout", NULL }; |  | 58426 | const char* keywords[] = { "tensor_layout", NULL };
| 58475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputTensorLayout", (char**)keywords, &pyobj_tensor_layout) && |  | 58427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputTensorLayout", (char**)keywords, &pyobj_tensor_layout) &&
| 58476 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) ) |  | 58428 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) )
| 58477 | { |  | 58429 | {
| 58478 | ERRWRAP2(retval = _self_->cfgInputTensorLayout(tensor_layout)); |  | 58430 | ERRWRAP2(retval = _self_->cfgInputTensorLayout(tensor_layout));
| 58479 | return pyopencv_from(retval); |  | 58431 | return pyopencv_from(retval);
| 58480 | } |  | 58432 | }
| 58481 |  |  | 58433 |
| 58482 |  |  | 58434 |
| 58483 | pyPopulateArgumentConversionErrors(); |  | 58435 | pyPopulateArgumentConversionErrors();
| 58484 | } |  | 58436 | }
| 58485 |  |  | 58437 |
| 58486 |  |  | 58438 |
| 58487 | { |  | 58439 | {
| 58488 | PyObject* pyobj_layout_map = NULL; |  | 58440 | PyObject* pyobj_layout_map = NULL;
| 58489 | map_string_and_string layout_map; |  | 58441 | map_string_and_string layout_map;
| 58490 | PyParams retval; |  | 58442 | PyParams retval;
| 58491 |  |  | 58443 |
| 58492 | const char* keywords[] = { "layout_map", NULL }; |  | 58444 | const char* keywords[] = { "layout_map", NULL };
| 58493 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputTensorLayout", (char**)keywords, &pyobj_layout_map) && |  | 58445 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgInputTensorLayout", (char**)keywords, &pyobj_layout_map) &&
| 58494 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) ) |  | 58446 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) )
| 58495 | { |  | 58447 | {
| 58496 | ERRWRAP2(retval = _self_->cfgInputTensorLayout(layout_map)); |  | 58448 | ERRWRAP2(retval = _self_->cfgInputTensorLayout(layout_map));
| 58497 | return pyopencv_from(retval); |  | 58449 | return pyopencv_from(retval);
| 58498 | } |  | 58450 | }
| 58499 |  |  | 58451 |
| 58500 |  |  | 58452 |
| 58501 | pyPopulateArgumentConversionErrors(); |  | 58453 | pyPopulateArgumentConversionErrors();
| 58502 | } |  | 58454 | }
| 58503 | pyRaiseCVOverloadException("cfgInputTensorLayout"); |  | 58455 | pyRaiseCVOverloadException("cfgInputTensorLayout");
| 58504 |  |  | 58456 |
| 58505 | return NULL; |  | 58457 | return NULL;
| 58506 | } |  | 58458 | }
| 58507 |  |  | 58459 |
| 58508 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgMean(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58460 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgMean(PyObject* self, PyObject* py_args, PyObject* kw)
| 58509 | { |  | 58461 | {
| 58510 | using namespace cv::gapi::ov; |  | 58462 | using namespace cv::gapi::ov;
| 58511 |  |  | 58463 |
| 58512 |  |  | 58464 |
| 58513 | cv::gapi::ov::PyParams * self1 = 0; |  | 58465 | cv::gapi::ov::PyParams * self1 = 0;
| 58514 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58466 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58515 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58467 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58516 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58468 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58517 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58469 | pyPrepareArgumentConversionErrorsStorage(2);
| 58518 |  |  | 58470 |
| 58519 | { |  | 58471 | {
| 58520 | PyObject* pyobj_mean_values = NULL; |  | 58472 | PyObject* pyobj_mean_values = NULL;
| 58521 | vector_float mean_values; |  | 58473 | vector_float mean_values;
| 58522 | PyParams retval; |  | 58474 | PyParams retval;
| 58523 |  |  | 58475 |
| 58524 | const char* keywords[] = { "mean_values", NULL }; |  | 58476 | const char* keywords[] = { "mean_values", NULL };
| 58525 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgMean", (char**)keywords, &pyobj_mean_values) && |  | 58477 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgMean", (char**)keywords, &pyobj_mean_values) &&
| 58526 | pyopencv_to_safe(pyobj_mean_values, mean_values, ArgInfo("mean_values", 0)) ) |  | 58478 | pyopencv_to_safe(pyobj_mean_values, mean_values, ArgInfo("mean_values", 0)) )
| 58527 | { |  | 58479 | {
| 58528 | ERRWRAP2(retval = _self_->cfgMean(mean_values)); |  | 58480 | ERRWRAP2(retval = _self_->cfgMean(mean_values));
| 58529 | return pyopencv_from(retval); |  | 58481 | return pyopencv_from(retval);
| 58530 | } |  | 58482 | }
| 58531 |  |  | 58483 |
| 58532 |  |  | 58484 |
| 58533 | pyPopulateArgumentConversionErrors(); |  | 58485 | pyPopulateArgumentConversionErrors();
| 58534 | } |  | 58486 | }
| 58535 |  |  | 58487 |
| 58536 |  |  | 58488 |
| 58537 | { |  | 58489 | {
| 58538 | PyObject* pyobj_mean_map = NULL; |  | 58490 | PyObject* pyobj_mean_map = NULL;
| 58539 | map_string_and_vector_float mean_map; |  | 58491 | map_string_and_vector_float mean_map;
| 58540 | PyParams retval; |  | 58492 | PyParams retval;
| 58541 |  |  | 58493 |
| 58542 | const char* keywords[] = { "mean_map", NULL }; |  | 58494 | const char* keywords[] = { "mean_map", NULL };
| 58543 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgMean", (char**)keywords, &pyobj_mean_map) && |  | 58495 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgMean", (char**)keywords, &pyobj_mean_map) &&
| 58544 | pyopencv_to_safe(pyobj_mean_map, mean_map, ArgInfo("mean_map", 0)) ) |  | 58496 | pyopencv_to_safe(pyobj_mean_map, mean_map, ArgInfo("mean_map", 0)) )
| 58545 | { |  | 58497 | {
| 58546 | ERRWRAP2(retval = _self_->cfgMean(mean_map)); |  | 58498 | ERRWRAP2(retval = _self_->cfgMean(mean_map));
| 58547 | return pyopencv_from(retval); |  | 58499 | return pyopencv_from(retval);
| 58548 | } |  | 58500 | }
| 58549 |  |  | 58501 |
| 58550 |  |  | 58502 |
| 58551 | pyPopulateArgumentConversionErrors(); |  | 58503 | pyPopulateArgumentConversionErrors();
| 58552 | } |  | 58504 | }
| 58553 | pyRaiseCVOverloadException("cfgMean"); |  | 58505 | pyRaiseCVOverloadException("cfgMean");
| 58554 |  |  | 58506 |
| 58555 | return NULL; |  | 58507 | return NULL;
| 58556 | } |  | 58508 | }
| 58557 |  |  | 58509 |
| 58558 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgNumRequests(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58510 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgNumRequests(PyObject* self, PyObject* py_args, PyObject* kw)
| 58559 | { |  | 58511 | {
| 58560 | using namespace cv::gapi::ov; |  | 58512 | using namespace cv::gapi::ov;
| 58561 |  |  | 58513 |
| 58562 |  |  | 58514 |
| 58563 | cv::gapi::ov::PyParams * self1 = 0; |  | 58515 | cv::gapi::ov::PyParams * self1 = 0;
| 58564 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58516 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58565 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58517 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58566 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58518 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58567 | PyObject* pyobj_nireq = NULL; |  | 58519 | PyObject* pyobj_nireq = NULL;
| 58568 | size_t nireq=0; |  | 58520 | size_t nireq=0;
| 58569 | PyParams retval; |  | 58521 | PyParams retval;
| 58570 |  |  | 58522 |
| 58571 | const char* keywords[] = { "nireq", NULL }; |  | 58523 | const char* keywords[] = { "nireq", NULL };
| 58572 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgNumRequests", (char**)keywords, &pyobj_nireq) && |  | 58524 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgNumRequests", (char**)keywords, &pyobj_nireq) &&
| 58573 | pyopencv_to_safe(pyobj_nireq, nireq, ArgInfo("nireq", 0)) ) |  | 58525 | pyopencv_to_safe(pyobj_nireq, nireq, ArgInfo("nireq", 0)) )
| 58574 | { |  | 58526 | {
| 58575 | ERRWRAP2(retval = _self_->cfgNumRequests(nireq)); |  | 58527 | ERRWRAP2(retval = _self_->cfgNumRequests(nireq));
| 58576 | return pyopencv_from(retval); |  | 58528 | return pyopencv_from(retval);
| 58577 | } |  | 58529 | }
| 58578 |  |  | 58530 |
| 58579 | return NULL; |  | 58531 | return NULL;
| 58580 | } |  | 58532 | }
| 58581 |  |  | 58533 |
| 58582 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputModelLayout(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58534 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputModelLayout(PyObject* self, PyObject* py_args, PyObject* kw)
| 58583 | { |  | 58535 | {
| 58584 | using namespace cv::gapi::ov; |  | 58536 | using namespace cv::gapi::ov;
| 58585 |  |  | 58537 |
| 58586 |  |  | 58538 |
| 58587 | cv::gapi::ov::PyParams * self1 = 0; |  | 58539 | cv::gapi::ov::PyParams * self1 = 0;
| 58588 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58540 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58589 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58541 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58590 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58542 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58591 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58543 | pyPrepareArgumentConversionErrorsStorage(2);
| 58592 |  |  | 58544 |
| 58593 | { |  | 58545 | {
| 58594 | PyObject* pyobj_tensor_layout = NULL; |  | 58546 | PyObject* pyobj_tensor_layout = NULL;
| 58595 | std::string tensor_layout; |  | 58547 | std::string tensor_layout;
| 58596 | PyParams retval; |  | 58548 | PyParams retval;
| 58597 |  |  | 58549 |
| 58598 | const char* keywords[] = { "tensor_layout", NULL }; |  | 58550 | const char* keywords[] = { "tensor_layout", NULL };
| 58599 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputModelLayout", (char**)keywords, &pyobj_tensor_layout) && |  | 58551 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputModelLayout", (char**)keywords, &pyobj_tensor_layout) &&
| 58600 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) ) |  | 58552 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) )
| 58601 | { |  | 58553 | {
| 58602 | ERRWRAP2(retval = _self_->cfgOutputModelLayout(tensor_layout)); |  | 58554 | ERRWRAP2(retval = _self_->cfgOutputModelLayout(tensor_layout));
| 58603 | return pyopencv_from(retval); |  | 58555 | return pyopencv_from(retval);
| 58604 | } |  | 58556 | }
| 58605 |  |  | 58557 |
| 58606 |  |  | 58558 |
| 58607 | pyPopulateArgumentConversionErrors(); |  | 58559 | pyPopulateArgumentConversionErrors();
| 58608 | } |  | 58560 | }
| 58609 |  |  | 58561 |
| 58610 |  |  | 58562 |
| 58611 | { |  | 58563 | {
| 58612 | PyObject* pyobj_layout_map = NULL; |  | 58564 | PyObject* pyobj_layout_map = NULL;
| 58613 | map_string_and_string layout_map; |  | 58565 | map_string_and_string layout_map;
| 58614 | PyParams retval; |  | 58566 | PyParams retval;
| 58615 |  |  | 58567 |
| 58616 | const char* keywords[] = { "layout_map", NULL }; |  | 58568 | const char* keywords[] = { "layout_map", NULL };
| 58617 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputModelLayout", (char**)keywords, &pyobj_layout_map) && |  | 58569 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputModelLayout", (char**)keywords, &pyobj_layout_map) &&
| 58618 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) ) |  | 58570 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) )
| 58619 | { |  | 58571 | {
| 58620 | ERRWRAP2(retval = _self_->cfgOutputModelLayout(layout_map)); |  | 58572 | ERRWRAP2(retval = _self_->cfgOutputModelLayout(layout_map));
| 58621 | return pyopencv_from(retval); |  | 58573 | return pyopencv_from(retval);
| 58622 | } |  | 58574 | }
| 58623 |  |  | 58575 |
| 58624 |  |  | 58576 |
| 58625 | pyPopulateArgumentConversionErrors(); |  | 58577 | pyPopulateArgumentConversionErrors();
| 58626 | } |  | 58578 | }
| 58627 | pyRaiseCVOverloadException("cfgOutputModelLayout"); |  | 58579 | pyRaiseCVOverloadException("cfgOutputModelLayout");
| 58628 |  |  | 58580 |
| 58629 | return NULL; |  | 58581 | return NULL;
| 58630 | } |  | 58582 | }
| 58631 |  |  | 58583 |
| 58632 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorLayout(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58584 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorLayout(PyObject* self, PyObject* py_args, PyObject* kw)
| 58633 | { |  | 58585 | {
| 58634 | using namespace cv::gapi::ov; |  | 58586 | using namespace cv::gapi::ov;
| 58635 |  |  | 58587 |
| 58636 |  |  | 58588 |
| 58637 | cv::gapi::ov::PyParams * self1 = 0; |  | 58589 | cv::gapi::ov::PyParams * self1 = 0;
| 58638 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58590 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58639 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58591 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58640 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58592 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58641 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58593 | pyPrepareArgumentConversionErrorsStorage(2);
| 58642 |  |  | 58594 |
| 58643 | { |  | 58595 | {
| 58644 | PyObject* pyobj_tensor_layout = NULL; |  | 58596 | PyObject* pyobj_tensor_layout = NULL;
| 58645 | std::string tensor_layout; |  | 58597 | std::string tensor_layout;
| 58646 | PyParams retval; |  | 58598 | PyParams retval;
| 58647 |  |  | 58599 |
| 58648 | const char* keywords[] = { "tensor_layout", NULL }; |  | 58600 | const char* keywords[] = { "tensor_layout", NULL };
| 58649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorLayout", (char**)keywords, &pyobj_tensor_layout) && |  | 58601 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorLayout", (char**)keywords, &pyobj_tensor_layout) &&
| 58650 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) ) |  | 58602 | pyopencv_to_safe(pyobj_tensor_layout, tensor_layout, ArgInfo("tensor_layout", 0)) )
| 58651 | { |  | 58603 | {
| 58652 | ERRWRAP2(retval = _self_->cfgOutputTensorLayout(tensor_layout)); |  | 58604 | ERRWRAP2(retval = _self_->cfgOutputTensorLayout(tensor_layout));
| 58653 | return pyopencv_from(retval); |  | 58605 | return pyopencv_from(retval);
| 58654 | } |  | 58606 | }
| 58655 |  |  | 58607 |
| 58656 |  |  | 58608 |
| 58657 | pyPopulateArgumentConversionErrors(); |  | 58609 | pyPopulateArgumentConversionErrors();
| 58658 | } |  | 58610 | }
| 58659 |  |  | 58611 |
| 58660 |  |  | 58612 |
| 58661 | { |  | 58613 | {
| 58662 | PyObject* pyobj_layout_map = NULL; |  | 58614 | PyObject* pyobj_layout_map = NULL;
| 58663 | map_string_and_string layout_map; |  | 58615 | map_string_and_string layout_map;
| 58664 | PyParams retval; |  | 58616 | PyParams retval;
| 58665 |  |  | 58617 |
| 58666 | const char* keywords[] = { "layout_map", NULL }; |  | 58618 | const char* keywords[] = { "layout_map", NULL };
| 58667 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorLayout", (char**)keywords, &pyobj_layout_map) && |  | 58619 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorLayout", (char**)keywords, &pyobj_layout_map) &&
| 58668 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) ) |  | 58620 | pyopencv_to_safe(pyobj_layout_map, layout_map, ArgInfo("layout_map", 0)) )
| 58669 | { |  | 58621 | {
| 58670 | ERRWRAP2(retval = _self_->cfgOutputTensorLayout(layout_map)); |  | 58622 | ERRWRAP2(retval = _self_->cfgOutputTensorLayout(layout_map));
| 58671 | return pyopencv_from(retval); |  | 58623 | return pyopencv_from(retval);
| 58672 | } |  | 58624 | }
| 58673 |  |  | 58625 |
| 58674 |  |  | 58626 |
| 58675 | pyPopulateArgumentConversionErrors(); |  | 58627 | pyPopulateArgumentConversionErrors();
| 58676 | } |  | 58628 | }
| 58677 | pyRaiseCVOverloadException("cfgOutputTensorLayout"); |  | 58629 | pyRaiseCVOverloadException("cfgOutputTensorLayout");
| 58678 |  |  | 58630 |
| 58679 | return NULL; |  | 58631 | return NULL;
| 58680 | } |  | 58632 | }
| 58681 |  |  | 58633 |
| 58682 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorPrecision(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58634 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorPrecision(PyObject* self, PyObject* py_args, PyObject* kw)
| 58683 | { |  | 58635 | {
| 58684 | using namespace cv::gapi::ov; |  | 58636 | using namespace cv::gapi::ov;
| 58685 |  |  | 58637 |
| 58686 |  |  | 58638 |
| 58687 | cv::gapi::ov::PyParams * self1 = 0; |  | 58639 | cv::gapi::ov::PyParams * self1 = 0;
| 58688 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58640 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58689 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58641 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58690 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58642 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58691 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58643 | pyPrepareArgumentConversionErrorsStorage(2);
| 58692 |  |  | 58644 |
| 58693 | { |  | 58645 | {
| 58694 | PyObject* pyobj_precision = NULL; |  | 58646 | PyObject* pyobj_precision = NULL;
| 58695 | int precision=0; |  | 58647 | int precision=0;
| 58696 | PyParams retval; |  | 58648 | PyParams retval;
| 58697 |  |  | 58649 |
| 58698 | const char* keywords[] = { "precision", NULL }; |  | 58650 | const char* keywords[] = { "precision", NULL };
| 58699 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorPrecision", (char**)keywords, &pyobj_precision) && |  | 58651 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorPrecision", (char**)keywords, &pyobj_precision) &&
| 58700 | pyopencv_to_safe(pyobj_precision, precision, ArgInfo("precision", 0)) ) |  | 58652 | pyopencv_to_safe(pyobj_precision, precision, ArgInfo("precision", 0)) )
| 58701 | { |  | 58653 | {
| 58702 | ERRWRAP2(retval = _self_->cfgOutputTensorPrecision(precision)); |  | 58654 | ERRWRAP2(retval = _self_->cfgOutputTensorPrecision(precision));
| 58703 | return pyopencv_from(retval); |  | 58655 | return pyopencv_from(retval);
| 58704 | } |  | 58656 | }
| 58705 |  |  | 58657 |
| 58706 |  |  | 58658 |
| 58707 | pyPopulateArgumentConversionErrors(); |  | 58659 | pyPopulateArgumentConversionErrors();
| 58708 | } |  | 58660 | }
| 58709 |  |  | 58661 |
| 58710 |  |  | 58662 |
| 58711 | { |  | 58663 | {
| 58712 | PyObject* pyobj_precision_map = NULL; |  | 58664 | PyObject* pyobj_precision_map = NULL;
| 58713 | map_string_and_int precision_map; |  | 58665 | map_string_and_int precision_map;
| 58714 | PyParams retval; |  | 58666 | PyParams retval;
| 58715 |  |  | 58667 |
| 58716 | const char* keywords[] = { "precision_map", NULL }; |  | 58668 | const char* keywords[] = { "precision_map", NULL };
| 58717 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorPrecision", (char**)keywords, &pyobj_precision_map) && |  | 58669 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgOutputTensorPrecision", (char**)keywords, &pyobj_precision_map) &&
| 58718 | pyopencv_to_safe(pyobj_precision_map, precision_map, ArgInfo("precision_map", 0)) ) |  | 58670 | pyopencv_to_safe(pyobj_precision_map, precision_map, ArgInfo("precision_map", 0)) )
| 58719 | { |  | 58671 | {
| 58720 | ERRWRAP2(retval = _self_->cfgOutputTensorPrecision(precision_map)); |  | 58672 | ERRWRAP2(retval = _self_->cfgOutputTensorPrecision(precision_map));
| 58721 | return pyopencv_from(retval); |  | 58673 | return pyopencv_from(retval);
| 58722 | } |  | 58674 | }
| 58723 |  |  | 58675 |
| 58724 |  |  | 58676 |
| 58725 | pyPopulateArgumentConversionErrors(); |  | 58677 | pyPopulateArgumentConversionErrors();
| 58726 | } |  | 58678 | }
| 58727 | pyRaiseCVOverloadException("cfgOutputTensorPrecision"); |  | 58679 | pyRaiseCVOverloadException("cfgOutputTensorPrecision");
| 58728 |  |  | 58680 |
| 58729 | return NULL; |  | 58681 | return NULL;
| 58730 | } |  | 58682 | }
| 58731 |  |  | 58683 |
| 58732 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgPluginConfig(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58684 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgPluginConfig(PyObject* self, PyObject* py_args, PyObject* kw)
| 58733 | { |  | 58685 | {
| 58734 | using namespace cv::gapi::ov; |  | 58686 | using namespace cv::gapi::ov;
| 58735 |  |  | 58687 |
| 58736 |  |  | 58688 |
| 58737 | cv::gapi::ov::PyParams * self1 = 0; |  | 58689 | cv::gapi::ov::PyParams * self1 = 0;
| 58738 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58690 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58739 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58691 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58740 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58692 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58741 | PyObject* pyobj_config = NULL; |  | 58693 | PyObject* pyobj_config = NULL;
| 58742 | map_string_and_string config; |  | 58694 | map_string_and_string config;
| 58743 | PyParams retval; |  | 58695 | PyParams retval;
| 58744 |  |  | 58696 |
| 58745 | const char* keywords[] = { "config", NULL }; |  | 58697 | const char* keywords[] = { "config", NULL };
| 58746 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgPluginConfig", (char**)keywords, &pyobj_config) && |  | 58698 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgPluginConfig", (char**)keywords, &pyobj_config) &&
| 58747 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 0)) ) |  | 58699 | pyopencv_to_safe(pyobj_config, config, ArgInfo("config", 0)) )
| 58748 | { |  | 58700 | {
| 58749 | ERRWRAP2(retval = _self_->cfgPluginConfig(config)); |  | 58701 | ERRWRAP2(retval = _self_->cfgPluginConfig(config));
| 58750 | return pyopencv_from(retval); |  | 58702 | return pyopencv_from(retval);
| 58751 | } |  | 58703 | }
| 58752 |  |  | 58704 |
| 58753 | return NULL; |  | 58705 | return NULL;
| 58754 | } |  | 58706 | }
| 58755 |  |  | 58707 |
| 58756 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgReshape(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58708 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgReshape(PyObject* self, PyObject* py_args, PyObject* kw)
| 58757 | { |  | 58709 | {
| 58758 | using namespace cv::gapi::ov; |  | 58710 | using namespace cv::gapi::ov;
| 58759 |  |  | 58711 |
| 58760 |  |  | 58712 |
| 58761 | cv::gapi::ov::PyParams * self1 = 0; |  | 58713 | cv::gapi::ov::PyParams * self1 = 0;
| 58762 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58714 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58763 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58715 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58764 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58716 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58765 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58717 | pyPrepareArgumentConversionErrorsStorage(2);
| 58766 |  |  | 58718 |
| 58767 | { |  | 58719 | {
| 58768 | PyObject* pyobj_new_shape = NULL; |  | 58720 | PyObject* pyobj_new_shape = NULL;
| 58769 | vector_size_t new_shape; |  | 58721 | vector_size_t new_shape;
| 58770 | PyParams retval; |  | 58722 | PyParams retval;
| 58771 |  |  | 58723 |
| 58772 | const char* keywords[] = { "new_shape", NULL }; |  | 58724 | const char* keywords[] = { "new_shape", NULL };
| 58773 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgReshape", (char**)keywords, &pyobj_new_shape) && |  | 58725 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgReshape", (char**)keywords, &pyobj_new_shape) &&
| 58774 | pyopencv_to_safe(pyobj_new_shape, new_shape, ArgInfo("new_shape", 0)) ) |  | 58726 | pyopencv_to_safe(pyobj_new_shape, new_shape, ArgInfo("new_shape", 0)) )
| 58775 | { |  | 58727 | {
| 58776 | ERRWRAP2(retval = _self_->cfgReshape(new_shape)); |  | 58728 | ERRWRAP2(retval = _self_->cfgReshape(new_shape));
| 58777 | return pyopencv_from(retval); |  | 58729 | return pyopencv_from(retval);
| 58778 | } |  | 58730 | }
| 58779 |  |  | 58731 |
| 58780 |  |  | 58732 |
| 58781 | pyPopulateArgumentConversionErrors(); |  | 58733 | pyPopulateArgumentConversionErrors();
| 58782 | } |  | 58734 | }
| 58783 |  |  | 58735 |
| 58784 |  |  | 58736 |
| 58785 | { |  | 58737 | {
| 58786 | PyObject* pyobj_new_shape_map = NULL; |  | 58738 | PyObject* pyobj_new_shape_map = NULL;
| 58787 | map_string_and_vector_size_t new_shape_map; |  | 58739 | map_string_and_vector_size_t new_shape_map;
| 58788 | PyParams retval; |  | 58740 | PyParams retval;
| 58789 |  |  | 58741 |
| 58790 | const char* keywords[] = { "new_shape_map", NULL }; |  | 58742 | const char* keywords[] = { "new_shape_map", NULL };
| 58791 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgReshape", (char**)keywords, &pyobj_new_shape_map) && |  | 58743 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgReshape", (char**)keywords, &pyobj_new_shape_map) &&
| 58792 | pyopencv_to_safe(pyobj_new_shape_map, new_shape_map, ArgInfo("new_shape_map", 0)) ) |  | 58744 | pyopencv_to_safe(pyobj_new_shape_map, new_shape_map, ArgInfo("new_shape_map", 0)) )
| 58793 | { |  | 58745 | {
| 58794 | ERRWRAP2(retval = _self_->cfgReshape(new_shape_map)); |  | 58746 | ERRWRAP2(retval = _self_->cfgReshape(new_shape_map));
| 58795 | return pyopencv_from(retval); |  | 58747 | return pyopencv_from(retval);
| 58796 | } |  | 58748 | }
| 58797 |  |  | 58749 |
| 58798 |  |  | 58750 |
| 58799 | pyPopulateArgumentConversionErrors(); |  | 58751 | pyPopulateArgumentConversionErrors();
| 58800 | } |  | 58752 | }
| 58801 | pyRaiseCVOverloadException("cfgReshape"); |  | 58753 | pyRaiseCVOverloadException("cfgReshape");
| 58802 |  |  | 58754 |
| 58803 | return NULL; |  | 58755 | return NULL;
| 58804 | } |  | 58756 | }
| 58805 |  |  | 58757 |
| 58806 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgResize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58758 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgResize(PyObject* self, PyObject* py_args, PyObject* kw)
| 58807 | { |  | 58759 | {
| 58808 | using namespace cv::gapi::ov; |  | 58760 | using namespace cv::gapi::ov;
| 58809 |  |  | 58761 |
| 58810 |  |  | 58762 |
| 58811 | cv::gapi::ov::PyParams * self1 = 0; |  | 58763 | cv::gapi::ov::PyParams * self1 = 0;
| 58812 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58764 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58813 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58765 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58814 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58766 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58815 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58767 | pyPrepareArgumentConversionErrorsStorage(2);
| 58816 |  |  | 58768 |
| 58817 | { |  | 58769 | {
| 58818 | PyObject* pyobj_interpolation = NULL; |  | 58770 | PyObject* pyobj_interpolation = NULL;
| 58819 | int interpolation=0; |  | 58771 | int interpolation=0;
| 58820 | PyParams retval; |  | 58772 | PyParams retval;
| 58821 |  |  | 58773 |
| 58822 | const char* keywords[] = { "interpolation", NULL }; |  | 58774 | const char* keywords[] = { "interpolation", NULL };
| 58823 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgResize", (char**)keywords, &pyobj_interpolation) && |  | 58775 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgResize", (char**)keywords, &pyobj_interpolation) &&
| 58824 | pyopencv_to_safe(pyobj_interpolation, interpolation, ArgInfo("interpolation", 0)) ) |  | 58776 | pyopencv_to_safe(pyobj_interpolation, interpolation, ArgInfo("interpolation", 0)) )
| 58825 | { |  | 58777 | {
| 58826 | ERRWRAP2(retval = _self_->cfgResize(interpolation)); |  | 58778 | ERRWRAP2(retval = _self_->cfgResize(interpolation));
| 58827 | return pyopencv_from(retval); |  | 58779 | return pyopencv_from(retval);
| 58828 | } |  | 58780 | }
| 58829 |  |  | 58781 |
| 58830 |  |  | 58782 |
| 58831 | pyPopulateArgumentConversionErrors(); |  | 58783 | pyPopulateArgumentConversionErrors();
| 58832 | } |  | 58784 | }
| 58833 |  |  | 58785 |
| 58834 |  |  | 58786 |
| 58835 | { |  | 58787 | {
| 58836 | PyObject* pyobj_interpolation = NULL; |  | 58788 | PyObject* pyobj_interpolation = NULL;
| 58837 | map_string_and_int interpolation; |  | 58789 | map_string_and_int interpolation;
| 58838 | PyParams retval; |  | 58790 | PyParams retval;
| 58839 |  |  | 58791 |
| 58840 | const char* keywords[] = { "interpolation", NULL }; |  | 58792 | const char* keywords[] = { "interpolation", NULL };
| 58841 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgResize", (char**)keywords, &pyobj_interpolation) && |  | 58793 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgResize", (char**)keywords, &pyobj_interpolation) &&
| 58842 | pyopencv_to_safe(pyobj_interpolation, interpolation, ArgInfo("interpolation", 0)) ) |  | 58794 | pyopencv_to_safe(pyobj_interpolation, interpolation, ArgInfo("interpolation", 0)) )
| 58843 | { |  | 58795 | {
| 58844 | ERRWRAP2(retval = _self_->cfgResize(interpolation)); |  | 58796 | ERRWRAP2(retval = _self_->cfgResize(interpolation));
| 58845 | return pyopencv_from(retval); |  | 58797 | return pyopencv_from(retval);
| 58846 | } |  | 58798 | }
| 58847 |  |  | 58799 |
| 58848 |  |  | 58800 |
| 58849 | pyPopulateArgumentConversionErrors(); |  | 58801 | pyPopulateArgumentConversionErrors();
| 58850 | } |  | 58802 | }
| 58851 | pyRaiseCVOverloadException("cfgResize"); |  | 58803 | pyRaiseCVOverloadException("cfgResize");
| 58852 |  |  | 58804 |
| 58853 | return NULL; |  | 58805 | return NULL;
| 58854 | } |  | 58806 | }
| 58855 |  |  | 58807 |
| 58856 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 58808 | static PyObject* pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 58857 | { |  | 58809 | {
| 58858 | using namespace cv::gapi::ov; |  | 58810 | using namespace cv::gapi::ov;
| 58859 |  |  | 58811 |
| 58860 |  |  | 58812 |
| 58861 | cv::gapi::ov::PyParams * self1 = 0; |  | 58813 | cv::gapi::ov::PyParams * self1 = 0;
| 58862 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1)) |  | 58814 | if (!pyopencv_gapi_ov_PyParams_getp(self, self1))
| 58863 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)"); |  | 58815 | return failmsgp("Incorrect type of self (must be 'gapi_ov_PyParams' or its derivative)");
| 58864 | cv::gapi::ov::PyParams* _self_ = (self1); |  | 58816 | cv::gapi::ov::PyParams* _self_ = (self1);
| 58865 | pyPrepareArgumentConversionErrorsStorage(2); |  | 58817 | pyPrepareArgumentConversionErrorsStorage(2);
| 58866 |  |  | 58818 |
| 58867 | { |  | 58819 | {
| 58868 | PyObject* pyobj_scale_values = NULL; |  | 58820 | PyObject* pyobj_scale_values = NULL;
| 58869 | vector_float scale_values; |  | 58821 | vector_float scale_values;
| 58870 | PyParams retval; |  | 58822 | PyParams retval;
| 58871 |  |  | 58823 |
| 58872 | const char* keywords[] = { "scale_values", NULL }; |  | 58824 | const char* keywords[] = { "scale_values", NULL };
| 58873 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgScale", (char**)keywords, &pyobj_scale_values) && |  | 58825 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgScale", (char**)keywords, &pyobj_scale_values) &&
| 58874 | pyopencv_to_safe(pyobj_scale_values, scale_values, ArgInfo("scale_values", 0)) ) |  | 58826 | pyopencv_to_safe(pyobj_scale_values, scale_values, ArgInfo("scale_values", 0)) )
| 58875 | { |  | 58827 | {
| 58876 | ERRWRAP2(retval = _self_->cfgScale(scale_values)); |  | 58828 | ERRWRAP2(retval = _self_->cfgScale(scale_values));
| 58877 | return pyopencv_from(retval); |  | 58829 | return pyopencv_from(retval);
| 58878 | } |  | 58830 | }
| 58879 |  |  | 58831 |
| 58880 |  |  | 58832 |
| 58881 | pyPopulateArgumentConversionErrors(); |  | 58833 | pyPopulateArgumentConversionErrors();
| 58882 | } |  | 58834 | }
| 58883 |  |  | 58835 |
| 58884 |  |  | 58836 |
| 58885 | { |  | 58837 | {
| 58886 | PyObject* pyobj_scale_map = NULL; |  | 58838 | PyObject* pyobj_scale_map = NULL;
| 58887 | map_string_and_vector_float scale_map; |  | 58839 | map_string_and_vector_float scale_map;
| 58888 | PyParams retval; |  | 58840 | PyParams retval;
| 58889 |  |  | 58841 |
| 58890 | const char* keywords[] = { "scale_map", NULL }; |  | 58842 | const char* keywords[] = { "scale_map", NULL };
| 58891 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgScale", (char**)keywords, &pyobj_scale_map) && |  | 58843 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_ov_PyParams.cfgScale", (char**)keywords, &pyobj_scale_map) &&
| 58892 | pyopencv_to_safe(pyobj_scale_map, scale_map, ArgInfo("scale_map", 0)) ) |  | 58844 | pyopencv_to_safe(pyobj_scale_map, scale_map, ArgInfo("scale_map", 0)) )
| 58893 | { |  | 58845 | {
| 58894 | ERRWRAP2(retval = _self_->cfgScale(scale_map)); |  | 58846 | ERRWRAP2(retval = _self_->cfgScale(scale_map));
| 58895 | return pyopencv_from(retval); |  | 58847 | return pyopencv_from(retval);
| 58896 | } |  | 58848 | }
| 58897 |  |  | 58849 |
| 58898 |  |  | 58850 |
| 58899 | pyPopulateArgumentConversionErrors(); |  | 58851 | pyPopulateArgumentConversionErrors();
| 58900 | } |  | 58852 | }
| 58901 | pyRaiseCVOverloadException("cfgScale"); |  | 58853 | pyRaiseCVOverloadException("cfgScale");
| 58902 |  |  | 58854 |
| 58903 | return NULL; |  | 58855 | return NULL;
| 58904 | } |  | 58856 | }
| 58905 |  |  | 58857 |
| 58906 |  |  | 58858 |
| 58907 |  |  | 58859 |
| 58908 | // Tables (gapi_ov_PyParams) |  | 58860 | // Tables (gapi_ov_PyParams)
| 58909 |  |  | 58861 |
| 58910 | static PyGetSetDef pyopencv_gapi_ov_PyParams_getseters[] = |  | 58862 | static PyGetSetDef pyopencv_gapi_ov_PyParams_getseters[] =
| 58911 | { |  | 58863 | {
| 58912 | {NULL} /* Sentinel */ |  | 58864 | {NULL} /* Sentinel */
| 58913 | }; |  | 58865 | };
| 58914 |  |  | 58866 |
| 58915 | static PyMethodDef pyopencv_gapi_ov_PyParams_methods[] = |  | 58867 | static PyMethodDef pyopencv_gapi_ov_PyParams_methods[] =
| 58916 | { |  | 58868 | {
| 58917 | {"cfgInputModelLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputModelLayout, 0), "cfgInputModelLayout(tensor_layout) -> retval\n. \n\n\n\ncfgInputModelLayout(layout_map) -> retval\n."}, |  | 58869 | {"cfgInputModelLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputModelLayout, 0), "cfgInputModelLayout(tensor_layout) -> retval\n. \n\n\n\ncfgInputModelLayout(layout_map) -> retval\n."},
| 58918 | {"cfgInputTensorLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputTensorLayout, 0), "cfgInputTensorLayout(tensor_layout) -> retval\n. \n\n\n\ncfgInputTensorLayout(layout_map) -> retval\n."}, |  | 58870 | {"cfgInputTensorLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgInputTensorLayout, 0), "cfgInputTensorLayout(tensor_layout) -> retval\n. \n\n\n\ncfgInputTensorLayout(layout_map) -> retval\n."},
| 58919 | {"cfgMean", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgMean, 0), "cfgMean(mean_values) -> retval\n. \n\n\n\ncfgMean(mean_map) -> retval\n."}, |  | 58871 | {"cfgMean", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgMean, 0), "cfgMean(mean_values) -> retval\n. \n\n\n\ncfgMean(mean_map) -> retval\n."},
| 58920 | {"cfgNumRequests", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgNumRequests, 0), "cfgNumRequests(nireq) -> retval\n."}, |  | 58872 | {"cfgNumRequests", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgNumRequests, 0), "cfgNumRequests(nireq) -> retval\n."},
| 58921 | {"cfgOutputModelLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputModelLayout, 0), "cfgOutputModelLayout(tensor_layout) -> retval\n. \n\n\n\ncfgOutputModelLayout(layout_map) -> retval\n."}, |  | 58873 | {"cfgOutputModelLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputModelLayout, 0), "cfgOutputModelLayout(tensor_layout) -> retval\n. \n\n\n\ncfgOutputModelLayout(layout_map) -> retval\n."},
| 58922 | {"cfgOutputTensorLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorLayout, 0), "cfgOutputTensorLayout(tensor_layout) -> retval\n. \n\n\n\ncfgOutputTensorLayout(layout_map) -> retval\n."}, |  | 58874 | {"cfgOutputTensorLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorLayout, 0), "cfgOutputTensorLayout(tensor_layout) -> retval\n. \n\n\n\ncfgOutputTensorLayout(layout_map) -> retval\n."},
| 58923 | {"cfgOutputTensorPrecision", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorPrecision, 0), "cfgOutputTensorPrecision(precision) -> retval\n. \n\n\n\ncfgOutputTensorPrecision(precision_map) -> retval\n."}, |  | 58875 | {"cfgOutputTensorPrecision", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgOutputTensorPrecision, 0), "cfgOutputTensorPrecision(precision) -> retval\n. \n\n\n\ncfgOutputTensorPrecision(precision_map) -> retval\n."},
| 58924 | {"cfgPluginConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgPluginConfig, 0), "cfgPluginConfig(config) -> retval\n."}, |  | 58876 | {"cfgPluginConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgPluginConfig, 0), "cfgPluginConfig(config) -> retval\n."},
| 58925 | {"cfgReshape", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgReshape, 0), "cfgReshape(new_shape) -> retval\n. \n\n\n\ncfgReshape(new_shape_map) -> retval\n."}, |  | 58877 | {"cfgReshape", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgReshape, 0), "cfgReshape(new_shape) -> retval\n. \n\n\n\ncfgReshape(new_shape_map) -> retval\n."},
| 58926 | {"cfgResize", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgResize, 0), "cfgResize(interpolation) -> retval\n."}, |  | 58878 | {"cfgResize", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgResize, 0), "cfgResize(interpolation) -> retval\n."},
| 58927 | {"cfgScale", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgScale, 0), "cfgScale(scale_values) -> retval\n. \n\n\n\ncfgScale(scale_map) -> retval\n."}, |  | 58879 | {"cfgScale", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_ov_gapi_ov_PyParams_cfgScale, 0), "cfgScale(scale_values) -> retval\n. \n\n\n\ncfgScale(scale_map) -> retval\n."},
| 58928 |  |  | 58880 |
| 58929 | {NULL, NULL} |  | 58881 | {NULL, NULL}
| 58930 | }; |  | 58882 | };
| 58931 |  |  | 58883 |
| 58932 | // Converter (gapi_ov_PyParams) |  | 58884 | // Converter (gapi_ov_PyParams)
| 58933 |  |  | 58885 |
| 58934 | template<> |  | 58886 | template<>
| 58935 | struct PyOpenCV_Converter< cv::gapi::ov::PyParams > |  | 58887 | struct PyOpenCV_Converter< cv::gapi::ov::PyParams >
| 58936 | { |  | 58888 | {
| 58937 | static PyObject* from(const cv::gapi::ov::PyParams& r) |  | 58889 | static PyObject* from(const cv::gapi::ov::PyParams& r)
| 58938 | { |  | 58890 | {
| 58939 | return pyopencv_gapi_ov_PyParams_Instance(r); |  | 58891 | return pyopencv_gapi_ov_PyParams_Instance(r);
| 58940 | } |  | 58892 | }
| 58941 | static bool to(PyObject* src, cv::gapi::ov::PyParams& dst, const ArgInfo& info) |  | 58893 | static bool to(PyObject* src, cv::gapi::ov::PyParams& dst, const ArgInfo& info)
| 58942 | { |  | 58894 | {
| 58943 | if(!src || src == Py_None) |  | 58895 | if(!src || src == Py_None)
| 58944 | return true; |  | 58896 | return true;
| 58945 | cv::gapi::ov::PyParams * dst_; |  | 58897 | cv::gapi::ov::PyParams * dst_;
| 58946 | if (pyopencv_gapi_ov_PyParams_getp(src, dst_)) |  | 58898 | if (pyopencv_gapi_ov_PyParams_getp(src, dst_))
| 58947 | { |  | 58899 | {
| 58948 | dst = *dst_; |  | 58900 | dst = *dst_;
| 58949 | return true; |  | 58901 | return true;
| 58950 | } |  | 58902 | }
| 58951 |  |  | 58903 |
| 58952 | failmsg("Expected cv::gapi::ov::PyParams for argument '%s'", info.name); |  | 58904 | failmsg("Expected cv::gapi::ov::PyParams for argument '%s'", info.name);
| 58953 | return false; |  | 58905 | return false;
| 58954 | } |  | 58906 | }
| 58955 | }; |  | 58907 | };
| 58956 |  |  | 58908 |
| 58957 | //================================================================================ |  | 58909 | //================================================================================
| 58958 | // gapi_streaming_queue_capacity (Generic) |  | 58910 | // gapi_streaming_queue_capacity (Generic)
| 58959 | //================================================================================ |  | 58911 | //================================================================================
| 58960 |  |  | 58912 |
| 58961 | // GetSet (gapi_streaming_queue_capacity) |  | 58913 | // GetSet (gapi_streaming_queue_capacity)
| 58962 |  |  | 58914 |
| 58963 |  |  | 58915 |
| 58964 | static PyObject* pyopencv_gapi_streaming_queue_capacity_get_capacity(pyopencv_gapi_streaming_queue_capacity_t* p, void *closure) |  | 58916 | static PyObject* pyopencv_gapi_streaming_queue_capacity_get_capacity(pyopencv_gapi_streaming_queue_capacity_t* p, void *closure)
| 58965 | { |  | 58917 | {
| 58966 | return pyopencv_from(p->v.capacity); |  | 58918 | return pyopencv_from(p->v.capacity);
| 58967 | } |  | 58919 | }
| 58968 |  |  | 58920 |
| 58969 | static int pyopencv_gapi_streaming_queue_capacity_set_capacity(pyopencv_gapi_streaming_queue_capacity_t* p, PyObject *value, void *closure) |  | 58921 | static int pyopencv_gapi_streaming_queue_capacity_set_capacity(pyopencv_gapi_streaming_queue_capacity_t* p, PyObject *value, void *closure)
| 58970 | { |  | 58922 | {
| 58971 | if (!value) |  | 58923 | if (!value)
| 58972 | { |  | 58924 | {
| 58973 | PyErr_SetString(PyExc_TypeError, "Cannot delete the capacity attribute"); |  | 58925 | PyErr_SetString(PyExc_TypeError, "Cannot delete the capacity attribute");
| 58974 | return -1; |  | 58926 | return -1;
| 58975 | } |  | 58927 | }
| 58976 | return pyopencv_to_safe(value, p->v.capacity, ArgInfo("value", 0)) ? 0 : -1; |  | 58928 | return pyopencv_to_safe(value, p->v.capacity, ArgInfo("value", 0)) ? 0 : -1;
| 58977 | } |  | 58929 | }
| 58978 |  |  | 58930 |
| 58979 |  |  | 58931 |
| 58980 | // Methods (gapi_streaming_queue_capacity) |  | 58932 | // Methods (gapi_streaming_queue_capacity)
| 58981 |  |  | 58933 |
| 58982 | static int pyopencv_cv_gapi_streaming_gapi_streaming_queue_capacity_queue_capacity(pyopencv_gapi_streaming_queue_capacity_t* self, PyObject* py_args, PyObject* kw) |  | 58934 | static int pyopencv_cv_gapi_streaming_gapi_streaming_queue_capacity_queue_capacity(pyopencv_gapi_streaming_queue_capacity_t* self, PyObject* py_args, PyObject* kw)
| 58983 | { |  | 58935 | {
| 58984 | using namespace cv::gapi::streaming; |  | 58936 | using namespace cv::gapi::streaming;
| 58985 |  |  | 58937 |
| 58986 | PyObject* pyobj_cap = NULL; |  | 58938 | PyObject* pyobj_cap = NULL;
| 58987 | size_t cap=1; |  | 58939 | size_t cap=1;
| 58988 |  |  | 58940 |
| 58989 | const char* keywords[] = { "cap", NULL }; |  | 58941 | const char* keywords[] = { "cap", NULL };
| 58990 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:queue_capacity", (char**)keywords, &pyobj_cap) && |  | 58942 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:queue_capacity", (char**)keywords, &pyobj_cap) &&
| 58991 | pyopencv_to_safe(pyobj_cap, cap, ArgInfo("cap", 0)) ) |  | 58943 | pyopencv_to_safe(pyobj_cap, cap, ArgInfo("cap", 0)) )
| 58992 | { |  | 58944 | {
| 58993 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::streaming::queue_capacity(cap)); |  | 58945 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::streaming::queue_capacity(cap));
| 58994 | return 0; |  | 58946 | return 0;
| 58995 | } |  | 58947 | }
| 58996 |  |  | 58948 |
| 58997 | return -1; |  | 58949 | return -1;
| 58998 | } |  | 58950 | }
| 58999 |  |  | 58951 |
| 59000 |  |  | 58952 |
| 59001 |  |  | 58953 |
| 59002 | // Tables (gapi_streaming_queue_capacity) |  | 58954 | // Tables (gapi_streaming_queue_capacity)
| 59003 |  |  | 58955 |
| 59004 | static PyGetSetDef pyopencv_gapi_streaming_queue_capacity_getseters[] = |  | 58956 | static PyGetSetDef pyopencv_gapi_streaming_queue_capacity_getseters[] =
| 59005 | { |  | 58957 | {
| 59006 | {(char*)"capacity", (getter)pyopencv_gapi_streaming_queue_capacity_get_capacity, (setter)pyopencv_gapi_streaming_queue_capacity_set_capacity, (char*)"capacity", NULL}, |  | 58958 | {(char*)"capacity", (getter)pyopencv_gapi_streaming_queue_capacity_get_capacity, (setter)pyopencv_gapi_streaming_queue_capacity_set_capacity, (char*)"capacity", NULL},
| 59007 | {NULL} /* Sentinel */ |  | 58959 | {NULL} /* Sentinel */
| 59008 | }; |  | 58960 | };
| 59009 |  |  | 58961 |
| 59010 | static PyMethodDef pyopencv_gapi_streaming_queue_capacity_methods[] = |  | 58962 | static PyMethodDef pyopencv_gapi_streaming_queue_capacity_methods[] =
| 59011 | { |  | 58963 | {
| 59012 |  |  | 58964 |
| 59013 | {NULL, NULL} |  | 58965 | {NULL, NULL}
| 59014 | }; |  | 58966 | };
| 59015 |  |  | 58967 |
| 59016 | // Converter (gapi_streaming_queue_capacity) |  | 58968 | // Converter (gapi_streaming_queue_capacity)
| 59017 |  |  | 58969 |
| 59018 | template<> |  | 58970 | template<>
| 59019 | struct PyOpenCV_Converter< cv::gapi::streaming::queue_capacity > |  | 58971 | struct PyOpenCV_Converter< cv::gapi::streaming::queue_capacity >
| 59020 | { |  | 58972 | {
| 59021 | static PyObject* from(const cv::gapi::streaming::queue_capacity& r) |  | 58973 | static PyObject* from(const cv::gapi::streaming::queue_capacity& r)
| 59022 | { |  | 58974 | {
| 59023 | return pyopencv_gapi_streaming_queue_capacity_Instance(r); |  | 58975 | return pyopencv_gapi_streaming_queue_capacity_Instance(r);
| 59024 | } |  | 58976 | }
| 59025 | static bool to(PyObject* src, cv::gapi::streaming::queue_capacity& dst, const ArgInfo& info) |  | 58977 | static bool to(PyObject* src, cv::gapi::streaming::queue_capacity& dst, const ArgInfo& info)
| 59026 | { |  | 58978 | {
| 59027 | if(!src || src == Py_None) |  | 58979 | if(!src || src == Py_None)
| 59028 | return true; |  | 58980 | return true;
| 59029 | cv::gapi::streaming::queue_capacity * dst_; |  | 58981 | cv::gapi::streaming::queue_capacity * dst_;
| 59030 | if (pyopencv_gapi_streaming_queue_capacity_getp(src, dst_)) |  | 58982 | if (pyopencv_gapi_streaming_queue_capacity_getp(src, dst_))
| 59031 | { |  | 58983 | {
| 59032 | dst = *dst_; |  | 58984 | dst = *dst_;
| 59033 | return true; |  | 58985 | return true;
| 59034 | } |  | 58986 | }
| 59035 |  |  | 58987 |
| 59036 | failmsg("Expected cv::gapi::streaming::queue_capacity for argument '%s'", info.name); |  | 58988 | failmsg("Expected cv::gapi::streaming::queue_capacity for argument '%s'", info.name);
| 59037 | return false; |  | 58989 | return false;
| 59038 | } |  | 58990 | }
| 59039 | }; |  | 58991 | };
| 59040 |  |  | 58992 |
| 59041 | //================================================================================ |  | 58993 | //================================================================================
| 59042 | // gapi_wip_GOutputs (Generic) |  | 58994 | // gapi_wip_GOutputs (Generic)
| 59043 | //================================================================================ |  | 58995 | //================================================================================
| 59044 |  |  | 58996 |
| 59045 | // GetSet (gapi_wip_GOutputs) |  | 58997 | // GetSet (gapi_wip_GOutputs)
| 59046 |  |  | 58998 |
| 59047 |  |  | 58999 |
| 59048 |  |  | 59000 |
| 59049 | // Methods (gapi_wip_GOutputs) |  | 59001 | // Methods (gapi_wip_GOutputs)
| 59050 |  |  | 59002 |
| 59051 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGArray(PyObject* self, PyObject* py_args, PyObject* kw) |  | 59003 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGArray(PyObject* self, PyObject* py_args, PyObject* kw)
| 59052 | { |  | 59004 | {
| 59053 | using namespace cv::gapi::wip; |  | 59005 | using namespace cv::gapi::wip;
| 59054 |  |  | 59006 |
| 59055 |  |  | 59007 |
| 59056 | cv::gapi::wip::GOutputs * self1 = 0; |  | 59008 | cv::gapi::wip::GOutputs * self1 = 0;
| 59057 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1)) |  | 59009 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1))
| 59058 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)"); |  | 59010 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)");
| 59059 | cv::gapi::wip::GOutputs* _self_ = (self1); |  | 59011 | cv::gapi::wip::GOutputs* _self_ = (self1);
| 59060 | PyObject* pyobj_type = NULL; |  | 59012 | PyObject* pyobj_type = NULL;
| 59061 | gapi_ArgType type=static_cast<gapi_ArgType>(0); |  | 59013 | gapi_ArgType type=static_cast<gapi_ArgType>(0);
| 59062 | cv::GArrayT retval; |  | 59014 | cv::GArrayT retval;
| 59063 |  |  | 59015 |
| 59064 | const char* keywords[] = { "type", NULL }; |  | 59016 | const char* keywords[] = { "type", NULL };
| 59065 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_wip_GOutputs.getGArray", (char**)keywords, &pyobj_type) && |  | 59017 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_wip_GOutputs.getGArray", (char**)keywords, &pyobj_type) &&
| 59066 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 59018 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 59067 | { |  | 59019 | {
| 59068 | ERRWRAP2(retval = _self_->getGArray(type)); |  | 59020 | ERRWRAP2(retval = _self_->getGArray(type));
| 59069 | return pyopencv_from(retval); |  | 59021 | return pyopencv_from(retval);
| 59070 | } |  | 59022 | }
| 59071 |  |  | 59023 |
| 59072 | return NULL; |  | 59024 | return NULL;
| 59073 | } |  | 59025 | }
| 59074 |  |  | 59026 |
| 59075 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGMat(PyObject* self, PyObject* py_args, PyObject* kw) |  | 59027 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGMat(PyObject* self, PyObject* py_args, PyObject* kw)
| 59076 | { |  | 59028 | {
| 59077 | using namespace cv::gapi::wip; |  | 59029 | using namespace cv::gapi::wip;
| 59078 |  |  | 59030 |
| 59079 |  |  | 59031 |
| 59080 | cv::gapi::wip::GOutputs * self1 = 0; |  | 59032 | cv::gapi::wip::GOutputs * self1 = 0;
| 59081 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1)) |  | 59033 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1))
| 59082 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)"); |  | 59034 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)");
| 59083 | cv::gapi::wip::GOutputs* _self_ = (self1); |  | 59035 | cv::gapi::wip::GOutputs* _self_ = (self1);
| 59084 | cv::GMat retval; |  | 59036 | cv::GMat retval;
| 59085 |  |  | 59037 |
| 59086 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 59038 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 59087 | { |  | 59039 | {
| 59088 | ERRWRAP2(retval = _self_->getGMat()); |  | 59040 | ERRWRAP2(retval = _self_->getGMat());
| 59089 | return pyopencv_from(retval); |  | 59041 | return pyopencv_from(retval);
| 59090 | } |  | 59042 | }
| 59091 |  |  | 59043 |
| 59092 | return NULL; |  | 59044 | return NULL;
| 59093 | } |  | 59045 | }
| 59094 |  |  | 59046 |
| 59095 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGOpaque(PyObject* self, PyObject* py_args, PyObject* kw) |  | 59047 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGOpaque(PyObject* self, PyObject* py_args, PyObject* kw)
| 59096 | { |  | 59048 | {
| 59097 | using namespace cv::gapi::wip; |  | 59049 | using namespace cv::gapi::wip;
| 59098 |  |  | 59050 |
| 59099 |  |  | 59051 |
| 59100 | cv::gapi::wip::GOutputs * self1 = 0; |  | 59052 | cv::gapi::wip::GOutputs * self1 = 0;
| 59101 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1)) |  | 59053 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1))
| 59102 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)"); |  | 59054 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)");
| 59103 | cv::gapi::wip::GOutputs* _self_ = (self1); |  | 59055 | cv::gapi::wip::GOutputs* _self_ = (self1);
| 59104 | PyObject* pyobj_type = NULL; |  | 59056 | PyObject* pyobj_type = NULL;
| 59105 | gapi_ArgType type=static_cast<gapi_ArgType>(0); |  | 59057 | gapi_ArgType type=static_cast<gapi_ArgType>(0);
| 59106 | cv::GOpaqueT retval; |  | 59058 | cv::GOpaqueT retval;
| 59107 |  |  | 59059 |
| 59108 | const char* keywords[] = { "type", NULL }; |  | 59060 | const char* keywords[] = { "type", NULL };
| 59109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_wip_GOutputs.getGOpaque", (char**)keywords, &pyobj_type) && |  | 59061 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:gapi_wip_GOutputs.getGOpaque", (char**)keywords, &pyobj_type) &&
| 59110 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) ) |  | 59062 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) )
| 59111 | { |  | 59063 | {
| 59112 | ERRWRAP2(retval = _self_->getGOpaque(type)); |  | 59064 | ERRWRAP2(retval = _self_->getGOpaque(type));
| 59113 | return pyopencv_from(retval); |  | 59065 | return pyopencv_from(retval);
| 59114 | } |  | 59066 | }
| 59115 |  |  | 59067 |
| 59116 | return NULL; |  | 59068 | return NULL;
| 59117 | } |  | 59069 | }
| 59118 |  |  | 59070 |
| 59119 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGScalar(PyObject* self, PyObject* py_args, PyObject* kw) |  | 59071 | static PyObject* pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGScalar(PyObject* self, PyObject* py_args, PyObject* kw)
| 59120 | { |  | 59072 | {
| 59121 | using namespace cv::gapi::wip; |  | 59073 | using namespace cv::gapi::wip;
| 59122 |  |  | 59074 |
| 59123 |  |  | 59075 |
| 59124 | cv::gapi::wip::GOutputs * self1 = 0; |  | 59076 | cv::gapi::wip::GOutputs * self1 = 0;
| 59125 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1)) |  | 59077 | if (!pyopencv_gapi_wip_GOutputs_getp(self, self1))
| 59126 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)"); |  | 59078 | return failmsgp("Incorrect type of self (must be 'gapi_wip_GOutputs' or its derivative)");
| 59127 | cv::gapi::wip::GOutputs* _self_ = (self1); |  | 59079 | cv::gapi::wip::GOutputs* _self_ = (self1);
| 59128 | cv::GScalar retval; |  | 59080 | cv::GScalar retval;
| 59129 |  |  | 59081 |
| 59130 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 59082 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 59131 | { |  | 59083 | {
| 59132 | ERRWRAP2(retval = _self_->getGScalar()); |  | 59084 | ERRWRAP2(retval = _self_->getGScalar());
| 59133 | return pyopencv_from(retval); |  | 59085 | return pyopencv_from(retval);
| 59134 | } |  | 59086 | }
| 59135 |  |  | 59087 |
| 59136 | return NULL; |  | 59088 | return NULL;
| 59137 | } |  | 59089 | }
| 59138 |  |  | 59090 |
| 59139 |  |  | 59091 |
| 59140 |  |  | 59092 |
| 59141 | // Tables (gapi_wip_GOutputs) |  | 59093 | // Tables (gapi_wip_GOutputs)
| 59142 |  |  | 59094 |
| 59143 | static PyGetSetDef pyopencv_gapi_wip_GOutputs_getseters[] = |  | 59095 | static PyGetSetDef pyopencv_gapi_wip_GOutputs_getseters[] =
| 59144 | { |  | 59096 | {
| 59145 | {NULL} /* Sentinel */ |  | 59097 | {NULL} /* Sentinel */
| 59146 | }; |  | 59098 | };
| 59147 |  |  | 59099 |
| 59148 | static PyMethodDef pyopencv_gapi_wip_GOutputs_methods[] = |  | 59100 | static PyMethodDef pyopencv_gapi_wip_GOutputs_methods[] =
| 59149 | { |  | 59101 | {
| 59150 | {"getGArray", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGArray, 0), "getGArray(type) -> retval\n."}, |  | 59102 | {"getGArray", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGArray, 0), "getGArray(type) -> retval\n."},
| 59151 | {"getGMat", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGMat, 0), "getGMat() -> retval\n."}, |  | 59103 | {"getGMat", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGMat, 0), "getGMat() -> retval\n."},
| 59152 | {"getGOpaque", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGOpaque, 0), "getGOpaque(type) -> retval\n."}, |  | 59104 | {"getGOpaque", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGOpaque, 0), "getGOpaque(type) -> retval\n."},
| 59153 | {"getGScalar", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGScalar, 0), "getGScalar() -> retval\n."}, |  | 59105 | {"getGScalar", CV_PY_FN_WITH_KW_(pyopencv_cv_gapi_wip_gapi_wip_GOutputs_getGScalar, 0), "getGScalar() -> retval\n."},
| 59154 |  |  | 59106 |
| 59155 | {NULL, NULL} |  | 59107 | {NULL, NULL}
| 59156 | }; |  | 59108 | };
| 59157 |  |  | 59109 |
| 59158 | // Converter (gapi_wip_GOutputs) |  | 59110 | // Converter (gapi_wip_GOutputs)
| 59159 |  |  | 59111 |
| 59160 | template<> |  | 59112 | template<>
| 59161 | struct PyOpenCV_Converter< cv::gapi::wip::GOutputs > |  | 59113 | struct PyOpenCV_Converter< cv::gapi::wip::GOutputs >
| 59162 | { |  | 59114 | {
| 59163 | static PyObject* from(const cv::gapi::wip::GOutputs& r) |  | 59115 | static PyObject* from(const cv::gapi::wip::GOutputs& r)
| 59164 | { |  | 59116 | {
| 59165 | return pyopencv_gapi_wip_GOutputs_Instance(r); |  | 59117 | return pyopencv_gapi_wip_GOutputs_Instance(r);
| 59166 | } |  | 59118 | }
| 59167 | static bool to(PyObject* src, cv::gapi::wip::GOutputs& dst, const ArgInfo& info) |  | 59119 | static bool to(PyObject* src, cv::gapi::wip::GOutputs& dst, const ArgInfo& info)
| 59168 | { |  | 59120 | {
| 59169 | if(!src || src == Py_None) |  | 59121 | if(!src || src == Py_None)
| 59170 | return true; |  | 59122 | return true;
| 59171 | cv::gapi::wip::GOutputs * dst_; |  | 59123 | cv::gapi::wip::GOutputs * dst_;
| 59172 | if (pyopencv_gapi_wip_GOutputs_getp(src, dst_)) |  | 59124 | if (pyopencv_gapi_wip_GOutputs_getp(src, dst_))
| 59173 | { |  | 59125 | {
| 59174 | dst = *dst_; |  | 59126 | dst = *dst_;
| 59175 | return true; |  | 59127 | return true;
| 59176 | } |  | 59128 | }
| 59177 |  |  | 59129 |
| 59178 | failmsg("Expected cv::gapi::wip::GOutputs for argument '%s'", info.name); |  | 59130 | failmsg("Expected cv::gapi::wip::GOutputs for argument '%s'", info.name);
| 59179 | return false; |  | 59131 | return false;
| 59180 | } |  | 59132 | }
| 59181 | }; |  | 59133 | };
| 59182 |  |  | 59134 |
| 59183 | //================================================================================ |  | 59135 | //================================================================================
| 59184 | // gapi_wip_IStreamSource (Generic) |  | 59136 | // gapi_wip_IStreamSource (Generic)
| 59185 | //================================================================================ |  | 59137 | //================================================================================
| 59186 |  |  | 59138 |
| 59187 | // GetSet (gapi_wip_IStreamSource) |  | 59139 | // GetSet (gapi_wip_IStreamSource)
| 59188 |  |  | 59140 |
| 59189 |  |  | 59141 |
| 59190 |  |  | 59142 |
| 59191 | // Methods (gapi_wip_IStreamSource) |  | 59143 | // Methods (gapi_wip_IStreamSource)
| 59192 |  |  | 59144 |
| 59193 |  |  | 59145 |
| 59194 |  |  | 59146 |
| 59195 | // Tables (gapi_wip_IStreamSource) |  | 59147 | // Tables (gapi_wip_IStreamSource)
| 59196 |  |  | 59148 |
| 59197 | static PyGetSetDef pyopencv_gapi_wip_IStreamSource_getseters[] = |  | 59149 | static PyGetSetDef pyopencv_gapi_wip_IStreamSource_getseters[] =
| 59198 | { |  | 59150 | {
| 59199 | {NULL} /* Sentinel */ |  | 59151 | {NULL} /* Sentinel */
| 59200 | }; |  | 59152 | };
| 59201 |  |  | 59153 |
| 59202 | static PyMethodDef pyopencv_gapi_wip_IStreamSource_methods[] = |  | 59154 | static PyMethodDef pyopencv_gapi_wip_IStreamSource_methods[] =
| 59203 | { |  | 59155 | {
| 59204 |  |  | 59156 |
| 59205 | {NULL, NULL} |  | 59157 | {NULL, NULL}
| 59206 | }; |  | 59158 | };
| 59207 |  |  | 59159 |
| 59208 | // Converter (gapi_wip_IStreamSource) |  | 59160 | // Converter (gapi_wip_IStreamSource)
| 59209 |  |  | 59161 |
| 59210 | template<> |  | 59162 | template<>
| 59211 | struct PyOpenCV_Converter< Ptr<cv::gapi::wip::IStreamSource> > |  | 59163 | struct PyOpenCV_Converter< Ptr<cv::gapi::wip::IStreamSource> >
| 59212 | { |  | 59164 | {
| 59213 | static PyObject* from(const Ptr<cv::gapi::wip::IStreamSource>& r) |  | 59165 | static PyObject* from(const Ptr<cv::gapi::wip::IStreamSource>& r)
| 59214 | { |  | 59166 | {
| 59215 | return pyopencv_gapi_wip_IStreamSource_Instance(r); |  | 59167 | return pyopencv_gapi_wip_IStreamSource_Instance(r);
| 59216 | } |  | 59168 | }
| 59217 | static bool to(PyObject* src, Ptr<cv::gapi::wip::IStreamSource>& dst, const ArgInfo& info) |  | 59169 | static bool to(PyObject* src, Ptr<cv::gapi::wip::IStreamSource>& dst, const ArgInfo& info)
| 59218 | { |  | 59170 | {
| 59219 | if(!src || src == Py_None) |  | 59171 | if(!src || src == Py_None)
| 59220 | return true; |  | 59172 | return true;
| 59221 | Ptr<cv::gapi::wip::IStreamSource> * dst_; |  | 59173 | Ptr<cv::gapi::wip::IStreamSource> * dst_;
| 59222 | if (pyopencv_gapi_wip_IStreamSource_getp(src, dst_)) |  | 59174 | if (pyopencv_gapi_wip_IStreamSource_getp(src, dst_))
| 59223 | { |  | 59175 | {
| 59224 | dst = *dst_; |  | 59176 | dst = *dst_;
| 59225 | return true; |  | 59177 | return true;
| 59226 | } |  | 59178 | }
| 59227 |  |  | 59179 |
| 59228 | failmsg("Expected Ptr<cv::gapi::wip::IStreamSource> for argument '%s'", info.name); |  | 59180 | failmsg("Expected Ptr<cv::gapi::wip::IStreamSource> for argument '%s'", info.name);
| 59229 | return false; |  | 59181 | return false;
| 59230 | } |  | 59182 | }
| 59231 | }; |  | 59183 | };
| 59232 |  |  | 59184 |
| 59233 | //================================================================================ |  | 59185 | //================================================================================
| 59234 | // gapi_wip_draw_Circle (Generic) |  | 59186 | // gapi_wip_draw_Circle (Generic)
| 59235 | //================================================================================ |  | 59187 | //================================================================================
| 59236 |  |  | 59188 |
| 59237 | // GetSet (gapi_wip_draw_Circle) |  | 59189 | // GetSet (gapi_wip_draw_Circle)
| 59238 |  |  | 59190 |
| 59239 |  |  | 59191 |
| 59240 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_center(pyopencv_gapi_wip_draw_Circle_t* p, void *closure) |  | 59192 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_center(pyopencv_gapi_wip_draw_Circle_t* p, void *closure)
| 59241 | { |  | 59193 | {
| 59242 | return pyopencv_from(p->v.center); |  | 59194 | return pyopencv_from(p->v.center);
| 59243 | } |  | 59195 | }
| 59244 |  |  | 59196 |
| 59245 | static int pyopencv_gapi_wip_draw_Circle_set_center(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure) |  | 59197 | static int pyopencv_gapi_wip_draw_Circle_set_center(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure)
| 59246 | { |  | 59198 | {
| 59247 | if (!value) |  | 59199 | if (!value)
| 59248 | { |  | 59200 | {
| 59249 | PyErr_SetString(PyExc_TypeError, "Cannot delete the center attribute"); |  | 59201 | PyErr_SetString(PyExc_TypeError, "Cannot delete the center attribute");
| 59250 | return -1; |  | 59202 | return -1;
| 59251 | } |  | 59203 | }
| 59252 | return pyopencv_to_safe(value, p->v.center, ArgInfo("value", 0)) ? 0 : -1; |  | 59204 | return pyopencv_to_safe(value, p->v.center, ArgInfo("value", 0)) ? 0 : -1;
| 59253 | } |  | 59205 | }
| 59254 |  |  | 59206 |
| 59255 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_color(pyopencv_gapi_wip_draw_Circle_t* p, void *closure) |  | 59207 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_color(pyopencv_gapi_wip_draw_Circle_t* p, void *closure)
| 59256 | { |  | 59208 | {
| 59257 | return pyopencv_from(p->v.color); |  | 59209 | return pyopencv_from(p->v.color);
| 59258 | } |  | 59210 | }
| 59259 |  |  | 59211 |
| 59260 | static int pyopencv_gapi_wip_draw_Circle_set_color(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure) |  | 59212 | static int pyopencv_gapi_wip_draw_Circle_set_color(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure)
| 59261 | { |  | 59213 | {
| 59262 | if (!value) |  | 59214 | if (!value)
| 59263 | { |  | 59215 | {
| 59264 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute"); |  | 59216 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute");
| 59265 | return -1; |  | 59217 | return -1;
| 59266 | } |  | 59218 | }
| 59267 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1; |  | 59219 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1;
| 59268 | } |  | 59220 | }
| 59269 |  |  | 59221 |
| 59270 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_lt(pyopencv_gapi_wip_draw_Circle_t* p, void *closure) |  | 59222 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_lt(pyopencv_gapi_wip_draw_Circle_t* p, void *closure)
| 59271 | { |  | 59223 | {
| 59272 | return pyopencv_from(p->v.lt); |  | 59224 | return pyopencv_from(p->v.lt);
| 59273 | } |  | 59225 | }
| 59274 |  |  | 59226 |
| 59275 | static int pyopencv_gapi_wip_draw_Circle_set_lt(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure) |  | 59227 | static int pyopencv_gapi_wip_draw_Circle_set_lt(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure)
| 59276 | { |  | 59228 | {
| 59277 | if (!value) |  | 59229 | if (!value)
| 59278 | { |  | 59230 | {
| 59279 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute"); |  | 59231 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute");
| 59280 | return -1; |  | 59232 | return -1;
| 59281 | } |  | 59233 | }
| 59282 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1; |  | 59234 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1;
| 59283 | } |  | 59235 | }
| 59284 |  |  | 59236 |
| 59285 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_radius(pyopencv_gapi_wip_draw_Circle_t* p, void *closure) |  | 59237 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_radius(pyopencv_gapi_wip_draw_Circle_t* p, void *closure)
| 59286 | { |  | 59238 | {
| 59287 | return pyopencv_from(p->v.radius); |  | 59239 | return pyopencv_from(p->v.radius);
| 59288 | } |  | 59240 | }
| 59289 |  |  | 59241 |
| 59290 | static int pyopencv_gapi_wip_draw_Circle_set_radius(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure) |  | 59242 | static int pyopencv_gapi_wip_draw_Circle_set_radius(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure)
| 59291 | { |  | 59243 | {
| 59292 | if (!value) |  | 59244 | if (!value)
| 59293 | { |  | 59245 | {
| 59294 | PyErr_SetString(PyExc_TypeError, "Cannot delete the radius attribute"); |  | 59246 | PyErr_SetString(PyExc_TypeError, "Cannot delete the radius attribute");
| 59295 | return -1; |  | 59247 | return -1;
| 59296 | } |  | 59248 | }
| 59297 | return pyopencv_to_safe(value, p->v.radius, ArgInfo("value", 0)) ? 0 : -1; |  | 59249 | return pyopencv_to_safe(value, p->v.radius, ArgInfo("value", 0)) ? 0 : -1;
| 59298 | } |  | 59250 | }
| 59299 |  |  | 59251 |
| 59300 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_shift(pyopencv_gapi_wip_draw_Circle_t* p, void *closure) |  | 59252 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_shift(pyopencv_gapi_wip_draw_Circle_t* p, void *closure)
| 59301 | { |  | 59253 | {
| 59302 | return pyopencv_from(p->v.shift); |  | 59254 | return pyopencv_from(p->v.shift);
| 59303 | } |  | 59255 | }
| 59304 |  |  | 59256 |
| 59305 | static int pyopencv_gapi_wip_draw_Circle_set_shift(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure) |  | 59257 | static int pyopencv_gapi_wip_draw_Circle_set_shift(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure)
| 59306 | { |  | 59258 | {
| 59307 | if (!value) |  | 59259 | if (!value)
| 59308 | { |  | 59260 | {
| 59309 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute"); |  | 59261 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute");
| 59310 | return -1; |  | 59262 | return -1;
| 59311 | } |  | 59263 | }
| 59312 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1; |  | 59264 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1;
| 59313 | } |  | 59265 | }
| 59314 |  |  | 59266 |
| 59315 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_thick(pyopencv_gapi_wip_draw_Circle_t* p, void *closure) |  | 59267 | static PyObject* pyopencv_gapi_wip_draw_Circle_get_thick(pyopencv_gapi_wip_draw_Circle_t* p, void *closure)
| 59316 | { |  | 59268 | {
| 59317 | return pyopencv_from(p->v.thick); |  | 59269 | return pyopencv_from(p->v.thick);
| 59318 | } |  | 59270 | }
| 59319 |  |  | 59271 |
| 59320 | static int pyopencv_gapi_wip_draw_Circle_set_thick(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure) |  | 59272 | static int pyopencv_gapi_wip_draw_Circle_set_thick(pyopencv_gapi_wip_draw_Circle_t* p, PyObject *value, void *closure)
| 59321 | { |  | 59273 | {
| 59322 | if (!value) |  | 59274 | if (!value)
| 59323 | { |  | 59275 | {
| 59324 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute"); |  | 59276 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute");
| 59325 | return -1; |  | 59277 | return -1;
| 59326 | } |  | 59278 | }
| 59327 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1; |  | 59279 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1;
| 59328 | } |  | 59280 | }
| 59329 |  |  | 59281 |
| 59330 |  |  | 59282 |
| 59331 | // Methods (gapi_wip_draw_Circle) |  | 59283 | // Methods (gapi_wip_draw_Circle)
| 59332 |  |  | 59284 |
| 59333 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Circle_Circle(pyopencv_gapi_wip_draw_Circle_t* self, PyObject* py_args, PyObject* kw) |  | 59285 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Circle_Circle(pyopencv_gapi_wip_draw_Circle_t* self, PyObject* py_args, PyObject* kw)
| 59334 | { |  | 59286 | {
| 59335 | using namespace cv::gapi::wip::draw; |  | 59287 | using namespace cv::gapi::wip::draw;
| 59336 |  |  | 59288 |
| 59337 | pyPrepareArgumentConversionErrorsStorage(2); |  | 59289 | pyPrepareArgumentConversionErrorsStorage(2);
| 59338 |  |  | 59290 |
| 59339 | { |  | 59291 | {
| 59340 | PyObject* pyobj_center_ = NULL; |  | 59292 | PyObject* pyobj_center_ = NULL;
| 59341 | Point center_; |  | 59293 | Point center_;
| 59342 | PyObject* pyobj_radius_ = NULL; |  | 59294 | PyObject* pyobj_radius_ = NULL;
| 59343 | int radius_=0; |  | 59295 | int radius_=0;
| 59344 | PyObject* pyobj_color_ = NULL; |  | 59296 | PyObject* pyobj_color_ = NULL;
| 59345 | Scalar color_; |  | 59297 | Scalar color_;
| 59346 | PyObject* pyobj_thick_ = NULL; |  | 59298 | PyObject* pyobj_thick_ = NULL;
| 59347 | int thick_=1; |  | 59299 | int thick_=1;
| 59348 | PyObject* pyobj_lt_ = NULL; |  | 59300 | PyObject* pyobj_lt_ = NULL;
| 59349 | int lt_=8; |  | 59301 | int lt_=8;
| 59350 | PyObject* pyobj_shift_ = NULL; |  | 59302 | PyObject* pyobj_shift_ = NULL;
| 59351 | int shift_=0; |  | 59303 | int shift_=0;
| 59352 |  |  | 59304 |
| 59353 | const char* keywords[] = { "center_", "radius_", "color_", "thick_", "lt_", "shift_", NULL }; |  | 59305 | const char* keywords[] = { "center_", "radius_", "color_", "thick_", "lt_", "shift_", NULL };
| 59354 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:Circle", (char**)keywords, &pyobj_center_, &pyobj_radius_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) && |  | 59306 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:Circle", (char**)keywords, &pyobj_center_, &pyobj_radius_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) &&
| 59355 | pyopencv_to_safe(pyobj_center_, center_, ArgInfo("center_", 0)) && |  | 59307 | pyopencv_to_safe(pyobj_center_, center_, ArgInfo("center_", 0)) &&
| 59356 | pyopencv_to_safe(pyobj_radius_, radius_, ArgInfo("radius_", 0)) && |  | 59308 | pyopencv_to_safe(pyobj_radius_, radius_, ArgInfo("radius_", 0)) &&
| 59357 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) && |  | 59309 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) &&
| 59358 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) && |  | 59310 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) &&
| 59359 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) && |  | 59311 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) &&
| 59360 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) ) |  | 59312 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) )
| 59361 | { |  | 59313 | {
| 59362 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Circle(center_, radius_, color_, thick_, lt_, shift_)); |  | 59314 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Circle(center_, radius_, color_, thick_, lt_, shift_));
| 59363 | return 0; |  | 59315 | return 0;
| 59364 | } |  | 59316 | }
| 59365 |  |  | 59317 |
| 59366 |  |  | 59318 |
| 59367 | pyPopulateArgumentConversionErrors(); |  | 59319 | pyPopulateArgumentConversionErrors();
| 59368 | } |  | 59320 | }
| 59369 |  |  | 59321 |
| 59370 |  |  | 59322 |
| 59371 | { |  | 59323 | {
| 59372 |  |  | 59324 |
| 59373 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 59325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 59374 | { |  | 59326 | {
| 59375 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Circle()); |  | 59327 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Circle());
| 59376 | return 0; |  | 59328 | return 0;
| 59377 | } |  | 59329 | }
| 59378 |  |  | 59330 |
| 59379 |  |  | 59331 |
| 59380 | pyPopulateArgumentConversionErrors(); |  | 59332 | pyPopulateArgumentConversionErrors();
| 59381 | } |  | 59333 | }
| 59382 | pyRaiseCVOverloadException("Circle"); |  | 59334 | pyRaiseCVOverloadException("Circle");
| 59383 |  |  | 59335 |
| 59384 | return -1; |  | 59336 | return -1;
| 59385 | } |  | 59337 | }
| 59386 |  |  | 59338 |
| 59387 |  |  | 59339 |
| 59388 |  |  | 59340 |
| 59389 | // Tables (gapi_wip_draw_Circle) |  | 59341 | // Tables (gapi_wip_draw_Circle)
| 59390 |  |  | 59342 |
| 59391 | static PyGetSetDef pyopencv_gapi_wip_draw_Circle_getseters[] = |  | 59343 | static PyGetSetDef pyopencv_gapi_wip_draw_Circle_getseters[] =
| 59392 | { |  | 59344 | {
| 59393 | {(char*)"center", (getter)pyopencv_gapi_wip_draw_Circle_get_center, (setter)pyopencv_gapi_wip_draw_Circle_set_center, (char*)"center", NULL}, |  | 59345 | {(char*)"center", (getter)pyopencv_gapi_wip_draw_Circle_get_center, (setter)pyopencv_gapi_wip_draw_Circle_set_center, (char*)"center", NULL},
| 59394 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Circle_get_color, (setter)pyopencv_gapi_wip_draw_Circle_set_color, (char*)"color", NULL}, |  | 59346 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Circle_get_color, (setter)pyopencv_gapi_wip_draw_Circle_set_color, (char*)"color", NULL},
| 59395 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Circle_get_lt, (setter)pyopencv_gapi_wip_draw_Circle_set_lt, (char*)"lt", NULL}, |  | 59347 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Circle_get_lt, (setter)pyopencv_gapi_wip_draw_Circle_set_lt, (char*)"lt", NULL},
| 59396 | {(char*)"radius", (getter)pyopencv_gapi_wip_draw_Circle_get_radius, (setter)pyopencv_gapi_wip_draw_Circle_set_radius, (char*)"radius", NULL}, |  | 59348 | {(char*)"radius", (getter)pyopencv_gapi_wip_draw_Circle_get_radius, (setter)pyopencv_gapi_wip_draw_Circle_set_radius, (char*)"radius", NULL},
| 59397 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Circle_get_shift, (setter)pyopencv_gapi_wip_draw_Circle_set_shift, (char*)"shift", NULL}, |  | 59349 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Circle_get_shift, (setter)pyopencv_gapi_wip_draw_Circle_set_shift, (char*)"shift", NULL},
| 59398 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Circle_get_thick, (setter)pyopencv_gapi_wip_draw_Circle_set_thick, (char*)"thick", NULL}, |  | 59350 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Circle_get_thick, (setter)pyopencv_gapi_wip_draw_Circle_set_thick, (char*)"thick", NULL},
| 59399 | {NULL} /* Sentinel */ |  | 59351 | {NULL} /* Sentinel */
| 59400 | }; |  | 59352 | };
| 59401 |  |  | 59353 |
| 59402 | static PyMethodDef pyopencv_gapi_wip_draw_Circle_methods[] = |  | 59354 | static PyMethodDef pyopencv_gapi_wip_draw_Circle_methods[] =
| 59403 | { |  | 59355 | {
| 59404 |  |  | 59356 |
| 59405 | {NULL, NULL} |  | 59357 | {NULL, NULL}
| 59406 | }; |  | 59358 | };
| 59407 |  |  | 59359 |
| 59408 | // Converter (gapi_wip_draw_Circle) |  | 59360 | // Converter (gapi_wip_draw_Circle)
| 59409 |  |  | 59361 |
| 59410 | template<> |  | 59362 | template<>
| 59411 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Circle > |  | 59363 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Circle >
| 59412 | { |  | 59364 | {
| 59413 | static PyObject* from(const cv::gapi::wip::draw::Circle& r) |  | 59365 | static PyObject* from(const cv::gapi::wip::draw::Circle& r)
| 59414 | { |  | 59366 | {
| 59415 | return pyopencv_gapi_wip_draw_Circle_Instance(r); |  | 59367 | return pyopencv_gapi_wip_draw_Circle_Instance(r);
| 59416 | } |  | 59368 | }
| 59417 | static bool to(PyObject* src, cv::gapi::wip::draw::Circle& dst, const ArgInfo& info) |  | 59369 | static bool to(PyObject* src, cv::gapi::wip::draw::Circle& dst, const ArgInfo& info)
| 59418 | { |  | 59370 | {
| 59419 | if(!src || src == Py_None) |  | 59371 | if(!src || src == Py_None)
| 59420 | return true; |  | 59372 | return true;
| 59421 | cv::gapi::wip::draw::Circle * dst_; |  | 59373 | cv::gapi::wip::draw::Circle * dst_;
| 59422 | if (pyopencv_gapi_wip_draw_Circle_getp(src, dst_)) |  | 59374 | if (pyopencv_gapi_wip_draw_Circle_getp(src, dst_))
| 59423 | { |  | 59375 | {
| 59424 | dst = *dst_; |  | 59376 | dst = *dst_;
| 59425 | return true; |  | 59377 | return true;
| 59426 | } |  | 59378 | }
| 59427 |  |  | 59379 |
| 59428 | failmsg("Expected cv::gapi::wip::draw::Circle for argument '%s'", info.name); |  | 59380 | failmsg("Expected cv::gapi::wip::draw::Circle for argument '%s'", info.name);
| 59429 | return false; |  | 59381 | return false;
| 59430 | } |  | 59382 | }
| 59431 | }; |  | 59383 | };
| 59432 |  |  | 59384 |
| 59433 | //================================================================================ |  | 59385 | //================================================================================
| 59434 | // gapi_wip_draw_Image (Generic) |  | 59386 | // gapi_wip_draw_Image (Generic)
| 59435 | //================================================================================ |  | 59387 | //================================================================================
| 59436 |  |  | 59388 |
| 59437 | // GetSet (gapi_wip_draw_Image) |  | 59389 | // GetSet (gapi_wip_draw_Image)
| 59438 |  |  | 59390 |
| 59439 |  |  | 59391 |
| 59440 | static PyObject* pyopencv_gapi_wip_draw_Image_get_alpha(pyopencv_gapi_wip_draw_Image_t* p, void *closure) |  | 59392 | static PyObject* pyopencv_gapi_wip_draw_Image_get_alpha(pyopencv_gapi_wip_draw_Image_t* p, void *closure)
| 59441 | { |  | 59393 | {
| 59442 | return pyopencv_from(p->v.alpha); |  | 59394 | return pyopencv_from(p->v.alpha);
| 59443 | } |  | 59395 | }
| 59444 |  |  | 59396 |
| 59445 | static int pyopencv_gapi_wip_draw_Image_set_alpha(pyopencv_gapi_wip_draw_Image_t* p, PyObject *value, void *closure) |  | 59397 | static int pyopencv_gapi_wip_draw_Image_set_alpha(pyopencv_gapi_wip_draw_Image_t* p, PyObject *value, void *closure)
| 59446 | { |  | 59398 | {
| 59447 | if (!value) |  | 59399 | if (!value)
| 59448 | { |  | 59400 | {
| 59449 | PyErr_SetString(PyExc_TypeError, "Cannot delete the alpha attribute"); |  | 59401 | PyErr_SetString(PyExc_TypeError, "Cannot delete the alpha attribute");
| 59450 | return -1; |  | 59402 | return -1;
| 59451 | } |  | 59403 | }
| 59452 | return pyopencv_to_safe(value, p->v.alpha, ArgInfo("value", 0)) ? 0 : -1; |  | 59404 | return pyopencv_to_safe(value, p->v.alpha, ArgInfo("value", 0)) ? 0 : -1;
| 59453 | } |  | 59405 | }
| 59454 |  |  | 59406 |
| 59455 | static PyObject* pyopencv_gapi_wip_draw_Image_get_img(pyopencv_gapi_wip_draw_Image_t* p, void *closure) |  | 59407 | static PyObject* pyopencv_gapi_wip_draw_Image_get_img(pyopencv_gapi_wip_draw_Image_t* p, void *closure)
| 59456 | { |  | 59408 | {
| 59457 | return pyopencv_from(p->v.img); |  | 59409 | return pyopencv_from(p->v.img);
| 59458 | } |  | 59410 | }
| 59459 |  |  | 59411 |
| 59460 | static int pyopencv_gapi_wip_draw_Image_set_img(pyopencv_gapi_wip_draw_Image_t* p, PyObject *value, void *closure) |  | 59412 | static int pyopencv_gapi_wip_draw_Image_set_img(pyopencv_gapi_wip_draw_Image_t* p, PyObject *value, void *closure)
| 59461 | { |  | 59413 | {
| 59462 | if (!value) |  | 59414 | if (!value)
| 59463 | { |  | 59415 | {
| 59464 | PyErr_SetString(PyExc_TypeError, "Cannot delete the img attribute"); |  | 59416 | PyErr_SetString(PyExc_TypeError, "Cannot delete the img attribute");
| 59465 | return -1; |  | 59417 | return -1;
| 59466 | } |  | 59418 | }
| 59467 | return pyopencv_to_safe(value, p->v.img, ArgInfo("value", 0)) ? 0 : -1; |  | 59419 | return pyopencv_to_safe(value, p->v.img, ArgInfo("value", 0)) ? 0 : -1;
| 59468 | } |  | 59420 | }
| 59469 |  |  | 59421 |
| 59470 | static PyObject* pyopencv_gapi_wip_draw_Image_get_org(pyopencv_gapi_wip_draw_Image_t* p, void *closure) |  | 59422 | static PyObject* pyopencv_gapi_wip_draw_Image_get_org(pyopencv_gapi_wip_draw_Image_t* p, void *closure)
| 59471 | { |  | 59423 | {
| 59472 | return pyopencv_from(p->v.org); |  | 59424 | return pyopencv_from(p->v.org);
| 59473 | } |  | 59425 | }
| 59474 |  |  | 59426 |
| 59475 | static int pyopencv_gapi_wip_draw_Image_set_org(pyopencv_gapi_wip_draw_Image_t* p, PyObject *value, void *closure) |  | 59427 | static int pyopencv_gapi_wip_draw_Image_set_org(pyopencv_gapi_wip_draw_Image_t* p, PyObject *value, void *closure)
| 59476 | { |  | 59428 | {
| 59477 | if (!value) |  | 59429 | if (!value)
| 59478 | { |  | 59430 | {
| 59479 | PyErr_SetString(PyExc_TypeError, "Cannot delete the org attribute"); |  | 59431 | PyErr_SetString(PyExc_TypeError, "Cannot delete the org attribute");
| 59480 | return -1; |  | 59432 | return -1;
| 59481 | } |  | 59433 | }
| 59482 | return pyopencv_to_safe(value, p->v.org, ArgInfo("value", 0)) ? 0 : -1; |  | 59434 | return pyopencv_to_safe(value, p->v.org, ArgInfo("value", 0)) ? 0 : -1;
| 59483 | } |  | 59435 | }
| 59484 |  |  | 59436 |
| 59485 |  |  | 59437 |
| 59486 | // Methods (gapi_wip_draw_Image) |  | 59438 | // Methods (gapi_wip_draw_Image)
| 59487 |  |  | 59439 |
| 59488 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Image_Image(pyopencv_gapi_wip_draw_Image_t* self, PyObject* py_args, PyObject* kw) |  | 59440 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Image_Image(pyopencv_gapi_wip_draw_Image_t* self, PyObject* py_args, PyObject* kw)
| 59489 | { |  | 59441 | {
| 59490 | using namespace cv::gapi::wip::draw; |  | 59442 | using namespace cv::gapi::wip::draw;
| 59491 |  |  | 59443 |
| 59492 | pyPrepareArgumentConversionErrorsStorage(2); |  | 59444 | pyPrepareArgumentConversionErrorsStorage(2);
| 59493 |  |  | 59445 |
| 59494 | { |  | 59446 | {
| 59495 | PyObject* pyobj_org_ = NULL; |  | 59447 | PyObject* pyobj_org_ = NULL;
| 59496 | Point org_; |  | 59448 | Point org_;
| 59497 | PyObject* pyobj_img_ = NULL; |  | 59449 | PyObject* pyobj_img_ = NULL;
| 59498 | Mat img_; |  | 59450 | Mat img_;
| 59499 | PyObject* pyobj_alpha_ = NULL; |  | 59451 | PyObject* pyobj_alpha_ = NULL;
| 59500 | Mat alpha_; |  | 59452 | Mat alpha_;
| 59501 |  |  | 59453 |
| 59502 | const char* keywords[] = { "org_", "img_", "alpha_", NULL }; |  | 59454 | const char* keywords[] = { "org_", "img_", "alpha_", NULL };
| 59503 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Image", (char**)keywords, &pyobj_org_, &pyobj_img_, &pyobj_alpha_) && |  | 59455 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Image", (char**)keywords, &pyobj_org_, &pyobj_img_, &pyobj_alpha_) &&
| 59504 | pyopencv_to_safe(pyobj_org_, org_, ArgInfo("org_", 0)) && |  | 59456 | pyopencv_to_safe(pyobj_org_, org_, ArgInfo("org_", 0)) &&
| 59505 | pyopencv_to_safe(pyobj_img_, img_, ArgInfo("img_", 0)) && |  | 59457 | pyopencv_to_safe(pyobj_img_, img_, ArgInfo("img_", 0)) &&
| 59506 | pyopencv_to_safe(pyobj_alpha_, alpha_, ArgInfo("alpha_", 0)) ) |  | 59458 | pyopencv_to_safe(pyobj_alpha_, alpha_, ArgInfo("alpha_", 0)) )
| 59507 | { |  | 59459 | {
| 59508 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Image(org_, img_, alpha_)); |  | 59460 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Image(org_, img_, alpha_));
| 59509 | return 0; |  | 59461 | return 0;
| 59510 | } |  | 59462 | }
| 59511 |  |  | 59463 |
| 59512 |  |  | 59464 |
| 59513 | pyPopulateArgumentConversionErrors(); |  | 59465 | pyPopulateArgumentConversionErrors();
| 59514 | } |  | 59466 | }
| 59515 |  |  | 59467 |
| 59516 |  |  | 59468 |
| 59517 | { |  | 59469 | {
| 59518 |  |  | 59470 |
| 59519 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 59471 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 59520 | { |  | 59472 | {
| 59521 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Image()); |  | 59473 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Image());
| 59522 | return 0; |  | 59474 | return 0;
| 59523 | } |  | 59475 | }
| 59524 |  |  | 59476 |
| 59525 |  |  | 59477 |
| 59526 | pyPopulateArgumentConversionErrors(); |  | 59478 | pyPopulateArgumentConversionErrors();
| 59527 | } |  | 59479 | }
| 59528 | pyRaiseCVOverloadException("Image"); |  | 59480 | pyRaiseCVOverloadException("Image");
| 59529 |  |  | 59481 |
| 59530 | return -1; |  | 59482 | return -1;
| 59531 | } |  | 59483 | }
| 59532 |  |  | 59484 |
| 59533 |  |  | 59485 |
| 59534 |  |  | 59486 |
| 59535 | // Tables (gapi_wip_draw_Image) |  | 59487 | // Tables (gapi_wip_draw_Image)
| 59536 |  |  | 59488 |
| 59537 | static PyGetSetDef pyopencv_gapi_wip_draw_Image_getseters[] = |  | 59489 | static PyGetSetDef pyopencv_gapi_wip_draw_Image_getseters[] =
| 59538 | { |  | 59490 | {
| 59539 | {(char*)"alpha", (getter)pyopencv_gapi_wip_draw_Image_get_alpha, (setter)pyopencv_gapi_wip_draw_Image_set_alpha, (char*)"alpha", NULL}, |  | 59491 | {(char*)"alpha", (getter)pyopencv_gapi_wip_draw_Image_get_alpha, (setter)pyopencv_gapi_wip_draw_Image_set_alpha, (char*)"alpha", NULL},
| 59540 | {(char*)"img", (getter)pyopencv_gapi_wip_draw_Image_get_img, (setter)pyopencv_gapi_wip_draw_Image_set_img, (char*)"img", NULL}, |  | 59492 | {(char*)"img", (getter)pyopencv_gapi_wip_draw_Image_get_img, (setter)pyopencv_gapi_wip_draw_Image_set_img, (char*)"img", NULL},
| 59541 | {(char*)"org", (getter)pyopencv_gapi_wip_draw_Image_get_org, (setter)pyopencv_gapi_wip_draw_Image_set_org, (char*)"org", NULL}, |  | 59493 | {(char*)"org", (getter)pyopencv_gapi_wip_draw_Image_get_org, (setter)pyopencv_gapi_wip_draw_Image_set_org, (char*)"org", NULL},
| 59542 | {NULL} /* Sentinel */ |  | 59494 | {NULL} /* Sentinel */
| 59543 | }; |  | 59495 | };
| 59544 |  |  | 59496 |
| 59545 | static PyMethodDef pyopencv_gapi_wip_draw_Image_methods[] = |  | 59497 | static PyMethodDef pyopencv_gapi_wip_draw_Image_methods[] =
| 59546 | { |  | 59498 | {
| 59547 |  |  | 59499 |
| 59548 | {NULL, NULL} |  | 59500 | {NULL, NULL}
| 59549 | }; |  | 59501 | };
| 59550 |  |  | 59502 |
| 59551 | // Converter (gapi_wip_draw_Image) |  | 59503 | // Converter (gapi_wip_draw_Image)
| 59552 |  |  | 59504 |
| 59553 | template<> |  | 59505 | template<>
| 59554 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Image > |  | 59506 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Image >
| 59555 | { |  | 59507 | {
| 59556 | static PyObject* from(const cv::gapi::wip::draw::Image& r) |  | 59508 | static PyObject* from(const cv::gapi::wip::draw::Image& r)
| 59557 | { |  | 59509 | {
| 59558 | return pyopencv_gapi_wip_draw_Image_Instance(r); |  | 59510 | return pyopencv_gapi_wip_draw_Image_Instance(r);
| 59559 | } |  | 59511 | }
| 59560 | static bool to(PyObject* src, cv::gapi::wip::draw::Image& dst, const ArgInfo& info) |  | 59512 | static bool to(PyObject* src, cv::gapi::wip::draw::Image& dst, const ArgInfo& info)
| 59561 | { |  | 59513 | {
| 59562 | if(!src || src == Py_None) |  | 59514 | if(!src || src == Py_None)
| 59563 | return true; |  | 59515 | return true;
| 59564 | cv::gapi::wip::draw::Image * dst_; |  | 59516 | cv::gapi::wip::draw::Image * dst_;
| 59565 | if (pyopencv_gapi_wip_draw_Image_getp(src, dst_)) |  | 59517 | if (pyopencv_gapi_wip_draw_Image_getp(src, dst_))
| 59566 | { |  | 59518 | {
| 59567 | dst = *dst_; |  | 59519 | dst = *dst_;
| 59568 | return true; |  | 59520 | return true;
| 59569 | } |  | 59521 | }
| 59570 |  |  | 59522 |
| 59571 | failmsg("Expected cv::gapi::wip::draw::Image for argument '%s'", info.name); |  | 59523 | failmsg("Expected cv::gapi::wip::draw::Image for argument '%s'", info.name);
| 59572 | return false; |  | 59524 | return false;
| 59573 | } |  | 59525 | }
| 59574 | }; |  | 59526 | };
| 59575 |  |  | 59527 |
| 59576 | //================================================================================ |  | 59528 | //================================================================================
| 59577 | // gapi_wip_draw_Line (Generic) |  | 59529 | // gapi_wip_draw_Line (Generic)
| 59578 | //================================================================================ |  | 59530 | //================================================================================
| 59579 |  |  | 59531 |
| 59580 | // GetSet (gapi_wip_draw_Line) |  | 59532 | // GetSet (gapi_wip_draw_Line)
| 59581 |  |  | 59533 |
| 59582 |  |  | 59534 |
| 59583 | static PyObject* pyopencv_gapi_wip_draw_Line_get_color(pyopencv_gapi_wip_draw_Line_t* p, void *closure) |  | 59535 | static PyObject* pyopencv_gapi_wip_draw_Line_get_color(pyopencv_gapi_wip_draw_Line_t* p, void *closure)
| 59584 | { |  | 59536 | {
| 59585 | return pyopencv_from(p->v.color); |  | 59537 | return pyopencv_from(p->v.color);
| 59586 | } |  | 59538 | }
| 59587 |  |  | 59539 |
| 59588 | static int pyopencv_gapi_wip_draw_Line_set_color(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure) |  | 59540 | static int pyopencv_gapi_wip_draw_Line_set_color(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure)
| 59589 | { |  | 59541 | {
| 59590 | if (!value) |  | 59542 | if (!value)
| 59591 | { |  | 59543 | {
| 59592 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute"); |  | 59544 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute");
| 59593 | return -1; |  | 59545 | return -1;
| 59594 | } |  | 59546 | }
| 59595 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1; |  | 59547 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1;
| 59596 | } |  | 59548 | }
| 59597 |  |  | 59549 |
| 59598 | static PyObject* pyopencv_gapi_wip_draw_Line_get_lt(pyopencv_gapi_wip_draw_Line_t* p, void *closure) |  | 59550 | static PyObject* pyopencv_gapi_wip_draw_Line_get_lt(pyopencv_gapi_wip_draw_Line_t* p, void *closure)
| 59599 | { |  | 59551 | {
| 59600 | return pyopencv_from(p->v.lt); |  | 59552 | return pyopencv_from(p->v.lt);
| 59601 | } |  | 59553 | }
| 59602 |  |  | 59554 |
| 59603 | static int pyopencv_gapi_wip_draw_Line_set_lt(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure) |  | 59555 | static int pyopencv_gapi_wip_draw_Line_set_lt(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure)
| 59604 | { |  | 59556 | {
| 59605 | if (!value) |  | 59557 | if (!value)
| 59606 | { |  | 59558 | {
| 59607 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute"); |  | 59559 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute");
| 59608 | return -1; |  | 59560 | return -1;
| 59609 | } |  | 59561 | }
| 59610 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1; |  | 59562 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1;
| 59611 | } |  | 59563 | }
| 59612 |  |  | 59564 |
| 59613 | static PyObject* pyopencv_gapi_wip_draw_Line_get_pt1(pyopencv_gapi_wip_draw_Line_t* p, void *closure) |  | 59565 | static PyObject* pyopencv_gapi_wip_draw_Line_get_pt1(pyopencv_gapi_wip_draw_Line_t* p, void *closure)
| 59614 | { |  | 59566 | {
| 59615 | return pyopencv_from(p->v.pt1); |  | 59567 | return pyopencv_from(p->v.pt1);
| 59616 | } |  | 59568 | }
| 59617 |  |  | 59569 |
| 59618 | static int pyopencv_gapi_wip_draw_Line_set_pt1(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure) |  | 59570 | static int pyopencv_gapi_wip_draw_Line_set_pt1(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure)
| 59619 | { |  | 59571 | {
| 59620 | if (!value) |  | 59572 | if (!value)
| 59621 | { |  | 59573 | {
| 59622 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt1 attribute"); |  | 59574 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt1 attribute");
| 59623 | return -1; |  | 59575 | return -1;
| 59624 | } |  | 59576 | }
| 59625 | return pyopencv_to_safe(value, p->v.pt1, ArgInfo("value", 0)) ? 0 : -1; |  | 59577 | return pyopencv_to_safe(value, p->v.pt1, ArgInfo("value", 0)) ? 0 : -1;
| 59626 | } |  | 59578 | }
| 59627 |  |  | 59579 |
| 59628 | static PyObject* pyopencv_gapi_wip_draw_Line_get_pt2(pyopencv_gapi_wip_draw_Line_t* p, void *closure) |  | 59580 | static PyObject* pyopencv_gapi_wip_draw_Line_get_pt2(pyopencv_gapi_wip_draw_Line_t* p, void *closure)
| 59629 | { |  | 59581 | {
| 59630 | return pyopencv_from(p->v.pt2); |  | 59582 | return pyopencv_from(p->v.pt2);
| 59631 | } |  | 59583 | }
| 59632 |  |  | 59584 |
| 59633 | static int pyopencv_gapi_wip_draw_Line_set_pt2(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure) |  | 59585 | static int pyopencv_gapi_wip_draw_Line_set_pt2(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure)
| 59634 | { |  | 59586 | {
| 59635 | if (!value) |  | 59587 | if (!value)
| 59636 | { |  | 59588 | {
| 59637 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt2 attribute"); |  | 59589 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt2 attribute");
| 59638 | return -1; |  | 59590 | return -1;
| 59639 | } |  | 59591 | }
| 59640 | return pyopencv_to_safe(value, p->v.pt2, ArgInfo("value", 0)) ? 0 : -1; |  | 59592 | return pyopencv_to_safe(value, p->v.pt2, ArgInfo("value", 0)) ? 0 : -1;
| 59641 | } |  | 59593 | }
| 59642 |  |  | 59594 |
| 59643 | static PyObject* pyopencv_gapi_wip_draw_Line_get_shift(pyopencv_gapi_wip_draw_Line_t* p, void *closure) |  | 59595 | static PyObject* pyopencv_gapi_wip_draw_Line_get_shift(pyopencv_gapi_wip_draw_Line_t* p, void *closure)
| 59644 | { |  | 59596 | {
| 59645 | return pyopencv_from(p->v.shift); |  | 59597 | return pyopencv_from(p->v.shift);
| 59646 | } |  | 59598 | }
| 59647 |  |  | 59599 |
| 59648 | static int pyopencv_gapi_wip_draw_Line_set_shift(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure) |  | 59600 | static int pyopencv_gapi_wip_draw_Line_set_shift(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure)
| 59649 | { |  | 59601 | {
| 59650 | if (!value) |  | 59602 | if (!value)
| 59651 | { |  | 59603 | {
| 59652 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute"); |  | 59604 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute");
| 59653 | return -1; |  | 59605 | return -1;
| 59654 | } |  | 59606 | }
| 59655 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1; |  | 59607 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1;
| 59656 | } |  | 59608 | }
| 59657 |  |  | 59609 |
| 59658 | static PyObject* pyopencv_gapi_wip_draw_Line_get_thick(pyopencv_gapi_wip_draw_Line_t* p, void *closure) |  | 59610 | static PyObject* pyopencv_gapi_wip_draw_Line_get_thick(pyopencv_gapi_wip_draw_Line_t* p, void *closure)
| 59659 | { |  | 59611 | {
| 59660 | return pyopencv_from(p->v.thick); |  | 59612 | return pyopencv_from(p->v.thick);
| 59661 | } |  | 59613 | }
| 59662 |  |  | 59614 |
| 59663 | static int pyopencv_gapi_wip_draw_Line_set_thick(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure) |  | 59615 | static int pyopencv_gapi_wip_draw_Line_set_thick(pyopencv_gapi_wip_draw_Line_t* p, PyObject *value, void *closure)
| 59664 | { |  | 59616 | {
| 59665 | if (!value) |  | 59617 | if (!value)
| 59666 | { |  | 59618 | {
| 59667 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute"); |  | 59619 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute");
| 59668 | return -1; |  | 59620 | return -1;
| 59669 | } |  | 59621 | }
| 59670 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1; |  | 59622 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1;
| 59671 | } |  | 59623 | }
| 59672 |  |  | 59624 |
| 59673 |  |  | 59625 |
| 59674 | // Methods (gapi_wip_draw_Line) |  | 59626 | // Methods (gapi_wip_draw_Line)
| 59675 |  |  | 59627 |
| 59676 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Line_Line(pyopencv_gapi_wip_draw_Line_t* self, PyObject* py_args, PyObject* kw) |  | 59628 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Line_Line(pyopencv_gapi_wip_draw_Line_t* self, PyObject* py_args, PyObject* kw)
| 59677 | { |  | 59629 | {
| 59678 | using namespace cv::gapi::wip::draw; |  | 59630 | using namespace cv::gapi::wip::draw;
| 59679 |  |  | 59631 |
| 59680 | pyPrepareArgumentConversionErrorsStorage(2); |  | 59632 | pyPrepareArgumentConversionErrorsStorage(2);
| 59681 |  |  | 59633 |
| 59682 | { |  | 59634 | {
| 59683 | PyObject* pyobj_pt1_ = NULL; |  | 59635 | PyObject* pyobj_pt1_ = NULL;
| 59684 | Point pt1_; |  | 59636 | Point pt1_;
| 59685 | PyObject* pyobj_pt2_ = NULL; |  | 59637 | PyObject* pyobj_pt2_ = NULL;
| 59686 | Point pt2_; |  | 59638 | Point pt2_;
| 59687 | PyObject* pyobj_color_ = NULL; |  | 59639 | PyObject* pyobj_color_ = NULL;
| 59688 | Scalar color_; |  | 59640 | Scalar color_;
| 59689 | PyObject* pyobj_thick_ = NULL; |  | 59641 | PyObject* pyobj_thick_ = NULL;
| 59690 | int thick_=1; |  | 59642 | int thick_=1;
| 59691 | PyObject* pyobj_lt_ = NULL; |  | 59643 | PyObject* pyobj_lt_ = NULL;
| 59692 | int lt_=8; |  | 59644 | int lt_=8;
| 59693 | PyObject* pyobj_shift_ = NULL; |  | 59645 | PyObject* pyobj_shift_ = NULL;
| 59694 | int shift_=0; |  | 59646 | int shift_=0;
| 59695 |  |  | 59647 |
| 59696 | const char* keywords[] = { "pt1_", "pt2_", "color_", "thick_", "lt_", "shift_", NULL }; |  | 59648 | const char* keywords[] = { "pt1_", "pt2_", "color_", "thick_", "lt_", "shift_", NULL };
| 59697 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:Line", (char**)keywords, &pyobj_pt1_, &pyobj_pt2_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) && |  | 59649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:Line", (char**)keywords, &pyobj_pt1_, &pyobj_pt2_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) &&
| 59698 | pyopencv_to_safe(pyobj_pt1_, pt1_, ArgInfo("pt1_", 0)) && |  | 59650 | pyopencv_to_safe(pyobj_pt1_, pt1_, ArgInfo("pt1_", 0)) &&
| 59699 | pyopencv_to_safe(pyobj_pt2_, pt2_, ArgInfo("pt2_", 0)) && |  | 59651 | pyopencv_to_safe(pyobj_pt2_, pt2_, ArgInfo("pt2_", 0)) &&
| 59700 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) && |  | 59652 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) &&
| 59701 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) && |  | 59653 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) &&
| 59702 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) && |  | 59654 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) &&
| 59703 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) ) |  | 59655 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) )
| 59704 | { |  | 59656 | {
| 59705 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Line(pt1_, pt2_, color_, thick_, lt_, shift_)); |  | 59657 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Line(pt1_, pt2_, color_, thick_, lt_, shift_));
| 59706 | return 0; |  | 59658 | return 0;
| 59707 | } |  | 59659 | }
| 59708 |  |  | 59660 |
| 59709 |  |  | 59661 |
| 59710 | pyPopulateArgumentConversionErrors(); |  | 59662 | pyPopulateArgumentConversionErrors();
| 59711 | } |  | 59663 | }
| 59712 |  |  | 59664 |
| 59713 |  |  | 59665 |
| 59714 | { |  | 59666 | {
| 59715 |  |  | 59667 |
| 59716 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 59668 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 59717 | { |  | 59669 | {
| 59718 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Line()); |  | 59670 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Line());
| 59719 | return 0; |  | 59671 | return 0;
| 59720 | } |  | 59672 | }
| 59721 |  |  | 59673 |
| 59722 |  |  | 59674 |
| 59723 | pyPopulateArgumentConversionErrors(); |  | 59675 | pyPopulateArgumentConversionErrors();
| 59724 | } |  | 59676 | }
| 59725 | pyRaiseCVOverloadException("Line"); |  | 59677 | pyRaiseCVOverloadException("Line");
| 59726 |  |  | 59678 |
| 59727 | return -1; |  | 59679 | return -1;
| 59728 | } |  | 59680 | }
| 59729 |  |  | 59681 |
| 59730 |  |  | 59682 |
| 59731 |  |  | 59683 |
| 59732 | // Tables (gapi_wip_draw_Line) |  | 59684 | // Tables (gapi_wip_draw_Line)
| 59733 |  |  | 59685 |
| 59734 | static PyGetSetDef pyopencv_gapi_wip_draw_Line_getseters[] = |  | 59686 | static PyGetSetDef pyopencv_gapi_wip_draw_Line_getseters[] =
| 59735 | { |  | 59687 | {
| 59736 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Line_get_color, (setter)pyopencv_gapi_wip_draw_Line_set_color, (char*)"color", NULL}, |  | 59688 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Line_get_color, (setter)pyopencv_gapi_wip_draw_Line_set_color, (char*)"color", NULL},
| 59737 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Line_get_lt, (setter)pyopencv_gapi_wip_draw_Line_set_lt, (char*)"lt", NULL}, |  | 59689 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Line_get_lt, (setter)pyopencv_gapi_wip_draw_Line_set_lt, (char*)"lt", NULL},
| 59738 | {(char*)"pt1", (getter)pyopencv_gapi_wip_draw_Line_get_pt1, (setter)pyopencv_gapi_wip_draw_Line_set_pt1, (char*)"pt1", NULL}, |  | 59690 | {(char*)"pt1", (getter)pyopencv_gapi_wip_draw_Line_get_pt1, (setter)pyopencv_gapi_wip_draw_Line_set_pt1, (char*)"pt1", NULL},
| 59739 | {(char*)"pt2", (getter)pyopencv_gapi_wip_draw_Line_get_pt2, (setter)pyopencv_gapi_wip_draw_Line_set_pt2, (char*)"pt2", NULL}, |  | 59691 | {(char*)"pt2", (getter)pyopencv_gapi_wip_draw_Line_get_pt2, (setter)pyopencv_gapi_wip_draw_Line_set_pt2, (char*)"pt2", NULL},
| 59740 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Line_get_shift, (setter)pyopencv_gapi_wip_draw_Line_set_shift, (char*)"shift", NULL}, |  | 59692 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Line_get_shift, (setter)pyopencv_gapi_wip_draw_Line_set_shift, (char*)"shift", NULL},
| 59741 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Line_get_thick, (setter)pyopencv_gapi_wip_draw_Line_set_thick, (char*)"thick", NULL}, |  | 59693 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Line_get_thick, (setter)pyopencv_gapi_wip_draw_Line_set_thick, (char*)"thick", NULL},
| 59742 | {NULL} /* Sentinel */ |  | 59694 | {NULL} /* Sentinel */
| 59743 | }; |  | 59695 | };
| 59744 |  |  | 59696 |
| 59745 | static PyMethodDef pyopencv_gapi_wip_draw_Line_methods[] = |  | 59697 | static PyMethodDef pyopencv_gapi_wip_draw_Line_methods[] =
| 59746 | { |  | 59698 | {
| 59747 |  |  | 59699 |
| 59748 | {NULL, NULL} |  | 59700 | {NULL, NULL}
| 59749 | }; |  | 59701 | };
| 59750 |  |  | 59702 |
| 59751 | // Converter (gapi_wip_draw_Line) |  | 59703 | // Converter (gapi_wip_draw_Line)
| 59752 |  |  | 59704 |
| 59753 | template<> |  | 59705 | template<>
| 59754 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Line > |  | 59706 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Line >
| 59755 | { |  | 59707 | {
| 59756 | static PyObject* from(const cv::gapi::wip::draw::Line& r) |  | 59708 | static PyObject* from(const cv::gapi::wip::draw::Line& r)
| 59757 | { |  | 59709 | {
| 59758 | return pyopencv_gapi_wip_draw_Line_Instance(r); |  | 59710 | return pyopencv_gapi_wip_draw_Line_Instance(r);
| 59759 | } |  | 59711 | }
| 59760 | static bool to(PyObject* src, cv::gapi::wip::draw::Line& dst, const ArgInfo& info) |  | 59712 | static bool to(PyObject* src, cv::gapi::wip::draw::Line& dst, const ArgInfo& info)
| 59761 | { |  | 59713 | {
| 59762 | if(!src || src == Py_None) |  | 59714 | if(!src || src == Py_None)
| 59763 | return true; |  | 59715 | return true;
| 59764 | cv::gapi::wip::draw::Line * dst_; |  | 59716 | cv::gapi::wip::draw::Line * dst_;
| 59765 | if (pyopencv_gapi_wip_draw_Line_getp(src, dst_)) |  | 59717 | if (pyopencv_gapi_wip_draw_Line_getp(src, dst_))
| 59766 | { |  | 59718 | {
| 59767 | dst = *dst_; |  | 59719 | dst = *dst_;
| 59768 | return true; |  | 59720 | return true;
| 59769 | } |  | 59721 | }
| 59770 |  |  | 59722 |
| 59771 | failmsg("Expected cv::gapi::wip::draw::Line for argument '%s'", info.name); |  | 59723 | failmsg("Expected cv::gapi::wip::draw::Line for argument '%s'", info.name);
| 59772 | return false; |  | 59724 | return false;
| 59773 | } |  | 59725 | }
| 59774 | }; |  | 59726 | };
| 59775 |  |  | 59727 |
| 59776 | //================================================================================ |  | 59728 | //================================================================================
| 59777 | // gapi_wip_draw_Mosaic (Generic) |  | 59729 | // gapi_wip_draw_Mosaic (Generic)
| 59778 | //================================================================================ |  | 59730 | //================================================================================
| 59779 |  |  | 59731 |
| 59780 | // GetSet (gapi_wip_draw_Mosaic) |  | 59732 | // GetSet (gapi_wip_draw_Mosaic)
| 59781 |  |  | 59733 |
| 59782 |  |  | 59734 |
| 59783 | static PyObject* pyopencv_gapi_wip_draw_Mosaic_get_cellSz(pyopencv_gapi_wip_draw_Mosaic_t* p, void *closure) |  | 59735 | static PyObject* pyopencv_gapi_wip_draw_Mosaic_get_cellSz(pyopencv_gapi_wip_draw_Mosaic_t* p, void *closure)
| 59784 | { |  | 59736 | {
| 59785 | return pyopencv_from(p->v.cellSz); |  | 59737 | return pyopencv_from(p->v.cellSz);
| 59786 | } |  | 59738 | }
| 59787 |  |  | 59739 |
| 59788 | static int pyopencv_gapi_wip_draw_Mosaic_set_cellSz(pyopencv_gapi_wip_draw_Mosaic_t* p, PyObject *value, void *closure) |  | 59740 | static int pyopencv_gapi_wip_draw_Mosaic_set_cellSz(pyopencv_gapi_wip_draw_Mosaic_t* p, PyObject *value, void *closure)
| 59789 | { |  | 59741 | {
| 59790 | if (!value) |  | 59742 | if (!value)
| 59791 | { |  | 59743 | {
| 59792 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cellSz attribute"); |  | 59744 | PyErr_SetString(PyExc_TypeError, "Cannot delete the cellSz attribute");
| 59793 | return -1; |  | 59745 | return -1;
| 59794 | } |  | 59746 | }
| 59795 | return pyopencv_to_safe(value, p->v.cellSz, ArgInfo("value", 0)) ? 0 : -1; |  | 59747 | return pyopencv_to_safe(value, p->v.cellSz, ArgInfo("value", 0)) ? 0 : -1;
| 59796 | } |  | 59748 | }
| 59797 |  |  | 59749 |
| 59798 | static PyObject* pyopencv_gapi_wip_draw_Mosaic_get_decim(pyopencv_gapi_wip_draw_Mosaic_t* p, void *closure) |  | 59750 | static PyObject* pyopencv_gapi_wip_draw_Mosaic_get_decim(pyopencv_gapi_wip_draw_Mosaic_t* p, void *closure)
| 59799 | { |  | 59751 | {
| 59800 | return pyopencv_from(p->v.decim); |  | 59752 | return pyopencv_from(p->v.decim);
| 59801 | } |  | 59753 | }
| 59802 |  |  | 59754 |
| 59803 | static int pyopencv_gapi_wip_draw_Mosaic_set_decim(pyopencv_gapi_wip_draw_Mosaic_t* p, PyObject *value, void *closure) |  | 59755 | static int pyopencv_gapi_wip_draw_Mosaic_set_decim(pyopencv_gapi_wip_draw_Mosaic_t* p, PyObject *value, void *closure)
| 59804 | { |  | 59756 | {
| 59805 | if (!value) |  | 59757 | if (!value)
| 59806 | { |  | 59758 | {
| 59807 | PyErr_SetString(PyExc_TypeError, "Cannot delete the decim attribute"); |  | 59759 | PyErr_SetString(PyExc_TypeError, "Cannot delete the decim attribute");
| 59808 | return -1; |  | 59760 | return -1;
| 59809 | } |  | 59761 | }
| 59810 | return pyopencv_to_safe(value, p->v.decim, ArgInfo("value", 0)) ? 0 : -1; |  | 59762 | return pyopencv_to_safe(value, p->v.decim, ArgInfo("value", 0)) ? 0 : -1;
| 59811 | } |  | 59763 | }
| 59812 |  |  | 59764 |
| 59813 | static PyObject* pyopencv_gapi_wip_draw_Mosaic_get_mos(pyopencv_gapi_wip_draw_Mosaic_t* p, void *closure) |  | 59765 | static PyObject* pyopencv_gapi_wip_draw_Mosaic_get_mos(pyopencv_gapi_wip_draw_Mosaic_t* p, void *closure)
| 59814 | { |  | 59766 | {
| 59815 | return pyopencv_from(p->v.mos); |  | 59767 | return pyopencv_from(p->v.mos);
| 59816 | } |  | 59768 | }
| 59817 |  |  | 59769 |
| 59818 | static int pyopencv_gapi_wip_draw_Mosaic_set_mos(pyopencv_gapi_wip_draw_Mosaic_t* p, PyObject *value, void *closure) |  | 59770 | static int pyopencv_gapi_wip_draw_Mosaic_set_mos(pyopencv_gapi_wip_draw_Mosaic_t* p, PyObject *value, void *closure)
| 59819 | { |  | 59771 | {
| 59820 | if (!value) |  | 59772 | if (!value)
| 59821 | { |  | 59773 | {
| 59822 | PyErr_SetString(PyExc_TypeError, "Cannot delete the mos attribute"); |  | 59774 | PyErr_SetString(PyExc_TypeError, "Cannot delete the mos attribute");
| 59823 | return -1; |  | 59775 | return -1;
| 59824 | } |  | 59776 | }
| 59825 | return pyopencv_to_safe(value, p->v.mos, ArgInfo("value", 0)) ? 0 : -1; |  | 59777 | return pyopencv_to_safe(value, p->v.mos, ArgInfo("value", 0)) ? 0 : -1;
| 59826 | } |  | 59778 | }
| 59827 |  |  | 59779 |
| 59828 |  |  | 59780 |
| 59829 | // Methods (gapi_wip_draw_Mosaic) |  | 59781 | // Methods (gapi_wip_draw_Mosaic)
| 59830 |  |  | 59782 |
| 59831 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Mosaic_Mosaic(pyopencv_gapi_wip_draw_Mosaic_t* self, PyObject* py_args, PyObject* kw) |  | 59783 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Mosaic_Mosaic(pyopencv_gapi_wip_draw_Mosaic_t* self, PyObject* py_args, PyObject* kw)
| 59832 | { |  | 59784 | {
| 59833 | using namespace cv::gapi::wip::draw; |  | 59785 | using namespace cv::gapi::wip::draw;
| 59834 |  |  | 59786 |
| 59835 | pyPrepareArgumentConversionErrorsStorage(2); |  | 59787 | pyPrepareArgumentConversionErrorsStorage(2);
| 59836 |  |  | 59788 |
| 59837 | { |  | 59789 | {
| 59838 |  |  | 59790 |
| 59839 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 59791 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 59840 | { |  | 59792 | {
| 59841 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Mosaic()); |  | 59793 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Mosaic());
| 59842 | return 0; |  | 59794 | return 0;
| 59843 | } |  | 59795 | }
| 59844 |  |  | 59796 |
| 59845 |  |  | 59797 |
| 59846 | pyPopulateArgumentConversionErrors(); |  | 59798 | pyPopulateArgumentConversionErrors();
| 59847 | } |  | 59799 | }
| 59848 |  |  | 59800 |
| 59849 |  |  | 59801 |
| 59850 | { |  | 59802 | {
| 59851 | PyObject* pyobj_mos_ = NULL; |  | 59803 | PyObject* pyobj_mos_ = NULL;
| 59852 | Rect2i mos_; |  | 59804 | Rect2i mos_;
| 59853 | PyObject* pyobj_cellSz_ = NULL; |  | 59805 | PyObject* pyobj_cellSz_ = NULL;
| 59854 | int cellSz_=0; |  | 59806 | int cellSz_=0;
| 59855 | PyObject* pyobj_decim_ = NULL; |  | 59807 | PyObject* pyobj_decim_ = NULL;
| 59856 | int decim_=0; |  | 59808 | int decim_=0;
| 59857 |  |  | 59809 |
| 59858 | const char* keywords[] = { "mos_", "cellSz_", "decim_", NULL }; |  | 59810 | const char* keywords[] = { "mos_", "cellSz_", "decim_", NULL };
| 59859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Mosaic", (char**)keywords, &pyobj_mos_, &pyobj_cellSz_, &pyobj_decim_) && |  | 59811 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Mosaic", (char**)keywords, &pyobj_mos_, &pyobj_cellSz_, &pyobj_decim_) &&
| 59860 | pyopencv_to_safe(pyobj_mos_, mos_, ArgInfo("mos_", 0)) && |  | 59812 | pyopencv_to_safe(pyobj_mos_, mos_, ArgInfo("mos_", 0)) &&
| 59861 | pyopencv_to_safe(pyobj_cellSz_, cellSz_, ArgInfo("cellSz_", 0)) && |  | 59813 | pyopencv_to_safe(pyobj_cellSz_, cellSz_, ArgInfo("cellSz_", 0)) &&
| 59862 | pyopencv_to_safe(pyobj_decim_, decim_, ArgInfo("decim_", 0)) ) |  | 59814 | pyopencv_to_safe(pyobj_decim_, decim_, ArgInfo("decim_", 0)) )
| 59863 | { |  | 59815 | {
| 59864 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Mosaic(mos_, cellSz_, decim_)); |  | 59816 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Mosaic(mos_, cellSz_, decim_));
| 59865 | return 0; |  | 59817 | return 0;
| 59866 | } |  | 59818 | }
| 59867 |  |  | 59819 |
| 59868 |  |  | 59820 |
| 59869 | pyPopulateArgumentConversionErrors(); |  | 59821 | pyPopulateArgumentConversionErrors();
| 59870 | } |  | 59822 | }
| 59871 | pyRaiseCVOverloadException("Mosaic"); |  | 59823 | pyRaiseCVOverloadException("Mosaic");
| 59872 |  |  | 59824 |
| 59873 | return -1; |  | 59825 | return -1;
| 59874 | } |  | 59826 | }
| 59875 |  |  | 59827 |
| 59876 |  |  | 59828 |
| 59877 |  |  | 59829 |
| 59878 | // Tables (gapi_wip_draw_Mosaic) |  | 59830 | // Tables (gapi_wip_draw_Mosaic)
| 59879 |  |  | 59831 |
| 59880 | static PyGetSetDef pyopencv_gapi_wip_draw_Mosaic_getseters[] = |  | 59832 | static PyGetSetDef pyopencv_gapi_wip_draw_Mosaic_getseters[] =
| 59881 | { |  | 59833 | {
| 59882 | {(char*)"cellSz", (getter)pyopencv_gapi_wip_draw_Mosaic_get_cellSz, (setter)pyopencv_gapi_wip_draw_Mosaic_set_cellSz, (char*)"cellSz", NULL}, |  | 59834 | {(char*)"cellSz", (getter)pyopencv_gapi_wip_draw_Mosaic_get_cellSz, (setter)pyopencv_gapi_wip_draw_Mosaic_set_cellSz, (char*)"cellSz", NULL},
| 59883 | {(char*)"decim", (getter)pyopencv_gapi_wip_draw_Mosaic_get_decim, (setter)pyopencv_gapi_wip_draw_Mosaic_set_decim, (char*)"decim", NULL}, |  | 59835 | {(char*)"decim", (getter)pyopencv_gapi_wip_draw_Mosaic_get_decim, (setter)pyopencv_gapi_wip_draw_Mosaic_set_decim, (char*)"decim", NULL},
| 59884 | {(char*)"mos", (getter)pyopencv_gapi_wip_draw_Mosaic_get_mos, (setter)pyopencv_gapi_wip_draw_Mosaic_set_mos, (char*)"mos", NULL}, |  | 59836 | {(char*)"mos", (getter)pyopencv_gapi_wip_draw_Mosaic_get_mos, (setter)pyopencv_gapi_wip_draw_Mosaic_set_mos, (char*)"mos", NULL},
| 59885 | {NULL} /* Sentinel */ |  | 59837 | {NULL} /* Sentinel */
| 59886 | }; |  | 59838 | };
| 59887 |  |  | 59839 |
| 59888 | static PyMethodDef pyopencv_gapi_wip_draw_Mosaic_methods[] = |  | 59840 | static PyMethodDef pyopencv_gapi_wip_draw_Mosaic_methods[] =
| 59889 | { |  | 59841 | {
| 59890 |  |  | 59842 |
| 59891 | {NULL, NULL} |  | 59843 | {NULL, NULL}
| 59892 | }; |  | 59844 | };
| 59893 |  |  | 59845 |
| 59894 | // Converter (gapi_wip_draw_Mosaic) |  | 59846 | // Converter (gapi_wip_draw_Mosaic)
| 59895 |  |  | 59847 |
| 59896 | template<> |  | 59848 | template<>
| 59897 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Mosaic > |  | 59849 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Mosaic >
| 59898 | { |  | 59850 | {
| 59899 | static PyObject* from(const cv::gapi::wip::draw::Mosaic& r) |  | 59851 | static PyObject* from(const cv::gapi::wip::draw::Mosaic& r)
| 59900 | { |  | 59852 | {
| 59901 | return pyopencv_gapi_wip_draw_Mosaic_Instance(r); |  | 59853 | return pyopencv_gapi_wip_draw_Mosaic_Instance(r);
| 59902 | } |  | 59854 | }
| 59903 | static bool to(PyObject* src, cv::gapi::wip::draw::Mosaic& dst, const ArgInfo& info) |  | 59855 | static bool to(PyObject* src, cv::gapi::wip::draw::Mosaic& dst, const ArgInfo& info)
| 59904 | { |  | 59856 | {
| 59905 | if(!src || src == Py_None) |  | 59857 | if(!src || src == Py_None)
| 59906 | return true; |  | 59858 | return true;
| 59907 | cv::gapi::wip::draw::Mosaic * dst_; |  | 59859 | cv::gapi::wip::draw::Mosaic * dst_;
| 59908 | if (pyopencv_gapi_wip_draw_Mosaic_getp(src, dst_)) |  | 59860 | if (pyopencv_gapi_wip_draw_Mosaic_getp(src, dst_))
| 59909 | { |  | 59861 | {
| 59910 | dst = *dst_; |  | 59862 | dst = *dst_;
| 59911 | return true; |  | 59863 | return true;
| 59912 | } |  | 59864 | }
| 59913 |  |  | 59865 |
| 59914 | failmsg("Expected cv::gapi::wip::draw::Mosaic for argument '%s'", info.name); |  | 59866 | failmsg("Expected cv::gapi::wip::draw::Mosaic for argument '%s'", info.name);
| 59915 | return false; |  | 59867 | return false;
| 59916 | } |  | 59868 | }
| 59917 | }; |  | 59869 | };
| 59918 |  |  | 59870 |
| 59919 | //================================================================================ |  | 59871 | //================================================================================
| 59920 | // gapi_wip_draw_Poly (Generic) |  | 59872 | // gapi_wip_draw_Poly (Generic)
| 59921 | //================================================================================ |  | 59873 | //================================================================================
| 59922 |  |  | 59874 |
| 59923 | // GetSet (gapi_wip_draw_Poly) |  | 59875 | // GetSet (gapi_wip_draw_Poly)
| 59924 |  |  | 59876 |
| 59925 |  |  | 59877 |
| 59926 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_color(pyopencv_gapi_wip_draw_Poly_t* p, void *closure) |  | 59878 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_color(pyopencv_gapi_wip_draw_Poly_t* p, void *closure)
| 59927 | { |  | 59879 | {
| 59928 | return pyopencv_from(p->v.color); |  | 59880 | return pyopencv_from(p->v.color);
| 59929 | } |  | 59881 | }
| 59930 |  |  | 59882 |
| 59931 | static int pyopencv_gapi_wip_draw_Poly_set_color(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure) |  | 59883 | static int pyopencv_gapi_wip_draw_Poly_set_color(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure)
| 59932 | { |  | 59884 | {
| 59933 | if (!value) |  | 59885 | if (!value)
| 59934 | { |  | 59886 | {
| 59935 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute"); |  | 59887 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute");
| 59936 | return -1; |  | 59888 | return -1;
| 59937 | } |  | 59889 | }
| 59938 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1; |  | 59890 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1;
| 59939 | } |  | 59891 | }
| 59940 |  |  | 59892 |
| 59941 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_lt(pyopencv_gapi_wip_draw_Poly_t* p, void *closure) |  | 59893 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_lt(pyopencv_gapi_wip_draw_Poly_t* p, void *closure)
| 59942 | { |  | 59894 | {
| 59943 | return pyopencv_from(p->v.lt); |  | 59895 | return pyopencv_from(p->v.lt);
| 59944 | } |  | 59896 | }
| 59945 |  |  | 59897 |
| 59946 | static int pyopencv_gapi_wip_draw_Poly_set_lt(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure) |  | 59898 | static int pyopencv_gapi_wip_draw_Poly_set_lt(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure)
| 59947 | { |  | 59899 | {
| 59948 | if (!value) |  | 59900 | if (!value)
| 59949 | { |  | 59901 | {
| 59950 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute"); |  | 59902 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute");
| 59951 | return -1; |  | 59903 | return -1;
| 59952 | } |  | 59904 | }
| 59953 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1; |  | 59905 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1;
| 59954 | } |  | 59906 | }
| 59955 |  |  | 59907 |
| 59956 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_points(pyopencv_gapi_wip_draw_Poly_t* p, void *closure) |  | 59908 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_points(pyopencv_gapi_wip_draw_Poly_t* p, void *closure)
| 59957 | { |  | 59909 | {
| 59958 | return pyopencv_from(p->v.points); |  | 59910 | return pyopencv_from(p->v.points);
| 59959 | } |  | 59911 | }
| 59960 |  |  | 59912 |
| 59961 | static int pyopencv_gapi_wip_draw_Poly_set_points(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure) |  | 59913 | static int pyopencv_gapi_wip_draw_Poly_set_points(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure)
| 59962 | { |  | 59914 | {
| 59963 | if (!value) |  | 59915 | if (!value)
| 59964 | { |  | 59916 | {
| 59965 | PyErr_SetString(PyExc_TypeError, "Cannot delete the points attribute"); |  | 59917 | PyErr_SetString(PyExc_TypeError, "Cannot delete the points attribute");
| 59966 | return -1; |  | 59918 | return -1;
| 59967 | } |  | 59919 | }
| 59968 | return pyopencv_to_safe(value, p->v.points, ArgInfo("value", 0)) ? 0 : -1; |  | 59920 | return pyopencv_to_safe(value, p->v.points, ArgInfo("value", 0)) ? 0 : -1;
| 59969 | } |  | 59921 | }
| 59970 |  |  | 59922 |
| 59971 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_shift(pyopencv_gapi_wip_draw_Poly_t* p, void *closure) |  | 59923 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_shift(pyopencv_gapi_wip_draw_Poly_t* p, void *closure)
| 59972 | { |  | 59924 | {
| 59973 | return pyopencv_from(p->v.shift); |  | 59925 | return pyopencv_from(p->v.shift);
| 59974 | } |  | 59926 | }
| 59975 |  |  | 59927 |
| 59976 | static int pyopencv_gapi_wip_draw_Poly_set_shift(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure) |  | 59928 | static int pyopencv_gapi_wip_draw_Poly_set_shift(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure)
| 59977 | { |  | 59929 | {
| 59978 | if (!value) |  | 59930 | if (!value)
| 59979 | { |  | 59931 | {
| 59980 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute"); |  | 59932 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute");
| 59981 | return -1; |  | 59933 | return -1;
| 59982 | } |  | 59934 | }
| 59983 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1; |  | 59935 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1;
| 59984 | } |  | 59936 | }
| 59985 |  |  | 59937 |
| 59986 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_thick(pyopencv_gapi_wip_draw_Poly_t* p, void *closure) |  | 59938 | static PyObject* pyopencv_gapi_wip_draw_Poly_get_thick(pyopencv_gapi_wip_draw_Poly_t* p, void *closure)
| 59987 | { |  | 59939 | {
| 59988 | return pyopencv_from(p->v.thick); |  | 59940 | return pyopencv_from(p->v.thick);
| 59989 | } |  | 59941 | }
| 59990 |  |  | 59942 |
| 59991 | static int pyopencv_gapi_wip_draw_Poly_set_thick(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure) |  | 59943 | static int pyopencv_gapi_wip_draw_Poly_set_thick(pyopencv_gapi_wip_draw_Poly_t* p, PyObject *value, void *closure)
| 59992 | { |  | 59944 | {
| 59993 | if (!value) |  | 59945 | if (!value)
| 59994 | { |  | 59946 | {
| 59995 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute"); |  | 59947 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute");
| 59996 | return -1; |  | 59948 | return -1;
| 59997 | } |  | 59949 | }
| 59998 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1; |  | 59950 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1;
| 59999 | } |  | 59951 | }
| 60000 |  |  | 59952 |
| 60001 |  |  | 59953 |
| 60002 | // Methods (gapi_wip_draw_Poly) |  | 59954 | // Methods (gapi_wip_draw_Poly)
| 60003 |  |  | 59955 |
| 60004 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Poly_Poly(pyopencv_gapi_wip_draw_Poly_t* self, PyObject* py_args, PyObject* kw) |  | 59956 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Poly_Poly(pyopencv_gapi_wip_draw_Poly_t* self, PyObject* py_args, PyObject* kw)
| 60005 | { |  | 59957 | {
| 60006 | using namespace cv::gapi::wip::draw; |  | 59958 | using namespace cv::gapi::wip::draw;
| 60007 |  |  | 59959 |
| 60008 | pyPrepareArgumentConversionErrorsStorage(2); |  | 59960 | pyPrepareArgumentConversionErrorsStorage(2);
| 60009 |  |  | 59961 |
| 60010 | { |  | 59962 | {
| 60011 | PyObject* pyobj_points_ = NULL; |  | 59963 | PyObject* pyobj_points_ = NULL;
| 60012 | vector_Point points_; |  | 59964 | vector_Point points_;
| 60013 | PyObject* pyobj_color_ = NULL; |  | 59965 | PyObject* pyobj_color_ = NULL;
| 60014 | Scalar color_; |  | 59966 | Scalar color_;
| 60015 | PyObject* pyobj_thick_ = NULL; |  | 59967 | PyObject* pyobj_thick_ = NULL;
| 60016 | int thick_=1; |  | 59968 | int thick_=1;
| 60017 | PyObject* pyobj_lt_ = NULL; |  | 59969 | PyObject* pyobj_lt_ = NULL;
| 60018 | int lt_=8; |  | 59970 | int lt_=8;
| 60019 | PyObject* pyobj_shift_ = NULL; |  | 59971 | PyObject* pyobj_shift_ = NULL;
| 60020 | int shift_=0; |  | 59972 | int shift_=0;
| 60021 |  |  | 59973 |
| 60022 | const char* keywords[] = { "points_", "color_", "thick_", "lt_", "shift_", NULL }; |  | 59974 | const char* keywords[] = { "points_", "color_", "thick_", "lt_", "shift_", NULL };
| 60023 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:Poly", (char**)keywords, &pyobj_points_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) && |  | 59975 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:Poly", (char**)keywords, &pyobj_points_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) &&
| 60024 | pyopencv_to_safe(pyobj_points_, points_, ArgInfo("points_", 0)) && |  | 59976 | pyopencv_to_safe(pyobj_points_, points_, ArgInfo("points_", 0)) &&
| 60025 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) && |  | 59977 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) &&
| 60026 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) && |  | 59978 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) &&
| 60027 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) && |  | 59979 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) &&
| 60028 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) ) |  | 59980 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) )
| 60029 | { |  | 59981 | {
| 60030 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Poly(points_, color_, thick_, lt_, shift_)); |  | 59982 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Poly(points_, color_, thick_, lt_, shift_));
| 60031 | return 0; |  | 59983 | return 0;
| 60032 | } |  | 59984 | }
| 60033 |  |  | 59985 |
| 60034 |  |  | 59986 |
| 60035 | pyPopulateArgumentConversionErrors(); |  | 59987 | pyPopulateArgumentConversionErrors();
| 60036 | } |  | 59988 | }
| 60037 |  |  | 59989 |
| 60038 |  |  | 59990 |
| 60039 | { |  | 59991 | {
| 60040 |  |  | 59992 |
| 60041 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 59993 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 60042 | { |  | 59994 | {
| 60043 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Poly()); |  | 59995 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Poly());
| 60044 | return 0; |  | 59996 | return 0;
| 60045 | } |  | 59997 | }
| 60046 |  |  | 59998 |
| 60047 |  |  | 59999 |
| 60048 | pyPopulateArgumentConversionErrors(); |  | 60000 | pyPopulateArgumentConversionErrors();
| 60049 | } |  | 60001 | }
| 60050 | pyRaiseCVOverloadException("Poly"); |  | 60002 | pyRaiseCVOverloadException("Poly");
| 60051 |  |  | 60003 |
| 60052 | return -1; |  | 60004 | return -1;
| 60053 | } |  | 60005 | }
| 60054 |  |  | 60006 |
| 60055 |  |  | 60007 |
| 60056 |  |  | 60008 |
| 60057 | // Tables (gapi_wip_draw_Poly) |  | 60009 | // Tables (gapi_wip_draw_Poly)
| 60058 |  |  | 60010 |
| 60059 | static PyGetSetDef pyopencv_gapi_wip_draw_Poly_getseters[] = |  | 60011 | static PyGetSetDef pyopencv_gapi_wip_draw_Poly_getseters[] =
| 60060 | { |  | 60012 | {
| 60061 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Poly_get_color, (setter)pyopencv_gapi_wip_draw_Poly_set_color, (char*)"color", NULL}, |  | 60013 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Poly_get_color, (setter)pyopencv_gapi_wip_draw_Poly_set_color, (char*)"color", NULL},
| 60062 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Poly_get_lt, (setter)pyopencv_gapi_wip_draw_Poly_set_lt, (char*)"lt", NULL}, |  | 60014 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Poly_get_lt, (setter)pyopencv_gapi_wip_draw_Poly_set_lt, (char*)"lt", NULL},
| 60063 | {(char*)"points", (getter)pyopencv_gapi_wip_draw_Poly_get_points, (setter)pyopencv_gapi_wip_draw_Poly_set_points, (char*)"points", NULL}, |  | 60015 | {(char*)"points", (getter)pyopencv_gapi_wip_draw_Poly_get_points, (setter)pyopencv_gapi_wip_draw_Poly_set_points, (char*)"points", NULL},
| 60064 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Poly_get_shift, (setter)pyopencv_gapi_wip_draw_Poly_set_shift, (char*)"shift", NULL}, |  | 60016 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Poly_get_shift, (setter)pyopencv_gapi_wip_draw_Poly_set_shift, (char*)"shift", NULL},
| 60065 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Poly_get_thick, (setter)pyopencv_gapi_wip_draw_Poly_set_thick, (char*)"thick", NULL}, |  | 60017 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Poly_get_thick, (setter)pyopencv_gapi_wip_draw_Poly_set_thick, (char*)"thick", NULL},
| 60066 | {NULL} /* Sentinel */ |  | 60018 | {NULL} /* Sentinel */
| 60067 | }; |  | 60019 | };
| 60068 |  |  | 60020 |
| 60069 | static PyMethodDef pyopencv_gapi_wip_draw_Poly_methods[] = |  | 60021 | static PyMethodDef pyopencv_gapi_wip_draw_Poly_methods[] =
| 60070 | { |  | 60022 | {
| 60071 |  |  | 60023 |
| 60072 | {NULL, NULL} |  | 60024 | {NULL, NULL}
| 60073 | }; |  | 60025 | };
| 60074 |  |  | 60026 |
| 60075 | // Converter (gapi_wip_draw_Poly) |  | 60027 | // Converter (gapi_wip_draw_Poly)
| 60076 |  |  | 60028 |
| 60077 | template<> |  | 60029 | template<>
| 60078 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Poly > |  | 60030 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Poly >
| 60079 | { |  | 60031 | {
| 60080 | static PyObject* from(const cv::gapi::wip::draw::Poly& r) |  | 60032 | static PyObject* from(const cv::gapi::wip::draw::Poly& r)
| 60081 | { |  | 60033 | {
| 60082 | return pyopencv_gapi_wip_draw_Poly_Instance(r); |  | 60034 | return pyopencv_gapi_wip_draw_Poly_Instance(r);
| 60083 | } |  | 60035 | }
| 60084 | static bool to(PyObject* src, cv::gapi::wip::draw::Poly& dst, const ArgInfo& info) |  | 60036 | static bool to(PyObject* src, cv::gapi::wip::draw::Poly& dst, const ArgInfo& info)
| 60085 | { |  | 60037 | {
| 60086 | if(!src || src == Py_None) |  | 60038 | if(!src || src == Py_None)
| 60087 | return true; |  | 60039 | return true;
| 60088 | cv::gapi::wip::draw::Poly * dst_; |  | 60040 | cv::gapi::wip::draw::Poly * dst_;
| 60089 | if (pyopencv_gapi_wip_draw_Poly_getp(src, dst_)) |  | 60041 | if (pyopencv_gapi_wip_draw_Poly_getp(src, dst_))
| 60090 | { |  | 60042 | {
| 60091 | dst = *dst_; |  | 60043 | dst = *dst_;
| 60092 | return true; |  | 60044 | return true;
| 60093 | } |  | 60045 | }
| 60094 |  |  | 60046 |
| 60095 | failmsg("Expected cv::gapi::wip::draw::Poly for argument '%s'", info.name); |  | 60047 | failmsg("Expected cv::gapi::wip::draw::Poly for argument '%s'", info.name);
| 60096 | return false; |  | 60048 | return false;
| 60097 | } |  | 60049 | }
| 60098 | }; |  | 60050 | };
| 60099 |  |  | 60051 |
| 60100 | //================================================================================ |  | 60052 | //================================================================================
| 60101 | // gapi_wip_draw_Rect (Generic) |  | 60053 | // gapi_wip_draw_Rect (Generic)
| 60102 | //================================================================================ |  | 60054 | //================================================================================
| 60103 |  |  | 60055 |
| 60104 | // GetSet (gapi_wip_draw_Rect) |  | 60056 | // GetSet (gapi_wip_draw_Rect)
| 60105 |  |  | 60057 |
| 60106 |  |  | 60058 |
| 60107 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_color(pyopencv_gapi_wip_draw_Rect_t* p, void *closure) |  | 60059 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_color(pyopencv_gapi_wip_draw_Rect_t* p, void *closure)
| 60108 | { |  | 60060 | {
| 60109 | return pyopencv_from(p->v.color); |  | 60061 | return pyopencv_from(p->v.color);
| 60110 | } |  | 60062 | }
| 60111 |  |  | 60063 |
| 60112 | static int pyopencv_gapi_wip_draw_Rect_set_color(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure) |  | 60064 | static int pyopencv_gapi_wip_draw_Rect_set_color(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure)
| 60113 | { |  | 60065 | {
| 60114 | if (!value) |  | 60066 | if (!value)
| 60115 | { |  | 60067 | {
| 60116 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute"); |  | 60068 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute");
| 60117 | return -1; |  | 60069 | return -1;
| 60118 | } |  | 60070 | }
| 60119 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1; |  | 60071 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1;
| 60120 | } |  | 60072 | }
| 60121 |  |  | 60073 |
| 60122 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_lt(pyopencv_gapi_wip_draw_Rect_t* p, void *closure) |  | 60074 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_lt(pyopencv_gapi_wip_draw_Rect_t* p, void *closure)
| 60123 | { |  | 60075 | {
| 60124 | return pyopencv_from(p->v.lt); |  | 60076 | return pyopencv_from(p->v.lt);
| 60125 | } |  | 60077 | }
| 60126 |  |  | 60078 |
| 60127 | static int pyopencv_gapi_wip_draw_Rect_set_lt(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure) |  | 60079 | static int pyopencv_gapi_wip_draw_Rect_set_lt(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure)
| 60128 | { |  | 60080 | {
| 60129 | if (!value) |  | 60081 | if (!value)
| 60130 | { |  | 60082 | {
| 60131 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute"); |  | 60083 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute");
| 60132 | return -1; |  | 60084 | return -1;
| 60133 | } |  | 60085 | }
| 60134 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1; |  | 60086 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1;
| 60135 | } |  | 60087 | }
| 60136 |  |  | 60088 |
| 60137 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_rect(pyopencv_gapi_wip_draw_Rect_t* p, void *closure) |  | 60089 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_rect(pyopencv_gapi_wip_draw_Rect_t* p, void *closure)
| 60138 | { |  | 60090 | {
| 60139 | return pyopencv_from(p->v.rect); |  | 60091 | return pyopencv_from(p->v.rect);
| 60140 | } |  | 60092 | }
| 60141 |  |  | 60093 |
| 60142 | static int pyopencv_gapi_wip_draw_Rect_set_rect(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure) |  | 60094 | static int pyopencv_gapi_wip_draw_Rect_set_rect(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure)
| 60143 | { |  | 60095 | {
| 60144 | if (!value) |  | 60096 | if (!value)
| 60145 | { |  | 60097 | {
| 60146 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rect attribute"); |  | 60098 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rect attribute");
| 60147 | return -1; |  | 60099 | return -1;
| 60148 | } |  | 60100 | }
| 60149 | return pyopencv_to_safe(value, p->v.rect, ArgInfo("value", 0)) ? 0 : -1; |  | 60101 | return pyopencv_to_safe(value, p->v.rect, ArgInfo("value", 0)) ? 0 : -1;
| 60150 | } |  | 60102 | }
| 60151 |  |  | 60103 |
| 60152 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_shift(pyopencv_gapi_wip_draw_Rect_t* p, void *closure) |  | 60104 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_shift(pyopencv_gapi_wip_draw_Rect_t* p, void *closure)
| 60153 | { |  | 60105 | {
| 60154 | return pyopencv_from(p->v.shift); |  | 60106 | return pyopencv_from(p->v.shift);
| 60155 | } |  | 60107 | }
| 60156 |  |  | 60108 |
| 60157 | static int pyopencv_gapi_wip_draw_Rect_set_shift(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure) |  | 60109 | static int pyopencv_gapi_wip_draw_Rect_set_shift(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure)
| 60158 | { |  | 60110 | {
| 60159 | if (!value) |  | 60111 | if (!value)
| 60160 | { |  | 60112 | {
| 60161 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute"); |  | 60113 | PyErr_SetString(PyExc_TypeError, "Cannot delete the shift attribute");
| 60162 | return -1; |  | 60114 | return -1;
| 60163 | } |  | 60115 | }
| 60164 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1; |  | 60116 | return pyopencv_to_safe(value, p->v.shift, ArgInfo("value", 0)) ? 0 : -1;
| 60165 | } |  | 60117 | }
| 60166 |  |  | 60118 |
| 60167 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_thick(pyopencv_gapi_wip_draw_Rect_t* p, void *closure) |  | 60119 | static PyObject* pyopencv_gapi_wip_draw_Rect_get_thick(pyopencv_gapi_wip_draw_Rect_t* p, void *closure)
| 60168 | { |  | 60120 | {
| 60169 | return pyopencv_from(p->v.thick); |  | 60121 | return pyopencv_from(p->v.thick);
| 60170 | } |  | 60122 | }
| 60171 |  |  | 60123 |
| 60172 | static int pyopencv_gapi_wip_draw_Rect_set_thick(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure) |  | 60124 | static int pyopencv_gapi_wip_draw_Rect_set_thick(pyopencv_gapi_wip_draw_Rect_t* p, PyObject *value, void *closure)
| 60173 | { |  | 60125 | {
| 60174 | if (!value) |  | 60126 | if (!value)
| 60175 | { |  | 60127 | {
| 60176 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute"); |  | 60128 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute");
| 60177 | return -1; |  | 60129 | return -1;
| 60178 | } |  | 60130 | }
| 60179 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1; |  | 60131 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1;
| 60180 | } |  | 60132 | }
| 60181 |  |  | 60133 |
| 60182 |  |  | 60134 |
| 60183 | // Methods (gapi_wip_draw_Rect) |  | 60135 | // Methods (gapi_wip_draw_Rect)
| 60184 |  |  | 60136 |
| 60185 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Rect_Rect(pyopencv_gapi_wip_draw_Rect_t* self, PyObject* py_args, PyObject* kw) |  | 60137 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Rect_Rect(pyopencv_gapi_wip_draw_Rect_t* self, PyObject* py_args, PyObject* kw)
| 60186 | { |  | 60138 | {
| 60187 | using namespace cv::gapi::wip::draw; |  | 60139 | using namespace cv::gapi::wip::draw;
| 60188 |  |  | 60140 |
| 60189 | pyPrepareArgumentConversionErrorsStorage(2); |  | 60141 | pyPrepareArgumentConversionErrorsStorage(2);
| 60190 |  |  | 60142 |
| 60191 | { |  | 60143 | {
| 60192 |  |  | 60144 |
| 60193 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 60145 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 60194 | { |  | 60146 | {
| 60195 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Rect()); |  | 60147 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Rect());
| 60196 | return 0; |  | 60148 | return 0;
| 60197 | } |  | 60149 | }
| 60198 |  |  | 60150 |
| 60199 |  |  | 60151 |
| 60200 | pyPopulateArgumentConversionErrors(); |  | 60152 | pyPopulateArgumentConversionErrors();
| 60201 | } |  | 60153 | }
| 60202 |  |  | 60154 |
| 60203 |  |  | 60155 |
| 60204 | { |  | 60156 | {
| 60205 | PyObject* pyobj_rect_ = NULL; |  | 60157 | PyObject* pyobj_rect_ = NULL;
| 60206 | Rect2i rect_; |  | 60158 | Rect2i rect_;
| 60207 | PyObject* pyobj_color_ = NULL; |  | 60159 | PyObject* pyobj_color_ = NULL;
| 60208 | Scalar color_; |  | 60160 | Scalar color_;
| 60209 | PyObject* pyobj_thick_ = NULL; |  | 60161 | PyObject* pyobj_thick_ = NULL;
| 60210 | int thick_=1; |  | 60162 | int thick_=1;
| 60211 | PyObject* pyobj_lt_ = NULL; |  | 60163 | PyObject* pyobj_lt_ = NULL;
| 60212 | int lt_=8; |  | 60164 | int lt_=8;
| 60213 | PyObject* pyobj_shift_ = NULL; |  | 60165 | PyObject* pyobj_shift_ = NULL;
| 60214 | int shift_=0; |  | 60166 | int shift_=0;
| 60215 |  |  | 60167 |
| 60216 | const char* keywords[] = { "rect_", "color_", "thick_", "lt_", "shift_", NULL }; |  | 60168 | const char* keywords[] = { "rect_", "color_", "thick_", "lt_", "shift_", NULL };
| 60217 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:Rect", (char**)keywords, &pyobj_rect_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) && |  | 60169 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:Rect", (char**)keywords, &pyobj_rect_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_shift_) &&
| 60218 | pyopencv_to_safe(pyobj_rect_, rect_, ArgInfo("rect_", 0)) && |  | 60170 | pyopencv_to_safe(pyobj_rect_, rect_, ArgInfo("rect_", 0)) &&
| 60219 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) && |  | 60171 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) &&
| 60220 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) && |  | 60172 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) &&
| 60221 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) && |  | 60173 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) &&
| 60222 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) ) |  | 60174 | pyopencv_to_safe(pyobj_shift_, shift_, ArgInfo("shift_", 0)) )
| 60223 | { |  | 60175 | {
| 60224 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Rect(rect_, color_, thick_, lt_, shift_)); |  | 60176 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Rect(rect_, color_, thick_, lt_, shift_));
| 60225 | return 0; |  | 60177 | return 0;
| 60226 | } |  | 60178 | }
| 60227 |  |  | 60179 |
| 60228 |  |  | 60180 |
| 60229 | pyPopulateArgumentConversionErrors(); |  | 60181 | pyPopulateArgumentConversionErrors();
| 60230 | } |  | 60182 | }
| 60231 | pyRaiseCVOverloadException("Rect"); |  | 60183 | pyRaiseCVOverloadException("Rect");
| 60232 |  |  | 60184 |
| 60233 | return -1; |  | 60185 | return -1;
| 60234 | } |  | 60186 | }
| 60235 |  |  | 60187 |
| 60236 |  |  | 60188 |
| 60237 |  |  | 60189 |
| 60238 | // Tables (gapi_wip_draw_Rect) |  | 60190 | // Tables (gapi_wip_draw_Rect)
| 60239 |  |  | 60191 |
| 60240 | static PyGetSetDef pyopencv_gapi_wip_draw_Rect_getseters[] = |  | 60192 | static PyGetSetDef pyopencv_gapi_wip_draw_Rect_getseters[] =
| 60241 | { |  | 60193 | {
| 60242 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Rect_get_color, (setter)pyopencv_gapi_wip_draw_Rect_set_color, (char*)"color", NULL}, |  | 60194 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Rect_get_color, (setter)pyopencv_gapi_wip_draw_Rect_set_color, (char*)"color", NULL},
| 60243 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Rect_get_lt, (setter)pyopencv_gapi_wip_draw_Rect_set_lt, (char*)"lt", NULL}, |  | 60195 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Rect_get_lt, (setter)pyopencv_gapi_wip_draw_Rect_set_lt, (char*)"lt", NULL},
| 60244 | {(char*)"rect", (getter)pyopencv_gapi_wip_draw_Rect_get_rect, (setter)pyopencv_gapi_wip_draw_Rect_set_rect, (char*)"rect", NULL}, |  | 60196 | {(char*)"rect", (getter)pyopencv_gapi_wip_draw_Rect_get_rect, (setter)pyopencv_gapi_wip_draw_Rect_set_rect, (char*)"rect", NULL},
| 60245 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Rect_get_shift, (setter)pyopencv_gapi_wip_draw_Rect_set_shift, (char*)"shift", NULL}, |  | 60197 | {(char*)"shift", (getter)pyopencv_gapi_wip_draw_Rect_get_shift, (setter)pyopencv_gapi_wip_draw_Rect_set_shift, (char*)"shift", NULL},
| 60246 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Rect_get_thick, (setter)pyopencv_gapi_wip_draw_Rect_set_thick, (char*)"thick", NULL}, |  | 60198 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Rect_get_thick, (setter)pyopencv_gapi_wip_draw_Rect_set_thick, (char*)"thick", NULL},
| 60247 | {NULL} /* Sentinel */ |  | 60199 | {NULL} /* Sentinel */
| 60248 | }; |  | 60200 | };
| 60249 |  |  | 60201 |
| 60250 | static PyMethodDef pyopencv_gapi_wip_draw_Rect_methods[] = |  | 60202 | static PyMethodDef pyopencv_gapi_wip_draw_Rect_methods[] =
| 60251 | { |  | 60203 | {
| 60252 |  |  | 60204 |
| 60253 | {NULL, NULL} |  | 60205 | {NULL, NULL}
| 60254 | }; |  | 60206 | };
| 60255 |  |  | 60207 |
| 60256 | // Converter (gapi_wip_draw_Rect) |  | 60208 | // Converter (gapi_wip_draw_Rect)
| 60257 |  |  | 60209 |
| 60258 | template<> |  | 60210 | template<>
| 60259 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Rect > |  | 60211 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Rect >
| 60260 | { |  | 60212 | {
| 60261 | static PyObject* from(const cv::gapi::wip::draw::Rect& r) |  | 60213 | static PyObject* from(const cv::gapi::wip::draw::Rect& r)
| 60262 | { |  | 60214 | {
| 60263 | return pyopencv_gapi_wip_draw_Rect_Instance(r); |  | 60215 | return pyopencv_gapi_wip_draw_Rect_Instance(r);
| 60264 | } |  | 60216 | }
| 60265 | static bool to(PyObject* src, cv::gapi::wip::draw::Rect& dst, const ArgInfo& info) |  | 60217 | static bool to(PyObject* src, cv::gapi::wip::draw::Rect& dst, const ArgInfo& info)
| 60266 | { |  | 60218 | {
| 60267 | if(!src || src == Py_None) |  | 60219 | if(!src || src == Py_None)
| 60268 | return true; |  | 60220 | return true;
| 60269 | cv::gapi::wip::draw::Rect * dst_; |  | 60221 | cv::gapi::wip::draw::Rect * dst_;
| 60270 | if (pyopencv_gapi_wip_draw_Rect_getp(src, dst_)) |  | 60222 | if (pyopencv_gapi_wip_draw_Rect_getp(src, dst_))
| 60271 | { |  | 60223 | {
| 60272 | dst = *dst_; |  | 60224 | dst = *dst_;
| 60273 | return true; |  | 60225 | return true;
| 60274 | } |  | 60226 | }
| 60275 |  |  | 60227 |
| 60276 | failmsg("Expected cv::gapi::wip::draw::Rect for argument '%s'", info.name); |  | 60228 | failmsg("Expected cv::gapi::wip::draw::Rect for argument '%s'", info.name);
| 60277 | return false; |  | 60229 | return false;
| 60278 | } |  | 60230 | }
| 60279 | }; |  | 60231 | };
| 60280 |  |  | 60232 |
| 60281 | //================================================================================ |  | 60233 | //================================================================================
| 60282 | // gapi_wip_draw_Text (Generic) |  | 60234 | // gapi_wip_draw_Text (Generic)
| 60283 | //================================================================================ |  | 60235 | //================================================================================
| 60284 |  |  | 60236 |
| 60285 | // GetSet (gapi_wip_draw_Text) |  | 60237 | // GetSet (gapi_wip_draw_Text)
| 60286 |  |  | 60238 |
| 60287 |  |  | 60239 |
| 60288 | static PyObject* pyopencv_gapi_wip_draw_Text_get_bottom_left_origin(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60240 | static PyObject* pyopencv_gapi_wip_draw_Text_get_bottom_left_origin(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60289 | { |  | 60241 | {
| 60290 | return pyopencv_from(p->v.bottom_left_origin); |  | 60242 | return pyopencv_from(p->v.bottom_left_origin);
| 60291 | } |  | 60243 | }
| 60292 |  |  | 60244 |
| 60293 | static int pyopencv_gapi_wip_draw_Text_set_bottom_left_origin(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60245 | static int pyopencv_gapi_wip_draw_Text_set_bottom_left_origin(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60294 | { |  | 60246 | {
| 60295 | if (!value) |  | 60247 | if (!value)
| 60296 | { |  | 60248 | {
| 60297 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bottom_left_origin attribute"); |  | 60249 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bottom_left_origin attribute");
| 60298 | return -1; |  | 60250 | return -1;
| 60299 | } |  | 60251 | }
| 60300 | return pyopencv_to_safe(value, p->v.bottom_left_origin, ArgInfo("value", 0)) ? 0 : -1; |  | 60252 | return pyopencv_to_safe(value, p->v.bottom_left_origin, ArgInfo("value", 0)) ? 0 : -1;
| 60301 | } |  | 60253 | }
| 60302 |  |  | 60254 |
| 60303 | static PyObject* pyopencv_gapi_wip_draw_Text_get_color(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60255 | static PyObject* pyopencv_gapi_wip_draw_Text_get_color(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60304 | { |  | 60256 | {
| 60305 | return pyopencv_from(p->v.color); |  | 60257 | return pyopencv_from(p->v.color);
| 60306 | } |  | 60258 | }
| 60307 |  |  | 60259 |
| 60308 | static int pyopencv_gapi_wip_draw_Text_set_color(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60260 | static int pyopencv_gapi_wip_draw_Text_set_color(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60309 | { |  | 60261 | {
| 60310 | if (!value) |  | 60262 | if (!value)
| 60311 | { |  | 60263 | {
| 60312 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute"); |  | 60264 | PyErr_SetString(PyExc_TypeError, "Cannot delete the color attribute");
| 60313 | return -1; |  | 60265 | return -1;
| 60314 | } |  | 60266 | }
| 60315 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1; |  | 60267 | return pyopencv_to_safe(value, p->v.color, ArgInfo("value", 0)) ? 0 : -1;
| 60316 | } |  | 60268 | }
| 60317 |  |  | 60269 |
| 60318 | static PyObject* pyopencv_gapi_wip_draw_Text_get_ff(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60270 | static PyObject* pyopencv_gapi_wip_draw_Text_get_ff(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60319 | { |  | 60271 | {
| 60320 | return pyopencv_from(p->v.ff); |  | 60272 | return pyopencv_from(p->v.ff);
| 60321 | } |  | 60273 | }
| 60322 |  |  | 60274 |
| 60323 | static int pyopencv_gapi_wip_draw_Text_set_ff(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60275 | static int pyopencv_gapi_wip_draw_Text_set_ff(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60324 | { |  | 60276 | {
| 60325 | if (!value) |  | 60277 | if (!value)
| 60326 | { |  | 60278 | {
| 60327 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ff attribute"); |  | 60279 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ff attribute");
| 60328 | return -1; |  | 60280 | return -1;
| 60329 | } |  | 60281 | }
| 60330 | return pyopencv_to_safe(value, p->v.ff, ArgInfo("value", 0)) ? 0 : -1; |  | 60282 | return pyopencv_to_safe(value, p->v.ff, ArgInfo("value", 0)) ? 0 : -1;
| 60331 | } |  | 60283 | }
| 60332 |  |  | 60284 |
| 60333 | static PyObject* pyopencv_gapi_wip_draw_Text_get_fs(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60285 | static PyObject* pyopencv_gapi_wip_draw_Text_get_fs(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60334 | { |  | 60286 | {
| 60335 | return pyopencv_from(p->v.fs); |  | 60287 | return pyopencv_from(p->v.fs);
| 60336 | } |  | 60288 | }
| 60337 |  |  | 60289 |
| 60338 | static int pyopencv_gapi_wip_draw_Text_set_fs(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60290 | static int pyopencv_gapi_wip_draw_Text_set_fs(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60339 | { |  | 60291 | {
| 60340 | if (!value) |  | 60292 | if (!value)
| 60341 | { |  | 60293 | {
| 60342 | PyErr_SetString(PyExc_TypeError, "Cannot delete the fs attribute"); |  | 60294 | PyErr_SetString(PyExc_TypeError, "Cannot delete the fs attribute");
| 60343 | return -1; |  | 60295 | return -1;
| 60344 | } |  | 60296 | }
| 60345 | return pyopencv_to_safe(value, p->v.fs, ArgInfo("value", 0)) ? 0 : -1; |  | 60297 | return pyopencv_to_safe(value, p->v.fs, ArgInfo("value", 0)) ? 0 : -1;
| 60346 | } |  | 60298 | }
| 60347 |  |  | 60299 |
| 60348 | static PyObject* pyopencv_gapi_wip_draw_Text_get_lt(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60300 | static PyObject* pyopencv_gapi_wip_draw_Text_get_lt(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60349 | { |  | 60301 | {
| 60350 | return pyopencv_from(p->v.lt); |  | 60302 | return pyopencv_from(p->v.lt);
| 60351 | } |  | 60303 | }
| 60352 |  |  | 60304 |
| 60353 | static int pyopencv_gapi_wip_draw_Text_set_lt(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60305 | static int pyopencv_gapi_wip_draw_Text_set_lt(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60354 | { |  | 60306 | {
| 60355 | if (!value) |  | 60307 | if (!value)
| 60356 | { |  | 60308 | {
| 60357 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute"); |  | 60309 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lt attribute");
| 60358 | return -1; |  | 60310 | return -1;
| 60359 | } |  | 60311 | }
| 60360 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1; |  | 60312 | return pyopencv_to_safe(value, p->v.lt, ArgInfo("value", 0)) ? 0 : -1;
| 60361 | } |  | 60313 | }
| 60362 |  |  | 60314 |
| 60363 | static PyObject* pyopencv_gapi_wip_draw_Text_get_org(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60315 | static PyObject* pyopencv_gapi_wip_draw_Text_get_org(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60364 | { |  | 60316 | {
| 60365 | return pyopencv_from(p->v.org); |  | 60317 | return pyopencv_from(p->v.org);
| 60366 | } |  | 60318 | }
| 60367 |  |  | 60319 |
| 60368 | static int pyopencv_gapi_wip_draw_Text_set_org(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60320 | static int pyopencv_gapi_wip_draw_Text_set_org(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60369 | { |  | 60321 | {
| 60370 | if (!value) |  | 60322 | if (!value)
| 60371 | { |  | 60323 | {
| 60372 | PyErr_SetString(PyExc_TypeError, "Cannot delete the org attribute"); |  | 60324 | PyErr_SetString(PyExc_TypeError, "Cannot delete the org attribute");
| 60373 | return -1; |  | 60325 | return -1;
| 60374 | } |  | 60326 | }
| 60375 | return pyopencv_to_safe(value, p->v.org, ArgInfo("value", 0)) ? 0 : -1; |  | 60327 | return pyopencv_to_safe(value, p->v.org, ArgInfo("value", 0)) ? 0 : -1;
| 60376 | } |  | 60328 | }
| 60377 |  |  | 60329 |
| 60378 | static PyObject* pyopencv_gapi_wip_draw_Text_get_text(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60330 | static PyObject* pyopencv_gapi_wip_draw_Text_get_text(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60379 | { |  | 60331 | {
| 60380 | return pyopencv_from(p->v.text); |  | 60332 | return pyopencv_from(p->v.text);
| 60381 | } |  | 60333 | }
| 60382 |  |  | 60334 |
| 60383 | static int pyopencv_gapi_wip_draw_Text_set_text(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60335 | static int pyopencv_gapi_wip_draw_Text_set_text(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60384 | { |  | 60336 | {
| 60385 | if (!value) |  | 60337 | if (!value)
| 60386 | { |  | 60338 | {
| 60387 | PyErr_SetString(PyExc_TypeError, "Cannot delete the text attribute"); |  | 60339 | PyErr_SetString(PyExc_TypeError, "Cannot delete the text attribute");
| 60388 | return -1; |  | 60340 | return -1;
| 60389 | } |  | 60341 | }
| 60390 | return pyopencv_to_safe(value, p->v.text, ArgInfo("value", 0)) ? 0 : -1; |  | 60342 | return pyopencv_to_safe(value, p->v.text, ArgInfo("value", 0)) ? 0 : -1;
| 60391 | } |  | 60343 | }
| 60392 |  |  | 60344 |
| 60393 | static PyObject* pyopencv_gapi_wip_draw_Text_get_thick(pyopencv_gapi_wip_draw_Text_t* p, void *closure) |  | 60345 | static PyObject* pyopencv_gapi_wip_draw_Text_get_thick(pyopencv_gapi_wip_draw_Text_t* p, void *closure)
| 60394 | { |  | 60346 | {
| 60395 | return pyopencv_from(p->v.thick); |  | 60347 | return pyopencv_from(p->v.thick);
| 60396 | } |  | 60348 | }
| 60397 |  |  | 60349 |
| 60398 | static int pyopencv_gapi_wip_draw_Text_set_thick(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure) |  | 60350 | static int pyopencv_gapi_wip_draw_Text_set_thick(pyopencv_gapi_wip_draw_Text_t* p, PyObject *value, void *closure)
| 60399 | { |  | 60351 | {
| 60400 | if (!value) |  | 60352 | if (!value)
| 60401 | { |  | 60353 | {
| 60402 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute"); |  | 60354 | PyErr_SetString(PyExc_TypeError, "Cannot delete the thick attribute");
| 60403 | return -1; |  | 60355 | return -1;
| 60404 | } |  | 60356 | }
| 60405 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1; |  | 60357 | return pyopencv_to_safe(value, p->v.thick, ArgInfo("value", 0)) ? 0 : -1;
| 60406 | } |  | 60358 | }
| 60407 |  |  | 60359 |
| 60408 |  |  | 60360 |
| 60409 | // Methods (gapi_wip_draw_Text) |  | 60361 | // Methods (gapi_wip_draw_Text)
| 60410 |  |  | 60362 |
| 60411 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Text_Text(pyopencv_gapi_wip_draw_Text_t* self, PyObject* py_args, PyObject* kw) |  | 60363 | static int pyopencv_cv_gapi_wip_draw_gapi_wip_draw_Text_Text(pyopencv_gapi_wip_draw_Text_t* self, PyObject* py_args, PyObject* kw)
| 60412 | { |  | 60364 | {
| 60413 | using namespace cv::gapi::wip::draw; |  | 60365 | using namespace cv::gapi::wip::draw;
| 60414 |  |  | 60366 |
| 60415 | pyPrepareArgumentConversionErrorsStorage(2); |  | 60367 | pyPrepareArgumentConversionErrorsStorage(2);
| 60416 |  |  | 60368 |
| 60417 | { |  | 60369 | {
| 60418 | PyObject* pyobj_text_ = NULL; |  | 60370 | PyObject* pyobj_text_ = NULL;
| 60419 | std::string text_; |  | 60371 | std::string text_;
| 60420 | PyObject* pyobj_org_ = NULL; |  | 60372 | PyObject* pyobj_org_ = NULL;
| 60421 | Point org_; |  | 60373 | Point org_;
| 60422 | PyObject* pyobj_ff_ = NULL; |  | 60374 | PyObject* pyobj_ff_ = NULL;
| 60423 | int ff_=0; |  | 60375 | int ff_=0;
| 60424 | PyObject* pyobj_fs_ = NULL; |  | 60376 | PyObject* pyobj_fs_ = NULL;
| 60425 | double fs_=0; |  | 60377 | double fs_=0;
| 60426 | PyObject* pyobj_color_ = NULL; |  | 60378 | PyObject* pyobj_color_ = NULL;
| 60427 | Scalar color_; |  | 60379 | Scalar color_;
| 60428 | PyObject* pyobj_thick_ = NULL; |  | 60380 | PyObject* pyobj_thick_ = NULL;
| 60429 | int thick_=1; |  | 60381 | int thick_=1;
| 60430 | PyObject* pyobj_lt_ = NULL; |  | 60382 | PyObject* pyobj_lt_ = NULL;
| 60431 | int lt_=8; |  | 60383 | int lt_=8;
| 60432 | PyObject* pyobj_bottom_left_origin_ = NULL; |  | 60384 | PyObject* pyobj_bottom_left_origin_ = NULL;
| 60433 | bool bottom_left_origin_=false; |  | 60385 | bool bottom_left_origin_=false;
| 60434 |  |  | 60386 |
| 60435 | const char* keywords[] = { "text_", "org_", "ff_", "fs_", "color_", "thick_", "lt_", "bottom_left_origin_", NULL }; |  | 60387 | const char* keywords[] = { "text_", "org_", "ff_", "fs_", "color_", "thick_", "lt_", "bottom_left_origin_", NULL };
| 60436 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOO:Text", (char**)keywords, &pyobj_text_, &pyobj_org_, &pyobj_ff_, &pyobj_fs_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_bottom_left_origin_) && |  | 60388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO|OOO:Text", (char**)keywords, &pyobj_text_, &pyobj_org_, &pyobj_ff_, &pyobj_fs_, &pyobj_color_, &pyobj_thick_, &pyobj_lt_, &pyobj_bottom_left_origin_) &&
| 60437 | pyopencv_to_safe(pyobj_text_, text_, ArgInfo("text_", 0)) && |  | 60389 | pyopencv_to_safe(pyobj_text_, text_, ArgInfo("text_", 0)) &&
| 60438 | pyopencv_to_safe(pyobj_org_, org_, ArgInfo("org_", 0)) && |  | 60390 | pyopencv_to_safe(pyobj_org_, org_, ArgInfo("org_", 0)) &&
| 60439 | pyopencv_to_safe(pyobj_ff_, ff_, ArgInfo("ff_", 0)) && |  | 60391 | pyopencv_to_safe(pyobj_ff_, ff_, ArgInfo("ff_", 0)) &&
| 60440 | pyopencv_to_safe(pyobj_fs_, fs_, ArgInfo("fs_", 0)) && |  | 60392 | pyopencv_to_safe(pyobj_fs_, fs_, ArgInfo("fs_", 0)) &&
| 60441 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) && |  | 60393 | pyopencv_to_safe(pyobj_color_, color_, ArgInfo("color_", 0)) &&
| 60442 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) && |  | 60394 | pyopencv_to_safe(pyobj_thick_, thick_, ArgInfo("thick_", 0)) &&
| 60443 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) && |  | 60395 | pyopencv_to_safe(pyobj_lt_, lt_, ArgInfo("lt_", 0)) &&
| 60444 | pyopencv_to_safe(pyobj_bottom_left_origin_, bottom_left_origin_, ArgInfo("bottom_left_origin_", 0)) ) |  | 60396 | pyopencv_to_safe(pyobj_bottom_left_origin_, bottom_left_origin_, ArgInfo("bottom_left_origin_", 0)) )
| 60445 | { |  | 60397 | {
| 60446 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Text(text_, org_, ff_, fs_, color_, thick_, lt_, bottom_left_origin_)); |  | 60398 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Text(text_, org_, ff_, fs_, color_, thick_, lt_, bottom_left_origin_));
| 60447 | return 0; |  | 60399 | return 0;
| 60448 | } |  | 60400 | }
| 60449 |  |  | 60401 |
| 60450 |  |  | 60402 |
| 60451 | pyPopulateArgumentConversionErrors(); |  | 60403 | pyPopulateArgumentConversionErrors();
| 60452 | } |  | 60404 | }
| 60453 |  |  | 60405 |
| 60454 |  |  | 60406 |
| 60455 | { |  | 60407 | {
| 60456 |  |  | 60408 |
| 60457 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 60409 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 60458 | { |  | 60410 | {
| 60459 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Text()); |  | 60411 | if(self) ERRWRAP2(new (&(self->v)) cv::gapi::wip::draw::Text());
| 60460 | return 0; |  | 60412 | return 0;
| 60461 | } |  | 60413 | }
| 60462 |  |  | 60414 |
| 60463 |  |  | 60415 |
| 60464 | pyPopulateArgumentConversionErrors(); |  | 60416 | pyPopulateArgumentConversionErrors();
| 60465 | } |  | 60417 | }
| 60466 | pyRaiseCVOverloadException("Text"); |  | 60418 | pyRaiseCVOverloadException("Text");
| 60467 |  |  | 60419 |
| 60468 | return -1; |  | 60420 | return -1;
| 60469 | } |  | 60421 | }
| 60470 |  |  | 60422 |
| 60471 |  |  | 60423 |
| 60472 |  |  | 60424 |
| 60473 | // Tables (gapi_wip_draw_Text) |  | 60425 | // Tables (gapi_wip_draw_Text)
| 60474 |  |  | 60426 |
| 60475 | static PyGetSetDef pyopencv_gapi_wip_draw_Text_getseters[] = |  | 60427 | static PyGetSetDef pyopencv_gapi_wip_draw_Text_getseters[] =
| 60476 | { |  | 60428 | {
| 60477 | {(char*)"bottom_left_origin", (getter)pyopencv_gapi_wip_draw_Text_get_bottom_left_origin, (setter)pyopencv_gapi_wip_draw_Text_set_bottom_left_origin, (char*)"bottom_left_origin", NULL}, |  | 60429 | {(char*)"bottom_left_origin", (getter)pyopencv_gapi_wip_draw_Text_get_bottom_left_origin, (setter)pyopencv_gapi_wip_draw_Text_set_bottom_left_origin, (char*)"bottom_left_origin", NULL},
| 60478 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Text_get_color, (setter)pyopencv_gapi_wip_draw_Text_set_color, (char*)"color", NULL}, |  | 60430 | {(char*)"color", (getter)pyopencv_gapi_wip_draw_Text_get_color, (setter)pyopencv_gapi_wip_draw_Text_set_color, (char*)"color", NULL},
| 60479 | {(char*)"ff", (getter)pyopencv_gapi_wip_draw_Text_get_ff, (setter)pyopencv_gapi_wip_draw_Text_set_ff, (char*)"ff", NULL}, |  | 60431 | {(char*)"ff", (getter)pyopencv_gapi_wip_draw_Text_get_ff, (setter)pyopencv_gapi_wip_draw_Text_set_ff, (char*)"ff", NULL},
| 60480 | {(char*)"fs", (getter)pyopencv_gapi_wip_draw_Text_get_fs, (setter)pyopencv_gapi_wip_draw_Text_set_fs, (char*)"fs", NULL}, |  | 60432 | {(char*)"fs", (getter)pyopencv_gapi_wip_draw_Text_get_fs, (setter)pyopencv_gapi_wip_draw_Text_set_fs, (char*)"fs", NULL},
| 60481 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Text_get_lt, (setter)pyopencv_gapi_wip_draw_Text_set_lt, (char*)"lt", NULL}, |  | 60433 | {(char*)"lt", (getter)pyopencv_gapi_wip_draw_Text_get_lt, (setter)pyopencv_gapi_wip_draw_Text_set_lt, (char*)"lt", NULL},
| 60482 | {(char*)"org", (getter)pyopencv_gapi_wip_draw_Text_get_org, (setter)pyopencv_gapi_wip_draw_Text_set_org, (char*)"org", NULL}, |  | 60434 | {(char*)"org", (getter)pyopencv_gapi_wip_draw_Text_get_org, (setter)pyopencv_gapi_wip_draw_Text_set_org, (char*)"org", NULL},
| 60483 | {(char*)"text", (getter)pyopencv_gapi_wip_draw_Text_get_text, (setter)pyopencv_gapi_wip_draw_Text_set_text, (char*)"text", NULL}, |  | 60435 | {(char*)"text", (getter)pyopencv_gapi_wip_draw_Text_get_text, (setter)pyopencv_gapi_wip_draw_Text_set_text, (char*)"text", NULL},
| 60484 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Text_get_thick, (setter)pyopencv_gapi_wip_draw_Text_set_thick, (char*)"thick", NULL}, |  | 60436 | {(char*)"thick", (getter)pyopencv_gapi_wip_draw_Text_get_thick, (setter)pyopencv_gapi_wip_draw_Text_set_thick, (char*)"thick", NULL},
| 60485 | {NULL} /* Sentinel */ |  | 60437 | {NULL} /* Sentinel */
| 60486 | }; |  | 60438 | };
| 60487 |  |  | 60439 |
| 60488 | static PyMethodDef pyopencv_gapi_wip_draw_Text_methods[] = |  | 60440 | static PyMethodDef pyopencv_gapi_wip_draw_Text_methods[] =
| 60489 | { |  | 60441 | {
| 60490 |  |  | 60442 |
| 60491 | {NULL, NULL} |  | 60443 | {NULL, NULL}
| 60492 | }; |  | 60444 | };
| 60493 |  |  | 60445 |
| 60494 | // Converter (gapi_wip_draw_Text) |  | 60446 | // Converter (gapi_wip_draw_Text)
| 60495 |  |  | 60447 |
| 60496 | template<> |  | 60448 | template<>
| 60497 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Text > |  | 60449 | struct PyOpenCV_Converter< cv::gapi::wip::draw::Text >
| 60498 | { |  | 60450 | {
| 60499 | static PyObject* from(const cv::gapi::wip::draw::Text& r) |  | 60451 | static PyObject* from(const cv::gapi::wip::draw::Text& r)
| 60500 | { |  | 60452 | {
| 60501 | return pyopencv_gapi_wip_draw_Text_Instance(r); |  | 60453 | return pyopencv_gapi_wip_draw_Text_Instance(r);
| 60502 | } |  | 60454 | }
| 60503 | static bool to(PyObject* src, cv::gapi::wip::draw::Text& dst, const ArgInfo& info) |  | 60455 | static bool to(PyObject* src, cv::gapi::wip::draw::Text& dst, const ArgInfo& info)
| 60504 | { |  | 60456 | {
| 60505 | if(!src || src == Py_None) |  | 60457 | if(!src || src == Py_None)
| 60506 | return true; |  | 60458 | return true;
| 60507 | cv::gapi::wip::draw::Text * dst_; |  | 60459 | cv::gapi::wip::draw::Text * dst_;
| 60508 | if (pyopencv_gapi_wip_draw_Text_getp(src, dst_)) |  | 60460 | if (pyopencv_gapi_wip_draw_Text_getp(src, dst_))
| 60509 | { |  | 60461 | {
| 60510 | dst = *dst_; |  | 60462 | dst = *dst_;
| 60511 | return true; |  | 60463 | return true;
| 60512 | } |  | 60464 | }
| 60513 |  |  | 60465 |
| 60514 | failmsg("Expected cv::gapi::wip::draw::Text for argument '%s'", info.name); |  | 60466 | failmsg("Expected cv::gapi::wip::draw::Text for argument '%s'", info.name);
| 60515 | return false; |  | 60467 | return false;
| 60516 | } |  | 60468 | }
| 60517 | }; |  | 60469 | };
| 60518 |  |  | 60470 |
| 60519 | //================================================================================ |  | 60471 | //================================================================================
| 60520 | // gapi_wip_gst_GStreamerPipeline (Generic) |  | 60472 | // gapi_wip_gst_GStreamerPipeline (Generic)
| 60521 | //================================================================================ |  | 60473 | //================================================================================
| 60522 |  |  | 60474 |
| 60523 | // GetSet (gapi_wip_gst_GStreamerPipeline) |  | 60475 | // GetSet (gapi_wip_gst_GStreamerPipeline)
| 60524 |  |  | 60476 |
| 60525 |  |  | 60477 |
| 60526 |  |  | 60478 |
| 60527 | // Methods (gapi_wip_gst_GStreamerPipeline) |  | 60479 | // Methods (gapi_wip_gst_GStreamerPipeline)
| 60528 |  |  | 60480 |
| 60529 | static int pyopencv_cv_gapi_wip_gst_gapi_wip_gst_GStreamerPipeline_GStreamerPipeline(pyopencv_gapi_wip_gst_GStreamerPipeline_t* self, PyObject* py_args, PyObject* kw) |  | 60481 | static int pyopencv_cv_gapi_wip_gst_gapi_wip_gst_GStreamerPipeline_GStreamerPipeline(pyopencv_gapi_wip_gst_GStreamerPipeline_t* self, PyObject* py_args, PyObject* kw)
| 60530 | { |  | 60482 | {
| 60531 | using namespace cv::gapi::wip::gst; |  | 60483 | using namespace cv::gapi::wip::gst;
| 60532 |  |  | 60484 |
| 60533 | PyObject* pyobj_pipeline = NULL; |  | 60485 | PyObject* pyobj_pipeline = NULL;
| 60534 | std::string pipeline; |  | 60486 | std::string pipeline;
| 60535 |  |  | 60487 |
| 60536 | const char* keywords[] = { "pipeline", NULL }; |  | 60488 | const char* keywords[] = { "pipeline", NULL };
| 60537 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GStreamerPipeline", (char**)keywords, &pyobj_pipeline) && |  | 60489 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:GStreamerPipeline", (char**)keywords, &pyobj_pipeline) &&
| 60538 | pyopencv_to_safe(pyobj_pipeline, pipeline, ArgInfo("pipeline", 0)) ) |  | 60490 | pyopencv_to_safe(pyobj_pipeline, pipeline, ArgInfo("pipeline", 0)) )
| 60539 | { |  | 60491 | {
| 60540 | new (&(self->v)) Ptr<cv::gapi::wip::gst::GStreamerPipeline>(); // init Ptr with placement new |  | 60492 | new (&(self->v)) Ptr<cv::gapi::wip::gst::GStreamerPipeline>(); // init Ptr with placement new
| 60541 | if(self) ERRWRAP2(self->v.reset(new cv::gapi::wip::gst::GStreamerPipeline(pipeline))); |  | 60493 | if(self) ERRWRAP2(self->v.reset(new cv::gapi::wip::gst::GStreamerPipeline(pipeline)));
| 60542 | return 0; |  | 60494 | return 0;
| 60543 | } |  | 60495 | }
| 60544 |  |  | 60496 |
| 60545 | return -1; |  | 60497 | return -1;
| 60546 | } |  | 60498 | }
| 60547 |  |  | 60499 |
| 60548 |  |  | 60500 |
| 60549 |  |  | 60501 |
| 60550 | // Tables (gapi_wip_gst_GStreamerPipeline) |  | 60502 | // Tables (gapi_wip_gst_GStreamerPipeline)
| 60551 |  |  | 60503 |
| 60552 | static PyGetSetDef pyopencv_gapi_wip_gst_GStreamerPipeline_getseters[] = |  | 60504 | static PyGetSetDef pyopencv_gapi_wip_gst_GStreamerPipeline_getseters[] =
| 60553 | { |  | 60505 | {
| 60554 | {NULL} /* Sentinel */ |  | 60506 | {NULL} /* Sentinel */
| 60555 | }; |  | 60507 | };
| 60556 |  |  | 60508 |
| 60557 | static PyMethodDef pyopencv_gapi_wip_gst_GStreamerPipeline_methods[] = |  | 60509 | static PyMethodDef pyopencv_gapi_wip_gst_GStreamerPipeline_methods[] =
| 60558 | { |  | 60510 | {
| 60559 |  |  | 60511 |
| 60560 | {NULL, NULL} |  | 60512 | {NULL, NULL}
| 60561 | }; |  | 60513 | };
| 60562 |  |  | 60514 |
| 60563 | // Converter (gapi_wip_gst_GStreamerPipeline) |  | 60515 | // Converter (gapi_wip_gst_GStreamerPipeline)
| 60564 |  |  | 60516 |
| 60565 | template<> |  | 60517 | template<>
| 60566 | struct PyOpenCV_Converter< Ptr<cv::gapi::wip::gst::GStreamerPipeline> > |  | 60518 | struct PyOpenCV_Converter< Ptr<cv::gapi::wip::gst::GStreamerPipeline> >
| 60567 | { |  | 60519 | {
| 60568 | static PyObject* from(const Ptr<cv::gapi::wip::gst::GStreamerPipeline>& r) |  | 60520 | static PyObject* from(const Ptr<cv::gapi::wip::gst::GStreamerPipeline>& r)
| 60569 | { |  | 60521 | {
| 60570 | return pyopencv_gapi_wip_gst_GStreamerPipeline_Instance(r); |  | 60522 | return pyopencv_gapi_wip_gst_GStreamerPipeline_Instance(r);
| 60571 | } |  | 60523 | }
| 60572 | static bool to(PyObject* src, Ptr<cv::gapi::wip::gst::GStreamerPipeline>& dst, const ArgInfo& info) |  | 60524 | static bool to(PyObject* src, Ptr<cv::gapi::wip::gst::GStreamerPipeline>& dst, const ArgInfo& info)
| 60573 | { |  | 60525 | {
| 60574 | if(!src || src == Py_None) |  | 60526 | if(!src || src == Py_None)
| 60575 | return true; |  | 60527 | return true;
| 60576 | Ptr<cv::gapi::wip::gst::GStreamerPipeline> * dst_; |  | 60528 | Ptr<cv::gapi::wip::gst::GStreamerPipeline> * dst_;
| 60577 | if (pyopencv_gapi_wip_gst_GStreamerPipeline_getp(src, dst_)) |  | 60529 | if (pyopencv_gapi_wip_gst_GStreamerPipeline_getp(src, dst_))
| 60578 | { |  | 60530 | {
| 60579 | dst = *dst_; |  | 60531 | dst = *dst_;
| 60580 | return true; |  | 60532 | return true;
| 60581 | } |  | 60533 | }
| 60582 |  |  | 60534 |
| 60583 | failmsg("Expected Ptr<cv::gapi::wip::gst::GStreamerPipeline> for argument '%s'", info.name); |  | 60535 | failmsg("Expected Ptr<cv::gapi::wip::gst::GStreamerPipeline> for argument '%s'", info.name);
| 60584 | return false; |  | 60536 | return false;
| 60585 | } |  | 60537 | }
| 60586 | }; |  | 60538 | };
| 60587 |  |  | 60539 |
| 60588 | //================================================================================ |  | 60540 | //================================================================================
| 60589 | // hdf_HDF5 (Generic) |  | 60541 | // hdf_HDF5 (Generic)
| 60590 | //================================================================================ |  | 60542 | //================================================================================
| 60591 |  |  | 60543 |
| 60592 | // GetSet (hdf_HDF5) |  | 60544 | // GetSet (hdf_HDF5)
| 60593 |  |  | 60545 |
| 60594 |  |  | 60546 |
| 60595 |  |  | 60547 |
| 60596 | // Methods (hdf_HDF5) |  | 60548 | // Methods (hdf_HDF5)
| 60597 |  |  | 60549 |
| 60598 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atdelete(PyObject* self, PyObject* py_args, PyObject* kw) |  | 60550 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atdelete(PyObject* self, PyObject* py_args, PyObject* kw)
| 60599 | { |  | 60551 | {
| 60600 | using namespace cv::hdf; |  | 60552 | using namespace cv::hdf;
| 60601 |  |  | 60553 |
| 60602 |  |  | 60554 |
| 60603 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 60555 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 60604 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 60556 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 60605 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 60557 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 60606 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 60558 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 60607 | PyObject* pyobj_atlabel = NULL; |  | 60559 | PyObject* pyobj_atlabel = NULL;
| 60608 | String atlabel; |  | 60560 | String atlabel;
| 60609 |  |  | 60561 |
| 60610 | const char* keywords[] = { "atlabel", NULL }; |  | 60562 | const char* keywords[] = { "atlabel", NULL };
| 60611 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.atdelete", (char**)keywords, &pyobj_atlabel) && |  | 60563 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.atdelete", (char**)keywords, &pyobj_atlabel) &&
| 60612 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60564 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60613 | { |  | 60565 | {
| 60614 | ERRWRAP2(_self_->atdelete(atlabel)); |  | 60566 | ERRWRAP2(_self_->atdelete(atlabel));
| 60615 | Py_RETURN_NONE; |  | 60567 | Py_RETURN_NONE;
| 60616 | } |  | 60568 | }
| 60617 |  |  | 60569 |
| 60618 | return NULL; |  | 60570 | return NULL;
| 60619 | } |  | 60571 | }
| 60620 |  |  | 60572 |
| 60621 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atexists(PyObject* self, PyObject* py_args, PyObject* kw) |  | 60573 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atexists(PyObject* self, PyObject* py_args, PyObject* kw)
| 60622 | { |  | 60574 | {
| 60623 | using namespace cv::hdf; |  | 60575 | using namespace cv::hdf;
| 60624 |  |  | 60576 |
| 60625 |  |  | 60577 |
| 60626 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 60578 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 60627 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 60579 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 60628 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 60580 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 60629 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 60581 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 60630 | PyObject* pyobj_atlabel = NULL; |  | 60582 | PyObject* pyobj_atlabel = NULL;
| 60631 | String atlabel; |  | 60583 | String atlabel;
| 60632 | bool retval; |  | 60584 | bool retval;
| 60633 |  |  | 60585 |
| 60634 | const char* keywords[] = { "atlabel", NULL }; |  | 60586 | const char* keywords[] = { "atlabel", NULL };
| 60635 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.atexists", (char**)keywords, &pyobj_atlabel) && |  | 60587 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.atexists", (char**)keywords, &pyobj_atlabel) &&
| 60636 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60588 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60637 | { |  | 60589 | {
| 60638 | ERRWRAP2(retval = _self_->atexists(atlabel)); |  | 60590 | ERRWRAP2(retval = _self_->atexists(atlabel));
| 60639 | return pyopencv_from(retval); |  | 60591 | return pyopencv_from(retval);
| 60640 | } |  | 60592 | }
| 60641 |  |  | 60593 |
| 60642 | return NULL; |  | 60594 | return NULL;
| 60643 | } |  | 60595 | }
| 60644 |  |  | 60596 |
| 60645 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atread(PyObject* self, PyObject* py_args, PyObject* kw) |  | 60597 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atread(PyObject* self, PyObject* py_args, PyObject* kw)
| 60646 | { |  | 60598 | {
| 60647 | using namespace cv::hdf; |  | 60599 | using namespace cv::hdf;
| 60648 |  |  | 60600 |
| 60649 |  |  | 60601 |
| 60650 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 60602 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 60651 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 60603 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 60652 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 60604 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 60653 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 60605 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 60654 | pyPrepareArgumentConversionErrorsStorage(5); |  | 60606 | pyPrepareArgumentConversionErrorsStorage(5);
| 60655 |  |  | 60607 |
| 60656 | { |  | 60608 | {
| 60657 | PyObject* pyobj_value = NULL; |  | 60609 | PyObject* pyobj_value = NULL;
| 60658 | int value=0; |  | 60610 | int value=0;
| 60659 | PyObject* pyobj_atlabel = NULL; |  | 60611 | PyObject* pyobj_atlabel = NULL;
| 60660 | String atlabel; |  | 60612 | String atlabel;
| 60661 |  |  | 60613 |
| 60662 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60614 | const char* keywords[] = { "value", "atlabel", NULL };
| 60663 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atread", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60615 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atread", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60664 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60616 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60665 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60617 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60666 | { |  | 60618 | {
| 60667 | ERRWRAP2(_self_->atread(&value, atlabel)); |  | 60619 | ERRWRAP2(_self_->atread(&value, atlabel));
| 60668 | Py_RETURN_NONE; |  | 60620 | Py_RETURN_NONE;
| 60669 | } |  | 60621 | }
| 60670 |  |  | 60622 |
| 60671 |  |  | 60623 |
| 60672 | pyPopulateArgumentConversionErrors(); |  | 60624 | pyPopulateArgumentConversionErrors();
| 60673 | } |  | 60625 | }
| 60674 |  |  | 60626 |
| 60675 |  |  | 60627 |
| 60676 | { |  | 60628 | {
| 60677 | PyObject* pyobj_value = NULL; |  | 60629 | PyObject* pyobj_value = NULL;
| 60678 | double value=0; |  | 60630 | double value=0;
| 60679 | PyObject* pyobj_atlabel = NULL; |  | 60631 | PyObject* pyobj_atlabel = NULL;
| 60680 | String atlabel; |  | 60632 | String atlabel;
| 60681 |  |  | 60633 |
| 60682 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60634 | const char* keywords[] = { "value", "atlabel", NULL };
| 60683 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atread", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60635 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atread", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60684 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60636 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60685 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60637 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60686 | { |  | 60638 | {
| 60687 | ERRWRAP2(_self_->atread(&value, atlabel)); |  | 60639 | ERRWRAP2(_self_->atread(&value, atlabel));
| 60688 | Py_RETURN_NONE; |  | 60640 | Py_RETURN_NONE;
| 60689 | } |  | 60641 | }
| 60690 |  |  | 60642 |
| 60691 |  |  | 60643 |
| 60692 | pyPopulateArgumentConversionErrors(); |  | 60644 | pyPopulateArgumentConversionErrors();
| 60693 | } |  | 60645 | }
| 60694 |  |  | 60646 |
| 60695 |  |  | 60647 |
| 60696 | { |  | 60648 | {
| 60697 | PyObject* pyobj_value = NULL; |  | 60649 | PyObject* pyobj_value = NULL;
| 60698 | String value; |  | 60650 | String value;
| 60699 | PyObject* pyobj_atlabel = NULL; |  | 60651 | PyObject* pyobj_atlabel = NULL;
| 60700 | String atlabel; |  | 60652 | String atlabel;
| 60701 |  |  | 60653 |
| 60702 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60654 | const char* keywords[] = { "value", "atlabel", NULL };
| 60703 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atread", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60655 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atread", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60704 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60656 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60705 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60657 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60706 | { |  | 60658 | {
| 60707 | ERRWRAP2(_self_->atread(&value, atlabel)); |  | 60659 | ERRWRAP2(_self_->atread(&value, atlabel));
| 60708 | Py_RETURN_NONE; |  | 60660 | Py_RETURN_NONE;
| 60709 | } |  | 60661 | }
| 60710 |  |  | 60662 |
| 60711 |  |  | 60663 |
| 60712 | pyPopulateArgumentConversionErrors(); |  | 60664 | pyPopulateArgumentConversionErrors();
| 60713 | } |  | 60665 | }
| 60714 |  |  | 60666 |
| 60715 |  |  | 60667 |
| 60716 | { |  | 60668 | {
| 60717 | PyObject* pyobj_value = NULL; |  | 60669 | PyObject* pyobj_value = NULL;
| 60718 | Mat value; |  | 60670 | Mat value;
| 60719 | PyObject* pyobj_atlabel = NULL; |  | 60671 | PyObject* pyobj_atlabel = NULL;
| 60720 | String atlabel; |  | 60672 | String atlabel;
| 60721 |  |  | 60673 |
| 60722 | const char* keywords[] = { "atlabel", "value", NULL }; |  | 60674 | const char* keywords[] = { "atlabel", "value", NULL };
| 60723 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.atread", (char**)keywords, &pyobj_atlabel, &pyobj_value) && |  | 60675 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.atread", (char**)keywords, &pyobj_atlabel, &pyobj_value) &&
| 60724 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 1)) && |  | 60676 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 1)) &&
| 60725 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60677 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60726 | { |  | 60678 | {
| 60727 | ERRWRAP2(_self_->atread(value, atlabel)); |  | 60679 | ERRWRAP2(_self_->atread(value, atlabel));
| 60728 | return pyopencv_from(value); |  | 60680 | return pyopencv_from(value);
| 60729 | } |  | 60681 | }
| 60730 |  |  | 60682 |
| 60731 |  |  | 60683 |
| 60732 | pyPopulateArgumentConversionErrors(); |  | 60684 | pyPopulateArgumentConversionErrors();
| 60733 | } |  | 60685 | }
| 60734 |  |  | 60686 |
| 60735 |  |  | 60687 |
| 60736 | { |  | 60688 | {
| 60737 | PyObject* pyobj_value = NULL; |  | 60689 | PyObject* pyobj_value = NULL;
| 60738 | UMat value; |  | 60690 | UMat value;
| 60739 | PyObject* pyobj_atlabel = NULL; |  | 60691 | PyObject* pyobj_atlabel = NULL;
| 60740 | String atlabel; |  | 60692 | String atlabel;
| 60741 |  |  | 60693 |
| 60742 | const char* keywords[] = { "atlabel", "value", NULL }; |  | 60694 | const char* keywords[] = { "atlabel", "value", NULL };
| 60743 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.atread", (char**)keywords, &pyobj_atlabel, &pyobj_value) && |  | 60695 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.atread", (char**)keywords, &pyobj_atlabel, &pyobj_value) &&
| 60744 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 1)) && |  | 60696 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 1)) &&
| 60745 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60697 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60746 | { |  | 60698 | {
| 60747 | ERRWRAP2(_self_->atread(value, atlabel)); |  | 60699 | ERRWRAP2(_self_->atread(value, atlabel));
| 60748 | return pyopencv_from(value); |  | 60700 | return pyopencv_from(value);
| 60749 | } |  | 60701 | }
| 60750 |  |  | 60702 |
| 60751 |  |  | 60703 |
| 60752 | pyPopulateArgumentConversionErrors(); |  | 60704 | pyPopulateArgumentConversionErrors();
| 60753 | } |  | 60705 | }
| 60754 | pyRaiseCVOverloadException("atread"); |  | 60706 | pyRaiseCVOverloadException("atread");
| 60755 |  |  | 60707 |
| 60756 | return NULL; |  | 60708 | return NULL;
| 60757 | } |  | 60709 | }
| 60758 |  |  | 60710 |
| 60759 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atwrite(PyObject* self, PyObject* py_args, PyObject* kw) |  | 60711 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_atwrite(PyObject* self, PyObject* py_args, PyObject* kw)
| 60760 | { |  | 60712 | {
| 60761 | using namespace cv::hdf; |  | 60713 | using namespace cv::hdf;
| 60762 |  |  | 60714 |
| 60763 |  |  | 60715 |
| 60764 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 60716 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 60765 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 60717 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 60766 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 60718 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 60767 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 60719 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 60768 | pyPrepareArgumentConversionErrorsStorage(5); |  | 60720 | pyPrepareArgumentConversionErrorsStorage(5);
| 60769 |  |  | 60721 |
| 60770 | { |  | 60722 | {
| 60771 | PyObject* pyobj_value = NULL; |  | 60723 | PyObject* pyobj_value = NULL;
| 60772 | int value=0; |  | 60724 | int value=0;
| 60773 | PyObject* pyobj_atlabel = NULL; |  | 60725 | PyObject* pyobj_atlabel = NULL;
| 60774 | String atlabel; |  | 60726 | String atlabel;
| 60775 |  |  | 60727 |
| 60776 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60728 | const char* keywords[] = { "value", "atlabel", NULL };
| 60777 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60729 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60778 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60730 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60779 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60731 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60780 | { |  | 60732 | {
| 60781 | ERRWRAP2(_self_->atwrite(value, atlabel)); |  | 60733 | ERRWRAP2(_self_->atwrite(value, atlabel));
| 60782 | Py_RETURN_NONE; |  | 60734 | Py_RETURN_NONE;
| 60783 | } |  | 60735 | }
| 60784 |  |  | 60736 |
| 60785 |  |  | 60737 |
| 60786 | pyPopulateArgumentConversionErrors(); |  | 60738 | pyPopulateArgumentConversionErrors();
| 60787 | } |  | 60739 | }
| 60788 |  |  | 60740 |
| 60789 |  |  | 60741 |
| 60790 | { |  | 60742 | {
| 60791 | PyObject* pyobj_value = NULL; |  | 60743 | PyObject* pyobj_value = NULL;
| 60792 | double value=0; |  | 60744 | double value=0;
| 60793 | PyObject* pyobj_atlabel = NULL; |  | 60745 | PyObject* pyobj_atlabel = NULL;
| 60794 | String atlabel; |  | 60746 | String atlabel;
| 60795 |  |  | 60747 |
| 60796 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60748 | const char* keywords[] = { "value", "atlabel", NULL };
| 60797 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60749 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60798 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60750 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60799 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60751 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60800 | { |  | 60752 | {
| 60801 | ERRWRAP2(_self_->atwrite(value, atlabel)); |  | 60753 | ERRWRAP2(_self_->atwrite(value, atlabel));
| 60802 | Py_RETURN_NONE; |  | 60754 | Py_RETURN_NONE;
| 60803 | } |  | 60755 | }
| 60804 |  |  | 60756 |
| 60805 |  |  | 60757 |
| 60806 | pyPopulateArgumentConversionErrors(); |  | 60758 | pyPopulateArgumentConversionErrors();
| 60807 | } |  | 60759 | }
| 60808 |  |  | 60760 |
| 60809 |  |  | 60761 |
| 60810 | { |  | 60762 | {
| 60811 | PyObject* pyobj_value = NULL; |  | 60763 | PyObject* pyobj_value = NULL;
| 60812 | String value; |  | 60764 | String value;
| 60813 | PyObject* pyobj_atlabel = NULL; |  | 60765 | PyObject* pyobj_atlabel = NULL;
| 60814 | String atlabel; |  | 60766 | String atlabel;
| 60815 |  |  | 60767 |
| 60816 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60768 | const char* keywords[] = { "value", "atlabel", NULL };
| 60817 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60769 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60818 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60770 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60819 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60771 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60820 | { |  | 60772 | {
| 60821 | ERRWRAP2(_self_->atwrite(value, atlabel)); |  | 60773 | ERRWRAP2(_self_->atwrite(value, atlabel));
| 60822 | Py_RETURN_NONE; |  | 60774 | Py_RETURN_NONE;
| 60823 | } |  | 60775 | }
| 60824 |  |  | 60776 |
| 60825 |  |  | 60777 |
| 60826 | pyPopulateArgumentConversionErrors(); |  | 60778 | pyPopulateArgumentConversionErrors();
| 60827 | } |  | 60779 | }
| 60828 |  |  | 60780 |
| 60829 |  |  | 60781 |
| 60830 | { |  | 60782 | {
| 60831 | PyObject* pyobj_value = NULL; |  | 60783 | PyObject* pyobj_value = NULL;
| 60832 | Mat value; |  | 60784 | Mat value;
| 60833 | PyObject* pyobj_atlabel = NULL; |  | 60785 | PyObject* pyobj_atlabel = NULL;
| 60834 | String atlabel; |  | 60786 | String atlabel;
| 60835 |  |  | 60787 |
| 60836 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60788 | const char* keywords[] = { "value", "atlabel", NULL };
| 60837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60838 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60790 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60839 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60791 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60840 | { |  | 60792 | {
| 60841 | ERRWRAP2(_self_->atwrite(value, atlabel)); |  | 60793 | ERRWRAP2(_self_->atwrite(value, atlabel));
| 60842 | Py_RETURN_NONE; |  | 60794 | Py_RETURN_NONE;
| 60843 | } |  | 60795 | }
| 60844 |  |  | 60796 |
| 60845 |  |  | 60797 |
| 60846 | pyPopulateArgumentConversionErrors(); |  | 60798 | pyPopulateArgumentConversionErrors();
| 60847 | } |  | 60799 | }
| 60848 |  |  | 60800 |
| 60849 |  |  | 60801 |
| 60850 | { |  | 60802 | {
| 60851 | PyObject* pyobj_value = NULL; |  | 60803 | PyObject* pyobj_value = NULL;
| 60852 | UMat value; |  | 60804 | UMat value;
| 60853 | PyObject* pyobj_atlabel = NULL; |  | 60805 | PyObject* pyobj_atlabel = NULL;
| 60854 | String atlabel; |  | 60806 | String atlabel;
| 60855 |  |  | 60807 |
| 60856 | const char* keywords[] = { "value", "atlabel", NULL }; |  | 60808 | const char* keywords[] = { "value", "atlabel", NULL };
| 60857 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) && |  | 60809 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.atwrite", (char**)keywords, &pyobj_value, &pyobj_atlabel) &&
| 60858 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) && |  | 60810 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) &&
| 60859 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) ) |  | 60811 | pyopencv_to_safe(pyobj_atlabel, atlabel, ArgInfo("atlabel", 0)) )
| 60860 | { |  | 60812 | {
| 60861 | ERRWRAP2(_self_->atwrite(value, atlabel)); |  | 60813 | ERRWRAP2(_self_->atwrite(value, atlabel));
| 60862 | Py_RETURN_NONE; |  | 60814 | Py_RETURN_NONE;
| 60863 | } |  | 60815 | }
| 60864 |  |  | 60816 |
| 60865 |  |  | 60817 |
| 60866 | pyPopulateArgumentConversionErrors(); |  | 60818 | pyPopulateArgumentConversionErrors();
| 60867 | } |  | 60819 | }
| 60868 | pyRaiseCVOverloadException("atwrite"); |  | 60820 | pyRaiseCVOverloadException("atwrite");
| 60869 |  |  | 60821 |
| 60870 | return NULL; |  | 60822 | return NULL;
| 60871 | } |  | 60823 | }
| 60872 |  |  | 60824 |
| 60873 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_close(PyObject* self, PyObject* py_args, PyObject* kw) |  | 60825 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_close(PyObject* self, PyObject* py_args, PyObject* kw)
| 60874 | { |  | 60826 | {
| 60875 | using namespace cv::hdf; |  | 60827 | using namespace cv::hdf;
| 60876 |  |  | 60828 |
| 60877 |  |  | 60829 |
| 60878 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 60830 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 60879 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 60831 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 60880 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 60832 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 60881 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 60833 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 60882 |  |  | 60834 |
| 60883 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 60835 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 60884 | { |  | 60836 | {
| 60885 | ERRWRAP2(_self_->close()); |  | 60837 | ERRWRAP2(_self_->close());
| 60886 | Py_RETURN_NONE; |  | 60838 | Py_RETURN_NONE;
| 60887 | } |  | 60839 | }
| 60888 |  |  | 60840 |
| 60889 | return NULL; |  | 60841 | return NULL;
| 60890 | } |  | 60842 | }
| 60891 |  |  | 60843 |
| 60892 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dscreate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 60844 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dscreate(PyObject* self, PyObject* py_args, PyObject* kw)
| 60893 | { |  | 60845 | {
| 60894 | using namespace cv::hdf; |  | 60846 | using namespace cv::hdf;
| 60895 |  |  | 60847 |
| 60896 |  |  | 60848 |
| 60897 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 60849 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 60898 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 60850 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 60899 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 60851 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 60900 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 60852 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 60901 | pyPrepareArgumentConversionErrorsStorage(8); |  | 60853 | pyPrepareArgumentConversionErrorsStorage(8);
| 60902 |  |  | 60854 |
| 60903 | { |  | 60855 | {
| 60904 | PyObject* pyobj_rows = NULL; |  | 60856 | PyObject* pyobj_rows = NULL;
| 60905 | int rows=0; |  | 60857 | int rows=0;
| 60906 | PyObject* pyobj_cols = NULL; |  | 60858 | PyObject* pyobj_cols = NULL;
| 60907 | int cols=0; |  | 60859 | int cols=0;
| 60908 | PyObject* pyobj_type = NULL; |  | 60860 | PyObject* pyobj_type = NULL;
| 60909 | int type=0; |  | 60861 | int type=0;
| 60910 | PyObject* pyobj_dslabel = NULL; |  | 60862 | PyObject* pyobj_dslabel = NULL;
| 60911 | String dslabel; |  | 60863 | String dslabel;
| 60912 |  |  | 60864 |
| 60913 | const char* keywords[] = { "rows", "cols", "type", "dslabel", NULL }; |  | 60865 | const char* keywords[] = { "rows", "cols", "type", "dslabel", NULL };
| 60914 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel) && |  | 60866 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel) &&
| 60915 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 60867 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 60916 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 60868 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 60917 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 60869 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 60918 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 60870 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 60919 | { |  | 60871 | {
| 60920 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel)); |  | 60872 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel));
| 60921 | Py_RETURN_NONE; |  | 60873 | Py_RETURN_NONE;
| 60922 | } |  | 60874 | }
| 60923 |  |  | 60875 |
| 60924 |  |  | 60876 |
| 60925 | pyPopulateArgumentConversionErrors(); |  | 60877 | pyPopulateArgumentConversionErrors();
| 60926 | } |  | 60878 | }
| 60927 |  |  | 60879 |
| 60928 |  |  | 60880 |
| 60929 | { |  | 60881 | {
| 60930 | PyObject* pyobj_rows = NULL; |  | 60882 | PyObject* pyobj_rows = NULL;
| 60931 | int rows=0; |  | 60883 | int rows=0;
| 60932 | PyObject* pyobj_cols = NULL; |  | 60884 | PyObject* pyobj_cols = NULL;
| 60933 | int cols=0; |  | 60885 | int cols=0;
| 60934 | PyObject* pyobj_type = NULL; |  | 60886 | PyObject* pyobj_type = NULL;
| 60935 | int type=0; |  | 60887 | int type=0;
| 60936 | PyObject* pyobj_dslabel = NULL; |  | 60888 | PyObject* pyobj_dslabel = NULL;
| 60937 | String dslabel; |  | 60889 | String dslabel;
| 60938 | PyObject* pyobj_compresslevel = NULL; |  | 60890 | PyObject* pyobj_compresslevel = NULL;
| 60939 | int compresslevel=0; |  | 60891 | int compresslevel=0;
| 60940 |  |  | 60892 |
| 60941 | const char* keywords[] = { "rows", "cols", "type", "dslabel", "compresslevel", NULL }; |  | 60893 | const char* keywords[] = { "rows", "cols", "type", "dslabel", "compresslevel", NULL };
| 60942 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel) && |  | 60894 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel) &&
| 60943 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 60895 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 60944 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 60896 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 60945 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 60897 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 60946 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 60898 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 60947 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) ) |  | 60899 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) )
| 60948 | { |  | 60900 | {
| 60949 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel, compresslevel)); |  | 60901 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel, compresslevel));
| 60950 | Py_RETURN_NONE; |  | 60902 | Py_RETURN_NONE;
| 60951 | } |  | 60903 | }
| 60952 |  |  | 60904 |
| 60953 |  |  | 60905 |
| 60954 | pyPopulateArgumentConversionErrors(); |  | 60906 | pyPopulateArgumentConversionErrors();
| 60955 | } |  | 60907 | }
| 60956 |  |  | 60908 |
| 60957 |  |  | 60909 |
| 60958 | { |  | 60910 | {
| 60959 | PyObject* pyobj_rows = NULL; |  | 60911 | PyObject* pyobj_rows = NULL;
| 60960 | int rows=0; |  | 60912 | int rows=0;
| 60961 | PyObject* pyobj_cols = NULL; |  | 60913 | PyObject* pyobj_cols = NULL;
| 60962 | int cols=0; |  | 60914 | int cols=0;
| 60963 | PyObject* pyobj_type = NULL; |  | 60915 | PyObject* pyobj_type = NULL;
| 60964 | int type=0; |  | 60916 | int type=0;
| 60965 | PyObject* pyobj_dslabel = NULL; |  | 60917 | PyObject* pyobj_dslabel = NULL;
| 60966 | String dslabel; |  | 60918 | String dslabel;
| 60967 | PyObject* pyobj_compresslevel = NULL; |  | 60919 | PyObject* pyobj_compresslevel = NULL;
| 60968 | int compresslevel=0; |  | 60920 | int compresslevel=0;
| 60969 | PyObject* pyobj_dims_chunks = NULL; |  | 60921 | PyObject* pyobj_dims_chunks = NULL;
| 60970 | vector_int dims_chunks; |  | 60922 | vector_int dims_chunks;
| 60971 |  |  | 60923 |
| 60972 | const char* keywords[] = { "rows", "cols", "type", "dslabel", "compresslevel", "dims_chunks", NULL }; |  | 60924 | const char* keywords[] = { "rows", "cols", "type", "dslabel", "compresslevel", "dims_chunks", NULL };
| 60973 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) && |  | 60925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) &&
| 60974 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 60926 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 60975 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 60927 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 60976 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 60928 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 60977 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 60929 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 60978 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) && |  | 60930 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) &&
| 60979 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) ) |  | 60931 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) )
| 60980 | { |  | 60932 | {
| 60981 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel, compresslevel, dims_chunks)); |  | 60933 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel, compresslevel, dims_chunks));
| 60982 | Py_RETURN_NONE; |  | 60934 | Py_RETURN_NONE;
| 60983 | } |  | 60935 | }
| 60984 |  |  | 60936 |
| 60985 |  |  | 60937 |
| 60986 | pyPopulateArgumentConversionErrors(); |  | 60938 | pyPopulateArgumentConversionErrors();
| 60987 | } |  | 60939 | }
| 60988 |  |  | 60940 |
| 60989 |  |  | 60941 |
| 60990 | { |  | 60942 | {
| 60991 | PyObject* pyobj_rows = NULL; |  | 60943 | PyObject* pyobj_rows = NULL;
| 60992 | int rows=0; |  | 60944 | int rows=0;
| 60993 | PyObject* pyobj_cols = NULL; |  | 60945 | PyObject* pyobj_cols = NULL;
| 60994 | int cols=0; |  | 60946 | int cols=0;
| 60995 | PyObject* pyobj_type = NULL; |  | 60947 | PyObject* pyobj_type = NULL;
| 60996 | int type=0; |  | 60948 | int type=0;
| 60997 | PyObject* pyobj_dslabel = NULL; |  | 60949 | PyObject* pyobj_dslabel = NULL;
| 60998 | String dslabel; |  | 60950 | String dslabel;
| 60999 | PyObject* pyobj_compresslevel = NULL; |  | 60951 | PyObject* pyobj_compresslevel = NULL;
| 61000 | int compresslevel=0; |  | 60952 | int compresslevel=0;
| 61001 | PyObject* pyobj_dims_chunks = NULL; |  | 60953 | PyObject* pyobj_dims_chunks = NULL;
| 61002 | int dims_chunks=0; |  | 60954 | int dims_chunks=0;
| 61003 |  |  | 60955 |
| 61004 | const char* keywords[] = { "rows", "cols", "type", "dslabel", "compresslevel", "dims_chunks", NULL }; |  | 60956 | const char* keywords[] = { "rows", "cols", "type", "dslabel", "compresslevel", "dims_chunks", NULL };
| 61005 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) && |  | 60957 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) &&
| 61006 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 60958 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 61007 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 60959 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 61008 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 60960 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 61009 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 60961 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61010 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) && |  | 60962 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) &&
| 61011 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) ) |  | 60963 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) )
| 61012 | { |  | 60964 | {
| 61013 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel, compresslevel, &dims_chunks)); |  | 60965 | ERRWRAP2(_self_->dscreate(rows, cols, type, dslabel, compresslevel, &dims_chunks));
| 61014 | Py_RETURN_NONE; |  | 60966 | Py_RETURN_NONE;
| 61015 | } |  | 60967 | }
| 61016 |  |  | 60968 |
| 61017 |  |  | 60969 |
| 61018 | pyPopulateArgumentConversionErrors(); |  | 60970 | pyPopulateArgumentConversionErrors();
| 61019 | } |  | 60971 | }
| 61020 |  |  | 60972 |
| 61021 |  |  | 60973 |
| 61022 | { |  | 60974 | {
| 61023 | PyObject* pyobj_n_dims = NULL; |  | 60975 | PyObject* pyobj_n_dims = NULL;
| 61024 | int n_dims=0; |  | 60976 | int n_dims=0;
| 61025 | PyObject* pyobj_sizes = NULL; |  | 60977 | PyObject* pyobj_sizes = NULL;
| 61026 | int sizes=0; |  | 60978 | int sizes=0;
| 61027 | PyObject* pyobj_type = NULL; |  | 60979 | PyObject* pyobj_type = NULL;
| 61028 | int type=0; |  | 60980 | int type=0;
| 61029 | PyObject* pyobj_dslabel = NULL; |  | 60981 | PyObject* pyobj_dslabel = NULL;
| 61030 | String dslabel; |  | 60982 | String dslabel;
| 61031 |  |  | 60983 |
| 61032 | const char* keywords[] = { "n_dims", "sizes", "type", "dslabel", NULL }; |  | 60984 | const char* keywords[] = { "n_dims", "sizes", "type", "dslabel", NULL };
| 61033 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_n_dims, &pyobj_sizes, &pyobj_type, &pyobj_dslabel) && |  | 60985 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_n_dims, &pyobj_sizes, &pyobj_type, &pyobj_dslabel) &&
| 61034 | pyopencv_to_safe(pyobj_n_dims, n_dims, ArgInfo("n_dims", 0)) && |  | 60986 | pyopencv_to_safe(pyobj_n_dims, n_dims, ArgInfo("n_dims", 0)) &&
| 61035 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) && |  | 60987 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) &&
| 61036 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 60988 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 61037 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 60989 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61038 | { |  | 60990 | {
| 61039 | ERRWRAP2(_self_->dscreate(n_dims, &sizes, type, dslabel)); |  | 60991 | ERRWRAP2(_self_->dscreate(n_dims, &sizes, type, dslabel));
| 61040 | Py_RETURN_NONE; |  | 60992 | Py_RETURN_NONE;
| 61041 | } |  | 60993 | }
| 61042 |  |  | 60994 |
| 61043 |  |  | 60995 |
| 61044 | pyPopulateArgumentConversionErrors(); |  | 60996 | pyPopulateArgumentConversionErrors();
| 61045 | } |  | 60997 | }
| 61046 |  |  | 60998 |
| 61047 |  |  | 60999 |
| 61048 | { |  | 61000 | {
| 61049 | PyObject* pyobj_n_dims = NULL; |  | 61001 | PyObject* pyobj_n_dims = NULL;
| 61050 | int n_dims=0; |  | 61002 | int n_dims=0;
| 61051 | PyObject* pyobj_sizes = NULL; |  | 61003 | PyObject* pyobj_sizes = NULL;
| 61052 | int sizes=0; |  | 61004 | int sizes=0;
| 61053 | PyObject* pyobj_type = NULL; |  | 61005 | PyObject* pyobj_type = NULL;
| 61054 | int type=0; |  | 61006 | int type=0;
| 61055 | PyObject* pyobj_dslabel = NULL; |  | 61007 | PyObject* pyobj_dslabel = NULL;
| 61056 | String dslabel; |  | 61008 | String dslabel;
| 61057 | PyObject* pyobj_compresslevel = NULL; |  | 61009 | PyObject* pyobj_compresslevel = NULL;
| 61058 | int compresslevel=0; |  | 61010 | int compresslevel=0;
| 61059 |  |  | 61011 |
| 61060 | const char* keywords[] = { "n_dims", "sizes", "type", "dslabel", "compresslevel", NULL }; |  | 61012 | const char* keywords[] = { "n_dims", "sizes", "type", "dslabel", "compresslevel", NULL };
| 61061 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_n_dims, &pyobj_sizes, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel) && |  | 61013 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_n_dims, &pyobj_sizes, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel) &&
| 61062 | pyopencv_to_safe(pyobj_n_dims, n_dims, ArgInfo("n_dims", 0)) && |  | 61014 | pyopencv_to_safe(pyobj_n_dims, n_dims, ArgInfo("n_dims", 0)) &&
| 61063 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) && |  | 61015 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) &&
| 61064 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 61016 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 61065 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61017 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61066 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) ) |  | 61018 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) )
| 61067 | { |  | 61019 | {
| 61068 | ERRWRAP2(_self_->dscreate(n_dims, &sizes, type, dslabel, compresslevel)); |  | 61020 | ERRWRAP2(_self_->dscreate(n_dims, &sizes, type, dslabel, compresslevel));
| 61069 | Py_RETURN_NONE; |  | 61021 | Py_RETURN_NONE;
| 61070 | } |  | 61022 | }
| 61071 |  |  | 61023 |
| 61072 |  |  | 61024 |
| 61073 | pyPopulateArgumentConversionErrors(); |  | 61025 | pyPopulateArgumentConversionErrors();
| 61074 | } |  | 61026 | }
| 61075 |  |  | 61027 |
| 61076 |  |  | 61028 |
| 61077 | { |  | 61029 | {
| 61078 | PyObject* pyobj_sizes = NULL; |  | 61030 | PyObject* pyobj_sizes = NULL;
| 61079 | vector_int sizes; |  | 61031 | vector_int sizes;
| 61080 | PyObject* pyobj_type = NULL; |  | 61032 | PyObject* pyobj_type = NULL;
| 61081 | int type=0; |  | 61033 | int type=0;
| 61082 | PyObject* pyobj_dslabel = NULL; |  | 61034 | PyObject* pyobj_dslabel = NULL;
| 61083 | String dslabel; |  | 61035 | String dslabel;
| 61084 | PyObject* pyobj_compresslevel = NULL; |  | 61036 | PyObject* pyobj_compresslevel = NULL;
| 61085 | int compresslevel=HDF5::H5_NONE; |  | 61037 | int compresslevel=HDF5::H5_NONE;
| 61086 | PyObject* pyobj_dims_chunks = NULL; |  | 61038 | PyObject* pyobj_dims_chunks = NULL;
| 61087 | vector_int dims_chunks=vector<int>(); |  | 61039 | vector_int dims_chunks=vector<int>();
| 61088 |  |  | 61040 |
| 61089 | const char* keywords[] = { "sizes", "type", "dslabel", "compresslevel", "dims_chunks", NULL }; |  | 61041 | const char* keywords[] = { "sizes", "type", "dslabel", "compresslevel", "dims_chunks", NULL };
| 61090 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_sizes, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) && |  | 61042 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_sizes, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) &&
| 61091 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) && |  | 61043 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) &&
| 61092 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 61044 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 61093 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61045 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61094 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) && |  | 61046 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) &&
| 61095 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) ) |  | 61047 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) )
| 61096 | { |  | 61048 | {
| 61097 | ERRWRAP2(_self_->dscreate(sizes, type, dslabel, compresslevel, dims_chunks)); |  | 61049 | ERRWRAP2(_self_->dscreate(sizes, type, dslabel, compresslevel, dims_chunks));
| 61098 | Py_RETURN_NONE; |  | 61050 | Py_RETURN_NONE;
| 61099 | } |  | 61051 | }
| 61100 |  |  | 61052 |
| 61101 |  |  | 61053 |
| 61102 | pyPopulateArgumentConversionErrors(); |  | 61054 | pyPopulateArgumentConversionErrors();
| 61103 | } |  | 61055 | }
| 61104 |  |  | 61056 |
| 61105 |  |  | 61057 |
| 61106 | { |  | 61058 | {
| 61107 | PyObject* pyobj_n_dims = NULL; |  | 61059 | PyObject* pyobj_n_dims = NULL;
| 61108 | int n_dims=0; |  | 61060 | int n_dims=0;
| 61109 | PyObject* pyobj_sizes = NULL; |  | 61061 | PyObject* pyobj_sizes = NULL;
| 61110 | int sizes=0; |  | 61062 | int sizes=0;
| 61111 | PyObject* pyobj_type = NULL; |  | 61063 | PyObject* pyobj_type = NULL;
| 61112 | int type=0; |  | 61064 | int type=0;
| 61113 | PyObject* pyobj_dslabel = NULL; |  | 61065 | PyObject* pyobj_dslabel = NULL;
| 61114 | String dslabel; |  | 61066 | String dslabel;
| 61115 | PyObject* pyobj_compresslevel = NULL; |  | 61067 | PyObject* pyobj_compresslevel = NULL;
| 61116 | int compresslevel=0; |  | 61068 | int compresslevel=0;
| 61117 | PyObject* pyobj_dims_chunks = NULL; |  | 61069 | PyObject* pyobj_dims_chunks = NULL;
| 61118 | int dims_chunks=0; |  | 61070 | int dims_chunks=0;
| 61119 |  |  | 61071 |
| 61120 | const char* keywords[] = { "n_dims", "sizes", "type", "dslabel", "compresslevel", "dims_chunks", NULL }; |  | 61072 | const char* keywords[] = { "n_dims", "sizes", "type", "dslabel", "compresslevel", "dims_chunks", NULL };
| 61121 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_n_dims, &pyobj_sizes, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) && |  | 61073 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO:hdf_HDF5.dscreate", (char**)keywords, &pyobj_n_dims, &pyobj_sizes, &pyobj_type, &pyobj_dslabel, &pyobj_compresslevel, &pyobj_dims_chunks) &&
| 61122 | pyopencv_to_safe(pyobj_n_dims, n_dims, ArgInfo("n_dims", 0)) && |  | 61074 | pyopencv_to_safe(pyobj_n_dims, n_dims, ArgInfo("n_dims", 0)) &&
| 61123 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) && |  | 61075 | pyopencv_to_safe(pyobj_sizes, sizes, ArgInfo("sizes", 0)) &&
| 61124 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 61076 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 61125 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61077 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61126 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) && |  | 61078 | pyopencv_to_safe(pyobj_compresslevel, compresslevel, ArgInfo("compresslevel", 0)) &&
| 61127 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) ) |  | 61079 | pyopencv_to_safe(pyobj_dims_chunks, dims_chunks, ArgInfo("dims_chunks", 0)) )
| 61128 | { |  | 61080 | {
| 61129 | ERRWRAP2(_self_->dscreate(n_dims, &sizes, type, dslabel, compresslevel, &dims_chunks)); |  | 61081 | ERRWRAP2(_self_->dscreate(n_dims, &sizes, type, dslabel, compresslevel, &dims_chunks));
| 61130 | Py_RETURN_NONE; |  | 61082 | Py_RETURN_NONE;
| 61131 | } |  | 61083 | }
| 61132 |  |  | 61084 |
| 61133 |  |  | 61085 |
| 61134 | pyPopulateArgumentConversionErrors(); |  | 61086 | pyPopulateArgumentConversionErrors();
| 61135 | } |  | 61087 | }
| 61136 | pyRaiseCVOverloadException("dscreate"); |  | 61088 | pyRaiseCVOverloadException("dscreate");
| 61137 |  |  | 61089 |
| 61138 | return NULL; |  | 61090 | return NULL;
| 61139 | } |  | 61091 | }
| 61140 |  |  | 61092 |
| 61141 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsgetsize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61093 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsgetsize(PyObject* self, PyObject* py_args, PyObject* kw)
| 61142 | { |  | 61094 | {
| 61143 | using namespace cv::hdf; |  | 61095 | using namespace cv::hdf;
| 61144 |  |  | 61096 |
| 61145 |  |  | 61097 |
| 61146 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61098 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61147 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61099 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61148 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61100 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61149 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61101 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61150 | PyObject* pyobj_dslabel = NULL; |  | 61102 | PyObject* pyobj_dslabel = NULL;
| 61151 | String dslabel; |  | 61103 | String dslabel;
| 61152 | PyObject* pyobj_dims_flag = NULL; |  | 61104 | PyObject* pyobj_dims_flag = NULL;
| 61153 | int dims_flag=HDF5::H5_GETDIMS; |  | 61105 | int dims_flag=HDF5::H5_GETDIMS;
| 61154 | vector<int> retval; |  | 61106 | vector<int> retval;
| 61155 |  |  | 61107 |
| 61156 | const char* keywords[] = { "dslabel", "dims_flag", NULL }; |  | 61108 | const char* keywords[] = { "dslabel", "dims_flag", NULL };
| 61157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.dsgetsize", (char**)keywords, &pyobj_dslabel, &pyobj_dims_flag) && |  | 61109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.dsgetsize", (char**)keywords, &pyobj_dslabel, &pyobj_dims_flag) &&
| 61158 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61110 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61159 | pyopencv_to_safe(pyobj_dims_flag, dims_flag, ArgInfo("dims_flag", 0)) ) |  | 61111 | pyopencv_to_safe(pyobj_dims_flag, dims_flag, ArgInfo("dims_flag", 0)) )
| 61160 | { |  | 61112 | {
| 61161 | ERRWRAP2(retval = _self_->dsgetsize(dslabel, dims_flag)); |  | 61113 | ERRWRAP2(retval = _self_->dsgetsize(dslabel, dims_flag));
| 61162 | return pyopencv_from(retval); |  | 61114 | return pyopencv_from(retval);
| 61163 | } |  | 61115 | }
| 61164 |  |  | 61116 |
| 61165 | return NULL; |  | 61117 | return NULL;
| 61166 | } |  | 61118 | }
| 61167 |  |  | 61119 |
| 61168 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsgettype(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61120 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsgettype(PyObject* self, PyObject* py_args, PyObject* kw)
| 61169 | { |  | 61121 | {
| 61170 | using namespace cv::hdf; |  | 61122 | using namespace cv::hdf;
| 61171 |  |  | 61123 |
| 61172 |  |  | 61124 |
| 61173 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61125 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61174 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61126 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61175 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61127 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61176 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61128 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61177 | PyObject* pyobj_dslabel = NULL; |  | 61129 | PyObject* pyobj_dslabel = NULL;
| 61178 | String dslabel; |  | 61130 | String dslabel;
| 61179 | int retval; |  | 61131 | int retval;
| 61180 |  |  | 61132 |
| 61181 | const char* keywords[] = { "dslabel", NULL }; |  | 61133 | const char* keywords[] = { "dslabel", NULL };
| 61182 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.dsgettype", (char**)keywords, &pyobj_dslabel) && |  | 61134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.dsgettype", (char**)keywords, &pyobj_dslabel) &&
| 61183 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 61135 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61184 | { |  | 61136 | {
| 61185 | ERRWRAP2(retval = _self_->dsgettype(dslabel)); |  | 61137 | ERRWRAP2(retval = _self_->dsgettype(dslabel));
| 61186 | return pyopencv_from(retval); |  | 61138 | return pyopencv_from(retval);
| 61187 | } |  | 61139 | }
| 61188 |  |  | 61140 |
| 61189 | return NULL; |  | 61141 | return NULL;
| 61190 | } |  | 61142 | }
| 61191 |  |  | 61143 |
| 61192 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsinsert(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61144 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsinsert(PyObject* self, PyObject* py_args, PyObject* kw)
| 61193 | { |  | 61145 | {
| 61194 | using namespace cv::hdf; |  | 61146 | using namespace cv::hdf;
| 61195 |  |  | 61147 |
| 61196 |  |  | 61148 |
| 61197 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61149 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61198 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61150 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61199 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61151 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61200 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61152 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61201 | pyPrepareArgumentConversionErrorsStorage(8); |  | 61153 | pyPrepareArgumentConversionErrorsStorage(8);
| 61202 |  |  | 61154 |
| 61203 | { |  | 61155 | {
| 61204 | PyObject* pyobj_Array = NULL; |  | 61156 | PyObject* pyobj_Array = NULL;
| 61205 | Mat Array; |  | 61157 | Mat Array;
| 61206 | PyObject* pyobj_dslabel = NULL; |  | 61158 | PyObject* pyobj_dslabel = NULL;
| 61207 | String dslabel; |  | 61159 | String dslabel;
| 61208 |  |  | 61160 |
| 61209 | const char* keywords[] = { "Array", "dslabel", NULL }; |  | 61161 | const char* keywords[] = { "Array", "dslabel", NULL };
| 61210 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel) && |  | 61162 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel) &&
| 61211 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61163 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61212 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 61164 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61213 | { |  | 61165 | {
| 61214 | ERRWRAP2(_self_->dsinsert(Array, dslabel)); |  | 61166 | ERRWRAP2(_self_->dsinsert(Array, dslabel));
| 61215 | Py_RETURN_NONE; |  | 61167 | Py_RETURN_NONE;
| 61216 | } |  | 61168 | }
| 61217 |  |  | 61169 |
| 61218 |  |  | 61170 |
| 61219 | pyPopulateArgumentConversionErrors(); |  | 61171 | pyPopulateArgumentConversionErrors();
| 61220 | } |  | 61172 | }
| 61221 |  |  | 61173 |
| 61222 |  |  | 61174 |
| 61223 | { |  | 61175 | {
| 61224 | PyObject* pyobj_Array = NULL; |  | 61176 | PyObject* pyobj_Array = NULL;
| 61225 | Mat Array; |  | 61177 | Mat Array;
| 61226 | PyObject* pyobj_dslabel = NULL; |  | 61178 | PyObject* pyobj_dslabel = NULL;
| 61227 | String dslabel; |  | 61179 | String dslabel;
| 61228 | PyObject* pyobj_dims_offset = NULL; |  | 61180 | PyObject* pyobj_dims_offset = NULL;
| 61229 | int dims_offset=0; |  | 61181 | int dims_offset=0;
| 61230 |  |  | 61182 |
| 61231 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL }; |  | 61183 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL };
| 61232 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) && |  | 61184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) &&
| 61233 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61185 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61234 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61186 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61235 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) ) |  | 61187 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) )
| 61236 | { |  | 61188 | {
| 61237 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset)); |  | 61189 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset));
| 61238 | Py_RETURN_NONE; |  | 61190 | Py_RETURN_NONE;
| 61239 | } |  | 61191 | }
| 61240 |  |  | 61192 |
| 61241 |  |  | 61193 |
| 61242 | pyPopulateArgumentConversionErrors(); |  | 61194 | pyPopulateArgumentConversionErrors();
| 61243 | } |  | 61195 | }
| 61244 |  |  | 61196 |
| 61245 |  |  | 61197 |
| 61246 | { |  | 61198 | {
| 61247 | PyObject* pyobj_Array = NULL; |  | 61199 | PyObject* pyobj_Array = NULL;
| 61248 | Mat Array; |  | 61200 | Mat Array;
| 61249 | PyObject* pyobj_dslabel = NULL; |  | 61201 | PyObject* pyobj_dslabel = NULL;
| 61250 | String dslabel; |  | 61202 | String dslabel;
| 61251 | PyObject* pyobj_dims_offset = NULL; |  | 61203 | PyObject* pyobj_dims_offset = NULL;
| 61252 | vector_int dims_offset; |  | 61204 | vector_int dims_offset;
| 61253 | PyObject* pyobj_dims_counts = NULL; |  | 61205 | PyObject* pyobj_dims_counts = NULL;
| 61254 | vector_int dims_counts=vector<int>(); |  | 61206 | vector_int dims_counts=vector<int>();
| 61255 |  |  | 61207 |
| 61256 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61208 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61257 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61209 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61258 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61210 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61259 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61211 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61260 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61212 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61261 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61213 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61262 | { |  | 61214 | {
| 61263 | ERRWRAP2(_self_->dsinsert(Array, dslabel, dims_offset, dims_counts)); |  | 61215 | ERRWRAP2(_self_->dsinsert(Array, dslabel, dims_offset, dims_counts));
| 61264 | Py_RETURN_NONE; |  | 61216 | Py_RETURN_NONE;
| 61265 | } |  | 61217 | }
| 61266 |  |  | 61218 |
| 61267 |  |  | 61219 |
| 61268 | pyPopulateArgumentConversionErrors(); |  | 61220 | pyPopulateArgumentConversionErrors();
| 61269 | } |  | 61221 | }
| 61270 |  |  | 61222 |
| 61271 |  |  | 61223 |
| 61272 | { |  | 61224 | {
| 61273 | PyObject* pyobj_Array = NULL; |  | 61225 | PyObject* pyobj_Array = NULL;
| 61274 | Mat Array; |  | 61226 | Mat Array;
| 61275 | PyObject* pyobj_dslabel = NULL; |  | 61227 | PyObject* pyobj_dslabel = NULL;
| 61276 | String dslabel; |  | 61228 | String dslabel;
| 61277 | PyObject* pyobj_dims_offset = NULL; |  | 61229 | PyObject* pyobj_dims_offset = NULL;
| 61278 | int dims_offset=0; |  | 61230 | int dims_offset=0;
| 61279 | PyObject* pyobj_dims_counts = NULL; |  | 61231 | PyObject* pyobj_dims_counts = NULL;
| 61280 | int dims_counts=0; |  | 61232 | int dims_counts=0;
| 61281 |  |  | 61233 |
| 61282 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61234 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61283 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61235 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61284 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61236 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61285 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61237 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61286 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61238 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61287 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61239 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61288 | { |  | 61240 | {
| 61289 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset, &dims_counts)); |  | 61241 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset, &dims_counts));
| 61290 | Py_RETURN_NONE; |  | 61242 | Py_RETURN_NONE;
| 61291 | } |  | 61243 | }
| 61292 |  |  | 61244 |
| 61293 |  |  | 61245 |
| 61294 | pyPopulateArgumentConversionErrors(); |  | 61246 | pyPopulateArgumentConversionErrors();
| 61295 | } |  | 61247 | }
| 61296 |  |  | 61248 |
| 61297 |  |  | 61249 |
| 61298 | { |  | 61250 | {
| 61299 | PyObject* pyobj_Array = NULL; |  | 61251 | PyObject* pyobj_Array = NULL;
| 61300 | UMat Array; |  | 61252 | UMat Array;
| 61301 | PyObject* pyobj_dslabel = NULL; |  | 61253 | PyObject* pyobj_dslabel = NULL;
| 61302 | String dslabel; |  | 61254 | String dslabel;
| 61303 |  |  | 61255 |
| 61304 | const char* keywords[] = { "Array", "dslabel", NULL }; |  | 61256 | const char* keywords[] = { "Array", "dslabel", NULL };
| 61305 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel) && |  | 61257 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel) &&
| 61306 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61258 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61307 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 61259 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61308 | { |  | 61260 | {
| 61309 | ERRWRAP2(_self_->dsinsert(Array, dslabel)); |  | 61261 | ERRWRAP2(_self_->dsinsert(Array, dslabel));
| 61310 | Py_RETURN_NONE; |  | 61262 | Py_RETURN_NONE;
| 61311 | } |  | 61263 | }
| 61312 |  |  | 61264 |
| 61313 |  |  | 61265 |
| 61314 | pyPopulateArgumentConversionErrors(); |  | 61266 | pyPopulateArgumentConversionErrors();
| 61315 | } |  | 61267 | }
| 61316 |  |  | 61268 |
| 61317 |  |  | 61269 |
| 61318 | { |  | 61270 | {
| 61319 | PyObject* pyobj_Array = NULL; |  | 61271 | PyObject* pyobj_Array = NULL;
| 61320 | UMat Array; |  | 61272 | UMat Array;
| 61321 | PyObject* pyobj_dslabel = NULL; |  | 61273 | PyObject* pyobj_dslabel = NULL;
| 61322 | String dslabel; |  | 61274 | String dslabel;
| 61323 | PyObject* pyobj_dims_offset = NULL; |  | 61275 | PyObject* pyobj_dims_offset = NULL;
| 61324 | int dims_offset=0; |  | 61276 | int dims_offset=0;
| 61325 |  |  | 61277 |
| 61326 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL }; |  | 61278 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL };
| 61327 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) && |  | 61279 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) &&
| 61328 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61280 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61329 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61281 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61330 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) ) |  | 61282 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) )
| 61331 | { |  | 61283 | {
| 61332 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset)); |  | 61284 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset));
| 61333 | Py_RETURN_NONE; |  | 61285 | Py_RETURN_NONE;
| 61334 | } |  | 61286 | }
| 61335 |  |  | 61287 |
| 61336 |  |  | 61288 |
| 61337 | pyPopulateArgumentConversionErrors(); |  | 61289 | pyPopulateArgumentConversionErrors();
| 61338 | } |  | 61290 | }
| 61339 |  |  | 61291 |
| 61340 |  |  | 61292 |
| 61341 | { |  | 61293 | {
| 61342 | PyObject* pyobj_Array = NULL; |  | 61294 | PyObject* pyobj_Array = NULL;
| 61343 | UMat Array; |  | 61295 | UMat Array;
| 61344 | PyObject* pyobj_dslabel = NULL; |  | 61296 | PyObject* pyobj_dslabel = NULL;
| 61345 | String dslabel; |  | 61297 | String dslabel;
| 61346 | PyObject* pyobj_dims_offset = NULL; |  | 61298 | PyObject* pyobj_dims_offset = NULL;
| 61347 | vector_int dims_offset; |  | 61299 | vector_int dims_offset;
| 61348 | PyObject* pyobj_dims_counts = NULL; |  | 61300 | PyObject* pyobj_dims_counts = NULL;
| 61349 | vector_int dims_counts=vector<int>(); |  | 61301 | vector_int dims_counts=vector<int>();
| 61350 |  |  | 61302 |
| 61351 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61303 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61352 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61304 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61353 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61305 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61354 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61306 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61355 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61307 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61356 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61308 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61357 | { |  | 61309 | {
| 61358 | ERRWRAP2(_self_->dsinsert(Array, dslabel, dims_offset, dims_counts)); |  | 61310 | ERRWRAP2(_self_->dsinsert(Array, dslabel, dims_offset, dims_counts));
| 61359 | Py_RETURN_NONE; |  | 61311 | Py_RETURN_NONE;
| 61360 | } |  | 61312 | }
| 61361 |  |  | 61313 |
| 61362 |  |  | 61314 |
| 61363 | pyPopulateArgumentConversionErrors(); |  | 61315 | pyPopulateArgumentConversionErrors();
| 61364 | } |  | 61316 | }
| 61365 |  |  | 61317 |
| 61366 |  |  | 61318 |
| 61367 | { |  | 61319 | {
| 61368 | PyObject* pyobj_Array = NULL; |  | 61320 | PyObject* pyobj_Array = NULL;
| 61369 | UMat Array; |  | 61321 | UMat Array;
| 61370 | PyObject* pyobj_dslabel = NULL; |  | 61322 | PyObject* pyobj_dslabel = NULL;
| 61371 | String dslabel; |  | 61323 | String dslabel;
| 61372 | PyObject* pyobj_dims_offset = NULL; |  | 61324 | PyObject* pyobj_dims_offset = NULL;
| 61373 | int dims_offset=0; |  | 61325 | int dims_offset=0;
| 61374 | PyObject* pyobj_dims_counts = NULL; |  | 61326 | PyObject* pyobj_dims_counts = NULL;
| 61375 | int dims_counts=0; |  | 61327 | int dims_counts=0;
| 61376 |  |  | 61328 |
| 61377 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61329 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61378 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61330 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dsinsert", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61379 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61331 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61380 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61332 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61381 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61333 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61382 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61334 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61383 | { |  | 61335 | {
| 61384 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset, &dims_counts)); |  | 61336 | ERRWRAP2(_self_->dsinsert(Array, dslabel, &dims_offset, &dims_counts));
| 61385 | Py_RETURN_NONE; |  | 61337 | Py_RETURN_NONE;
| 61386 | } |  | 61338 | }
| 61387 |  |  | 61339 |
| 61388 |  |  | 61340 |
| 61389 | pyPopulateArgumentConversionErrors(); |  | 61341 | pyPopulateArgumentConversionErrors();
| 61390 | } |  | 61342 | }
| 61391 | pyRaiseCVOverloadException("dsinsert"); |  | 61343 | pyRaiseCVOverloadException("dsinsert");
| 61392 |  |  | 61344 |
| 61393 | return NULL; |  | 61345 | return NULL;
| 61394 | } |  | 61346 | }
| 61395 |  |  | 61347 |
| 61396 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsread(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61348 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dsread(PyObject* self, PyObject* py_args, PyObject* kw)
| 61397 | { |  | 61349 | {
| 61398 | using namespace cv::hdf; |  | 61350 | using namespace cv::hdf;
| 61399 |  |  | 61351 |
| 61400 |  |  | 61352 |
| 61401 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61353 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61402 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61354 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61403 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61355 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61404 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61356 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61405 | pyPrepareArgumentConversionErrorsStorage(8); |  | 61357 | pyPrepareArgumentConversionErrorsStorage(8);
| 61406 |  |  | 61358 |
| 61407 | { |  | 61359 | {
| 61408 | PyObject* pyobj_Array = NULL; |  | 61360 | PyObject* pyobj_Array = NULL;
| 61409 | Mat Array; |  | 61361 | Mat Array;
| 61410 | PyObject* pyobj_dslabel = NULL; |  | 61362 | PyObject* pyobj_dslabel = NULL;
| 61411 | String dslabel; |  | 61363 | String dslabel;
| 61412 |  |  | 61364 |
| 61413 | const char* keywords[] = { "dslabel", "Array", NULL }; |  | 61365 | const char* keywords[] = { "dslabel", "Array", NULL };
| 61414 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_Array) && |  | 61366 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_Array) &&
| 61415 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61367 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61416 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 61368 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61417 | { |  | 61369 | {
| 61418 | ERRWRAP2(_self_->dsread(Array, dslabel)); |  | 61370 | ERRWRAP2(_self_->dsread(Array, dslabel));
| 61419 | return pyopencv_from(Array); |  | 61371 | return pyopencv_from(Array);
| 61420 | } |  | 61372 | }
| 61421 |  |  | 61373 |
| 61422 |  |  | 61374 |
| 61423 | pyPopulateArgumentConversionErrors(); |  | 61375 | pyPopulateArgumentConversionErrors();
| 61424 | } |  | 61376 | }
| 61425 |  |  | 61377 |
| 61426 |  |  | 61378 |
| 61427 | { |  | 61379 | {
| 61428 | PyObject* pyobj_Array = NULL; |  | 61380 | PyObject* pyobj_Array = NULL;
| 61429 | Mat Array; |  | 61381 | Mat Array;
| 61430 | PyObject* pyobj_dslabel = NULL; |  | 61382 | PyObject* pyobj_dslabel = NULL;
| 61431 | String dslabel; |  | 61383 | String dslabel;
| 61432 | PyObject* pyobj_dims_offset = NULL; |  | 61384 | PyObject* pyobj_dims_offset = NULL;
| 61433 | int dims_offset=0; |  | 61385 | int dims_offset=0;
| 61434 |  |  | 61386 |
| 61435 | const char* keywords[] = { "dslabel", "dims_offset", "Array", NULL }; |  | 61387 | const char* keywords[] = { "dslabel", "dims_offset", "Array", NULL };
| 61436 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array) && |  | 61388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array) &&
| 61437 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61389 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61438 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61390 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61439 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) ) |  | 61391 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) )
| 61440 | { |  | 61392 | {
| 61441 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset)); |  | 61393 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset));
| 61442 | return pyopencv_from(Array); |  | 61394 | return pyopencv_from(Array);
| 61443 | } |  | 61395 | }
| 61444 |  |  | 61396 |
| 61445 |  |  | 61397 |
| 61446 | pyPopulateArgumentConversionErrors(); |  | 61398 | pyPopulateArgumentConversionErrors();
| 61447 | } |  | 61399 | }
| 61448 |  |  | 61400 |
| 61449 |  |  | 61401 |
| 61450 | { |  | 61402 | {
| 61451 | PyObject* pyobj_Array = NULL; |  | 61403 | PyObject* pyobj_Array = NULL;
| 61452 | Mat Array; |  | 61404 | Mat Array;
| 61453 | PyObject* pyobj_dslabel = NULL; |  | 61405 | PyObject* pyobj_dslabel = NULL;
| 61454 | String dslabel; |  | 61406 | String dslabel;
| 61455 | PyObject* pyobj_dims_offset = NULL; |  | 61407 | PyObject* pyobj_dims_offset = NULL;
| 61456 | vector_int dims_offset; |  | 61408 | vector_int dims_offset;
| 61457 | PyObject* pyobj_dims_counts = NULL; |  | 61409 | PyObject* pyobj_dims_counts = NULL;
| 61458 | vector_int dims_counts=vector<int>(); |  | 61410 | vector_int dims_counts=vector<int>();
| 61459 |  |  | 61411 |
| 61460 | const char* keywords[] = { "dslabel", "dims_offset", "Array", "dims_counts", NULL }; |  | 61412 | const char* keywords[] = { "dslabel", "dims_offset", "Array", "dims_counts", NULL };
| 61461 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array, &pyobj_dims_counts) && |  | 61413 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array, &pyobj_dims_counts) &&
| 61462 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61414 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61463 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61415 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61464 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61416 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61465 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61417 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61466 | { |  | 61418 | {
| 61467 | ERRWRAP2(_self_->dsread(Array, dslabel, dims_offset, dims_counts)); |  | 61419 | ERRWRAP2(_self_->dsread(Array, dslabel, dims_offset, dims_counts));
| 61468 | return pyopencv_from(Array); |  | 61420 | return pyopencv_from(Array);
| 61469 | } |  | 61421 | }
| 61470 |  |  | 61422 |
| 61471 |  |  | 61423 |
| 61472 | pyPopulateArgumentConversionErrors(); |  | 61424 | pyPopulateArgumentConversionErrors();
| 61473 | } |  | 61425 | }
| 61474 |  |  | 61426 |
| 61475 |  |  | 61427 |
| 61476 | { |  | 61428 | {
| 61477 | PyObject* pyobj_Array = NULL; |  | 61429 | PyObject* pyobj_Array = NULL;
| 61478 | Mat Array; |  | 61430 | Mat Array;
| 61479 | PyObject* pyobj_dslabel = NULL; |  | 61431 | PyObject* pyobj_dslabel = NULL;
| 61480 | String dslabel; |  | 61432 | String dslabel;
| 61481 | PyObject* pyobj_dims_offset = NULL; |  | 61433 | PyObject* pyobj_dims_offset = NULL;
| 61482 | int dims_offset=0; |  | 61434 | int dims_offset=0;
| 61483 | PyObject* pyobj_dims_counts = NULL; |  | 61435 | PyObject* pyobj_dims_counts = NULL;
| 61484 | int dims_counts=0; |  | 61436 | int dims_counts=0;
| 61485 |  |  | 61437 |
| 61486 | const char* keywords[] = { "dslabel", "dims_offset", "dims_counts", "Array", NULL }; |  | 61438 | const char* keywords[] = { "dslabel", "dims_offset", "dims_counts", "Array", NULL };
| 61487 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts, &pyobj_Array) && |  | 61439 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts, &pyobj_Array) &&
| 61488 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61440 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61489 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61441 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61490 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61442 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61491 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61443 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61492 | { |  | 61444 | {
| 61493 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset, &dims_counts)); |  | 61445 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset, &dims_counts));
| 61494 | return pyopencv_from(Array); |  | 61446 | return pyopencv_from(Array);
| 61495 | } |  | 61447 | }
| 61496 |  |  | 61448 |
| 61497 |  |  | 61449 |
| 61498 | pyPopulateArgumentConversionErrors(); |  | 61450 | pyPopulateArgumentConversionErrors();
| 61499 | } |  | 61451 | }
| 61500 |  |  | 61452 |
| 61501 |  |  | 61453 |
| 61502 | { |  | 61454 | {
| 61503 | PyObject* pyobj_Array = NULL; |  | 61455 | PyObject* pyobj_Array = NULL;
| 61504 | UMat Array; |  | 61456 | UMat Array;
| 61505 | PyObject* pyobj_dslabel = NULL; |  | 61457 | PyObject* pyobj_dslabel = NULL;
| 61506 | String dslabel; |  | 61458 | String dslabel;
| 61507 |  |  | 61459 |
| 61508 | const char* keywords[] = { "dslabel", "Array", NULL }; |  | 61460 | const char* keywords[] = { "dslabel", "Array", NULL };
| 61509 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_Array) && |  | 61461 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_Array) &&
| 61510 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61462 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61511 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 61463 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61512 | { |  | 61464 | {
| 61513 | ERRWRAP2(_self_->dsread(Array, dslabel)); |  | 61465 | ERRWRAP2(_self_->dsread(Array, dslabel));
| 61514 | return pyopencv_from(Array); |  | 61466 | return pyopencv_from(Array);
| 61515 | } |  | 61467 | }
| 61516 |  |  | 61468 |
| 61517 |  |  | 61469 |
| 61518 | pyPopulateArgumentConversionErrors(); |  | 61470 | pyPopulateArgumentConversionErrors();
| 61519 | } |  | 61471 | }
| 61520 |  |  | 61472 |
| 61521 |  |  | 61473 |
| 61522 | { |  | 61474 | {
| 61523 | PyObject* pyobj_Array = NULL; |  | 61475 | PyObject* pyobj_Array = NULL;
| 61524 | UMat Array; |  | 61476 | UMat Array;
| 61525 | PyObject* pyobj_dslabel = NULL; |  | 61477 | PyObject* pyobj_dslabel = NULL;
| 61526 | String dslabel; |  | 61478 | String dslabel;
| 61527 | PyObject* pyobj_dims_offset = NULL; |  | 61479 | PyObject* pyobj_dims_offset = NULL;
| 61528 | int dims_offset=0; |  | 61480 | int dims_offset=0;
| 61529 |  |  | 61481 |
| 61530 | const char* keywords[] = { "dslabel", "dims_offset", "Array", NULL }; |  | 61482 | const char* keywords[] = { "dslabel", "dims_offset", "Array", NULL };
| 61531 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array) && |  | 61483 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array) &&
| 61532 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61484 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61533 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61485 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61534 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) ) |  | 61486 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) )
| 61535 | { |  | 61487 | {
| 61536 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset)); |  | 61488 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset));
| 61537 | return pyopencv_from(Array); |  | 61489 | return pyopencv_from(Array);
| 61538 | } |  | 61490 | }
| 61539 |  |  | 61491 |
| 61540 |  |  | 61492 |
| 61541 | pyPopulateArgumentConversionErrors(); |  | 61493 | pyPopulateArgumentConversionErrors();
| 61542 | } |  | 61494 | }
| 61543 |  |  | 61495 |
| 61544 |  |  | 61496 |
| 61545 | { |  | 61497 | {
| 61546 | PyObject* pyobj_Array = NULL; |  | 61498 | PyObject* pyobj_Array = NULL;
| 61547 | UMat Array; |  | 61499 | UMat Array;
| 61548 | PyObject* pyobj_dslabel = NULL; |  | 61500 | PyObject* pyobj_dslabel = NULL;
| 61549 | String dslabel; |  | 61501 | String dslabel;
| 61550 | PyObject* pyobj_dims_offset = NULL; |  | 61502 | PyObject* pyobj_dims_offset = NULL;
| 61551 | vector_int dims_offset; |  | 61503 | vector_int dims_offset;
| 61552 | PyObject* pyobj_dims_counts = NULL; |  | 61504 | PyObject* pyobj_dims_counts = NULL;
| 61553 | vector_int dims_counts=vector<int>(); |  | 61505 | vector_int dims_counts=vector<int>();
| 61554 |  |  | 61506 |
| 61555 | const char* keywords[] = { "dslabel", "dims_offset", "Array", "dims_counts", NULL }; |  | 61507 | const char* keywords[] = { "dslabel", "dims_offset", "Array", "dims_counts", NULL };
| 61556 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array, &pyobj_dims_counts) && |  | 61508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_Array, &pyobj_dims_counts) &&
| 61557 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61509 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61558 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61510 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61559 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61511 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61560 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61512 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61561 | { |  | 61513 | {
| 61562 | ERRWRAP2(_self_->dsread(Array, dslabel, dims_offset, dims_counts)); |  | 61514 | ERRWRAP2(_self_->dsread(Array, dslabel, dims_offset, dims_counts));
| 61563 | return pyopencv_from(Array); |  | 61515 | return pyopencv_from(Array);
| 61564 | } |  | 61516 | }
| 61565 |  |  | 61517 |
| 61566 |  |  | 61518 |
| 61567 | pyPopulateArgumentConversionErrors(); |  | 61519 | pyPopulateArgumentConversionErrors();
| 61568 | } |  | 61520 | }
| 61569 |  |  | 61521 |
| 61570 |  |  | 61522 |
| 61571 | { |  | 61523 | {
| 61572 | PyObject* pyobj_Array = NULL; |  | 61524 | PyObject* pyobj_Array = NULL;
| 61573 | UMat Array; |  | 61525 | UMat Array;
| 61574 | PyObject* pyobj_dslabel = NULL; |  | 61526 | PyObject* pyobj_dslabel = NULL;
| 61575 | String dslabel; |  | 61527 | String dslabel;
| 61576 | PyObject* pyobj_dims_offset = NULL; |  | 61528 | PyObject* pyobj_dims_offset = NULL;
| 61577 | int dims_offset=0; |  | 61529 | int dims_offset=0;
| 61578 | PyObject* pyobj_dims_counts = NULL; |  | 61530 | PyObject* pyobj_dims_counts = NULL;
| 61579 | int dims_counts=0; |  | 61531 | int dims_counts=0;
| 61580 |  |  | 61532 |
| 61581 | const char* keywords[] = { "dslabel", "dims_offset", "dims_counts", "Array", NULL }; |  | 61533 | const char* keywords[] = { "dslabel", "dims_offset", "dims_counts", "Array", NULL };
| 61582 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts, &pyobj_Array) && |  | 61534 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dsread", (char**)keywords, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts, &pyobj_Array) &&
| 61583 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) && |  | 61535 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 1)) &&
| 61584 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61536 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61585 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61537 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61586 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61538 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61587 | { |  | 61539 | {
| 61588 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset, &dims_counts)); |  | 61540 | ERRWRAP2(_self_->dsread(Array, dslabel, &dims_offset, &dims_counts));
| 61589 | return pyopencv_from(Array); |  | 61541 | return pyopencv_from(Array);
| 61590 | } |  | 61542 | }
| 61591 |  |  | 61543 |
| 61592 |  |  | 61544 |
| 61593 | pyPopulateArgumentConversionErrors(); |  | 61545 | pyPopulateArgumentConversionErrors();
| 61594 | } |  | 61546 | }
| 61595 | pyRaiseCVOverloadException("dsread"); |  | 61547 | pyRaiseCVOverloadException("dsread");
| 61596 |  |  | 61548 |
| 61597 | return NULL; |  | 61549 | return NULL;
| 61598 | } |  | 61550 | }
| 61599 |  |  | 61551 |
| 61600 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dswrite(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61552 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_dswrite(PyObject* self, PyObject* py_args, PyObject* kw)
| 61601 | { |  | 61553 | {
| 61602 | using namespace cv::hdf; |  | 61554 | using namespace cv::hdf;
| 61603 |  |  | 61555 |
| 61604 |  |  | 61556 |
| 61605 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61557 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61606 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61558 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61607 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61559 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61608 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61560 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61609 | pyPrepareArgumentConversionErrorsStorage(8); |  | 61561 | pyPrepareArgumentConversionErrorsStorage(8);
| 61610 |  |  | 61562 |
| 61611 | { |  | 61563 | {
| 61612 | PyObject* pyobj_Array = NULL; |  | 61564 | PyObject* pyobj_Array = NULL;
| 61613 | Mat Array; |  | 61565 | Mat Array;
| 61614 | PyObject* pyobj_dslabel = NULL; |  | 61566 | PyObject* pyobj_dslabel = NULL;
| 61615 | String dslabel; |  | 61567 | String dslabel;
| 61616 |  |  | 61568 |
| 61617 | const char* keywords[] = { "Array", "dslabel", NULL }; |  | 61569 | const char* keywords[] = { "Array", "dslabel", NULL };
| 61618 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel) && |  | 61570 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel) &&
| 61619 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61571 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61620 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 61572 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61621 | { |  | 61573 | {
| 61622 | ERRWRAP2(_self_->dswrite(Array, dslabel)); |  | 61574 | ERRWRAP2(_self_->dswrite(Array, dslabel));
| 61623 | Py_RETURN_NONE; |  | 61575 | Py_RETURN_NONE;
| 61624 | } |  | 61576 | }
| 61625 |  |  | 61577 |
| 61626 |  |  | 61578 |
| 61627 | pyPopulateArgumentConversionErrors(); |  | 61579 | pyPopulateArgumentConversionErrors();
| 61628 | } |  | 61580 | }
| 61629 |  |  | 61581 |
| 61630 |  |  | 61582 |
| 61631 | { |  | 61583 | {
| 61632 | PyObject* pyobj_Array = NULL; |  | 61584 | PyObject* pyobj_Array = NULL;
| 61633 | Mat Array; |  | 61585 | Mat Array;
| 61634 | PyObject* pyobj_dslabel = NULL; |  | 61586 | PyObject* pyobj_dslabel = NULL;
| 61635 | String dslabel; |  | 61587 | String dslabel;
| 61636 | PyObject* pyobj_dims_offset = NULL; |  | 61588 | PyObject* pyobj_dims_offset = NULL;
| 61637 | int dims_offset=0; |  | 61589 | int dims_offset=0;
| 61638 |  |  | 61590 |
| 61639 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL }; |  | 61591 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL };
| 61640 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) && |  | 61592 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) &&
| 61641 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61593 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61642 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61594 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61643 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) ) |  | 61595 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) )
| 61644 | { |  | 61596 | {
| 61645 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset)); |  | 61597 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset));
| 61646 | Py_RETURN_NONE; |  | 61598 | Py_RETURN_NONE;
| 61647 | } |  | 61599 | }
| 61648 |  |  | 61600 |
| 61649 |  |  | 61601 |
| 61650 | pyPopulateArgumentConversionErrors(); |  | 61602 | pyPopulateArgumentConversionErrors();
| 61651 | } |  | 61603 | }
| 61652 |  |  | 61604 |
| 61653 |  |  | 61605 |
| 61654 | { |  | 61606 | {
| 61655 | PyObject* pyobj_Array = NULL; |  | 61607 | PyObject* pyobj_Array = NULL;
| 61656 | Mat Array; |  | 61608 | Mat Array;
| 61657 | PyObject* pyobj_dslabel = NULL; |  | 61609 | PyObject* pyobj_dslabel = NULL;
| 61658 | String dslabel; |  | 61610 | String dslabel;
| 61659 | PyObject* pyobj_dims_offset = NULL; |  | 61611 | PyObject* pyobj_dims_offset = NULL;
| 61660 | vector_int dims_offset; |  | 61612 | vector_int dims_offset;
| 61661 | PyObject* pyobj_dims_counts = NULL; |  | 61613 | PyObject* pyobj_dims_counts = NULL;
| 61662 | vector_int dims_counts=vector<int>(); |  | 61614 | vector_int dims_counts=vector<int>();
| 61663 |  |  | 61615 |
| 61664 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61616 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61665 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61617 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61666 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61618 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61667 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61619 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61668 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61620 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61669 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61621 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61670 | { |  | 61622 | {
| 61671 | ERRWRAP2(_self_->dswrite(Array, dslabel, dims_offset, dims_counts)); |  | 61623 | ERRWRAP2(_self_->dswrite(Array, dslabel, dims_offset, dims_counts));
| 61672 | Py_RETURN_NONE; |  | 61624 | Py_RETURN_NONE;
| 61673 | } |  | 61625 | }
| 61674 |  |  | 61626 |
| 61675 |  |  | 61627 |
| 61676 | pyPopulateArgumentConversionErrors(); |  | 61628 | pyPopulateArgumentConversionErrors();
| 61677 | } |  | 61629 | }
| 61678 |  |  | 61630 |
| 61679 |  |  | 61631 |
| 61680 | { |  | 61632 | {
| 61681 | PyObject* pyobj_Array = NULL; |  | 61633 | PyObject* pyobj_Array = NULL;
| 61682 | Mat Array; |  | 61634 | Mat Array;
| 61683 | PyObject* pyobj_dslabel = NULL; |  | 61635 | PyObject* pyobj_dslabel = NULL;
| 61684 | String dslabel; |  | 61636 | String dslabel;
| 61685 | PyObject* pyobj_dims_offset = NULL; |  | 61637 | PyObject* pyobj_dims_offset = NULL;
| 61686 | int dims_offset=0; |  | 61638 | int dims_offset=0;
| 61687 | PyObject* pyobj_dims_counts = NULL; |  | 61639 | PyObject* pyobj_dims_counts = NULL;
| 61688 | int dims_counts=0; |  | 61640 | int dims_counts=0;
| 61689 |  |  | 61641 |
| 61690 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61642 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61691 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61643 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61692 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61644 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61693 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61645 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61694 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61646 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61695 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61647 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61696 | { |  | 61648 | {
| 61697 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset, &dims_counts)); |  | 61649 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset, &dims_counts));
| 61698 | Py_RETURN_NONE; |  | 61650 | Py_RETURN_NONE;
| 61699 | } |  | 61651 | }
| 61700 |  |  | 61652 |
| 61701 |  |  | 61653 |
| 61702 | pyPopulateArgumentConversionErrors(); |  | 61654 | pyPopulateArgumentConversionErrors();
| 61703 | } |  | 61655 | }
| 61704 |  |  | 61656 |
| 61705 |  |  | 61657 |
| 61706 | { |  | 61658 | {
| 61707 | PyObject* pyobj_Array = NULL; |  | 61659 | PyObject* pyobj_Array = NULL;
| 61708 | UMat Array; |  | 61660 | UMat Array;
| 61709 | PyObject* pyobj_dslabel = NULL; |  | 61661 | PyObject* pyobj_dslabel = NULL;
| 61710 | String dslabel; |  | 61662 | String dslabel;
| 61711 |  |  | 61663 |
| 61712 | const char* keywords[] = { "Array", "dslabel", NULL }; |  | 61664 | const char* keywords[] = { "Array", "dslabel", NULL };
| 61713 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel) && |  | 61665 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel) &&
| 61714 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61666 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61715 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) ) |  | 61667 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) )
| 61716 | { |  | 61668 | {
| 61717 | ERRWRAP2(_self_->dswrite(Array, dslabel)); |  | 61669 | ERRWRAP2(_self_->dswrite(Array, dslabel));
| 61718 | Py_RETURN_NONE; |  | 61670 | Py_RETURN_NONE;
| 61719 | } |  | 61671 | }
| 61720 |  |  | 61672 |
| 61721 |  |  | 61673 |
| 61722 | pyPopulateArgumentConversionErrors(); |  | 61674 | pyPopulateArgumentConversionErrors();
| 61723 | } |  | 61675 | }
| 61724 |  |  | 61676 |
| 61725 |  |  | 61677 |
| 61726 | { |  | 61678 | {
| 61727 | PyObject* pyobj_Array = NULL; |  | 61679 | PyObject* pyobj_Array = NULL;
| 61728 | UMat Array; |  | 61680 | UMat Array;
| 61729 | PyObject* pyobj_dslabel = NULL; |  | 61681 | PyObject* pyobj_dslabel = NULL;
| 61730 | String dslabel; |  | 61682 | String dslabel;
| 61731 | PyObject* pyobj_dims_offset = NULL; |  | 61683 | PyObject* pyobj_dims_offset = NULL;
| 61732 | int dims_offset=0; |  | 61684 | int dims_offset=0;
| 61733 |  |  | 61685 |
| 61734 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL }; |  | 61686 | const char* keywords[] = { "Array", "dslabel", "dims_offset", NULL };
| 61735 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) && |  | 61687 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset) &&
| 61736 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61688 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61737 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61689 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61738 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) ) |  | 61690 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) )
| 61739 | { |  | 61691 | {
| 61740 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset)); |  | 61692 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset));
| 61741 | Py_RETURN_NONE; |  | 61693 | Py_RETURN_NONE;
| 61742 | } |  | 61694 | }
| 61743 |  |  | 61695 |
| 61744 |  |  | 61696 |
| 61745 | pyPopulateArgumentConversionErrors(); |  | 61697 | pyPopulateArgumentConversionErrors();
| 61746 | } |  | 61698 | }
| 61747 |  |  | 61699 |
| 61748 |  |  | 61700 |
| 61749 | { |  | 61701 | {
| 61750 | PyObject* pyobj_Array = NULL; |  | 61702 | PyObject* pyobj_Array = NULL;
| 61751 | UMat Array; |  | 61703 | UMat Array;
| 61752 | PyObject* pyobj_dslabel = NULL; |  | 61704 | PyObject* pyobj_dslabel = NULL;
| 61753 | String dslabel; |  | 61705 | String dslabel;
| 61754 | PyObject* pyobj_dims_offset = NULL; |  | 61706 | PyObject* pyobj_dims_offset = NULL;
| 61755 | vector_int dims_offset; |  | 61707 | vector_int dims_offset;
| 61756 | PyObject* pyobj_dims_counts = NULL; |  | 61708 | PyObject* pyobj_dims_counts = NULL;
| 61757 | vector_int dims_counts=vector<int>(); |  | 61709 | vector_int dims_counts=vector<int>();
| 61758 |  |  | 61710 |
| 61759 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61711 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61760 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61712 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61761 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61713 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61762 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61714 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61763 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61715 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61764 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61716 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61765 | { |  | 61717 | {
| 61766 | ERRWRAP2(_self_->dswrite(Array, dslabel, dims_offset, dims_counts)); |  | 61718 | ERRWRAP2(_self_->dswrite(Array, dslabel, dims_offset, dims_counts));
| 61767 | Py_RETURN_NONE; |  | 61719 | Py_RETURN_NONE;
| 61768 | } |  | 61720 | }
| 61769 |  |  | 61721 |
| 61770 |  |  | 61722 |
| 61771 | pyPopulateArgumentConversionErrors(); |  | 61723 | pyPopulateArgumentConversionErrors();
| 61772 | } |  | 61724 | }
| 61773 |  |  | 61725 |
| 61774 |  |  | 61726 |
| 61775 | { |  | 61727 | {
| 61776 | PyObject* pyobj_Array = NULL; |  | 61728 | PyObject* pyobj_Array = NULL;
| 61777 | UMat Array; |  | 61729 | UMat Array;
| 61778 | PyObject* pyobj_dslabel = NULL; |  | 61730 | PyObject* pyobj_dslabel = NULL;
| 61779 | String dslabel; |  | 61731 | String dslabel;
| 61780 | PyObject* pyobj_dims_offset = NULL; |  | 61732 | PyObject* pyobj_dims_offset = NULL;
| 61781 | int dims_offset=0; |  | 61733 | int dims_offset=0;
| 61782 | PyObject* pyobj_dims_counts = NULL; |  | 61734 | PyObject* pyobj_dims_counts = NULL;
| 61783 | int dims_counts=0; |  | 61735 | int dims_counts=0;
| 61784 |  |  | 61736 |
| 61785 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL }; |  | 61737 | const char* keywords[] = { "Array", "dslabel", "dims_offset", "dims_counts", NULL };
| 61786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) && |  | 61738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:hdf_HDF5.dswrite", (char**)keywords, &pyobj_Array, &pyobj_dslabel, &pyobj_dims_offset, &pyobj_dims_counts) &&
| 61787 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) && |  | 61739 | pyopencv_to_safe(pyobj_Array, Array, ArgInfo("Array", 0)) &&
| 61788 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) && |  | 61740 | pyopencv_to_safe(pyobj_dslabel, dslabel, ArgInfo("dslabel", 0)) &&
| 61789 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) && |  | 61741 | pyopencv_to_safe(pyobj_dims_offset, dims_offset, ArgInfo("dims_offset", 0)) &&
| 61790 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) ) |  | 61742 | pyopencv_to_safe(pyobj_dims_counts, dims_counts, ArgInfo("dims_counts", 0)) )
| 61791 | { |  | 61743 | {
| 61792 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset, &dims_counts)); |  | 61744 | ERRWRAP2(_self_->dswrite(Array, dslabel, &dims_offset, &dims_counts));
| 61793 | Py_RETURN_NONE; |  | 61745 | Py_RETURN_NONE;
| 61794 | } |  | 61746 | }
| 61795 |  |  | 61747 |
| 61796 |  |  | 61748 |
| 61797 | pyPopulateArgumentConversionErrors(); |  | 61749 | pyPopulateArgumentConversionErrors();
| 61798 | } |  | 61750 | }
| 61799 | pyRaiseCVOverloadException("dswrite"); |  | 61751 | pyRaiseCVOverloadException("dswrite");
| 61800 |  |  | 61752 |
| 61801 | return NULL; |  | 61753 | return NULL;
| 61802 | } |  | 61754 | }
| 61803 |  |  | 61755 |
| 61804 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_grcreate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61756 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_grcreate(PyObject* self, PyObject* py_args, PyObject* kw)
| 61805 | { |  | 61757 | {
| 61806 | using namespace cv::hdf; |  | 61758 | using namespace cv::hdf;
| 61807 |  |  | 61759 |
| 61808 |  |  | 61760 |
| 61809 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61761 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61810 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61762 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61811 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61763 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61812 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61764 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61813 | PyObject* pyobj_grlabel = NULL; |  | 61765 | PyObject* pyobj_grlabel = NULL;
| 61814 | String grlabel; |  | 61766 | String grlabel;
| 61815 |  |  | 61767 |
| 61816 | const char* keywords[] = { "grlabel", NULL }; |  | 61768 | const char* keywords[] = { "grlabel", NULL };
| 61817 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.grcreate", (char**)keywords, &pyobj_grlabel) && |  | 61769 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.grcreate", (char**)keywords, &pyobj_grlabel) &&
| 61818 | pyopencv_to_safe(pyobj_grlabel, grlabel, ArgInfo("grlabel", 0)) ) |  | 61770 | pyopencv_to_safe(pyobj_grlabel, grlabel, ArgInfo("grlabel", 0)) )
| 61819 | { |  | 61771 | {
| 61820 | ERRWRAP2(_self_->grcreate(grlabel)); |  | 61772 | ERRWRAP2(_self_->grcreate(grlabel));
| 61821 | Py_RETURN_NONE; |  | 61773 | Py_RETURN_NONE;
| 61822 | } |  | 61774 | }
| 61823 |  |  | 61775 |
| 61824 | return NULL; |  | 61776 | return NULL;
| 61825 | } |  | 61777 | }
| 61826 |  |  | 61778 |
| 61827 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_hlexists(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61779 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_hlexists(PyObject* self, PyObject* py_args, PyObject* kw)
| 61828 | { |  | 61780 | {
| 61829 | using namespace cv::hdf; |  | 61781 | using namespace cv::hdf;
| 61830 |  |  | 61782 |
| 61831 |  |  | 61783 |
| 61832 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61784 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61833 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61785 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61834 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61786 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61835 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61787 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61836 | PyObject* pyobj_label = NULL; |  | 61788 | PyObject* pyobj_label = NULL;
| 61837 | String label; |  | 61789 | String label;
| 61838 | bool retval; |  | 61790 | bool retval;
| 61839 |  |  | 61791 |
| 61840 | const char* keywords[] = { "label", NULL }; |  | 61792 | const char* keywords[] = { "label", NULL };
| 61841 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.hlexists", (char**)keywords, &pyobj_label) && |  | 61793 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hdf_HDF5.hlexists", (char**)keywords, &pyobj_label) &&
| 61842 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) ) |  | 61794 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) )
| 61843 | { |  | 61795 | {
| 61844 | ERRWRAP2(retval = _self_->hlexists(label)); |  | 61796 | ERRWRAP2(retval = _self_->hlexists(label));
| 61845 | return pyopencv_from(retval); |  | 61797 | return pyopencv_from(retval);
| 61846 | } |  | 61798 | }
| 61847 |  |  | 61799 |
| 61848 | return NULL; |  | 61800 | return NULL;
| 61849 | } |  | 61801 | }
| 61850 |  |  | 61802 |
| 61851 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_kpgetsize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61803 | static PyObject* pyopencv_cv_hdf_hdf_HDF5_kpgetsize(PyObject* self, PyObject* py_args, PyObject* kw)
| 61852 | { |  | 61804 | {
| 61853 | using namespace cv::hdf; |  | 61805 | using namespace cv::hdf;
| 61854 |  |  | 61806 |
| 61855 |  |  | 61807 |
| 61856 | Ptr<cv::hdf::HDF5> * self1 = 0; |  | 61808 | Ptr<cv::hdf::HDF5> * self1 = 0;
| 61857 | if (!pyopencv_hdf_HDF5_getp(self, self1)) |  | 61809 | if (!pyopencv_hdf_HDF5_getp(self, self1))
| 61858 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)"); |  | 61810 | return failmsgp("Incorrect type of self (must be 'hdf_HDF5' or its derivative)");
| 61859 | Ptr<cv::hdf::HDF5> _self_ = *(self1); |  | 61811 | Ptr<cv::hdf::HDF5> _self_ = *(self1);
| 61860 | PyObject* pyobj_kplabel = NULL; |  | 61812 | PyObject* pyobj_kplabel = NULL;
| 61861 | String kplabel; |  | 61813 | String kplabel;
| 61862 | PyObject* pyobj_dims_flag = NULL; |  | 61814 | PyObject* pyobj_dims_flag = NULL;
| 61863 | int dims_flag=HDF5::H5_GETDIMS; |  | 61815 | int dims_flag=HDF5::H5_GETDIMS;
| 61864 | int retval; |  | 61816 | int retval;
| 61865 |  |  | 61817 |
| 61866 | const char* keywords[] = { "kplabel", "dims_flag", NULL }; |  | 61818 | const char* keywords[] = { "kplabel", "dims_flag", NULL };
| 61867 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.kpgetsize", (char**)keywords, &pyobj_kplabel, &pyobj_dims_flag) && |  | 61819 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hdf_HDF5.kpgetsize", (char**)keywords, &pyobj_kplabel, &pyobj_dims_flag) &&
| 61868 | pyopencv_to_safe(pyobj_kplabel, kplabel, ArgInfo("kplabel", 0)) && |  | 61820 | pyopencv_to_safe(pyobj_kplabel, kplabel, ArgInfo("kplabel", 0)) &&
| 61869 | pyopencv_to_safe(pyobj_dims_flag, dims_flag, ArgInfo("dims_flag", 0)) ) |  | 61821 | pyopencv_to_safe(pyobj_dims_flag, dims_flag, ArgInfo("dims_flag", 0)) )
| 61870 | { |  | 61822 | {
| 61871 | ERRWRAP2(retval = _self_->kpgetsize(kplabel, dims_flag)); |  | 61823 | ERRWRAP2(retval = _self_->kpgetsize(kplabel, dims_flag));
| 61872 | return pyopencv_from(retval); |  | 61824 | return pyopencv_from(retval);
| 61873 | } |  | 61825 | }
| 61874 |  |  | 61826 |
| 61875 | return NULL; |  | 61827 | return NULL;
| 61876 | } |  | 61828 | }
| 61877 |  |  | 61829 |
| 61878 |  |  | 61830 |
| 61879 |  |  | 61831 |
| 61880 | // Tables (hdf_HDF5) |  | 61832 | // Tables (hdf_HDF5)
| 61881 |  |  | 61833 |
| 61882 | static PyGetSetDef pyopencv_hdf_HDF5_getseters[] = |  | 61834 | static PyGetSetDef pyopencv_hdf_HDF5_getseters[] =
| 61883 | { |  | 61835 | {
| 61884 | {NULL} /* Sentinel */ |  | 61836 | {NULL} /* Sentinel */
| 61885 | }; |  | 61837 | };
| 61886 |  |  | 61838 |
| 61887 | static PyMethodDef pyopencv_hdf_HDF5_methods[] = |  | 61839 | static PyMethodDef pyopencv_hdf_HDF5_methods[] =
| 61888 | { |  | 61840 | {
| 61889 | {"atdelete", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atdelete, 0), "atdelete(atlabel) -> None\n. * Delete an attribute from the root group.\n. *\n. * @param atlabel the attribute to be deleted.\n. *\n. * @note CV_Error() is called if the given attribute does not exist. Use atexists()\n. * to check whether it exists or not beforehand.\n. *\n. * @sa atexists, atwrite, atread"}, |  | 61841 | {"atdelete", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atdelete, 0), "atdelete(atlabel) -> None\n. * Delete an attribute from the root group.\n. *\n. * @param atlabel the attribute to be deleted.\n. *\n. * @note CV_Error() is called if the given attribute does not exist. Use atexists()\n. * to check whether it exists or not beforehand.\n. *\n. * @sa atexists, atwrite, atread"},
| 61890 | {"atexists", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atexists, 0), "atexists(atlabel) -> retval\n. * Check whether a given attribute exits or not in the root group.\n. *\n. * @param atlabel the attribute name to be checked.\n. * @return true if the attribute exists, false otherwise.\n. *\n. * @sa atdelete, atwrite, atread"}, |  | 61842 | {"atexists", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atexists, 0), "atexists(atlabel) -> retval\n. * Check whether a given attribute exits or not in the root group.\n. *\n. * @param atlabel the attribute name to be checked.\n. * @return true if the attribute exists, false otherwise.\n. *\n. * @sa atdelete, atwrite, atread"},
| 61891 | {"atread", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atread, 0), "atread(value, atlabel) -> None\n. * Read an attribute from the root group.\n. *\n. * @param value address where the attribute is read into\n. * @param atlabel attribute name\n. *\n. * The following example demonstrates how to read an attribute of type cv::String:\n. *\n. * @snippet samples/read_write_attributes.cpp snippets_read_str\n. *\n. * @note The attribute MUST exist, otherwise CV_Error() is called. Use atexists()\n. * to check if it exists beforehand.\n. *\n. * @sa atexists, atdelete, atwrite\n\n\n\natread(atlabel[, value]) -> value\n. * Read an attribute from the root group.\n. *\n. * @param value attribute value. Currently, only n-d continuous multi-channel arrays are supported.\n. * @param atlabel attribute name.\n. *\n. * @note The attribute MUST exist, otherwise CV_Error() is called. Use atexists()\n. * to check if it exists beforehand.\n. *\n. * @sa atexists, atdelete, atwrite"}, |  | 61843 | {"atread", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atread, 0), "atread(value, atlabel) -> None\n. * Read an attribute from the root group.\n. *\n. * @param value address where the attribute is read into\n. * @param atlabel attribute name\n. *\n. * The following example demonstrates how to read an attribute of type cv::String:\n. *\n. * @snippet samples/read_write_attributes.cpp snippets_read_str\n. *\n. * @note The attribute MUST exist, otherwise CV_Error() is called. Use atexists()\n. * to check if it exists beforehand.\n. *\n. * @sa atexists, atdelete, atwrite\n\n\n\natread(atlabel[, value]) -> value\n. * Read an attribute from the root group.\n. *\n. * @param value attribute value. Currently, only n-d continuous multi-channel arrays are supported.\n. * @param atlabel attribute name.\n. *\n. * @note The attribute MUST exist, otherwise CV_Error() is called. Use atexists()\n. * to check if it exists beforehand.\n. *\n. * @sa atexists, atdelete, atwrite"},
| 61892 | {"atwrite", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atwrite, 0), "atwrite(value, atlabel) -> None\n. * Write an attribute inside the root group.\n. *\n. * @param value attribute value.\n. * @param atlabel attribute name.\n. *\n. * The following example demonstrates how to write an attribute of type cv::String:\n. *\n. * @snippet samples/read_write_attributes.cpp snippets_write_str\n. *\n. * @note CV_Error() is called if the given attribute already exists. Use atexists()\n. * to check whether it exists or not beforehand. And use atdelete() to delete\n. * it if it already exists.\n. *\n. * @sa atexists, atdelete, atread"}, |  | 61844 | {"atwrite", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_atwrite, 0), "atwrite(value, atlabel) -> None\n. * Write an attribute inside the root group.\n. *\n. * @param value attribute value.\n. * @param atlabel attribute name.\n. *\n. * The following example demonstrates how to write an attribute of type cv::String:\n. *\n. * @snippet samples/read_write_attributes.cpp snippets_write_str\n. *\n. * @note CV_Error() is called if the given attribute already exists. Use atexists()\n. * to check whether it exists or not beforehand. And use atdelete() to delete\n. * it if it already exists.\n. *\n. * @sa atexists, atdelete, atread"},
| 61893 | {"close", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_close, 0), "close() -> None\n. @brief Close and release hdf5 object."}, |  | 61845 | {"close", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_close, 0), "close() -> None\n. @brief Close and release hdf5 object."},
| 61894 | {"dscreate", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dscreate, 0), "dscreate(rows, cols, type, dslabel) -> None\n. @overload\n\n\n\ndscreate(rows, cols, type, dslabel, compresslevel) -> None\n. @overload\n\n\n\ndscreate(rows, cols, type, dslabel, compresslevel, dims_chunks) -> None\n. @overload\n\n\n\ndscreate(n_dims, sizes, type, dslabel) -> None\n. \n\n\n\ndscreate(n_dims, sizes, type, dslabel, compresslevel) -> None\n. \n\n\n\ndscreate(sizes, type, dslabel[, compresslevel[, dims_chunks]]) -> None\n. \n\n\n\ndscreate(n_dims, sizes, type, dslabel, compresslevel, dims_chunks) -> None\n. @brief Create and allocate storage for n-dimensional dataset, single or multichannel type.\n. @param n_dims declare number of dimensions\n. @param sizes array containing sizes for each dimensions\n. @param type type to be used, e.g., CV_8UC3, CV_32FC1, etc.\n. @param dslabel specify the hdf5 dataset label. Existing dataset label will cause an error.\n. @param compresslevel specify the compression level 0-9 to be used, H5_NONE is the default value and means no compression.\n. The value 0 also means no compression.\n. A value 9 indicating the best compression ration. Note\n. that a higher compression level indicates a higher computational cost. It relies\n. on GNU gzip for compression.\n. @param dims_chunks each array member specifies chunking sizes to be used for block I/O,\n. by default NULL means none at all.\n. @note If the dataset already exists, an exception will be thrown. Existence of the dataset can be checked\n. using hlexists().\n. \n. - See example below that creates a 6 dimensional storage space:\n. @code{.cpp}\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // create space for 6 dimensional CV_64FC2 matrix\n. if ( ! h5io->hlexists( \"nddata\" ) )\n. int n_dims = 5;\n. int dsdims[n_dims] = { 100, 100, 20, 10, 5, 5 };\n. h5io->dscreate( n_dims, sizes, CV_64FC2, \"nddata\" );\n. else\n. printf(\"DS already created, skipping\\n\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. @note Activating compression requires internal chunking. Chunking can significantly improve access\n. speed both at read and write time, especially for windowed access logic that shifts offset inside dataset.\n. If no custom chunking is specified, the default one will be invoked by the size of **whole** dataset\n. as single big chunk of data.\n. \n. - See example of level 0 compression (shallow) using chunking against the first\n. dimension, thus storage will consists of 100 chunks of data:\n. @code{.cpp}\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // create space for 6 dimensional CV_64FC2 matrix\n. if ( ! h5io->hlexists( \"nddata\" ) )\n. int n_dims = 5;\n. int dsdims[n_dims] = { 100, 100, 20, 10, 5, 5 };\n. int chunks[n_dims] = { 1, 100, 20, 10, 5, 5 };\n. h5io->dscreate( n_dims, dsdims, CV_64FC2, \"nddata\", 0, chunks );\n. else\n. printf(\"DS already created, skipping\\n\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. @note A value of H5_UNLIMITED inside the **sizes** array means **unlimited** data on that dimension, thus it is\n. possible to expand anytime such dataset on those unlimited directions. Presence of H5_UNLIMITED on any dimension\n. **requires** to define custom chunking. No default chunking will be defined in unlimited scenario since the default size\n. on that dimension will be zero, and will grow once dataset is written. Writing into dataset that has H5_UNLIMITED on\n. some of its dimension requires dsinsert() instead of dswrite() that allows growth on unlimited dimension instead of\n. dswrite() that allows to write only in predefined data space.\n. \n. - Example below shows a 3 dimensional dataset using no compression with all unlimited sizes and one unit chunking:\n. @code{.cpp}\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. int n_dims = 3;\n. int chunks[n_dims] = { 1, 1, 1 };\n. int dsdims[n_dims] = { cv::hdf::HDF5::H5_UNLIMITED, cv::hdf::HDF5::H5_UNLIMITED, cv::hdf::HDF5::H5_UNLIMITED };\n. h5io->dscreate( n_dims, dsdims, CV_64FC2, \"nddata\", cv::hdf::HDF5::H5_NONE, chunks );\n. // release\n. h5io->close();\n. @endcode"}, |  | 61846 | {"dscreate", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dscreate, 0), "dscreate(rows, cols, type, dslabel) -> None\n. @overload\n\n\n\ndscreate(rows, cols, type, dslabel, compresslevel) -> None\n. @overload\n\n\n\ndscreate(rows, cols, type, dslabel, compresslevel, dims_chunks) -> None\n. @overload\n\n\n\ndscreate(n_dims, sizes, type, dslabel) -> None\n. \n\n\n\ndscreate(n_dims, sizes, type, dslabel, compresslevel) -> None\n. \n\n\n\ndscreate(sizes, type, dslabel[, compresslevel[, dims_chunks]]) -> None\n. \n\n\n\ndscreate(n_dims, sizes, type, dslabel, compresslevel, dims_chunks) -> None\n. @brief Create and allocate storage for n-dimensional dataset, single or multichannel type.\n. @param n_dims declare number of dimensions\n. @param sizes array containing sizes for each dimensions\n. @param type type to be used, e.g., CV_8UC3, CV_32FC1, etc.\n. @param dslabel specify the hdf5 dataset label. Existing dataset label will cause an error.\n. @param compresslevel specify the compression level 0-9 to be used, H5_NONE is the default value and means no compression.\n. The value 0 also means no compression.\n. A value 9 indicating the best compression ration. Note\n. that a higher compression level indicates a higher computational cost. It relies\n. on GNU gzip for compression.\n. @param dims_chunks each array member specifies chunking sizes to be used for block I/O,\n. by default NULL means none at all.\n. @note If the dataset already exists, an exception will be thrown. Existence of the dataset can be checked\n. using hlexists().\n. \n. - See example below that creates a 6 dimensional storage space:\n. @code{.cpp}\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // create space for 6 dimensional CV_64FC2 matrix\n. if ( ! h5io->hlexists( \"nddata\" ) )\n. int n_dims = 5;\n. int dsdims[n_dims] = { 100, 100, 20, 10, 5, 5 };\n. h5io->dscreate( n_dims, sizes, CV_64FC2, \"nddata\" );\n. else\n. printf(\"DS already created, skipping\\n\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. @note Activating compression requires internal chunking. Chunking can significantly improve access\n. speed both at read and write time, especially for windowed access logic that shifts offset inside dataset.\n. If no custom chunking is specified, the default one will be invoked by the size of **whole** dataset\n. as single big chunk of data.\n. \n. - See example of level 0 compression (shallow) using chunking against the first\n. dimension, thus storage will consists of 100 chunks of data:\n. @code{.cpp}\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // create space for 6 dimensional CV_64FC2 matrix\n. if ( ! h5io->hlexists( \"nddata\" ) )\n. int n_dims = 5;\n. int dsdims[n_dims] = { 100, 100, 20, 10, 5, 5 };\n. int chunks[n_dims] = { 1, 100, 20, 10, 5, 5 };\n. h5io->dscreate( n_dims, dsdims, CV_64FC2, \"nddata\", 0, chunks );\n. else\n. printf(\"DS already created, skipping\\n\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. @note A value of H5_UNLIMITED inside the **sizes** array means **unlimited** data on that dimension, thus it is\n. possible to expand anytime such dataset on those unlimited directions. Presence of H5_UNLIMITED on any dimension\n. **requires** to define custom chunking. No default chunking will be defined in unlimited scenario since the default size\n. on that dimension will be zero, and will grow once dataset is written. Writing into dataset that has H5_UNLIMITED on\n. some of its dimension requires dsinsert() instead of dswrite() that allows growth on unlimited dimension instead of\n. dswrite() that allows to write only in predefined data space.\n. \n. - Example below shows a 3 dimensional dataset using no compression with all unlimited sizes and one unit chunking:\n. @code{.cpp}\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. int n_dims = 3;\n. int chunks[n_dims] = { 1, 1, 1 };\n. int dsdims[n_dims] = { cv::hdf::HDF5::H5_UNLIMITED, cv::hdf::HDF5::H5_UNLIMITED, cv::hdf::HDF5::H5_UNLIMITED };\n. h5io->dscreate( n_dims, dsdims, CV_64FC2, \"nddata\", cv::hdf::HDF5::H5_NONE, chunks );\n. // release\n. h5io->close();\n. @endcode"},
| 61895 | {"dsgetsize", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsgetsize, 0), "dsgetsize(dslabel[, dims_flag]) -> retval\n. @brief Fetch dataset sizes\n. @param dslabel specify the hdf5 dataset label to be measured.\n. @param dims_flag will fetch dataset dimensions on H5_GETDIMS, dataset maximum dimensions on H5_GETMAXDIMS,\n. and chunk sizes on H5_GETCHUNKDIMS.\n. \n. Returns vector object containing sizes of dataset on each dimensions.\n. \n. @note Resulting vector size will match the amount of dataset dimensions. By default H5_GETDIMS will return\n. actual dataset dimensions. Using H5_GETMAXDIM flag will get maximum allowed dimension which normally match\n. actual dataset dimension but can hold H5_UNLIMITED value if dataset was prepared in **unlimited** mode on\n. some of its dimension. It can be useful to check existing dataset dimensions before overwrite it as whole or subset.\n. Trying to write with oversized source data into dataset target will thrown exception. The H5_GETCHUNKDIMS will\n. return the dimension of chunk if dataset was created with chunking options otherwise returned vector size\n. will be zero."}, |  | 61847 | {"dsgetsize", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsgetsize, 0), "dsgetsize(dslabel[, dims_flag]) -> retval\n. @brief Fetch dataset sizes\n. @param dslabel specify the hdf5 dataset label to be measured.\n. @param dims_flag will fetch dataset dimensions on H5_GETDIMS, dataset maximum dimensions on H5_GETMAXDIMS,\n. and chunk sizes on H5_GETCHUNKDIMS.\n. \n. Returns vector object containing sizes of dataset on each dimensions.\n. \n. @note Resulting vector size will match the amount of dataset dimensions. By default H5_GETDIMS will return\n. actual dataset dimensions. Using H5_GETMAXDIM flag will get maximum allowed dimension which normally match\n. actual dataset dimension but can hold H5_UNLIMITED value if dataset was prepared in **unlimited** mode on\n. some of its dimension. It can be useful to check existing dataset dimensions before overwrite it as whole or subset.\n. Trying to write with oversized source data into dataset target will thrown exception. The H5_GETCHUNKDIMS will\n. return the dimension of chunk if dataset was created with chunking options otherwise returned vector size\n. will be zero."},
| 61896 | {"dsgettype", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsgettype, 0), "dsgettype(dslabel) -> retval\n. @brief Fetch dataset type\n. @param dslabel specify the hdf5 dataset label to be checked.\n. \n. Returns the stored matrix type. This is an identifier compatible with the CvMat type system,\n. like e.g. CV_16SC5 (16-bit signed 5-channel array), and so on.\n. \n. @note Result can be parsed with CV_MAT_CN() to obtain amount of channels and CV_MAT_DEPTH() to obtain native cvdata type.\n. It is thread safe."}, |  | 61848 | {"dsgettype", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsgettype, 0), "dsgettype(dslabel) -> retval\n. @brief Fetch dataset type\n. @param dslabel specify the hdf5 dataset label to be checked.\n. \n. Returns the stored matrix type. This is an identifier compatible with the CvMat type system,\n. like e.g. CV_16SC5 (16-bit signed 5-channel array), and so on.\n. \n. @note Result can be parsed with CV_MAT_CN() to obtain amount of channels and CV_MAT_DEPTH() to obtain native cvdata type.\n. It is thread safe."},
| 61897 | {"dsinsert", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsinsert, 0), "dsinsert(Array, dslabel) -> None\n. \n\n\n\ndsinsert(Array, dslabel, dims_offset) -> None\n. \n\n\n\ndsinsert(Array, dslabel, dims_offset[, dims_counts]) -> None\n. \n\n\n\ndsinsert(Array, dslabel, dims_offset, dims_counts) -> None\n. @brief Insert or overwrite a Mat object into specified dataset and auto expand dataset size if **unlimited** property allows.\n. @param Array specify Mat data array to be written.\n. @param dslabel specify the target hdf5 dataset label.\n. @param dims_offset each array member specify the offset location\n. over dataset's each dimensions from where InputArray will be (over)written into dataset.\n. @param dims_counts each array member specify the amount of data over dataset's\n. each dimensions from InputArray that will be written into dataset.\n. \n. Writes Mat object into targeted dataset and **autoexpand** dataset dimension if allowed.\n. \n. @note Unlike dswrite(), datasets are **not** created **automatically**. Only Mat is supported and it must be **continuous**.\n. If dsinsert() happens over outer regions of dataset dimensions and on that dimension of dataset is in **unlimited** mode then\n. dataset is expanded, otherwise exception is thrown. To create datasets with **unlimited** property on specific or more\n. dimensions see dscreate() and the optional H5_UNLIMITED flag at creation time. It is not thread safe over same dataset\n. but multiple datasets can be merged inside a single hdf5 file.\n. \n. - Example below creates **unlimited** rows x 100 cols and expands rows 5 times with dsinsert() using single 100x100 CV_64FC2\n. over the dataset. Final size will have 5x100 rows and 100 cols, reflecting H matrix five times over row's span. Chunks size is\n. 100x100 just optimized against the H matrix size having compression disabled. If routine is called multiple times dataset will be\n. just overwritten:\n. @code{.cpp}\n. // dual channel hilbert matrix\n. cv::Mat H(50, 100, CV_64FC2);\n. for(int i = 0; i < H.rows; i++)\n. for(int j = 0; j < H.cols; j++)\n. {\n. H.at<cv::Vec2d>(i,j)[0] = 1./(i+j+1);\n. H.at<cv::Vec2d>(i,j)[1] = -1./(i+j+1);\n. count++;\n. }\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // optimise dataset by chunks\n. int chunks[2] = { 100, 100 };\n. // create Unlimited x 100 CV_64FC2 space\n. h5io->dscreate( cv::hdf::HDF5::H5_UNLIMITED, 100, CV_64FC2, \"hilbert\", cv::hdf::HDF5::H5_NONE, chunks );\n. // write into first half\n. int offset[2] = { 0, 0 };\n. for ( int t = 0; t < 5; t++ )\n. {\n. offset[0] += 100 * t;\n. h5io->dsinsert( H, \"hilbert\", offset );\n. }\n. // release\n. h5io->close();\n. @endcode"}, |  | 61849 | {"dsinsert", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsinsert, 0), "dsinsert(Array, dslabel) -> None\n. \n\n\n\ndsinsert(Array, dslabel, dims_offset) -> None\n. \n\n\n\ndsinsert(Array, dslabel, dims_offset[, dims_counts]) -> None\n. \n\n\n\ndsinsert(Array, dslabel, dims_offset, dims_counts) -> None\n. @brief Insert or overwrite a Mat object into specified dataset and auto expand dataset size if **unlimited** property allows.\n. @param Array specify Mat data array to be written.\n. @param dslabel specify the target hdf5 dataset label.\n. @param dims_offset each array member specify the offset location\n. over dataset's each dimensions from where InputArray will be (over)written into dataset.\n. @param dims_counts each array member specify the amount of data over dataset's\n. each dimensions from InputArray that will be written into dataset.\n. \n. Writes Mat object into targeted dataset and **autoexpand** dataset dimension if allowed.\n. \n. @note Unlike dswrite(), datasets are **not** created **automatically**. Only Mat is supported and it must be **continuous**.\n. If dsinsert() happens over outer regions of dataset dimensions and on that dimension of dataset is in **unlimited** mode then\n. dataset is expanded, otherwise exception is thrown. To create datasets with **unlimited** property on specific or more\n. dimensions see dscreate() and the optional H5_UNLIMITED flag at creation time. It is not thread safe over same dataset\n. but multiple datasets can be merged inside a single hdf5 file.\n. \n. - Example below creates **unlimited** rows x 100 cols and expands rows 5 times with dsinsert() using single 100x100 CV_64FC2\n. over the dataset. Final size will have 5x100 rows and 100 cols, reflecting H matrix five times over row's span. Chunks size is\n. 100x100 just optimized against the H matrix size having compression disabled. If routine is called multiple times dataset will be\n. just overwritten:\n. @code{.cpp}\n. // dual channel hilbert matrix\n. cv::Mat H(50, 100, CV_64FC2);\n. for(int i = 0; i < H.rows; i++)\n. for(int j = 0; j < H.cols; j++)\n. {\n. H.at<cv::Vec2d>(i,j)[0] = 1./(i+j+1);\n. H.at<cv::Vec2d>(i,j)[1] = -1./(i+j+1);\n. count++;\n. }\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // optimise dataset by chunks\n. int chunks[2] = { 100, 100 };\n. // create Unlimited x 100 CV_64FC2 space\n. h5io->dscreate( cv::hdf::HDF5::H5_UNLIMITED, 100, CV_64FC2, \"hilbert\", cv::hdf::HDF5::H5_NONE, chunks );\n. // write into first half\n. int offset[2] = { 0, 0 };\n. for ( int t = 0; t < 5; t++ )\n. {\n. offset[0] += 100 * t;\n. h5io->dsinsert( H, \"hilbert\", offset );\n. }\n. // release\n. h5io->close();\n. @endcode"},
| 61898 | {"dsread", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsread, 0), "dsread(dslabel[, Array]) -> Array\n. \n\n\n\ndsread(dslabel, dims_offset[, Array]) -> Array\n. \n\n\n\ndsread(dslabel, dims_offset[, Array[, dims_counts]]) -> Array\n. \n\n\n\ndsread(dslabel, dims_offset, dims_counts[, Array]) -> Array\n. @brief Read specific dataset from hdf5 file into Mat object.\n. @param Array Mat container where data reads will be returned.\n. @param dslabel specify the source hdf5 dataset label.\n. @param dims_offset each array member specify the offset location over\n. each dimensions from where dataset starts to read into OutputArray.\n. @param dims_counts each array member specify the amount over dataset's each\n. dimensions of dataset to read into OutputArray.\n. \n. Reads out Mat object reflecting the stored dataset.\n. \n. @note If hdf5 file does not exist an exception will be thrown. Use hlexists() to check dataset presence.\n. It is thread safe.\n. \n. - Example below reads a dataset:\n. @code{.cpp}\n. // open hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // blank Mat container\n. cv::Mat H;\n. // read hibert dataset\n. h5io->read( H, \"hilbert\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. - Example below perform read of 3x5 submatrix from second row and third element.\n. @code{.cpp}\n. // open hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // blank Mat container\n. cv::Mat H;\n. int offset[2] = { 1, 2 };\n. int counts[2] = { 3, 5 };\n. // read hibert dataset\n. h5io->read( H, \"hilbert\", offset, counts );\n. // release\n. h5io->close();\n. @endcode"}, |  | 61850 | {"dsread", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dsread, 0), "dsread(dslabel[, Array]) -> Array\n. \n\n\n\ndsread(dslabel, dims_offset[, Array]) -> Array\n. \n\n\n\ndsread(dslabel, dims_offset[, Array[, dims_counts]]) -> Array\n. \n\n\n\ndsread(dslabel, dims_offset, dims_counts[, Array]) -> Array\n. @brief Read specific dataset from hdf5 file into Mat object.\n. @param Array Mat container where data reads will be returned.\n. @param dslabel specify the source hdf5 dataset label.\n. @param dims_offset each array member specify the offset location over\n. each dimensions from where dataset starts to read into OutputArray.\n. @param dims_counts each array member specify the amount over dataset's each\n. dimensions of dataset to read into OutputArray.\n. \n. Reads out Mat object reflecting the stored dataset.\n. \n. @note If hdf5 file does not exist an exception will be thrown. Use hlexists() to check dataset presence.\n. It is thread safe.\n. \n. - Example below reads a dataset:\n. @code{.cpp}\n. // open hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // blank Mat container\n. cv::Mat H;\n. // read hibert dataset\n. h5io->read( H, \"hilbert\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. - Example below perform read of 3x5 submatrix from second row and third element.\n. @code{.cpp}\n. // open hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // blank Mat container\n. cv::Mat H;\n. int offset[2] = { 1, 2 };\n. int counts[2] = { 3, 5 };\n. // read hibert dataset\n. h5io->read( H, \"hilbert\", offset, counts );\n. // release\n. h5io->close();\n. @endcode"},
| 61899 | {"dswrite", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dswrite, 0), "dswrite(Array, dslabel) -> None\n. \n\n\n\ndswrite(Array, dslabel, dims_offset) -> None\n. \n\n\n\ndswrite(Array, dslabel, dims_offset[, dims_counts]) -> None\n. \n\n\n\ndswrite(Array, dslabel, dims_offset, dims_counts) -> None\n. @brief Write or overwrite a Mat object into specified dataset of hdf5 file.\n. @param Array specify Mat data array to be written.\n. @param dslabel specify the target hdf5 dataset label.\n. @param dims_offset each array member specify the offset location\n. over dataset's each dimensions from where InputArray will be (over)written into dataset.\n. @param dims_counts each array member specifies the amount of data over dataset's\n. each dimensions from InputArray that will be written into dataset.\n. \n. Writes Mat object into targeted dataset.\n. \n. @note If dataset is not created and does not exist it will be created **automatically**. Only Mat is supported and\n. it must be **continuous**. It is thread safe but it is recommended that writes to happen over separate non-overlapping\n. regions. Multiple datasets can be written inside a single hdf5 file.\n. \n. - Example below writes a 100x100 CV_64FC2 matrix into a dataset. No dataset pre-creation required. If routine\n. is called multiple times dataset will be just overwritten:\n. @code{.cpp}\n. // dual channel hilbert matrix\n. cv::Mat H(100, 100, CV_64FC2);\n. for(int i = 0; i < H.rows; i++)\n. for(int j = 0; j < H.cols; j++)\n. {\n. H.at<cv::Vec2d>(i,j)[0] = 1./(i+j+1);\n. H.at<cv::Vec2d>(i,j)[1] = -1./(i+j+1);\n. count++;\n. }\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // write / overwrite dataset\n. h5io->dswrite( H, \"hilbert\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. - Example below writes a smaller 50x100 matrix into 100x100 compressed space optimised by two 50x100 chunks.\n. Matrix is written twice into first half (0->50) and second half (50->100) of data space using offset.\n. @code{.cpp}\n. // dual channel hilbert matrix\n. cv::Mat H(50, 100, CV_64FC2);\n. for(int i = 0; i < H.rows; i++)\n. for(int j = 0; j < H.cols; j++)\n. {\n. H.at<cv::Vec2d>(i,j)[0] = 1./(i+j+1);\n. H.at<cv::Vec2d>(i,j)[1] = -1./(i+j+1);\n. count++;\n. }\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // optimise dataset by two chunks\n. int chunks[2] = { 50, 100 };\n. // create 100x100 CV_64FC2 compressed space\n. h5io->dscreate( 100, 100, CV_64FC2, \"hilbert\", 9, chunks );\n. // write into first half\n. int offset1[2] = { 0, 0 };\n. h5io->dswrite( H, \"hilbert\", offset1 );\n. // write into second half\n. int offset2[2] = { 50, 0 };\n. h5io->dswrite( H, \"hilbert\", offset2 );\n. // release\n. h5io->close();\n. @endcode"}, |  | 61851 | {"dswrite", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_dswrite, 0), "dswrite(Array, dslabel) -> None\n. \n\n\n\ndswrite(Array, dslabel, dims_offset) -> None\n. \n\n\n\ndswrite(Array, dslabel, dims_offset[, dims_counts]) -> None\n. \n\n\n\ndswrite(Array, dslabel, dims_offset, dims_counts) -> None\n. @brief Write or overwrite a Mat object into specified dataset of hdf5 file.\n. @param Array specify Mat data array to be written.\n. @param dslabel specify the target hdf5 dataset label.\n. @param dims_offset each array member specify the offset location\n. over dataset's each dimensions from where InputArray will be (over)written into dataset.\n. @param dims_counts each array member specifies the amount of data over dataset's\n. each dimensions from InputArray that will be written into dataset.\n. \n. Writes Mat object into targeted dataset.\n. \n. @note If dataset is not created and does not exist it will be created **automatically**. Only Mat is supported and\n. it must be **continuous**. It is thread safe but it is recommended that writes to happen over separate non-overlapping\n. regions. Multiple datasets can be written inside a single hdf5 file.\n. \n. - Example below writes a 100x100 CV_64FC2 matrix into a dataset. No dataset pre-creation required. If routine\n. is called multiple times dataset will be just overwritten:\n. @code{.cpp}\n. // dual channel hilbert matrix\n. cv::Mat H(100, 100, CV_64FC2);\n. for(int i = 0; i < H.rows; i++)\n. for(int j = 0; j < H.cols; j++)\n. {\n. H.at<cv::Vec2d>(i,j)[0] = 1./(i+j+1);\n. H.at<cv::Vec2d>(i,j)[1] = -1./(i+j+1);\n. count++;\n. }\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // write / overwrite dataset\n. h5io->dswrite( H, \"hilbert\" );\n. // release\n. h5io->close();\n. @endcode\n. \n. - Example below writes a smaller 50x100 matrix into 100x100 compressed space optimised by two 50x100 chunks.\n. Matrix is written twice into first half (0->50) and second half (50->100) of data space using offset.\n. @code{.cpp}\n. // dual channel hilbert matrix\n. cv::Mat H(50, 100, CV_64FC2);\n. for(int i = 0; i < H.rows; i++)\n. for(int j = 0; j < H.cols; j++)\n. {\n. H.at<cv::Vec2d>(i,j)[0] = 1./(i+j+1);\n. H.at<cv::Vec2d>(i,j)[1] = -1./(i+j+1);\n. count++;\n. }\n. // open / autocreate hdf5 file\n. cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( \"mytest.h5\" );\n. // optimise dataset by two chunks\n. int chunks[2] = { 50, 100 };\n. // create 100x100 CV_64FC2 compressed space\n. h5io->dscreate( 100, 100, CV_64FC2, \"hilbert\", 9, chunks );\n. // write into first half\n. int offset1[2] = { 0, 0 };\n. h5io->dswrite( H, \"hilbert\", offset1 );\n. // write into second half\n. int offset2[2] = { 50, 0 };\n. h5io->dswrite( H, \"hilbert\", offset2 );\n. // release\n. h5io->close();\n. @endcode"},
| 61900 | {"grcreate", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_grcreate, 0), "grcreate(grlabel) -> None\n. @brief Create a group.\n. @param grlabel specify the hdf5 group label.\n. \n. Create a hdf5 group with default properties. The group is closed automatically after creation.\n. \n. @note Groups are useful for better organising multiple datasets. It is possible to create subgroups within any group.\n. Existence of a particular group can be checked using hlexists(). In case of subgroups, a label would be e.g: 'Group1/SubGroup1'\n. where SubGroup1 is within the root group Group1. Before creating a subgroup, its parent group MUST be created.\n. \n. - In this example, Group1 will have one subgroup called SubGroup1:\n. \n. @snippet samples/create_groups.cpp create_group\n. \n. The corresponding result visualized using the HDFView tool is\n. \n. ![Visualization of groups using the HDFView tool](pics/create_groups.png)\n. \n. @note When a dataset is created with dscreate() or kpcreate(), it can be created within a group by specifying the\n. full path within the label. In our example, it would be: 'Group1/SubGroup1/MyDataSet'. It is not thread safe."}, |  | 61852 | {"grcreate", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_grcreate, 0), "grcreate(grlabel) -> None\n. @brief Create a group.\n. @param grlabel specify the hdf5 group label.\n. \n. Create a hdf5 group with default properties. The group is closed automatically after creation.\n. \n. @note Groups are useful for better organising multiple datasets. It is possible to create subgroups within any group.\n. Existence of a particular group can be checked using hlexists(). In case of subgroups, a label would be e.g: 'Group1/SubGroup1'\n. where SubGroup1 is within the root group Group1. Before creating a subgroup, its parent group MUST be created.\n. \n. - In this example, Group1 will have one subgroup called SubGroup1:\n. \n. @snippet samples/create_groups.cpp create_group\n. \n. The corresponding result visualized using the HDFView tool is\n. \n. ![Visualization of groups using the HDFView tool](pics/create_groups.png)\n. \n. @note When a dataset is created with dscreate() or kpcreate(), it can be created within a group by specifying the\n. full path within the label. In our example, it would be: 'Group1/SubGroup1/MyDataSet'. It is not thread safe."},
| 61901 | {"hlexists", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_hlexists, 0), "hlexists(label) -> retval\n. @brief Check if label exists or not.\n. @param label specify the hdf5 dataset label.\n. \n. Returns **true** if dataset exists, and **false** otherwise.\n. \n. @note Checks if dataset, group or other object type (hdf5 link) exists under the label name. It is thread safe."}, |  | 61853 | {"hlexists", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_hlexists, 0), "hlexists(label) -> retval\n. @brief Check if label exists or not.\n. @param label specify the hdf5 dataset label.\n. \n. Returns **true** if dataset exists, and **false** otherwise.\n. \n. @note Checks if dataset, group or other object type (hdf5 link) exists under the label name. It is thread safe."},
| 61902 | {"kpgetsize", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_kpgetsize, 0), "kpgetsize(kplabel[, dims_flag]) -> retval\n. @brief Fetch keypoint dataset size\n. @param kplabel specify the hdf5 dataset label to be measured.\n. @param dims_flag will fetch dataset dimensions on H5_GETDIMS, and dataset maximum dimensions on H5_GETMAXDIMS.\n. \n. Returns size of keypoints dataset.\n. \n. @note Resulting size will match the amount of keypoints. By default H5_GETDIMS will return actual dataset dimension.\n. Using H5_GETMAXDIM flag will get maximum allowed dimension which normally match actual dataset dimension but can hold\n. H5_UNLIMITED value if dataset was prepared in **unlimited** mode. It can be useful to check existing dataset dimension\n. before overwrite it as whole or subset. Trying to write with oversized source data into dataset target will thrown\n. exception. The H5_GETCHUNKDIMS will return the dimension of chunk if dataset was created with chunking options otherwise\n. returned vector size will be zero."}, |  | 61854 | {"kpgetsize", CV_PY_FN_WITH_KW_(pyopencv_cv_hdf_hdf_HDF5_kpgetsize, 0), "kpgetsize(kplabel[, dims_flag]) -> retval\n. @brief Fetch keypoint dataset size\n. @param kplabel specify the hdf5 dataset label to be measured.\n. @param dims_flag will fetch dataset dimensions on H5_GETDIMS, and dataset maximum dimensions on H5_GETMAXDIMS.\n. \n. Returns size of keypoints dataset.\n. \n. @note Resulting size will match the amount of keypoints. By default H5_GETDIMS will return actual dataset dimension.\n. Using H5_GETMAXDIM flag will get maximum allowed dimension which normally match actual dataset dimension but can hold\n. H5_UNLIMITED value if dataset was prepared in **unlimited** mode. It can be useful to check existing dataset dimension\n. before overwrite it as whole or subset. Trying to write with oversized source data into dataset target will thrown\n. exception. The H5_GETCHUNKDIMS will return the dimension of chunk if dataset was created with chunking options otherwise\n. returned vector size will be zero."},
| 61903 |  |  | 61855 |
| 61904 | {NULL, NULL} |  | 61856 | {NULL, NULL}
| 61905 | }; |  | 61857 | };
| 61906 |  |  | 61858 |
| 61907 | // Converter (hdf_HDF5) |  | 61859 | // Converter (hdf_HDF5)
| 61908 |  |  | 61860 |
| 61909 | template<> |  | 61861 | template<>
| 61910 | struct PyOpenCV_Converter< Ptr<cv::hdf::HDF5> > |  | 61862 | struct PyOpenCV_Converter< Ptr<cv::hdf::HDF5> >
| 61911 | { |  | 61863 | {
| 61912 | static PyObject* from(const Ptr<cv::hdf::HDF5>& r) |  | 61864 | static PyObject* from(const Ptr<cv::hdf::HDF5>& r)
| 61913 | { |  | 61865 | {
| 61914 | return pyopencv_hdf_HDF5_Instance(r); |  | 61866 | return pyopencv_hdf_HDF5_Instance(r);
| 61915 | } |  | 61867 | }
| 61916 | static bool to(PyObject* src, Ptr<cv::hdf::HDF5>& dst, const ArgInfo& info) |  | 61868 | static bool to(PyObject* src, Ptr<cv::hdf::HDF5>& dst, const ArgInfo& info)
| 61917 | { |  | 61869 | {
| 61918 | if(!src || src == Py_None) |  | 61870 | if(!src || src == Py_None)
| 61919 | return true; |  | 61871 | return true;
| 61920 | Ptr<cv::hdf::HDF5> * dst_; |  | 61872 | Ptr<cv::hdf::HDF5> * dst_;
| 61921 | if (pyopencv_hdf_HDF5_getp(src, dst_)) |  | 61873 | if (pyopencv_hdf_HDF5_getp(src, dst_))
| 61922 | { |  | 61874 | {
| 61923 | dst = *dst_; |  | 61875 | dst = *dst_;
| 61924 | return true; |  | 61876 | return true;
| 61925 | } |  | 61877 | }
| 61926 |  |  | 61878 |
| 61927 | failmsg("Expected Ptr<cv::hdf::HDF5> for argument '%s'", info.name); |  | 61879 | failmsg("Expected Ptr<cv::hdf::HDF5> for argument '%s'", info.name);
| 61928 | return false; |  | 61880 | return false;
| 61929 | } |  | 61881 | }
| 61930 | }; |  | 61882 | };
| 61931 |  |  | 61883 |
| 61932 | //================================================================================ |  | 61884 | //================================================================================
| 61933 | // hfs_HfsSegment (Generic) |  | 61885 | // hfs_HfsSegment (Generic)
| 61934 | //================================================================================ |  | 61886 | //================================================================================
| 61935 |  |  | 61887 |
| 61936 | // GetSet (hfs_HfsSegment) |  | 61888 | // GetSet (hfs_HfsSegment)
| 61937 |  |  | 61889 |
| 61938 |  |  | 61890 |
| 61939 |  |  | 61891 |
| 61940 | // Methods (hfs_HfsSegment) |  | 61892 | // Methods (hfs_HfsSegment)
| 61941 |  |  | 61893 |
| 61942 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61894 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 61943 | { |  | 61895 | {
| 61944 | using namespace cv::hfs; |  | 61896 | using namespace cv::hfs;
| 61945 |  |  | 61897 |
| 61946 | PyObject* pyobj_height = NULL; |  | 61898 | PyObject* pyobj_height = NULL;
| 61947 | int height=0; |  | 61899 | int height=0;
| 61948 | PyObject* pyobj_width = NULL; |  | 61900 | PyObject* pyobj_width = NULL;
| 61949 | int width=0; |  | 61901 | int width=0;
| 61950 | PyObject* pyobj_segEgbThresholdI = NULL; |  | 61902 | PyObject* pyobj_segEgbThresholdI = NULL;
| 61951 | float segEgbThresholdI=0.08f; |  | 61903 | float segEgbThresholdI=0.08f;
| 61952 | PyObject* pyobj_minRegionSizeI = NULL; |  | 61904 | PyObject* pyobj_minRegionSizeI = NULL;
| 61953 | int minRegionSizeI=100; |  | 61905 | int minRegionSizeI=100;
| 61954 | PyObject* pyobj_segEgbThresholdII = NULL; |  | 61906 | PyObject* pyobj_segEgbThresholdII = NULL;
| 61955 | float segEgbThresholdII=0.28f; |  | 61907 | float segEgbThresholdII=0.28f;
| 61956 | PyObject* pyobj_minRegionSizeII = NULL; |  | 61908 | PyObject* pyobj_minRegionSizeII = NULL;
| 61957 | int minRegionSizeII=200; |  | 61909 | int minRegionSizeII=200;
| 61958 | PyObject* pyobj_spatialWeight = NULL; |  | 61910 | PyObject* pyobj_spatialWeight = NULL;
| 61959 | float spatialWeight=0.6f; |  | 61911 | float spatialWeight=0.6f;
| 61960 | PyObject* pyobj_slicSpixelSize = NULL; |  | 61912 | PyObject* pyobj_slicSpixelSize = NULL;
| 61961 | int slicSpixelSize=8; |  | 61913 | int slicSpixelSize=8;
| 61962 | PyObject* pyobj_numSlicIter = NULL; |  | 61914 | PyObject* pyobj_numSlicIter = NULL;
| 61963 | int numSlicIter=5; |  | 61915 | int numSlicIter=5;
| 61964 | Ptr<HfsSegment> retval; |  | 61916 | Ptr<HfsSegment> retval;
| 61965 |  |  | 61917 |
| 61966 | const char* keywords[] = { "height", "width", "segEgbThresholdI", "minRegionSizeI", "segEgbThresholdII", "minRegionSizeII", "spatialWeight", "slicSpixelSize", "numSlicIter", NULL }; |  | 61918 | const char* keywords[] = { "height", "width", "segEgbThresholdI", "minRegionSizeI", "segEgbThresholdII", "minRegionSizeII", "spatialWeight", "slicSpixelSize", "numSlicIter", NULL };
| 61967 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOOOOO:hfs_HfsSegment.create", (char**)keywords, &pyobj_height, &pyobj_width, &pyobj_segEgbThresholdI, &pyobj_minRegionSizeI, &pyobj_segEgbThresholdII, &pyobj_minRegionSizeII, &pyobj_spatialWeight, &pyobj_slicSpixelSize, &pyobj_numSlicIter) && |  | 61919 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOOOOO:hfs_HfsSegment.create", (char**)keywords, &pyobj_height, &pyobj_width, &pyobj_segEgbThresholdI, &pyobj_minRegionSizeI, &pyobj_segEgbThresholdII, &pyobj_minRegionSizeII, &pyobj_spatialWeight, &pyobj_slicSpixelSize, &pyobj_numSlicIter) &&
| 61968 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) && |  | 61920 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) &&
| 61969 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) && |  | 61921 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) &&
| 61970 | pyopencv_to_safe(pyobj_segEgbThresholdI, segEgbThresholdI, ArgInfo("segEgbThresholdI", 0)) && |  | 61922 | pyopencv_to_safe(pyobj_segEgbThresholdI, segEgbThresholdI, ArgInfo("segEgbThresholdI", 0)) &&
| 61971 | pyopencv_to_safe(pyobj_minRegionSizeI, minRegionSizeI, ArgInfo("minRegionSizeI", 0)) && |  | 61923 | pyopencv_to_safe(pyobj_minRegionSizeI, minRegionSizeI, ArgInfo("minRegionSizeI", 0)) &&
| 61972 | pyopencv_to_safe(pyobj_segEgbThresholdII, segEgbThresholdII, ArgInfo("segEgbThresholdII", 0)) && |  | 61924 | pyopencv_to_safe(pyobj_segEgbThresholdII, segEgbThresholdII, ArgInfo("segEgbThresholdII", 0)) &&
| 61973 | pyopencv_to_safe(pyobj_minRegionSizeII, minRegionSizeII, ArgInfo("minRegionSizeII", 0)) && |  | 61925 | pyopencv_to_safe(pyobj_minRegionSizeII, minRegionSizeII, ArgInfo("minRegionSizeII", 0)) &&
| 61974 | pyopencv_to_safe(pyobj_spatialWeight, spatialWeight, ArgInfo("spatialWeight", 0)) && |  | 61926 | pyopencv_to_safe(pyobj_spatialWeight, spatialWeight, ArgInfo("spatialWeight", 0)) &&
| 61975 | pyopencv_to_safe(pyobj_slicSpixelSize, slicSpixelSize, ArgInfo("slicSpixelSize", 0)) && |  | 61927 | pyopencv_to_safe(pyobj_slicSpixelSize, slicSpixelSize, ArgInfo("slicSpixelSize", 0)) &&
| 61976 | pyopencv_to_safe(pyobj_numSlicIter, numSlicIter, ArgInfo("numSlicIter", 0)) ) |  | 61928 | pyopencv_to_safe(pyobj_numSlicIter, numSlicIter, ArgInfo("numSlicIter", 0)) )
| 61977 | { |  | 61929 | {
| 61978 | ERRWRAP2(retval = cv::hfs::HfsSegment::create(height, width, segEgbThresholdI, minRegionSizeI, segEgbThresholdII, minRegionSizeII, spatialWeight, slicSpixelSize, numSlicIter)); |  | 61930 | ERRWRAP2(retval = cv::hfs::HfsSegment::create(height, width, segEgbThresholdI, minRegionSizeI, segEgbThresholdII, minRegionSizeII, spatialWeight, slicSpixelSize, numSlicIter));
| 61979 | return pyopencv_from(retval); |  | 61931 | return pyopencv_from(retval);
| 61980 | } |  | 61932 | }
| 61981 |  |  | 61933 |
| 61982 | return NULL; |  | 61934 | return NULL;
| 61983 | } |  | 61935 | }
| 61984 |  |  | 61936 |
| 61985 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeI(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61937 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeI(PyObject* self, PyObject* py_args, PyObject* kw)
| 61986 | { |  | 61938 | {
| 61987 | using namespace cv::hfs; |  | 61939 | using namespace cv::hfs;
| 61988 |  |  | 61940 |
| 61989 |  |  | 61941 |
| 61990 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 61942 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 61991 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 61943 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 61992 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 61944 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 61993 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 61945 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 61994 | int retval; |  | 61946 | int retval;
| 61995 |  |  | 61947 |
| 61996 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 61948 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 61997 | { |  | 61949 | {
| 61998 | ERRWRAP2(retval = _self_->getMinRegionSizeI()); |  | 61950 | ERRWRAP2(retval = _self_->getMinRegionSizeI());
| 61999 | return pyopencv_from(retval); |  | 61951 | return pyopencv_from(retval);
| 62000 | } |  | 61952 | }
| 62001 |  |  | 61953 |
| 62002 | return NULL; |  | 61954 | return NULL;
| 62003 | } |  | 61955 | }
| 62004 |  |  | 61956 |
| 62005 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeII(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61957 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeII(PyObject* self, PyObject* py_args, PyObject* kw)
| 62006 | { |  | 61958 | {
| 62007 | using namespace cv::hfs; |  | 61959 | using namespace cv::hfs;
| 62008 |  |  | 61960 |
| 62009 |  |  | 61961 |
| 62010 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 61962 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62011 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 61963 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62012 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 61964 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62013 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 61965 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62014 | int retval; |  | 61966 | int retval;
| 62015 |  |  | 61967 |
| 62016 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 61968 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62017 | { |  | 61969 | {
| 62018 | ERRWRAP2(retval = _self_->getMinRegionSizeII()); |  | 61970 | ERRWRAP2(retval = _self_->getMinRegionSizeII());
| 62019 | return pyopencv_from(retval); |  | 61971 | return pyopencv_from(retval);
| 62020 | } |  | 61972 | }
| 62021 |  |  | 61973 |
| 62022 | return NULL; |  | 61974 | return NULL;
| 62023 | } |  | 61975 | }
| 62024 |  |  | 61976 |
| 62025 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getNumSlicIter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61977 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getNumSlicIter(PyObject* self, PyObject* py_args, PyObject* kw)
| 62026 | { |  | 61978 | {
| 62027 | using namespace cv::hfs; |  | 61979 | using namespace cv::hfs;
| 62028 |  |  | 61980 |
| 62029 |  |  | 61981 |
| 62030 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 61982 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62031 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 61983 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62032 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 61984 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62033 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 61985 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62034 | int retval; |  | 61986 | int retval;
| 62035 |  |  | 61987 |
| 62036 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 61988 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62037 | { |  | 61989 | {
| 62038 | ERRWRAP2(retval = _self_->getNumSlicIter()); |  | 61990 | ERRWRAP2(retval = _self_->getNumSlicIter());
| 62039 | return pyopencv_from(retval); |  | 61991 | return pyopencv_from(retval);
| 62040 | } |  | 61992 | }
| 62041 |  |  | 61993 |
| 62042 | return NULL; |  | 61994 | return NULL;
| 62043 | } |  | 61995 | }
| 62044 |  |  | 61996 |
| 62045 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdI(PyObject* self, PyObject* py_args, PyObject* kw) |  | 61997 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdI(PyObject* self, PyObject* py_args, PyObject* kw)
| 62046 | { |  | 61998 | {
| 62047 | using namespace cv::hfs; |  | 61999 | using namespace cv::hfs;
| 62048 |  |  | 62000 |
| 62049 |  |  | 62001 |
| 62050 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62002 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62051 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62003 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62052 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62004 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62053 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62005 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62054 | float retval; |  | 62006 | float retval;
| 62055 |  |  | 62007 |
| 62056 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62008 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62057 | { |  | 62009 | {
| 62058 | ERRWRAP2(retval = _self_->getSegEgbThresholdI()); |  | 62010 | ERRWRAP2(retval = _self_->getSegEgbThresholdI());
| 62059 | return pyopencv_from(retval); |  | 62011 | return pyopencv_from(retval);
| 62060 | } |  | 62012 | }
| 62061 |  |  | 62013 |
| 62062 | return NULL; |  | 62014 | return NULL;
| 62063 | } |  | 62015 | }
| 62064 |  |  | 62016 |
| 62065 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdII(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62017 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdII(PyObject* self, PyObject* py_args, PyObject* kw)
| 62066 | { |  | 62018 | {
| 62067 | using namespace cv::hfs; |  | 62019 | using namespace cv::hfs;
| 62068 |  |  | 62020 |
| 62069 |  |  | 62021 |
| 62070 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62022 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62071 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62023 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62072 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62024 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62073 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62025 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62074 | float retval; |  | 62026 | float retval;
| 62075 |  |  | 62027 |
| 62076 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62028 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62077 | { |  | 62029 | {
| 62078 | ERRWRAP2(retval = _self_->getSegEgbThresholdII()); |  | 62030 | ERRWRAP2(retval = _self_->getSegEgbThresholdII());
| 62079 | return pyopencv_from(retval); |  | 62031 | return pyopencv_from(retval);
| 62080 | } |  | 62032 | }
| 62081 |  |  | 62033 |
| 62082 | return NULL; |  | 62034 | return NULL;
| 62083 | } |  | 62035 | }
| 62084 |  |  | 62036 |
| 62085 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSlicSpixelSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62037 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSlicSpixelSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 62086 | { |  | 62038 | {
| 62087 | using namespace cv::hfs; |  | 62039 | using namespace cv::hfs;
| 62088 |  |  | 62040 |
| 62089 |  |  | 62041 |
| 62090 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62042 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62091 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62043 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62092 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62044 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62093 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62045 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62094 | int retval; |  | 62046 | int retval;
| 62095 |  |  | 62047 |
| 62096 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62048 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62097 | { |  | 62049 | {
| 62098 | ERRWRAP2(retval = _self_->getSlicSpixelSize()); |  | 62050 | ERRWRAP2(retval = _self_->getSlicSpixelSize());
| 62099 | return pyopencv_from(retval); |  | 62051 | return pyopencv_from(retval);
| 62100 | } |  | 62052 | }
| 62101 |  |  | 62053 |
| 62102 | return NULL; |  | 62054 | return NULL;
| 62103 | } |  | 62055 | }
| 62104 |  |  | 62056 |
| 62105 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSpatialWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62057 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_getSpatialWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 62106 | { |  | 62058 | {
| 62107 | using namespace cv::hfs; |  | 62059 | using namespace cv::hfs;
| 62108 |  |  | 62060 |
| 62109 |  |  | 62061 |
| 62110 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62062 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62111 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62063 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62112 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62064 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62113 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62065 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62114 | float retval; |  | 62066 | float retval;
| 62115 |  |  | 62067 |
| 62116 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62068 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62117 | { |  | 62069 | {
| 62118 | ERRWRAP2(retval = _self_->getSpatialWeight()); |  | 62070 | ERRWRAP2(retval = _self_->getSpatialWeight());
| 62119 | return pyopencv_from(retval); |  | 62071 | return pyopencv_from(retval);
| 62120 | } |  | 62072 | }
| 62121 |  |  | 62073 |
| 62122 | return NULL; |  | 62074 | return NULL;
| 62123 | } |  | 62075 | }
| 62124 |  |  | 62076 |
| 62125 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_performSegmentCpu(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62077 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_performSegmentCpu(PyObject* self, PyObject* py_args, PyObject* kw)
| 62126 | { |  | 62078 | {
| 62127 | using namespace cv::hfs; |  | 62079 | using namespace cv::hfs;
| 62128 |  |  | 62080 |
| 62129 |  |  | 62081 |
| 62130 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62082 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62131 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62083 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62132 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62084 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62133 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62085 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62134 | pyPrepareArgumentConversionErrorsStorage(2); |  | 62086 | pyPrepareArgumentConversionErrorsStorage(2);
| 62135 |  |  | 62087 |
| 62136 | { |  | 62088 | {
| 62137 | PyObject* pyobj_src = NULL; |  | 62089 | PyObject* pyobj_src = NULL;
| 62138 | Mat src; |  | 62090 | Mat src;
| 62139 | PyObject* pyobj_ifDraw = NULL; |  | 62091 | PyObject* pyobj_ifDraw = NULL;
| 62140 | bool ifDraw=true; |  | 62092 | bool ifDraw=true;
| 62141 | Mat retval; |  | 62093 | Mat retval;
| 62142 |  |  | 62094 |
| 62143 | const char* keywords[] = { "src", "ifDraw", NULL }; |  | 62095 | const char* keywords[] = { "src", "ifDraw", NULL };
| 62144 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentCpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) && |  | 62096 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentCpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) &&
| 62145 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 62097 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 62146 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) ) |  | 62098 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) )
| 62147 | { |  | 62099 | {
| 62148 | ERRWRAP2(retval = _self_->performSegmentCpu(src, ifDraw)); |  | 62100 | ERRWRAP2(retval = _self_->performSegmentCpu(src, ifDraw));
| 62149 | return pyopencv_from(retval); |  | 62101 | return pyopencv_from(retval);
| 62150 | } |  | 62102 | }
| 62151 |  |  | 62103 |
| 62152 |  |  | 62104 |
| 62153 | pyPopulateArgumentConversionErrors(); |  | 62105 | pyPopulateArgumentConversionErrors();
| 62154 | } |  | 62106 | }
| 62155 |  |  | 62107 |
| 62156 |  |  | 62108 |
| 62157 | { |  | 62109 | {
| 62158 | PyObject* pyobj_src = NULL; |  | 62110 | PyObject* pyobj_src = NULL;
| 62159 | UMat src; |  | 62111 | UMat src;
| 62160 | PyObject* pyobj_ifDraw = NULL; |  | 62112 | PyObject* pyobj_ifDraw = NULL;
| 62161 | bool ifDraw=true; |  | 62113 | bool ifDraw=true;
| 62162 | Mat retval; |  | 62114 | Mat retval;
| 62163 |  |  | 62115 |
| 62164 | const char* keywords[] = { "src", "ifDraw", NULL }; |  | 62116 | const char* keywords[] = { "src", "ifDraw", NULL };
| 62165 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentCpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) && |  | 62117 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentCpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) &&
| 62166 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 62118 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 62167 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) ) |  | 62119 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) )
| 62168 | { |  | 62120 | {
| 62169 | ERRWRAP2(retval = _self_->performSegmentCpu(src, ifDraw)); |  | 62121 | ERRWRAP2(retval = _self_->performSegmentCpu(src, ifDraw));
| 62170 | return pyopencv_from(retval); |  | 62122 | return pyopencv_from(retval);
| 62171 | } |  | 62123 | }
| 62172 |  |  | 62124 |
| 62173 |  |  | 62125 |
| 62174 | pyPopulateArgumentConversionErrors(); |  | 62126 | pyPopulateArgumentConversionErrors();
| 62175 | } |  | 62127 | }
| 62176 | pyRaiseCVOverloadException("performSegmentCpu"); |  | 62128 | pyRaiseCVOverloadException("performSegmentCpu");
| 62177 |  |  | 62129 |
| 62178 | return NULL; |  | 62130 | return NULL;
| 62179 | } |  | 62131 | }
| 62180 |  |  | 62132 |
| 62181 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_performSegmentGpu(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62133 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_performSegmentGpu(PyObject* self, PyObject* py_args, PyObject* kw)
| 62182 | { |  | 62134 | {
| 62183 | using namespace cv::hfs; |  | 62135 | using namespace cv::hfs;
| 62184 |  |  | 62136 |
| 62185 |  |  | 62137 |
| 62186 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62138 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62187 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62139 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62188 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62140 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62189 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62141 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62190 | pyPrepareArgumentConversionErrorsStorage(2); |  | 62142 | pyPrepareArgumentConversionErrorsStorage(2);
| 62191 |  |  | 62143 |
| 62192 | { |  | 62144 | {
| 62193 | PyObject* pyobj_src = NULL; |  | 62145 | PyObject* pyobj_src = NULL;
| 62194 | Mat src; |  | 62146 | Mat src;
| 62195 | PyObject* pyobj_ifDraw = NULL; |  | 62147 | PyObject* pyobj_ifDraw = NULL;
| 62196 | bool ifDraw=true; |  | 62148 | bool ifDraw=true;
| 62197 | Mat retval; |  | 62149 | Mat retval;
| 62198 |  |  | 62150 |
| 62199 | const char* keywords[] = { "src", "ifDraw", NULL }; |  | 62151 | const char* keywords[] = { "src", "ifDraw", NULL };
| 62200 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentGpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) && |  | 62152 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentGpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) &&
| 62201 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 62153 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 62202 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) ) |  | 62154 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) )
| 62203 | { |  | 62155 | {
| 62204 | ERRWRAP2(retval = _self_->performSegmentGpu(src, ifDraw)); |  | 62156 | ERRWRAP2(retval = _self_->performSegmentGpu(src, ifDraw));
| 62205 | return pyopencv_from(retval); |  | 62157 | return pyopencv_from(retval);
| 62206 | } |  | 62158 | }
| 62207 |  |  | 62159 |
| 62208 |  |  | 62160 |
| 62209 | pyPopulateArgumentConversionErrors(); |  | 62161 | pyPopulateArgumentConversionErrors();
| 62210 | } |  | 62162 | }
| 62211 |  |  | 62163 |
| 62212 |  |  | 62164 |
| 62213 | { |  | 62165 | {
| 62214 | PyObject* pyobj_src = NULL; |  | 62166 | PyObject* pyobj_src = NULL;
| 62215 | UMat src; |  | 62167 | UMat src;
| 62216 | PyObject* pyobj_ifDraw = NULL; |  | 62168 | PyObject* pyobj_ifDraw = NULL;
| 62217 | bool ifDraw=true; |  | 62169 | bool ifDraw=true;
| 62218 | Mat retval; |  | 62170 | Mat retval;
| 62219 |  |  | 62171 |
| 62220 | const char* keywords[] = { "src", "ifDraw", NULL }; |  | 62172 | const char* keywords[] = { "src", "ifDraw", NULL };
| 62221 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentGpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) && |  | 62173 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:hfs_HfsSegment.performSegmentGpu", (char**)keywords, &pyobj_src, &pyobj_ifDraw) &&
| 62222 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 62174 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 62223 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) ) |  | 62175 | pyopencv_to_safe(pyobj_ifDraw, ifDraw, ArgInfo("ifDraw", 0)) )
| 62224 | { |  | 62176 | {
| 62225 | ERRWRAP2(retval = _self_->performSegmentGpu(src, ifDraw)); |  | 62177 | ERRWRAP2(retval = _self_->performSegmentGpu(src, ifDraw));
| 62226 | return pyopencv_from(retval); |  | 62178 | return pyopencv_from(retval);
| 62227 | } |  | 62179 | }
| 62228 |  |  | 62180 |
| 62229 |  |  | 62181 |
| 62230 | pyPopulateArgumentConversionErrors(); |  | 62182 | pyPopulateArgumentConversionErrors();
| 62231 | } |  | 62183 | }
| 62232 | pyRaiseCVOverloadException("performSegmentGpu"); |  | 62184 | pyRaiseCVOverloadException("performSegmentGpu");
| 62233 |  |  | 62185 |
| 62234 | return NULL; |  | 62186 | return NULL;
| 62235 | } |  | 62187 | }
| 62236 |  |  | 62188 |
| 62237 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeI(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62189 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeI(PyObject* self, PyObject* py_args, PyObject* kw)
| 62238 | { |  | 62190 | {
| 62239 | using namespace cv::hfs; |  | 62191 | using namespace cv::hfs;
| 62240 |  |  | 62192 |
| 62241 |  |  | 62193 |
| 62242 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62194 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62243 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62195 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62244 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62196 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62245 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62197 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62246 | PyObject* pyobj_n = NULL; |  | 62198 | PyObject* pyobj_n = NULL;
| 62247 | int n=0; |  | 62199 | int n=0;
| 62248 |  |  | 62200 |
| 62249 | const char* keywords[] = { "n", NULL }; |  | 62201 | const char* keywords[] = { "n", NULL };
| 62250 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setMinRegionSizeI", (char**)keywords, &pyobj_n) && |  | 62202 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setMinRegionSizeI", (char**)keywords, &pyobj_n) &&
| 62251 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) ) |  | 62203 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) )
| 62252 | { |  | 62204 | {
| 62253 | ERRWRAP2(_self_->setMinRegionSizeI(n)); |  | 62205 | ERRWRAP2(_self_->setMinRegionSizeI(n));
| 62254 | Py_RETURN_NONE; |  | 62206 | Py_RETURN_NONE;
| 62255 | } |  | 62207 | }
| 62256 |  |  | 62208 |
| 62257 | return NULL; |  | 62209 | return NULL;
| 62258 | } |  | 62210 | }
| 62259 |  |  | 62211 |
| 62260 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeII(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62212 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeII(PyObject* self, PyObject* py_args, PyObject* kw)
| 62261 | { |  | 62213 | {
| 62262 | using namespace cv::hfs; |  | 62214 | using namespace cv::hfs;
| 62263 |  |  | 62215 |
| 62264 |  |  | 62216 |
| 62265 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62217 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62266 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62218 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62267 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62219 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62268 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62220 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62269 | PyObject* pyobj_n = NULL; |  | 62221 | PyObject* pyobj_n = NULL;
| 62270 | int n=0; |  | 62222 | int n=0;
| 62271 |  |  | 62223 |
| 62272 | const char* keywords[] = { "n", NULL }; |  | 62224 | const char* keywords[] = { "n", NULL };
| 62273 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setMinRegionSizeII", (char**)keywords, &pyobj_n) && |  | 62225 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setMinRegionSizeII", (char**)keywords, &pyobj_n) &&
| 62274 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) ) |  | 62226 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) )
| 62275 | { |  | 62227 | {
| 62276 | ERRWRAP2(_self_->setMinRegionSizeII(n)); |  | 62228 | ERRWRAP2(_self_->setMinRegionSizeII(n));
| 62277 | Py_RETURN_NONE; |  | 62229 | Py_RETURN_NONE;
| 62278 | } |  | 62230 | }
| 62279 |  |  | 62231 |
| 62280 | return NULL; |  | 62232 | return NULL;
| 62281 | } |  | 62233 | }
| 62282 |  |  | 62234 |
| 62283 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setNumSlicIter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62235 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setNumSlicIter(PyObject* self, PyObject* py_args, PyObject* kw)
| 62284 | { |  | 62236 | {
| 62285 | using namespace cv::hfs; |  | 62237 | using namespace cv::hfs;
| 62286 |  |  | 62238 |
| 62287 |  |  | 62239 |
| 62288 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62240 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62289 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62241 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62290 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62242 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62291 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62243 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62292 | PyObject* pyobj_n = NULL; |  | 62244 | PyObject* pyobj_n = NULL;
| 62293 | int n=0; |  | 62245 | int n=0;
| 62294 |  |  | 62246 |
| 62295 | const char* keywords[] = { "n", NULL }; |  | 62247 | const char* keywords[] = { "n", NULL };
| 62296 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setNumSlicIter", (char**)keywords, &pyobj_n) && |  | 62248 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setNumSlicIter", (char**)keywords, &pyobj_n) &&
| 62297 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) ) |  | 62249 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) )
| 62298 | { |  | 62250 | {
| 62299 | ERRWRAP2(_self_->setNumSlicIter(n)); |  | 62251 | ERRWRAP2(_self_->setNumSlicIter(n));
| 62300 | Py_RETURN_NONE; |  | 62252 | Py_RETURN_NONE;
| 62301 | } |  | 62253 | }
| 62302 |  |  | 62254 |
| 62303 | return NULL; |  | 62255 | return NULL;
| 62304 | } |  | 62256 | }
| 62305 |  |  | 62257 |
| 62306 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdI(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62258 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdI(PyObject* self, PyObject* py_args, PyObject* kw)
| 62307 | { |  | 62259 | {
| 62308 | using namespace cv::hfs; |  | 62260 | using namespace cv::hfs;
| 62309 |  |  | 62261 |
| 62310 |  |  | 62262 |
| 62311 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62263 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62312 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62264 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62313 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62265 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62314 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62266 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62315 | PyObject* pyobj_c = NULL; |  | 62267 | PyObject* pyobj_c = NULL;
| 62316 | float c=0.f; |  | 62268 | float c=0.f;
| 62317 |  |  | 62269 |
| 62318 | const char* keywords[] = { "c", NULL }; |  | 62270 | const char* keywords[] = { "c", NULL };
| 62319 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSegEgbThresholdI", (char**)keywords, &pyobj_c) && |  | 62271 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSegEgbThresholdI", (char**)keywords, &pyobj_c) &&
| 62320 | pyopencv_to_safe(pyobj_c, c, ArgInfo("c", 0)) ) |  | 62272 | pyopencv_to_safe(pyobj_c, c, ArgInfo("c", 0)) )
| 62321 | { |  | 62273 | {
| 62322 | ERRWRAP2(_self_->setSegEgbThresholdI(c)); |  | 62274 | ERRWRAP2(_self_->setSegEgbThresholdI(c));
| 62323 | Py_RETURN_NONE; |  | 62275 | Py_RETURN_NONE;
| 62324 | } |  | 62276 | }
| 62325 |  |  | 62277 |
| 62326 | return NULL; |  | 62278 | return NULL;
| 62327 | } |  | 62279 | }
| 62328 |  |  | 62280 |
| 62329 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdII(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62281 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdII(PyObject* self, PyObject* py_args, PyObject* kw)
| 62330 | { |  | 62282 | {
| 62331 | using namespace cv::hfs; |  | 62283 | using namespace cv::hfs;
| 62332 |  |  | 62284 |
| 62333 |  |  | 62285 |
| 62334 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62286 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62335 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62287 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62336 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62288 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62337 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62289 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62338 | PyObject* pyobj_c = NULL; |  | 62290 | PyObject* pyobj_c = NULL;
| 62339 | float c=0.f; |  | 62291 | float c=0.f;
| 62340 |  |  | 62292 |
| 62341 | const char* keywords[] = { "c", NULL }; |  | 62293 | const char* keywords[] = { "c", NULL };
| 62342 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSegEgbThresholdII", (char**)keywords, &pyobj_c) && |  | 62294 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSegEgbThresholdII", (char**)keywords, &pyobj_c) &&
| 62343 | pyopencv_to_safe(pyobj_c, c, ArgInfo("c", 0)) ) |  | 62295 | pyopencv_to_safe(pyobj_c, c, ArgInfo("c", 0)) )
| 62344 | { |  | 62296 | {
| 62345 | ERRWRAP2(_self_->setSegEgbThresholdII(c)); |  | 62297 | ERRWRAP2(_self_->setSegEgbThresholdII(c));
| 62346 | Py_RETURN_NONE; |  | 62298 | Py_RETURN_NONE;
| 62347 | } |  | 62299 | }
| 62348 |  |  | 62300 |
| 62349 | return NULL; |  | 62301 | return NULL;
| 62350 | } |  | 62302 | }
| 62351 |  |  | 62303 |
| 62352 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSlicSpixelSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62304 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSlicSpixelSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 62353 | { |  | 62305 | {
| 62354 | using namespace cv::hfs; |  | 62306 | using namespace cv::hfs;
| 62355 |  |  | 62307 |
| 62356 |  |  | 62308 |
| 62357 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62309 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62358 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62310 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62359 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62311 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62360 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62312 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62361 | PyObject* pyobj_n = NULL; |  | 62313 | PyObject* pyobj_n = NULL;
| 62362 | int n=0; |  | 62314 | int n=0;
| 62363 |  |  | 62315 |
| 62364 | const char* keywords[] = { "n", NULL }; |  | 62316 | const char* keywords[] = { "n", NULL };
| 62365 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSlicSpixelSize", (char**)keywords, &pyobj_n) && |  | 62317 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSlicSpixelSize", (char**)keywords, &pyobj_n) &&
| 62366 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) ) |  | 62318 | pyopencv_to_safe(pyobj_n, n, ArgInfo("n", 0)) )
| 62367 | { |  | 62319 | {
| 62368 | ERRWRAP2(_self_->setSlicSpixelSize(n)); |  | 62320 | ERRWRAP2(_self_->setSlicSpixelSize(n));
| 62369 | Py_RETURN_NONE; |  | 62321 | Py_RETURN_NONE;
| 62370 | } |  | 62322 | }
| 62371 |  |  | 62323 |
| 62372 | return NULL; |  | 62324 | return NULL;
| 62373 | } |  | 62325 | }
| 62374 |  |  | 62326 |
| 62375 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSpatialWeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62327 | static PyObject* pyopencv_cv_hfs_hfs_HfsSegment_setSpatialWeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 62376 | { |  | 62328 | {
| 62377 | using namespace cv::hfs; |  | 62329 | using namespace cv::hfs;
| 62378 |  |  | 62330 |
| 62379 |  |  | 62331 |
| 62380 | Ptr<cv::hfs::HfsSegment> * self1 = 0; |  | 62332 | Ptr<cv::hfs::HfsSegment> * self1 = 0;
| 62381 | if (!pyopencv_hfs_HfsSegment_getp(self, self1)) |  | 62333 | if (!pyopencv_hfs_HfsSegment_getp(self, self1))
| 62382 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)"); |  | 62334 | return failmsgp("Incorrect type of self (must be 'hfs_HfsSegment' or its derivative)");
| 62383 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1); |  | 62335 | Ptr<cv::hfs::HfsSegment> _self_ = *(self1);
| 62384 | PyObject* pyobj_w = NULL; |  | 62336 | PyObject* pyobj_w = NULL;
| 62385 | float w=0.f; |  | 62337 | float w=0.f;
| 62386 |  |  | 62338 |
| 62387 | const char* keywords[] = { "w", NULL }; |  | 62339 | const char* keywords[] = { "w", NULL };
| 62388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSpatialWeight", (char**)keywords, &pyobj_w) && |  | 62340 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:hfs_HfsSegment.setSpatialWeight", (char**)keywords, &pyobj_w) &&
| 62389 | pyopencv_to_safe(pyobj_w, w, ArgInfo("w", 0)) ) |  | 62341 | pyopencv_to_safe(pyobj_w, w, ArgInfo("w", 0)) )
| 62390 | { |  | 62342 | {
| 62391 | ERRWRAP2(_self_->setSpatialWeight(w)); |  | 62343 | ERRWRAP2(_self_->setSpatialWeight(w));
| 62392 | Py_RETURN_NONE; |  | 62344 | Py_RETURN_NONE;
| 62393 | } |  | 62345 | }
| 62394 |  |  | 62346 |
| 62395 | return NULL; |  | 62347 | return NULL;
| 62396 | } |  | 62348 | }
| 62397 |  |  | 62349 |
| 62398 |  |  | 62350 |
| 62399 |  |  | 62351 |
| 62400 | // Tables (hfs_HfsSegment) |  | 62352 | // Tables (hfs_HfsSegment)
| 62401 |  |  | 62353 |
| 62402 | static PyGetSetDef pyopencv_hfs_HfsSegment_getseters[] = |  | 62354 | static PyGetSetDef pyopencv_hfs_HfsSegment_getseters[] =
| 62403 | { |  | 62355 | {
| 62404 | {NULL} /* Sentinel */ |  | 62356 | {NULL} /* Sentinel */
| 62405 | }; |  | 62357 | };
| 62406 |  |  | 62358 |
| 62407 | static PyMethodDef pyopencv_hfs_HfsSegment_methods[] = |  | 62359 | static PyMethodDef pyopencv_hfs_HfsSegment_methods[] =
| 62408 | { |  | 62360 | {
| 62409 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_create_static, METH_STATIC), "create(height, width[, segEgbThresholdI[, minRegionSizeI[, segEgbThresholdII[, minRegionSizeII[, spatialWeight[, slicSpixelSize[, numSlicIter]]]]]]]) -> retval\n. @brief: create a hfs object\n. * @param height: the height of the input image\n. * @param width: the width of the input image\n. * @param segEgbThresholdI: parameter segEgbThresholdI\n. * @param minRegionSizeI: parameter minRegionSizeI\n. * @param segEgbThresholdII: parameter segEgbThresholdII\n. * @param minRegionSizeII: parameter minRegionSizeII\n. * @param spatialWeight: parameter spatialWeight\n. * @param slicSpixelSize: parameter slicSpixelSize\n. * @param numSlicIter: parameter numSlicIter"}, |  | 62361 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_create_static, METH_STATIC), "create(height, width[, segEgbThresholdI[, minRegionSizeI[, segEgbThresholdII[, minRegionSizeII[, spatialWeight[, slicSpixelSize[, numSlicIter]]]]]]]) -> retval\n. @brief: create a hfs object\n. * @param height: the height of the input image\n. * @param width: the width of the input image\n. * @param segEgbThresholdI: parameter segEgbThresholdI\n. * @param minRegionSizeI: parameter minRegionSizeI\n. * @param segEgbThresholdII: parameter segEgbThresholdII\n. * @param minRegionSizeII: parameter minRegionSizeII\n. * @param spatialWeight: parameter spatialWeight\n. * @param slicSpixelSize: parameter slicSpixelSize\n. * @param numSlicIter: parameter numSlicIter"},
| 62410 | {"getMinRegionSizeI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeI, 0), "getMinRegionSizeI() -> retval\n."}, |  | 62362 | {"getMinRegionSizeI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeI, 0), "getMinRegionSizeI() -> retval\n."},
| 62411 | {"getMinRegionSizeII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeII, 0), "getMinRegionSizeII() -> retval\n."}, |  | 62363 | {"getMinRegionSizeII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getMinRegionSizeII, 0), "getMinRegionSizeII() -> retval\n."},
| 62412 | {"getNumSlicIter", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getNumSlicIter, 0), "getNumSlicIter() -> retval\n."}, |  | 62364 | {"getNumSlicIter", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getNumSlicIter, 0), "getNumSlicIter() -> retval\n."},
| 62413 | {"getSegEgbThresholdI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdI, 0), "getSegEgbThresholdI() -> retval\n."}, |  | 62365 | {"getSegEgbThresholdI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdI, 0), "getSegEgbThresholdI() -> retval\n."},
| 62414 | {"getSegEgbThresholdII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdII, 0), "getSegEgbThresholdII() -> retval\n."}, |  | 62366 | {"getSegEgbThresholdII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSegEgbThresholdII, 0), "getSegEgbThresholdII() -> retval\n."},
| 62415 | {"getSlicSpixelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSlicSpixelSize, 0), "getSlicSpixelSize() -> retval\n."}, |  | 62367 | {"getSlicSpixelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSlicSpixelSize, 0), "getSlicSpixelSize() -> retval\n."},
| 62416 | {"getSpatialWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSpatialWeight, 0), "getSpatialWeight() -> retval\n."}, |  | 62368 | {"getSpatialWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_getSpatialWeight, 0), "getSpatialWeight() -> retval\n."},
| 62417 | {"performSegmentCpu", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_performSegmentCpu, 0), "performSegmentCpu(src[, ifDraw]) -> retval\n. @brief do segmentation with cpu\n. * This method is only implemented for reference.\n. * It is highly NOT recommanded to use it."}, |  | 62369 | {"performSegmentCpu", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_performSegmentCpu, 0), "performSegmentCpu(src[, ifDraw]) -> retval\n. @brief do segmentation with cpu\n. * This method is only implemented for reference.\n. * It is highly NOT recommanded to use it."},
| 62418 | {"performSegmentGpu", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_performSegmentGpu, 0), "performSegmentGpu(src[, ifDraw]) -> retval\n. @brief do segmentation gpu\n. * @param src: the input image\n. * @param ifDraw: if draw the image in the returned Mat. if this parameter is false,\n. * then the content of the returned Mat is a matrix of index, describing the region\n. * each pixel belongs to. And it's data type is CV_16U. If this parameter is true,\n. * then the returned Mat is a segmented picture, and color of each region is the\n. * average color of all pixels in that region. And it's data type is the same as\n. * the input image"}, |  | 62370 | {"performSegmentGpu", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_performSegmentGpu, 0), "performSegmentGpu(src[, ifDraw]) -> retval\n. @brief do segmentation gpu\n. * @param src: the input image\n. * @param ifDraw: if draw the image in the returned Mat. if this parameter is false,\n. * then the content of the returned Mat is a matrix of index, describing the region\n. * each pixel belongs to. And it's data type is CV_16U. If this parameter is true,\n. * then the returned Mat is a segmented picture, and color of each region is the\n. * average color of all pixels in that region. And it's data type is the same as\n. * the input image"},
| 62419 | {"setMinRegionSizeI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeI, 0), "setMinRegionSizeI(n) -> None\n. @brief: set and get the parameter minRegionSizeI.\n. * This parameter is used in the second stage\n. * mentioned above. After the EGB segmentation, regions that have fewer\n. * pixels then this parameter will be merged into it's adjacent region."}, |  | 62371 | {"setMinRegionSizeI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeI, 0), "setMinRegionSizeI(n) -> None\n. @brief: set and get the parameter minRegionSizeI.\n. * This parameter is used in the second stage\n. * mentioned above. After the EGB segmentation, regions that have fewer\n. * pixels then this parameter will be merged into it's adjacent region."},
| 62420 | {"setMinRegionSizeII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeII, 0), "setMinRegionSizeII(n) -> None\n. @brief: set and get the parameter minRegionSizeII.\n. * This parameter is used in the third stage\n. * mentioned above. It serves the same purpose as minRegionSizeI"}, |  | 62372 | {"setMinRegionSizeII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setMinRegionSizeII, 0), "setMinRegionSizeII(n) -> None\n. @brief: set and get the parameter minRegionSizeII.\n. * This parameter is used in the third stage\n. * mentioned above. It serves the same purpose as minRegionSizeI"},
| 62421 | {"setNumSlicIter", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setNumSlicIter, 0), "setNumSlicIter(n) -> None\n. @brief: set and get the parameter numSlicIter.\n. * This parameter is used in the first stage. It\n. * describes how many iteration to perform when executing SLIC."}, |  | 62373 | {"setNumSlicIter", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setNumSlicIter, 0), "setNumSlicIter(n) -> None\n. @brief: set and get the parameter numSlicIter.\n. * This parameter is used in the first stage. It\n. * describes how many iteration to perform when executing SLIC."},
| 62422 | {"setSegEgbThresholdI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdI, 0), "setSegEgbThresholdI(c) -> None\n. @brief: set and get the parameter segEgbThresholdI.\n. * This parameter is used in the second stage mentioned above.\n. * It is a constant used to threshold weights of the edge when merging\n. * adjacent nodes when applying EGB algorithm. The segmentation result\n. * tends to have more regions remained if this value is large and vice versa."}, |  | 62374 | {"setSegEgbThresholdI", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdI, 0), "setSegEgbThresholdI(c) -> None\n. @brief: set and get the parameter segEgbThresholdI.\n. * This parameter is used in the second stage mentioned above.\n. * It is a constant used to threshold weights of the edge when merging\n. * adjacent nodes when applying EGB algorithm. The segmentation result\n. * tends to have more regions remained if this value is large and vice versa."},
| 62423 | {"setSegEgbThresholdII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdII, 0), "setSegEgbThresholdII(c) -> None\n. @brief: set and get the parameter segEgbThresholdII.\n. * This parameter is used in the third stage\n. * mentioned above. It serves the same purpose as segEgbThresholdI.\n. * The segmentation result tends to have more regions remained if\n. * this value is large and vice versa."}, |  | 62375 | {"setSegEgbThresholdII", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSegEgbThresholdII, 0), "setSegEgbThresholdII(c) -> None\n. @brief: set and get the parameter segEgbThresholdII.\n. * This parameter is used in the third stage\n. * mentioned above. It serves the same purpose as segEgbThresholdI.\n. * The segmentation result tends to have more regions remained if\n. * this value is large and vice versa."},
| 62424 | {"setSlicSpixelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSlicSpixelSize, 0), "setSlicSpixelSize(n) -> None\n. @brief: set and get the parameter slicSpixelSize.\n. * This parameter is used in the first stage mentioned\n. * above(the SLIC stage). It describes the size of each\n. * superpixel when initializing SLIC. Every superpixel\n. * approximately has \\f$slicSpixelSize \\times slicSpixelSize\\f$\n. * pixels in the beginning."}, |  | 62376 | {"setSlicSpixelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSlicSpixelSize, 0), "setSlicSpixelSize(n) -> None\n. @brief: set and get the parameter slicSpixelSize.\n. * This parameter is used in the first stage mentioned\n. * above(the SLIC stage). It describes the size of each\n. * superpixel when initializing SLIC. Every superpixel\n. * approximately has \\f$slicSpixelSize \\times slicSpixelSize\\f$\n. * pixels in the beginning."},
| 62425 | {"setSpatialWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSpatialWeight, 0), "setSpatialWeight(w) -> None\n. @brief: set and get the parameter spatialWeight.\n. * This parameter is used in the first stage\n. * mentioned above(the SLIC stage). It describes how important is the role\n. * of position when calculating the distance between each pixel and it's\n. * center. The exact formula to calculate the distance is\n. * \\f$colorDistance + spatialWeight \\times spatialDistance\\f$.\n. * The segmentation result tends to have more local consistency\n. * if this value is larger."}, |  | 62377 | {"setSpatialWeight", CV_PY_FN_WITH_KW_(pyopencv_cv_hfs_hfs_HfsSegment_setSpatialWeight, 0), "setSpatialWeight(w) -> None\n. @brief: set and get the parameter spatialWeight.\n. * This parameter is used in the first stage\n. * mentioned above(the SLIC stage). It describes how important is the role\n. * of position when calculating the distance between each pixel and it's\n. * center. The exact formula to calculate the distance is\n. * \\f$colorDistance + spatialWeight \\times spatialDistance\\f$.\n. * The segmentation result tends to have more local consistency\n. * if this value is larger."},
| 62426 |  |  | 62378 |
| 62427 | {NULL, NULL} |  | 62379 | {NULL, NULL}
| 62428 | }; |  | 62380 | };
| 62429 |  |  | 62381 |
| 62430 | // Converter (hfs_HfsSegment) |  | 62382 | // Converter (hfs_HfsSegment)
| 62431 |  |  | 62383 |
| 62432 | template<> |  | 62384 | template<>
| 62433 | struct PyOpenCV_Converter< Ptr<cv::hfs::HfsSegment> > |  | 62385 | struct PyOpenCV_Converter< Ptr<cv::hfs::HfsSegment> >
| 62434 | { |  | 62386 | {
| 62435 | static PyObject* from(const Ptr<cv::hfs::HfsSegment>& r) |  | 62387 | static PyObject* from(const Ptr<cv::hfs::HfsSegment>& r)
| 62436 | { |  | 62388 | {
| 62437 | return pyopencv_hfs_HfsSegment_Instance(r); |  | 62389 | return pyopencv_hfs_HfsSegment_Instance(r);
| 62438 | } |  | 62390 | }
| 62439 | static bool to(PyObject* src, Ptr<cv::hfs::HfsSegment>& dst, const ArgInfo& info) |  | 62391 | static bool to(PyObject* src, Ptr<cv::hfs::HfsSegment>& dst, const ArgInfo& info)
| 62440 | { |  | 62392 | {
| 62441 | if(!src || src == Py_None) |  | 62393 | if(!src || src == Py_None)
| 62442 | return true; |  | 62394 | return true;
| 62443 | Ptr<cv::hfs::HfsSegment> * dst_; |  | 62395 | Ptr<cv::hfs::HfsSegment> * dst_;
| 62444 | if (pyopencv_hfs_HfsSegment_getp(src, dst_)) |  | 62396 | if (pyopencv_hfs_HfsSegment_getp(src, dst_))
| 62445 | { |  | 62397 | {
| 62446 | dst = *dst_; |  | 62398 | dst = *dst_;
| 62447 | return true; |  | 62399 | return true;
| 62448 | } |  | 62400 | }
| 62449 |  |  | 62401 |
| 62450 | failmsg("Expected Ptr<cv::hfs::HfsSegment> for argument '%s'", info.name); |  | 62402 | failmsg("Expected Ptr<cv::hfs::HfsSegment> for argument '%s'", info.name);
| 62451 | return false; |  | 62403 | return false;
| 62452 | } |  | 62404 | }
| 62453 | }; |  | 62405 | };
| 62454 |  |  | 62406 |
| 62455 | //================================================================================ |  | 62407 | //================================================================================
| 62456 | // img_hash_AverageHash (Generic) |  | 62408 | // img_hash_AverageHash (Generic)
| 62457 | //================================================================================ |  | 62409 | //================================================================================
| 62458 |  |  | 62410 |
| 62459 | // GetSet (img_hash_AverageHash) |  | 62411 | // GetSet (img_hash_AverageHash)
| 62460 |  |  | 62412 |
| 62461 |  |  | 62413 |
| 62462 |  |  | 62414 |
| 62463 | // Methods (img_hash_AverageHash) |  | 62415 | // Methods (img_hash_AverageHash)
| 62464 |  |  | 62416 |
| 62465 | static PyObject* pyopencv_cv_img_hash_img_hash_AverageHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62417 | static PyObject* pyopencv_cv_img_hash_img_hash_AverageHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 62466 | { |  | 62418 | {
| 62467 | using namespace cv::img_hash; |  | 62419 | using namespace cv::img_hash;
| 62468 |  |  | 62420 |
| 62469 | Ptr<AverageHash> retval; |  | 62421 | Ptr<AverageHash> retval;
| 62470 |  |  | 62422 |
| 62471 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62423 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62472 | { |  | 62424 | {
| 62473 | ERRWRAP2(retval = cv::img_hash::AverageHash::create()); |  | 62425 | ERRWRAP2(retval = cv::img_hash::AverageHash::create());
| 62474 | return pyopencv_from(retval); |  | 62426 | return pyopencv_from(retval);
| 62475 | } |  | 62427 | }
| 62476 |  |  | 62428 |
| 62477 | return NULL; |  | 62429 | return NULL;
| 62478 | } |  | 62430 | }
| 62479 |  |  | 62431 |
| 62480 |  |  | 62432 |
| 62481 |  |  | 62433 |
| 62482 | // Tables (img_hash_AverageHash) |  | 62434 | // Tables (img_hash_AverageHash)
| 62483 |  |  | 62435 |
| 62484 | static PyGetSetDef pyopencv_img_hash_AverageHash_getseters[] = |  | 62436 | static PyGetSetDef pyopencv_img_hash_AverageHash_getseters[] =
| 62485 | { |  | 62437 | {
| 62486 | {NULL} /* Sentinel */ |  | 62438 | {NULL} /* Sentinel */
| 62487 | }; |  | 62439 | };
| 62488 |  |  | 62440 |
| 62489 | static PyMethodDef pyopencv_img_hash_AverageHash_methods[] = |  | 62441 | static PyMethodDef pyopencv_img_hash_AverageHash_methods[] =
| 62490 | { |  | 62442 | {
| 62491 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_AverageHash_create_static, METH_STATIC), "create() -> retval\n."}, |  | 62443 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_AverageHash_create_static, METH_STATIC), "create() -> retval\n."},
| 62492 |  |  | 62444 |
| 62493 | {NULL, NULL} |  | 62445 | {NULL, NULL}
| 62494 | }; |  | 62446 | };
| 62495 |  |  | 62447 |
| 62496 | // Converter (img_hash_AverageHash) |  | 62448 | // Converter (img_hash_AverageHash)
| 62497 |  |  | 62449 |
| 62498 | template<> |  | 62450 | template<>
| 62499 | struct PyOpenCV_Converter< Ptr<cv::img_hash::AverageHash> > |  | 62451 | struct PyOpenCV_Converter< Ptr<cv::img_hash::AverageHash> >
| 62500 | { |  | 62452 | {
| 62501 | static PyObject* from(const Ptr<cv::img_hash::AverageHash>& r) |  | 62453 | static PyObject* from(const Ptr<cv::img_hash::AverageHash>& r)
| 62502 | { |  | 62454 | {
| 62503 | return pyopencv_img_hash_AverageHash_Instance(r); |  | 62455 | return pyopencv_img_hash_AverageHash_Instance(r);
| 62504 | } |  | 62456 | }
| 62505 | static bool to(PyObject* src, Ptr<cv::img_hash::AverageHash>& dst, const ArgInfo& info) |  | 62457 | static bool to(PyObject* src, Ptr<cv::img_hash::AverageHash>& dst, const ArgInfo& info)
| 62506 | { |  | 62458 | {
| 62507 | if(!src || src == Py_None) |  | 62459 | if(!src || src == Py_None)
| 62508 | return true; |  | 62460 | return true;
| 62509 | Ptr<cv::img_hash::AverageHash> * dst_; |  | 62461 | Ptr<cv::img_hash::AverageHash> * dst_;
| 62510 | if (pyopencv_img_hash_AverageHash_getp(src, dst_)) |  | 62462 | if (pyopencv_img_hash_AverageHash_getp(src, dst_))
| 62511 | { |  | 62463 | {
| 62512 | dst = *dst_; |  | 62464 | dst = *dst_;
| 62513 | return true; |  | 62465 | return true;
| 62514 | } |  | 62466 | }
| 62515 |  |  | 62467 |
| 62516 | failmsg("Expected Ptr<cv::img_hash::AverageHash> for argument '%s'", info.name); |  | 62468 | failmsg("Expected Ptr<cv::img_hash::AverageHash> for argument '%s'", info.name);
| 62517 | return false; |  | 62469 | return false;
| 62518 | } |  | 62470 | }
| 62519 | }; |  | 62471 | };
| 62520 |  |  | 62472 |
| 62521 | //================================================================================ |  | 62473 | //================================================================================
| 62522 | // img_hash_BlockMeanHash (Generic) |  | 62474 | // img_hash_BlockMeanHash (Generic)
| 62523 | //================================================================================ |  | 62475 | //================================================================================
| 62524 |  |  | 62476 |
| 62525 | // GetSet (img_hash_BlockMeanHash) |  | 62477 | // GetSet (img_hash_BlockMeanHash)
| 62526 |  |  | 62478 |
| 62527 |  |  | 62479 |
| 62528 |  |  | 62480 |
| 62529 | // Methods (img_hash_BlockMeanHash) |  | 62481 | // Methods (img_hash_BlockMeanHash)
| 62530 |  |  | 62482 |
| 62531 | static PyObject* pyopencv_cv_img_hash_img_hash_BlockMeanHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62483 | static PyObject* pyopencv_cv_img_hash_img_hash_BlockMeanHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 62532 | { |  | 62484 | {
| 62533 | using namespace cv::img_hash; |  | 62485 | using namespace cv::img_hash;
| 62534 |  |  | 62486 |
| 62535 | PyObject* pyobj_mode = NULL; |  | 62487 | PyObject* pyobj_mode = NULL;
| 62536 | int mode=BLOCK_MEAN_HASH_MODE_0; |  | 62488 | int mode=BLOCK_MEAN_HASH_MODE_0;
| 62537 | Ptr<BlockMeanHash> retval; |  | 62489 | Ptr<BlockMeanHash> retval;
| 62538 |  |  | 62490 |
| 62539 | const char* keywords[] = { "mode", NULL }; |  | 62491 | const char* keywords[] = { "mode", NULL };
| 62540 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:img_hash_BlockMeanHash.create", (char**)keywords, &pyobj_mode) && |  | 62492 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:img_hash_BlockMeanHash.create", (char**)keywords, &pyobj_mode) &&
| 62541 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) ) |  | 62493 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) )
| 62542 | { |  | 62494 | {
| 62543 | ERRWRAP2(retval = cv::img_hash::BlockMeanHash::create(mode)); |  | 62495 | ERRWRAP2(retval = cv::img_hash::BlockMeanHash::create(mode));
| 62544 | return pyopencv_from(retval); |  | 62496 | return pyopencv_from(retval);
| 62545 | } |  | 62497 | }
| 62546 |  |  | 62498 |
| 62547 | return NULL; |  | 62499 | return NULL;
| 62548 | } |  | 62500 | }
| 62549 |  |  | 62501 |
| 62550 | static PyObject* pyopencv_cv_img_hash_img_hash_BlockMeanHash_getMean(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62502 | static PyObject* pyopencv_cv_img_hash_img_hash_BlockMeanHash_getMean(PyObject* self, PyObject* py_args, PyObject* kw)
| 62551 | { |  | 62503 | {
| 62552 | using namespace cv::img_hash; |  | 62504 | using namespace cv::img_hash;
| 62553 |  |  | 62505 |
| 62554 |  |  | 62506 |
| 62555 | Ptr<cv::img_hash::BlockMeanHash> * self1 = 0; |  | 62507 | Ptr<cv::img_hash::BlockMeanHash> * self1 = 0;
| 62556 | if (!pyopencv_img_hash_BlockMeanHash_getp(self, self1)) |  | 62508 | if (!pyopencv_img_hash_BlockMeanHash_getp(self, self1))
| 62557 | return failmsgp("Incorrect type of self (must be 'img_hash_BlockMeanHash' or its derivative)"); |  | 62509 | return failmsgp("Incorrect type of self (must be 'img_hash_BlockMeanHash' or its derivative)");
| 62558 | Ptr<cv::img_hash::BlockMeanHash> _self_ = *(self1); |  | 62510 | Ptr<cv::img_hash::BlockMeanHash> _self_ = *(self1);
| 62559 | std::vector<double> retval; |  | 62511 | std::vector<double> retval;
| 62560 |  |  | 62512 |
| 62561 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62513 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62562 | { |  | 62514 | {
| 62563 | ERRWRAP2(retval = _self_->getMean()); |  | 62515 | ERRWRAP2(retval = _self_->getMean());
| 62564 | return pyopencv_from(retval); |  | 62516 | return pyopencv_from(retval);
| 62565 | } |  | 62517 | }
| 62566 |  |  | 62518 |
| 62567 | return NULL; |  | 62519 | return NULL;
| 62568 | } |  | 62520 | }
| 62569 |  |  | 62521 |
| 62570 | static PyObject* pyopencv_cv_img_hash_img_hash_BlockMeanHash_setMode(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62522 | static PyObject* pyopencv_cv_img_hash_img_hash_BlockMeanHash_setMode(PyObject* self, PyObject* py_args, PyObject* kw)
| 62571 | { |  | 62523 | {
| 62572 | using namespace cv::img_hash; |  | 62524 | using namespace cv::img_hash;
| 62573 |  |  | 62525 |
| 62574 |  |  | 62526 |
| 62575 | Ptr<cv::img_hash::BlockMeanHash> * self1 = 0; |  | 62527 | Ptr<cv::img_hash::BlockMeanHash> * self1 = 0;
| 62576 | if (!pyopencv_img_hash_BlockMeanHash_getp(self, self1)) |  | 62528 | if (!pyopencv_img_hash_BlockMeanHash_getp(self, self1))
| 62577 | return failmsgp("Incorrect type of self (must be 'img_hash_BlockMeanHash' or its derivative)"); |  | 62529 | return failmsgp("Incorrect type of self (must be 'img_hash_BlockMeanHash' or its derivative)");
| 62578 | Ptr<cv::img_hash::BlockMeanHash> _self_ = *(self1); |  | 62530 | Ptr<cv::img_hash::BlockMeanHash> _self_ = *(self1);
| 62579 | PyObject* pyobj_mode = NULL; |  | 62531 | PyObject* pyobj_mode = NULL;
| 62580 | int mode=0; |  | 62532 | int mode=0;
| 62581 |  |  | 62533 |
| 62582 | const char* keywords[] = { "mode", NULL }; |  | 62534 | const char* keywords[] = { "mode", NULL };
| 62583 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:img_hash_BlockMeanHash.setMode", (char**)keywords, &pyobj_mode) && |  | 62535 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:img_hash_BlockMeanHash.setMode", (char**)keywords, &pyobj_mode) &&
| 62584 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) ) |  | 62536 | pyopencv_to_safe(pyobj_mode, mode, ArgInfo("mode", 0)) )
| 62585 | { |  | 62537 | {
| 62586 | ERRWRAP2(_self_->setMode(mode)); |  | 62538 | ERRWRAP2(_self_->setMode(mode));
| 62587 | Py_RETURN_NONE; |  | 62539 | Py_RETURN_NONE;
| 62588 | } |  | 62540 | }
| 62589 |  |  | 62541 |
| 62590 | return NULL; |  | 62542 | return NULL;
| 62591 | } |  | 62543 | }
| 62592 |  |  | 62544 |
| 62593 |  |  | 62545 |
| 62594 |  |  | 62546 |
| 62595 | // Tables (img_hash_BlockMeanHash) |  | 62547 | // Tables (img_hash_BlockMeanHash)
| 62596 |  |  | 62548 |
| 62597 | static PyGetSetDef pyopencv_img_hash_BlockMeanHash_getseters[] = |  | 62549 | static PyGetSetDef pyopencv_img_hash_BlockMeanHash_getseters[] =
| 62598 | { |  | 62550 | {
| 62599 | {NULL} /* Sentinel */ |  | 62551 | {NULL} /* Sentinel */
| 62600 | }; |  | 62552 | };
| 62601 |  |  | 62553 |
| 62602 | static PyMethodDef pyopencv_img_hash_BlockMeanHash_methods[] = |  | 62554 | static PyMethodDef pyopencv_img_hash_BlockMeanHash_methods[] =
| 62603 | { |  | 62555 | {
| 62604 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_BlockMeanHash_create_static, METH_STATIC), "create([, mode]) -> retval\n."}, |  | 62556 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_BlockMeanHash_create_static, METH_STATIC), "create([, mode]) -> retval\n."},
| 62605 | {"getMean", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_BlockMeanHash_getMean, 0), "getMean() -> retval\n."}, |  | 62557 | {"getMean", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_BlockMeanHash_getMean, 0), "getMean() -> retval\n."},
| 62606 | {"setMode", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_BlockMeanHash_setMode, 0), "setMode(mode) -> None\n. @brief Create BlockMeanHash object\n. @param mode the mode"}, |  | 62558 | {"setMode", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_BlockMeanHash_setMode, 0), "setMode(mode) -> None\n. @brief Create BlockMeanHash object\n. @param mode the mode"},
| 62607 |  |  | 62559 |
| 62608 | {NULL, NULL} |  | 62560 | {NULL, NULL}
| 62609 | }; |  | 62561 | };
| 62610 |  |  | 62562 |
| 62611 | // Converter (img_hash_BlockMeanHash) |  | 62563 | // Converter (img_hash_BlockMeanHash)
| 62612 |  |  | 62564 |
| 62613 | template<> |  | 62565 | template<>
| 62614 | struct PyOpenCV_Converter< Ptr<cv::img_hash::BlockMeanHash> > |  | 62566 | struct PyOpenCV_Converter< Ptr<cv::img_hash::BlockMeanHash> >
| 62615 | { |  | 62567 | {
| 62616 | static PyObject* from(const Ptr<cv::img_hash::BlockMeanHash>& r) |  | 62568 | static PyObject* from(const Ptr<cv::img_hash::BlockMeanHash>& r)
| 62617 | { |  | 62569 | {
| 62618 | return pyopencv_img_hash_BlockMeanHash_Instance(r); |  | 62570 | return pyopencv_img_hash_BlockMeanHash_Instance(r);
| 62619 | } |  | 62571 | }
| 62620 | static bool to(PyObject* src, Ptr<cv::img_hash::BlockMeanHash>& dst, const ArgInfo& info) |  | 62572 | static bool to(PyObject* src, Ptr<cv::img_hash::BlockMeanHash>& dst, const ArgInfo& info)
| 62621 | { |  | 62573 | {
| 62622 | if(!src || src == Py_None) |  | 62574 | if(!src || src == Py_None)
| 62623 | return true; |  | 62575 | return true;
| 62624 | Ptr<cv::img_hash::BlockMeanHash> * dst_; |  | 62576 | Ptr<cv::img_hash::BlockMeanHash> * dst_;
| 62625 | if (pyopencv_img_hash_BlockMeanHash_getp(src, dst_)) |  | 62577 | if (pyopencv_img_hash_BlockMeanHash_getp(src, dst_))
| 62626 | { |  | 62578 | {
| 62627 | dst = *dst_; |  | 62579 | dst = *dst_;
| 62628 | return true; |  | 62580 | return true;
| 62629 | } |  | 62581 | }
| 62630 |  |  | 62582 |
| 62631 | failmsg("Expected Ptr<cv::img_hash::BlockMeanHash> for argument '%s'", info.name); |  | 62583 | failmsg("Expected Ptr<cv::img_hash::BlockMeanHash> for argument '%s'", info.name);
| 62632 | return false; |  | 62584 | return false;
| 62633 | } |  | 62585 | }
| 62634 | }; |  | 62586 | };
| 62635 |  |  | 62587 |
| 62636 | //================================================================================ |  | 62588 | //================================================================================
| 62637 | // img_hash_ColorMomentHash (Generic) |  | 62589 | // img_hash_ColorMomentHash (Generic)
| 62638 | //================================================================================ |  | 62590 | //================================================================================
| 62639 |  |  | 62591 |
| 62640 | // GetSet (img_hash_ColorMomentHash) |  | 62592 | // GetSet (img_hash_ColorMomentHash)
| 62641 |  |  | 62593 |
| 62642 |  |  | 62594 |
| 62643 |  |  | 62595 |
| 62644 | // Methods (img_hash_ColorMomentHash) |  | 62596 | // Methods (img_hash_ColorMomentHash)
| 62645 |  |  | 62597 |
| 62646 | static PyObject* pyopencv_cv_img_hash_img_hash_ColorMomentHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62598 | static PyObject* pyopencv_cv_img_hash_img_hash_ColorMomentHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 62647 | { |  | 62599 | {
| 62648 | using namespace cv::img_hash; |  | 62600 | using namespace cv::img_hash;
| 62649 |  |  | 62601 |
| 62650 | Ptr<ColorMomentHash> retval; |  | 62602 | Ptr<ColorMomentHash> retval;
| 62651 |  |  | 62603 |
| 62652 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62604 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62653 | { |  | 62605 | {
| 62654 | ERRWRAP2(retval = cv::img_hash::ColorMomentHash::create()); |  | 62606 | ERRWRAP2(retval = cv::img_hash::ColorMomentHash::create());
| 62655 | return pyopencv_from(retval); |  | 62607 | return pyopencv_from(retval);
| 62656 | } |  | 62608 | }
| 62657 |  |  | 62609 |
| 62658 | return NULL; |  | 62610 | return NULL;
| 62659 | } |  | 62611 | }
| 62660 |  |  | 62612 |
| 62661 |  |  | 62613 |
| 62662 |  |  | 62614 |
| 62663 | // Tables (img_hash_ColorMomentHash) |  | 62615 | // Tables (img_hash_ColorMomentHash)
| 62664 |  |  | 62616 |
| 62665 | static PyGetSetDef pyopencv_img_hash_ColorMomentHash_getseters[] = |  | 62617 | static PyGetSetDef pyopencv_img_hash_ColorMomentHash_getseters[] =
| 62666 | { |  | 62618 | {
| 62667 | {NULL} /* Sentinel */ |  | 62619 | {NULL} /* Sentinel */
| 62668 | }; |  | 62620 | };
| 62669 |  |  | 62621 |
| 62670 | static PyMethodDef pyopencv_img_hash_ColorMomentHash_methods[] = |  | 62622 | static PyMethodDef pyopencv_img_hash_ColorMomentHash_methods[] =
| 62671 | { |  | 62623 | {
| 62672 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_ColorMomentHash_create_static, METH_STATIC), "create() -> retval\n."}, |  | 62624 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_ColorMomentHash_create_static, METH_STATIC), "create() -> retval\n."},
| 62673 |  |  | 62625 |
| 62674 | {NULL, NULL} |  | 62626 | {NULL, NULL}
| 62675 | }; |  | 62627 | };
| 62676 |  |  | 62628 |
| 62677 | // Converter (img_hash_ColorMomentHash) |  | 62629 | // Converter (img_hash_ColorMomentHash)
| 62678 |  |  | 62630 |
| 62679 | template<> |  | 62631 | template<>
| 62680 | struct PyOpenCV_Converter< Ptr<cv::img_hash::ColorMomentHash> > |  | 62632 | struct PyOpenCV_Converter< Ptr<cv::img_hash::ColorMomentHash> >
| 62681 | { |  | 62633 | {
| 62682 | static PyObject* from(const Ptr<cv::img_hash::ColorMomentHash>& r) |  | 62634 | static PyObject* from(const Ptr<cv::img_hash::ColorMomentHash>& r)
| 62683 | { |  | 62635 | {
| 62684 | return pyopencv_img_hash_ColorMomentHash_Instance(r); |  | 62636 | return pyopencv_img_hash_ColorMomentHash_Instance(r);
| 62685 | } |  | 62637 | }
| 62686 | static bool to(PyObject* src, Ptr<cv::img_hash::ColorMomentHash>& dst, const ArgInfo& info) |  | 62638 | static bool to(PyObject* src, Ptr<cv::img_hash::ColorMomentHash>& dst, const ArgInfo& info)
| 62687 | { |  | 62639 | {
| 62688 | if(!src || src == Py_None) |  | 62640 | if(!src || src == Py_None)
| 62689 | return true; |  | 62641 | return true;
| 62690 | Ptr<cv::img_hash::ColorMomentHash> * dst_; |  | 62642 | Ptr<cv::img_hash::ColorMomentHash> * dst_;
| 62691 | if (pyopencv_img_hash_ColorMomentHash_getp(src, dst_)) |  | 62643 | if (pyopencv_img_hash_ColorMomentHash_getp(src, dst_))
| 62692 | { |  | 62644 | {
| 62693 | dst = *dst_; |  | 62645 | dst = *dst_;
| 62694 | return true; |  | 62646 | return true;
| 62695 | } |  | 62647 | }
| 62696 |  |  | 62648 |
| 62697 | failmsg("Expected Ptr<cv::img_hash::ColorMomentHash> for argument '%s'", info.name); |  | 62649 | failmsg("Expected Ptr<cv::img_hash::ColorMomentHash> for argument '%s'", info.name);
| 62698 | return false; |  | 62650 | return false;
| 62699 | } |  | 62651 | }
| 62700 | }; |  | 62652 | };
| 62701 |  |  | 62653 |
| 62702 | //================================================================================ |  | 62654 | //================================================================================
| 62703 | // img_hash_ImgHashBase (Generic) |  | 62655 | // img_hash_ImgHashBase (Generic)
| 62704 | //================================================================================ |  | 62656 | //================================================================================
| 62705 |  |  | 62657 |
| 62706 | // GetSet (img_hash_ImgHashBase) |  | 62658 | // GetSet (img_hash_ImgHashBase)
| 62707 |  |  | 62659 |
| 62708 |  |  | 62660 |
| 62709 |  |  | 62661 |
| 62710 | // Methods (img_hash_ImgHashBase) |  | 62662 | // Methods (img_hash_ImgHashBase)
| 62711 |  |  | 62663 |
| 62712 | static PyObject* pyopencv_cv_img_hash_img_hash_ImgHashBase_compare(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62664 | static PyObject* pyopencv_cv_img_hash_img_hash_ImgHashBase_compare(PyObject* self, PyObject* py_args, PyObject* kw)
| 62713 | { |  | 62665 | {
| 62714 | using namespace cv::img_hash; |  | 62666 | using namespace cv::img_hash;
| 62715 |  |  | 62667 |
| 62716 |  |  | 62668 |
| 62717 | Ptr<cv::img_hash::ImgHashBase> * self1 = 0; |  | 62669 | Ptr<cv::img_hash::ImgHashBase> * self1 = 0;
| 62718 | if (!pyopencv_img_hash_ImgHashBase_getp(self, self1)) |  | 62670 | if (!pyopencv_img_hash_ImgHashBase_getp(self, self1))
| 62719 | return failmsgp("Incorrect type of self (must be 'img_hash_ImgHashBase' or its derivative)"); |  | 62671 | return failmsgp("Incorrect type of self (must be 'img_hash_ImgHashBase' or its derivative)");
| 62720 | Ptr<cv::img_hash::ImgHashBase> _self_ = *(self1); |  | 62672 | Ptr<cv::img_hash::ImgHashBase> _self_ = *(self1);
| 62721 | pyPrepareArgumentConversionErrorsStorage(2); |  | 62673 | pyPrepareArgumentConversionErrorsStorage(2);
| 62722 |  |  | 62674 |
| 62723 | { |  | 62675 | {
| 62724 | PyObject* pyobj_hashOne = NULL; |  | 62676 | PyObject* pyobj_hashOne = NULL;
| 62725 | Mat hashOne; |  | 62677 | Mat hashOne;
| 62726 | PyObject* pyobj_hashTwo = NULL; |  | 62678 | PyObject* pyobj_hashTwo = NULL;
| 62727 | Mat hashTwo; |  | 62679 | Mat hashTwo;
| 62728 | double retval; |  | 62680 | double retval;
| 62729 |  |  | 62681 |
| 62730 | const char* keywords[] = { "hashOne", "hashTwo", NULL }; |  | 62682 | const char* keywords[] = { "hashOne", "hashTwo", NULL };
| 62731 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:img_hash_ImgHashBase.compare", (char**)keywords, &pyobj_hashOne, &pyobj_hashTwo) && |  | 62683 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:img_hash_ImgHashBase.compare", (char**)keywords, &pyobj_hashOne, &pyobj_hashTwo) &&
| 62732 | pyopencv_to_safe(pyobj_hashOne, hashOne, ArgInfo("hashOne", 0)) && |  | 62684 | pyopencv_to_safe(pyobj_hashOne, hashOne, ArgInfo("hashOne", 0)) &&
| 62733 | pyopencv_to_safe(pyobj_hashTwo, hashTwo, ArgInfo("hashTwo", 0)) ) |  | 62685 | pyopencv_to_safe(pyobj_hashTwo, hashTwo, ArgInfo("hashTwo", 0)) )
| 62734 | { |  | 62686 | {
| 62735 | ERRWRAP2(retval = _self_->compare(hashOne, hashTwo)); |  | 62687 | ERRWRAP2(retval = _self_->compare(hashOne, hashTwo));
| 62736 | return pyopencv_from(retval); |  | 62688 | return pyopencv_from(retval);
| 62737 | } |  | 62689 | }
| 62738 |  |  | 62690 |
| 62739 |  |  | 62691 |
| 62740 | pyPopulateArgumentConversionErrors(); |  | 62692 | pyPopulateArgumentConversionErrors();
| 62741 | } |  | 62693 | }
| 62742 |  |  | 62694 |
| 62743 |  |  | 62695 |
| 62744 | { |  | 62696 | {
| 62745 | PyObject* pyobj_hashOne = NULL; |  | 62697 | PyObject* pyobj_hashOne = NULL;
| 62746 | UMat hashOne; |  | 62698 | UMat hashOne;
| 62747 | PyObject* pyobj_hashTwo = NULL; |  | 62699 | PyObject* pyobj_hashTwo = NULL;
| 62748 | UMat hashTwo; |  | 62700 | UMat hashTwo;
| 62749 | double retval; |  | 62701 | double retval;
| 62750 |  |  | 62702 |
| 62751 | const char* keywords[] = { "hashOne", "hashTwo", NULL }; |  | 62703 | const char* keywords[] = { "hashOne", "hashTwo", NULL };
| 62752 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:img_hash_ImgHashBase.compare", (char**)keywords, &pyobj_hashOne, &pyobj_hashTwo) && |  | 62704 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:img_hash_ImgHashBase.compare", (char**)keywords, &pyobj_hashOne, &pyobj_hashTwo) &&
| 62753 | pyopencv_to_safe(pyobj_hashOne, hashOne, ArgInfo("hashOne", 0)) && |  | 62705 | pyopencv_to_safe(pyobj_hashOne, hashOne, ArgInfo("hashOne", 0)) &&
| 62754 | pyopencv_to_safe(pyobj_hashTwo, hashTwo, ArgInfo("hashTwo", 0)) ) |  | 62706 | pyopencv_to_safe(pyobj_hashTwo, hashTwo, ArgInfo("hashTwo", 0)) )
| 62755 | { |  | 62707 | {
| 62756 | ERRWRAP2(retval = _self_->compare(hashOne, hashTwo)); |  | 62708 | ERRWRAP2(retval = _self_->compare(hashOne, hashTwo));
| 62757 | return pyopencv_from(retval); |  | 62709 | return pyopencv_from(retval);
| 62758 | } |  | 62710 | }
| 62759 |  |  | 62711 |
| 62760 |  |  | 62712 |
| 62761 | pyPopulateArgumentConversionErrors(); |  | 62713 | pyPopulateArgumentConversionErrors();
| 62762 | } |  | 62714 | }
| 62763 | pyRaiseCVOverloadException("compare"); |  | 62715 | pyRaiseCVOverloadException("compare");
| 62764 |  |  | 62716 |
| 62765 | return NULL; |  | 62717 | return NULL;
| 62766 | } |  | 62718 | }
| 62767 |  |  | 62719 |
| 62768 | static PyObject* pyopencv_cv_img_hash_img_hash_ImgHashBase_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62720 | static PyObject* pyopencv_cv_img_hash_img_hash_ImgHashBase_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 62769 | { |  | 62721 | {
| 62770 | using namespace cv::img_hash; |  | 62722 | using namespace cv::img_hash;
| 62771 |  |  | 62723 |
| 62772 |  |  | 62724 |
| 62773 | Ptr<cv::img_hash::ImgHashBase> * self1 = 0; |  | 62725 | Ptr<cv::img_hash::ImgHashBase> * self1 = 0;
| 62774 | if (!pyopencv_img_hash_ImgHashBase_getp(self, self1)) |  | 62726 | if (!pyopencv_img_hash_ImgHashBase_getp(self, self1))
| 62775 | return failmsgp("Incorrect type of self (must be 'img_hash_ImgHashBase' or its derivative)"); |  | 62727 | return failmsgp("Incorrect type of self (must be 'img_hash_ImgHashBase' or its derivative)");
| 62776 | Ptr<cv::img_hash::ImgHashBase> _self_ = *(self1); |  | 62728 | Ptr<cv::img_hash::ImgHashBase> _self_ = *(self1);
| 62777 | pyPrepareArgumentConversionErrorsStorage(2); |  | 62729 | pyPrepareArgumentConversionErrorsStorage(2);
| 62778 |  |  | 62730 |
| 62779 | { |  | 62731 | {
| 62780 | PyObject* pyobj_inputArr = NULL; |  | 62732 | PyObject* pyobj_inputArr = NULL;
| 62781 | Mat inputArr; |  | 62733 | Mat inputArr;
| 62782 | PyObject* pyobj_outputArr = NULL; |  | 62734 | PyObject* pyobj_outputArr = NULL;
| 62783 | Mat outputArr; |  | 62735 | Mat outputArr;
| 62784 |  |  | 62736 |
| 62785 | const char* keywords[] = { "inputArr", "outputArr", NULL }; |  | 62737 | const char* keywords[] = { "inputArr", "outputArr", NULL };
| 62786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:img_hash_ImgHashBase.compute", (char**)keywords, &pyobj_inputArr, &pyobj_outputArr) && |  | 62738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:img_hash_ImgHashBase.compute", (char**)keywords, &pyobj_inputArr, &pyobj_outputArr) &&
| 62787 | pyopencv_to_safe(pyobj_inputArr, inputArr, ArgInfo("inputArr", 0)) && |  | 62739 | pyopencv_to_safe(pyobj_inputArr, inputArr, ArgInfo("inputArr", 0)) &&
| 62788 | pyopencv_to_safe(pyobj_outputArr, outputArr, ArgInfo("outputArr", 1)) ) |  | 62740 | pyopencv_to_safe(pyobj_outputArr, outputArr, ArgInfo("outputArr", 1)) )
| 62789 | { |  | 62741 | {
| 62790 | ERRWRAP2(_self_->compute(inputArr, outputArr)); |  | 62742 | ERRWRAP2(_self_->compute(inputArr, outputArr));
| 62791 | return pyopencv_from(outputArr); |  | 62743 | return pyopencv_from(outputArr);
| 62792 | } |  | 62744 | }
| 62793 |  |  | 62745 |
| 62794 |  |  | 62746 |
| 62795 | pyPopulateArgumentConversionErrors(); |  | 62747 | pyPopulateArgumentConversionErrors();
| 62796 | } |  | 62748 | }
| 62797 |  |  | 62749 |
| 62798 |  |  | 62750 |
| 62799 | { |  | 62751 | {
| 62800 | PyObject* pyobj_inputArr = NULL; |  | 62752 | PyObject* pyobj_inputArr = NULL;
| 62801 | UMat inputArr; |  | 62753 | UMat inputArr;
| 62802 | PyObject* pyobj_outputArr = NULL; |  | 62754 | PyObject* pyobj_outputArr = NULL;
| 62803 | UMat outputArr; |  | 62755 | UMat outputArr;
| 62804 |  |  | 62756 |
| 62805 | const char* keywords[] = { "inputArr", "outputArr", NULL }; |  | 62757 | const char* keywords[] = { "inputArr", "outputArr", NULL };
| 62806 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:img_hash_ImgHashBase.compute", (char**)keywords, &pyobj_inputArr, &pyobj_outputArr) && |  | 62758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:img_hash_ImgHashBase.compute", (char**)keywords, &pyobj_inputArr, &pyobj_outputArr) &&
| 62807 | pyopencv_to_safe(pyobj_inputArr, inputArr, ArgInfo("inputArr", 0)) && |  | 62759 | pyopencv_to_safe(pyobj_inputArr, inputArr, ArgInfo("inputArr", 0)) &&
| 62808 | pyopencv_to_safe(pyobj_outputArr, outputArr, ArgInfo("outputArr", 1)) ) |  | 62760 | pyopencv_to_safe(pyobj_outputArr, outputArr, ArgInfo("outputArr", 1)) )
| 62809 | { |  | 62761 | {
| 62810 | ERRWRAP2(_self_->compute(inputArr, outputArr)); |  | 62762 | ERRWRAP2(_self_->compute(inputArr, outputArr));
| 62811 | return pyopencv_from(outputArr); |  | 62763 | return pyopencv_from(outputArr);
| 62812 | } |  | 62764 | }
| 62813 |  |  | 62765 |
| 62814 |  |  | 62766 |
| 62815 | pyPopulateArgumentConversionErrors(); |  | 62767 | pyPopulateArgumentConversionErrors();
| 62816 | } |  | 62768 | }
| 62817 | pyRaiseCVOverloadException("compute"); |  | 62769 | pyRaiseCVOverloadException("compute");
| 62818 |  |  | 62770 |
| 62819 | return NULL; |  | 62771 | return NULL;
| 62820 | } |  | 62772 | }
| 62821 |  |  | 62773 |
| 62822 |  |  | 62774 |
| 62823 |  |  | 62775 |
| 62824 | // Tables (img_hash_ImgHashBase) |  | 62776 | // Tables (img_hash_ImgHashBase)
| 62825 |  |  | 62777 |
| 62826 | static PyGetSetDef pyopencv_img_hash_ImgHashBase_getseters[] = |  | 62778 | static PyGetSetDef pyopencv_img_hash_ImgHashBase_getseters[] =
| 62827 | { |  | 62779 | {
| 62828 | {NULL} /* Sentinel */ |  | 62780 | {NULL} /* Sentinel */
| 62829 | }; |  | 62781 | };
| 62830 |  |  | 62782 |
| 62831 | static PyMethodDef pyopencv_img_hash_ImgHashBase_methods[] = |  | 62783 | static PyMethodDef pyopencv_img_hash_ImgHashBase_methods[] =
| 62832 | { |  | 62784 | {
| 62833 | {"compare", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_ImgHashBase_compare, 0), "compare(hashOne, hashTwo) -> retval\n. @brief Compare the hash value between inOne and inTwo\n. @param hashOne Hash value one\n. @param hashTwo Hash value two\n. @return value indicate similarity between inOne and inTwo, the meaning\n. of the value vary from algorithms to algorithms"}, |  | 62785 | {"compare", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_ImgHashBase_compare, 0), "compare(hashOne, hashTwo) -> retval\n. @brief Compare the hash value between inOne and inTwo\n. @param hashOne Hash value one\n. @param hashTwo Hash value two\n. @return value indicate similarity between inOne and inTwo, the meaning\n. of the value vary from algorithms to algorithms"},
| 62834 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_ImgHashBase_compute, 0), "compute(inputArr[, outputArr]) -> outputArr\n. @brief Computes hash of the input image\n. @param inputArr input image want to compute hash value\n. @param outputArr hash of the image"}, |  | 62786 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_ImgHashBase_compute, 0), "compute(inputArr[, outputArr]) -> outputArr\n. @brief Computes hash of the input image\n. @param inputArr input image want to compute hash value\n. @param outputArr hash of the image"},
| 62835 |  |  | 62787 |
| 62836 | {NULL, NULL} |  | 62788 | {NULL, NULL}
| 62837 | }; |  | 62789 | };
| 62838 |  |  | 62790 |
| 62839 | // Converter (img_hash_ImgHashBase) |  | 62791 | // Converter (img_hash_ImgHashBase)
| 62840 |  |  | 62792 |
| 62841 | template<> |  | 62793 | template<>
| 62842 | struct PyOpenCV_Converter< Ptr<cv::img_hash::ImgHashBase> > |  | 62794 | struct PyOpenCV_Converter< Ptr<cv::img_hash::ImgHashBase> >
| 62843 | { |  | 62795 | {
| 62844 | static PyObject* from(const Ptr<cv::img_hash::ImgHashBase>& r) |  | 62796 | static PyObject* from(const Ptr<cv::img_hash::ImgHashBase>& r)
| 62845 | { |  | 62797 | {
| 62846 | return pyopencv_img_hash_ImgHashBase_Instance(r); |  | 62798 | return pyopencv_img_hash_ImgHashBase_Instance(r);
| 62847 | } |  | 62799 | }
| 62848 | static bool to(PyObject* src, Ptr<cv::img_hash::ImgHashBase>& dst, const ArgInfo& info) |  | 62800 | static bool to(PyObject* src, Ptr<cv::img_hash::ImgHashBase>& dst, const ArgInfo& info)
| 62849 | { |  | 62801 | {
| 62850 | if(!src || src == Py_None) |  | 62802 | if(!src || src == Py_None)
| 62851 | return true; |  | 62803 | return true;
| 62852 | Ptr<cv::img_hash::ImgHashBase> * dst_; |  | 62804 | Ptr<cv::img_hash::ImgHashBase> * dst_;
| 62853 | if (pyopencv_img_hash_ImgHashBase_getp(src, dst_)) |  | 62805 | if (pyopencv_img_hash_ImgHashBase_getp(src, dst_))
| 62854 | { |  | 62806 | {
| 62855 | dst = *dst_; |  | 62807 | dst = *dst_;
| 62856 | return true; |  | 62808 | return true;
| 62857 | } |  | 62809 | }
| 62858 |  |  | 62810 |
| 62859 | failmsg("Expected Ptr<cv::img_hash::ImgHashBase> for argument '%s'", info.name); |  | 62811 | failmsg("Expected Ptr<cv::img_hash::ImgHashBase> for argument '%s'", info.name);
| 62860 | return false; |  | 62812 | return false;
| 62861 | } |  | 62813 | }
| 62862 | }; |  | 62814 | };
| 62863 |  |  | 62815 |
| 62864 | //================================================================================ |  | 62816 | //================================================================================
| 62865 | // img_hash_MarrHildrethHash (Generic) |  | 62817 | // img_hash_MarrHildrethHash (Generic)
| 62866 | //================================================================================ |  | 62818 | //================================================================================
| 62867 |  |  | 62819 |
| 62868 | // GetSet (img_hash_MarrHildrethHash) |  | 62820 | // GetSet (img_hash_MarrHildrethHash)
| 62869 |  |  | 62821 |
| 62870 |  |  | 62822 |
| 62871 |  |  | 62823 |
| 62872 | // Methods (img_hash_MarrHildrethHash) |  | 62824 | // Methods (img_hash_MarrHildrethHash)
| 62873 |  |  | 62825 |
| 62874 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62826 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 62875 | { |  | 62827 | {
| 62876 | using namespace cv::img_hash; |  | 62828 | using namespace cv::img_hash;
| 62877 |  |  | 62829 |
| 62878 | PyObject* pyobj_alpha = NULL; |  | 62830 | PyObject* pyobj_alpha = NULL;
| 62879 | float alpha=2.0f; |  | 62831 | float alpha=2.0f;
| 62880 | PyObject* pyobj_scale = NULL; |  | 62832 | PyObject* pyobj_scale = NULL;
| 62881 | float scale=1.0f; |  | 62833 | float scale=1.0f;
| 62882 | Ptr<MarrHildrethHash> retval; |  | 62834 | Ptr<MarrHildrethHash> retval;
| 62883 |  |  | 62835 |
| 62884 | const char* keywords[] = { "alpha", "scale", NULL }; |  | 62836 | const char* keywords[] = { "alpha", "scale", NULL };
| 62885 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:img_hash_MarrHildrethHash.create", (char**)keywords, &pyobj_alpha, &pyobj_scale) && |  | 62837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:img_hash_MarrHildrethHash.create", (char**)keywords, &pyobj_alpha, &pyobj_scale) &&
| 62886 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) && |  | 62838 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) &&
| 62887 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) ) |  | 62839 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) )
| 62888 | { |  | 62840 | {
| 62889 | ERRWRAP2(retval = cv::img_hash::MarrHildrethHash::create(alpha, scale)); |  | 62841 | ERRWRAP2(retval = cv::img_hash::MarrHildrethHash::create(alpha, scale));
| 62890 | return pyopencv_from(retval); |  | 62842 | return pyopencv_from(retval);
| 62891 | } |  | 62843 | }
| 62892 |  |  | 62844 |
| 62893 | return NULL; |  | 62845 | return NULL;
| 62894 | } |  | 62846 | }
| 62895 |  |  | 62847 |
| 62896 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getAlpha(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62848 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getAlpha(PyObject* self, PyObject* py_args, PyObject* kw)
| 62897 | { |  | 62849 | {
| 62898 | using namespace cv::img_hash; |  | 62850 | using namespace cv::img_hash;
| 62899 |  |  | 62851 |
| 62900 |  |  | 62852 |
| 62901 | Ptr<cv::img_hash::MarrHildrethHash> * self1 = 0; |  | 62853 | Ptr<cv::img_hash::MarrHildrethHash> * self1 = 0;
| 62902 | if (!pyopencv_img_hash_MarrHildrethHash_getp(self, self1)) |  | 62854 | if (!pyopencv_img_hash_MarrHildrethHash_getp(self, self1))
| 62903 | return failmsgp("Incorrect type of self (must be 'img_hash_MarrHildrethHash' or its derivative)"); |  | 62855 | return failmsgp("Incorrect type of self (must be 'img_hash_MarrHildrethHash' or its derivative)");
| 62904 | Ptr<cv::img_hash::MarrHildrethHash> _self_ = *(self1); |  | 62856 | Ptr<cv::img_hash::MarrHildrethHash> _self_ = *(self1);
| 62905 | float retval; |  | 62857 | float retval;
| 62906 |  |  | 62858 |
| 62907 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62859 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62908 | { |  | 62860 | {
| 62909 | ERRWRAP2(retval = _self_->getAlpha()); |  | 62861 | ERRWRAP2(retval = _self_->getAlpha());
| 62910 | return pyopencv_from(retval); |  | 62862 | return pyopencv_from(retval);
| 62911 | } |  | 62863 | }
| 62912 |  |  | 62864 |
| 62913 | return NULL; |  | 62865 | return NULL;
| 62914 | } |  | 62866 | }
| 62915 |  |  | 62867 |
| 62916 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62868 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 62917 | { |  | 62869 | {
| 62918 | using namespace cv::img_hash; |  | 62870 | using namespace cv::img_hash;
| 62919 |  |  | 62871 |
| 62920 |  |  | 62872 |
| 62921 | Ptr<cv::img_hash::MarrHildrethHash> * self1 = 0; |  | 62873 | Ptr<cv::img_hash::MarrHildrethHash> * self1 = 0;
| 62922 | if (!pyopencv_img_hash_MarrHildrethHash_getp(self, self1)) |  | 62874 | if (!pyopencv_img_hash_MarrHildrethHash_getp(self, self1))
| 62923 | return failmsgp("Incorrect type of self (must be 'img_hash_MarrHildrethHash' or its derivative)"); |  | 62875 | return failmsgp("Incorrect type of self (must be 'img_hash_MarrHildrethHash' or its derivative)");
| 62924 | Ptr<cv::img_hash::MarrHildrethHash> _self_ = *(self1); |  | 62876 | Ptr<cv::img_hash::MarrHildrethHash> _self_ = *(self1);
| 62925 | float retval; |  | 62877 | float retval;
| 62926 |  |  | 62878 |
| 62927 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62879 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 62928 | { |  | 62880 | {
| 62929 | ERRWRAP2(retval = _self_->getScale()); |  | 62881 | ERRWRAP2(retval = _self_->getScale());
| 62930 | return pyopencv_from(retval); |  | 62882 | return pyopencv_from(retval);
| 62931 | } |  | 62883 | }
| 62932 |  |  | 62884 |
| 62933 | return NULL; |  | 62885 | return NULL;
| 62934 | } |  | 62886 | }
| 62935 |  |  | 62887 |
| 62936 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_setKernelParam(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62888 | static PyObject* pyopencv_cv_img_hash_img_hash_MarrHildrethHash_setKernelParam(PyObject* self, PyObject* py_args, PyObject* kw)
| 62937 | { |  | 62889 | {
| 62938 | using namespace cv::img_hash; |  | 62890 | using namespace cv::img_hash;
| 62939 |  |  | 62891 |
| 62940 |  |  | 62892 |
| 62941 | Ptr<cv::img_hash::MarrHildrethHash> * self1 = 0; |  | 62893 | Ptr<cv::img_hash::MarrHildrethHash> * self1 = 0;
| 62942 | if (!pyopencv_img_hash_MarrHildrethHash_getp(self, self1)) |  | 62894 | if (!pyopencv_img_hash_MarrHildrethHash_getp(self, self1))
| 62943 | return failmsgp("Incorrect type of self (must be 'img_hash_MarrHildrethHash' or its derivative)"); |  | 62895 | return failmsgp("Incorrect type of self (must be 'img_hash_MarrHildrethHash' or its derivative)");
| 62944 | Ptr<cv::img_hash::MarrHildrethHash> _self_ = *(self1); |  | 62896 | Ptr<cv::img_hash::MarrHildrethHash> _self_ = *(self1);
| 62945 | PyObject* pyobj_alpha = NULL; |  | 62897 | PyObject* pyobj_alpha = NULL;
| 62946 | float alpha=0.f; |  | 62898 | float alpha=0.f;
| 62947 | PyObject* pyobj_scale = NULL; |  | 62899 | PyObject* pyobj_scale = NULL;
| 62948 | float scale=0.f; |  | 62900 | float scale=0.f;
| 62949 |  |  | 62901 |
| 62950 | const char* keywords[] = { "alpha", "scale", NULL }; |  | 62902 | const char* keywords[] = { "alpha", "scale", NULL };
| 62951 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:img_hash_MarrHildrethHash.setKernelParam", (char**)keywords, &pyobj_alpha, &pyobj_scale) && |  | 62903 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:img_hash_MarrHildrethHash.setKernelParam", (char**)keywords, &pyobj_alpha, &pyobj_scale) &&
| 62952 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) && |  | 62904 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 0)) &&
| 62953 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) ) |  | 62905 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) )
| 62954 | { |  | 62906 | {
| 62955 | ERRWRAP2(_self_->setKernelParam(alpha, scale)); |  | 62907 | ERRWRAP2(_self_->setKernelParam(alpha, scale));
| 62956 | Py_RETURN_NONE; |  | 62908 | Py_RETURN_NONE;
| 62957 | } |  | 62909 | }
| 62958 |  |  | 62910 |
| 62959 | return NULL; |  | 62911 | return NULL;
| 62960 | } |  | 62912 | }
| 62961 |  |  | 62913 |
| 62962 |  |  | 62914 |
| 62963 |  |  | 62915 |
| 62964 | // Tables (img_hash_MarrHildrethHash) |  | 62916 | // Tables (img_hash_MarrHildrethHash)
| 62965 |  |  | 62917 |
| 62966 | static PyGetSetDef pyopencv_img_hash_MarrHildrethHash_getseters[] = |  | 62918 | static PyGetSetDef pyopencv_img_hash_MarrHildrethHash_getseters[] =
| 62967 | { |  | 62919 | {
| 62968 | {NULL} /* Sentinel */ |  | 62920 | {NULL} /* Sentinel */
| 62969 | }; |  | 62921 | };
| 62970 |  |  | 62922 |
| 62971 | static PyMethodDef pyopencv_img_hash_MarrHildrethHash_methods[] = |  | 62923 | static PyMethodDef pyopencv_img_hash_MarrHildrethHash_methods[] =
| 62972 | { |  | 62924 | {
| 62973 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_create_static, METH_STATIC), "create([, alpha[, scale]]) -> retval\n. @param alpha int scale factor for marr wavelet (default=2).\n. @param scale int level of scale factor (default = 1)"}, |  | 62925 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_create_static, METH_STATIC), "create([, alpha[, scale]]) -> retval\n. @param alpha int scale factor for marr wavelet (default=2).\n. @param scale int level of scale factor (default = 1)"},
| 62974 | {"getAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getAlpha, 0), "getAlpha() -> retval\n. * @brief self explain"}, |  | 62926 | {"getAlpha", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getAlpha, 0), "getAlpha() -> retval\n. * @brief self explain"},
| 62975 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getScale, 0), "getScale() -> retval\n. * @brief self explain"}, |  | 62927 | {"getScale", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_getScale, 0), "getScale() -> retval\n. * @brief self explain"},
| 62976 | {"setKernelParam", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_setKernelParam, 0), "setKernelParam(alpha, scale) -> None\n. @brief Set Mh kernel parameters\n. @param alpha int scale factor for marr wavelet (default=2).\n. @param scale int level of scale factor (default = 1)"}, |  | 62928 | {"setKernelParam", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_MarrHildrethHash_setKernelParam, 0), "setKernelParam(alpha, scale) -> None\n. @brief Set Mh kernel parameters\n. @param alpha int scale factor for marr wavelet (default=2).\n. @param scale int level of scale factor (default = 1)"},
| 62977 |  |  | 62929 |
| 62978 | {NULL, NULL} |  | 62930 | {NULL, NULL}
| 62979 | }; |  | 62931 | };
| 62980 |  |  | 62932 |
| 62981 | // Converter (img_hash_MarrHildrethHash) |  | 62933 | // Converter (img_hash_MarrHildrethHash)
| 62982 |  |  | 62934 |
| 62983 | template<> |  | 62935 | template<>
| 62984 | struct PyOpenCV_Converter< Ptr<cv::img_hash::MarrHildrethHash> > |  | 62936 | struct PyOpenCV_Converter< Ptr<cv::img_hash::MarrHildrethHash> >
| 62985 | { |  | 62937 | {
| 62986 | static PyObject* from(const Ptr<cv::img_hash::MarrHildrethHash>& r) |  | 62938 | static PyObject* from(const Ptr<cv::img_hash::MarrHildrethHash>& r)
| 62987 | { |  | 62939 | {
| 62988 | return pyopencv_img_hash_MarrHildrethHash_Instance(r); |  | 62940 | return pyopencv_img_hash_MarrHildrethHash_Instance(r);
| 62989 | } |  | 62941 | }
| 62990 | static bool to(PyObject* src, Ptr<cv::img_hash::MarrHildrethHash>& dst, const ArgInfo& info) |  | 62942 | static bool to(PyObject* src, Ptr<cv::img_hash::MarrHildrethHash>& dst, const ArgInfo& info)
| 62991 | { |  | 62943 | {
| 62992 | if(!src || src == Py_None) |  | 62944 | if(!src || src == Py_None)
| 62993 | return true; |  | 62945 | return true;
| 62994 | Ptr<cv::img_hash::MarrHildrethHash> * dst_; |  | 62946 | Ptr<cv::img_hash::MarrHildrethHash> * dst_;
| 62995 | if (pyopencv_img_hash_MarrHildrethHash_getp(src, dst_)) |  | 62947 | if (pyopencv_img_hash_MarrHildrethHash_getp(src, dst_))
| 62996 | { |  | 62948 | {
| 62997 | dst = *dst_; |  | 62949 | dst = *dst_;
| 62998 | return true; |  | 62950 | return true;
| 62999 | } |  | 62951 | }
| 63000 |  |  | 62952 |
| 63001 | failmsg("Expected Ptr<cv::img_hash::MarrHildrethHash> for argument '%s'", info.name); |  | 62953 | failmsg("Expected Ptr<cv::img_hash::MarrHildrethHash> for argument '%s'", info.name);
| 63002 | return false; |  | 62954 | return false;
| 63003 | } |  | 62955 | }
| 63004 | }; |  | 62956 | };
| 63005 |  |  | 62957 |
| 63006 | //================================================================================ |  | 62958 | //================================================================================
| 63007 | // img_hash_PHash (Generic) |  | 62959 | // img_hash_PHash (Generic)
| 63008 | //================================================================================ |  | 62960 | //================================================================================
| 63009 |  |  | 62961 |
| 63010 | // GetSet (img_hash_PHash) |  | 62962 | // GetSet (img_hash_PHash)
| 63011 |  |  | 62963 |
| 63012 |  |  | 62964 |
| 63013 |  |  | 62965 |
| 63014 | // Methods (img_hash_PHash) |  | 62966 | // Methods (img_hash_PHash)
| 63015 |  |  | 62967 |
| 63016 | static PyObject* pyopencv_cv_img_hash_img_hash_PHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 62968 | static PyObject* pyopencv_cv_img_hash_img_hash_PHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 63017 | { |  | 62969 | {
| 63018 | using namespace cv::img_hash; |  | 62970 | using namespace cv::img_hash;
| 63019 |  |  | 62971 |
| 63020 | Ptr<PHash> retval; |  | 62972 | Ptr<PHash> retval;
| 63021 |  |  | 62973 |
| 63022 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 62974 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 63023 | { |  | 62975 | {
| 63024 | ERRWRAP2(retval = cv::img_hash::PHash::create()); |  | 62976 | ERRWRAP2(retval = cv::img_hash::PHash::create());
| 63025 | return pyopencv_from(retval); |  | 62977 | return pyopencv_from(retval);
| 63026 | } |  | 62978 | }
| 63027 |  |  | 62979 |
| 63028 | return NULL; |  | 62980 | return NULL;
| 63029 | } |  | 62981 | }
| 63030 |  |  | 62982 |
| 63031 |  |  | 62983 |
| 63032 |  |  | 62984 |
| 63033 | // Tables (img_hash_PHash) |  | 62985 | // Tables (img_hash_PHash)
| 63034 |  |  | 62986 |
| 63035 | static PyGetSetDef pyopencv_img_hash_PHash_getseters[] = |  | 62987 | static PyGetSetDef pyopencv_img_hash_PHash_getseters[] =
| 63036 | { |  | 62988 | {
| 63037 | {NULL} /* Sentinel */ |  | 62989 | {NULL} /* Sentinel */
| 63038 | }; |  | 62990 | };
| 63039 |  |  | 62991 |
| 63040 | static PyMethodDef pyopencv_img_hash_PHash_methods[] = |  | 62992 | static PyMethodDef pyopencv_img_hash_PHash_methods[] =
| 63041 | { |  | 62993 | {
| 63042 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_PHash_create_static, METH_STATIC), "create() -> retval\n."}, |  | 62994 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_PHash_create_static, METH_STATIC), "create() -> retval\n."},
| 63043 |  |  | 62995 |
| 63044 | {NULL, NULL} |  | 62996 | {NULL, NULL}
| 63045 | }; |  | 62997 | };
| 63046 |  |  | 62998 |
| 63047 | // Converter (img_hash_PHash) |  | 62999 | // Converter (img_hash_PHash)
| 63048 |  |  | 63000 |
| 63049 | template<> |  | 63001 | template<>
| 63050 | struct PyOpenCV_Converter< Ptr<cv::img_hash::PHash> > |  | 63002 | struct PyOpenCV_Converter< Ptr<cv::img_hash::PHash> >
| 63051 | { |  | 63003 | {
| 63052 | static PyObject* from(const Ptr<cv::img_hash::PHash>& r) |  | 63004 | static PyObject* from(const Ptr<cv::img_hash::PHash>& r)
| 63053 | { |  | 63005 | {
| 63054 | return pyopencv_img_hash_PHash_Instance(r); |  | 63006 | return pyopencv_img_hash_PHash_Instance(r);
| 63055 | } |  | 63007 | }
| 63056 | static bool to(PyObject* src, Ptr<cv::img_hash::PHash>& dst, const ArgInfo& info) |  | 63008 | static bool to(PyObject* src, Ptr<cv::img_hash::PHash>& dst, const ArgInfo& info)
| 63057 | { |  | 63009 | {
| 63058 | if(!src || src == Py_None) |  | 63010 | if(!src || src == Py_None)
| 63059 | return true; |  | 63011 | return true;
| 63060 | Ptr<cv::img_hash::PHash> * dst_; |  | 63012 | Ptr<cv::img_hash::PHash> * dst_;
| 63061 | if (pyopencv_img_hash_PHash_getp(src, dst_)) |  | 63013 | if (pyopencv_img_hash_PHash_getp(src, dst_))
| 63062 | { |  | 63014 | {
| 63063 | dst = *dst_; |  | 63015 | dst = *dst_;
| 63064 | return true; |  | 63016 | return true;
| 63065 | } |  | 63017 | }
| 63066 |  |  | 63018 |
| 63067 | failmsg("Expected Ptr<cv::img_hash::PHash> for argument '%s'", info.name); |  | 63019 | failmsg("Expected Ptr<cv::img_hash::PHash> for argument '%s'", info.name);
| 63068 | return false; |  | 63020 | return false;
| 63069 | } |  | 63021 | }
| 63070 | }; |  | 63022 | };
| 63071 |  |  | 63023 |
| 63072 | //================================================================================ |  | 63024 | //================================================================================
| 63073 | // img_hash_RadialVarianceHash (Generic) |  | 63025 | // img_hash_RadialVarianceHash (Generic)
| 63074 | //================================================================================ |  | 63026 | //================================================================================
| 63075 |  |  | 63027 |
| 63076 | // GetSet (img_hash_RadialVarianceHash) |  | 63028 | // GetSet (img_hash_RadialVarianceHash)
| 63077 |  |  | 63029 |
| 63078 |  |  | 63030 |
| 63079 |  |  | 63031 |
| 63080 | // Methods (img_hash_RadialVarianceHash) |  | 63032 | // Methods (img_hash_RadialVarianceHash)
| 63081 |  |  | 63033 |
| 63082 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63034 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 63083 | { |  | 63035 | {
| 63084 | using namespace cv::img_hash; |  | 63036 | using namespace cv::img_hash;
| 63085 |  |  | 63037 |
| 63086 | PyObject* pyobj_sigma = NULL; |  | 63038 | PyObject* pyobj_sigma = NULL;
| 63087 | double sigma=1; |  | 63039 | double sigma=1;
| 63088 | PyObject* pyobj_numOfAngleLine = NULL; |  | 63040 | PyObject* pyobj_numOfAngleLine = NULL;
| 63089 | int numOfAngleLine=180; |  | 63041 | int numOfAngleLine=180;
| 63090 | Ptr<RadialVarianceHash> retval; |  | 63042 | Ptr<RadialVarianceHash> retval;
| 63091 |  |  | 63043 |
| 63092 | const char* keywords[] = { "sigma", "numOfAngleLine", NULL }; |  | 63044 | const char* keywords[] = { "sigma", "numOfAngleLine", NULL };
| 63093 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:img_hash_RadialVarianceHash.create", (char**)keywords, &pyobj_sigma, &pyobj_numOfAngleLine) && |  | 63045 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:img_hash_RadialVarianceHash.create", (char**)keywords, &pyobj_sigma, &pyobj_numOfAngleLine) &&
| 63094 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) && |  | 63046 | pyopencv_to_safe(pyobj_sigma, sigma, ArgInfo("sigma", 0)) &&
| 63095 | pyopencv_to_safe(pyobj_numOfAngleLine, numOfAngleLine, ArgInfo("numOfAngleLine", 0)) ) |  | 63047 | pyopencv_to_safe(pyobj_numOfAngleLine, numOfAngleLine, ArgInfo("numOfAngleLine", 0)) )
| 63096 | { |  | 63048 | {
| 63097 | ERRWRAP2(retval = cv::img_hash::RadialVarianceHash::create(sigma, numOfAngleLine)); |  | 63049 | ERRWRAP2(retval = cv::img_hash::RadialVarianceHash::create(sigma, numOfAngleLine));
| 63098 | return pyopencv_from(retval); |  | 63050 | return pyopencv_from(retval);
| 63099 | } |  | 63051 | }
| 63100 |  |  | 63052 |
| 63101 | return NULL; |  | 63053 | return NULL;
| 63102 | } |  | 63054 | }
| 63103 |  |  | 63055 |
| 63104 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getNumOfAngleLine(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63056 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getNumOfAngleLine(PyObject* self, PyObject* py_args, PyObject* kw)
| 63105 | { |  | 63057 | {
| 63106 | using namespace cv::img_hash; |  | 63058 | using namespace cv::img_hash;
| 63107 |  |  | 63059 |
| 63108 |  |  | 63060 |
| 63109 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0; |  | 63061 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0;
| 63110 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1)) |  | 63062 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1))
| 63111 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)"); |  | 63063 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)");
| 63112 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1); |  | 63064 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1);
| 63113 | int retval; |  | 63065 | int retval;
| 63114 |  |  | 63066 |
| 63115 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 63067 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 63116 | { |  | 63068 | {
| 63117 | ERRWRAP2(retval = _self_->getNumOfAngleLine()); |  | 63069 | ERRWRAP2(retval = _self_->getNumOfAngleLine());
| 63118 | return pyopencv_from(retval); |  | 63070 | return pyopencv_from(retval);
| 63119 | } |  | 63071 | }
| 63120 |  |  | 63072 |
| 63121 | return NULL; |  | 63073 | return NULL;
| 63122 | } |  | 63074 | }
| 63123 |  |  | 63075 |
| 63124 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63076 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 63125 | { |  | 63077 | {
| 63126 | using namespace cv::img_hash; |  | 63078 | using namespace cv::img_hash;
| 63127 |  |  | 63079 |
| 63128 |  |  | 63080 |
| 63129 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0; |  | 63081 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0;
| 63130 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1)) |  | 63082 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1))
| 63131 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)"); |  | 63083 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)");
| 63132 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1); |  | 63084 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1);
| 63133 | double retval; |  | 63085 | double retval;
| 63134 |  |  | 63086 |
| 63135 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 63087 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 63136 | { |  | 63088 | {
| 63137 | ERRWRAP2(retval = _self_->getSigma()); |  | 63089 | ERRWRAP2(retval = _self_->getSigma());
| 63138 | return pyopencv_from(retval); |  | 63090 | return pyopencv_from(retval);
| 63139 | } |  | 63091 | }
| 63140 |  |  | 63092 |
| 63141 | return NULL; |  | 63093 | return NULL;
| 63142 | } |  | 63094 | }
| 63143 |  |  | 63095 |
| 63144 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setNumOfAngleLine(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63096 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setNumOfAngleLine(PyObject* self, PyObject* py_args, PyObject* kw)
| 63145 | { |  | 63097 | {
| 63146 | using namespace cv::img_hash; |  | 63098 | using namespace cv::img_hash;
| 63147 |  |  | 63099 |
| 63148 |  |  | 63100 |
| 63149 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0; |  | 63101 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0;
| 63150 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1)) |  | 63102 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1))
| 63151 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)"); |  | 63103 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)");
| 63152 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1); |  | 63104 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1);
| 63153 | PyObject* pyobj_value = NULL; |  | 63105 | PyObject* pyobj_value = NULL;
| 63154 | int value=0; |  | 63106 | int value=0;
| 63155 |  |  | 63107 |
| 63156 | const char* keywords[] = { "value", NULL }; |  | 63108 | const char* keywords[] = { "value", NULL };
| 63157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:img_hash_RadialVarianceHash.setNumOfAngleLine", (char**)keywords, &pyobj_value) && |  | 63109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:img_hash_RadialVarianceHash.setNumOfAngleLine", (char**)keywords, &pyobj_value) &&
| 63158 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 63110 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 63159 | { |  | 63111 | {
| 63160 | ERRWRAP2(_self_->setNumOfAngleLine(value)); |  | 63112 | ERRWRAP2(_self_->setNumOfAngleLine(value));
| 63161 | Py_RETURN_NONE; |  | 63113 | Py_RETURN_NONE;
| 63162 | } |  | 63114 | }
| 63163 |  |  | 63115 |
| 63164 | return NULL; |  | 63116 | return NULL;
| 63165 | } |  | 63117 | }
| 63166 |  |  | 63118 |
| 63167 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63119 | static PyObject* pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 63168 | { |  | 63120 | {
| 63169 | using namespace cv::img_hash; |  | 63121 | using namespace cv::img_hash;
| 63170 |  |  | 63122 |
| 63171 |  |  | 63123 |
| 63172 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0; |  | 63124 | Ptr<cv::img_hash::RadialVarianceHash> * self1 = 0;
| 63173 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1)) |  | 63125 | if (!pyopencv_img_hash_RadialVarianceHash_getp(self, self1))
| 63174 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)"); |  | 63126 | return failmsgp("Incorrect type of self (must be 'img_hash_RadialVarianceHash' or its derivative)");
| 63175 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1); |  | 63127 | Ptr<cv::img_hash::RadialVarianceHash> _self_ = *(self1);
| 63176 | PyObject* pyobj_value = NULL; |  | 63128 | PyObject* pyobj_value = NULL;
| 63177 | double value=0; |  | 63129 | double value=0;
| 63178 |  |  | 63130 |
| 63179 | const char* keywords[] = { "value", NULL }; |  | 63131 | const char* keywords[] = { "value", NULL };
| 63180 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:img_hash_RadialVarianceHash.setSigma", (char**)keywords, &pyobj_value) && |  | 63132 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:img_hash_RadialVarianceHash.setSigma", (char**)keywords, &pyobj_value) &&
| 63181 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) ) |  | 63133 | pyopencv_to_safe(pyobj_value, value, ArgInfo("value", 0)) )
| 63182 | { |  | 63134 | {
| 63183 | ERRWRAP2(_self_->setSigma(value)); |  | 63135 | ERRWRAP2(_self_->setSigma(value));
| 63184 | Py_RETURN_NONE; |  | 63136 | Py_RETURN_NONE;
| 63185 | } |  | 63137 | }
| 63186 |  |  | 63138 |
| 63187 | return NULL; |  | 63139 | return NULL;
| 63188 | } |  | 63140 | }
| 63189 |  |  | 63141 |
| 63190 |  |  | 63142 |
| 63191 |  |  | 63143 |
| 63192 | // Tables (img_hash_RadialVarianceHash) |  | 63144 | // Tables (img_hash_RadialVarianceHash)
| 63193 |  |  | 63145 |
| 63194 | static PyGetSetDef pyopencv_img_hash_RadialVarianceHash_getseters[] = |  | 63146 | static PyGetSetDef pyopencv_img_hash_RadialVarianceHash_getseters[] =
| 63195 | { |  | 63147 | {
| 63196 | {NULL} /* Sentinel */ |  | 63148 | {NULL} /* Sentinel */
| 63197 | }; |  | 63149 | };
| 63198 |  |  | 63150 |
| 63199 | static PyMethodDef pyopencv_img_hash_RadialVarianceHash_methods[] = |  | 63151 | static PyMethodDef pyopencv_img_hash_RadialVarianceHash_methods[] =
| 63200 | { |  | 63152 | {
| 63201 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_create_static, METH_STATIC), "create([, sigma[, numOfAngleLine]]) -> retval\n."}, |  | 63153 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_create_static, METH_STATIC), "create([, sigma[, numOfAngleLine]]) -> retval\n."},
| 63202 | {"getNumOfAngleLine", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getNumOfAngleLine, 0), "getNumOfAngleLine() -> retval\n."}, |  | 63154 | {"getNumOfAngleLine", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getNumOfAngleLine, 0), "getNumOfAngleLine() -> retval\n."},
| 63203 | {"getSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getSigma, 0), "getSigma() -> retval\n."}, |  | 63155 | {"getSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_getSigma, 0), "getSigma() -> retval\n."},
| 63204 | {"setNumOfAngleLine", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setNumOfAngleLine, 0), "setNumOfAngleLine(value) -> None\n."}, |  | 63156 | {"setNumOfAngleLine", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setNumOfAngleLine, 0), "setNumOfAngleLine(value) -> None\n."},
| 63205 | {"setSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setSigma, 0), "setSigma(value) -> None\n."}, |  | 63157 | {"setSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_img_hash_img_hash_RadialVarianceHash_setSigma, 0), "setSigma(value) -> None\n."},
| 63206 |  |  | 63158 |
| 63207 | {NULL, NULL} |  | 63159 | {NULL, NULL}
| 63208 | }; |  | 63160 | };
| 63209 |  |  | 63161 |
| 63210 | // Converter (img_hash_RadialVarianceHash) |  | 63162 | // Converter (img_hash_RadialVarianceHash)
| 63211 |  |  | 63163 |
| 63212 | template<> |  | 63164 | template<>
| 63213 | struct PyOpenCV_Converter< Ptr<cv::img_hash::RadialVarianceHash> > |  | 63165 | struct PyOpenCV_Converter< Ptr<cv::img_hash::RadialVarianceHash> >
| 63214 | { |  | 63166 | {
| 63215 | static PyObject* from(const Ptr<cv::img_hash::RadialVarianceHash>& r) |  | 63167 | static PyObject* from(const Ptr<cv::img_hash::RadialVarianceHash>& r)
| 63216 | { |  | 63168 | {
| 63217 | return pyopencv_img_hash_RadialVarianceHash_Instance(r); |  | 63169 | return pyopencv_img_hash_RadialVarianceHash_Instance(r);
| 63218 | } |  | 63170 | }
| 63219 | static bool to(PyObject* src, Ptr<cv::img_hash::RadialVarianceHash>& dst, const ArgInfo& info) |  | 63171 | static bool to(PyObject* src, Ptr<cv::img_hash::RadialVarianceHash>& dst, const ArgInfo& info)
| 63220 | { |  | 63172 | {
| 63221 | if(!src || src == Py_None) |  | 63173 | if(!src || src == Py_None)
| 63222 | return true; |  | 63174 | return true;
| 63223 | Ptr<cv::img_hash::RadialVarianceHash> * dst_; |  | 63175 | Ptr<cv::img_hash::RadialVarianceHash> * dst_;
| 63224 | if (pyopencv_img_hash_RadialVarianceHash_getp(src, dst_)) |  | 63176 | if (pyopencv_img_hash_RadialVarianceHash_getp(src, dst_))
| 63225 | { |  | 63177 | {
| 63226 | dst = *dst_; |  | 63178 | dst = *dst_;
| 63227 | return true; |  | 63179 | return true;
| 63228 | } |  | 63180 | }
| 63229 |  |  | 63181 |
| 63230 | failmsg("Expected Ptr<cv::img_hash::RadialVarianceHash> for argument '%s'", info.name); |  | 63182 | failmsg("Expected Ptr<cv::img_hash::RadialVarianceHash> for argument '%s'", info.name);
| 63231 | return false; |  | 63183 | return false;
| 63232 | } |  | 63184 | }
| 63233 | }; |  | 63185 | };
| 63234 |  |  | 63186 |
| 63235 | //================================================================================ |  | 63187 | //================================================================================
| 63236 | // kinfu_KinFu (Generic) |  | 63188 | // kinfu_KinFu (Generic)
| 63237 | //================================================================================ |  | 63189 | //================================================================================
| 63238 |  |  | 63190 |
| 63239 | // GetSet (kinfu_KinFu) |  | 63191 | // GetSet (kinfu_KinFu)
| 63240 |  |  | 63192 |
| 63241 |  |  | 63193 |
| 63242 |  |  | 63194 |
| 63243 | // Methods (kinfu_KinFu) |  | 63195 | // Methods (kinfu_KinFu)
| 63244 |  |  | 63196 |
| 63245 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63197 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 63246 | { |  | 63198 | {
| 63247 | using namespace cv::kinfu; |  | 63199 | using namespace cv::kinfu;
| 63248 |  |  | 63200 |
| 63249 | PyObject* pyobj__params = NULL; |  | 63201 | PyObject* pyobj__params = NULL;
| 63250 | Ptr<Params> _params; |  | 63202 | Ptr<Params> _params;
| 63251 | Ptr<KinFu> retval; |  | 63203 | Ptr<KinFu> retval;
| 63252 |  |  | 63204 |
| 63253 | const char* keywords[] = { "_params", NULL }; |  | 63205 | const char* keywords[] = { "_params", NULL };
| 63254 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_KinFu.create", (char**)keywords, &pyobj__params) && |  | 63206 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_KinFu.create", (char**)keywords, &pyobj__params) &&
| 63255 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) ) |  | 63207 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) )
| 63256 | { |  | 63208 | {
| 63257 | ERRWRAP2(retval = cv::kinfu::KinFu::create(_params)); |  | 63209 | ERRWRAP2(retval = cv::kinfu::KinFu::create(_params));
| 63258 | return pyopencv_from(retval); |  | 63210 | return pyopencv_from(retval);
| 63259 | } |  | 63211 | }
| 63260 |  |  | 63212 |
| 63261 | return NULL; |  | 63213 | return NULL;
| 63262 | } |  | 63214 | }
| 63263 |  |  | 63215 |
| 63264 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63216 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw)
| 63265 | { |  | 63217 | {
| 63266 | using namespace cv::kinfu; |  | 63218 | using namespace cv::kinfu;
| 63267 |  |  | 63219 |
| 63268 |  |  | 63220 |
| 63269 | Ptr<cv::kinfu::KinFu> * self1 = 0; |  | 63221 | Ptr<cv::kinfu::KinFu> * self1 = 0;
| 63270 | if (!pyopencv_kinfu_KinFu_getp(self, self1)) |  | 63222 | if (!pyopencv_kinfu_KinFu_getp(self, self1))
| 63271 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)"); |  | 63223 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)");
| 63272 | Ptr<cv::kinfu::KinFu> _self_ = *(self1); |  | 63224 | Ptr<cv::kinfu::KinFu> _self_ = *(self1);
| 63273 | pyPrepareArgumentConversionErrorsStorage(2); |  | 63225 | pyPrepareArgumentConversionErrorsStorage(2);
| 63274 |  |  | 63226 |
| 63275 | { |  | 63227 | {
| 63276 | PyObject* pyobj_points = NULL; |  | 63228 | PyObject* pyobj_points = NULL;
| 63277 | Mat points; |  | 63229 | Mat points;
| 63278 | PyObject* pyobj_normals = NULL; |  | 63230 | PyObject* pyobj_normals = NULL;
| 63279 | Mat normals; |  | 63231 | Mat normals;
| 63280 |  |  | 63232 |
| 63281 | const char* keywords[] = { "points", "normals", NULL }; |  | 63233 | const char* keywords[] = { "points", "normals", NULL };
| 63282 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:kinfu_KinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 63234 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:kinfu_KinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 63283 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 63235 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 63284 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 63236 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 63285 | { |  | 63237 | {
| 63286 | ERRWRAP2(_self_->getCloud(points, normals)); |  | 63238 | ERRWRAP2(_self_->getCloud(points, normals));
| 63287 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals)); |  | 63239 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals));
| 63288 | } |  | 63240 | }
| 63289 |  |  | 63241 |
| 63290 |  |  | 63242 |
| 63291 | pyPopulateArgumentConversionErrors(); |  | 63243 | pyPopulateArgumentConversionErrors();
| 63292 | } |  | 63244 | }
| 63293 |  |  | 63245 |
| 63294 |  |  | 63246 |
| 63295 | { |  | 63247 | {
| 63296 | PyObject* pyobj_points = NULL; |  | 63248 | PyObject* pyobj_points = NULL;
| 63297 | UMat points; |  | 63249 | UMat points;
| 63298 | PyObject* pyobj_normals = NULL; |  | 63250 | PyObject* pyobj_normals = NULL;
| 63299 | UMat normals; |  | 63251 | UMat normals;
| 63300 |  |  | 63252 |
| 63301 | const char* keywords[] = { "points", "normals", NULL }; |  | 63253 | const char* keywords[] = { "points", "normals", NULL };
| 63302 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:kinfu_KinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 63254 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:kinfu_KinFu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 63303 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 63255 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 63304 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 63256 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 63305 | { |  | 63257 | {
| 63306 | ERRWRAP2(_self_->getCloud(points, normals)); |  | 63258 | ERRWRAP2(_self_->getCloud(points, normals));
| 63307 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals)); |  | 63259 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals));
| 63308 | } |  | 63260 | }
| 63309 |  |  | 63261 |
| 63310 |  |  | 63262 |
| 63311 | pyPopulateArgumentConversionErrors(); |  | 63263 | pyPopulateArgumentConversionErrors();
| 63312 | } |  | 63264 | }
| 63313 | pyRaiseCVOverloadException("getCloud"); |  | 63265 | pyRaiseCVOverloadException("getCloud");
| 63314 |  |  | 63266 |
| 63315 | return NULL; |  | 63267 | return NULL;
| 63316 | } |  | 63268 | }
| 63317 |  |  | 63269 |
| 63318 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63270 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw)
| 63319 | { |  | 63271 | {
| 63320 | using namespace cv::kinfu; |  | 63272 | using namespace cv::kinfu;
| 63321 |  |  | 63273 |
| 63322 |  |  | 63274 |
| 63323 | Ptr<cv::kinfu::KinFu> * self1 = 0; |  | 63275 | Ptr<cv::kinfu::KinFu> * self1 = 0;
| 63324 | if (!pyopencv_kinfu_KinFu_getp(self, self1)) |  | 63276 | if (!pyopencv_kinfu_KinFu_getp(self, self1))
| 63325 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)"); |  | 63277 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)");
| 63326 | Ptr<cv::kinfu::KinFu> _self_ = *(self1); |  | 63278 | Ptr<cv::kinfu::KinFu> _self_ = *(self1);
| 63327 | pyPrepareArgumentConversionErrorsStorage(2); |  | 63279 | pyPrepareArgumentConversionErrorsStorage(2);
| 63328 |  |  | 63280 |
| 63329 | { |  | 63281 | {
| 63330 | PyObject* pyobj_points = NULL; |  | 63282 | PyObject* pyobj_points = NULL;
| 63331 | Mat points; |  | 63283 | Mat points;
| 63332 | PyObject* pyobj_normals = NULL; |  | 63284 | PyObject* pyobj_normals = NULL;
| 63333 | Mat normals; |  | 63285 | Mat normals;
| 63334 |  |  | 63286 |
| 63335 | const char* keywords[] = { "points", "normals", NULL }; |  | 63287 | const char* keywords[] = { "points", "normals", NULL };
| 63336 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 63288 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 63337 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 63289 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 63338 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 63290 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 63339 | { |  | 63291 | {
| 63340 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 63292 | ERRWRAP2(_self_->getNormals(points, normals));
| 63341 | return pyopencv_from(normals); |  | 63293 | return pyopencv_from(normals);
| 63342 | } |  | 63294 | }
| 63343 |  |  | 63295 |
| 63344 |  |  | 63296 |
| 63345 | pyPopulateArgumentConversionErrors(); |  | 63297 | pyPopulateArgumentConversionErrors();
| 63346 | } |  | 63298 | }
| 63347 |  |  | 63299 |
| 63348 |  |  | 63300 |
| 63349 | { |  | 63301 | {
| 63350 | PyObject* pyobj_points = NULL; |  | 63302 | PyObject* pyobj_points = NULL;
| 63351 | UMat points; |  | 63303 | UMat points;
| 63352 | PyObject* pyobj_normals = NULL; |  | 63304 | PyObject* pyobj_normals = NULL;
| 63353 | UMat normals; |  | 63305 | UMat normals;
| 63354 |  |  | 63306 |
| 63355 | const char* keywords[] = { "points", "normals", NULL }; |  | 63307 | const char* keywords[] = { "points", "normals", NULL };
| 63356 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 63308 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 63357 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 63309 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 63358 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 63310 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 63359 | { |  | 63311 | {
| 63360 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 63312 | ERRWRAP2(_self_->getNormals(points, normals));
| 63361 | return pyopencv_from(normals); |  | 63313 | return pyopencv_from(normals);
| 63362 | } |  | 63314 | }
| 63363 |  |  | 63315 |
| 63364 |  |  | 63316 |
| 63365 | pyPopulateArgumentConversionErrors(); |  | 63317 | pyPopulateArgumentConversionErrors();
| 63366 | } |  | 63318 | }
| 63367 | pyRaiseCVOverloadException("getNormals"); |  | 63319 | pyRaiseCVOverloadException("getNormals");
| 63368 |  |  | 63320 |
| 63369 | return NULL; |  | 63321 | return NULL;
| 63370 | } |  | 63322 | }
| 63371 |  |  | 63323 |
| 63372 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63324 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 63373 | { |  | 63325 | {
| 63374 | using namespace cv::kinfu; |  | 63326 | using namespace cv::kinfu;
| 63375 |  |  | 63327 |
| 63376 |  |  | 63328 |
| 63377 | Ptr<cv::kinfu::KinFu> * self1 = 0; |  | 63329 | Ptr<cv::kinfu::KinFu> * self1 = 0;
| 63378 | if (!pyopencv_kinfu_KinFu_getp(self, self1)) |  | 63330 | if (!pyopencv_kinfu_KinFu_getp(self, self1))
| 63379 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)"); |  | 63331 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)");
| 63380 | Ptr<cv::kinfu::KinFu> _self_ = *(self1); |  | 63332 | Ptr<cv::kinfu::KinFu> _self_ = *(self1);
| 63381 | pyPrepareArgumentConversionErrorsStorage(2); |  | 63333 | pyPrepareArgumentConversionErrorsStorage(2);
| 63382 |  |  | 63334 |
| 63383 | { |  | 63335 | {
| 63384 | PyObject* pyobj_points = NULL; |  | 63336 | PyObject* pyobj_points = NULL;
| 63385 | Mat points; |  | 63337 | Mat points;
| 63386 |  |  | 63338 |
| 63387 | const char* keywords[] = { "points", NULL }; |  | 63339 | const char* keywords[] = { "points", NULL };
| 63388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.getPoints", (char**)keywords, &pyobj_points) && |  | 63340 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.getPoints", (char**)keywords, &pyobj_points) &&
| 63389 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 63341 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 63390 | { |  | 63342 | {
| 63391 | ERRWRAP2(_self_->getPoints(points)); |  | 63343 | ERRWRAP2(_self_->getPoints(points));
| 63392 | return pyopencv_from(points); |  | 63344 | return pyopencv_from(points);
| 63393 | } |  | 63345 | }
| 63394 |  |  | 63346 |
| 63395 |  |  | 63347 |
| 63396 | pyPopulateArgumentConversionErrors(); |  | 63348 | pyPopulateArgumentConversionErrors();
| 63397 | } |  | 63349 | }
| 63398 |  |  | 63350 |
| 63399 |  |  | 63351 |
| 63400 | { |  | 63352 | {
| 63401 | PyObject* pyobj_points = NULL; |  | 63353 | PyObject* pyobj_points = NULL;
| 63402 | UMat points; |  | 63354 | UMat points;
| 63403 |  |  | 63355 |
| 63404 | const char* keywords[] = { "points", NULL }; |  | 63356 | const char* keywords[] = { "points", NULL };
| 63405 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.getPoints", (char**)keywords, &pyobj_points) && |  | 63357 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.getPoints", (char**)keywords, &pyobj_points) &&
| 63406 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 63358 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 63407 | { |  | 63359 | {
| 63408 | ERRWRAP2(_self_->getPoints(points)); |  | 63360 | ERRWRAP2(_self_->getPoints(points));
| 63409 | return pyopencv_from(points); |  | 63361 | return pyopencv_from(points);
| 63410 | } |  | 63362 | }
| 63411 |  |  | 63363 |
| 63412 |  |  | 63364 |
| 63413 | pyPopulateArgumentConversionErrors(); |  | 63365 | pyPopulateArgumentConversionErrors();
| 63414 | } |  | 63366 | }
| 63415 | pyRaiseCVOverloadException("getPoints"); |  | 63367 | pyRaiseCVOverloadException("getPoints");
| 63416 |  |  | 63368 |
| 63417 | return NULL; |  | 63369 | return NULL;
| 63418 | } |  | 63370 | }
| 63419 |  |  | 63371 |
| 63420 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_render(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63372 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_render(PyObject* self, PyObject* py_args, PyObject* kw)
| 63421 | { |  | 63373 | {
| 63422 | using namespace cv::kinfu; |  | 63374 | using namespace cv::kinfu;
| 63423 |  |  | 63375 |
| 63424 |  |  | 63376 |
| 63425 | Ptr<cv::kinfu::KinFu> * self1 = 0; |  | 63377 | Ptr<cv::kinfu::KinFu> * self1 = 0;
| 63426 | if (!pyopencv_kinfu_KinFu_getp(self, self1)) |  | 63378 | if (!pyopencv_kinfu_KinFu_getp(self, self1))
| 63427 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)"); |  | 63379 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)");
| 63428 | Ptr<cv::kinfu::KinFu> _self_ = *(self1); |  | 63380 | Ptr<cv::kinfu::KinFu> _self_ = *(self1);
| 63429 | pyPrepareArgumentConversionErrorsStorage(4); |  | 63381 | pyPrepareArgumentConversionErrorsStorage(4);
| 63430 |  |  | 63382 |
| 63431 | { |  | 63383 | {
| 63432 | PyObject* pyobj_image = NULL; |  | 63384 | PyObject* pyobj_image = NULL;
| 63433 | Mat image; |  | 63385 | Mat image;
| 63434 |  |  | 63386 |
| 63435 | const char* keywords[] = { "image", NULL }; |  | 63387 | const char* keywords[] = { "image", NULL };
| 63436 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.render", (char**)keywords, &pyobj_image) && |  | 63388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.render", (char**)keywords, &pyobj_image) &&
| 63437 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 63389 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 63438 | { |  | 63390 | {
| 63439 | ERRWRAP2(_self_->render(image)); |  | 63391 | ERRWRAP2(_self_->render(image));
| 63440 | return pyopencv_from(image); |  | 63392 | return pyopencv_from(image);
| 63441 | } |  | 63393 | }
| 63442 |  |  | 63394 |
| 63443 |  |  | 63395 |
| 63444 | pyPopulateArgumentConversionErrors(); |  | 63396 | pyPopulateArgumentConversionErrors();
| 63445 | } |  | 63397 | }
| 63446 |  |  | 63398 |
| 63447 |  |  | 63399 |
| 63448 | { |  | 63400 | {
| 63449 | PyObject* pyobj_image = NULL; |  | 63401 | PyObject* pyobj_image = NULL;
| 63450 | Mat image; |  | 63402 | Mat image;
| 63451 | PyObject* pyobj_cameraPose = NULL; |  | 63403 | PyObject* pyobj_cameraPose = NULL;
| 63452 | Matx44f cameraPose; |  | 63404 | Matx44f cameraPose;
| 63453 |  |  | 63405 |
| 63454 | const char* keywords[] = { "cameraPose", "image", NULL }; |  | 63406 | const char* keywords[] = { "cameraPose", "image", NULL };
| 63455 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) && |  | 63407 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) &&
| 63456 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 63408 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 63457 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 63409 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 63458 | { |  | 63410 | {
| 63459 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 63411 | ERRWRAP2(_self_->render(image, cameraPose));
| 63460 | return pyopencv_from(image); |  | 63412 | return pyopencv_from(image);
| 63461 | } |  | 63413 | }
| 63462 |  |  | 63414 |
| 63463 |  |  | 63415 |
| 63464 | pyPopulateArgumentConversionErrors(); |  | 63416 | pyPopulateArgumentConversionErrors();
| 63465 | } |  | 63417 | }
| 63466 |  |  | 63418 |
| 63467 |  |  | 63419 |
| 63468 | { |  | 63420 | {
| 63469 | PyObject* pyobj_image = NULL; |  | 63421 | PyObject* pyobj_image = NULL;
| 63470 | UMat image; |  | 63422 | UMat image;
| 63471 |  |  | 63423 |
| 63472 | const char* keywords[] = { "image", NULL }; |  | 63424 | const char* keywords[] = { "image", NULL };
| 63473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.render", (char**)keywords, &pyobj_image) && |  | 63425 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:kinfu_KinFu.render", (char**)keywords, &pyobj_image) &&
| 63474 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 63426 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 63475 | { |  | 63427 | {
| 63476 | ERRWRAP2(_self_->render(image)); |  | 63428 | ERRWRAP2(_self_->render(image));
| 63477 | return pyopencv_from(image); |  | 63429 | return pyopencv_from(image);
| 63478 | } |  | 63430 | }
| 63479 |  |  | 63431 |
| 63480 |  |  | 63432 |
| 63481 | pyPopulateArgumentConversionErrors(); |  | 63433 | pyPopulateArgumentConversionErrors();
| 63482 | } |  | 63434 | }
| 63483 |  |  | 63435 |
| 63484 |  |  | 63436 |
| 63485 | { |  | 63437 | {
| 63486 | PyObject* pyobj_image = NULL; |  | 63438 | PyObject* pyobj_image = NULL;
| 63487 | UMat image; |  | 63439 | UMat image;
| 63488 | PyObject* pyobj_cameraPose = NULL; |  | 63440 | PyObject* pyobj_cameraPose = NULL;
| 63489 | Matx44f cameraPose; |  | 63441 | Matx44f cameraPose;
| 63490 |  |  | 63442 |
| 63491 | const char* keywords[] = { "cameraPose", "image", NULL }; |  | 63443 | const char* keywords[] = { "cameraPose", "image", NULL };
| 63492 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) && |  | 63444 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:kinfu_KinFu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) &&
| 63493 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 63445 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 63494 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 63446 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 63495 | { |  | 63447 | {
| 63496 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 63448 | ERRWRAP2(_self_->render(image, cameraPose));
| 63497 | return pyopencv_from(image); |  | 63449 | return pyopencv_from(image);
| 63498 | } |  | 63450 | }
| 63499 |  |  | 63451 |
| 63500 |  |  | 63452 |
| 63501 | pyPopulateArgumentConversionErrors(); |  | 63453 | pyPopulateArgumentConversionErrors();
| 63502 | } |  | 63454 | }
| 63503 | pyRaiseCVOverloadException("render"); |  | 63455 | pyRaiseCVOverloadException("render");
| 63504 |  |  | 63456 |
| 63505 | return NULL; |  | 63457 | return NULL;
| 63506 | } |  | 63458 | }
| 63507 |  |  | 63459 |
| 63508 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_reset(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63460 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_reset(PyObject* self, PyObject* py_args, PyObject* kw)
| 63509 | { |  | 63461 | {
| 63510 | using namespace cv::kinfu; |  | 63462 | using namespace cv::kinfu;
| 63511 |  |  | 63463 |
| 63512 |  |  | 63464 |
| 63513 | Ptr<cv::kinfu::KinFu> * self1 = 0; |  | 63465 | Ptr<cv::kinfu::KinFu> * self1 = 0;
| 63514 | if (!pyopencv_kinfu_KinFu_getp(self, self1)) |  | 63466 | if (!pyopencv_kinfu_KinFu_getp(self, self1))
| 63515 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)"); |  | 63467 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)");
| 63516 | Ptr<cv::kinfu::KinFu> _self_ = *(self1); |  | 63468 | Ptr<cv::kinfu::KinFu> _self_ = *(self1);
| 63517 |  |  | 63469 |
| 63518 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 63470 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 63519 | { |  | 63471 | {
| 63520 | ERRWRAP2(_self_->reset()); |  | 63472 | ERRWRAP2(_self_->reset());
| 63521 | Py_RETURN_NONE; |  | 63473 | Py_RETURN_NONE;
| 63522 | } |  | 63474 | }
| 63523 |  |  | 63475 |
| 63524 | return NULL; |  | 63476 | return NULL;
| 63525 | } |  | 63477 | }
| 63526 |  |  | 63478 |
| 63527 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63479 | static PyObject* pyopencv_cv_kinfu_kinfu_KinFu_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 63528 | { |  | 63480 | {
| 63529 | using namespace cv::kinfu; |  | 63481 | using namespace cv::kinfu;
| 63530 |  |  | 63482 |
| 63531 |  |  | 63483 |
| 63532 | Ptr<cv::kinfu::KinFu> * self1 = 0; |  | 63484 | Ptr<cv::kinfu::KinFu> * self1 = 0;
| 63533 | if (!pyopencv_kinfu_KinFu_getp(self, self1)) |  | 63485 | if (!pyopencv_kinfu_KinFu_getp(self, self1))
| 63534 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)"); |  | 63486 | return failmsgp("Incorrect type of self (must be 'kinfu_KinFu' or its derivative)");
| 63535 | Ptr<cv::kinfu::KinFu> _self_ = *(self1); |  | 63487 | Ptr<cv::kinfu::KinFu> _self_ = *(self1);
| 63536 | pyPrepareArgumentConversionErrorsStorage(2); |  | 63488 | pyPrepareArgumentConversionErrorsStorage(2);
| 63537 |  |  | 63489 |
| 63538 | { |  | 63490 | {
| 63539 | PyObject* pyobj_depth = NULL; |  | 63491 | PyObject* pyobj_depth = NULL;
| 63540 | Mat depth; |  | 63492 | Mat depth;
| 63541 | bool retval; |  | 63493 | bool retval;
| 63542 |  |  | 63494 |
| 63543 | const char* keywords[] = { "depth", NULL }; |  | 63495 | const char* keywords[] = { "depth", NULL };
| 63544 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_KinFu.update", (char**)keywords, &pyobj_depth) && |  | 63496 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_KinFu.update", (char**)keywords, &pyobj_depth) &&
| 63545 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) ) |  | 63497 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) )
| 63546 | { |  | 63498 | {
| 63547 | ERRWRAP2(retval = _self_->update(depth)); |  | 63499 | ERRWRAP2(retval = _self_->update(depth));
| 63548 | return pyopencv_from(retval); |  | 63500 | return pyopencv_from(retval);
| 63549 | } |  | 63501 | }
| 63550 |  |  | 63502 |
| 63551 |  |  | 63503 |
| 63552 | pyPopulateArgumentConversionErrors(); |  | 63504 | pyPopulateArgumentConversionErrors();
| 63553 | } |  | 63505 | }
| 63554 |  |  | 63506 |
| 63555 |  |  | 63507 |
| 63556 | { |  | 63508 | {
| 63557 | PyObject* pyobj_depth = NULL; |  | 63509 | PyObject* pyobj_depth = NULL;
| 63558 | UMat depth; |  | 63510 | UMat depth;
| 63559 | bool retval; |  | 63511 | bool retval;
| 63560 |  |  | 63512 |
| 63561 | const char* keywords[] = { "depth", NULL }; |  | 63513 | const char* keywords[] = { "depth", NULL };
| 63562 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_KinFu.update", (char**)keywords, &pyobj_depth) && |  | 63514 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_KinFu.update", (char**)keywords, &pyobj_depth) &&
| 63563 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) ) |  | 63515 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) )
| 63564 | { |  | 63516 | {
| 63565 | ERRWRAP2(retval = _self_->update(depth)); |  | 63517 | ERRWRAP2(retval = _self_->update(depth));
| 63566 | return pyopencv_from(retval); |  | 63518 | return pyopencv_from(retval);
| 63567 | } |  | 63519 | }
| 63568 |  |  | 63520 |
| 63569 |  |  | 63521 |
| 63570 | pyPopulateArgumentConversionErrors(); |  | 63522 | pyPopulateArgumentConversionErrors();
| 63571 | } |  | 63523 | }
| 63572 | pyRaiseCVOverloadException("update"); |  | 63524 | pyRaiseCVOverloadException("update");
| 63573 |  |  | 63525 |
| 63574 | return NULL; |  | 63526 | return NULL;
| 63575 | } |  | 63527 | }
| 63576 |  |  | 63528 |
| 63577 |  |  | 63529 |
| 63578 |  |  | 63530 |
| 63579 | // Tables (kinfu_KinFu) |  | 63531 | // Tables (kinfu_KinFu)
| 63580 |  |  | 63532 |
| 63581 | static PyGetSetDef pyopencv_kinfu_KinFu_getseters[] = |  | 63533 | static PyGetSetDef pyopencv_kinfu_KinFu_getseters[] =
| 63582 | { |  | 63534 | {
| 63583 | {NULL} /* Sentinel */ |  | 63535 | {NULL} /* Sentinel */
| 63584 | }; |  | 63536 | };
| 63585 |  |  | 63537 |
| 63586 | static PyMethodDef pyopencv_kinfu_KinFu_methods[] = |  | 63538 | static PyMethodDef pyopencv_kinfu_KinFu_methods[] =
| 63587 | { |  | 63539 | {
| 63588 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_create_static, METH_STATIC), "create(_params) -> retval\n."}, |  | 63540 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_create_static, METH_STATIC), "create(_params) -> retval\n."},
| 63589 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_getCloud, 0), "getCloud([, points[, normals]]) -> points, normals\n. @brief Gets points and normals of current 3d mesh\n. \n. The order of normals corresponds to order of points.\n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors\n. @param normals vector of normals which are 4-float vectors"}, |  | 63541 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_getCloud, 0), "getCloud([, points[, normals]]) -> points, normals\n. @brief Gets points and normals of current 3d mesh\n. \n. The order of normals corresponds to order of points.\n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors\n. @param normals vector of normals which are 4-float vectors"},
| 63590 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_getNormals, 0), "getNormals(points[, normals]) -> normals\n. @brief Calculates normals for given points\n. @param points input vector of points which are 4-float vectors\n. @param normals output vector of corresponding normals which are 4-float vectors"}, |  | 63542 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_getNormals, 0), "getNormals(points[, normals]) -> normals\n. @brief Calculates normals for given points\n. @param points input vector of points which are 4-float vectors\n. @param normals output vector of corresponding normals which are 4-float vectors"},
| 63591 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_getPoints, 0), "getPoints([, points]) -> points\n. @brief Gets points of current 3d mesh\n. \n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors"}, |  | 63543 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_getPoints, 0), "getPoints([, points]) -> points\n. @brief Gets points of current 3d mesh\n. \n. The order of points is undefined.\n. \n. @param points vector of points which are 4-float vectors"},
| 63592 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_render, 0), "render([, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n\n\n\nrender(cameraPose[, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n. @param cameraPose pose of camera to render from. If empty then render from current pose\n. which is a last frame camera pose."}, |  | 63544 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_render, 0), "render([, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n\n\n\nrender(cameraPose[, image]) -> image\n. @brief Renders a volume into an image\n. \n. Renders a 0-surface of TSDF using Phong shading into a CV_8UC4 Mat.\n. Light pose is fixed in KinFu params.\n. \n. @param image resulting image\n. @param cameraPose pose of camera to render from. If empty then render from current pose\n. which is a last frame camera pose."},
| 63593 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_reset, 0), "reset() -> None\n. @brief Resets the algorithm\n. \n. Clears current model and resets a pose."}, |  | 63545 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_reset, 0), "reset() -> None\n. @brief Resets the algorithm\n. \n. Clears current model and resets a pose."},
| 63594 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_update, 0), "update(depth) -> retval\n. @brief Process next depth frame\n. \n. Integrates depth into voxel space with respect to its ICP-calculated pose.\n. Input image is converted to CV_32F internally if has another type.\n. \n. @param depth one-channel image which size and depth scale is described in algorithm's parameters\n. @return true if succeeded to align new frame with current scene, false if opposite"}, |  | 63546 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_KinFu_update, 0), "update(depth) -> retval\n. @brief Process next depth frame\n. \n. Integrates depth into voxel space with respect to its ICP-calculated pose.\n. Input image is converted to CV_32F internally if has another type.\n. \n. @param depth one-channel image which size and depth scale is described in algorithm's parameters\n. @return true if succeeded to align new frame with current scene, false if opposite"},
| 63595 |  |  | 63547 |
| 63596 | {NULL, NULL} |  | 63548 | {NULL, NULL}
| 63597 | }; |  | 63549 | };
| 63598 |  |  | 63550 |
| 63599 | // Converter (kinfu_KinFu) |  | 63551 | // Converter (kinfu_KinFu)
| 63600 |  |  | 63552 |
| 63601 | template<> |  | 63553 | template<>
| 63602 | struct PyOpenCV_Converter< Ptr<cv::kinfu::KinFu> > |  | 63554 | struct PyOpenCV_Converter< Ptr<cv::kinfu::KinFu> >
| 63603 | { |  | 63555 | {
| 63604 | static PyObject* from(const Ptr<cv::kinfu::KinFu>& r) |  | 63556 | static PyObject* from(const Ptr<cv::kinfu::KinFu>& r)
| 63605 | { |  | 63557 | {
| 63606 | return pyopencv_kinfu_KinFu_Instance(r); |  | 63558 | return pyopencv_kinfu_KinFu_Instance(r);
| 63607 | } |  | 63559 | }
| 63608 | static bool to(PyObject* src, Ptr<cv::kinfu::KinFu>& dst, const ArgInfo& info) |  | 63560 | static bool to(PyObject* src, Ptr<cv::kinfu::KinFu>& dst, const ArgInfo& info)
| 63609 | { |  | 63561 | {
| 63610 | if(!src || src == Py_None) |  | 63562 | if(!src || src == Py_None)
| 63611 | return true; |  | 63563 | return true;
| 63612 | Ptr<cv::kinfu::KinFu> * dst_; |  | 63564 | Ptr<cv::kinfu::KinFu> * dst_;
| 63613 | if (pyopencv_kinfu_KinFu_getp(src, dst_)) |  | 63565 | if (pyopencv_kinfu_KinFu_getp(src, dst_))
| 63614 | { |  | 63566 | {
| 63615 | dst = *dst_; |  | 63567 | dst = *dst_;
| 63616 | return true; |  | 63568 | return true;
| 63617 | } |  | 63569 | }
| 63618 |  |  | 63570 |
| 63619 | failmsg("Expected Ptr<cv::kinfu::KinFu> for argument '%s'", info.name); |  | 63571 | failmsg("Expected Ptr<cv::kinfu::KinFu> for argument '%s'", info.name);
| 63620 | return false; |  | 63572 | return false;
| 63621 | } |  | 63573 | }
| 63622 | }; |  | 63574 | };
| 63623 |  |  | 63575 |
| 63624 | //================================================================================ |  | 63576 | //================================================================================
| 63625 | // kinfu_Params (Generic) |  | 63577 | // kinfu_Params (Generic)
| 63626 | //================================================================================ |  | 63578 | //================================================================================
| 63627 |  |  | 63579 |
| 63628 | // GetSet (kinfu_Params) |  | 63580 | // GetSet (kinfu_Params)
| 63629 |  |  | 63581 |
| 63630 |  |  | 63582 |
| 63631 | static PyObject* pyopencv_kinfu_Params_get_bilateral_kernel_size(pyopencv_kinfu_Params_t* p, void *closure) |  | 63583 | static PyObject* pyopencv_kinfu_Params_get_bilateral_kernel_size(pyopencv_kinfu_Params_t* p, void *closure)
| 63632 | { |  | 63584 | {
| 63633 | return pyopencv_from(p->v->bilateral_kernel_size); |  | 63585 | return pyopencv_from(p->v->bilateral_kernel_size);
| 63634 | } |  | 63586 | }
| 63635 |  |  | 63587 |
| 63636 | static int pyopencv_kinfu_Params_set_bilateral_kernel_size(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63588 | static int pyopencv_kinfu_Params_set_bilateral_kernel_size(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63637 | { |  | 63589 | {
| 63638 | if (!value) |  | 63590 | if (!value)
| 63639 | { |  | 63591 | {
| 63640 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_kernel_size attribute"); |  | 63592 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_kernel_size attribute");
| 63641 | return -1; |  | 63593 | return -1;
| 63642 | } |  | 63594 | }
| 63643 | return pyopencv_to_safe(value, p->v->bilateral_kernel_size, ArgInfo("value", 0)) ? 0 : -1; |  | 63595 | return pyopencv_to_safe(value, p->v->bilateral_kernel_size, ArgInfo("value", 0)) ? 0 : -1;
| 63644 | } |  | 63596 | }
| 63645 |  |  | 63597 |
| 63646 | static PyObject* pyopencv_kinfu_Params_get_bilateral_sigma_depth(pyopencv_kinfu_Params_t* p, void *closure) |  | 63598 | static PyObject* pyopencv_kinfu_Params_get_bilateral_sigma_depth(pyopencv_kinfu_Params_t* p, void *closure)
| 63647 | { |  | 63599 | {
| 63648 | return pyopencv_from(p->v->bilateral_sigma_depth); |  | 63600 | return pyopencv_from(p->v->bilateral_sigma_depth);
| 63649 | } |  | 63601 | }
| 63650 |  |  | 63602 |
| 63651 | static int pyopencv_kinfu_Params_set_bilateral_sigma_depth(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63603 | static int pyopencv_kinfu_Params_set_bilateral_sigma_depth(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63652 | { |  | 63604 | {
| 63653 | if (!value) |  | 63605 | if (!value)
| 63654 | { |  | 63606 | {
| 63655 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_depth attribute"); |  | 63607 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_depth attribute");
| 63656 | return -1; |  | 63608 | return -1;
| 63657 | } |  | 63609 | }
| 63658 | return pyopencv_to_safe(value, p->v->bilateral_sigma_depth, ArgInfo("value", 0)) ? 0 : -1; |  | 63610 | return pyopencv_to_safe(value, p->v->bilateral_sigma_depth, ArgInfo("value", 0)) ? 0 : -1;
| 63659 | } |  | 63611 | }
| 63660 |  |  | 63612 |
| 63661 | static PyObject* pyopencv_kinfu_Params_get_bilateral_sigma_spatial(pyopencv_kinfu_Params_t* p, void *closure) |  | 63613 | static PyObject* pyopencv_kinfu_Params_get_bilateral_sigma_spatial(pyopencv_kinfu_Params_t* p, void *closure)
| 63662 | { |  | 63614 | {
| 63663 | return pyopencv_from(p->v->bilateral_sigma_spatial); |  | 63615 | return pyopencv_from(p->v->bilateral_sigma_spatial);
| 63664 | } |  | 63616 | }
| 63665 |  |  | 63617 |
| 63666 | static int pyopencv_kinfu_Params_set_bilateral_sigma_spatial(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63618 | static int pyopencv_kinfu_Params_set_bilateral_sigma_spatial(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63667 | { |  | 63619 | {
| 63668 | if (!value) |  | 63620 | if (!value)
| 63669 | { |  | 63621 | {
| 63670 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_spatial attribute"); |  | 63622 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_spatial attribute");
| 63671 | return -1; |  | 63623 | return -1;
| 63672 | } |  | 63624 | }
| 63673 | return pyopencv_to_safe(value, p->v->bilateral_sigma_spatial, ArgInfo("value", 0)) ? 0 : -1; |  | 63625 | return pyopencv_to_safe(value, p->v->bilateral_sigma_spatial, ArgInfo("value", 0)) ? 0 : -1;
| 63674 | } |  | 63626 | }
| 63675 |  |  | 63627 |
| 63676 | static PyObject* pyopencv_kinfu_Params_get_depthFactor(pyopencv_kinfu_Params_t* p, void *closure) |  | 63628 | static PyObject* pyopencv_kinfu_Params_get_depthFactor(pyopencv_kinfu_Params_t* p, void *closure)
| 63677 | { |  | 63629 | {
| 63678 | return pyopencv_from(p->v->depthFactor); |  | 63630 | return pyopencv_from(p->v->depthFactor);
| 63679 | } |  | 63631 | }
| 63680 |  |  | 63632 |
| 63681 | static int pyopencv_kinfu_Params_set_depthFactor(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63633 | static int pyopencv_kinfu_Params_set_depthFactor(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63682 | { |  | 63634 | {
| 63683 | if (!value) |  | 63635 | if (!value)
| 63684 | { |  | 63636 | {
| 63685 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthFactor attribute"); |  | 63637 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthFactor attribute");
| 63686 | return -1; |  | 63638 | return -1;
| 63687 | } |  | 63639 | }
| 63688 | return pyopencv_to_safe(value, p->v->depthFactor, ArgInfo("value", 0)) ? 0 : -1; |  | 63640 | return pyopencv_to_safe(value, p->v->depthFactor, ArgInfo("value", 0)) ? 0 : -1;
| 63689 | } |  | 63641 | }
| 63690 |  |  | 63642 |
| 63691 | static PyObject* pyopencv_kinfu_Params_get_frameSize(pyopencv_kinfu_Params_t* p, void *closure) |  | 63643 | static PyObject* pyopencv_kinfu_Params_get_frameSize(pyopencv_kinfu_Params_t* p, void *closure)
| 63692 | { |  | 63644 | {
| 63693 | return pyopencv_from(p->v->frameSize); |  | 63645 | return pyopencv_from(p->v->frameSize);
| 63694 | } |  | 63646 | }
| 63695 |  |  | 63647 |
| 63696 | static int pyopencv_kinfu_Params_set_frameSize(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63648 | static int pyopencv_kinfu_Params_set_frameSize(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63697 | { |  | 63649 | {
| 63698 | if (!value) |  | 63650 | if (!value)
| 63699 | { |  | 63651 | {
| 63700 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frameSize attribute"); |  | 63652 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frameSize attribute");
| 63701 | return -1; |  | 63653 | return -1;
| 63702 | } |  | 63654 | }
| 63703 | return pyopencv_to_safe(value, p->v->frameSize, ArgInfo("value", 0)) ? 0 : -1; |  | 63655 | return pyopencv_to_safe(value, p->v->frameSize, ArgInfo("value", 0)) ? 0 : -1;
| 63704 | } |  | 63656 | }
| 63705 |  |  | 63657 |
| 63706 | static PyObject* pyopencv_kinfu_Params_get_icpAngleThresh(pyopencv_kinfu_Params_t* p, void *closure) |  | 63658 | static PyObject* pyopencv_kinfu_Params_get_icpAngleThresh(pyopencv_kinfu_Params_t* p, void *closure)
| 63707 | { |  | 63659 | {
| 63708 | return pyopencv_from(p->v->icpAngleThresh); |  | 63660 | return pyopencv_from(p->v->icpAngleThresh);
| 63709 | } |  | 63661 | }
| 63710 |  |  | 63662 |
| 63711 | static int pyopencv_kinfu_Params_set_icpAngleThresh(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63663 | static int pyopencv_kinfu_Params_set_icpAngleThresh(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63712 | { |  | 63664 | {
| 63713 | if (!value) |  | 63665 | if (!value)
| 63714 | { |  | 63666 | {
| 63715 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpAngleThresh attribute"); |  | 63667 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpAngleThresh attribute");
| 63716 | return -1; |  | 63668 | return -1;
| 63717 | } |  | 63669 | }
| 63718 | return pyopencv_to_safe(value, p->v->icpAngleThresh, ArgInfo("value", 0)) ? 0 : -1; |  | 63670 | return pyopencv_to_safe(value, p->v->icpAngleThresh, ArgInfo("value", 0)) ? 0 : -1;
| 63719 | } |  | 63671 | }
| 63720 |  |  | 63672 |
| 63721 | static PyObject* pyopencv_kinfu_Params_get_icpDistThresh(pyopencv_kinfu_Params_t* p, void *closure) |  | 63673 | static PyObject* pyopencv_kinfu_Params_get_icpDistThresh(pyopencv_kinfu_Params_t* p, void *closure)
| 63722 | { |  | 63674 | {
| 63723 | return pyopencv_from(p->v->icpDistThresh); |  | 63675 | return pyopencv_from(p->v->icpDistThresh);
| 63724 | } |  | 63676 | }
| 63725 |  |  | 63677 |
| 63726 | static int pyopencv_kinfu_Params_set_icpDistThresh(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63678 | static int pyopencv_kinfu_Params_set_icpDistThresh(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63727 | { |  | 63679 | {
| 63728 | if (!value) |  | 63680 | if (!value)
| 63729 | { |  | 63681 | {
| 63730 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpDistThresh attribute"); |  | 63682 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpDistThresh attribute");
| 63731 | return -1; |  | 63683 | return -1;
| 63732 | } |  | 63684 | }
| 63733 | return pyopencv_to_safe(value, p->v->icpDistThresh, ArgInfo("value", 0)) ? 0 : -1; |  | 63685 | return pyopencv_to_safe(value, p->v->icpDistThresh, ArgInfo("value", 0)) ? 0 : -1;
| 63734 | } |  | 63686 | }
| 63735 |  |  | 63687 |
| 63736 | static PyObject* pyopencv_kinfu_Params_get_icpIterations(pyopencv_kinfu_Params_t* p, void *closure) |  | 63688 | static PyObject* pyopencv_kinfu_Params_get_icpIterations(pyopencv_kinfu_Params_t* p, void *closure)
| 63737 | { |  | 63689 | {
| 63738 | return pyopencv_from(p->v->icpIterations); |  | 63690 | return pyopencv_from(p->v->icpIterations);
| 63739 | } |  | 63691 | }
| 63740 |  |  | 63692 |
| 63741 | static int pyopencv_kinfu_Params_set_icpIterations(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63693 | static int pyopencv_kinfu_Params_set_icpIterations(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63742 | { |  | 63694 | {
| 63743 | if (!value) |  | 63695 | if (!value)
| 63744 | { |  | 63696 | {
| 63745 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpIterations attribute"); |  | 63697 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpIterations attribute");
| 63746 | return -1; |  | 63698 | return -1;
| 63747 | } |  | 63699 | }
| 63748 | return pyopencv_to_safe(value, p->v->icpIterations, ArgInfo("value", 0)) ? 0 : -1; |  | 63700 | return pyopencv_to_safe(value, p->v->icpIterations, ArgInfo("value", 0)) ? 0 : -1;
| 63749 | } |  | 63701 | }
| 63750 |  |  | 63702 |
| 63751 | static PyObject* pyopencv_kinfu_Params_get_intr(pyopencv_kinfu_Params_t* p, void *closure) |  | 63703 | static PyObject* pyopencv_kinfu_Params_get_intr(pyopencv_kinfu_Params_t* p, void *closure)
| 63752 | { |  | 63704 | {
| 63753 | return pyopencv_from(p->v->intr); |  | 63705 | return pyopencv_from(p->v->intr);
| 63754 | } |  | 63706 | }
| 63755 |  |  | 63707 |
| 63756 | static int pyopencv_kinfu_Params_set_intr(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63708 | static int pyopencv_kinfu_Params_set_intr(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63757 | { |  | 63709 | {
| 63758 | if (!value) |  | 63710 | if (!value)
| 63759 | { |  | 63711 | {
| 63760 | PyErr_SetString(PyExc_TypeError, "Cannot delete the intr attribute"); |  | 63712 | PyErr_SetString(PyExc_TypeError, "Cannot delete the intr attribute");
| 63761 | return -1; |  | 63713 | return -1;
| 63762 | } |  | 63714 | }
| 63763 | return pyopencv_to_safe(value, p->v->intr, ArgInfo("value", 0)) ? 0 : -1; |  | 63715 | return pyopencv_to_safe(value, p->v->intr, ArgInfo("value", 0)) ? 0 : -1;
| 63764 | } |  | 63716 | }
| 63765 |  |  | 63717 |
| 63766 | static PyObject* pyopencv_kinfu_Params_get_lightPose(pyopencv_kinfu_Params_t* p, void *closure) |  | 63718 | static PyObject* pyopencv_kinfu_Params_get_lightPose(pyopencv_kinfu_Params_t* p, void *closure)
| 63767 | { |  | 63719 | {
| 63768 | return pyopencv_from(p->v->lightPose); |  | 63720 | return pyopencv_from(p->v->lightPose);
| 63769 | } |  | 63721 | }
| 63770 |  |  | 63722 |
| 63771 | static int pyopencv_kinfu_Params_set_lightPose(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63723 | static int pyopencv_kinfu_Params_set_lightPose(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63772 | { |  | 63724 | {
| 63773 | if (!value) |  | 63725 | if (!value)
| 63774 | { |  | 63726 | {
| 63775 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lightPose attribute"); |  | 63727 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lightPose attribute");
| 63776 | return -1; |  | 63728 | return -1;
| 63777 | } |  | 63729 | }
| 63778 | return pyopencv_to_safe(value, p->v->lightPose, ArgInfo("value", 0)) ? 0 : -1; |  | 63730 | return pyopencv_to_safe(value, p->v->lightPose, ArgInfo("value", 0)) ? 0 : -1;
| 63779 | } |  | 63731 | }
| 63780 |  |  | 63732 |
| 63781 | static PyObject* pyopencv_kinfu_Params_get_pyramidLevels(pyopencv_kinfu_Params_t* p, void *closure) |  | 63733 | static PyObject* pyopencv_kinfu_Params_get_pyramidLevels(pyopencv_kinfu_Params_t* p, void *closure)
| 63782 | { |  | 63734 | {
| 63783 | return pyopencv_from(p->v->pyramidLevels); |  | 63735 | return pyopencv_from(p->v->pyramidLevels);
| 63784 | } |  | 63736 | }
| 63785 |  |  | 63737 |
| 63786 | static int pyopencv_kinfu_Params_set_pyramidLevels(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63738 | static int pyopencv_kinfu_Params_set_pyramidLevels(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63787 | { |  | 63739 | {
| 63788 | if (!value) |  | 63740 | if (!value)
| 63789 | { |  | 63741 | {
| 63790 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pyramidLevels attribute"); |  | 63742 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pyramidLevels attribute");
| 63791 | return -1; |  | 63743 | return -1;
| 63792 | } |  | 63744 | }
| 63793 | return pyopencv_to_safe(value, p->v->pyramidLevels, ArgInfo("value", 0)) ? 0 : -1; |  | 63745 | return pyopencv_to_safe(value, p->v->pyramidLevels, ArgInfo("value", 0)) ? 0 : -1;
| 63794 | } |  | 63746 | }
| 63795 |  |  | 63747 |
| 63796 | static PyObject* pyopencv_kinfu_Params_get_raycast_step_factor(pyopencv_kinfu_Params_t* p, void *closure) |  | 63748 | static PyObject* pyopencv_kinfu_Params_get_raycast_step_factor(pyopencv_kinfu_Params_t* p, void *closure)
| 63797 | { |  | 63749 | {
| 63798 | return pyopencv_from(p->v->raycast_step_factor); |  | 63750 | return pyopencv_from(p->v->raycast_step_factor);
| 63799 | } |  | 63751 | }
| 63800 |  |  | 63752 |
| 63801 | static int pyopencv_kinfu_Params_set_raycast_step_factor(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63753 | static int pyopencv_kinfu_Params_set_raycast_step_factor(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63802 | { |  | 63754 | {
| 63803 | if (!value) |  | 63755 | if (!value)
| 63804 | { |  | 63756 | {
| 63805 | PyErr_SetString(PyExc_TypeError, "Cannot delete the raycast_step_factor attribute"); |  | 63757 | PyErr_SetString(PyExc_TypeError, "Cannot delete the raycast_step_factor attribute");
| 63806 | return -1; |  | 63758 | return -1;
| 63807 | } |  | 63759 | }
| 63808 | return pyopencv_to_safe(value, p->v->raycast_step_factor, ArgInfo("value", 0)) ? 0 : -1; |  | 63760 | return pyopencv_to_safe(value, p->v->raycast_step_factor, ArgInfo("value", 0)) ? 0 : -1;
| 63809 | } |  | 63761 | }
| 63810 |  |  | 63762 |
| 63811 | static PyObject* pyopencv_kinfu_Params_get_rgb_intr(pyopencv_kinfu_Params_t* p, void *closure) |  | 63763 | static PyObject* pyopencv_kinfu_Params_get_rgb_intr(pyopencv_kinfu_Params_t* p, void *closure)
| 63812 | { |  | 63764 | {
| 63813 | return pyopencv_from(p->v->rgb_intr); |  | 63765 | return pyopencv_from(p->v->rgb_intr);
| 63814 | } |  | 63766 | }
| 63815 |  |  | 63767 |
| 63816 | static int pyopencv_kinfu_Params_set_rgb_intr(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63768 | static int pyopencv_kinfu_Params_set_rgb_intr(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63817 | { |  | 63769 | {
| 63818 | if (!value) |  | 63770 | if (!value)
| 63819 | { |  | 63771 | {
| 63820 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_intr attribute"); |  | 63772 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_intr attribute");
| 63821 | return -1; |  | 63773 | return -1;
| 63822 | } |  | 63774 | }
| 63823 | return pyopencv_to_safe(value, p->v->rgb_intr, ArgInfo("value", 0)) ? 0 : -1; |  | 63775 | return pyopencv_to_safe(value, p->v->rgb_intr, ArgInfo("value", 0)) ? 0 : -1;
| 63824 | } |  | 63776 | }
| 63825 |  |  | 63777 |
| 63826 | static PyObject* pyopencv_kinfu_Params_get_truncateThreshold(pyopencv_kinfu_Params_t* p, void *closure) |  | 63778 | static PyObject* pyopencv_kinfu_Params_get_truncateThreshold(pyopencv_kinfu_Params_t* p, void *closure)
| 63827 | { |  | 63779 | {
| 63828 | return pyopencv_from(p->v->truncateThreshold); |  | 63780 | return pyopencv_from(p->v->truncateThreshold);
| 63829 | } |  | 63781 | }
| 63830 |  |  | 63782 |
| 63831 | static int pyopencv_kinfu_Params_set_truncateThreshold(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63783 | static int pyopencv_kinfu_Params_set_truncateThreshold(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63832 | { |  | 63784 | {
| 63833 | if (!value) |  | 63785 | if (!value)
| 63834 | { |  | 63786 | {
| 63835 | PyErr_SetString(PyExc_TypeError, "Cannot delete the truncateThreshold attribute"); |  | 63787 | PyErr_SetString(PyExc_TypeError, "Cannot delete the truncateThreshold attribute");
| 63836 | return -1; |  | 63788 | return -1;
| 63837 | } |  | 63789 | }
| 63838 | return pyopencv_to_safe(value, p->v->truncateThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 63790 | return pyopencv_to_safe(value, p->v->truncateThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 63839 | } |  | 63791 | }
| 63840 |  |  | 63792 |
| 63841 | static PyObject* pyopencv_kinfu_Params_get_tsdf_max_weight(pyopencv_kinfu_Params_t* p, void *closure) |  | 63793 | static PyObject* pyopencv_kinfu_Params_get_tsdf_max_weight(pyopencv_kinfu_Params_t* p, void *closure)
| 63842 | { |  | 63794 | {
| 63843 | return pyopencv_from(p->v->tsdf_max_weight); |  | 63795 | return pyopencv_from(p->v->tsdf_max_weight);
| 63844 | } |  | 63796 | }
| 63845 |  |  | 63797 |
| 63846 | static int pyopencv_kinfu_Params_set_tsdf_max_weight(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63798 | static int pyopencv_kinfu_Params_set_tsdf_max_weight(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63847 | { |  | 63799 | {
| 63848 | if (!value) |  | 63800 | if (!value)
| 63849 | { |  | 63801 | {
| 63850 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_max_weight attribute"); |  | 63802 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_max_weight attribute");
| 63851 | return -1; |  | 63803 | return -1;
| 63852 | } |  | 63804 | }
| 63853 | return pyopencv_to_safe(value, p->v->tsdf_max_weight, ArgInfo("value", 0)) ? 0 : -1; |  | 63805 | return pyopencv_to_safe(value, p->v->tsdf_max_weight, ArgInfo("value", 0)) ? 0 : -1;
| 63854 | } |  | 63806 | }
| 63855 |  |  | 63807 |
| 63856 | static PyObject* pyopencv_kinfu_Params_get_tsdf_min_camera_movement(pyopencv_kinfu_Params_t* p, void *closure) |  | 63808 | static PyObject* pyopencv_kinfu_Params_get_tsdf_min_camera_movement(pyopencv_kinfu_Params_t* p, void *closure)
| 63857 | { |  | 63809 | {
| 63858 | return pyopencv_from(p->v->tsdf_min_camera_movement); |  | 63810 | return pyopencv_from(p->v->tsdf_min_camera_movement);
| 63859 | } |  | 63811 | }
| 63860 |  |  | 63812 |
| 63861 | static int pyopencv_kinfu_Params_set_tsdf_min_camera_movement(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63813 | static int pyopencv_kinfu_Params_set_tsdf_min_camera_movement(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63862 | { |  | 63814 | {
| 63863 | if (!value) |  | 63815 | if (!value)
| 63864 | { |  | 63816 | {
| 63865 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_min_camera_movement attribute"); |  | 63817 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_min_camera_movement attribute");
| 63866 | return -1; |  | 63818 | return -1;
| 63867 | } |  | 63819 | }
| 63868 | return pyopencv_to_safe(value, p->v->tsdf_min_camera_movement, ArgInfo("value", 0)) ? 0 : -1; |  | 63820 | return pyopencv_to_safe(value, p->v->tsdf_min_camera_movement, ArgInfo("value", 0)) ? 0 : -1;
| 63869 | } |  | 63821 | }
| 63870 |  |  | 63822 |
| 63871 | static PyObject* pyopencv_kinfu_Params_get_tsdf_trunc_dist(pyopencv_kinfu_Params_t* p, void *closure) |  | 63823 | static PyObject* pyopencv_kinfu_Params_get_tsdf_trunc_dist(pyopencv_kinfu_Params_t* p, void *closure)
| 63872 | { |  | 63824 | {
| 63873 | return pyopencv_from(p->v->tsdf_trunc_dist); |  | 63825 | return pyopencv_from(p->v->tsdf_trunc_dist);
| 63874 | } |  | 63826 | }
| 63875 |  |  | 63827 |
| 63876 | static int pyopencv_kinfu_Params_set_tsdf_trunc_dist(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63828 | static int pyopencv_kinfu_Params_set_tsdf_trunc_dist(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63877 | { |  | 63829 | {
| 63878 | if (!value) |  | 63830 | if (!value)
| 63879 | { |  | 63831 | {
| 63880 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_trunc_dist attribute"); |  | 63832 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_trunc_dist attribute");
| 63881 | return -1; |  | 63833 | return -1;
| 63882 | } |  | 63834 | }
| 63883 | return pyopencv_to_safe(value, p->v->tsdf_trunc_dist, ArgInfo("value", 0)) ? 0 : -1; |  | 63835 | return pyopencv_to_safe(value, p->v->tsdf_trunc_dist, ArgInfo("value", 0)) ? 0 : -1;
| 63884 | } |  | 63836 | }
| 63885 |  |  | 63837 |
| 63886 | static PyObject* pyopencv_kinfu_Params_get_volumeDims(pyopencv_kinfu_Params_t* p, void *closure) |  | 63838 | static PyObject* pyopencv_kinfu_Params_get_volumeDims(pyopencv_kinfu_Params_t* p, void *closure)
| 63887 | { |  | 63839 | {
| 63888 | return pyopencv_from(p->v->volumeDims); |  | 63840 | return pyopencv_from(p->v->volumeDims);
| 63889 | } |  | 63841 | }
| 63890 |  |  | 63842 |
| 63891 | static int pyopencv_kinfu_Params_set_volumeDims(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63843 | static int pyopencv_kinfu_Params_set_volumeDims(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63892 | { |  | 63844 | {
| 63893 | if (!value) |  | 63845 | if (!value)
| 63894 | { |  | 63846 | {
| 63895 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeDims attribute"); |  | 63847 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeDims attribute");
| 63896 | return -1; |  | 63848 | return -1;
| 63897 | } |  | 63849 | }
| 63898 | return pyopencv_to_safe(value, p->v->volumeDims, ArgInfo("value", 0)) ? 0 : -1; |  | 63850 | return pyopencv_to_safe(value, p->v->volumeDims, ArgInfo("value", 0)) ? 0 : -1;
| 63899 | } |  | 63851 | }
| 63900 |  |  | 63852 |
| 63901 | static PyObject* pyopencv_kinfu_Params_get_volumeType(pyopencv_kinfu_Params_t* p, void *closure) |  | 63853 | static PyObject* pyopencv_kinfu_Params_get_volumeType(pyopencv_kinfu_Params_t* p, void *closure)
| 63902 | { |  | 63854 | {
| 63903 | return pyopencv_from(p->v->volumeType); |  | 63855 | return pyopencv_from(p->v->volumeType);
| 63904 | } |  | 63856 | }
| 63905 |  |  | 63857 |
| 63906 | static int pyopencv_kinfu_Params_set_volumeType(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63858 | static int pyopencv_kinfu_Params_set_volumeType(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63907 | { |  | 63859 | {
| 63908 | if (!value) |  | 63860 | if (!value)
| 63909 | { |  | 63861 | {
| 63910 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeType attribute"); |  | 63862 | PyErr_SetString(PyExc_TypeError, "Cannot delete the volumeType attribute");
| 63911 | return -1; |  | 63863 | return -1;
| 63912 | } |  | 63864 | }
| 63913 | return pyopencv_to_safe(value, p->v->volumeType, ArgInfo("value", 0)) ? 0 : -1; |  | 63865 | return pyopencv_to_safe(value, p->v->volumeType, ArgInfo("value", 0)) ? 0 : -1;
| 63914 | } |  | 63866 | }
| 63915 |  |  | 63867 |
| 63916 | static PyObject* pyopencv_kinfu_Params_get_voxelSize(pyopencv_kinfu_Params_t* p, void *closure) |  | 63868 | static PyObject* pyopencv_kinfu_Params_get_voxelSize(pyopencv_kinfu_Params_t* p, void *closure)
| 63917 | { |  | 63869 | {
| 63918 | return pyopencv_from(p->v->voxelSize); |  | 63870 | return pyopencv_from(p->v->voxelSize);
| 63919 | } |  | 63871 | }
| 63920 |  |  | 63872 |
| 63921 | static int pyopencv_kinfu_Params_set_voxelSize(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure) |  | 63873 | static int pyopencv_kinfu_Params_set_voxelSize(pyopencv_kinfu_Params_t* p, PyObject *value, void *closure)
| 63922 | { |  | 63874 | {
| 63923 | if (!value) |  | 63875 | if (!value)
| 63924 | { |  | 63876 | {
| 63925 | PyErr_SetString(PyExc_TypeError, "Cannot delete the voxelSize attribute"); |  | 63877 | PyErr_SetString(PyExc_TypeError, "Cannot delete the voxelSize attribute");
| 63926 | return -1; |  | 63878 | return -1;
| 63927 | } |  | 63879 | }
| 63928 | return pyopencv_to_safe(value, p->v->voxelSize, ArgInfo("value", 0)) ? 0 : -1; |  | 63880 | return pyopencv_to_safe(value, p->v->voxelSize, ArgInfo("value", 0)) ? 0 : -1;
| 63929 | } |  | 63881 | }
| 63930 |  |  | 63882 |
| 63931 |  |  | 63883 |
| 63932 | // Methods (kinfu_Params) |  | 63884 | // Methods (kinfu_Params)
| 63933 |  |  | 63885 |
| 63934 | static int pyopencv_cv_kinfu_kinfu_Params_Params(pyopencv_kinfu_Params_t* self, PyObject* py_args, PyObject* kw) |  | 63886 | static int pyopencv_cv_kinfu_kinfu_Params_Params(pyopencv_kinfu_Params_t* self, PyObject* py_args, PyObject* kw)
| 63935 | { |  | 63887 | {
| 63936 | using namespace cv::kinfu; |  | 63888 | using namespace cv::kinfu;
| 63937 |  |  | 63889 |
| 63938 | pyPrepareArgumentConversionErrorsStorage(3); |  | 63890 | pyPrepareArgumentConversionErrorsStorage(3);
| 63939 |  |  | 63891 |
| 63940 | { |  | 63892 | {
| 63941 |  |  | 63893 |
| 63942 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 63894 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 63943 | { |  | 63895 | {
| 63944 | new (&(self->v)) Ptr<cv::kinfu::Params>(); // init Ptr with placement new |  | 63896 | new (&(self->v)) Ptr<cv::kinfu::Params>(); // init Ptr with placement new
| 63945 | if(self) ERRWRAP2(self->v.reset(new cv::kinfu::Params())); |  | 63897 | if(self) ERRWRAP2(self->v.reset(new cv::kinfu::Params()));
| 63946 | return 0; |  | 63898 | return 0;
| 63947 | } |  | 63899 | }
| 63948 |  |  | 63900 |
| 63949 |  |  | 63901 |
| 63950 | pyPopulateArgumentConversionErrors(); |  | 63902 | pyPopulateArgumentConversionErrors();
| 63951 | } |  | 63903 | }
| 63952 |  |  | 63904 |
| 63953 |  |  | 63905 |
| 63954 | { |  | 63906 | {
| 63955 | PyObject* pyobj_volumeInitialPoseRot = NULL; |  | 63907 | PyObject* pyobj_volumeInitialPoseRot = NULL;
| 63956 | Matx33f volumeInitialPoseRot; |  | 63908 | Matx33f volumeInitialPoseRot;
| 63957 | PyObject* pyobj_volumeInitialPoseTransl = NULL; |  | 63909 | PyObject* pyobj_volumeInitialPoseTransl = NULL;
| 63958 | Vec3f volumeInitialPoseTransl; |  | 63910 | Vec3f volumeInitialPoseTransl;
| 63959 |  |  | 63911 |
| 63960 | const char* keywords[] = { "volumeInitialPoseRot", "volumeInitialPoseTransl", NULL }; |  | 63912 | const char* keywords[] = { "volumeInitialPoseRot", "volumeInitialPoseTransl", NULL };
| 63961 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Params", (char**)keywords, &pyobj_volumeInitialPoseRot, &pyobj_volumeInitialPoseTransl) && |  | 63913 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Params", (char**)keywords, &pyobj_volumeInitialPoseRot, &pyobj_volumeInitialPoseTransl) &&
| 63962 | pyopencv_to_safe(pyobj_volumeInitialPoseRot, volumeInitialPoseRot, ArgInfo("volumeInitialPoseRot", 0)) && |  | 63914 | pyopencv_to_safe(pyobj_volumeInitialPoseRot, volumeInitialPoseRot, ArgInfo("volumeInitialPoseRot", 0)) &&
| 63963 | pyopencv_to_safe(pyobj_volumeInitialPoseTransl, volumeInitialPoseTransl, ArgInfo("volumeInitialPoseTransl", 0)) ) |  | 63915 | pyopencv_to_safe(pyobj_volumeInitialPoseTransl, volumeInitialPoseTransl, ArgInfo("volumeInitialPoseTransl", 0)) )
| 63964 | { |  | 63916 | {
| 63965 | new (&(self->v)) Ptr<cv::kinfu::Params>(); // init Ptr with placement new |  | 63917 | new (&(self->v)) Ptr<cv::kinfu::Params>(); // init Ptr with placement new
| 63966 | if(self) ERRWRAP2(self->v.reset(new cv::kinfu::Params(volumeInitialPoseRot, volumeInitialPoseTransl))); |  | 63918 | if(self) ERRWRAP2(self->v.reset(new cv::kinfu::Params(volumeInitialPoseRot, volumeInitialPoseTransl)));
| 63967 | return 0; |  | 63919 | return 0;
| 63968 | } |  | 63920 | }
| 63969 |  |  | 63921 |
| 63970 |  |  | 63922 |
| 63971 | pyPopulateArgumentConversionErrors(); |  | 63923 | pyPopulateArgumentConversionErrors();
| 63972 | } |  | 63924 | }
| 63973 |  |  | 63925 |
| 63974 |  |  | 63926 |
| 63975 | { |  | 63927 | {
| 63976 | PyObject* pyobj_volumeInitialPose = NULL; |  | 63928 | PyObject* pyobj_volumeInitialPose = NULL;
| 63977 | Matx44f volumeInitialPose; |  | 63929 | Matx44f volumeInitialPose;
| 63978 |  |  | 63930 |
| 63979 | const char* keywords[] = { "volumeInitialPose", NULL }; |  | 63931 | const char* keywords[] = { "volumeInitialPose", NULL };
| 63980 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Params", (char**)keywords, &pyobj_volumeInitialPose) && |  | 63932 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:Params", (char**)keywords, &pyobj_volumeInitialPose) &&
| 63981 | pyopencv_to_safe(pyobj_volumeInitialPose, volumeInitialPose, ArgInfo("volumeInitialPose", 0)) ) |  | 63933 | pyopencv_to_safe(pyobj_volumeInitialPose, volumeInitialPose, ArgInfo("volumeInitialPose", 0)) )
| 63982 | { |  | 63934 | {
| 63983 | new (&(self->v)) Ptr<cv::kinfu::Params>(); // init Ptr with placement new |  | 63935 | new (&(self->v)) Ptr<cv::kinfu::Params>(); // init Ptr with placement new
| 63984 | if(self) ERRWRAP2(self->v.reset(new cv::kinfu::Params(volumeInitialPose))); |  | 63936 | if(self) ERRWRAP2(self->v.reset(new cv::kinfu::Params(volumeInitialPose)));
| 63985 | return 0; |  | 63937 | return 0;
| 63986 | } |  | 63938 | }
| 63987 |  |  | 63939 |
| 63988 |  |  | 63940 |
| 63989 | pyPopulateArgumentConversionErrors(); |  | 63941 | pyPopulateArgumentConversionErrors();
| 63990 | } |  | 63942 | }
| 63991 | pyRaiseCVOverloadException("Params"); |  | 63943 | pyRaiseCVOverloadException("Params");
| 63992 |  |  | 63944 |
| 63993 | return -1; |  | 63945 | return -1;
| 63994 | } |  | 63946 | }
| 63995 |  |  | 63947 |
| 63996 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63948 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 63997 | { |  | 63949 | {
| 63998 | using namespace cv::kinfu; |  | 63950 | using namespace cv::kinfu;
| 63999 |  |  | 63951 |
| 64000 | Ptr<Params> retval; |  | 63952 | Ptr<Params> retval;
| 64001 |  |  | 63953 |
| 64002 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 63954 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 64003 | { |  | 63955 | {
| 64004 | ERRWRAP2(retval = cv::kinfu::Params::coarseParams()); |  | 63956 | ERRWRAP2(retval = cv::kinfu::Params::coarseParams());
| 64005 | return pyopencv_from(retval); |  | 63957 | return pyopencv_from(retval);
| 64006 | } |  | 63958 | }
| 64007 |  |  | 63959 |
| 64008 | return NULL; |  | 63960 | return NULL;
| 64009 | } |  | 63961 | }
| 64010 |  |  | 63962 |
| 64011 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_coloredTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63963 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_coloredTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 64012 | { |  | 63964 | {
| 64013 | using namespace cv::kinfu; |  | 63965 | using namespace cv::kinfu;
| 64014 |  |  | 63966 |
| 64015 | PyObject* pyobj_isCoarse = NULL; |  | 63967 | PyObject* pyobj_isCoarse = NULL;
| 64016 | bool isCoarse=0; |  | 63968 | bool isCoarse=0;
| 64017 | Ptr<Params> retval; |  | 63969 | Ptr<Params> retval;
| 64018 |  |  | 63970 |
| 64019 | const char* keywords[] = { "isCoarse", NULL }; |  | 63971 | const char* keywords[] = { "isCoarse", NULL };
| 64020 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_Params.coloredTSDFParams", (char**)keywords, &pyobj_isCoarse) && |  | 63972 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_Params.coloredTSDFParams", (char**)keywords, &pyobj_isCoarse) &&
| 64021 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) ) |  | 63973 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) )
| 64022 | { |  | 63974 | {
| 64023 | ERRWRAP2(retval = cv::kinfu::Params::coloredTSDFParams(isCoarse)); |  | 63975 | ERRWRAP2(retval = cv::kinfu::Params::coloredTSDFParams(isCoarse));
| 64024 | return pyopencv_from(retval); |  | 63976 | return pyopencv_from(retval);
| 64025 | } |  | 63977 | }
| 64026 |  |  | 63978 |
| 64027 | return NULL; |  | 63979 | return NULL;
| 64028 | } |  | 63980 | }
| 64029 |  |  | 63981 |
| 64030 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63982 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 64031 | { |  | 63983 | {
| 64032 | using namespace cv::kinfu; |  | 63984 | using namespace cv::kinfu;
| 64033 |  |  | 63985 |
| 64034 | Ptr<Params> retval; |  | 63986 | Ptr<Params> retval;
| 64035 |  |  | 63987 |
| 64036 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 63988 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 64037 | { |  | 63989 | {
| 64038 | ERRWRAP2(retval = cv::kinfu::Params::defaultParams()); |  | 63990 | ERRWRAP2(retval = cv::kinfu::Params::defaultParams());
| 64039 | return pyopencv_from(retval); |  | 63991 | return pyopencv_from(retval);
| 64040 | } |  | 63992 | }
| 64041 |  |  | 63993 |
| 64042 | return NULL; |  | 63994 | return NULL;
| 64043 | } |  | 63995 | }
| 64044 |  |  | 63996 |
| 64045 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_hashTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 63997 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_hashTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 64046 | { |  | 63998 | {
| 64047 | using namespace cv::kinfu; |  | 63999 | using namespace cv::kinfu;
| 64048 |  |  | 64000 |
| 64049 | PyObject* pyobj_isCoarse = NULL; |  | 64001 | PyObject* pyobj_isCoarse = NULL;
| 64050 | bool isCoarse=0; |  | 64002 | bool isCoarse=0;
| 64051 | Ptr<Params> retval; |  | 64003 | Ptr<Params> retval;
| 64052 |  |  | 64004 |
| 64053 | const char* keywords[] = { "isCoarse", NULL }; |  | 64005 | const char* keywords[] = { "isCoarse", NULL };
| 64054 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_Params.hashTSDFParams", (char**)keywords, &pyobj_isCoarse) && |  | 64006 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_Params.hashTSDFParams", (char**)keywords, &pyobj_isCoarse) &&
| 64055 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) ) |  | 64007 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) )
| 64056 | { |  | 64008 | {
| 64057 | ERRWRAP2(retval = cv::kinfu::Params::hashTSDFParams(isCoarse)); |  | 64009 | ERRWRAP2(retval = cv::kinfu::Params::hashTSDFParams(isCoarse));
| 64058 | return pyopencv_from(retval); |  | 64010 | return pyopencv_from(retval);
| 64059 | } |  | 64011 | }
| 64060 |  |  | 64012 |
| 64061 | return NULL; |  | 64013 | return NULL;
| 64062 | } |  | 64014 | }
| 64063 |  |  | 64015 |
| 64064 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_setInitialVolumePose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64016 | static PyObject* pyopencv_cv_kinfu_kinfu_Params_setInitialVolumePose(PyObject* self, PyObject* py_args, PyObject* kw)
| 64065 | { |  | 64017 | {
| 64066 | using namespace cv::kinfu; |  | 64018 | using namespace cv::kinfu;
| 64067 |  |  | 64019 |
| 64068 |  |  | 64020 |
| 64069 | Ptr<cv::kinfu::Params> * self1 = 0; |  | 64021 | Ptr<cv::kinfu::Params> * self1 = 0;
| 64070 | if (!pyopencv_kinfu_Params_getp(self, self1)) |  | 64022 | if (!pyopencv_kinfu_Params_getp(self, self1))
| 64071 | return failmsgp("Incorrect type of self (must be 'kinfu_Params' or its derivative)"); |  | 64023 | return failmsgp("Incorrect type of self (must be 'kinfu_Params' or its derivative)");
| 64072 | Ptr<cv::kinfu::Params> _self_ = *(self1); |  | 64024 | Ptr<cv::kinfu::Params> _self_ = *(self1);
| 64073 | pyPrepareArgumentConversionErrorsStorage(2); |  | 64025 | pyPrepareArgumentConversionErrorsStorage(2);
| 64074 |  |  | 64026 |
| 64075 | { |  | 64027 | {
| 64076 | PyObject* pyobj_R = NULL; |  | 64028 | PyObject* pyobj_R = NULL;
| 64077 | Matx33f R; |  | 64029 | Matx33f R;
| 64078 | PyObject* pyobj_t = NULL; |  | 64030 | PyObject* pyobj_t = NULL;
| 64079 | Vec3f t; |  | 64031 | Vec3f t;
| 64080 |  |  | 64032 |
| 64081 | const char* keywords[] = { "R", "t", NULL }; |  | 64033 | const char* keywords[] = { "R", "t", NULL };
| 64082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_R, &pyobj_t) && |  | 64034 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_R, &pyobj_t) &&
| 64083 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) && |  | 64035 | pyopencv_to_safe(pyobj_R, R, ArgInfo("R", 0)) &&
| 64084 | pyopencv_to_safe(pyobj_t, t, ArgInfo("t", 0)) ) |  | 64036 | pyopencv_to_safe(pyobj_t, t, ArgInfo("t", 0)) )
| 64085 | { |  | 64037 | {
| 64086 | ERRWRAP2(_self_->setInitialVolumePose(R, t)); |  | 64038 | ERRWRAP2(_self_->setInitialVolumePose(R, t));
| 64087 | Py_RETURN_NONE; |  | 64039 | Py_RETURN_NONE;
| 64088 | } |  | 64040 | }
| 64089 |  |  | 64041 |
| 64090 |  |  | 64042 |
| 64091 | pyPopulateArgumentConversionErrors(); |  | 64043 | pyPopulateArgumentConversionErrors();
| 64092 | } |  | 64044 | }
| 64093 |  |  | 64045 |
| 64094 |  |  | 64046 |
| 64095 | { |  | 64047 | {
| 64096 | PyObject* pyobj_homogen_tf = NULL; |  | 64048 | PyObject* pyobj_homogen_tf = NULL;
| 64097 | Matx44f homogen_tf; |  | 64049 | Matx44f homogen_tf;
| 64098 |  |  | 64050 |
| 64099 | const char* keywords[] = { "homogen_tf", NULL }; |  | 64051 | const char* keywords[] = { "homogen_tf", NULL };
| 64100 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_homogen_tf) && |  | 64052 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_Params.setInitialVolumePose", (char**)keywords, &pyobj_homogen_tf) &&
| 64101 | pyopencv_to_safe(pyobj_homogen_tf, homogen_tf, ArgInfo("homogen_tf", 0)) ) |  | 64053 | pyopencv_to_safe(pyobj_homogen_tf, homogen_tf, ArgInfo("homogen_tf", 0)) )
| 64102 | { |  | 64054 | {
| 64103 | ERRWRAP2(_self_->setInitialVolumePose(homogen_tf)); |  | 64055 | ERRWRAP2(_self_->setInitialVolumePose(homogen_tf));
| 64104 | Py_RETURN_NONE; |  | 64056 | Py_RETURN_NONE;
| 64105 | } |  | 64057 | }
| 64106 |  |  | 64058 |
| 64107 |  |  | 64059 |
| 64108 | pyPopulateArgumentConversionErrors(); |  | 64060 | pyPopulateArgumentConversionErrors();
| 64109 | } |  | 64061 | }
| 64110 | pyRaiseCVOverloadException("setInitialVolumePose"); |  | 64062 | pyRaiseCVOverloadException("setInitialVolumePose");
| 64111 |  |  | 64063 |
| 64112 | return NULL; |  | 64064 | return NULL;
| 64113 | } |  | 64065 | }
| 64114 |  |  | 64066 |
| 64115 |  |  | 64067 |
| 64116 |  |  | 64068 |
| 64117 | // Tables (kinfu_Params) |  | 64069 | // Tables (kinfu_Params)
| 64118 |  |  | 64070 |
| 64119 | static PyGetSetDef pyopencv_kinfu_Params_getseters[] = |  | 64071 | static PyGetSetDef pyopencv_kinfu_Params_getseters[] =
| 64120 | { |  | 64072 | {
| 64121 | {(char*)"bilateral_kernel_size", (getter)pyopencv_kinfu_Params_get_bilateral_kernel_size, (setter)pyopencv_kinfu_Params_set_bilateral_kernel_size, (char*)"bilateral_kernel_size", NULL}, |  | 64073 | {(char*)"bilateral_kernel_size", (getter)pyopencv_kinfu_Params_get_bilateral_kernel_size, (setter)pyopencv_kinfu_Params_set_bilateral_kernel_size, (char*)"bilateral_kernel_size", NULL},
| 64122 | {(char*)"bilateral_sigma_depth", (getter)pyopencv_kinfu_Params_get_bilateral_sigma_depth, (setter)pyopencv_kinfu_Params_set_bilateral_sigma_depth, (char*)"bilateral_sigma_depth", NULL}, |  | 64074 | {(char*)"bilateral_sigma_depth", (getter)pyopencv_kinfu_Params_get_bilateral_sigma_depth, (setter)pyopencv_kinfu_Params_set_bilateral_sigma_depth, (char*)"bilateral_sigma_depth", NULL},
| 64123 | {(char*)"bilateral_sigma_spatial", (getter)pyopencv_kinfu_Params_get_bilateral_sigma_spatial, (setter)pyopencv_kinfu_Params_set_bilateral_sigma_spatial, (char*)"bilateral_sigma_spatial", NULL}, |  | 64075 | {(char*)"bilateral_sigma_spatial", (getter)pyopencv_kinfu_Params_get_bilateral_sigma_spatial, (setter)pyopencv_kinfu_Params_set_bilateral_sigma_spatial, (char*)"bilateral_sigma_spatial", NULL},
| 64124 | {(char*)"depthFactor", (getter)pyopencv_kinfu_Params_get_depthFactor, (setter)pyopencv_kinfu_Params_set_depthFactor, (char*)"depthFactor", NULL}, |  | 64076 | {(char*)"depthFactor", (getter)pyopencv_kinfu_Params_get_depthFactor, (setter)pyopencv_kinfu_Params_set_depthFactor, (char*)"depthFactor", NULL},
| 64125 | {(char*)"frameSize", (getter)pyopencv_kinfu_Params_get_frameSize, (setter)pyopencv_kinfu_Params_set_frameSize, (char*)"frameSize", NULL}, |  | 64077 | {(char*)"frameSize", (getter)pyopencv_kinfu_Params_get_frameSize, (setter)pyopencv_kinfu_Params_set_frameSize, (char*)"frameSize", NULL},
| 64126 | {(char*)"icpAngleThresh", (getter)pyopencv_kinfu_Params_get_icpAngleThresh, (setter)pyopencv_kinfu_Params_set_icpAngleThresh, (char*)"icpAngleThresh", NULL}, |  | 64078 | {(char*)"icpAngleThresh", (getter)pyopencv_kinfu_Params_get_icpAngleThresh, (setter)pyopencv_kinfu_Params_set_icpAngleThresh, (char*)"icpAngleThresh", NULL},
| 64127 | {(char*)"icpDistThresh", (getter)pyopencv_kinfu_Params_get_icpDistThresh, (setter)pyopencv_kinfu_Params_set_icpDistThresh, (char*)"icpDistThresh", NULL}, |  | 64079 | {(char*)"icpDistThresh", (getter)pyopencv_kinfu_Params_get_icpDistThresh, (setter)pyopencv_kinfu_Params_set_icpDistThresh, (char*)"icpDistThresh", NULL},
| 64128 | {(char*)"icpIterations", (getter)pyopencv_kinfu_Params_get_icpIterations, (setter)pyopencv_kinfu_Params_set_icpIterations, (char*)"icpIterations", NULL}, |  | 64080 | {(char*)"icpIterations", (getter)pyopencv_kinfu_Params_get_icpIterations, (setter)pyopencv_kinfu_Params_set_icpIterations, (char*)"icpIterations", NULL},
| 64129 | {(char*)"intr", (getter)pyopencv_kinfu_Params_get_intr, (setter)pyopencv_kinfu_Params_set_intr, (char*)"intr", NULL}, |  | 64081 | {(char*)"intr", (getter)pyopencv_kinfu_Params_get_intr, (setter)pyopencv_kinfu_Params_set_intr, (char*)"intr", NULL},
| 64130 | {(char*)"lightPose", (getter)pyopencv_kinfu_Params_get_lightPose, (setter)pyopencv_kinfu_Params_set_lightPose, (char*)"lightPose", NULL}, |  | 64082 | {(char*)"lightPose", (getter)pyopencv_kinfu_Params_get_lightPose, (setter)pyopencv_kinfu_Params_set_lightPose, (char*)"lightPose", NULL},
| 64131 | {(char*)"pyramidLevels", (getter)pyopencv_kinfu_Params_get_pyramidLevels, (setter)pyopencv_kinfu_Params_set_pyramidLevels, (char*)"pyramidLevels", NULL}, |  | 64083 | {(char*)"pyramidLevels", (getter)pyopencv_kinfu_Params_get_pyramidLevels, (setter)pyopencv_kinfu_Params_set_pyramidLevels, (char*)"pyramidLevels", NULL},
| 64132 | {(char*)"raycast_step_factor", (getter)pyopencv_kinfu_Params_get_raycast_step_factor, (setter)pyopencv_kinfu_Params_set_raycast_step_factor, (char*)"raycast_step_factor", NULL}, |  | 64084 | {(char*)"raycast_step_factor", (getter)pyopencv_kinfu_Params_get_raycast_step_factor, (setter)pyopencv_kinfu_Params_set_raycast_step_factor, (char*)"raycast_step_factor", NULL},
| 64133 | {(char*)"rgb_intr", (getter)pyopencv_kinfu_Params_get_rgb_intr, (setter)pyopencv_kinfu_Params_set_rgb_intr, (char*)"rgb_intr", NULL}, |  | 64085 | {(char*)"rgb_intr", (getter)pyopencv_kinfu_Params_get_rgb_intr, (setter)pyopencv_kinfu_Params_set_rgb_intr, (char*)"rgb_intr", NULL},
| 64134 | {(char*)"truncateThreshold", (getter)pyopencv_kinfu_Params_get_truncateThreshold, (setter)pyopencv_kinfu_Params_set_truncateThreshold, (char*)"truncateThreshold", NULL}, |  | 64086 | {(char*)"truncateThreshold", (getter)pyopencv_kinfu_Params_get_truncateThreshold, (setter)pyopencv_kinfu_Params_set_truncateThreshold, (char*)"truncateThreshold", NULL},
| 64135 | {(char*)"tsdf_max_weight", (getter)pyopencv_kinfu_Params_get_tsdf_max_weight, (setter)pyopencv_kinfu_Params_set_tsdf_max_weight, (char*)"tsdf_max_weight", NULL}, |  | 64087 | {(char*)"tsdf_max_weight", (getter)pyopencv_kinfu_Params_get_tsdf_max_weight, (setter)pyopencv_kinfu_Params_set_tsdf_max_weight, (char*)"tsdf_max_weight", NULL},
| 64136 | {(char*)"tsdf_min_camera_movement", (getter)pyopencv_kinfu_Params_get_tsdf_min_camera_movement, (setter)pyopencv_kinfu_Params_set_tsdf_min_camera_movement, (char*)"tsdf_min_camera_movement", NULL}, |  | 64088 | {(char*)"tsdf_min_camera_movement", (getter)pyopencv_kinfu_Params_get_tsdf_min_camera_movement, (setter)pyopencv_kinfu_Params_set_tsdf_min_camera_movement, (char*)"tsdf_min_camera_movement", NULL},
| 64137 | {(char*)"tsdf_trunc_dist", (getter)pyopencv_kinfu_Params_get_tsdf_trunc_dist, (setter)pyopencv_kinfu_Params_set_tsdf_trunc_dist, (char*)"tsdf_trunc_dist", NULL}, |  | 64089 | {(char*)"tsdf_trunc_dist", (getter)pyopencv_kinfu_Params_get_tsdf_trunc_dist, (setter)pyopencv_kinfu_Params_set_tsdf_trunc_dist, (char*)"tsdf_trunc_dist", NULL},
| 64138 | {(char*)"volumeDims", (getter)pyopencv_kinfu_Params_get_volumeDims, (setter)pyopencv_kinfu_Params_set_volumeDims, (char*)"volumeDims", NULL}, |  | 64090 | {(char*)"volumeDims", (getter)pyopencv_kinfu_Params_get_volumeDims, (setter)pyopencv_kinfu_Params_set_volumeDims, (char*)"volumeDims", NULL},
| 64139 | {(char*)"volumeType", (getter)pyopencv_kinfu_Params_get_volumeType, (setter)pyopencv_kinfu_Params_set_volumeType, (char*)"volumeType", NULL}, |  | 64091 | {(char*)"volumeType", (getter)pyopencv_kinfu_Params_get_volumeType, (setter)pyopencv_kinfu_Params_set_volumeType, (char*)"volumeType", NULL},
| 64140 | {(char*)"voxelSize", (getter)pyopencv_kinfu_Params_get_voxelSize, (setter)pyopencv_kinfu_Params_set_voxelSize, (char*)"voxelSize", NULL}, |  | 64092 | {(char*)"voxelSize", (getter)pyopencv_kinfu_Params_get_voxelSize, (setter)pyopencv_kinfu_Params_set_voxelSize, (char*)"voxelSize", NULL},
| 64141 | {NULL} /* Sentinel */ |  | 64093 | {NULL} /* Sentinel */
| 64142 | }; |  | 64094 | };
| 64143 |  |  | 64095 |
| 64144 | static PyMethodDef pyopencv_kinfu_Params_methods[] = |  | 64096 | static PyMethodDef pyopencv_kinfu_Params_methods[] =
| 64145 | { |  | 64097 | {
| 64146 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_coarseParams_static, METH_STATIC), "coarseParams() -> retval\n. @brief Coarse parameters\n. A set of parameters which provides better speed, can fail to match frames\n. in case of rapid sensor motion."}, |  | 64098 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_coarseParams_static, METH_STATIC), "coarseParams() -> retval\n. @brief Coarse parameters\n. A set of parameters which provides better speed, can fail to match frames\n. in case of rapid sensor motion."},
| 64147 | {"coloredTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_coloredTSDFParams_static, METH_STATIC), "coloredTSDFParams(isCoarse) -> retval\n. @brief ColoredTSDF parameters\n. A set of parameters suitable for use with ColoredTSDFVolume"}, |  | 64099 | {"coloredTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_coloredTSDFParams_static, METH_STATIC), "coloredTSDFParams(isCoarse) -> retval\n. @brief ColoredTSDF parameters\n. A set of parameters suitable for use with ColoredTSDFVolume"},
| 64148 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_defaultParams_static, METH_STATIC), "defaultParams() -> retval\n. * @brief Default parameters\n. * A set of parameters which provides better model quality, can be very slow."}, |  | 64100 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_defaultParams_static, METH_STATIC), "defaultParams() -> retval\n. * @brief Default parameters\n. * A set of parameters which provides better model quality, can be very slow."},
| 64149 | {"hashTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_hashTSDFParams_static, METH_STATIC), "hashTSDFParams(isCoarse) -> retval\n. @brief HashTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"}, |  | 64101 | {"hashTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_hashTSDFParams_static, METH_STATIC), "hashTSDFParams(isCoarse) -> retval\n. @brief HashTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"},
| 64150 | {"setInitialVolumePose", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_setInitialVolumePose, 0), "setInitialVolumePose(R, t) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param R rotation matrix\n. * @param t translation vector\n\n\n\nsetInitialVolumePose(homogen_tf) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param homogen_tf 4 by 4 Homogeneous Transform matrix to set the intial pose of TSDF volume"}, |  | 64102 | {"setInitialVolumePose", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_Params_setInitialVolumePose, 0), "setInitialVolumePose(R, t) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param R rotation matrix\n. * @param t translation vector\n\n\n\nsetInitialVolumePose(homogen_tf) -> None\n. * @brief Set Initial Volume Pose\n. * Sets the initial pose of the TSDF volume.\n. * @param homogen_tf 4 by 4 Homogeneous Transform matrix to set the intial pose of TSDF volume"},
| 64151 |  |  | 64103 |
| 64152 | {NULL, NULL} |  | 64104 | {NULL, NULL}
| 64153 | }; |  | 64105 | };
| 64154 |  |  | 64106 |
| 64155 | // Converter (kinfu_Params) |  | 64107 | // Converter (kinfu_Params)
| 64156 |  |  | 64108 |
| 64157 | template<> |  | 64109 | template<>
| 64158 | struct PyOpenCV_Converter< Ptr<cv::kinfu::Params> > |  | 64110 | struct PyOpenCV_Converter< Ptr<cv::kinfu::Params> >
| 64159 | { |  | 64111 | {
| 64160 | static PyObject* from(const Ptr<cv::kinfu::Params>& r) |  | 64112 | static PyObject* from(const Ptr<cv::kinfu::Params>& r)
| 64161 | { |  | 64113 | {
| 64162 | return pyopencv_kinfu_Params_Instance(r); |  | 64114 | return pyopencv_kinfu_Params_Instance(r);
| 64163 | } |  | 64115 | }
| 64164 | static bool to(PyObject* src, Ptr<cv::kinfu::Params>& dst, const ArgInfo& info) |  | 64116 | static bool to(PyObject* src, Ptr<cv::kinfu::Params>& dst, const ArgInfo& info)
| 64165 | { |  | 64117 | {
| 64166 | if(!src || src == Py_None) |  | 64118 | if(!src || src == Py_None)
| 64167 | return true; |  | 64119 | return true;
| 64168 | Ptr<cv::kinfu::Params> * dst_; |  | 64120 | Ptr<cv::kinfu::Params> * dst_;
| 64169 | if (pyopencv_kinfu_Params_getp(src, dst_)) |  | 64121 | if (pyopencv_kinfu_Params_getp(src, dst_))
| 64170 | { |  | 64122 | {
| 64171 | dst = *dst_; |  | 64123 | dst = *dst_;
| 64172 | return true; |  | 64124 | return true;
| 64173 | } |  | 64125 | }
| 64174 |  |  | 64126 |
| 64175 | failmsg("Expected Ptr<cv::kinfu::Params> for argument '%s'", info.name); |  | 64127 | failmsg("Expected Ptr<cv::kinfu::Params> for argument '%s'", info.name);
| 64176 | return false; |  | 64128 | return false;
| 64177 | } |  | 64129 | }
| 64178 | }; |  | 64130 | };
| 64179 |  |  | 64131 |
| 64180 | //================================================================================ |  | 64132 | //================================================================================
| 64181 | // kinfu_Volume (Generic) |  | 64133 | // kinfu_Volume (Generic)
| 64182 | //================================================================================ |  | 64134 | //================================================================================
| 64183 |  |  | 64135 |
| 64184 | // GetSet (kinfu_Volume) |  | 64136 | // GetSet (kinfu_Volume)
| 64185 |  |  | 64137 |
| 64186 |  |  | 64138 |
| 64187 |  |  | 64139 |
| 64188 | // Methods (kinfu_Volume) |  | 64140 | // Methods (kinfu_Volume)
| 64189 |  |  | 64141 |
| 64190 |  |  | 64142 |
| 64191 |  |  | 64143 |
| 64192 | // Tables (kinfu_Volume) |  | 64144 | // Tables (kinfu_Volume)
| 64193 |  |  | 64145 |
| 64194 | static PyGetSetDef pyopencv_kinfu_Volume_getseters[] = |  | 64146 | static PyGetSetDef pyopencv_kinfu_Volume_getseters[] =
| 64195 | { |  | 64147 | {
| 64196 | {NULL} /* Sentinel */ |  | 64148 | {NULL} /* Sentinel */
| 64197 | }; |  | 64149 | };
| 64198 |  |  | 64150 |
| 64199 | static PyMethodDef pyopencv_kinfu_Volume_methods[] = |  | 64151 | static PyMethodDef pyopencv_kinfu_Volume_methods[] =
| 64200 | { |  | 64152 | {
| 64201 |  |  | 64153 |
| 64202 | {NULL, NULL} |  | 64154 | {NULL, NULL}
| 64203 | }; |  | 64155 | };
| 64204 |  |  | 64156 |
| 64205 | // Converter (kinfu_Volume) |  | 64157 | // Converter (kinfu_Volume)
| 64206 |  |  | 64158 |
| 64207 | template<> |  | 64159 | template<>
| 64208 | struct PyOpenCV_Converter< Ptr<cv::kinfu::Volume> > |  | 64160 | struct PyOpenCV_Converter< Ptr<cv::kinfu::Volume> >
| 64209 | { |  | 64161 | {
| 64210 | static PyObject* from(const Ptr<cv::kinfu::Volume>& r) |  | 64162 | static PyObject* from(const Ptr<cv::kinfu::Volume>& r)
| 64211 | { |  | 64163 | {
| 64212 | return pyopencv_kinfu_Volume_Instance(r); |  | 64164 | return pyopencv_kinfu_Volume_Instance(r);
| 64213 | } |  | 64165 | }
| 64214 | static bool to(PyObject* src, Ptr<cv::kinfu::Volume>& dst, const ArgInfo& info) |  | 64166 | static bool to(PyObject* src, Ptr<cv::kinfu::Volume>& dst, const ArgInfo& info)
| 64215 | { |  | 64167 | {
| 64216 | if(!src || src == Py_None) |  | 64168 | if(!src || src == Py_None)
| 64217 | return true; |  | 64169 | return true;
| 64218 | Ptr<cv::kinfu::Volume> * dst_; |  | 64170 | Ptr<cv::kinfu::Volume> * dst_;
| 64219 | if (pyopencv_kinfu_Volume_getp(src, dst_)) |  | 64171 | if (pyopencv_kinfu_Volume_getp(src, dst_))
| 64220 | { |  | 64172 | {
| 64221 | dst = *dst_; |  | 64173 | dst = *dst_;
| 64222 | return true; |  | 64174 | return true;
| 64223 | } |  | 64175 | }
| 64224 |  |  | 64176 |
| 64225 | failmsg("Expected Ptr<cv::kinfu::Volume> for argument '%s'", info.name); |  | 64177 | failmsg("Expected Ptr<cv::kinfu::Volume> for argument '%s'", info.name);
| 64226 | return false; |  | 64178 | return false;
| 64227 | } |  | 64179 | }
| 64228 | }; |  | 64180 | };
| 64229 |  |  | 64181 |
| 64230 | //================================================================================ |  | 64182 | //================================================================================
| 64231 | // kinfu_VolumeParams (Generic) |  | 64183 | // kinfu_VolumeParams (Generic)
| 64232 | //================================================================================ |  | 64184 | //================================================================================
| 64233 |  |  | 64185 |
| 64234 | // GetSet (kinfu_VolumeParams) |  | 64186 | // GetSet (kinfu_VolumeParams)
| 64235 |  |  | 64187 |
| 64236 |  |  | 64188 |
| 64237 | static PyObject* pyopencv_kinfu_VolumeParams_get_depthTruncThreshold(pyopencv_kinfu_VolumeParams_t* p, void *closure) |  | 64189 | static PyObject* pyopencv_kinfu_VolumeParams_get_depthTruncThreshold(pyopencv_kinfu_VolumeParams_t* p, void *closure)
| 64238 | { |  | 64190 | {
| 64239 | return pyopencv_from(p->v->depthTruncThreshold); |  | 64191 | return pyopencv_from(p->v->depthTruncThreshold);
| 64240 | } |  | 64192 | }
| 64241 |  |  | 64193 |
| 64242 | static int pyopencv_kinfu_VolumeParams_set_depthTruncThreshold(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure) |  | 64194 | static int pyopencv_kinfu_VolumeParams_set_depthTruncThreshold(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure)
| 64243 | { |  | 64195 | {
| 64244 | if (!value) |  | 64196 | if (!value)
| 64245 | { |  | 64197 | {
| 64246 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthTruncThreshold attribute"); |  | 64198 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthTruncThreshold attribute");
| 64247 | return -1; |  | 64199 | return -1;
| 64248 | } |  | 64200 | }
| 64249 | return pyopencv_to_safe(value, p->v->depthTruncThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 64201 | return pyopencv_to_safe(value, p->v->depthTruncThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 64250 | } |  | 64202 | }
| 64251 |  |  | 64203 |
| 64252 | static PyObject* pyopencv_kinfu_VolumeParams_get_maxWeight(pyopencv_kinfu_VolumeParams_t* p, void *closure) |  | 64204 | static PyObject* pyopencv_kinfu_VolumeParams_get_maxWeight(pyopencv_kinfu_VolumeParams_t* p, void *closure)
| 64253 | { |  | 64205 | {
| 64254 | return pyopencv_from(p->v->maxWeight); |  | 64206 | return pyopencv_from(p->v->maxWeight);
| 64255 | } |  | 64207 | }
| 64256 |  |  | 64208 |
| 64257 | static int pyopencv_kinfu_VolumeParams_set_maxWeight(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure) |  | 64209 | static int pyopencv_kinfu_VolumeParams_set_maxWeight(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure)
| 64258 | { |  | 64210 | {
| 64259 | if (!value) |  | 64211 | if (!value)
| 64260 | { |  | 64212 | {
| 64261 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxWeight attribute"); |  | 64213 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxWeight attribute");
| 64262 | return -1; |  | 64214 | return -1;
| 64263 | } |  | 64215 | }
| 64264 | return pyopencv_to_safe(value, p->v->maxWeight, ArgInfo("value", 0)) ? 0 : -1; |  | 64216 | return pyopencv_to_safe(value, p->v->maxWeight, ArgInfo("value", 0)) ? 0 : -1;
| 64265 | } |  | 64217 | }
| 64266 |  |  | 64218 |
| 64267 | static PyObject* pyopencv_kinfu_VolumeParams_get_raycastStepFactor(pyopencv_kinfu_VolumeParams_t* p, void *closure) |  | 64219 | static PyObject* pyopencv_kinfu_VolumeParams_get_raycastStepFactor(pyopencv_kinfu_VolumeParams_t* p, void *closure)
| 64268 | { |  | 64220 | {
| 64269 | return pyopencv_from(p->v->raycastStepFactor); |  | 64221 | return pyopencv_from(p->v->raycastStepFactor);
| 64270 | } |  | 64222 | }
| 64271 |  |  | 64223 |
| 64272 | static int pyopencv_kinfu_VolumeParams_set_raycastStepFactor(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure) |  | 64224 | static int pyopencv_kinfu_VolumeParams_set_raycastStepFactor(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure)
| 64273 | { |  | 64225 | {
| 64274 | if (!value) |  | 64226 | if (!value)
| 64275 | { |  | 64227 | {
| 64276 | PyErr_SetString(PyExc_TypeError, "Cannot delete the raycastStepFactor attribute"); |  | 64228 | PyErr_SetString(PyExc_TypeError, "Cannot delete the raycastStepFactor attribute");
| 64277 | return -1; |  | 64229 | return -1;
| 64278 | } |  | 64230 | }
| 64279 | return pyopencv_to_safe(value, p->v->raycastStepFactor, ArgInfo("value", 0)) ? 0 : -1; |  | 64231 | return pyopencv_to_safe(value, p->v->raycastStepFactor, ArgInfo("value", 0)) ? 0 : -1;
| 64280 | } |  | 64232 | }
| 64281 |  |  | 64233 |
| 64282 | static PyObject* pyopencv_kinfu_VolumeParams_get_resolution(pyopencv_kinfu_VolumeParams_t* p, void *closure) |  | 64234 | static PyObject* pyopencv_kinfu_VolumeParams_get_resolution(pyopencv_kinfu_VolumeParams_t* p, void *closure)
| 64283 | { |  | 64235 | {
| 64284 | return pyopencv_from(p->v->resolution); |  | 64236 | return pyopencv_from(p->v->resolution);
| 64285 | } |  | 64237 | }
| 64286 |  |  | 64238 |
| 64287 | static int pyopencv_kinfu_VolumeParams_set_resolution(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure) |  | 64239 | static int pyopencv_kinfu_VolumeParams_set_resolution(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure)
| 64288 | { |  | 64240 | {
| 64289 | if (!value) |  | 64241 | if (!value)
| 64290 | { |  | 64242 | {
| 64291 | PyErr_SetString(PyExc_TypeError, "Cannot delete the resolution attribute"); |  | 64243 | PyErr_SetString(PyExc_TypeError, "Cannot delete the resolution attribute");
| 64292 | return -1; |  | 64244 | return -1;
| 64293 | } |  | 64245 | }
| 64294 | return pyopencv_to_safe(value, p->v->resolution, ArgInfo("value", 0)) ? 0 : -1; |  | 64246 | return pyopencv_to_safe(value, p->v->resolution, ArgInfo("value", 0)) ? 0 : -1;
| 64295 | } |  | 64247 | }
| 64296 |  |  | 64248 |
| 64297 | static PyObject* pyopencv_kinfu_VolumeParams_get_tsdfTruncDist(pyopencv_kinfu_VolumeParams_t* p, void *closure) |  | 64249 | static PyObject* pyopencv_kinfu_VolumeParams_get_tsdfTruncDist(pyopencv_kinfu_VolumeParams_t* p, void *closure)
| 64298 | { |  | 64250 | {
| 64299 | return pyopencv_from(p->v->tsdfTruncDist); |  | 64251 | return pyopencv_from(p->v->tsdfTruncDist);
| 64300 | } |  | 64252 | }
| 64301 |  |  | 64253 |
| 64302 | static int pyopencv_kinfu_VolumeParams_set_tsdfTruncDist(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure) |  | 64254 | static int pyopencv_kinfu_VolumeParams_set_tsdfTruncDist(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure)
| 64303 | { |  | 64255 | {
| 64304 | if (!value) |  | 64256 | if (!value)
| 64305 | { |  | 64257 | {
| 64306 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdfTruncDist attribute"); |  | 64258 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdfTruncDist attribute");
| 64307 | return -1; |  | 64259 | return -1;
| 64308 | } |  | 64260 | }
| 64309 | return pyopencv_to_safe(value, p->v->tsdfTruncDist, ArgInfo("value", 0)) ? 0 : -1; |  | 64261 | return pyopencv_to_safe(value, p->v->tsdfTruncDist, ArgInfo("value", 0)) ? 0 : -1;
| 64310 | } |  | 64262 | }
| 64311 |  |  | 64263 |
| 64312 | static PyObject* pyopencv_kinfu_VolumeParams_get_type(pyopencv_kinfu_VolumeParams_t* p, void *closure) |  | 64264 | static PyObject* pyopencv_kinfu_VolumeParams_get_type(pyopencv_kinfu_VolumeParams_t* p, void *closure)
| 64313 | { |  | 64265 | {
| 64314 | return pyopencv_from(p->v->type); |  | 64266 | return pyopencv_from(p->v->type);
| 64315 | } |  | 64267 | }
| 64316 |  |  | 64268 |
| 64317 | static int pyopencv_kinfu_VolumeParams_set_type(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure) |  | 64269 | static int pyopencv_kinfu_VolumeParams_set_type(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure)
| 64318 | { |  | 64270 | {
| 64319 | if (!value) |  | 64271 | if (!value)
| 64320 | { |  | 64272 | {
| 64321 | PyErr_SetString(PyExc_TypeError, "Cannot delete the type attribute"); |  | 64273 | PyErr_SetString(PyExc_TypeError, "Cannot delete the type attribute");
| 64322 | return -1; |  | 64274 | return -1;
| 64323 | } |  | 64275 | }
| 64324 | return pyopencv_to_safe(value, p->v->type, ArgInfo("value", 0)) ? 0 : -1; |  | 64276 | return pyopencv_to_safe(value, p->v->type, ArgInfo("value", 0)) ? 0 : -1;
| 64325 | } |  | 64277 | }
| 64326 |  |  | 64278 |
| 64327 | static PyObject* pyopencv_kinfu_VolumeParams_get_voxelSize(pyopencv_kinfu_VolumeParams_t* p, void *closure) |  | 64279 | static PyObject* pyopencv_kinfu_VolumeParams_get_voxelSize(pyopencv_kinfu_VolumeParams_t* p, void *closure)
| 64328 | { |  | 64280 | {
| 64329 | return pyopencv_from(p->v->voxelSize); |  | 64281 | return pyopencv_from(p->v->voxelSize);
| 64330 | } |  | 64282 | }
| 64331 |  |  | 64283 |
| 64332 | static int pyopencv_kinfu_VolumeParams_set_voxelSize(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure) |  | 64284 | static int pyopencv_kinfu_VolumeParams_set_voxelSize(pyopencv_kinfu_VolumeParams_t* p, PyObject *value, void *closure)
| 64333 | { |  | 64285 | {
| 64334 | if (!value) |  | 64286 | if (!value)
| 64335 | { |  | 64287 | {
| 64336 | PyErr_SetString(PyExc_TypeError, "Cannot delete the voxelSize attribute"); |  | 64288 | PyErr_SetString(PyExc_TypeError, "Cannot delete the voxelSize attribute");
| 64337 | return -1; |  | 64289 | return -1;
| 64338 | } |  | 64290 | }
| 64339 | return pyopencv_to_safe(value, p->v->voxelSize, ArgInfo("value", 0)) ? 0 : -1; |  | 64291 | return pyopencv_to_safe(value, p->v->voxelSize, ArgInfo("value", 0)) ? 0 : -1;
| 64340 | } |  | 64292 | }
| 64341 |  |  | 64293 |
| 64342 |  |  | 64294 |
| 64343 | // Methods (kinfu_VolumeParams) |  | 64295 | // Methods (kinfu_VolumeParams)
| 64344 |  |  | 64296 |
| 64345 | static PyObject* pyopencv_cv_kinfu_kinfu_VolumeParams_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64297 | static PyObject* pyopencv_cv_kinfu_kinfu_VolumeParams_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 64346 | { |  | 64298 | {
| 64347 | using namespace cv::kinfu; |  | 64299 | using namespace cv::kinfu;
| 64348 |  |  | 64300 |
| 64349 | PyObject* pyobj__volumeType = NULL; |  | 64301 | PyObject* pyobj__volumeType = NULL;
| 64350 | VolumeType _volumeType=static_cast<VolumeType>(0); |  | 64302 | VolumeType _volumeType=static_cast<VolumeType>(0);
| 64351 | Ptr<VolumeParams> retval; |  | 64303 | Ptr<VolumeParams> retval;
| 64352 |  |  | 64304 |
| 64353 | const char* keywords[] = { "_volumeType", NULL }; |  | 64305 | const char* keywords[] = { "_volumeType", NULL };
| 64354 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_VolumeParams.coarseParams", (char**)keywords, &pyobj__volumeType) && |  | 64306 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_VolumeParams.coarseParams", (char**)keywords, &pyobj__volumeType) &&
| 64355 | pyopencv_to_safe(pyobj__volumeType, _volumeType, ArgInfo("_volumeType", 0)) ) |  | 64307 | pyopencv_to_safe(pyobj__volumeType, _volumeType, ArgInfo("_volumeType", 0)) )
| 64356 | { |  | 64308 | {
| 64357 | ERRWRAP2(retval = cv::kinfu::VolumeParams::coarseParams(_volumeType)); |  | 64309 | ERRWRAP2(retval = cv::kinfu::VolumeParams::coarseParams(_volumeType));
| 64358 | return pyopencv_from(retval); |  | 64310 | return pyopencv_from(retval);
| 64359 | } |  | 64311 | }
| 64360 |  |  | 64312 |
| 64361 | return NULL; |  | 64313 | return NULL;
| 64362 | } |  | 64314 | }
| 64363 |  |  | 64315 |
| 64364 | static PyObject* pyopencv_cv_kinfu_kinfu_VolumeParams_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64316 | static PyObject* pyopencv_cv_kinfu_kinfu_VolumeParams_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 64365 | { |  | 64317 | {
| 64366 | using namespace cv::kinfu; |  | 64318 | using namespace cv::kinfu;
| 64367 |  |  | 64319 |
| 64368 | PyObject* pyobj__volumeType = NULL; |  | 64320 | PyObject* pyobj__volumeType = NULL;
| 64369 | VolumeType _volumeType=static_cast<VolumeType>(0); |  | 64321 | VolumeType _volumeType=static_cast<VolumeType>(0);
| 64370 | Ptr<VolumeParams> retval; |  | 64322 | Ptr<VolumeParams> retval;
| 64371 |  |  | 64323 |
| 64372 | const char* keywords[] = { "_volumeType", NULL }; |  | 64324 | const char* keywords[] = { "_volumeType", NULL };
| 64373 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_VolumeParams.defaultParams", (char**)keywords, &pyobj__volumeType) && |  | 64325 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:kinfu_VolumeParams.defaultParams", (char**)keywords, &pyobj__volumeType) &&
| 64374 | pyopencv_to_safe(pyobj__volumeType, _volumeType, ArgInfo("_volumeType", 0)) ) |  | 64326 | pyopencv_to_safe(pyobj__volumeType, _volumeType, ArgInfo("_volumeType", 0)) )
| 64375 | { |  | 64327 | {
| 64376 | ERRWRAP2(retval = cv::kinfu::VolumeParams::defaultParams(_volumeType)); |  | 64328 | ERRWRAP2(retval = cv::kinfu::VolumeParams::defaultParams(_volumeType));
| 64377 | return pyopencv_from(retval); |  | 64329 | return pyopencv_from(retval);
| 64378 | } |  | 64330 | }
| 64379 |  |  | 64331 |
| 64380 | return NULL; |  | 64332 | return NULL;
| 64381 | } |  | 64333 | }
| 64382 |  |  | 64334 |
| 64383 |  |  | 64335 |
| 64384 |  |  | 64336 |
| 64385 | // Tables (kinfu_VolumeParams) |  | 64337 | // Tables (kinfu_VolumeParams)
| 64386 |  |  | 64338 |
| 64387 | static PyGetSetDef pyopencv_kinfu_VolumeParams_getseters[] = |  | 64339 | static PyGetSetDef pyopencv_kinfu_VolumeParams_getseters[] =
| 64388 | { |  | 64340 | {
| 64389 | {(char*)"depthTruncThreshold", (getter)pyopencv_kinfu_VolumeParams_get_depthTruncThreshold, (setter)pyopencv_kinfu_VolumeParams_set_depthTruncThreshold, (char*)"depthTruncThreshold", NULL}, |  | 64341 | {(char*)"depthTruncThreshold", (getter)pyopencv_kinfu_VolumeParams_get_depthTruncThreshold, (setter)pyopencv_kinfu_VolumeParams_set_depthTruncThreshold, (char*)"depthTruncThreshold", NULL},
| 64390 | {(char*)"maxWeight", (getter)pyopencv_kinfu_VolumeParams_get_maxWeight, (setter)pyopencv_kinfu_VolumeParams_set_maxWeight, (char*)"maxWeight", NULL}, |  | 64342 | {(char*)"maxWeight", (getter)pyopencv_kinfu_VolumeParams_get_maxWeight, (setter)pyopencv_kinfu_VolumeParams_set_maxWeight, (char*)"maxWeight", NULL},
| 64391 | {(char*)"raycastStepFactor", (getter)pyopencv_kinfu_VolumeParams_get_raycastStepFactor, (setter)pyopencv_kinfu_VolumeParams_set_raycastStepFactor, (char*)"raycastStepFactor", NULL}, |  | 64343 | {(char*)"raycastStepFactor", (getter)pyopencv_kinfu_VolumeParams_get_raycastStepFactor, (setter)pyopencv_kinfu_VolumeParams_set_raycastStepFactor, (char*)"raycastStepFactor", NULL},
| 64392 | {(char*)"resolution", (getter)pyopencv_kinfu_VolumeParams_get_resolution, (setter)pyopencv_kinfu_VolumeParams_set_resolution, (char*)"resolution", NULL}, |  | 64344 | {(char*)"resolution", (getter)pyopencv_kinfu_VolumeParams_get_resolution, (setter)pyopencv_kinfu_VolumeParams_set_resolution, (char*)"resolution", NULL},
| 64393 | {(char*)"tsdfTruncDist", (getter)pyopencv_kinfu_VolumeParams_get_tsdfTruncDist, (setter)pyopencv_kinfu_VolumeParams_set_tsdfTruncDist, (char*)"tsdfTruncDist", NULL}, |  | 64345 | {(char*)"tsdfTruncDist", (getter)pyopencv_kinfu_VolumeParams_get_tsdfTruncDist, (setter)pyopencv_kinfu_VolumeParams_set_tsdfTruncDist, (char*)"tsdfTruncDist", NULL},
| 64394 | {(char*)"type", (getter)pyopencv_kinfu_VolumeParams_get_type, (setter)pyopencv_kinfu_VolumeParams_set_type, (char*)"type", NULL}, |  | 64346 | {(char*)"type", (getter)pyopencv_kinfu_VolumeParams_get_type, (setter)pyopencv_kinfu_VolumeParams_set_type, (char*)"type", NULL},
| 64395 | {(char*)"voxelSize", (getter)pyopencv_kinfu_VolumeParams_get_voxelSize, (setter)pyopencv_kinfu_VolumeParams_set_voxelSize, (char*)"voxelSize", NULL}, |  | 64347 | {(char*)"voxelSize", (getter)pyopencv_kinfu_VolumeParams_get_voxelSize, (setter)pyopencv_kinfu_VolumeParams_set_voxelSize, (char*)"voxelSize", NULL},
| 64396 | {NULL} /* Sentinel */ |  | 64348 | {NULL} /* Sentinel */
| 64397 | }; |  | 64349 | };
| 64398 |  |  | 64350 |
| 64399 | static PyMethodDef pyopencv_kinfu_VolumeParams_methods[] = |  | 64351 | static PyMethodDef pyopencv_kinfu_VolumeParams_methods[] =
| 64400 | { |  | 64352 | {
| 64401 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_VolumeParams_coarseParams_static, METH_STATIC), "coarseParams(_volumeType) -> retval\n. @brief Coarse set of parameters that provides relatively higher performance\n. at the cost of reconstrution quality."}, |  | 64353 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_VolumeParams_coarseParams_static, METH_STATIC), "coarseParams(_volumeType) -> retval\n. @brief Coarse set of parameters that provides relatively higher performance\n. at the cost of reconstrution quality."},
| 64402 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_VolumeParams_defaultParams_static, METH_STATIC), "defaultParams(_volumeType) -> retval\n. @brief Default set of parameters that provide higher quality reconstruction\n. at the cost of slow performance."}, |  | 64354 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_kinfu_kinfu_VolumeParams_defaultParams_static, METH_STATIC), "defaultParams(_volumeType) -> retval\n. @brief Default set of parameters that provide higher quality reconstruction\n. at the cost of slow performance."},
| 64403 |  |  | 64355 |
| 64404 | {NULL, NULL} |  | 64356 | {NULL, NULL}
| 64405 | }; |  | 64357 | };
| 64406 |  |  | 64358 |
| 64407 | // Converter (kinfu_VolumeParams) |  | 64359 | // Converter (kinfu_VolumeParams)
| 64408 |  |  | 64360 |
| 64409 | template<> |  | 64361 | template<>
| 64410 | struct PyOpenCV_Converter< Ptr<cv::kinfu::VolumeParams> > |  | 64362 | struct PyOpenCV_Converter< Ptr<cv::kinfu::VolumeParams> >
| 64411 | { |  | 64363 | {
| 64412 | static PyObject* from(const Ptr<cv::kinfu::VolumeParams>& r) |  | 64364 | static PyObject* from(const Ptr<cv::kinfu::VolumeParams>& r)
| 64413 | { |  | 64365 | {
| 64414 | return pyopencv_kinfu_VolumeParams_Instance(r); |  | 64366 | return pyopencv_kinfu_VolumeParams_Instance(r);
| 64415 | } |  | 64367 | }
| 64416 | static bool to(PyObject* src, Ptr<cv::kinfu::VolumeParams>& dst, const ArgInfo& info) |  | 64368 | static bool to(PyObject* src, Ptr<cv::kinfu::VolumeParams>& dst, const ArgInfo& info)
| 64417 | { |  | 64369 | {
| 64418 | if(!src || src == Py_None) |  | 64370 | if(!src || src == Py_None)
| 64419 | return true; |  | 64371 | return true;
| 64420 | Ptr<cv::kinfu::VolumeParams> * dst_; |  | 64372 | Ptr<cv::kinfu::VolumeParams> * dst_;
| 64421 | if (pyopencv_kinfu_VolumeParams_getp(src, dst_)) |  | 64373 | if (pyopencv_kinfu_VolumeParams_getp(src, dst_))
| 64422 | { |  | 64374 | {
| 64423 | dst = *dst_; |  | 64375 | dst = *dst_;
| 64424 | return true; |  | 64376 | return true;
| 64425 | } |  | 64377 | }
| 64426 |  |  | 64378 |
| 64427 | failmsg("Expected Ptr<cv::kinfu::VolumeParams> for argument '%s'", info.name); |  | 64379 | failmsg("Expected Ptr<cv::kinfu::VolumeParams> for argument '%s'", info.name);
| 64428 | return false; |  | 64380 | return false;
| 64429 | } |  | 64381 | }
| 64430 | }; |  | 64382 | };
| 64431 |  |  | 64383 |
| 64432 | //================================================================================ |  | 64384 | //================================================================================
| 64433 | // kinfu_detail_PoseGraph (Generic) |  | 64385 | // kinfu_detail_PoseGraph (Generic)
| 64434 | //================================================================================ |  | 64386 | //================================================================================
| 64435 |  |  | 64387 |
| 64436 | // GetSet (kinfu_detail_PoseGraph) |  | 64388 | // GetSet (kinfu_detail_PoseGraph)
| 64437 |  |  | 64389 |
| 64438 |  |  | 64390 |
| 64439 |  |  | 64391 |
| 64440 | // Methods (kinfu_detail_PoseGraph) |  | 64392 | // Methods (kinfu_detail_PoseGraph)
| 64441 |  |  | 64393 |
| 64442 |  |  | 64394 |
| 64443 |  |  | 64395 |
| 64444 | // Tables (kinfu_detail_PoseGraph) |  | 64396 | // Tables (kinfu_detail_PoseGraph)
| 64445 |  |  | 64397 |
| 64446 | static PyGetSetDef pyopencv_kinfu_detail_PoseGraph_getseters[] = |  | 64398 | static PyGetSetDef pyopencv_kinfu_detail_PoseGraph_getseters[] =
| 64447 | { |  | 64399 | {
| 64448 | {NULL} /* Sentinel */ |  | 64400 | {NULL} /* Sentinel */
| 64449 | }; |  | 64401 | };
| 64450 |  |  | 64402 |
| 64451 | static PyMethodDef pyopencv_kinfu_detail_PoseGraph_methods[] = |  | 64403 | static PyMethodDef pyopencv_kinfu_detail_PoseGraph_methods[] =
| 64452 | { |  | 64404 | {
| 64453 |  |  | 64405 |
| 64454 | {NULL, NULL} |  | 64406 | {NULL, NULL}
| 64455 | }; |  | 64407 | };
| 64456 |  |  | 64408 |
| 64457 | // Converter (kinfu_detail_PoseGraph) |  | 64409 | // Converter (kinfu_detail_PoseGraph)
| 64458 |  |  | 64410 |
| 64459 | template<> |  | 64411 | template<>
| 64460 | struct PyOpenCV_Converter< Ptr<cv::kinfu::detail::PoseGraph> > |  | 64412 | struct PyOpenCV_Converter< Ptr<cv::kinfu::detail::PoseGraph> >
| 64461 | { |  | 64413 | {
| 64462 | static PyObject* from(const Ptr<cv::kinfu::detail::PoseGraph>& r) |  | 64414 | static PyObject* from(const Ptr<cv::kinfu::detail::PoseGraph>& r)
| 64463 | { |  | 64415 | {
| 64464 | return pyopencv_kinfu_detail_PoseGraph_Instance(r); |  | 64416 | return pyopencv_kinfu_detail_PoseGraph_Instance(r);
| 64465 | } |  | 64417 | }
| 64466 | static bool to(PyObject* src, Ptr<cv::kinfu::detail::PoseGraph>& dst, const ArgInfo& info) |  | 64418 | static bool to(PyObject* src, Ptr<cv::kinfu::detail::PoseGraph>& dst, const ArgInfo& info)
| 64467 | { |  | 64419 | {
| 64468 | if(!src || src == Py_None) |  | 64420 | if(!src || src == Py_None)
| 64469 | return true; |  | 64421 | return true;
| 64470 | Ptr<cv::kinfu::detail::PoseGraph> * dst_; |  | 64422 | Ptr<cv::kinfu::detail::PoseGraph> * dst_;
| 64471 | if (pyopencv_kinfu_detail_PoseGraph_getp(src, dst_)) |  | 64423 | if (pyopencv_kinfu_detail_PoseGraph_getp(src, dst_))
| 64472 | { |  | 64424 | {
| 64473 | dst = *dst_; |  | 64425 | dst = *dst_;
| 64474 | return true; |  | 64426 | return true;
| 64475 | } |  | 64427 | }
| 64476 |  |  | 64428 |
| 64477 | failmsg("Expected Ptr<cv::kinfu::detail::PoseGraph> for argument '%s'", info.name); |  | 64429 | failmsg("Expected Ptr<cv::kinfu::detail::PoseGraph> for argument '%s'", info.name);
| 64478 | return false; |  | 64430 | return false;
| 64479 | } |  | 64431 | }
| 64480 | }; |  | 64432 | };
| 64481 |  |  | 64433 |
| 64482 | //================================================================================ |  | 64434 | //================================================================================
| 64483 | // large_kinfu_LargeKinfu (Generic) |  | 64435 | // large_kinfu_LargeKinfu (Generic)
| 64484 | //================================================================================ |  | 64436 | //================================================================================
| 64485 |  |  | 64437 |
| 64486 | // GetSet (large_kinfu_LargeKinfu) |  | 64438 | // GetSet (large_kinfu_LargeKinfu)
| 64487 |  |  | 64439 |
| 64488 |  |  | 64440 |
| 64489 |  |  | 64441 |
| 64490 | // Methods (large_kinfu_LargeKinfu) |  | 64442 | // Methods (large_kinfu_LargeKinfu)
| 64491 |  |  | 64443 |
| 64492 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64444 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 64493 | { |  | 64445 | {
| 64494 | using namespace cv::large_kinfu; |  | 64446 | using namespace cv::large_kinfu;
| 64495 |  |  | 64447 |
| 64496 | PyObject* pyobj__params = NULL; |  | 64448 | PyObject* pyobj__params = NULL;
| 64497 | Ptr<Params> _params; |  | 64449 | Ptr<Params> _params;
| 64498 | Ptr<LargeKinfu> retval; |  | 64450 | Ptr<LargeKinfu> retval;
| 64499 |  |  | 64451 |
| 64500 | const char* keywords[] = { "_params", NULL }; |  | 64452 | const char* keywords[] = { "_params", NULL };
| 64501 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_LargeKinfu.create", (char**)keywords, &pyobj__params) && |  | 64453 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_LargeKinfu.create", (char**)keywords, &pyobj__params) &&
| 64502 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) ) |  | 64454 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) )
| 64503 | { |  | 64455 | {
| 64504 | ERRWRAP2(retval = cv::large_kinfu::LargeKinfu::create(_params)); |  | 64456 | ERRWRAP2(retval = cv::large_kinfu::LargeKinfu::create(_params));
| 64505 | return pyopencv_from(retval); |  | 64457 | return pyopencv_from(retval);
| 64506 | } |  | 64458 | }
| 64507 |  |  | 64459 |
| 64508 | return NULL; |  | 64460 | return NULL;
| 64509 | } |  | 64461 | }
| 64510 |  |  | 64462 |
| 64511 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64463 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getCloud(PyObject* self, PyObject* py_args, PyObject* kw)
| 64512 | { |  | 64464 | {
| 64513 | using namespace cv::large_kinfu; |  | 64465 | using namespace cv::large_kinfu;
| 64514 |  |  | 64466 |
| 64515 |  |  | 64467 |
| 64516 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0; |  | 64468 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0;
| 64517 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1)) |  | 64469 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1))
| 64518 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)"); |  | 64470 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)");
| 64519 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1); |  | 64471 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1);
| 64520 | pyPrepareArgumentConversionErrorsStorage(2); |  | 64472 | pyPrepareArgumentConversionErrorsStorage(2);
| 64521 |  |  | 64473 |
| 64522 | { |  | 64474 | {
| 64523 | PyObject* pyobj_points = NULL; |  | 64475 | PyObject* pyobj_points = NULL;
| 64524 | Mat points; |  | 64476 | Mat points;
| 64525 | PyObject* pyobj_normals = NULL; |  | 64477 | PyObject* pyobj_normals = NULL;
| 64526 | Mat normals; |  | 64478 | Mat normals;
| 64527 |  |  | 64479 |
| 64528 | const char* keywords[] = { "points", "normals", NULL }; |  | 64480 | const char* keywords[] = { "points", "normals", NULL };
| 64529 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:large_kinfu_LargeKinfu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 64481 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:large_kinfu_LargeKinfu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 64530 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 64482 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 64531 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 64483 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 64532 | { |  | 64484 | {
| 64533 | ERRWRAP2(_self_->getCloud(points, normals)); |  | 64485 | ERRWRAP2(_self_->getCloud(points, normals));
| 64534 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals)); |  | 64486 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals));
| 64535 | } |  | 64487 | }
| 64536 |  |  | 64488 |
| 64537 |  |  | 64489 |
| 64538 | pyPopulateArgumentConversionErrors(); |  | 64490 | pyPopulateArgumentConversionErrors();
| 64539 | } |  | 64491 | }
| 64540 |  |  | 64492 |
| 64541 |  |  | 64493 |
| 64542 | { |  | 64494 | {
| 64543 | PyObject* pyobj_points = NULL; |  | 64495 | PyObject* pyobj_points = NULL;
| 64544 | UMat points; |  | 64496 | UMat points;
| 64545 | PyObject* pyobj_normals = NULL; |  | 64497 | PyObject* pyobj_normals = NULL;
| 64546 | UMat normals; |  | 64498 | UMat normals;
| 64547 |  |  | 64499 |
| 64548 | const char* keywords[] = { "points", "normals", NULL }; |  | 64500 | const char* keywords[] = { "points", "normals", NULL };
| 64549 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:large_kinfu_LargeKinfu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 64501 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:large_kinfu_LargeKinfu.getCloud", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 64550 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) && |  | 64502 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) &&
| 64551 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 64503 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 64552 | { |  | 64504 | {
| 64553 | ERRWRAP2(_self_->getCloud(points, normals)); |  | 64505 | ERRWRAP2(_self_->getCloud(points, normals));
| 64554 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals)); |  | 64506 | return Py_BuildValue("(NN)", pyopencv_from(points), pyopencv_from(normals));
| 64555 | } |  | 64507 | }
| 64556 |  |  | 64508 |
| 64557 |  |  | 64509 |
| 64558 | pyPopulateArgumentConversionErrors(); |  | 64510 | pyPopulateArgumentConversionErrors();
| 64559 | } |  | 64511 | }
| 64560 | pyRaiseCVOverloadException("getCloud"); |  | 64512 | pyRaiseCVOverloadException("getCloud");
| 64561 |  |  | 64513 |
| 64562 | return NULL; |  | 64514 | return NULL;
| 64563 | } |  | 64515 | }
| 64564 |  |  | 64516 |
| 64565 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64517 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getNormals(PyObject* self, PyObject* py_args, PyObject* kw)
| 64566 | { |  | 64518 | {
| 64567 | using namespace cv::large_kinfu; |  | 64519 | using namespace cv::large_kinfu;
| 64568 |  |  | 64520 |
| 64569 |  |  | 64521 |
| 64570 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0; |  | 64522 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0;
| 64571 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1)) |  | 64523 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1))
| 64572 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)"); |  | 64524 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)");
| 64573 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1); |  | 64525 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1);
| 64574 | pyPrepareArgumentConversionErrorsStorage(2); |  | 64526 | pyPrepareArgumentConversionErrorsStorage(2);
| 64575 |  |  | 64527 |
| 64576 | { |  | 64528 | {
| 64577 | PyObject* pyobj_points = NULL; |  | 64529 | PyObject* pyobj_points = NULL;
| 64578 | Mat points; |  | 64530 | Mat points;
| 64579 | PyObject* pyobj_normals = NULL; |  | 64531 | PyObject* pyobj_normals = NULL;
| 64580 | Mat normals; |  | 64532 | Mat normals;
| 64581 |  |  | 64533 |
| 64582 | const char* keywords[] = { "points", "normals", NULL }; |  | 64534 | const char* keywords[] = { "points", "normals", NULL };
| 64583 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 64535 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 64584 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 64536 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 64585 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 64537 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 64586 | { |  | 64538 | {
| 64587 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 64539 | ERRWRAP2(_self_->getNormals(points, normals));
| 64588 | return pyopencv_from(normals); |  | 64540 | return pyopencv_from(normals);
| 64589 | } |  | 64541 | }
| 64590 |  |  | 64542 |
| 64591 |  |  | 64543 |
| 64592 | pyPopulateArgumentConversionErrors(); |  | 64544 | pyPopulateArgumentConversionErrors();
| 64593 | } |  | 64545 | }
| 64594 |  |  | 64546 |
| 64595 |  |  | 64547 |
| 64596 | { |  | 64548 | {
| 64597 | PyObject* pyobj_points = NULL; |  | 64549 | PyObject* pyobj_points = NULL;
| 64598 | UMat points; |  | 64550 | UMat points;
| 64599 | PyObject* pyobj_normals = NULL; |  | 64551 | PyObject* pyobj_normals = NULL;
| 64600 | UMat normals; |  | 64552 | UMat normals;
| 64601 |  |  | 64553 |
| 64602 | const char* keywords[] = { "points", "normals", NULL }; |  | 64554 | const char* keywords[] = { "points", "normals", NULL };
| 64603 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 64555 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.getNormals", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 64604 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 64556 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 64605 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 64557 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 64606 | { |  | 64558 | {
| 64607 | ERRWRAP2(_self_->getNormals(points, normals)); |  | 64559 | ERRWRAP2(_self_->getNormals(points, normals));
| 64608 | return pyopencv_from(normals); |  | 64560 | return pyopencv_from(normals);
| 64609 | } |  | 64561 | }
| 64610 |  |  | 64562 |
| 64611 |  |  | 64563 |
| 64612 | pyPopulateArgumentConversionErrors(); |  | 64564 | pyPopulateArgumentConversionErrors();
| 64613 | } |  | 64565 | }
| 64614 | pyRaiseCVOverloadException("getNormals"); |  | 64566 | pyRaiseCVOverloadException("getNormals");
| 64615 |  |  | 64567 |
| 64616 | return NULL; |  | 64568 | return NULL;
| 64617 | } |  | 64569 | }
| 64618 |  |  | 64570 |
| 64619 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64571 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getPoints(PyObject* self, PyObject* py_args, PyObject* kw)
| 64620 | { |  | 64572 | {
| 64621 | using namespace cv::large_kinfu; |  | 64573 | using namespace cv::large_kinfu;
| 64622 |  |  | 64574 |
| 64623 |  |  | 64575 |
| 64624 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0; |  | 64576 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0;
| 64625 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1)) |  | 64577 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1))
| 64626 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)"); |  | 64578 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)");
| 64627 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1); |  | 64579 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1);
| 64628 | pyPrepareArgumentConversionErrorsStorage(2); |  | 64580 | pyPrepareArgumentConversionErrorsStorage(2);
| 64629 |  |  | 64581 |
| 64630 | { |  | 64582 | {
| 64631 | PyObject* pyobj_points = NULL; |  | 64583 | PyObject* pyobj_points = NULL;
| 64632 | Mat points; |  | 64584 | Mat points;
| 64633 |  |  | 64585 |
| 64634 | const char* keywords[] = { "points", NULL }; |  | 64586 | const char* keywords[] = { "points", NULL };
| 64635 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.getPoints", (char**)keywords, &pyobj_points) && |  | 64587 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.getPoints", (char**)keywords, &pyobj_points) &&
| 64636 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 64588 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 64637 | { |  | 64589 | {
| 64638 | ERRWRAP2(_self_->getPoints(points)); |  | 64590 | ERRWRAP2(_self_->getPoints(points));
| 64639 | return pyopencv_from(points); |  | 64591 | return pyopencv_from(points);
| 64640 | } |  | 64592 | }
| 64641 |  |  | 64593 |
| 64642 |  |  | 64594 |
| 64643 | pyPopulateArgumentConversionErrors(); |  | 64595 | pyPopulateArgumentConversionErrors();
| 64644 | } |  | 64596 | }
| 64645 |  |  | 64597 |
| 64646 |  |  | 64598 |
| 64647 | { |  | 64599 | {
| 64648 | PyObject* pyobj_points = NULL; |  | 64600 | PyObject* pyobj_points = NULL;
| 64649 | UMat points; |  | 64601 | UMat points;
| 64650 |  |  | 64602 |
| 64651 | const char* keywords[] = { "points", NULL }; |  | 64603 | const char* keywords[] = { "points", NULL };
| 64652 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.getPoints", (char**)keywords, &pyobj_points) && |  | 64604 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.getPoints", (char**)keywords, &pyobj_points) &&
| 64653 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) ) |  | 64605 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 1)) )
| 64654 | { |  | 64606 | {
| 64655 | ERRWRAP2(_self_->getPoints(points)); |  | 64607 | ERRWRAP2(_self_->getPoints(points));
| 64656 | return pyopencv_from(points); |  | 64608 | return pyopencv_from(points);
| 64657 | } |  | 64609 | }
| 64658 |  |  | 64610 |
| 64659 |  |  | 64611 |
| 64660 | pyPopulateArgumentConversionErrors(); |  | 64612 | pyPopulateArgumentConversionErrors();
| 64661 | } |  | 64613 | }
| 64662 | pyRaiseCVOverloadException("getPoints"); |  | 64614 | pyRaiseCVOverloadException("getPoints");
| 64663 |  |  | 64615 |
| 64664 | return NULL; |  | 64616 | return NULL;
| 64665 | } |  | 64617 | }
| 64666 |  |  | 64618 |
| 64667 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_render(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64619 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_render(PyObject* self, PyObject* py_args, PyObject* kw)
| 64668 | { |  | 64620 | {
| 64669 | using namespace cv::large_kinfu; |  | 64621 | using namespace cv::large_kinfu;
| 64670 |  |  | 64622 |
| 64671 |  |  | 64623 |
| 64672 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0; |  | 64624 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0;
| 64673 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1)) |  | 64625 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1))
| 64674 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)"); |  | 64626 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)");
| 64675 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1); |  | 64627 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1);
| 64676 | pyPrepareArgumentConversionErrorsStorage(4); |  | 64628 | pyPrepareArgumentConversionErrorsStorage(4);
| 64677 |  |  | 64629 |
| 64678 | { |  | 64630 | {
| 64679 | PyObject* pyobj_image = NULL; |  | 64631 | PyObject* pyobj_image = NULL;
| 64680 | Mat image; |  | 64632 | Mat image;
| 64681 |  |  | 64633 |
| 64682 | const char* keywords[] = { "image", NULL }; |  | 64634 | const char* keywords[] = { "image", NULL };
| 64683 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_image) && |  | 64635 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_image) &&
| 64684 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 64636 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 64685 | { |  | 64637 | {
| 64686 | ERRWRAP2(_self_->render(image)); |  | 64638 | ERRWRAP2(_self_->render(image));
| 64687 | return pyopencv_from(image); |  | 64639 | return pyopencv_from(image);
| 64688 | } |  | 64640 | }
| 64689 |  |  | 64641 |
| 64690 |  |  | 64642 |
| 64691 | pyPopulateArgumentConversionErrors(); |  | 64643 | pyPopulateArgumentConversionErrors();
| 64692 | } |  | 64644 | }
| 64693 |  |  | 64645 |
| 64694 |  |  | 64646 |
| 64695 | { |  | 64647 | {
| 64696 | PyObject* pyobj_image = NULL; |  | 64648 | PyObject* pyobj_image = NULL;
| 64697 | Mat image; |  | 64649 | Mat image;
| 64698 | PyObject* pyobj_cameraPose = NULL; |  | 64650 | PyObject* pyobj_cameraPose = NULL;
| 64699 | Matx44f cameraPose; |  | 64651 | Matx44f cameraPose;
| 64700 |  |  | 64652 |
| 64701 | const char* keywords[] = { "cameraPose", "image", NULL }; |  | 64653 | const char* keywords[] = { "cameraPose", "image", NULL };
| 64702 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) && |  | 64654 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) &&
| 64703 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 64655 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 64704 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 64656 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 64705 | { |  | 64657 | {
| 64706 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 64658 | ERRWRAP2(_self_->render(image, cameraPose));
| 64707 | return pyopencv_from(image); |  | 64659 | return pyopencv_from(image);
| 64708 | } |  | 64660 | }
| 64709 |  |  | 64661 |
| 64710 |  |  | 64662 |
| 64711 | pyPopulateArgumentConversionErrors(); |  | 64663 | pyPopulateArgumentConversionErrors();
| 64712 | } |  | 64664 | }
| 64713 |  |  | 64665 |
| 64714 |  |  | 64666 |
| 64715 | { |  | 64667 | {
| 64716 | PyObject* pyobj_image = NULL; |  | 64668 | PyObject* pyobj_image = NULL;
| 64717 | UMat image; |  | 64669 | UMat image;
| 64718 |  |  | 64670 |
| 64719 | const char* keywords[] = { "image", NULL }; |  | 64671 | const char* keywords[] = { "image", NULL };
| 64720 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_image) && |  | 64672 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_image) &&
| 64721 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) ) |  | 64673 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) )
| 64722 | { |  | 64674 | {
| 64723 | ERRWRAP2(_self_->render(image)); |  | 64675 | ERRWRAP2(_self_->render(image));
| 64724 | return pyopencv_from(image); |  | 64676 | return pyopencv_from(image);
| 64725 | } |  | 64677 | }
| 64726 |  |  | 64678 |
| 64727 |  |  | 64679 |
| 64728 | pyPopulateArgumentConversionErrors(); |  | 64680 | pyPopulateArgumentConversionErrors();
| 64729 | } |  | 64681 | }
| 64730 |  |  | 64682 |
| 64731 |  |  | 64683 |
| 64732 | { |  | 64684 | {
| 64733 | PyObject* pyobj_image = NULL; |  | 64685 | PyObject* pyobj_image = NULL;
| 64734 | UMat image; |  | 64686 | UMat image;
| 64735 | PyObject* pyobj_cameraPose = NULL; |  | 64687 | PyObject* pyobj_cameraPose = NULL;
| 64736 | Matx44f cameraPose; |  | 64688 | Matx44f cameraPose;
| 64737 |  |  | 64689 |
| 64738 | const char* keywords[] = { "cameraPose", "image", NULL }; |  | 64690 | const char* keywords[] = { "cameraPose", "image", NULL };
| 64739 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) && |  | 64691 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:large_kinfu_LargeKinfu.render", (char**)keywords, &pyobj_cameraPose, &pyobj_image) &&
| 64740 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) && |  | 64692 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 1)) &&
| 64741 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) ) |  | 64693 | pyopencv_to_safe(pyobj_cameraPose, cameraPose, ArgInfo("cameraPose", 0)) )
| 64742 | { |  | 64694 | {
| 64743 | ERRWRAP2(_self_->render(image, cameraPose)); |  | 64695 | ERRWRAP2(_self_->render(image, cameraPose));
| 64744 | return pyopencv_from(image); |  | 64696 | return pyopencv_from(image);
| 64745 | } |  | 64697 | }
| 64746 |  |  | 64698 |
| 64747 |  |  | 64699 |
| 64748 | pyPopulateArgumentConversionErrors(); |  | 64700 | pyPopulateArgumentConversionErrors();
| 64749 | } |  | 64701 | }
| 64750 | pyRaiseCVOverloadException("render"); |  | 64702 | pyRaiseCVOverloadException("render");
| 64751 |  |  | 64703 |
| 64752 | return NULL; |  | 64704 | return NULL;
| 64753 | } |  | 64705 | }
| 64754 |  |  | 64706 |
| 64755 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_reset(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64707 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_reset(PyObject* self, PyObject* py_args, PyObject* kw)
| 64756 | { |  | 64708 | {
| 64757 | using namespace cv::large_kinfu; |  | 64709 | using namespace cv::large_kinfu;
| 64758 |  |  | 64710 |
| 64759 |  |  | 64711 |
| 64760 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0; |  | 64712 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0;
| 64761 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1)) |  | 64713 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1))
| 64762 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)"); |  | 64714 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)");
| 64763 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1); |  | 64715 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1);
| 64764 |  |  | 64716 |
| 64765 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 64717 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 64766 | { |  | 64718 | {
| 64767 | ERRWRAP2(_self_->reset()); |  | 64719 | ERRWRAP2(_self_->reset());
| 64768 | Py_RETURN_NONE; |  | 64720 | Py_RETURN_NONE;
| 64769 | } |  | 64721 | }
| 64770 |  |  | 64722 |
| 64771 | return NULL; |  | 64723 | return NULL;
| 64772 | } |  | 64724 | }
| 64773 |  |  | 64725 |
| 64774 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 64726 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 64775 | { |  | 64727 | {
| 64776 | using namespace cv::large_kinfu; |  | 64728 | using namespace cv::large_kinfu;
| 64777 |  |  | 64729 |
| 64778 |  |  | 64730 |
| 64779 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0; |  | 64731 | Ptr<cv::large_kinfu::LargeKinfu> * self1 = 0;
| 64780 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1)) |  | 64732 | if (!pyopencv_large_kinfu_LargeKinfu_getp(self, self1))
| 64781 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)"); |  | 64733 | return failmsgp("Incorrect type of self (must be 'large_kinfu_LargeKinfu' or its derivative)");
| 64782 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1); |  | 64734 | Ptr<cv::large_kinfu::LargeKinfu> _self_ = *(self1);
| 64783 | pyPrepareArgumentConversionErrorsStorage(2); |  | 64735 | pyPrepareArgumentConversionErrorsStorage(2);
| 64784 |  |  | 64736 |
| 64785 | { |  | 64737 | {
| 64786 | PyObject* pyobj_depth = NULL; |  | 64738 | PyObject* pyobj_depth = NULL;
| 64787 | Mat depth; |  | 64739 | Mat depth;
| 64788 | bool retval; |  | 64740 | bool retval;
| 64789 |  |  | 64741 |
| 64790 | const char* keywords[] = { "depth", NULL }; |  | 64742 | const char* keywords[] = { "depth", NULL };
| 64791 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_LargeKinfu.update", (char**)keywords, &pyobj_depth) && |  | 64743 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_LargeKinfu.update", (char**)keywords, &pyobj_depth) &&
| 64792 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) ) |  | 64744 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) )
| 64793 | { |  | 64745 | {
| 64794 | ERRWRAP2(retval = _self_->update(depth)); |  | 64746 | ERRWRAP2(retval = _self_->update(depth));
| 64795 | return pyopencv_from(retval); |  | 64747 | return pyopencv_from(retval);
| 64796 | } |  | 64748 | }
| 64797 |  |  | 64749 |
| 64798 |  |  | 64750 |
| 64799 | pyPopulateArgumentConversionErrors(); |  | 64751 | pyPopulateArgumentConversionErrors();
| 64800 | } |  | 64752 | }
| 64801 |  |  | 64753 |
| 64802 |  |  | 64754 |
| 64803 | { |  | 64755 | {
| 64804 | PyObject* pyobj_depth = NULL; |  | 64756 | PyObject* pyobj_depth = NULL;
| 64805 | UMat depth; |  | 64757 | UMat depth;
| 64806 | bool retval; |  | 64758 | bool retval;
| 64807 |  |  | 64759 |
| 64808 | const char* keywords[] = { "depth", NULL }; |  | 64760 | const char* keywords[] = { "depth", NULL };
| 64809 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_LargeKinfu.update", (char**)keywords, &pyobj_depth) && |  | 64761 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_LargeKinfu.update", (char**)keywords, &pyobj_depth) &&
| 64810 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) ) |  | 64762 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) )
| 64811 | { |  | 64763 | {
| 64812 | ERRWRAP2(retval = _self_->update(depth)); |  | 64764 | ERRWRAP2(retval = _self_->update(depth));
| 64813 | return pyopencv_from(retval); |  | 64765 | return pyopencv_from(retval);
| 64814 | } |  | 64766 | }
| 64815 |  |  | 64767 |
| 64816 |  |  | 64768 |
| 64817 | pyPopulateArgumentConversionErrors(); |  | 64769 | pyPopulateArgumentConversionErrors();
| 64818 | } |  | 64770 | }
| 64819 | pyRaiseCVOverloadException("update"); |  | 64771 | pyRaiseCVOverloadException("update");
| 64820 |  |  | 64772 |
| 64821 | return NULL; |  | 64773 | return NULL;
| 64822 | } |  | 64774 | }
| 64823 |  |  | 64775 |
| 64824 |  |  | 64776 |
| 64825 |  |  | 64777 |
| 64826 | // Tables (large_kinfu_LargeKinfu) |  | 64778 | // Tables (large_kinfu_LargeKinfu)
| 64827 |  |  | 64779 |
| 64828 | static PyGetSetDef pyopencv_large_kinfu_LargeKinfu_getseters[] = |  | 64780 | static PyGetSetDef pyopencv_large_kinfu_LargeKinfu_getseters[] =
| 64829 | { |  | 64781 | {
| 64830 | {NULL} /* Sentinel */ |  | 64782 | {NULL} /* Sentinel */
| 64831 | }; |  | 64783 | };
| 64832 |  |  | 64784 |
| 64833 | static PyMethodDef pyopencv_large_kinfu_LargeKinfu_methods[] = |  | 64785 | static PyMethodDef pyopencv_large_kinfu_LargeKinfu_methods[] =
| 64834 | { |  | 64786 | {
| 64835 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_create_static, METH_STATIC), "create(_params) -> retval\n."}, |  | 64787 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_create_static, METH_STATIC), "create(_params) -> retval\n."},
| 64836 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getCloud, 0), "getCloud([, points[, normals]]) -> points, normals\n."}, |  | 64788 | {"getCloud", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getCloud, 0), "getCloud([, points[, normals]]) -> points, normals\n."},
| 64837 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getNormals, 0), "getNormals(points[, normals]) -> normals\n."}, |  | 64789 | {"getNormals", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getNormals, 0), "getNormals(points[, normals]) -> normals\n."},
| 64838 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getPoints, 0), "getPoints([, points]) -> points\n."}, |  | 64790 | {"getPoints", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_getPoints, 0), "getPoints([, points]) -> points\n."},
| 64839 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_render, 0), "render([, image]) -> image\n. \n\n\n\nrender(cameraPose[, image]) -> image\n."}, |  | 64791 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_render, 0), "render([, image]) -> image\n. \n\n\n\nrender(cameraPose[, image]) -> image\n."},
| 64840 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_reset, 0), "reset() -> None\n."}, |  | 64792 | {"reset", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_reset, 0), "reset() -> None\n."},
| 64841 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_update, 0), "update(depth) -> retval\n."}, |  | 64793 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_LargeKinfu_update, 0), "update(depth) -> retval\n."},
| 64842 |  |  | 64794 |
| 64843 | {NULL, NULL} |  | 64795 | {NULL, NULL}
| 64844 | }; |  | 64796 | };
| 64845 |  |  | 64797 |
| 64846 | // Converter (large_kinfu_LargeKinfu) |  | 64798 | // Converter (large_kinfu_LargeKinfu)
| 64847 |  |  | 64799 |
| 64848 | template<> |  | 64800 | template<>
| 64849 | struct PyOpenCV_Converter< Ptr<cv::large_kinfu::LargeKinfu> > |  | 64801 | struct PyOpenCV_Converter< Ptr<cv::large_kinfu::LargeKinfu> >
| 64850 | { |  | 64802 | {
| 64851 | static PyObject* from(const Ptr<cv::large_kinfu::LargeKinfu>& r) |  | 64803 | static PyObject* from(const Ptr<cv::large_kinfu::LargeKinfu>& r)
| 64852 | { |  | 64804 | {
| 64853 | return pyopencv_large_kinfu_LargeKinfu_Instance(r); |  | 64805 | return pyopencv_large_kinfu_LargeKinfu_Instance(r);
| 64854 | } |  | 64806 | }
| 64855 | static bool to(PyObject* src, Ptr<cv::large_kinfu::LargeKinfu>& dst, const ArgInfo& info) |  | 64807 | static bool to(PyObject* src, Ptr<cv::large_kinfu::LargeKinfu>& dst, const ArgInfo& info)
| 64856 | { |  | 64808 | {
| 64857 | if(!src || src == Py_None) |  | 64809 | if(!src || src == Py_None)
| 64858 | return true; |  | 64810 | return true;
| 64859 | Ptr<cv::large_kinfu::LargeKinfu> * dst_; |  | 64811 | Ptr<cv::large_kinfu::LargeKinfu> * dst_;
| 64860 | if (pyopencv_large_kinfu_LargeKinfu_getp(src, dst_)) |  | 64812 | if (pyopencv_large_kinfu_LargeKinfu_getp(src, dst_))
| 64861 | { |  | 64813 | {
| 64862 | dst = *dst_; |  | 64814 | dst = *dst_;
| 64863 | return true; |  | 64815 | return true;
| 64864 | } |  | 64816 | }
| 64865 |  |  | 64817 |
| 64866 | failmsg("Expected Ptr<cv::large_kinfu::LargeKinfu> for argument '%s'", info.name); |  | 64818 | failmsg("Expected Ptr<cv::large_kinfu::LargeKinfu> for argument '%s'", info.name);
| 64867 | return false; |  | 64819 | return false;
| 64868 | } |  | 64820 | }
| 64869 | }; |  | 64821 | };
| 64870 |  |  | 64822 |
| 64871 | //================================================================================ |  | 64823 | //================================================================================
| 64872 | // large_kinfu_Params (Generic) |  | 64824 | // large_kinfu_Params (Generic)
| 64873 | //================================================================================ |  | 64825 | //================================================================================
| 64874 |  |  | 64826 |
| 64875 | // GetSet (large_kinfu_Params) |  | 64827 | // GetSet (large_kinfu_Params)
| 64876 |  |  | 64828 |
| 64877 |  |  | 64829 |
| 64878 | static PyObject* pyopencv_large_kinfu_Params_get_bilateral_kernel_size(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64830 | static PyObject* pyopencv_large_kinfu_Params_get_bilateral_kernel_size(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64879 | { |  | 64831 | {
| 64880 | return pyopencv_from(p->v->bilateral_kernel_size); |  | 64832 | return pyopencv_from(p->v->bilateral_kernel_size);
| 64881 | } |  | 64833 | }
| 64882 |  |  | 64834 |
| 64883 | static int pyopencv_large_kinfu_Params_set_bilateral_kernel_size(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64835 | static int pyopencv_large_kinfu_Params_set_bilateral_kernel_size(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64884 | { |  | 64836 | {
| 64885 | if (!value) |  | 64837 | if (!value)
| 64886 | { |  | 64838 | {
| 64887 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_kernel_size attribute"); |  | 64839 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_kernel_size attribute");
| 64888 | return -1; |  | 64840 | return -1;
| 64889 | } |  | 64841 | }
| 64890 | return pyopencv_to_safe(value, p->v->bilateral_kernel_size, ArgInfo("value", 0)) ? 0 : -1; |  | 64842 | return pyopencv_to_safe(value, p->v->bilateral_kernel_size, ArgInfo("value", 0)) ? 0 : -1;
| 64891 | } |  | 64843 | }
| 64892 |  |  | 64844 |
| 64893 | static PyObject* pyopencv_large_kinfu_Params_get_bilateral_sigma_depth(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64845 | static PyObject* pyopencv_large_kinfu_Params_get_bilateral_sigma_depth(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64894 | { |  | 64846 | {
| 64895 | return pyopencv_from(p->v->bilateral_sigma_depth); |  | 64847 | return pyopencv_from(p->v->bilateral_sigma_depth);
| 64896 | } |  | 64848 | }
| 64897 |  |  | 64849 |
| 64898 | static int pyopencv_large_kinfu_Params_set_bilateral_sigma_depth(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64850 | static int pyopencv_large_kinfu_Params_set_bilateral_sigma_depth(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64899 | { |  | 64851 | {
| 64900 | if (!value) |  | 64852 | if (!value)
| 64901 | { |  | 64853 | {
| 64902 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_depth attribute"); |  | 64854 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_depth attribute");
| 64903 | return -1; |  | 64855 | return -1;
| 64904 | } |  | 64856 | }
| 64905 | return pyopencv_to_safe(value, p->v->bilateral_sigma_depth, ArgInfo("value", 0)) ? 0 : -1; |  | 64857 | return pyopencv_to_safe(value, p->v->bilateral_sigma_depth, ArgInfo("value", 0)) ? 0 : -1;
| 64906 | } |  | 64858 | }
| 64907 |  |  | 64859 |
| 64908 | static PyObject* pyopencv_large_kinfu_Params_get_bilateral_sigma_spatial(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64860 | static PyObject* pyopencv_large_kinfu_Params_get_bilateral_sigma_spatial(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64909 | { |  | 64861 | {
| 64910 | return pyopencv_from(p->v->bilateral_sigma_spatial); |  | 64862 | return pyopencv_from(p->v->bilateral_sigma_spatial);
| 64911 | } |  | 64863 | }
| 64912 |  |  | 64864 |
| 64913 | static int pyopencv_large_kinfu_Params_set_bilateral_sigma_spatial(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64865 | static int pyopencv_large_kinfu_Params_set_bilateral_sigma_spatial(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64914 | { |  | 64866 | {
| 64915 | if (!value) |  | 64867 | if (!value)
| 64916 | { |  | 64868 | {
| 64917 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_spatial attribute"); |  | 64869 | PyErr_SetString(PyExc_TypeError, "Cannot delete the bilateral_sigma_spatial attribute");
| 64918 | return -1; |  | 64870 | return -1;
| 64919 | } |  | 64871 | }
| 64920 | return pyopencv_to_safe(value, p->v->bilateral_sigma_spatial, ArgInfo("value", 0)) ? 0 : -1; |  | 64872 | return pyopencv_to_safe(value, p->v->bilateral_sigma_spatial, ArgInfo("value", 0)) ? 0 : -1;
| 64921 | } |  | 64873 | }
| 64922 |  |  | 64874 |
| 64923 | static PyObject* pyopencv_large_kinfu_Params_get_depthFactor(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64875 | static PyObject* pyopencv_large_kinfu_Params_get_depthFactor(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64924 | { |  | 64876 | {
| 64925 | return pyopencv_from(p->v->depthFactor); |  | 64877 | return pyopencv_from(p->v->depthFactor);
| 64926 | } |  | 64878 | }
| 64927 |  |  | 64879 |
| 64928 | static int pyopencv_large_kinfu_Params_set_depthFactor(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64880 | static int pyopencv_large_kinfu_Params_set_depthFactor(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64929 | { |  | 64881 | {
| 64930 | if (!value) |  | 64882 | if (!value)
| 64931 | { |  | 64883 | {
| 64932 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthFactor attribute"); |  | 64884 | PyErr_SetString(PyExc_TypeError, "Cannot delete the depthFactor attribute");
| 64933 | return -1; |  | 64885 | return -1;
| 64934 | } |  | 64886 | }
| 64935 | return pyopencv_to_safe(value, p->v->depthFactor, ArgInfo("value", 0)) ? 0 : -1; |  | 64887 | return pyopencv_to_safe(value, p->v->depthFactor, ArgInfo("value", 0)) ? 0 : -1;
| 64936 | } |  | 64888 | }
| 64937 |  |  | 64889 |
| 64938 | static PyObject* pyopencv_large_kinfu_Params_get_frameSize(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64890 | static PyObject* pyopencv_large_kinfu_Params_get_frameSize(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64939 | { |  | 64891 | {
| 64940 | return pyopencv_from(p->v->frameSize); |  | 64892 | return pyopencv_from(p->v->frameSize);
| 64941 | } |  | 64893 | }
| 64942 |  |  | 64894 |
| 64943 | static int pyopencv_large_kinfu_Params_set_frameSize(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64895 | static int pyopencv_large_kinfu_Params_set_frameSize(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64944 | { |  | 64896 | {
| 64945 | if (!value) |  | 64897 | if (!value)
| 64946 | { |  | 64898 | {
| 64947 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frameSize attribute"); |  | 64899 | PyErr_SetString(PyExc_TypeError, "Cannot delete the frameSize attribute");
| 64948 | return -1; |  | 64900 | return -1;
| 64949 | } |  | 64901 | }
| 64950 | return pyopencv_to_safe(value, p->v->frameSize, ArgInfo("value", 0)) ? 0 : -1; |  | 64902 | return pyopencv_to_safe(value, p->v->frameSize, ArgInfo("value", 0)) ? 0 : -1;
| 64951 | } |  | 64903 | }
| 64952 |  |  | 64904 |
| 64953 | static PyObject* pyopencv_large_kinfu_Params_get_icpAngleThresh(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64905 | static PyObject* pyopencv_large_kinfu_Params_get_icpAngleThresh(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64954 | { |  | 64906 | {
| 64955 | return pyopencv_from(p->v->icpAngleThresh); |  | 64907 | return pyopencv_from(p->v->icpAngleThresh);
| 64956 | } |  | 64908 | }
| 64957 |  |  | 64909 |
| 64958 | static int pyopencv_large_kinfu_Params_set_icpAngleThresh(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64910 | static int pyopencv_large_kinfu_Params_set_icpAngleThresh(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64959 | { |  | 64911 | {
| 64960 | if (!value) |  | 64912 | if (!value)
| 64961 | { |  | 64913 | {
| 64962 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpAngleThresh attribute"); |  | 64914 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpAngleThresh attribute");
| 64963 | return -1; |  | 64915 | return -1;
| 64964 | } |  | 64916 | }
| 64965 | return pyopencv_to_safe(value, p->v->icpAngleThresh, ArgInfo("value", 0)) ? 0 : -1; |  | 64917 | return pyopencv_to_safe(value, p->v->icpAngleThresh, ArgInfo("value", 0)) ? 0 : -1;
| 64966 | } |  | 64918 | }
| 64967 |  |  | 64919 |
| 64968 | static PyObject* pyopencv_large_kinfu_Params_get_icpDistThresh(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64920 | static PyObject* pyopencv_large_kinfu_Params_get_icpDistThresh(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64969 | { |  | 64921 | {
| 64970 | return pyopencv_from(p->v->icpDistThresh); |  | 64922 | return pyopencv_from(p->v->icpDistThresh);
| 64971 | } |  | 64923 | }
| 64972 |  |  | 64924 |
| 64973 | static int pyopencv_large_kinfu_Params_set_icpDistThresh(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64925 | static int pyopencv_large_kinfu_Params_set_icpDistThresh(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64974 | { |  | 64926 | {
| 64975 | if (!value) |  | 64927 | if (!value)
| 64976 | { |  | 64928 | {
| 64977 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpDistThresh attribute"); |  | 64929 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpDistThresh attribute");
| 64978 | return -1; |  | 64930 | return -1;
| 64979 | } |  | 64931 | }
| 64980 | return pyopencv_to_safe(value, p->v->icpDistThresh, ArgInfo("value", 0)) ? 0 : -1; |  | 64932 | return pyopencv_to_safe(value, p->v->icpDistThresh, ArgInfo("value", 0)) ? 0 : -1;
| 64981 | } |  | 64933 | }
| 64982 |  |  | 64934 |
| 64983 | static PyObject* pyopencv_large_kinfu_Params_get_icpIterations(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64935 | static PyObject* pyopencv_large_kinfu_Params_get_icpIterations(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64984 | { |  | 64936 | {
| 64985 | return pyopencv_from(p->v->icpIterations); |  | 64937 | return pyopencv_from(p->v->icpIterations);
| 64986 | } |  | 64938 | }
| 64987 |  |  | 64939 |
| 64988 | static int pyopencv_large_kinfu_Params_set_icpIterations(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64940 | static int pyopencv_large_kinfu_Params_set_icpIterations(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 64989 | { |  | 64941 | {
| 64990 | if (!value) |  | 64942 | if (!value)
| 64991 | { |  | 64943 | {
| 64992 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpIterations attribute"); |  | 64944 | PyErr_SetString(PyExc_TypeError, "Cannot delete the icpIterations attribute");
| 64993 | return -1; |  | 64945 | return -1;
| 64994 | } |  | 64946 | }
| 64995 | return pyopencv_to_safe(value, p->v->icpIterations, ArgInfo("value", 0)) ? 0 : -1; |  | 64947 | return pyopencv_to_safe(value, p->v->icpIterations, ArgInfo("value", 0)) ? 0 : -1;
| 64996 | } |  | 64948 | }
| 64997 |  |  | 64949 |
| 64998 | static PyObject* pyopencv_large_kinfu_Params_get_intr(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64950 | static PyObject* pyopencv_large_kinfu_Params_get_intr(pyopencv_large_kinfu_Params_t* p, void *closure)
| 64999 | { |  | 64951 | {
| 65000 | return pyopencv_from(p->v->intr); |  | 64952 | return pyopencv_from(p->v->intr);
| 65001 | } |  | 64953 | }
| 65002 |  |  | 64954 |
| 65003 | static int pyopencv_large_kinfu_Params_set_intr(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64955 | static int pyopencv_large_kinfu_Params_set_intr(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 65004 | { |  | 64956 | {
| 65005 | if (!value) |  | 64957 | if (!value)
| 65006 | { |  | 64958 | {
| 65007 | PyErr_SetString(PyExc_TypeError, "Cannot delete the intr attribute"); |  | 64959 | PyErr_SetString(PyExc_TypeError, "Cannot delete the intr attribute");
| 65008 | return -1; |  | 64960 | return -1;
| 65009 | } |  | 64961 | }
| 65010 | return pyopencv_to_safe(value, p->v->intr, ArgInfo("value", 0)) ? 0 : -1; |  | 64962 | return pyopencv_to_safe(value, p->v->intr, ArgInfo("value", 0)) ? 0 : -1;
| 65011 | } |  | 64963 | }
| 65012 |  |  | 64964 |
| 65013 | static PyObject* pyopencv_large_kinfu_Params_get_lightPose(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64965 | static PyObject* pyopencv_large_kinfu_Params_get_lightPose(pyopencv_large_kinfu_Params_t* p, void *closure)
| 65014 | { |  | 64966 | {
| 65015 | return pyopencv_from(p->v->lightPose); |  | 64967 | return pyopencv_from(p->v->lightPose);
| 65016 | } |  | 64968 | }
| 65017 |  |  | 64969 |
| 65018 | static int pyopencv_large_kinfu_Params_set_lightPose(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64970 | static int pyopencv_large_kinfu_Params_set_lightPose(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 65019 | { |  | 64971 | {
| 65020 | if (!value) |  | 64972 | if (!value)
| 65021 | { |  | 64973 | {
| 65022 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lightPose attribute"); |  | 64974 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lightPose attribute");
| 65023 | return -1; |  | 64975 | return -1;
| 65024 | } |  | 64976 | }
| 65025 | return pyopencv_to_safe(value, p->v->lightPose, ArgInfo("value", 0)) ? 0 : -1; |  | 64977 | return pyopencv_to_safe(value, p->v->lightPose, ArgInfo("value", 0)) ? 0 : -1;
| 65026 | } |  | 64978 | }
| 65027 |  |  | 64979 |
| 65028 | static PyObject* pyopencv_large_kinfu_Params_get_pyramidLevels(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64980 | static PyObject* pyopencv_large_kinfu_Params_get_pyramidLevels(pyopencv_large_kinfu_Params_t* p, void *closure)
| 65029 | { |  | 64981 | {
| 65030 | return pyopencv_from(p->v->pyramidLevels); |  | 64982 | return pyopencv_from(p->v->pyramidLevels);
| 65031 | } |  | 64983 | }
| 65032 |  |  | 64984 |
| 65033 | static int pyopencv_large_kinfu_Params_set_pyramidLevels(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 64985 | static int pyopencv_large_kinfu_Params_set_pyramidLevels(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 65034 | { |  | 64986 | {
| 65035 | if (!value) |  | 64987 | if (!value)
| 65036 | { |  | 64988 | {
| 65037 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pyramidLevels attribute"); |  | 64989 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pyramidLevels attribute");
| 65038 | return -1; |  | 64990 | return -1;
| 65039 | } |  | 64991 | }
| 65040 | return pyopencv_to_safe(value, p->v->pyramidLevels, ArgInfo("value", 0)) ? 0 : -1; |  | 64992 | return pyopencv_to_safe(value, p->v->pyramidLevels, ArgInfo("value", 0)) ? 0 : -1;
| 65041 | } |  | 64993 | }
| 65042 |  |  | 64994 |
| 65043 | static PyObject* pyopencv_large_kinfu_Params_get_rgb_intr(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 64995 | static PyObject* pyopencv_large_kinfu_Params_get_rgb_intr(pyopencv_large_kinfu_Params_t* p, void *closure)
| 65044 | { |  | 64996 | {
| 65045 | return pyopencv_from(p->v->rgb_intr); |  | 64997 | return pyopencv_from(p->v->rgb_intr);
| 65046 | } |  | 64998 | }
| 65047 |  |  | 64999 |
| 65048 | static int pyopencv_large_kinfu_Params_set_rgb_intr(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 65000 | static int pyopencv_large_kinfu_Params_set_rgb_intr(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 65049 | { |  | 65001 | {
| 65050 | if (!value) |  | 65002 | if (!value)
| 65051 | { |  | 65003 | {
| 65052 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_intr attribute"); |  | 65004 | PyErr_SetString(PyExc_TypeError, "Cannot delete the rgb_intr attribute");
| 65053 | return -1; |  | 65005 | return -1;
| 65054 | } |  | 65006 | }
| 65055 | return pyopencv_to_safe(value, p->v->rgb_intr, ArgInfo("value", 0)) ? 0 : -1; |  | 65007 | return pyopencv_to_safe(value, p->v->rgb_intr, ArgInfo("value", 0)) ? 0 : -1;
| 65056 | } |  | 65008 | }
| 65057 |  |  | 65009 |
| 65058 | static PyObject* pyopencv_large_kinfu_Params_get_truncateThreshold(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 65010 | static PyObject* pyopencv_large_kinfu_Params_get_truncateThreshold(pyopencv_large_kinfu_Params_t* p, void *closure)
| 65059 | { |  | 65011 | {
| 65060 | return pyopencv_from(p->v->truncateThreshold); |  | 65012 | return pyopencv_from(p->v->truncateThreshold);
| 65061 | } |  | 65013 | }
| 65062 |  |  | 65014 |
| 65063 | static int pyopencv_large_kinfu_Params_set_truncateThreshold(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 65015 | static int pyopencv_large_kinfu_Params_set_truncateThreshold(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 65064 | { |  | 65016 | {
| 65065 | if (!value) |  | 65017 | if (!value)
| 65066 | { |  | 65018 | {
| 65067 | PyErr_SetString(PyExc_TypeError, "Cannot delete the truncateThreshold attribute"); |  | 65019 | PyErr_SetString(PyExc_TypeError, "Cannot delete the truncateThreshold attribute");
| 65068 | return -1; |  | 65020 | return -1;
| 65069 | } |  | 65021 | }
| 65070 | return pyopencv_to_safe(value, p->v->truncateThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 65022 | return pyopencv_to_safe(value, p->v->truncateThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 65071 | } |  | 65023 | }
| 65072 |  |  | 65024 |
| 65073 | static PyObject* pyopencv_large_kinfu_Params_get_tsdf_min_camera_movement(pyopencv_large_kinfu_Params_t* p, void *closure) |  | 65025 | static PyObject* pyopencv_large_kinfu_Params_get_tsdf_min_camera_movement(pyopencv_large_kinfu_Params_t* p, void *closure)
| 65074 | { |  | 65026 | {
| 65075 | return pyopencv_from(p->v->tsdf_min_camera_movement); |  | 65027 | return pyopencv_from(p->v->tsdf_min_camera_movement);
| 65076 | } |  | 65028 | }
| 65077 |  |  | 65029 |
| 65078 | static int pyopencv_large_kinfu_Params_set_tsdf_min_camera_movement(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure) |  | 65030 | static int pyopencv_large_kinfu_Params_set_tsdf_min_camera_movement(pyopencv_large_kinfu_Params_t* p, PyObject *value, void *closure)
| 65079 | { |  | 65031 | {
| 65080 | if (!value) |  | 65032 | if (!value)
| 65081 | { |  | 65033 | {
| 65082 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_min_camera_movement attribute"); |  | 65034 | PyErr_SetString(PyExc_TypeError, "Cannot delete the tsdf_min_camera_movement attribute");
| 65083 | return -1; |  | 65035 | return -1;
| 65084 | } |  | 65036 | }
| 65085 | return pyopencv_to_safe(value, p->v->tsdf_min_camera_movement, ArgInfo("value", 0)) ? 0 : -1; |  | 65037 | return pyopencv_to_safe(value, p->v->tsdf_min_camera_movement, ArgInfo("value", 0)) ? 0 : -1;
| 65086 | } |  | 65038 | }
| 65087 |  |  | 65039 |
| 65088 |  |  | 65040 |
| 65089 | // Methods (large_kinfu_Params) |  | 65041 | // Methods (large_kinfu_Params)
| 65090 |  |  | 65042 |
| 65091 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_Params_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65043 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_Params_coarseParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65092 | { |  | 65044 | {
| 65093 | using namespace cv::large_kinfu; |  | 65045 | using namespace cv::large_kinfu;
| 65094 |  |  | 65046 |
| 65095 | Ptr<Params> retval; |  | 65047 | Ptr<Params> retval;
| 65096 |  |  | 65048 |
| 65097 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65049 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65098 | { |  | 65050 | {
| 65099 | ERRWRAP2(retval = cv::large_kinfu::Params::coarseParams()); |  | 65051 | ERRWRAP2(retval = cv::large_kinfu::Params::coarseParams());
| 65100 | return pyopencv_from(retval); |  | 65052 | return pyopencv_from(retval);
| 65101 | } |  | 65053 | }
| 65102 |  |  | 65054 |
| 65103 | return NULL; |  | 65055 | return NULL;
| 65104 | } |  | 65056 | }
| 65105 |  |  | 65057 |
| 65106 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_Params_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65058 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_Params_defaultParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65107 | { |  | 65059 | {
| 65108 | using namespace cv::large_kinfu; |  | 65060 | using namespace cv::large_kinfu;
| 65109 |  |  | 65061 |
| 65110 | Ptr<Params> retval; |  | 65062 | Ptr<Params> retval;
| 65111 |  |  | 65063 |
| 65112 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65064 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65113 | { |  | 65065 | {
| 65114 | ERRWRAP2(retval = cv::large_kinfu::Params::defaultParams()); |  | 65066 | ERRWRAP2(retval = cv::large_kinfu::Params::defaultParams());
| 65115 | return pyopencv_from(retval); |  | 65067 | return pyopencv_from(retval);
| 65116 | } |  | 65068 | }
| 65117 |  |  | 65069 |
| 65118 | return NULL; |  | 65070 | return NULL;
| 65119 | } |  | 65071 | }
| 65120 |  |  | 65072 |
| 65121 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_Params_hashTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65073 | static PyObject* pyopencv_cv_large_kinfu_large_kinfu_Params_hashTSDFParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65122 | { |  | 65074 | {
| 65123 | using namespace cv::large_kinfu; |  | 65075 | using namespace cv::large_kinfu;
| 65124 |  |  | 65076 |
| 65125 | PyObject* pyobj_isCoarse = NULL; |  | 65077 | PyObject* pyobj_isCoarse = NULL;
| 65126 | bool isCoarse=0; |  | 65078 | bool isCoarse=0;
| 65127 | Ptr<Params> retval; |  | 65079 | Ptr<Params> retval;
| 65128 |  |  | 65080 |
| 65129 | const char* keywords[] = { "isCoarse", NULL }; |  | 65081 | const char* keywords[] = { "isCoarse", NULL };
| 65130 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_Params.hashTSDFParams", (char**)keywords, &pyobj_isCoarse) && |  | 65082 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:large_kinfu_Params.hashTSDFParams", (char**)keywords, &pyobj_isCoarse) &&
| 65131 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) ) |  | 65083 | pyopencv_to_safe(pyobj_isCoarse, isCoarse, ArgInfo("isCoarse", 0)) )
| 65132 | { |  | 65084 | {
| 65133 | ERRWRAP2(retval = cv::large_kinfu::Params::hashTSDFParams(isCoarse)); |  | 65085 | ERRWRAP2(retval = cv::large_kinfu::Params::hashTSDFParams(isCoarse));
| 65134 | return pyopencv_from(retval); |  | 65086 | return pyopencv_from(retval);
| 65135 | } |  | 65087 | }
| 65136 |  |  | 65088 |
| 65137 | return NULL; |  | 65089 | return NULL;
| 65138 | } |  | 65090 | }
| 65139 |  |  | 65091 |
| 65140 |  |  | 65092 |
| 65141 |  |  | 65093 |
| 65142 | // Tables (large_kinfu_Params) |  | 65094 | // Tables (large_kinfu_Params)
| 65143 |  |  | 65095 |
| 65144 | static PyGetSetDef pyopencv_large_kinfu_Params_getseters[] = |  | 65096 | static PyGetSetDef pyopencv_large_kinfu_Params_getseters[] =
| 65145 | { |  | 65097 | {
| 65146 | {(char*)"bilateral_kernel_size", (getter)pyopencv_large_kinfu_Params_get_bilateral_kernel_size, (setter)pyopencv_large_kinfu_Params_set_bilateral_kernel_size, (char*)"bilateral_kernel_size", NULL}, |  | 65098 | {(char*)"bilateral_kernel_size", (getter)pyopencv_large_kinfu_Params_get_bilateral_kernel_size, (setter)pyopencv_large_kinfu_Params_set_bilateral_kernel_size, (char*)"bilateral_kernel_size", NULL},
| 65147 | {(char*)"bilateral_sigma_depth", (getter)pyopencv_large_kinfu_Params_get_bilateral_sigma_depth, (setter)pyopencv_large_kinfu_Params_set_bilateral_sigma_depth, (char*)"bilateral_sigma_depth", NULL}, |  | 65099 | {(char*)"bilateral_sigma_depth", (getter)pyopencv_large_kinfu_Params_get_bilateral_sigma_depth, (setter)pyopencv_large_kinfu_Params_set_bilateral_sigma_depth, (char*)"bilateral_sigma_depth", NULL},
| 65148 | {(char*)"bilateral_sigma_spatial", (getter)pyopencv_large_kinfu_Params_get_bilateral_sigma_spatial, (setter)pyopencv_large_kinfu_Params_set_bilateral_sigma_spatial, (char*)"bilateral_sigma_spatial", NULL}, |  | 65100 | {(char*)"bilateral_sigma_spatial", (getter)pyopencv_large_kinfu_Params_get_bilateral_sigma_spatial, (setter)pyopencv_large_kinfu_Params_set_bilateral_sigma_spatial, (char*)"bilateral_sigma_spatial", NULL},
| 65149 | {(char*)"depthFactor", (getter)pyopencv_large_kinfu_Params_get_depthFactor, (setter)pyopencv_large_kinfu_Params_set_depthFactor, (char*)"depthFactor", NULL}, |  | 65101 | {(char*)"depthFactor", (getter)pyopencv_large_kinfu_Params_get_depthFactor, (setter)pyopencv_large_kinfu_Params_set_depthFactor, (char*)"depthFactor", NULL},
| 65150 | {(char*)"frameSize", (getter)pyopencv_large_kinfu_Params_get_frameSize, (setter)pyopencv_large_kinfu_Params_set_frameSize, (char*)"frameSize", NULL}, |  | 65102 | {(char*)"frameSize", (getter)pyopencv_large_kinfu_Params_get_frameSize, (setter)pyopencv_large_kinfu_Params_set_frameSize, (char*)"frameSize", NULL},
| 65151 | {(char*)"icpAngleThresh", (getter)pyopencv_large_kinfu_Params_get_icpAngleThresh, (setter)pyopencv_large_kinfu_Params_set_icpAngleThresh, (char*)"icpAngleThresh", NULL}, |  | 65103 | {(char*)"icpAngleThresh", (getter)pyopencv_large_kinfu_Params_get_icpAngleThresh, (setter)pyopencv_large_kinfu_Params_set_icpAngleThresh, (char*)"icpAngleThresh", NULL},
| 65152 | {(char*)"icpDistThresh", (getter)pyopencv_large_kinfu_Params_get_icpDistThresh, (setter)pyopencv_large_kinfu_Params_set_icpDistThresh, (char*)"icpDistThresh", NULL}, |  | 65104 | {(char*)"icpDistThresh", (getter)pyopencv_large_kinfu_Params_get_icpDistThresh, (setter)pyopencv_large_kinfu_Params_set_icpDistThresh, (char*)"icpDistThresh", NULL},
| 65153 | {(char*)"icpIterations", (getter)pyopencv_large_kinfu_Params_get_icpIterations, (setter)pyopencv_large_kinfu_Params_set_icpIterations, (char*)"icpIterations", NULL}, |  | 65105 | {(char*)"icpIterations", (getter)pyopencv_large_kinfu_Params_get_icpIterations, (setter)pyopencv_large_kinfu_Params_set_icpIterations, (char*)"icpIterations", NULL},
| 65154 | {(char*)"intr", (getter)pyopencv_large_kinfu_Params_get_intr, (setter)pyopencv_large_kinfu_Params_set_intr, (char*)"intr", NULL}, |  | 65106 | {(char*)"intr", (getter)pyopencv_large_kinfu_Params_get_intr, (setter)pyopencv_large_kinfu_Params_set_intr, (char*)"intr", NULL},
| 65155 | {(char*)"lightPose", (getter)pyopencv_large_kinfu_Params_get_lightPose, (setter)pyopencv_large_kinfu_Params_set_lightPose, (char*)"lightPose", NULL}, |  | 65107 | {(char*)"lightPose", (getter)pyopencv_large_kinfu_Params_get_lightPose, (setter)pyopencv_large_kinfu_Params_set_lightPose, (char*)"lightPose", NULL},
| 65156 | {(char*)"pyramidLevels", (getter)pyopencv_large_kinfu_Params_get_pyramidLevels, (setter)pyopencv_large_kinfu_Params_set_pyramidLevels, (char*)"pyramidLevels", NULL}, |  | 65108 | {(char*)"pyramidLevels", (getter)pyopencv_large_kinfu_Params_get_pyramidLevels, (setter)pyopencv_large_kinfu_Params_set_pyramidLevels, (char*)"pyramidLevels", NULL},
| 65157 | {(char*)"rgb_intr", (getter)pyopencv_large_kinfu_Params_get_rgb_intr, (setter)pyopencv_large_kinfu_Params_set_rgb_intr, (char*)"rgb_intr", NULL}, |  | 65109 | {(char*)"rgb_intr", (getter)pyopencv_large_kinfu_Params_get_rgb_intr, (setter)pyopencv_large_kinfu_Params_set_rgb_intr, (char*)"rgb_intr", NULL},
| 65158 | {(char*)"truncateThreshold", (getter)pyopencv_large_kinfu_Params_get_truncateThreshold, (setter)pyopencv_large_kinfu_Params_set_truncateThreshold, (char*)"truncateThreshold", NULL}, |  | 65110 | {(char*)"truncateThreshold", (getter)pyopencv_large_kinfu_Params_get_truncateThreshold, (setter)pyopencv_large_kinfu_Params_set_truncateThreshold, (char*)"truncateThreshold", NULL},
| 65159 | {(char*)"tsdf_min_camera_movement", (getter)pyopencv_large_kinfu_Params_get_tsdf_min_camera_movement, (setter)pyopencv_large_kinfu_Params_set_tsdf_min_camera_movement, (char*)"tsdf_min_camera_movement", NULL}, |  | 65111 | {(char*)"tsdf_min_camera_movement", (getter)pyopencv_large_kinfu_Params_get_tsdf_min_camera_movement, (setter)pyopencv_large_kinfu_Params_set_tsdf_min_camera_movement, (char*)"tsdf_min_camera_movement", NULL},
| 65160 | {NULL} /* Sentinel */ |  | 65112 | {NULL} /* Sentinel */
| 65161 | }; |  | 65113 | };
| 65162 |  |  | 65114 |
| 65163 | static PyMethodDef pyopencv_large_kinfu_Params_methods[] = |  | 65115 | static PyMethodDef pyopencv_large_kinfu_Params_methods[] =
| 65164 | { |  | 65116 | {
| 65165 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_Params_coarseParams_static, METH_STATIC), "coarseParams() -> retval\n. @brief Coarse parameters\n. A set of parameters which provides better speed, can fail to match frames\n. in case of rapid sensor motion."}, |  | 65117 | {"coarseParams", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_Params_coarseParams_static, METH_STATIC), "coarseParams() -> retval\n. @brief Coarse parameters\n. A set of parameters which provides better speed, can fail to match frames\n. in case of rapid sensor motion."},
| 65166 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_Params_defaultParams_static, METH_STATIC), "defaultParams() -> retval\n. @brief Default parameters\n. A set of parameters which provides better model quality, can be very slow."}, |  | 65118 | {"defaultParams", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_Params_defaultParams_static, METH_STATIC), "defaultParams() -> retval\n. @brief Default parameters\n. A set of parameters which provides better model quality, can be very slow."},
| 65167 | {"hashTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_Params_hashTSDFParams_static, METH_STATIC), "hashTSDFParams(isCoarse) -> retval\n. @brief HashTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"}, |  | 65119 | {"hashTSDFParams", CV_PY_FN_WITH_KW_(pyopencv_cv_large_kinfu_large_kinfu_Params_hashTSDFParams_static, METH_STATIC), "hashTSDFParams(isCoarse) -> retval\n. @brief HashTSDF parameters\n. A set of parameters suitable for use with HashTSDFVolume"},
| 65168 |  |  | 65120 |
| 65169 | {NULL, NULL} |  | 65121 | {NULL, NULL}
| 65170 | }; |  | 65122 | };
| 65171 |  |  | 65123 |
| 65172 | // Converter (large_kinfu_Params) |  | 65124 | // Converter (large_kinfu_Params)
| 65173 |  |  | 65125 |
| 65174 | template<> |  | 65126 | template<>
| 65175 | struct PyOpenCV_Converter< Ptr<cv::large_kinfu::Params> > |  | 65127 | struct PyOpenCV_Converter< Ptr<cv::large_kinfu::Params> >
| 65176 | { |  | 65128 | {
| 65177 | static PyObject* from(const Ptr<cv::large_kinfu::Params>& r) |  | 65129 | static PyObject* from(const Ptr<cv::large_kinfu::Params>& r)
| 65178 | { |  | 65130 | {
| 65179 | return pyopencv_large_kinfu_Params_Instance(r); |  | 65131 | return pyopencv_large_kinfu_Params_Instance(r);
| 65180 | } |  | 65132 | }
| 65181 | static bool to(PyObject* src, Ptr<cv::large_kinfu::Params>& dst, const ArgInfo& info) |  | 65133 | static bool to(PyObject* src, Ptr<cv::large_kinfu::Params>& dst, const ArgInfo& info)
| 65182 | { |  | 65134 | {
| 65183 | if(!src || src == Py_None) |  | 65135 | if(!src || src == Py_None)
| 65184 | return true; |  | 65136 | return true;
| 65185 | Ptr<cv::large_kinfu::Params> * dst_; |  | 65137 | Ptr<cv::large_kinfu::Params> * dst_;
| 65186 | if (pyopencv_large_kinfu_Params_getp(src, dst_)) |  | 65138 | if (pyopencv_large_kinfu_Params_getp(src, dst_))
| 65187 | { |  | 65139 | {
| 65188 | dst = *dst_; |  | 65140 | dst = *dst_;
| 65189 | return true; |  | 65141 | return true;
| 65190 | } |  | 65142 | }
| 65191 |  |  | 65143 |
| 65192 | failmsg("Expected Ptr<cv::large_kinfu::Params> for argument '%s'", info.name); |  | 65144 | failmsg("Expected Ptr<cv::large_kinfu::Params> for argument '%s'", info.name);
| 65193 | return false; |  | 65145 | return false;
| 65194 | } |  | 65146 | }
| 65195 | }; |  | 65147 | };
| 65196 |  |  | 65148 |
| 65197 | //================================================================================ |  | 65149 | //================================================================================
| 65198 | // legacy_MultiTracker (Generic) |  | 65150 | // legacy_MultiTracker (Generic)
| 65199 | //================================================================================ |  | 65151 | //================================================================================
| 65200 |  |  | 65152 |
| 65201 | // GetSet (legacy_MultiTracker) |  | 65153 | // GetSet (legacy_MultiTracker)
| 65202 |  |  | 65154 |
| 65203 |  |  | 65155 |
| 65204 |  |  | 65156 |
| 65205 | // Methods (legacy_MultiTracker) |  | 65157 | // Methods (legacy_MultiTracker)
| 65206 |  |  | 65158 |
| 65207 | static int pyopencv_cv_legacy_legacy_MultiTracker_MultiTracker(pyopencv_legacy_MultiTracker_t* self, PyObject* py_args, PyObject* kw) |  | 65159 | static int pyopencv_cv_legacy_legacy_MultiTracker_MultiTracker(pyopencv_legacy_MultiTracker_t* self, PyObject* py_args, PyObject* kw)
| 65208 | { |  | 65160 | {
| 65209 | using namespace cv::legacy; |  | 65161 | using namespace cv::legacy;
| 65210 |  |  | 65162 |
| 65211 |  |  | 65163 |
| 65212 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65164 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65213 | { |  | 65165 | {
| 65214 | new (&(self->v)) Ptr<cv::legacy::MultiTracker>(); // init Ptr with placement new |  | 65166 | new (&(self->v)) Ptr<cv::legacy::MultiTracker>(); // init Ptr with placement new
| 65215 | if(self) ERRWRAP2(self->v.reset(new cv::legacy::MultiTracker())); |  | 65167 | if(self) ERRWRAP2(self->v.reset(new cv::legacy::MultiTracker()));
| 65216 | return 0; |  | 65168 | return 0;
| 65217 | } |  | 65169 | }
| 65218 |  |  | 65170 |
| 65219 | return -1; |  | 65171 | return -1;
| 65220 | } |  | 65172 | }
| 65221 |  |  | 65173 |
| 65222 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_add(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65174 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_add(PyObject* self, PyObject* py_args, PyObject* kw)
| 65223 | { |  | 65175 | {
| 65224 | using namespace cv::legacy; |  | 65176 | using namespace cv::legacy;
| 65225 |  |  | 65177 |
| 65226 |  |  | 65178 |
| 65227 | Ptr<cv::legacy::MultiTracker> * self1 = 0; |  | 65179 | Ptr<cv::legacy::MultiTracker> * self1 = 0;
| 65228 | if (!pyopencv_legacy_MultiTracker_getp(self, self1)) |  | 65180 | if (!pyopencv_legacy_MultiTracker_getp(self, self1))
| 65229 | return failmsgp("Incorrect type of self (must be 'legacy_MultiTracker' or its derivative)"); |  | 65181 | return failmsgp("Incorrect type of self (must be 'legacy_MultiTracker' or its derivative)");
| 65230 | Ptr<cv::legacy::MultiTracker> _self_ = *(self1); |  | 65182 | Ptr<cv::legacy::MultiTracker> _self_ = *(self1);
| 65231 | pyPrepareArgumentConversionErrorsStorage(2); |  | 65183 | pyPrepareArgumentConversionErrorsStorage(2);
| 65232 |  |  | 65184 |
| 65233 | { |  | 65185 | {
| 65234 | PyObject* pyobj_newTracker = NULL; |  | 65186 | PyObject* pyobj_newTracker = NULL;
| 65235 | Ptr<legacy::Tracker> newTracker; |  | 65187 | Ptr<legacy::Tracker> newTracker;
| 65236 | PyObject* pyobj_image = NULL; |  | 65188 | PyObject* pyobj_image = NULL;
| 65237 | Mat image; |  | 65189 | Mat image;
| 65238 | PyObject* pyobj_boundingBox = NULL; |  | 65190 | PyObject* pyobj_boundingBox = NULL;
| 65239 | Rect2d boundingBox; |  | 65191 | Rect2d boundingBox;
| 65240 | bool retval; |  | 65192 | bool retval;
| 65241 |  |  | 65193 |
| 65242 | const char* keywords[] = { "newTracker", "image", "boundingBox", NULL }; |  | 65194 | const char* keywords[] = { "newTracker", "image", "boundingBox", NULL };
| 65243 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:legacy_MultiTracker.add", (char**)keywords, &pyobj_newTracker, &pyobj_image, &pyobj_boundingBox) && |  | 65195 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:legacy_MultiTracker.add", (char**)keywords, &pyobj_newTracker, &pyobj_image, &pyobj_boundingBox) &&
| 65244 | pyopencv_to_safe(pyobj_newTracker, newTracker, ArgInfo("newTracker", 0)) && |  | 65196 | pyopencv_to_safe(pyobj_newTracker, newTracker, ArgInfo("newTracker", 0)) &&
| 65245 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 65197 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 65246 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) ) |  | 65198 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) )
| 65247 | { |  | 65199 | {
| 65248 | ERRWRAP2(retval = _self_->add(newTracker, image, boundingBox)); |  | 65200 | ERRWRAP2(retval = _self_->add(newTracker, image, boundingBox));
| 65249 | return pyopencv_from(retval); |  | 65201 | return pyopencv_from(retval);
| 65250 | } |  | 65202 | }
| 65251 |  |  | 65203 |
| 65252 |  |  | 65204 |
| 65253 | pyPopulateArgumentConversionErrors(); |  | 65205 | pyPopulateArgumentConversionErrors();
| 65254 | } |  | 65206 | }
| 65255 |  |  | 65207 |
| 65256 |  |  | 65208 |
| 65257 | { |  | 65209 | {
| 65258 | PyObject* pyobj_newTracker = NULL; |  | 65210 | PyObject* pyobj_newTracker = NULL;
| 65259 | Ptr<legacy::Tracker> newTracker; |  | 65211 | Ptr<legacy::Tracker> newTracker;
| 65260 | PyObject* pyobj_image = NULL; |  | 65212 | PyObject* pyobj_image = NULL;
| 65261 | UMat image; |  | 65213 | UMat image;
| 65262 | PyObject* pyobj_boundingBox = NULL; |  | 65214 | PyObject* pyobj_boundingBox = NULL;
| 65263 | Rect2d boundingBox; |  | 65215 | Rect2d boundingBox;
| 65264 | bool retval; |  | 65216 | bool retval;
| 65265 |  |  | 65217 |
| 65266 | const char* keywords[] = { "newTracker", "image", "boundingBox", NULL }; |  | 65218 | const char* keywords[] = { "newTracker", "image", "boundingBox", NULL };
| 65267 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:legacy_MultiTracker.add", (char**)keywords, &pyobj_newTracker, &pyobj_image, &pyobj_boundingBox) && |  | 65219 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:legacy_MultiTracker.add", (char**)keywords, &pyobj_newTracker, &pyobj_image, &pyobj_boundingBox) &&
| 65268 | pyopencv_to_safe(pyobj_newTracker, newTracker, ArgInfo("newTracker", 0)) && |  | 65220 | pyopencv_to_safe(pyobj_newTracker, newTracker, ArgInfo("newTracker", 0)) &&
| 65269 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 65221 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 65270 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) ) |  | 65222 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) )
| 65271 | { |  | 65223 | {
| 65272 | ERRWRAP2(retval = _self_->add(newTracker, image, boundingBox)); |  | 65224 | ERRWRAP2(retval = _self_->add(newTracker, image, boundingBox));
| 65273 | return pyopencv_from(retval); |  | 65225 | return pyopencv_from(retval);
| 65274 | } |  | 65226 | }
| 65275 |  |  | 65227 |
| 65276 |  |  | 65228 |
| 65277 | pyPopulateArgumentConversionErrors(); |  | 65229 | pyPopulateArgumentConversionErrors();
| 65278 | } |  | 65230 | }
| 65279 | pyRaiseCVOverloadException("add"); |  | 65231 | pyRaiseCVOverloadException("add");
| 65280 |  |  | 65232 |
| 65281 | return NULL; |  | 65233 | return NULL;
| 65282 | } |  | 65234 | }
| 65283 |  |  | 65235 |
| 65284 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65236 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65285 | { |  | 65237 | {
| 65286 | using namespace cv::legacy; |  | 65238 | using namespace cv::legacy;
| 65287 |  |  | 65239 |
| 65288 | Ptr<MultiTracker> retval; |  | 65240 | Ptr<MultiTracker> retval;
| 65289 |  |  | 65241 |
| 65290 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65242 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65291 | { |  | 65243 | {
| 65292 | ERRWRAP2(retval = cv::legacy::MultiTracker::create()); |  | 65244 | ERRWRAP2(retval = cv::legacy::MultiTracker::create());
| 65293 | return pyopencv_from(retval); |  | 65245 | return pyopencv_from(retval);
| 65294 | } |  | 65246 | }
| 65295 |  |  | 65247 |
| 65296 | return NULL; |  | 65248 | return NULL;
| 65297 | } |  | 65249 | }
| 65298 |  |  | 65250 |
| 65299 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_getObjects(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65251 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_getObjects(PyObject* self, PyObject* py_args, PyObject* kw)
| 65300 | { |  | 65252 | {
| 65301 | using namespace cv::legacy; |  | 65253 | using namespace cv::legacy;
| 65302 |  |  | 65254 |
| 65303 |  |  | 65255 |
| 65304 | Ptr<cv::legacy::MultiTracker> * self1 = 0; |  | 65256 | Ptr<cv::legacy::MultiTracker> * self1 = 0;
| 65305 | if (!pyopencv_legacy_MultiTracker_getp(self, self1)) |  | 65257 | if (!pyopencv_legacy_MultiTracker_getp(self, self1))
| 65306 | return failmsgp("Incorrect type of self (must be 'legacy_MultiTracker' or its derivative)"); |  | 65258 | return failmsgp("Incorrect type of self (must be 'legacy_MultiTracker' or its derivative)");
| 65307 | Ptr<cv::legacy::MultiTracker> _self_ = *(self1); |  | 65259 | Ptr<cv::legacy::MultiTracker> _self_ = *(self1);
| 65308 | std::vector<Rect2d> retval; |  | 65260 | std::vector<Rect2d> retval;
| 65309 |  |  | 65261 |
| 65310 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65262 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65311 | { |  | 65263 | {
| 65312 | ERRWRAP2(retval = _self_->getObjects()); |  | 65264 | ERRWRAP2(retval = _self_->getObjects());
| 65313 | return pyopencv_from(retval); |  | 65265 | return pyopencv_from(retval);
| 65314 | } |  | 65266 | }
| 65315 |  |  | 65267 |
| 65316 | return NULL; |  | 65268 | return NULL;
| 65317 | } |  | 65269 | }
| 65318 |  |  | 65270 |
| 65319 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65271 | static PyObject* pyopencv_cv_legacy_legacy_MultiTracker_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 65320 | { |  | 65272 | {
| 65321 | using namespace cv::legacy; |  | 65273 | using namespace cv::legacy;
| 65322 |  |  | 65274 |
| 65323 |  |  | 65275 |
| 65324 | Ptr<cv::legacy::MultiTracker> * self1 = 0; |  | 65276 | Ptr<cv::legacy::MultiTracker> * self1 = 0;
| 65325 | if (!pyopencv_legacy_MultiTracker_getp(self, self1)) |  | 65277 | if (!pyopencv_legacy_MultiTracker_getp(self, self1))
| 65326 | return failmsgp("Incorrect type of self (must be 'legacy_MultiTracker' or its derivative)"); |  | 65278 | return failmsgp("Incorrect type of self (must be 'legacy_MultiTracker' or its derivative)");
| 65327 | Ptr<cv::legacy::MultiTracker> _self_ = *(self1); |  | 65279 | Ptr<cv::legacy::MultiTracker> _self_ = *(self1);
| 65328 | pyPrepareArgumentConversionErrorsStorage(2); |  | 65280 | pyPrepareArgumentConversionErrorsStorage(2);
| 65329 |  |  | 65281 |
| 65330 | { |  | 65282 | {
| 65331 | PyObject* pyobj_image = NULL; |  | 65283 | PyObject* pyobj_image = NULL;
| 65332 | Mat image; |  | 65284 | Mat image;
| 65333 | vector_Rect2d boundingBox; |  | 65285 | vector_Rect2d boundingBox;
| 65334 | bool retval; |  | 65286 | bool retval;
| 65335 |  |  | 65287 |
| 65336 | const char* keywords[] = { "image", NULL }; |  | 65288 | const char* keywords[] = { "image", NULL };
| 65337 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_MultiTracker.update", (char**)keywords, &pyobj_image) && |  | 65289 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_MultiTracker.update", (char**)keywords, &pyobj_image) &&
| 65338 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 65290 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 65339 | { |  | 65291 | {
| 65340 | ERRWRAP2(retval = _self_->update(image, boundingBox)); |  | 65292 | ERRWRAP2(retval = _self_->update(image, boundingBox));
| 65341 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox)); |  | 65293 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox));
| 65342 | } |  | 65294 | }
| 65343 |  |  | 65295 |
| 65344 |  |  | 65296 |
| 65345 | pyPopulateArgumentConversionErrors(); |  | 65297 | pyPopulateArgumentConversionErrors();
| 65346 | } |  | 65298 | }
| 65347 |  |  | 65299 |
| 65348 |  |  | 65300 |
| 65349 | { |  | 65301 | {
| 65350 | PyObject* pyobj_image = NULL; |  | 65302 | PyObject* pyobj_image = NULL;
| 65351 | UMat image; |  | 65303 | UMat image;
| 65352 | vector_Rect2d boundingBox; |  | 65304 | vector_Rect2d boundingBox;
| 65353 | bool retval; |  | 65305 | bool retval;
| 65354 |  |  | 65306 |
| 65355 | const char* keywords[] = { "image", NULL }; |  | 65307 | const char* keywords[] = { "image", NULL };
| 65356 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_MultiTracker.update", (char**)keywords, &pyobj_image) && |  | 65308 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_MultiTracker.update", (char**)keywords, &pyobj_image) &&
| 65357 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 65309 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 65358 | { |  | 65310 | {
| 65359 | ERRWRAP2(retval = _self_->update(image, boundingBox)); |  | 65311 | ERRWRAP2(retval = _self_->update(image, boundingBox));
| 65360 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox)); |  | 65312 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox));
| 65361 | } |  | 65313 | }
| 65362 |  |  | 65314 |
| 65363 |  |  | 65315 |
| 65364 | pyPopulateArgumentConversionErrors(); |  | 65316 | pyPopulateArgumentConversionErrors();
| 65365 | } |  | 65317 | }
| 65366 | pyRaiseCVOverloadException("update"); |  | 65318 | pyRaiseCVOverloadException("update");
| 65367 |  |  | 65319 |
| 65368 | return NULL; |  | 65320 | return NULL;
| 65369 | } |  | 65321 | }
| 65370 |  |  | 65322 |
| 65371 |  |  | 65323 |
| 65372 |  |  | 65324 |
| 65373 | // Tables (legacy_MultiTracker) |  | 65325 | // Tables (legacy_MultiTracker)
| 65374 |  |  | 65326 |
| 65375 | static PyGetSetDef pyopencv_legacy_MultiTracker_getseters[] = |  | 65327 | static PyGetSetDef pyopencv_legacy_MultiTracker_getseters[] =
| 65376 | { |  | 65328 | {
| 65377 | {NULL} /* Sentinel */ |  | 65329 | {NULL} /* Sentinel */
| 65378 | }; |  | 65330 | };
| 65379 |  |  | 65331 |
| 65380 | static PyMethodDef pyopencv_legacy_MultiTracker_methods[] = |  | 65332 | static PyMethodDef pyopencv_legacy_MultiTracker_methods[] =
| 65381 | { |  | 65333 | {
| 65382 | {"add", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_add, 0), "add(newTracker, image, boundingBox) -> retval\n. * \\brief Add a new object to be tracked.\n. *\n. * @param newTracker tracking algorithm to be used\n. * @param image input image\n. * @param boundingBox a rectangle represents ROI of the tracked object"}, |  | 65334 | {"add", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_add, 0), "add(newTracker, image, boundingBox) -> retval\n. * \\brief Add a new object to be tracked.\n. *\n. * @param newTracker tracking algorithm to be used\n. * @param image input image\n. * @param boundingBox a rectangle represents ROI of the tracked object"},
| 65383 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_create_static, METH_STATIC), "create() -> retval\n. * \\brief Returns a pointer to a new instance of MultiTracker"}, |  | 65335 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_create_static, METH_STATIC), "create() -> retval\n. * \\brief Returns a pointer to a new instance of MultiTracker"},
| 65384 | {"getObjects", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_getObjects, 0), "getObjects() -> retval\n. * \\brief Returns a reference to a storage for the tracked objects, each object corresponds to one tracker algorithm"}, |  | 65336 | {"getObjects", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_getObjects, 0), "getObjects() -> retval\n. * \\brief Returns a reference to a storage for the tracked objects, each object corresponds to one tracker algorithm"},
| 65385 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_update, 0), "update(image) -> retval, boundingBox\n. * \\brief Update the current tracking status.\n. * @param image input image\n. * @param boundingBox the tracking result, represent a list of ROIs of the tracked objects."}, |  | 65337 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_MultiTracker_update, 0), "update(image) -> retval, boundingBox\n. * \\brief Update the current tracking status.\n. * @param image input image\n. * @param boundingBox the tracking result, represent a list of ROIs of the tracked objects."},
| 65386 |  |  | 65338 |
| 65387 | {NULL, NULL} |  | 65339 | {NULL, NULL}
| 65388 | }; |  | 65340 | };
| 65389 |  |  | 65341 |
| 65390 | // Converter (legacy_MultiTracker) |  | 65342 | // Converter (legacy_MultiTracker)
| 65391 |  |  | 65343 |
| 65392 | template<> |  | 65344 | template<>
| 65393 | struct PyOpenCV_Converter< Ptr<cv::legacy::MultiTracker> > |  | 65345 | struct PyOpenCV_Converter< Ptr<cv::legacy::MultiTracker> >
| 65394 | { |  | 65346 | {
| 65395 | static PyObject* from(const Ptr<cv::legacy::MultiTracker>& r) |  | 65347 | static PyObject* from(const Ptr<cv::legacy::MultiTracker>& r)
| 65396 | { |  | 65348 | {
| 65397 | return pyopencv_legacy_MultiTracker_Instance(r); |  | 65349 | return pyopencv_legacy_MultiTracker_Instance(r);
| 65398 | } |  | 65350 | }
| 65399 | static bool to(PyObject* src, Ptr<cv::legacy::MultiTracker>& dst, const ArgInfo& info) |  | 65351 | static bool to(PyObject* src, Ptr<cv::legacy::MultiTracker>& dst, const ArgInfo& info)
| 65400 | { |  | 65352 | {
| 65401 | if(!src || src == Py_None) |  | 65353 | if(!src || src == Py_None)
| 65402 | return true; |  | 65354 | return true;
| 65403 | Ptr<cv::legacy::MultiTracker> * dst_; |  | 65355 | Ptr<cv::legacy::MultiTracker> * dst_;
| 65404 | if (pyopencv_legacy_MultiTracker_getp(src, dst_)) |  | 65356 | if (pyopencv_legacy_MultiTracker_getp(src, dst_))
| 65405 | { |  | 65357 | {
| 65406 | dst = *dst_; |  | 65358 | dst = *dst_;
| 65407 | return true; |  | 65359 | return true;
| 65408 | } |  | 65360 | }
| 65409 |  |  | 65361 |
| 65410 | failmsg("Expected Ptr<cv::legacy::MultiTracker> for argument '%s'", info.name); |  | 65362 | failmsg("Expected Ptr<cv::legacy::MultiTracker> for argument '%s'", info.name);
| 65411 | return false; |  | 65363 | return false;
| 65412 | } |  | 65364 | }
| 65413 | }; |  | 65365 | };
| 65414 |  |  | 65366 |
| 65415 | //================================================================================ |  | 65367 | //================================================================================
| 65416 | // legacy_Tracker (Generic) |  | 65368 | // legacy_Tracker (Generic)
| 65417 | //================================================================================ |  | 65369 | //================================================================================
| 65418 |  |  | 65370 |
| 65419 | // GetSet (legacy_Tracker) |  | 65371 | // GetSet (legacy_Tracker)
| 65420 |  |  | 65372 |
| 65421 |  |  | 65373 |
| 65422 |  |  | 65374 |
| 65423 | // Methods (legacy_Tracker) |  | 65375 | // Methods (legacy_Tracker)
| 65424 |  |  | 65376 |
| 65425 | static PyObject* pyopencv_cv_legacy_legacy_Tracker_init(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65377 | static PyObject* pyopencv_cv_legacy_legacy_Tracker_init(PyObject* self, PyObject* py_args, PyObject* kw)
| 65426 | { |  | 65378 | {
| 65427 | using namespace cv::legacy; |  | 65379 | using namespace cv::legacy;
| 65428 |  |  | 65380 |
| 65429 |  |  | 65381 |
| 65430 | Ptr<cv::legacy::Tracker> * self1 = 0; |  | 65382 | Ptr<cv::legacy::Tracker> * self1 = 0;
| 65431 | if (!pyopencv_legacy_Tracker_getp(self, self1)) |  | 65383 | if (!pyopencv_legacy_Tracker_getp(self, self1))
| 65432 | return failmsgp("Incorrect type of self (must be 'legacy_Tracker' or its derivative)"); |  | 65384 | return failmsgp("Incorrect type of self (must be 'legacy_Tracker' or its derivative)");
| 65433 | Ptr<cv::legacy::Tracker> _self_ = *(self1); |  | 65385 | Ptr<cv::legacy::Tracker> _self_ = *(self1);
| 65434 | pyPrepareArgumentConversionErrorsStorage(2); |  | 65386 | pyPrepareArgumentConversionErrorsStorage(2);
| 65435 |  |  | 65387 |
| 65436 | { |  | 65388 | {
| 65437 | PyObject* pyobj_image = NULL; |  | 65389 | PyObject* pyobj_image = NULL;
| 65438 | Mat image; |  | 65390 | Mat image;
| 65439 | PyObject* pyobj_boundingBox = NULL; |  | 65391 | PyObject* pyobj_boundingBox = NULL;
| 65440 | Rect2d boundingBox; |  | 65392 | Rect2d boundingBox;
| 65441 | bool retval; |  | 65393 | bool retval;
| 65442 |  |  | 65394 |
| 65443 | const char* keywords[] = { "image", "boundingBox", NULL }; |  | 65395 | const char* keywords[] = { "image", "boundingBox", NULL };
| 65444 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:legacy_Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) && |  | 65396 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:legacy_Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) &&
| 65445 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 65397 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 65446 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) ) |  | 65398 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) )
| 65447 | { |  | 65399 | {
| 65448 | ERRWRAP2(retval = _self_->init(image, boundingBox)); |  | 65400 | ERRWRAP2(retval = _self_->init(image, boundingBox));
| 65449 | return pyopencv_from(retval); |  | 65401 | return pyopencv_from(retval);
| 65450 | } |  | 65402 | }
| 65451 |  |  | 65403 |
| 65452 |  |  | 65404 |
| 65453 | pyPopulateArgumentConversionErrors(); |  | 65405 | pyPopulateArgumentConversionErrors();
| 65454 | } |  | 65406 | }
| 65455 |  |  | 65407 |
| 65456 |  |  | 65408 |
| 65457 | { |  | 65409 | {
| 65458 | PyObject* pyobj_image = NULL; |  | 65410 | PyObject* pyobj_image = NULL;
| 65459 | UMat image; |  | 65411 | UMat image;
| 65460 | PyObject* pyobj_boundingBox = NULL; |  | 65412 | PyObject* pyobj_boundingBox = NULL;
| 65461 | Rect2d boundingBox; |  | 65413 | Rect2d boundingBox;
| 65462 | bool retval; |  | 65414 | bool retval;
| 65463 |  |  | 65415 |
| 65464 | const char* keywords[] = { "image", "boundingBox", NULL }; |  | 65416 | const char* keywords[] = { "image", "boundingBox", NULL };
| 65465 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:legacy_Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) && |  | 65417 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:legacy_Tracker.init", (char**)keywords, &pyobj_image, &pyobj_boundingBox) &&
| 65466 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 65418 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 65467 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) ) |  | 65419 | pyopencv_to_safe(pyobj_boundingBox, boundingBox, ArgInfo("boundingBox", 0)) )
| 65468 | { |  | 65420 | {
| 65469 | ERRWRAP2(retval = _self_->init(image, boundingBox)); |  | 65421 | ERRWRAP2(retval = _self_->init(image, boundingBox));
| 65470 | return pyopencv_from(retval); |  | 65422 | return pyopencv_from(retval);
| 65471 | } |  | 65423 | }
| 65472 |  |  | 65424 |
| 65473 |  |  | 65425 |
| 65474 | pyPopulateArgumentConversionErrors(); |  | 65426 | pyPopulateArgumentConversionErrors();
| 65475 | } |  | 65427 | }
| 65476 | pyRaiseCVOverloadException("init"); |  | 65428 | pyRaiseCVOverloadException("init");
| 65477 |  |  | 65429 |
| 65478 | return NULL; |  | 65430 | return NULL;
| 65479 | } |  | 65431 | }
| 65480 |  |  | 65432 |
| 65481 | static PyObject* pyopencv_cv_legacy_legacy_Tracker_update(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65433 | static PyObject* pyopencv_cv_legacy_legacy_Tracker_update(PyObject* self, PyObject* py_args, PyObject* kw)
| 65482 | { |  | 65434 | {
| 65483 | using namespace cv::legacy; |  | 65435 | using namespace cv::legacy;
| 65484 |  |  | 65436 |
| 65485 |  |  | 65437 |
| 65486 | Ptr<cv::legacy::Tracker> * self1 = 0; |  | 65438 | Ptr<cv::legacy::Tracker> * self1 = 0;
| 65487 | if (!pyopencv_legacy_Tracker_getp(self, self1)) |  | 65439 | if (!pyopencv_legacy_Tracker_getp(self, self1))
| 65488 | return failmsgp("Incorrect type of self (must be 'legacy_Tracker' or its derivative)"); |  | 65440 | return failmsgp("Incorrect type of self (must be 'legacy_Tracker' or its derivative)");
| 65489 | Ptr<cv::legacy::Tracker> _self_ = *(self1); |  | 65441 | Ptr<cv::legacy::Tracker> _self_ = *(self1);
| 65490 | pyPrepareArgumentConversionErrorsStorage(2); |  | 65442 | pyPrepareArgumentConversionErrorsStorage(2);
| 65491 |  |  | 65443 |
| 65492 | { |  | 65444 | {
| 65493 | PyObject* pyobj_image = NULL; |  | 65445 | PyObject* pyobj_image = NULL;
| 65494 | Mat image; |  | 65446 | Mat image;
| 65495 | Rect2d boundingBox; |  | 65447 | Rect2d boundingBox;
| 65496 | bool retval; |  | 65448 | bool retval;
| 65497 |  |  | 65449 |
| 65498 | const char* keywords[] = { "image", NULL }; |  | 65450 | const char* keywords[] = { "image", NULL };
| 65499 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_Tracker.update", (char**)keywords, &pyobj_image) && |  | 65451 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_Tracker.update", (char**)keywords, &pyobj_image) &&
| 65500 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 65452 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 65501 | { |  | 65453 | {
| 65502 | ERRWRAP2(retval = _self_->update(image, boundingBox)); |  | 65454 | ERRWRAP2(retval = _self_->update(image, boundingBox));
| 65503 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox)); |  | 65455 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox));
| 65504 | } |  | 65456 | }
| 65505 |  |  | 65457 |
| 65506 |  |  | 65458 |
| 65507 | pyPopulateArgumentConversionErrors(); |  | 65459 | pyPopulateArgumentConversionErrors();
| 65508 | } |  | 65460 | }
| 65509 |  |  | 65461 |
| 65510 |  |  | 65462 |
| 65511 | { |  | 65463 | {
| 65512 | PyObject* pyobj_image = NULL; |  | 65464 | PyObject* pyobj_image = NULL;
| 65513 | UMat image; |  | 65465 | UMat image;
| 65514 | Rect2d boundingBox; |  | 65466 | Rect2d boundingBox;
| 65515 | bool retval; |  | 65467 | bool retval;
| 65516 |  |  | 65468 |
| 65517 | const char* keywords[] = { "image", NULL }; |  | 65469 | const char* keywords[] = { "image", NULL };
| 65518 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_Tracker.update", (char**)keywords, &pyobj_image) && |  | 65470 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_Tracker.update", (char**)keywords, &pyobj_image) &&
| 65519 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 65471 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 65520 | { |  | 65472 | {
| 65521 | ERRWRAP2(retval = _self_->update(image, boundingBox)); |  | 65473 | ERRWRAP2(retval = _self_->update(image, boundingBox));
| 65522 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox)); |  | 65474 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(boundingBox));
| 65523 | } |  | 65475 | }
| 65524 |  |  | 65476 |
| 65525 |  |  | 65477 |
| 65526 | pyPopulateArgumentConversionErrors(); |  | 65478 | pyPopulateArgumentConversionErrors();
| 65527 | } |  | 65479 | }
| 65528 | pyRaiseCVOverloadException("update"); |  | 65480 | pyRaiseCVOverloadException("update");
| 65529 |  |  | 65481 |
| 65530 | return NULL; |  | 65482 | return NULL;
| 65531 | } |  | 65483 | }
| 65532 |  |  | 65484 |
| 65533 |  |  | 65485 |
| 65534 |  |  | 65486 |
| 65535 | // Tables (legacy_Tracker) |  | 65487 | // Tables (legacy_Tracker)
| 65536 |  |  | 65488 |
| 65537 | static PyGetSetDef pyopencv_legacy_Tracker_getseters[] = |  | 65489 | static PyGetSetDef pyopencv_legacy_Tracker_getseters[] =
| 65538 | { |  | 65490 | {
| 65539 | {NULL} /* Sentinel */ |  | 65491 | {NULL} /* Sentinel */
| 65540 | }; |  | 65492 | };
| 65541 |  |  | 65493 |
| 65542 | static PyMethodDef pyopencv_legacy_Tracker_methods[] = |  | 65494 | static PyMethodDef pyopencv_legacy_Tracker_methods[] =
| 65543 | { |  | 65495 | {
| 65544 | {"init", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_Tracker_init, 0), "init(image, boundingBox) -> retval\n. @brief Initialize the tracker with a known bounding box that surrounded the target\n. @param image The initial frame\n. @param boundingBox The initial bounding box\n. \n. @return True if initialization went succesfully, false otherwise"}, |  | 65496 | {"init", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_Tracker_init, 0), "init(image, boundingBox) -> retval\n. @brief Initialize the tracker with a known bounding box that surrounded the target\n. @param image The initial frame\n. @param boundingBox The initial bounding box\n. \n. @return True if initialization went succesfully, false otherwise"},
| 65545 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_Tracker_update, 0), "update(image) -> retval, boundingBox\n. @brief Update the tracker, find the new most likely bounding box for the target\n. @param image The current frame\n. @param boundingBox The bounding box that represent the new target location, if true was returned, not\n. modified otherwise\n. \n. @return True means that target was located and false means that tracker cannot locate target in\n. current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed\n. missing from the frame (say, out of sight)"}, |  | 65497 | {"update", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_Tracker_update, 0), "update(image) -> retval, boundingBox\n. @brief Update the tracker, find the new most likely bounding box for the target\n. @param image The current frame\n. @param boundingBox The bounding box that represent the new target location, if true was returned, not\n. modified otherwise\n. \n. @return True means that target was located and false means that tracker cannot locate target in\n. current frame. Note, that latter *does not* imply that tracker has failed, maybe target is indeed\n. missing from the frame (say, out of sight)"},
| 65546 |  |  | 65498 |
| 65547 | {NULL, NULL} |  | 65499 | {NULL, NULL}
| 65548 | }; |  | 65500 | };
| 65549 |  |  | 65501 |
| 65550 | // Converter (legacy_Tracker) |  | 65502 | // Converter (legacy_Tracker)
| 65551 |  |  | 65503 |
| 65552 | template<> |  | 65504 | template<>
| 65553 | struct PyOpenCV_Converter< Ptr<cv::legacy::Tracker> > |  | 65505 | struct PyOpenCV_Converter< Ptr<cv::legacy::Tracker> >
| 65554 | { |  | 65506 | {
| 65555 | static PyObject* from(const Ptr<cv::legacy::Tracker>& r) |  | 65507 | static PyObject* from(const Ptr<cv::legacy::Tracker>& r)
| 65556 | { |  | 65508 | {
| 65557 | return pyopencv_legacy_Tracker_Instance(r); |  | 65509 | return pyopencv_legacy_Tracker_Instance(r);
| 65558 | } |  | 65510 | }
| 65559 | static bool to(PyObject* src, Ptr<cv::legacy::Tracker>& dst, const ArgInfo& info) |  | 65511 | static bool to(PyObject* src, Ptr<cv::legacy::Tracker>& dst, const ArgInfo& info)
| 65560 | { |  | 65512 | {
| 65561 | if(!src || src == Py_None) |  | 65513 | if(!src || src == Py_None)
| 65562 | return true; |  | 65514 | return true;
| 65563 | Ptr<cv::legacy::Tracker> * dst_; |  | 65515 | Ptr<cv::legacy::Tracker> * dst_;
| 65564 | if (pyopencv_legacy_Tracker_getp(src, dst_)) |  | 65516 | if (pyopencv_legacy_Tracker_getp(src, dst_))
| 65565 | { |  | 65517 | {
| 65566 | dst = *dst_; |  | 65518 | dst = *dst_;
| 65567 | return true; |  | 65519 | return true;
| 65568 | } |  | 65520 | }
| 65569 |  |  | 65521 |
| 65570 | failmsg("Expected Ptr<cv::legacy::Tracker> for argument '%s'", info.name); |  | 65522 | failmsg("Expected Ptr<cv::legacy::Tracker> for argument '%s'", info.name);
| 65571 | return false; |  | 65523 | return false;
| 65572 | } |  | 65524 | }
| 65573 | }; |  | 65525 | };
| 65574 |  |  | 65526 |
| 65575 | //================================================================================ |  | 65527 | //================================================================================
| 65576 | // legacy_TrackerBoosting (Generic) |  | 65528 | // legacy_TrackerBoosting (Generic)
| 65577 | //================================================================================ |  | 65529 | //================================================================================
| 65578 |  |  | 65530 |
| 65579 | // GetSet (legacy_TrackerBoosting) |  | 65531 | // GetSet (legacy_TrackerBoosting)
| 65580 |  |  | 65532 |
| 65581 |  |  | 65533 |
| 65582 |  |  | 65534 |
| 65583 | // Methods (legacy_TrackerBoosting) |  | 65535 | // Methods (legacy_TrackerBoosting)
| 65584 |  |  | 65536 |
| 65585 | static PyObject* pyopencv_cv_legacy_legacy_TrackerBoosting_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65537 | static PyObject* pyopencv_cv_legacy_legacy_TrackerBoosting_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65586 | { |  | 65538 | {
| 65587 | using namespace cv::legacy; |  | 65539 | using namespace cv::legacy;
| 65588 |  |  | 65540 |
| 65589 | Ptr<legacy::TrackerBoosting> retval; |  | 65541 | Ptr<legacy::TrackerBoosting> retval;
| 65590 |  |  | 65542 |
| 65591 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65543 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65592 | { |  | 65544 | {
| 65593 | ERRWRAP2(retval = cv::legacy::TrackerBoosting::create()); |  | 65545 | ERRWRAP2(retval = cv::legacy::TrackerBoosting::create());
| 65594 | return pyopencv_from(retval); |  | 65546 | return pyopencv_from(retval);
| 65595 | } |  | 65547 | }
| 65596 |  |  | 65548 |
| 65597 | return NULL; |  | 65549 | return NULL;
| 65598 | } |  | 65550 | }
| 65599 |  |  | 65551 |
| 65600 |  |  | 65552 |
| 65601 |  |  | 65553 |
| 65602 | // Tables (legacy_TrackerBoosting) |  | 65554 | // Tables (legacy_TrackerBoosting)
| 65603 |  |  | 65555 |
| 65604 | static PyGetSetDef pyopencv_legacy_TrackerBoosting_getseters[] = |  | 65556 | static PyGetSetDef pyopencv_legacy_TrackerBoosting_getseters[] =
| 65605 | { |  | 65557 | {
| 65606 | {NULL} /* Sentinel */ |  | 65558 | {NULL} /* Sentinel */
| 65607 | }; |  | 65559 | };
| 65608 |  |  | 65560 |
| 65609 | static PyMethodDef pyopencv_legacy_TrackerBoosting_methods[] = |  | 65561 | static PyMethodDef pyopencv_legacy_TrackerBoosting_methods[] =
| 65610 | { |  | 65562 | {
| 65611 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerBoosting_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters BOOSTING parameters TrackerBoosting::Params"}, |  | 65563 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerBoosting_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters BOOSTING parameters TrackerBoosting::Params"},
| 65612 |  |  | 65564 |
| 65613 | {NULL, NULL} |  | 65565 | {NULL, NULL}
| 65614 | }; |  | 65566 | };
| 65615 |  |  | 65567 |
| 65616 | // Converter (legacy_TrackerBoosting) |  | 65568 | // Converter (legacy_TrackerBoosting)
| 65617 |  |  | 65569 |
| 65618 | template<> |  | 65570 | template<>
| 65619 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerBoosting> > |  | 65571 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerBoosting> >
| 65620 | { |  | 65572 | {
| 65621 | static PyObject* from(const Ptr<cv::legacy::TrackerBoosting>& r) |  | 65573 | static PyObject* from(const Ptr<cv::legacy::TrackerBoosting>& r)
| 65622 | { |  | 65574 | {
| 65623 | return pyopencv_legacy_TrackerBoosting_Instance(r); |  | 65575 | return pyopencv_legacy_TrackerBoosting_Instance(r);
| 65624 | } |  | 65576 | }
| 65625 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerBoosting>& dst, const ArgInfo& info) |  | 65577 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerBoosting>& dst, const ArgInfo& info)
| 65626 | { |  | 65578 | {
| 65627 | if(!src || src == Py_None) |  | 65579 | if(!src || src == Py_None)
| 65628 | return true; |  | 65580 | return true;
| 65629 | Ptr<cv::legacy::TrackerBoosting> * dst_; |  | 65581 | Ptr<cv::legacy::TrackerBoosting> * dst_;
| 65630 | if (pyopencv_legacy_TrackerBoosting_getp(src, dst_)) |  | 65582 | if (pyopencv_legacy_TrackerBoosting_getp(src, dst_))
| 65631 | { |  | 65583 | {
| 65632 | dst = *dst_; |  | 65584 | dst = *dst_;
| 65633 | return true; |  | 65585 | return true;
| 65634 | } |  | 65586 | }
| 65635 |  |  | 65587 |
| 65636 | failmsg("Expected Ptr<cv::legacy::TrackerBoosting> for argument '%s'", info.name); |  | 65588 | failmsg("Expected Ptr<cv::legacy::TrackerBoosting> for argument '%s'", info.name);
| 65637 | return false; |  | 65589 | return false;
| 65638 | } |  | 65590 | }
| 65639 | }; |  | 65591 | };
| 65640 |  |  | 65592 |
| 65641 | //================================================================================ |  | 65593 | //================================================================================
| 65642 | // legacy_TrackerCSRT (Generic) |  | 65594 | // legacy_TrackerCSRT (Generic)
| 65643 | //================================================================================ |  | 65595 | //================================================================================
| 65644 |  |  | 65596 |
| 65645 | // GetSet (legacy_TrackerCSRT) |  | 65597 | // GetSet (legacy_TrackerCSRT)
| 65646 |  |  | 65598 |
| 65647 |  |  | 65599 |
| 65648 |  |  | 65600 |
| 65649 | // Methods (legacy_TrackerCSRT) |  | 65601 | // Methods (legacy_TrackerCSRT)
| 65650 |  |  | 65602 |
| 65651 | static PyObject* pyopencv_cv_legacy_legacy_TrackerCSRT_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65603 | static PyObject* pyopencv_cv_legacy_legacy_TrackerCSRT_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65652 | { |  | 65604 | {
| 65653 | using namespace cv::legacy; |  | 65605 | using namespace cv::legacy;
| 65654 |  |  | 65606 |
| 65655 | Ptr<legacy::TrackerCSRT> retval; |  | 65607 | Ptr<legacy::TrackerCSRT> retval;
| 65656 |  |  | 65608 |
| 65657 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65609 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65658 | { |  | 65610 | {
| 65659 | ERRWRAP2(retval = cv::legacy::TrackerCSRT::create()); |  | 65611 | ERRWRAP2(retval = cv::legacy::TrackerCSRT::create());
| 65660 | return pyopencv_from(retval); |  | 65612 | return pyopencv_from(retval);
| 65661 | } |  | 65613 | }
| 65662 |  |  | 65614 |
| 65663 | return NULL; |  | 65615 | return NULL;
| 65664 | } |  | 65616 | }
| 65665 |  |  | 65617 |
| 65666 | static PyObject* pyopencv_cv_legacy_legacy_TrackerCSRT_setInitialMask(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65618 | static PyObject* pyopencv_cv_legacy_legacy_TrackerCSRT_setInitialMask(PyObject* self, PyObject* py_args, PyObject* kw)
| 65667 | { |  | 65619 | {
| 65668 | using namespace cv::legacy; |  | 65620 | using namespace cv::legacy;
| 65669 |  |  | 65621 |
| 65670 |  |  | 65622 |
| 65671 | Ptr<cv::legacy::TrackerCSRT> * self1 = 0; |  | 65623 | Ptr<cv::legacy::TrackerCSRT> * self1 = 0;
| 65672 | if (!pyopencv_legacy_TrackerCSRT_getp(self, self1)) |  | 65624 | if (!pyopencv_legacy_TrackerCSRT_getp(self, self1))
| 65673 | return failmsgp("Incorrect type of self (must be 'legacy_TrackerCSRT' or its derivative)"); |  | 65625 | return failmsgp("Incorrect type of self (must be 'legacy_TrackerCSRT' or its derivative)");
| 65674 | Ptr<cv::legacy::TrackerCSRT> _self_ = *(self1); |  | 65626 | Ptr<cv::legacy::TrackerCSRT> _self_ = *(self1);
| 65675 | pyPrepareArgumentConversionErrorsStorage(2); |  | 65627 | pyPrepareArgumentConversionErrorsStorage(2);
| 65676 |  |  | 65628 |
| 65677 | { |  | 65629 | {
| 65678 | PyObject* pyobj_mask = NULL; |  | 65630 | PyObject* pyobj_mask = NULL;
| 65679 | Mat mask; |  | 65631 | Mat mask;
| 65680 |  |  | 65632 |
| 65681 | const char* keywords[] = { "mask", NULL }; |  | 65633 | const char* keywords[] = { "mask", NULL };
| 65682 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) && |  | 65634 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) &&
| 65683 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 65635 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 65684 | { |  | 65636 | {
| 65685 | ERRWRAP2(_self_->setInitialMask(mask)); |  | 65637 | ERRWRAP2(_self_->setInitialMask(mask));
| 65686 | Py_RETURN_NONE; |  | 65638 | Py_RETURN_NONE;
| 65687 | } |  | 65639 | }
| 65688 |  |  | 65640 |
| 65689 |  |  | 65641 |
| 65690 | pyPopulateArgumentConversionErrors(); |  | 65642 | pyPopulateArgumentConversionErrors();
| 65691 | } |  | 65643 | }
| 65692 |  |  | 65644 |
| 65693 |  |  | 65645 |
| 65694 | { |  | 65646 | {
| 65695 | PyObject* pyobj_mask = NULL; |  | 65647 | PyObject* pyobj_mask = NULL;
| 65696 | UMat mask; |  | 65648 | UMat mask;
| 65697 |  |  | 65649 |
| 65698 | const char* keywords[] = { "mask", NULL }; |  | 65650 | const char* keywords[] = { "mask", NULL };
| 65699 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) && |  | 65651 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:legacy_TrackerCSRT.setInitialMask", (char**)keywords, &pyobj_mask) &&
| 65700 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 65652 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 65701 | { |  | 65653 | {
| 65702 | ERRWRAP2(_self_->setInitialMask(mask)); |  | 65654 | ERRWRAP2(_self_->setInitialMask(mask));
| 65703 | Py_RETURN_NONE; |  | 65655 | Py_RETURN_NONE;
| 65704 | } |  | 65656 | }
| 65705 |  |  | 65657 |
| 65706 |  |  | 65658 |
| 65707 | pyPopulateArgumentConversionErrors(); |  | 65659 | pyPopulateArgumentConversionErrors();
| 65708 | } |  | 65660 | }
| 65709 | pyRaiseCVOverloadException("setInitialMask"); |  | 65661 | pyRaiseCVOverloadException("setInitialMask");
| 65710 |  |  | 65662 |
| 65711 | return NULL; |  | 65663 | return NULL;
| 65712 | } |  | 65664 | }
| 65713 |  |  | 65665 |
| 65714 |  |  | 65666 |
| 65715 |  |  | 65667 |
| 65716 | // Tables (legacy_TrackerCSRT) |  | 65668 | // Tables (legacy_TrackerCSRT)
| 65717 |  |  | 65669 |
| 65718 | static PyGetSetDef pyopencv_legacy_TrackerCSRT_getseters[] = |  | 65670 | static PyGetSetDef pyopencv_legacy_TrackerCSRT_getseters[] =
| 65719 | { |  | 65671 | {
| 65720 | {NULL} /* Sentinel */ |  | 65672 | {NULL} /* Sentinel */
| 65721 | }; |  | 65673 | };
| 65722 |  |  | 65674 |
| 65723 | static PyMethodDef pyopencv_legacy_TrackerCSRT_methods[] = |  | 65675 | static PyMethodDef pyopencv_legacy_TrackerCSRT_methods[] =
| 65724 | { |  | 65676 | {
| 65725 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerCSRT_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters CSRT parameters TrackerCSRT::Params"}, |  | 65677 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerCSRT_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters CSRT parameters TrackerCSRT::Params"},
| 65726 | {"setInitialMask", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerCSRT_setInitialMask, 0), "setInitialMask(mask) -> None\n."}, |  | 65678 | {"setInitialMask", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerCSRT_setInitialMask, 0), "setInitialMask(mask) -> None\n."},
| 65727 |  |  | 65679 |
| 65728 | {NULL, NULL} |  | 65680 | {NULL, NULL}
| 65729 | }; |  | 65681 | };
| 65730 |  |  | 65682 |
| 65731 | // Converter (legacy_TrackerCSRT) |  | 65683 | // Converter (legacy_TrackerCSRT)
| 65732 |  |  | 65684 |
| 65733 | template<> |  | 65685 | template<>
| 65734 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerCSRT> > |  | 65686 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerCSRT> >
| 65735 | { |  | 65687 | {
| 65736 | static PyObject* from(const Ptr<cv::legacy::TrackerCSRT>& r) |  | 65688 | static PyObject* from(const Ptr<cv::legacy::TrackerCSRT>& r)
| 65737 | { |  | 65689 | {
| 65738 | return pyopencv_legacy_TrackerCSRT_Instance(r); |  | 65690 | return pyopencv_legacy_TrackerCSRT_Instance(r);
| 65739 | } |  | 65691 | }
| 65740 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerCSRT>& dst, const ArgInfo& info) |  | 65692 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerCSRT>& dst, const ArgInfo& info)
| 65741 | { |  | 65693 | {
| 65742 | if(!src || src == Py_None) |  | 65694 | if(!src || src == Py_None)
| 65743 | return true; |  | 65695 | return true;
| 65744 | Ptr<cv::legacy::TrackerCSRT> * dst_; |  | 65696 | Ptr<cv::legacy::TrackerCSRT> * dst_;
| 65745 | if (pyopencv_legacy_TrackerCSRT_getp(src, dst_)) |  | 65697 | if (pyopencv_legacy_TrackerCSRT_getp(src, dst_))
| 65746 | { |  | 65698 | {
| 65747 | dst = *dst_; |  | 65699 | dst = *dst_;
| 65748 | return true; |  | 65700 | return true;
| 65749 | } |  | 65701 | }
| 65750 |  |  | 65702 |
| 65751 | failmsg("Expected Ptr<cv::legacy::TrackerCSRT> for argument '%s'", info.name); |  | 65703 | failmsg("Expected Ptr<cv::legacy::TrackerCSRT> for argument '%s'", info.name);
| 65752 | return false; |  | 65704 | return false;
| 65753 | } |  | 65705 | }
| 65754 | }; |  | 65706 | };
| 65755 |  |  | 65707 |
| 65756 | //================================================================================ |  | 65708 | //================================================================================
| 65757 | // legacy_TrackerKCF (Generic) |  | 65709 | // legacy_TrackerKCF (Generic)
| 65758 | //================================================================================ |  | 65710 | //================================================================================
| 65759 |  |  | 65711 |
| 65760 | // GetSet (legacy_TrackerKCF) |  | 65712 | // GetSet (legacy_TrackerKCF)
| 65761 |  |  | 65713 |
| 65762 |  |  | 65714 |
| 65763 |  |  | 65715 |
| 65764 | // Methods (legacy_TrackerKCF) |  | 65716 | // Methods (legacy_TrackerKCF)
| 65765 |  |  | 65717 |
| 65766 | static PyObject* pyopencv_cv_legacy_legacy_TrackerKCF_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65718 | static PyObject* pyopencv_cv_legacy_legacy_TrackerKCF_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65767 | { |  | 65719 | {
| 65768 | using namespace cv::legacy; |  | 65720 | using namespace cv::legacy;
| 65769 |  |  | 65721 |
| 65770 | Ptr<legacy::TrackerKCF> retval; |  | 65722 | Ptr<legacy::TrackerKCF> retval;
| 65771 |  |  | 65723 |
| 65772 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65724 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65773 | { |  | 65725 | {
| 65774 | ERRWRAP2(retval = cv::legacy::TrackerKCF::create()); |  | 65726 | ERRWRAP2(retval = cv::legacy::TrackerKCF::create());
| 65775 | return pyopencv_from(retval); |  | 65727 | return pyopencv_from(retval);
| 65776 | } |  | 65728 | }
| 65777 |  |  | 65729 |
| 65778 | return NULL; |  | 65730 | return NULL;
| 65779 | } |  | 65731 | }
| 65780 |  |  | 65732 |
| 65781 |  |  | 65733 |
| 65782 |  |  | 65734 |
| 65783 | // Tables (legacy_TrackerKCF) |  | 65735 | // Tables (legacy_TrackerKCF)
| 65784 |  |  | 65736 |
| 65785 | static PyGetSetDef pyopencv_legacy_TrackerKCF_getseters[] = |  | 65737 | static PyGetSetDef pyopencv_legacy_TrackerKCF_getseters[] =
| 65786 | { |  | 65738 | {
| 65787 | {NULL} /* Sentinel */ |  | 65739 | {NULL} /* Sentinel */
| 65788 | }; |  | 65740 | };
| 65789 |  |  | 65741 |
| 65790 | static PyMethodDef pyopencv_legacy_TrackerKCF_methods[] = |  | 65742 | static PyMethodDef pyopencv_legacy_TrackerKCF_methods[] =
| 65791 | { |  | 65743 | {
| 65792 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerKCF_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters KCF parameters TrackerKCF::Params"}, |  | 65744 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerKCF_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters KCF parameters TrackerKCF::Params"},
| 65793 |  |  | 65745 |
| 65794 | {NULL, NULL} |  | 65746 | {NULL, NULL}
| 65795 | }; |  | 65747 | };
| 65796 |  |  | 65748 |
| 65797 | // Converter (legacy_TrackerKCF) |  | 65749 | // Converter (legacy_TrackerKCF)
| 65798 |  |  | 65750 |
| 65799 | template<> |  | 65751 | template<>
| 65800 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerKCF> > |  | 65752 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerKCF> >
| 65801 | { |  | 65753 | {
| 65802 | static PyObject* from(const Ptr<cv::legacy::TrackerKCF>& r) |  | 65754 | static PyObject* from(const Ptr<cv::legacy::TrackerKCF>& r)
| 65803 | { |  | 65755 | {
| 65804 | return pyopencv_legacy_TrackerKCF_Instance(r); |  | 65756 | return pyopencv_legacy_TrackerKCF_Instance(r);
| 65805 | } |  | 65757 | }
| 65806 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerKCF>& dst, const ArgInfo& info) |  | 65758 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerKCF>& dst, const ArgInfo& info)
| 65807 | { |  | 65759 | {
| 65808 | if(!src || src == Py_None) |  | 65760 | if(!src || src == Py_None)
| 65809 | return true; |  | 65761 | return true;
| 65810 | Ptr<cv::legacy::TrackerKCF> * dst_; |  | 65762 | Ptr<cv::legacy::TrackerKCF> * dst_;
| 65811 | if (pyopencv_legacy_TrackerKCF_getp(src, dst_)) |  | 65763 | if (pyopencv_legacy_TrackerKCF_getp(src, dst_))
| 65812 | { |  | 65764 | {
| 65813 | dst = *dst_; |  | 65765 | dst = *dst_;
| 65814 | return true; |  | 65766 | return true;
| 65815 | } |  | 65767 | }
| 65816 |  |  | 65768 |
| 65817 | failmsg("Expected Ptr<cv::legacy::TrackerKCF> for argument '%s'", info.name); |  | 65769 | failmsg("Expected Ptr<cv::legacy::TrackerKCF> for argument '%s'", info.name);
| 65818 | return false; |  | 65770 | return false;
| 65819 | } |  | 65771 | }
| 65820 | }; |  | 65772 | };
| 65821 |  |  | 65773 |
| 65822 | //================================================================================ |  | 65774 | //================================================================================
| 65823 | // legacy_TrackerMIL (Generic) |  | 65775 | // legacy_TrackerMIL (Generic)
| 65824 | //================================================================================ |  | 65776 | //================================================================================
| 65825 |  |  | 65777 |
| 65826 | // GetSet (legacy_TrackerMIL) |  | 65778 | // GetSet (legacy_TrackerMIL)
| 65827 |  |  | 65779 |
| 65828 |  |  | 65780 |
| 65829 |  |  | 65781 |
| 65830 | // Methods (legacy_TrackerMIL) |  | 65782 | // Methods (legacy_TrackerMIL)
| 65831 |  |  | 65783 |
| 65832 | static PyObject* pyopencv_cv_legacy_legacy_TrackerMIL_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65784 | static PyObject* pyopencv_cv_legacy_legacy_TrackerMIL_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65833 | { |  | 65785 | {
| 65834 | using namespace cv::legacy; |  | 65786 | using namespace cv::legacy;
| 65835 |  |  | 65787 |
| 65836 | Ptr<legacy::TrackerMIL> retval; |  | 65788 | Ptr<legacy::TrackerMIL> retval;
| 65837 |  |  | 65789 |
| 65838 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65790 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65839 | { |  | 65791 | {
| 65840 | ERRWRAP2(retval = cv::legacy::TrackerMIL::create()); |  | 65792 | ERRWRAP2(retval = cv::legacy::TrackerMIL::create());
| 65841 | return pyopencv_from(retval); |  | 65793 | return pyopencv_from(retval);
| 65842 | } |  | 65794 | }
| 65843 |  |  | 65795 |
| 65844 | return NULL; |  | 65796 | return NULL;
| 65845 | } |  | 65797 | }
| 65846 |  |  | 65798 |
| 65847 |  |  | 65799 |
| 65848 |  |  | 65800 |
| 65849 | // Tables (legacy_TrackerMIL) |  | 65801 | // Tables (legacy_TrackerMIL)
| 65850 |  |  | 65802 |
| 65851 | static PyGetSetDef pyopencv_legacy_TrackerMIL_getseters[] = |  | 65803 | static PyGetSetDef pyopencv_legacy_TrackerMIL_getseters[] =
| 65852 | { |  | 65804 | {
| 65853 | {NULL} /* Sentinel */ |  | 65805 | {NULL} /* Sentinel */
| 65854 | }; |  | 65806 | };
| 65855 |  |  | 65807 |
| 65856 | static PyMethodDef pyopencv_legacy_TrackerMIL_methods[] = |  | 65808 | static PyMethodDef pyopencv_legacy_TrackerMIL_methods[] =
| 65857 | { |  | 65809 | {
| 65858 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerMIL_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters MIL parameters TrackerMIL::Params"}, |  | 65810 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerMIL_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters MIL parameters TrackerMIL::Params"},
| 65859 |  |  | 65811 |
| 65860 | {NULL, NULL} |  | 65812 | {NULL, NULL}
| 65861 | }; |  | 65813 | };
| 65862 |  |  | 65814 |
| 65863 | // Converter (legacy_TrackerMIL) |  | 65815 | // Converter (legacy_TrackerMIL)
| 65864 |  |  | 65816 |
| 65865 | template<> |  | 65817 | template<>
| 65866 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerMIL> > |  | 65818 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerMIL> >
| 65867 | { |  | 65819 | {
| 65868 | static PyObject* from(const Ptr<cv::legacy::TrackerMIL>& r) |  | 65820 | static PyObject* from(const Ptr<cv::legacy::TrackerMIL>& r)
| 65869 | { |  | 65821 | {
| 65870 | return pyopencv_legacy_TrackerMIL_Instance(r); |  | 65822 | return pyopencv_legacy_TrackerMIL_Instance(r);
| 65871 | } |  | 65823 | }
| 65872 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerMIL>& dst, const ArgInfo& info) |  | 65824 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerMIL>& dst, const ArgInfo& info)
| 65873 | { |  | 65825 | {
| 65874 | if(!src || src == Py_None) |  | 65826 | if(!src || src == Py_None)
| 65875 | return true; |  | 65827 | return true;
| 65876 | Ptr<cv::legacy::TrackerMIL> * dst_; |  | 65828 | Ptr<cv::legacy::TrackerMIL> * dst_;
| 65877 | if (pyopencv_legacy_TrackerMIL_getp(src, dst_)) |  | 65829 | if (pyopencv_legacy_TrackerMIL_getp(src, dst_))
| 65878 | { |  | 65830 | {
| 65879 | dst = *dst_; |  | 65831 | dst = *dst_;
| 65880 | return true; |  | 65832 | return true;
| 65881 | } |  | 65833 | }
| 65882 |  |  | 65834 |
| 65883 | failmsg("Expected Ptr<cv::legacy::TrackerMIL> for argument '%s'", info.name); |  | 65835 | failmsg("Expected Ptr<cv::legacy::TrackerMIL> for argument '%s'", info.name);
| 65884 | return false; |  | 65836 | return false;
| 65885 | } |  | 65837 | }
| 65886 | }; |  | 65838 | };
| 65887 |  |  | 65839 |
| 65888 | //================================================================================ |  | 65840 | //================================================================================
| 65889 | // legacy_TrackerMOSSE (Generic) |  | 65841 | // legacy_TrackerMOSSE (Generic)
| 65890 | //================================================================================ |  | 65842 | //================================================================================
| 65891 |  |  | 65843 |
| 65892 | // GetSet (legacy_TrackerMOSSE) |  | 65844 | // GetSet (legacy_TrackerMOSSE)
| 65893 |  |  | 65845 |
| 65894 |  |  | 65846 |
| 65895 |  |  | 65847 |
| 65896 | // Methods (legacy_TrackerMOSSE) |  | 65848 | // Methods (legacy_TrackerMOSSE)
| 65897 |  |  | 65849 |
| 65898 | static PyObject* pyopencv_cv_legacy_legacy_TrackerMOSSE_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65850 | static PyObject* pyopencv_cv_legacy_legacy_TrackerMOSSE_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65899 | { |  | 65851 | {
| 65900 | using namespace cv::legacy; |  | 65852 | using namespace cv::legacy;
| 65901 |  |  | 65853 |
| 65902 | Ptr<legacy::TrackerMOSSE> retval; |  | 65854 | Ptr<legacy::TrackerMOSSE> retval;
| 65903 |  |  | 65855 |
| 65904 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65856 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65905 | { |  | 65857 | {
| 65906 | ERRWRAP2(retval = cv::legacy::TrackerMOSSE::create()); |  | 65858 | ERRWRAP2(retval = cv::legacy::TrackerMOSSE::create());
| 65907 | return pyopencv_from(retval); |  | 65859 | return pyopencv_from(retval);
| 65908 | } |  | 65860 | }
| 65909 |  |  | 65861 |
| 65910 | return NULL; |  | 65862 | return NULL;
| 65911 | } |  | 65863 | }
| 65912 |  |  | 65864 |
| 65913 |  |  | 65865 |
| 65914 |  |  | 65866 |
| 65915 | // Tables (legacy_TrackerMOSSE) |  | 65867 | // Tables (legacy_TrackerMOSSE)
| 65916 |  |  | 65868 |
| 65917 | static PyGetSetDef pyopencv_legacy_TrackerMOSSE_getseters[] = |  | 65869 | static PyGetSetDef pyopencv_legacy_TrackerMOSSE_getseters[] =
| 65918 | { |  | 65870 | {
| 65919 | {NULL} /* Sentinel */ |  | 65871 | {NULL} /* Sentinel */
| 65920 | }; |  | 65872 | };
| 65921 |  |  | 65873 |
| 65922 | static PyMethodDef pyopencv_legacy_TrackerMOSSE_methods[] = |  | 65874 | static PyMethodDef pyopencv_legacy_TrackerMOSSE_methods[] =
| 65923 | { |  | 65875 | {
| 65924 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerMOSSE_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor"}, |  | 65876 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerMOSSE_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor"},
| 65925 |  |  | 65877 |
| 65926 | {NULL, NULL} |  | 65878 | {NULL, NULL}
| 65927 | }; |  | 65879 | };
| 65928 |  |  | 65880 |
| 65929 | // Converter (legacy_TrackerMOSSE) |  | 65881 | // Converter (legacy_TrackerMOSSE)
| 65930 |  |  | 65882 |
| 65931 | template<> |  | 65883 | template<>
| 65932 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerMOSSE> > |  | 65884 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerMOSSE> >
| 65933 | { |  | 65885 | {
| 65934 | static PyObject* from(const Ptr<cv::legacy::TrackerMOSSE>& r) |  | 65886 | static PyObject* from(const Ptr<cv::legacy::TrackerMOSSE>& r)
| 65935 | { |  | 65887 | {
| 65936 | return pyopencv_legacy_TrackerMOSSE_Instance(r); |  | 65888 | return pyopencv_legacy_TrackerMOSSE_Instance(r);
| 65937 | } |  | 65889 | }
| 65938 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerMOSSE>& dst, const ArgInfo& info) |  | 65890 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerMOSSE>& dst, const ArgInfo& info)
| 65939 | { |  | 65891 | {
| 65940 | if(!src || src == Py_None) |  | 65892 | if(!src || src == Py_None)
| 65941 | return true; |  | 65893 | return true;
| 65942 | Ptr<cv::legacy::TrackerMOSSE> * dst_; |  | 65894 | Ptr<cv::legacy::TrackerMOSSE> * dst_;
| 65943 | if (pyopencv_legacy_TrackerMOSSE_getp(src, dst_)) |  | 65895 | if (pyopencv_legacy_TrackerMOSSE_getp(src, dst_))
| 65944 | { |  | 65896 | {
| 65945 | dst = *dst_; |  | 65897 | dst = *dst_;
| 65946 | return true; |  | 65898 | return true;
| 65947 | } |  | 65899 | }
| 65948 |  |  | 65900 |
| 65949 | failmsg("Expected Ptr<cv::legacy::TrackerMOSSE> for argument '%s'", info.name); |  | 65901 | failmsg("Expected Ptr<cv::legacy::TrackerMOSSE> for argument '%s'", info.name);
| 65950 | return false; |  | 65902 | return false;
| 65951 | } |  | 65903 | }
| 65952 | }; |  | 65904 | };
| 65953 |  |  | 65905 |
| 65954 | //================================================================================ |  | 65906 | //================================================================================
| 65955 | // legacy_TrackerMedianFlow (Generic) |  | 65907 | // legacy_TrackerMedianFlow (Generic)
| 65956 | //================================================================================ |  | 65908 | //================================================================================
| 65957 |  |  | 65909 |
| 65958 | // GetSet (legacy_TrackerMedianFlow) |  | 65910 | // GetSet (legacy_TrackerMedianFlow)
| 65959 |  |  | 65911 |
| 65960 |  |  | 65912 |
| 65961 |  |  | 65913 |
| 65962 | // Methods (legacy_TrackerMedianFlow) |  | 65914 | // Methods (legacy_TrackerMedianFlow)
| 65963 |  |  | 65915 |
| 65964 | static PyObject* pyopencv_cv_legacy_legacy_TrackerMedianFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65916 | static PyObject* pyopencv_cv_legacy_legacy_TrackerMedianFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 65965 | { |  | 65917 | {
| 65966 | using namespace cv::legacy; |  | 65918 | using namespace cv::legacy;
| 65967 |  |  | 65919 |
| 65968 | Ptr<legacy::TrackerMedianFlow> retval; |  | 65920 | Ptr<legacy::TrackerMedianFlow> retval;
| 65969 |  |  | 65921 |
| 65970 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65922 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 65971 | { |  | 65923 | {
| 65972 | ERRWRAP2(retval = cv::legacy::TrackerMedianFlow::create()); |  | 65924 | ERRWRAP2(retval = cv::legacy::TrackerMedianFlow::create());
| 65973 | return pyopencv_from(retval); |  | 65925 | return pyopencv_from(retval);
| 65974 | } |  | 65926 | }
| 65975 |  |  | 65927 |
| 65976 | return NULL; |  | 65928 | return NULL;
| 65977 | } |  | 65929 | }
| 65978 |  |  | 65930 |
| 65979 |  |  | 65931 |
| 65980 |  |  | 65932 |
| 65981 | // Tables (legacy_TrackerMedianFlow) |  | 65933 | // Tables (legacy_TrackerMedianFlow)
| 65982 |  |  | 65934 |
| 65983 | static PyGetSetDef pyopencv_legacy_TrackerMedianFlow_getseters[] = |  | 65935 | static PyGetSetDef pyopencv_legacy_TrackerMedianFlow_getseters[] =
| 65984 | { |  | 65936 | {
| 65985 | {NULL} /* Sentinel */ |  | 65937 | {NULL} /* Sentinel */
| 65986 | }; |  | 65938 | };
| 65987 |  |  | 65939 |
| 65988 | static PyMethodDef pyopencv_legacy_TrackerMedianFlow_methods[] = |  | 65940 | static PyMethodDef pyopencv_legacy_TrackerMedianFlow_methods[] =
| 65989 | { |  | 65941 | {
| 65990 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerMedianFlow_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters Median Flow parameters TrackerMedianFlow::Params"}, |  | 65942 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerMedianFlow_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters Median Flow parameters TrackerMedianFlow::Params"},
| 65991 |  |  | 65943 |
| 65992 | {NULL, NULL} |  | 65944 | {NULL, NULL}
| 65993 | }; |  | 65945 | };
| 65994 |  |  | 65946 |
| 65995 | // Converter (legacy_TrackerMedianFlow) |  | 65947 | // Converter (legacy_TrackerMedianFlow)
| 65996 |  |  | 65948 |
| 65997 | template<> |  | 65949 | template<>
| 65998 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerMedianFlow> > |  | 65950 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerMedianFlow> >
| 65999 | { |  | 65951 | {
| 66000 | static PyObject* from(const Ptr<cv::legacy::TrackerMedianFlow>& r) |  | 65952 | static PyObject* from(const Ptr<cv::legacy::TrackerMedianFlow>& r)
| 66001 | { |  | 65953 | {
| 66002 | return pyopencv_legacy_TrackerMedianFlow_Instance(r); |  | 65954 | return pyopencv_legacy_TrackerMedianFlow_Instance(r);
| 66003 | } |  | 65955 | }
| 66004 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerMedianFlow>& dst, const ArgInfo& info) |  | 65956 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerMedianFlow>& dst, const ArgInfo& info)
| 66005 | { |  | 65957 | {
| 66006 | if(!src || src == Py_None) |  | 65958 | if(!src || src == Py_None)
| 66007 | return true; |  | 65959 | return true;
| 66008 | Ptr<cv::legacy::TrackerMedianFlow> * dst_; |  | 65960 | Ptr<cv::legacy::TrackerMedianFlow> * dst_;
| 66009 | if (pyopencv_legacy_TrackerMedianFlow_getp(src, dst_)) |  | 65961 | if (pyopencv_legacy_TrackerMedianFlow_getp(src, dst_))
| 66010 | { |  | 65962 | {
| 66011 | dst = *dst_; |  | 65963 | dst = *dst_;
| 66012 | return true; |  | 65964 | return true;
| 66013 | } |  | 65965 | }
| 66014 |  |  | 65966 |
| 66015 | failmsg("Expected Ptr<cv::legacy::TrackerMedianFlow> for argument '%s'", info.name); |  | 65967 | failmsg("Expected Ptr<cv::legacy::TrackerMedianFlow> for argument '%s'", info.name);
| 66016 | return false; |  | 65968 | return false;
| 66017 | } |  | 65969 | }
| 66018 | }; |  | 65970 | };
| 66019 |  |  | 65971 |
| 66020 | //================================================================================ |  | 65972 | //================================================================================
| 66021 | // legacy_TrackerTLD (Generic) |  | 65973 | // legacy_TrackerTLD (Generic)
| 66022 | //================================================================================ |  | 65974 | //================================================================================
| 66023 |  |  | 65975 |
| 66024 | // GetSet (legacy_TrackerTLD) |  | 65976 | // GetSet (legacy_TrackerTLD)
| 66025 |  |  | 65977 |
| 66026 |  |  | 65978 |
| 66027 |  |  | 65979 |
| 66028 | // Methods (legacy_TrackerTLD) |  | 65980 | // Methods (legacy_TrackerTLD)
| 66029 |  |  | 65981 |
| 66030 | static PyObject* pyopencv_cv_legacy_legacy_TrackerTLD_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 65982 | static PyObject* pyopencv_cv_legacy_legacy_TrackerTLD_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 66031 | { |  | 65983 | {
| 66032 | using namespace cv::legacy; |  | 65984 | using namespace cv::legacy;
| 66033 |  |  | 65985 |
| 66034 | Ptr<legacy::TrackerTLD> retval; |  | 65986 | Ptr<legacy::TrackerTLD> retval;
| 66035 |  |  | 65987 |
| 66036 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 65988 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66037 | { |  | 65989 | {
| 66038 | ERRWRAP2(retval = cv::legacy::TrackerTLD::create()); |  | 65990 | ERRWRAP2(retval = cv::legacy::TrackerTLD::create());
| 66039 | return pyopencv_from(retval); |  | 65991 | return pyopencv_from(retval);
| 66040 | } |  | 65992 | }
| 66041 |  |  | 65993 |
| 66042 | return NULL; |  | 65994 | return NULL;
| 66043 | } |  | 65995 | }
| 66044 |  |  | 65996 |
| 66045 |  |  | 65997 |
| 66046 |  |  | 65998 |
| 66047 | // Tables (legacy_TrackerTLD) |  | 65999 | // Tables (legacy_TrackerTLD)
| 66048 |  |  | 66000 |
| 66049 | static PyGetSetDef pyopencv_legacy_TrackerTLD_getseters[] = |  | 66001 | static PyGetSetDef pyopencv_legacy_TrackerTLD_getseters[] =
| 66050 | { |  | 66002 | {
| 66051 | {NULL} /* Sentinel */ |  | 66003 | {NULL} /* Sentinel */
| 66052 | }; |  | 66004 | };
| 66053 |  |  | 66005 |
| 66054 | static PyMethodDef pyopencv_legacy_TrackerTLD_methods[] = |  | 66006 | static PyMethodDef pyopencv_legacy_TrackerTLD_methods[] =
| 66055 | { |  | 66007 | {
| 66056 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerTLD_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters TLD parameters TrackerTLD::Params"}, |  | 66008 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_legacy_legacy_TrackerTLD_create_static, METH_STATIC), "create() -> retval\n. @brief Constructor\n. @param parameters TLD parameters TrackerTLD::Params"},
| 66057 |  |  | 66009 |
| 66058 | {NULL, NULL} |  | 66010 | {NULL, NULL}
| 66059 | }; |  | 66011 | };
| 66060 |  |  | 66012 |
| 66061 | // Converter (legacy_TrackerTLD) |  | 66013 | // Converter (legacy_TrackerTLD)
| 66062 |  |  | 66014 |
| 66063 | template<> |  | 66015 | template<>
| 66064 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerTLD> > |  | 66016 | struct PyOpenCV_Converter< Ptr<cv::legacy::TrackerTLD> >
| 66065 | { |  | 66017 | {
| 66066 | static PyObject* from(const Ptr<cv::legacy::TrackerTLD>& r) |  | 66018 | static PyObject* from(const Ptr<cv::legacy::TrackerTLD>& r)
| 66067 | { |  | 66019 | {
| 66068 | return pyopencv_legacy_TrackerTLD_Instance(r); |  | 66020 | return pyopencv_legacy_TrackerTLD_Instance(r);
| 66069 | } |  | 66021 | }
| 66070 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerTLD>& dst, const ArgInfo& info) |  | 66022 | static bool to(PyObject* src, Ptr<cv::legacy::TrackerTLD>& dst, const ArgInfo& info)
| 66071 | { |  | 66023 | {
| 66072 | if(!src || src == Py_None) |  | 66024 | if(!src || src == Py_None)
| 66073 | return true; |  | 66025 | return true;
| 66074 | Ptr<cv::legacy::TrackerTLD> * dst_; |  | 66026 | Ptr<cv::legacy::TrackerTLD> * dst_;
| 66075 | if (pyopencv_legacy_TrackerTLD_getp(src, dst_)) |  | 66027 | if (pyopencv_legacy_TrackerTLD_getp(src, dst_))
| 66076 | { |  | 66028 | {
| 66077 | dst = *dst_; |  | 66029 | dst = *dst_;
| 66078 | return true; |  | 66030 | return true;
| 66079 | } |  | 66031 | }
| 66080 |  |  | 66032 |
| 66081 | failmsg("Expected Ptr<cv::legacy::TrackerTLD> for argument '%s'", info.name); |  | 66033 | failmsg("Expected Ptr<cv::legacy::TrackerTLD> for argument '%s'", info.name);
| 66082 | return false; |  | 66034 | return false;
| 66083 | } |  | 66035 | }
| 66084 | }; |  | 66036 | };
| 66085 |  |  | 66037 |
| 66086 | //================================================================================ |  | 66038 | //================================================================================
| 66087 | // line_descriptor_BinaryDescriptor (Generic) |  | 66039 | // line_descriptor_BinaryDescriptor (Generic)
| 66088 | //================================================================================ |  | 66040 | //================================================================================
| 66089 |  |  | 66041 |
| 66090 | // GetSet (line_descriptor_BinaryDescriptor) |  | 66042 | // GetSet (line_descriptor_BinaryDescriptor)
| 66091 |  |  | 66043 |
| 66092 |  |  | 66044 |
| 66093 |  |  | 66045 |
| 66094 | // Methods (line_descriptor_BinaryDescriptor) |  | 66046 | // Methods (line_descriptor_BinaryDescriptor)
| 66095 |  |  | 66047 |
| 66096 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66048 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 66097 | { |  | 66049 | {
| 66098 | using namespace cv::line_descriptor; |  | 66050 | using namespace cv::line_descriptor;
| 66099 |  |  | 66051 |
| 66100 |  |  | 66052 |
| 66101 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66053 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66102 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66054 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66103 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66055 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66104 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66056 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66105 | PyObject* pyobj_image = NULL; |  | 66057 | PyObject* pyobj_image = NULL;
| 66106 | Mat image; |  | 66058 | Mat image;
| 66107 | PyObject* pyobj_keylines = NULL; |  | 66059 | PyObject* pyobj_keylines = NULL;
| 66108 | vector_KeyLine keylines; |  | 66060 | vector_KeyLine keylines;
| 66109 | PyObject* pyobj_descriptors = NULL; |  | 66061 | PyObject* pyobj_descriptors = NULL;
| 66110 | Mat descriptors; |  | 66062 | Mat descriptors;
| 66111 | PyObject* pyobj_returnFloatDescr = NULL; |  | 66063 | PyObject* pyobj_returnFloatDescr = NULL;
| 66112 | bool returnFloatDescr=false; |  | 66064 | bool returnFloatDescr=false;
| 66113 |  |  | 66065 |
| 66114 | const char* keywords[] = { "image", "keylines", "descriptors", "returnFloatDescr", NULL }; |  | 66066 | const char* keywords[] = { "image", "keylines", "descriptors", "returnFloatDescr", NULL };
| 66115 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:line_descriptor_BinaryDescriptor.compute", (char**)keywords, &pyobj_image, &pyobj_keylines, &pyobj_descriptors, &pyobj_returnFloatDescr) && |  | 66067 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:line_descriptor_BinaryDescriptor.compute", (char**)keywords, &pyobj_image, &pyobj_keylines, &pyobj_descriptors, &pyobj_returnFloatDescr) &&
| 66116 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 66068 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 66117 | pyopencv_to_safe(pyobj_keylines, keylines, ArgInfo("keylines", 1)) && |  | 66069 | pyopencv_to_safe(pyobj_keylines, keylines, ArgInfo("keylines", 1)) &&
| 66118 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) && |  | 66070 | pyopencv_to_safe(pyobj_descriptors, descriptors, ArgInfo("descriptors", 1)) &&
| 66119 | pyopencv_to_safe(pyobj_returnFloatDescr, returnFloatDescr, ArgInfo("returnFloatDescr", 0)) ) |  | 66071 | pyopencv_to_safe(pyobj_returnFloatDescr, returnFloatDescr, ArgInfo("returnFloatDescr", 0)) )
| 66120 | { |  | 66072 | {
| 66121 | ERRWRAP2(_self_->compute(image, keylines, descriptors, returnFloatDescr)); |  | 66073 | ERRWRAP2(_self_->compute(image, keylines, descriptors, returnFloatDescr));
| 66122 | return Py_BuildValue("(NN)", pyopencv_from(keylines), pyopencv_from(descriptors)); |  | 66074 | return Py_BuildValue("(NN)", pyopencv_from(keylines), pyopencv_from(descriptors));
| 66123 | } |  | 66075 | }
| 66124 |  |  | 66076 |
| 66125 | return NULL; |  | 66077 | return NULL;
| 66126 | } |  | 66078 | }
| 66127 |  |  | 66079 |
| 66128 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_createBinaryDescriptor_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66080 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_createBinaryDescriptor_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 66129 | { |  | 66081 | {
| 66130 | using namespace cv::line_descriptor; |  | 66082 | using namespace cv::line_descriptor;
| 66131 |  |  | 66083 |
| 66132 | Ptr<BinaryDescriptor> retval; |  | 66084 | Ptr<BinaryDescriptor> retval;
| 66133 |  |  | 66085 |
| 66134 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66086 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66135 | { |  | 66087 | {
| 66136 | ERRWRAP2(retval = cv::line_descriptor::BinaryDescriptor::createBinaryDescriptor()); |  | 66088 | ERRWRAP2(retval = cv::line_descriptor::BinaryDescriptor::createBinaryDescriptor());
| 66137 | return pyopencv_from(retval); |  | 66089 | return pyopencv_from(retval);
| 66138 | } |  | 66090 | }
| 66139 |  |  | 66091 |
| 66140 | return NULL; |  | 66092 | return NULL;
| 66141 | } |  | 66093 | }
| 66142 |  |  | 66094 |
| 66143 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66095 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 66144 | { |  | 66096 | {
| 66145 | using namespace cv::line_descriptor; |  | 66097 | using namespace cv::line_descriptor;
| 66146 |  |  | 66098 |
| 66147 |  |  | 66099 |
| 66148 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66100 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66149 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66101 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66150 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66102 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66151 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66103 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66152 | PyObject* pyobj_image = NULL; |  | 66104 | PyObject* pyobj_image = NULL;
| 66153 | Mat image; |  | 66105 | Mat image;
| 66154 | vector_KeyLine keypoints; |  | 66106 | vector_KeyLine keypoints;
| 66155 | PyObject* pyobj_mask = NULL; |  | 66107 | PyObject* pyobj_mask = NULL;
| 66156 | Mat mask; |  | 66108 | Mat mask;
| 66157 |  |  | 66109 |
| 66158 | const char* keywords[] = { "image", "mask", NULL }; |  | 66110 | const char* keywords[] = { "image", "mask", NULL };
| 66159 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:line_descriptor_BinaryDescriptor.detect", (char**)keywords, &pyobj_image, &pyobj_mask) && |  | 66111 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:line_descriptor_BinaryDescriptor.detect", (char**)keywords, &pyobj_image, &pyobj_mask) &&
| 66160 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 66112 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 66161 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 66113 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 66162 | { |  | 66114 | {
| 66163 | ERRWRAP2(_self_->detect(image, keypoints, mask)); |  | 66115 | ERRWRAP2(_self_->detect(image, keypoints, mask));
| 66164 | return pyopencv_from(keypoints); |  | 66116 | return pyopencv_from(keypoints);
| 66165 | } |  | 66117 | }
| 66166 |  |  | 66118 |
| 66167 | return NULL; |  | 66119 | return NULL;
| 66168 | } |  | 66120 | }
| 66169 |  |  | 66121 |
| 66170 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getNumOfOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66122 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getNumOfOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 66171 | { |  | 66123 | {
| 66172 | using namespace cv::line_descriptor; |  | 66124 | using namespace cv::line_descriptor;
| 66173 |  |  | 66125 |
| 66174 |  |  | 66126 |
| 66175 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66127 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66176 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66128 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66177 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66129 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66178 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66130 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66179 | int retval; |  | 66131 | int retval;
| 66180 |  |  | 66132 |
| 66181 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66133 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66182 | { |  | 66134 | {
| 66183 | ERRWRAP2(retval = _self_->getNumOfOctaves()); |  | 66135 | ERRWRAP2(retval = _self_->getNumOfOctaves());
| 66184 | return pyopencv_from(retval); |  | 66136 | return pyopencv_from(retval);
| 66185 | } |  | 66137 | }
| 66186 |  |  | 66138 |
| 66187 | return NULL; |  | 66139 | return NULL;
| 66188 | } |  | 66140 | }
| 66189 |  |  | 66141 |
| 66190 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getReductionRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66142 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getReductionRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 66191 | { |  | 66143 | {
| 66192 | using namespace cv::line_descriptor; |  | 66144 | using namespace cv::line_descriptor;
| 66193 |  |  | 66145 |
| 66194 |  |  | 66146 |
| 66195 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66147 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66196 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66148 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66197 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66149 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66198 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66150 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66199 | int retval; |  | 66151 | int retval;
| 66200 |  |  | 66152 |
| 66201 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66153 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66202 | { |  | 66154 | {
| 66203 | ERRWRAP2(retval = _self_->getReductionRatio()); |  | 66155 | ERRWRAP2(retval = _self_->getReductionRatio());
| 66204 | return pyopencv_from(retval); |  | 66156 | return pyopencv_from(retval);
| 66205 | } |  | 66157 | }
| 66206 |  |  | 66158 |
| 66207 | return NULL; |  | 66159 | return NULL;
| 66208 | } |  | 66160 | }
| 66209 |  |  | 66161 |
| 66210 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getWidthOfBand(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66162 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getWidthOfBand(PyObject* self, PyObject* py_args, PyObject* kw)
| 66211 | { |  | 66163 | {
| 66212 | using namespace cv::line_descriptor; |  | 66164 | using namespace cv::line_descriptor;
| 66213 |  |  | 66165 |
| 66214 |  |  | 66166 |
| 66215 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66167 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66216 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66168 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66217 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66169 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66218 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66170 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66219 | int retval; |  | 66171 | int retval;
| 66220 |  |  | 66172 |
| 66221 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66173 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66222 | { |  | 66174 | {
| 66223 | ERRWRAP2(retval = _self_->getWidthOfBand()); |  | 66175 | ERRWRAP2(retval = _self_->getWidthOfBand());
| 66224 | return pyopencv_from(retval); |  | 66176 | return pyopencv_from(retval);
| 66225 | } |  | 66177 | }
| 66226 |  |  | 66178 |
| 66227 | return NULL; |  | 66179 | return NULL;
| 66228 | } |  | 66180 | }
| 66229 |  |  | 66181 |
| 66230 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setNumOfOctaves(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66182 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setNumOfOctaves(PyObject* self, PyObject* py_args, PyObject* kw)
| 66231 | { |  | 66183 | {
| 66232 | using namespace cv::line_descriptor; |  | 66184 | using namespace cv::line_descriptor;
| 66233 |  |  | 66185 |
| 66234 |  |  | 66186 |
| 66235 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66187 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66236 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66188 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66237 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66189 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66238 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66190 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66239 | PyObject* pyobj_octaves = NULL; |  | 66191 | PyObject* pyobj_octaves = NULL;
| 66240 | int octaves=0; |  | 66192 | int octaves=0;
| 66241 |  |  | 66193 |
| 66242 | const char* keywords[] = { "octaves", NULL }; |  | 66194 | const char* keywords[] = { "octaves", NULL };
| 66243 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_BinaryDescriptor.setNumOfOctaves", (char**)keywords, &pyobj_octaves) && |  | 66195 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_BinaryDescriptor.setNumOfOctaves", (char**)keywords, &pyobj_octaves) &&
| 66244 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) ) |  | 66196 | pyopencv_to_safe(pyobj_octaves, octaves, ArgInfo("octaves", 0)) )
| 66245 | { |  | 66197 | {
| 66246 | ERRWRAP2(_self_->setNumOfOctaves(octaves)); |  | 66198 | ERRWRAP2(_self_->setNumOfOctaves(octaves));
| 66247 | Py_RETURN_NONE; |  | 66199 | Py_RETURN_NONE;
| 66248 | } |  | 66200 | }
| 66249 |  |  | 66201 |
| 66250 | return NULL; |  | 66202 | return NULL;
| 66251 | } |  | 66203 | }
| 66252 |  |  | 66204 |
| 66253 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setReductionRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66205 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setReductionRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 66254 | { |  | 66206 | {
| 66255 | using namespace cv::line_descriptor; |  | 66207 | using namespace cv::line_descriptor;
| 66256 |  |  | 66208 |
| 66257 |  |  | 66209 |
| 66258 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66210 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66259 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66211 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66260 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66212 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66261 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66213 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66262 | PyObject* pyobj_rRatio = NULL; |  | 66214 | PyObject* pyobj_rRatio = NULL;
| 66263 | int rRatio=0; |  | 66215 | int rRatio=0;
| 66264 |  |  | 66216 |
| 66265 | const char* keywords[] = { "rRatio", NULL }; |  | 66217 | const char* keywords[] = { "rRatio", NULL };
| 66266 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_BinaryDescriptor.setReductionRatio", (char**)keywords, &pyobj_rRatio) && |  | 66218 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_BinaryDescriptor.setReductionRatio", (char**)keywords, &pyobj_rRatio) &&
| 66267 | pyopencv_to_safe(pyobj_rRatio, rRatio, ArgInfo("rRatio", 0)) ) |  | 66219 | pyopencv_to_safe(pyobj_rRatio, rRatio, ArgInfo("rRatio", 0)) )
| 66268 | { |  | 66220 | {
| 66269 | ERRWRAP2(_self_->setReductionRatio(rRatio)); |  | 66221 | ERRWRAP2(_self_->setReductionRatio(rRatio));
| 66270 | Py_RETURN_NONE; |  | 66222 | Py_RETURN_NONE;
| 66271 | } |  | 66223 | }
| 66272 |  |  | 66224 |
| 66273 | return NULL; |  | 66225 | return NULL;
| 66274 | } |  | 66226 | }
| 66275 |  |  | 66227 |
| 66276 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setWidthOfBand(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66228 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setWidthOfBand(PyObject* self, PyObject* py_args, PyObject* kw)
| 66277 | { |  | 66229 | {
| 66278 | using namespace cv::line_descriptor; |  | 66230 | using namespace cv::line_descriptor;
| 66279 |  |  | 66231 |
| 66280 |  |  | 66232 |
| 66281 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0; |  | 66233 | Ptr<cv::line_descriptor::BinaryDescriptor> * self1 = 0;
| 66282 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1)) |  | 66234 | if (!pyopencv_line_descriptor_BinaryDescriptor_getp(self, self1))
| 66283 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)"); |  | 66235 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptor' or its derivative)");
| 66284 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1); |  | 66236 | Ptr<cv::line_descriptor::BinaryDescriptor> _self_ = *(self1);
| 66285 | PyObject* pyobj_width = NULL; |  | 66237 | PyObject* pyobj_width = NULL;
| 66286 | int width=0; |  | 66238 | int width=0;
| 66287 |  |  | 66239 |
| 66288 | const char* keywords[] = { "width", NULL }; |  | 66240 | const char* keywords[] = { "width", NULL };
| 66289 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_BinaryDescriptor.setWidthOfBand", (char**)keywords, &pyobj_width) && |  | 66241 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_BinaryDescriptor.setWidthOfBand", (char**)keywords, &pyobj_width) &&
| 66290 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) ) |  | 66242 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) )
| 66291 | { |  | 66243 | {
| 66292 | ERRWRAP2(_self_->setWidthOfBand(width)); |  | 66244 | ERRWRAP2(_self_->setWidthOfBand(width));
| 66293 | Py_RETURN_NONE; |  | 66245 | Py_RETURN_NONE;
| 66294 | } |  | 66246 | }
| 66295 |  |  | 66247 |
| 66296 | return NULL; |  | 66248 | return NULL;
| 66297 | } |  | 66249 | }
| 66298 |  |  | 66250 |
| 66299 |  |  | 66251 |
| 66300 |  |  | 66252 |
| 66301 | // Tables (line_descriptor_BinaryDescriptor) |  | 66253 | // Tables (line_descriptor_BinaryDescriptor)
| 66302 |  |  | 66254 |
| 66303 | static PyGetSetDef pyopencv_line_descriptor_BinaryDescriptor_getseters[] = |  | 66255 | static PyGetSetDef pyopencv_line_descriptor_BinaryDescriptor_getseters[] =
| 66304 | { |  | 66256 | {
| 66305 | {NULL} /* Sentinel */ |  | 66257 | {NULL} /* Sentinel */
| 66306 | }; |  | 66258 | };
| 66307 |  |  | 66259 |
| 66308 | static PyMethodDef pyopencv_line_descriptor_BinaryDescriptor_methods[] = |  | 66260 | static PyMethodDef pyopencv_line_descriptor_BinaryDescriptor_methods[] =
| 66309 | { |  | 66261 | {
| 66310 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_compute, 0), "compute(image, keylines[, descriptors[, returnFloatDescr]]) -> keylines, descriptors\n. @brief Requires descriptors computation\n. \n. @param image input image\n. @param keylines vector containing lines for which descriptors must be computed\n. @param descriptors\n. @param returnFloatDescr flag (when set to true, original non-binary descriptors are returned)"}, |  | 66262 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_compute, 0), "compute(image, keylines[, descriptors[, returnFloatDescr]]) -> keylines, descriptors\n. @brief Requires descriptors computation\n. \n. @param image input image\n. @param keylines vector containing lines for which descriptors must be computed\n. @param descriptors\n. @param returnFloatDescr flag (when set to true, original non-binary descriptors are returned)"},
| 66311 | {"createBinaryDescriptor", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_createBinaryDescriptor_static, METH_STATIC), "createBinaryDescriptor() -> retval\n. @brief Create a BinaryDescriptor object with default parameters (or with the ones provided)\n. and return a smart pointer to it"}, |  | 66263 | {"createBinaryDescriptor", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_createBinaryDescriptor_static, METH_STATIC), "createBinaryDescriptor() -> retval\n. @brief Create a BinaryDescriptor object with default parameters (or with the ones provided)\n. and return a smart pointer to it"},
| 66312 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_detect, 0), "detect(image[, mask]) -> keypoints\n. @brief Requires line detection\n. \n. @param image input image\n. @param keypoints vector that will store extracted lines for one or more images\n. @param mask mask matrix to detect only KeyLines of interest"}, |  | 66264 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_detect, 0), "detect(image[, mask]) -> keypoints\n. @brief Requires line detection\n. \n. @param image input image\n. @param keypoints vector that will store extracted lines for one or more images\n. @param mask mask matrix to detect only KeyLines of interest"},
| 66313 | {"getNumOfOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getNumOfOctaves, 0), "getNumOfOctaves() -> retval\n. @brief Get current number of octaves"}, |  | 66265 | {"getNumOfOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getNumOfOctaves, 0), "getNumOfOctaves() -> retval\n. @brief Get current number of octaves"},
| 66314 | {"getReductionRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getReductionRatio, 0), "getReductionRatio() -> retval\n. @brief Get current reduction ratio (used in Gaussian pyramids)"}, |  | 66266 | {"getReductionRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getReductionRatio, 0), "getReductionRatio() -> retval\n. @brief Get current reduction ratio (used in Gaussian pyramids)"},
| 66315 | {"getWidthOfBand", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getWidthOfBand, 0), "getWidthOfBand() -> retval\n. @brief Get current width of bands"}, |  | 66267 | {"getWidthOfBand", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_getWidthOfBand, 0), "getWidthOfBand() -> retval\n. @brief Get current width of bands"},
| 66316 | {"setNumOfOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setNumOfOctaves, 0), "setNumOfOctaves(octaves) -> None\n. @brief Set number of octaves\n. @param octaves number of octaves"}, |  | 66268 | {"setNumOfOctaves", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setNumOfOctaves, 0), "setNumOfOctaves(octaves) -> None\n. @brief Set number of octaves\n. @param octaves number of octaves"},
| 66317 | {"setReductionRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setReductionRatio, 0), "setReductionRatio(rRatio) -> None\n. @brief Set reduction ratio (used in Gaussian pyramids)\n. @param rRatio reduction ratio"}, |  | 66269 | {"setReductionRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setReductionRatio, 0), "setReductionRatio(rRatio) -> None\n. @brief Set reduction ratio (used in Gaussian pyramids)\n. @param rRatio reduction ratio"},
| 66318 | {"setWidthOfBand", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setWidthOfBand, 0), "setWidthOfBand(width) -> None\n. @brief Set width of bands\n. @param width width of bands"}, |  | 66270 | {"setWidthOfBand", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptor_setWidthOfBand, 0), "setWidthOfBand(width) -> None\n. @brief Set width of bands\n. @param width width of bands"},
| 66319 |  |  | 66271 |
| 66320 | {NULL, NULL} |  | 66272 | {NULL, NULL}
| 66321 | }; |  | 66273 | };
| 66322 |  |  | 66274 |
| 66323 | // Converter (line_descriptor_BinaryDescriptor) |  | 66275 | // Converter (line_descriptor_BinaryDescriptor)
| 66324 |  |  | 66276 |
| 66325 | template<> |  | 66277 | template<>
| 66326 | struct PyOpenCV_Converter< Ptr<cv::line_descriptor::BinaryDescriptor> > |  | 66278 | struct PyOpenCV_Converter< Ptr<cv::line_descriptor::BinaryDescriptor> >
| 66327 | { |  | 66279 | {
| 66328 | static PyObject* from(const Ptr<cv::line_descriptor::BinaryDescriptor>& r) |  | 66280 | static PyObject* from(const Ptr<cv::line_descriptor::BinaryDescriptor>& r)
| 66329 | { |  | 66281 | {
| 66330 | return pyopencv_line_descriptor_BinaryDescriptor_Instance(r); |  | 66282 | return pyopencv_line_descriptor_BinaryDescriptor_Instance(r);
| 66331 | } |  | 66283 | }
| 66332 | static bool to(PyObject* src, Ptr<cv::line_descriptor::BinaryDescriptor>& dst, const ArgInfo& info) |  | 66284 | static bool to(PyObject* src, Ptr<cv::line_descriptor::BinaryDescriptor>& dst, const ArgInfo& info)
| 66333 | { |  | 66285 | {
| 66334 | if(!src || src == Py_None) |  | 66286 | if(!src || src == Py_None)
| 66335 | return true; |  | 66287 | return true;
| 66336 | Ptr<cv::line_descriptor::BinaryDescriptor> * dst_; |  | 66288 | Ptr<cv::line_descriptor::BinaryDescriptor> * dst_;
| 66337 | if (pyopencv_line_descriptor_BinaryDescriptor_getp(src, dst_)) |  | 66289 | if (pyopencv_line_descriptor_BinaryDescriptor_getp(src, dst_))
| 66338 | { |  | 66290 | {
| 66339 | dst = *dst_; |  | 66291 | dst = *dst_;
| 66340 | return true; |  | 66292 | return true;
| 66341 | } |  | 66293 | }
| 66342 |  |  | 66294 |
| 66343 | failmsg("Expected Ptr<cv::line_descriptor::BinaryDescriptor> for argument '%s'", info.name); |  | 66295 | failmsg("Expected Ptr<cv::line_descriptor::BinaryDescriptor> for argument '%s'", info.name);
| 66344 | return false; |  | 66296 | return false;
| 66345 | } |  | 66297 | }
| 66346 | }; |  | 66298 | };
| 66347 |  |  | 66299 |
| 66348 | //================================================================================ |  | 66300 | //================================================================================
| 66349 | // line_descriptor_BinaryDescriptorMatcher (Generic) |  | 66301 | // line_descriptor_BinaryDescriptorMatcher (Generic)
| 66350 | //================================================================================ |  | 66302 | //================================================================================
| 66351 |  |  | 66303 |
| 66352 | // GetSet (line_descriptor_BinaryDescriptorMatcher) |  | 66304 | // GetSet (line_descriptor_BinaryDescriptorMatcher)
| 66353 |  |  | 66305 |
| 66354 |  |  | 66306 |
| 66355 |  |  | 66307 |
| 66356 | // Methods (line_descriptor_BinaryDescriptorMatcher) |  | 66308 | // Methods (line_descriptor_BinaryDescriptorMatcher)
| 66357 |  |  | 66309 |
| 66358 | static int pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_BinaryDescriptorMatcher(pyopencv_line_descriptor_BinaryDescriptorMatcher_t* self, PyObject* py_args, PyObject* kw) |  | 66310 | static int pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_BinaryDescriptorMatcher(pyopencv_line_descriptor_BinaryDescriptorMatcher_t* self, PyObject* py_args, PyObject* kw)
| 66359 | { |  | 66311 | {
| 66360 | using namespace cv::line_descriptor; |  | 66312 | using namespace cv::line_descriptor;
| 66361 |  |  | 66313 |
| 66362 |  |  | 66314 |
| 66363 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66315 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66364 | { |  | 66316 | {
| 66365 | new (&(self->v)) Ptr<cv::line_descriptor::BinaryDescriptorMatcher>(); // init Ptr with placement new |  | 66317 | new (&(self->v)) Ptr<cv::line_descriptor::BinaryDescriptorMatcher>(); // init Ptr with placement new
| 66366 | if(self) ERRWRAP2(self->v.reset(new cv::line_descriptor::BinaryDescriptorMatcher())); |  | 66318 | if(self) ERRWRAP2(self->v.reset(new cv::line_descriptor::BinaryDescriptorMatcher()));
| 66367 | return 0; |  | 66319 | return 0;
| 66368 | } |  | 66320 | }
| 66369 |  |  | 66321 |
| 66370 | return -1; |  | 66322 | return -1;
| 66371 | } |  | 66323 | }
| 66372 |  |  | 66324 |
| 66373 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66325 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatch(PyObject* self, PyObject* py_args, PyObject* kw)
| 66374 | { |  | 66326 | {
| 66375 | using namespace cv::line_descriptor; |  | 66327 | using namespace cv::line_descriptor;
| 66376 |  |  | 66328 |
| 66377 |  |  | 66329 |
| 66378 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0; |  | 66330 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0;
| 66379 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1)) |  | 66331 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1))
| 66380 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)"); |  | 66332 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)");
| 66381 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1); |  | 66333 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1);
| 66382 | PyObject* pyobj_queryDescriptors = NULL; |  | 66334 | PyObject* pyobj_queryDescriptors = NULL;
| 66383 | Mat queryDescriptors; |  | 66335 | Mat queryDescriptors;
| 66384 | PyObject* pyobj_trainDescriptors = NULL; |  | 66336 | PyObject* pyobj_trainDescriptors = NULL;
| 66385 | Mat trainDescriptors; |  | 66337 | Mat trainDescriptors;
| 66386 | vector_vector_DMatch matches; |  | 66338 | vector_vector_DMatch matches;
| 66387 | PyObject* pyobj_k = NULL; |  | 66339 | PyObject* pyobj_k = NULL;
| 66388 | int k=0; |  | 66340 | int k=0;
| 66389 | PyObject* pyobj_mask = NULL; |  | 66341 | PyObject* pyobj_mask = NULL;
| 66390 | Mat mask; |  | 66342 | Mat mask;
| 66391 | PyObject* pyobj_compactResult = NULL; |  | 66343 | PyObject* pyobj_compactResult = NULL;
| 66392 | bool compactResult=false; |  | 66344 | bool compactResult=false;
| 66393 |  |  | 66345 |
| 66394 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "k", "mask", "compactResult", NULL }; |  | 66346 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "k", "mask", "compactResult", NULL };
| 66395 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:line_descriptor_BinaryDescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_k, &pyobj_mask, &pyobj_compactResult) && |  | 66347 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:line_descriptor_BinaryDescriptorMatcher.knnMatch", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_k, &pyobj_mask, &pyobj_compactResult) &&
| 66396 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 66348 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 66397 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 66349 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 66398 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 66350 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 66399 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 66351 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 66400 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 66352 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 66401 | { |  | 66353 | {
| 66402 | ERRWRAP2(_self_->knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult)); |  | 66354 | ERRWRAP2(_self_->knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult));
| 66403 | return pyopencv_from(matches); |  | 66355 | return pyopencv_from(matches);
| 66404 | } |  | 66356 | }
| 66405 |  |  | 66357 |
| 66406 | return NULL; |  | 66358 | return NULL;
| 66407 | } |  | 66359 | }
| 66408 |  |  | 66360 |
| 66409 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatchQuery(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66361 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatchQuery(PyObject* self, PyObject* py_args, PyObject* kw)
| 66410 | { |  | 66362 | {
| 66411 | using namespace cv::line_descriptor; |  | 66363 | using namespace cv::line_descriptor;
| 66412 |  |  | 66364 |
| 66413 |  |  | 66365 |
| 66414 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0; |  | 66366 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0;
| 66415 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1)) |  | 66367 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1))
| 66416 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)"); |  | 66368 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)");
| 66417 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1); |  | 66369 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1);
| 66418 | PyObject* pyobj_queryDescriptors = NULL; |  | 66370 | PyObject* pyobj_queryDescriptors = NULL;
| 66419 | Mat queryDescriptors; |  | 66371 | Mat queryDescriptors;
| 66420 | PyObject* pyobj_matches = NULL; |  | 66372 | PyObject* pyobj_matches = NULL;
| 66421 | vector_vector_DMatch matches; |  | 66373 | vector_vector_DMatch matches;
| 66422 | PyObject* pyobj_k = NULL; |  | 66374 | PyObject* pyobj_k = NULL;
| 66423 | int k=0; |  | 66375 | int k=0;
| 66424 | PyObject* pyobj_masks = NULL; |  | 66376 | PyObject* pyobj_masks = NULL;
| 66425 | vector_Mat masks=std::vector<Mat>(); |  | 66377 | vector_Mat masks=std::vector<Mat>();
| 66426 | PyObject* pyobj_compactResult = NULL; |  | 66378 | PyObject* pyobj_compactResult = NULL;
| 66427 | bool compactResult=false; |  | 66379 | bool compactResult=false;
| 66428 |  |  | 66380 |
| 66429 | const char* keywords[] = { "queryDescriptors", "matches", "k", "masks", "compactResult", NULL }; |  | 66381 | const char* keywords[] = { "queryDescriptors", "matches", "k", "masks", "compactResult", NULL };
| 66430 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:line_descriptor_BinaryDescriptorMatcher.knnMatchQuery", (char**)keywords, &pyobj_queryDescriptors, &pyobj_matches, &pyobj_k, &pyobj_masks, &pyobj_compactResult) && |  | 66382 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OO:line_descriptor_BinaryDescriptorMatcher.knnMatchQuery", (char**)keywords, &pyobj_queryDescriptors, &pyobj_matches, &pyobj_k, &pyobj_masks, &pyobj_compactResult) &&
| 66431 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 66383 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 66432 | pyopencv_to_safe(pyobj_matches, matches, ArgInfo("matches", 0)) && |  | 66384 | pyopencv_to_safe(pyobj_matches, matches, ArgInfo("matches", 0)) &&
| 66433 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 66385 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 66434 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) && |  | 66386 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) &&
| 66435 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) ) |  | 66387 | pyopencv_to_safe(pyobj_compactResult, compactResult, ArgInfo("compactResult", 0)) )
| 66436 | { |  | 66388 | {
| 66437 | ERRWRAP2(_self_->knnMatch(queryDescriptors, matches, k, masks, compactResult)); |  | 66389 | ERRWRAP2(_self_->knnMatch(queryDescriptors, matches, k, masks, compactResult));
| 66438 | Py_RETURN_NONE; |  | 66390 | Py_RETURN_NONE;
| 66439 | } |  | 66391 | }
| 66440 |  |  | 66392 |
| 66441 | return NULL; |  | 66393 | return NULL;
| 66442 | } |  | 66394 | }
| 66443 |  |  | 66395 |
| 66444 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_match(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66396 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_match(PyObject* self, PyObject* py_args, PyObject* kw)
| 66445 | { |  | 66397 | {
| 66446 | using namespace cv::line_descriptor; |  | 66398 | using namespace cv::line_descriptor;
| 66447 |  |  | 66399 |
| 66448 |  |  | 66400 |
| 66449 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0; |  | 66401 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0;
| 66450 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1)) |  | 66402 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1))
| 66451 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)"); |  | 66403 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)");
| 66452 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1); |  | 66404 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1);
| 66453 | PyObject* pyobj_queryDescriptors = NULL; |  | 66405 | PyObject* pyobj_queryDescriptors = NULL;
| 66454 | Mat queryDescriptors; |  | 66406 | Mat queryDescriptors;
| 66455 | PyObject* pyobj_trainDescriptors = NULL; |  | 66407 | PyObject* pyobj_trainDescriptors = NULL;
| 66456 | Mat trainDescriptors; |  | 66408 | Mat trainDescriptors;
| 66457 | vector_DMatch matches; |  | 66409 | vector_DMatch matches;
| 66458 | PyObject* pyobj_mask = NULL; |  | 66410 | PyObject* pyobj_mask = NULL;
| 66459 | Mat mask; |  | 66411 | Mat mask;
| 66460 |  |  | 66412 |
| 66461 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "mask", NULL }; |  | 66413 | const char* keywords[] = { "queryDescriptors", "trainDescriptors", "mask", NULL };
| 66462 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:line_descriptor_BinaryDescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_mask) && |  | 66414 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:line_descriptor_BinaryDescriptorMatcher.match", (char**)keywords, &pyobj_queryDescriptors, &pyobj_trainDescriptors, &pyobj_mask) &&
| 66463 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 66415 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 66464 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) && |  | 66416 | pyopencv_to_safe(pyobj_trainDescriptors, trainDescriptors, ArgInfo("trainDescriptors", 0)) &&
| 66465 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 66417 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 66466 | { |  | 66418 | {
| 66467 | ERRWRAP2(_self_->match(queryDescriptors, trainDescriptors, matches, mask)); |  | 66419 | ERRWRAP2(_self_->match(queryDescriptors, trainDescriptors, matches, mask));
| 66468 | return pyopencv_from(matches); |  | 66420 | return pyopencv_from(matches);
| 66469 | } |  | 66421 | }
| 66470 |  |  | 66422 |
| 66471 | return NULL; |  | 66423 | return NULL;
| 66472 | } |  | 66424 | }
| 66473 |  |  | 66425 |
| 66474 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_matchQuery(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66426 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_matchQuery(PyObject* self, PyObject* py_args, PyObject* kw)
| 66475 | { |  | 66427 | {
| 66476 | using namespace cv::line_descriptor; |  | 66428 | using namespace cv::line_descriptor;
| 66477 |  |  | 66429 |
| 66478 |  |  | 66430 |
| 66479 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0; |  | 66431 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * self1 = 0;
| 66480 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1)) |  | 66432 | if (!pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(self, self1))
| 66481 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)"); |  | 66433 | return failmsgp("Incorrect type of self (must be 'line_descriptor_BinaryDescriptorMatcher' or its derivative)");
| 66482 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1); |  | 66434 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> _self_ = *(self1);
| 66483 | PyObject* pyobj_queryDescriptors = NULL; |  | 66435 | PyObject* pyobj_queryDescriptors = NULL;
| 66484 | Mat queryDescriptors; |  | 66436 | Mat queryDescriptors;
| 66485 | vector_DMatch matches; |  | 66437 | vector_DMatch matches;
| 66486 | PyObject* pyobj_masks = NULL; |  | 66438 | PyObject* pyobj_masks = NULL;
| 66487 | vector_Mat masks=std::vector<Mat>(); |  | 66439 | vector_Mat masks=std::vector<Mat>();
| 66488 |  |  | 66440 |
| 66489 | const char* keywords[] = { "queryDescriptors", "masks", NULL }; |  | 66441 | const char* keywords[] = { "queryDescriptors", "masks", NULL };
| 66490 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:line_descriptor_BinaryDescriptorMatcher.matchQuery", (char**)keywords, &pyobj_queryDescriptors, &pyobj_masks) && |  | 66442 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:line_descriptor_BinaryDescriptorMatcher.matchQuery", (char**)keywords, &pyobj_queryDescriptors, &pyobj_masks) &&
| 66491 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) && |  | 66443 | pyopencv_to_safe(pyobj_queryDescriptors, queryDescriptors, ArgInfo("queryDescriptors", 0)) &&
| 66492 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 66444 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 66493 | { |  | 66445 | {
| 66494 | ERRWRAP2(_self_->match(queryDescriptors, matches, masks)); |  | 66446 | ERRWRAP2(_self_->match(queryDescriptors, matches, masks));
| 66495 | return pyopencv_from(matches); |  | 66447 | return pyopencv_from(matches);
| 66496 | } |  | 66448 | }
| 66497 |  |  | 66449 |
| 66498 | return NULL; |  | 66450 | return NULL;
| 66499 | } |  | 66451 | }
| 66500 |  |  | 66452 |
| 66501 |  |  | 66453 |
| 66502 |  |  | 66454 |
| 66503 | // Tables (line_descriptor_BinaryDescriptorMatcher) |  | 66455 | // Tables (line_descriptor_BinaryDescriptorMatcher)
| 66504 |  |  | 66456 |
| 66505 | static PyGetSetDef pyopencv_line_descriptor_BinaryDescriptorMatcher_getseters[] = |  | 66457 | static PyGetSetDef pyopencv_line_descriptor_BinaryDescriptorMatcher_getseters[] =
| 66506 | { |  | 66458 | {
| 66507 | {NULL} /* Sentinel */ |  | 66459 | {NULL} /* Sentinel */
| 66508 | }; |  | 66460 | };
| 66509 |  |  | 66461 |
| 66510 | static PyMethodDef pyopencv_line_descriptor_BinaryDescriptorMatcher_methods[] = |  | 66462 | static PyMethodDef pyopencv_line_descriptor_BinaryDescriptorMatcher_methods[] =
| 66511 | { |  | 66463 | {
| 66512 | {"knnMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatch, 0), "knnMatch(queryDescriptors, trainDescriptors, k[, mask[, compactResult]]) -> matches\n. @brief For every input query descriptor, retrieve the best *k* matching ones from a dataset provided from\n. user or from the one internal to class\n. \n. @param queryDescriptors query descriptors\n. @param trainDescriptors dataset of descriptors furnished by user\n. @param matches vector to host retrieved matches\n. @param k number of the closest descriptors to be returned for every input query\n. @param mask mask to select which input descriptors must be matched to ones in dataset\n. @param compactResult flag to obtain a compact result (if true, a vector that doesn't contain any\n. matches for a given query is not inserted in final result)"}, |  | 66464 | {"knnMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatch, 0), "knnMatch(queryDescriptors, trainDescriptors, k[, mask[, compactResult]]) -> matches\n. @brief For every input query descriptor, retrieve the best *k* matching ones from a dataset provided from\n. user or from the one internal to class\n. \n. @param queryDescriptors query descriptors\n. @param trainDescriptors dataset of descriptors furnished by user\n. @param matches vector to host retrieved matches\n. @param k number of the closest descriptors to be returned for every input query\n. @param mask mask to select which input descriptors must be matched to ones in dataset\n. @param compactResult flag to obtain a compact result (if true, a vector that doesn't contain any\n. matches for a given query is not inserted in final result)"},
| 66513 | {"knnMatchQuery", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatchQuery, 0), "knnMatchQuery(queryDescriptors, matches, k[, masks[, compactResult]]) -> None\n. @overload\n. @param queryDescriptors query descriptors\n. @param matches vector to host retrieved matches\n. @param k number of the closest descriptors to be returned for every input query\n. @param masks vector of masks to select which input descriptors must be matched to ones in dataset\n. (the *i*-th mask in vector indicates whether each input query can be matched with descriptors in\n. dataset relative to *i*-th image)\n. @param compactResult flag to obtain a compact result (if true, a vector that doesn't contain any\n. matches for a given query is not inserted in final result)"}, |  | 66465 | {"knnMatchQuery", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_knnMatchQuery, 0), "knnMatchQuery(queryDescriptors, matches, k[, masks[, compactResult]]) -> None\n. @overload\n. @param queryDescriptors query descriptors\n. @param matches vector to host retrieved matches\n. @param k number of the closest descriptors to be returned for every input query\n. @param masks vector of masks to select which input descriptors must be matched to ones in dataset\n. (the *i*-th mask in vector indicates whether each input query can be matched with descriptors in\n. dataset relative to *i*-th image)\n. @param compactResult flag to obtain a compact result (if true, a vector that doesn't contain any\n. matches for a given query is not inserted in final result)"},
| 66514 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_match, 0), "match(queryDescriptors, trainDescriptors[, mask]) -> matches\n. @brief For every input query descriptor, retrieve the best matching one from a dataset provided from user\n. or from the one internal to class\n. \n. @param queryDescriptors query descriptors\n. @param trainDescriptors dataset of descriptors furnished by user\n. @param matches vector to host retrieved matches\n. @param mask mask to select which input descriptors must be matched to one in dataset"}, |  | 66466 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_match, 0), "match(queryDescriptors, trainDescriptors[, mask]) -> matches\n. @brief For every input query descriptor, retrieve the best matching one from a dataset provided from user\n. or from the one internal to class\n. \n. @param queryDescriptors query descriptors\n. @param trainDescriptors dataset of descriptors furnished by user\n. @param matches vector to host retrieved matches\n. @param mask mask to select which input descriptors must be matched to one in dataset"},
| 66515 | {"matchQuery", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_matchQuery, 0), "matchQuery(queryDescriptors[, masks]) -> matches\n. @overload\n. @param queryDescriptors query descriptors\n. @param matches vector to host retrieved matches\n. @param masks vector of masks to select which input descriptors must be matched to one in dataset\n. (the *i*-th mask in vector indicates whether each input query can be matched with descriptors in\n. dataset relative to *i*-th image)"}, |  | 66467 | {"matchQuery", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_BinaryDescriptorMatcher_matchQuery, 0), "matchQuery(queryDescriptors[, masks]) -> matches\n. @overload\n. @param queryDescriptors query descriptors\n. @param matches vector to host retrieved matches\n. @param masks vector of masks to select which input descriptors must be matched to one in dataset\n. (the *i*-th mask in vector indicates whether each input query can be matched with descriptors in\n. dataset relative to *i*-th image)"},
| 66516 |  |  | 66468 |
| 66517 | {NULL, NULL} |  | 66469 | {NULL, NULL}
| 66518 | }; |  | 66470 | };
| 66519 |  |  | 66471 |
| 66520 | // Converter (line_descriptor_BinaryDescriptorMatcher) |  | 66472 | // Converter (line_descriptor_BinaryDescriptorMatcher)
| 66521 |  |  | 66473 |
| 66522 | template<> |  | 66474 | template<>
| 66523 | struct PyOpenCV_Converter< Ptr<cv::line_descriptor::BinaryDescriptorMatcher> > |  | 66475 | struct PyOpenCV_Converter< Ptr<cv::line_descriptor::BinaryDescriptorMatcher> >
| 66524 | { |  | 66476 | {
| 66525 | static PyObject* from(const Ptr<cv::line_descriptor::BinaryDescriptorMatcher>& r) |  | 66477 | static PyObject* from(const Ptr<cv::line_descriptor::BinaryDescriptorMatcher>& r)
| 66526 | { |  | 66478 | {
| 66527 | return pyopencv_line_descriptor_BinaryDescriptorMatcher_Instance(r); |  | 66479 | return pyopencv_line_descriptor_BinaryDescriptorMatcher_Instance(r);
| 66528 | } |  | 66480 | }
| 66529 | static bool to(PyObject* src, Ptr<cv::line_descriptor::BinaryDescriptorMatcher>& dst, const ArgInfo& info) |  | 66481 | static bool to(PyObject* src, Ptr<cv::line_descriptor::BinaryDescriptorMatcher>& dst, const ArgInfo& info)
| 66530 | { |  | 66482 | {
| 66531 | if(!src || src == Py_None) |  | 66483 | if(!src || src == Py_None)
| 66532 | return true; |  | 66484 | return true;
| 66533 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * dst_; |  | 66485 | Ptr<cv::line_descriptor::BinaryDescriptorMatcher> * dst_;
| 66534 | if (pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(src, dst_)) |  | 66486 | if (pyopencv_line_descriptor_BinaryDescriptorMatcher_getp(src, dst_))
| 66535 | { |  | 66487 | {
| 66536 | dst = *dst_; |  | 66488 | dst = *dst_;
| 66537 | return true; |  | 66489 | return true;
| 66538 | } |  | 66490 | }
| 66539 |  |  | 66491 |
| 66540 | failmsg("Expected Ptr<cv::line_descriptor::BinaryDescriptorMatcher> for argument '%s'", info.name); |  | 66492 | failmsg("Expected Ptr<cv::line_descriptor::BinaryDescriptorMatcher> for argument '%s'", info.name);
| 66541 | return false; |  | 66493 | return false;
| 66542 | } |  | 66494 | }
| 66543 | }; |  | 66495 | };
| 66544 |  |  | 66496 |
| 66545 | //================================================================================ |  | 66497 | //================================================================================
| 66546 | // line_descriptor_DrawLinesMatchesFlags (Generic) |  | 66498 | // line_descriptor_DrawLinesMatchesFlags (Generic)
| 66547 | //================================================================================ |  | 66499 | //================================================================================
| 66548 |  |  | 66500 |
| 66549 | // GetSet (line_descriptor_DrawLinesMatchesFlags) |  | 66501 | // GetSet (line_descriptor_DrawLinesMatchesFlags)
| 66550 |  |  | 66502 |
| 66551 |  |  | 66503 |
| 66552 |  |  | 66504 |
| 66553 | // Methods (line_descriptor_DrawLinesMatchesFlags) |  | 66505 | // Methods (line_descriptor_DrawLinesMatchesFlags)
| 66554 |  |  | 66506 |
| 66555 |  |  | 66507 |
| 66556 |  |  | 66508 |
| 66557 | // Tables (line_descriptor_DrawLinesMatchesFlags) |  | 66509 | // Tables (line_descriptor_DrawLinesMatchesFlags)
| 66558 |  |  | 66510 |
| 66559 | static PyGetSetDef pyopencv_line_descriptor_DrawLinesMatchesFlags_getseters[] = |  | 66511 | static PyGetSetDef pyopencv_line_descriptor_DrawLinesMatchesFlags_getseters[] =
| 66560 | { |  | 66512 | {
| 66561 | {NULL} /* Sentinel */ |  | 66513 | {NULL} /* Sentinel */
| 66562 | }; |  | 66514 | };
| 66563 |  |  | 66515 |
| 66564 | static PyMethodDef pyopencv_line_descriptor_DrawLinesMatchesFlags_methods[] = |  | 66516 | static PyMethodDef pyopencv_line_descriptor_DrawLinesMatchesFlags_methods[] =
| 66565 | { |  | 66517 | {
| 66566 |  |  | 66518 |
| 66567 | {NULL, NULL} |  | 66519 | {NULL, NULL}
| 66568 | }; |  | 66520 | };
| 66569 |  |  | 66521 |
| 66570 | // Converter (line_descriptor_DrawLinesMatchesFlags) |  | 66522 | // Converter (line_descriptor_DrawLinesMatchesFlags)
| 66571 |  |  | 66523 |
| 66572 | template<> |  | 66524 | template<>
| 66573 | struct PyOpenCV_Converter< cv::line_descriptor::DrawLinesMatchesFlags > |  | 66525 | struct PyOpenCV_Converter< cv::line_descriptor::DrawLinesMatchesFlags >
| 66574 | { |  | 66526 | {
| 66575 | static PyObject* from(const cv::line_descriptor::DrawLinesMatchesFlags& r) |  | 66527 | static PyObject* from(const cv::line_descriptor::DrawLinesMatchesFlags& r)
| 66576 | { |  | 66528 | {
| 66577 | return pyopencv_line_descriptor_DrawLinesMatchesFlags_Instance(r); |  | 66529 | return pyopencv_line_descriptor_DrawLinesMatchesFlags_Instance(r);
| 66578 | } |  | 66530 | }
| 66579 | static bool to(PyObject* src, cv::line_descriptor::DrawLinesMatchesFlags& dst, const ArgInfo& info) |  | 66531 | static bool to(PyObject* src, cv::line_descriptor::DrawLinesMatchesFlags& dst, const ArgInfo& info)
| 66580 | { |  | 66532 | {
| 66581 | if(!src || src == Py_None) |  | 66533 | if(!src || src == Py_None)
| 66582 | return true; |  | 66534 | return true;
| 66583 | cv::line_descriptor::DrawLinesMatchesFlags * dst_; |  | 66535 | cv::line_descriptor::DrawLinesMatchesFlags * dst_;
| 66584 | if (pyopencv_line_descriptor_DrawLinesMatchesFlags_getp(src, dst_)) |  | 66536 | if (pyopencv_line_descriptor_DrawLinesMatchesFlags_getp(src, dst_))
| 66585 | { |  | 66537 | {
| 66586 | dst = *dst_; |  | 66538 | dst = *dst_;
| 66587 | return true; |  | 66539 | return true;
| 66588 | } |  | 66540 | }
| 66589 |  |  | 66541 |
| 66590 | failmsg("Expected cv::line_descriptor::DrawLinesMatchesFlags for argument '%s'", info.name); |  | 66542 | failmsg("Expected cv::line_descriptor::DrawLinesMatchesFlags for argument '%s'", info.name);
| 66591 | return false; |  | 66543 | return false;
| 66592 | } |  | 66544 | }
| 66593 | }; |  | 66545 | };
| 66594 |  |  | 66546 |
| 66595 | //================================================================================ |  | 66547 | //================================================================================
| 66596 | // line_descriptor_KeyLine (Generic) |  | 66548 | // line_descriptor_KeyLine (Generic)
| 66597 | //================================================================================ |  | 66549 | //================================================================================
| 66598 |  |  | 66550 |
| 66599 | // GetSet (line_descriptor_KeyLine) |  | 66551 | // GetSet (line_descriptor_KeyLine)
| 66600 |  |  | 66552 |
| 66601 |  |  | 66553 |
| 66602 | static PyObject* pyopencv_line_descriptor_KeyLine_get_angle(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66554 | static PyObject* pyopencv_line_descriptor_KeyLine_get_angle(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66603 | { |  | 66555 | {
| 66604 | return pyopencv_from(p->v.angle); |  | 66556 | return pyopencv_from(p->v.angle);
| 66605 | } |  | 66557 | }
| 66606 |  |  | 66558 |
| 66607 | static int pyopencv_line_descriptor_KeyLine_set_angle(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66559 | static int pyopencv_line_descriptor_KeyLine_set_angle(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66608 | { |  | 66560 | {
| 66609 | if (!value) |  | 66561 | if (!value)
| 66610 | { |  | 66562 | {
| 66611 | PyErr_SetString(PyExc_TypeError, "Cannot delete the angle attribute"); |  | 66563 | PyErr_SetString(PyExc_TypeError, "Cannot delete the angle attribute");
| 66612 | return -1; |  | 66564 | return -1;
| 66613 | } |  | 66565 | }
| 66614 | return pyopencv_to_safe(value, p->v.angle, ArgInfo("value", 0)) ? 0 : -1; |  | 66566 | return pyopencv_to_safe(value, p->v.angle, ArgInfo("value", 0)) ? 0 : -1;
| 66615 | } |  | 66567 | }
| 66616 |  |  | 66568 |
| 66617 | static PyObject* pyopencv_line_descriptor_KeyLine_get_class_id(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66569 | static PyObject* pyopencv_line_descriptor_KeyLine_get_class_id(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66618 | { |  | 66570 | {
| 66619 | return pyopencv_from(p->v.class_id); |  | 66571 | return pyopencv_from(p->v.class_id);
| 66620 | } |  | 66572 | }
| 66621 |  |  | 66573 |
| 66622 | static int pyopencv_line_descriptor_KeyLine_set_class_id(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66574 | static int pyopencv_line_descriptor_KeyLine_set_class_id(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66623 | { |  | 66575 | {
| 66624 | if (!value) |  | 66576 | if (!value)
| 66625 | { |  | 66577 | {
| 66626 | PyErr_SetString(PyExc_TypeError, "Cannot delete the class_id attribute"); |  | 66578 | PyErr_SetString(PyExc_TypeError, "Cannot delete the class_id attribute");
| 66627 | return -1; |  | 66579 | return -1;
| 66628 | } |  | 66580 | }
| 66629 | return pyopencv_to_safe(value, p->v.class_id, ArgInfo("value", 0)) ? 0 : -1; |  | 66581 | return pyopencv_to_safe(value, p->v.class_id, ArgInfo("value", 0)) ? 0 : -1;
| 66630 | } |  | 66582 | }
| 66631 |  |  | 66583 |
| 66632 | static PyObject* pyopencv_line_descriptor_KeyLine_get_ePointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66584 | static PyObject* pyopencv_line_descriptor_KeyLine_get_ePointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66633 | { |  | 66585 | {
| 66634 | return pyopencv_from(p->v.ePointInOctaveX); |  | 66586 | return pyopencv_from(p->v.ePointInOctaveX);
| 66635 | } |  | 66587 | }
| 66636 |  |  | 66588 |
| 66637 | static int pyopencv_line_descriptor_KeyLine_set_ePointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66589 | static int pyopencv_line_descriptor_KeyLine_set_ePointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66638 | { |  | 66590 | {
| 66639 | if (!value) |  | 66591 | if (!value)
| 66640 | { |  | 66592 | {
| 66641 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ePointInOctaveX attribute"); |  | 66593 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ePointInOctaveX attribute");
| 66642 | return -1; |  | 66594 | return -1;
| 66643 | } |  | 66595 | }
| 66644 | return pyopencv_to_safe(value, p->v.ePointInOctaveX, ArgInfo("value", 0)) ? 0 : -1; |  | 66596 | return pyopencv_to_safe(value, p->v.ePointInOctaveX, ArgInfo("value", 0)) ? 0 : -1;
| 66645 | } |  | 66597 | }
| 66646 |  |  | 66598 |
| 66647 | static PyObject* pyopencv_line_descriptor_KeyLine_get_ePointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66599 | static PyObject* pyopencv_line_descriptor_KeyLine_get_ePointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66648 | { |  | 66600 | {
| 66649 | return pyopencv_from(p->v.ePointInOctaveY); |  | 66601 | return pyopencv_from(p->v.ePointInOctaveY);
| 66650 | } |  | 66602 | }
| 66651 |  |  | 66603 |
| 66652 | static int pyopencv_line_descriptor_KeyLine_set_ePointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66604 | static int pyopencv_line_descriptor_KeyLine_set_ePointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66653 | { |  | 66605 | {
| 66654 | if (!value) |  | 66606 | if (!value)
| 66655 | { |  | 66607 | {
| 66656 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ePointInOctaveY attribute"); |  | 66608 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ePointInOctaveY attribute");
| 66657 | return -1; |  | 66609 | return -1;
| 66658 | } |  | 66610 | }
| 66659 | return pyopencv_to_safe(value, p->v.ePointInOctaveY, ArgInfo("value", 0)) ? 0 : -1; |  | 66611 | return pyopencv_to_safe(value, p->v.ePointInOctaveY, ArgInfo("value", 0)) ? 0 : -1;
| 66660 | } |  | 66612 | }
| 66661 |  |  | 66613 |
| 66662 | static PyObject* pyopencv_line_descriptor_KeyLine_get_endPointX(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66614 | static PyObject* pyopencv_line_descriptor_KeyLine_get_endPointX(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66663 | { |  | 66615 | {
| 66664 | return pyopencv_from(p->v.endPointX); |  | 66616 | return pyopencv_from(p->v.endPointX);
| 66665 | } |  | 66617 | }
| 66666 |  |  | 66618 |
| 66667 | static int pyopencv_line_descriptor_KeyLine_set_endPointX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66619 | static int pyopencv_line_descriptor_KeyLine_set_endPointX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66668 | { |  | 66620 | {
| 66669 | if (!value) |  | 66621 | if (!value)
| 66670 | { |  | 66622 | {
| 66671 | PyErr_SetString(PyExc_TypeError, "Cannot delete the endPointX attribute"); |  | 66623 | PyErr_SetString(PyExc_TypeError, "Cannot delete the endPointX attribute");
| 66672 | return -1; |  | 66624 | return -1;
| 66673 | } |  | 66625 | }
| 66674 | return pyopencv_to_safe(value, p->v.endPointX, ArgInfo("value", 0)) ? 0 : -1; |  | 66626 | return pyopencv_to_safe(value, p->v.endPointX, ArgInfo("value", 0)) ? 0 : -1;
| 66675 | } |  | 66627 | }
| 66676 |  |  | 66628 |
| 66677 | static PyObject* pyopencv_line_descriptor_KeyLine_get_endPointY(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66629 | static PyObject* pyopencv_line_descriptor_KeyLine_get_endPointY(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66678 | { |  | 66630 | {
| 66679 | return pyopencv_from(p->v.endPointY); |  | 66631 | return pyopencv_from(p->v.endPointY);
| 66680 | } |  | 66632 | }
| 66681 |  |  | 66633 |
| 66682 | static int pyopencv_line_descriptor_KeyLine_set_endPointY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66634 | static int pyopencv_line_descriptor_KeyLine_set_endPointY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66683 | { |  | 66635 | {
| 66684 | if (!value) |  | 66636 | if (!value)
| 66685 | { |  | 66637 | {
| 66686 | PyErr_SetString(PyExc_TypeError, "Cannot delete the endPointY attribute"); |  | 66638 | PyErr_SetString(PyExc_TypeError, "Cannot delete the endPointY attribute");
| 66687 | return -1; |  | 66639 | return -1;
| 66688 | } |  | 66640 | }
| 66689 | return pyopencv_to_safe(value, p->v.endPointY, ArgInfo("value", 0)) ? 0 : -1; |  | 66641 | return pyopencv_to_safe(value, p->v.endPointY, ArgInfo("value", 0)) ? 0 : -1;
| 66690 | } |  | 66642 | }
| 66691 |  |  | 66643 |
| 66692 | static PyObject* pyopencv_line_descriptor_KeyLine_get_lineLength(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66644 | static PyObject* pyopencv_line_descriptor_KeyLine_get_lineLength(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66693 | { |  | 66645 | {
| 66694 | return pyopencv_from(p->v.lineLength); |  | 66646 | return pyopencv_from(p->v.lineLength);
| 66695 | } |  | 66647 | }
| 66696 |  |  | 66648 |
| 66697 | static int pyopencv_line_descriptor_KeyLine_set_lineLength(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66649 | static int pyopencv_line_descriptor_KeyLine_set_lineLength(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66698 | { |  | 66650 | {
| 66699 | if (!value) |  | 66651 | if (!value)
| 66700 | { |  | 66652 | {
| 66701 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lineLength attribute"); |  | 66653 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lineLength attribute");
| 66702 | return -1; |  | 66654 | return -1;
| 66703 | } |  | 66655 | }
| 66704 | return pyopencv_to_safe(value, p->v.lineLength, ArgInfo("value", 0)) ? 0 : -1; |  | 66656 | return pyopencv_to_safe(value, p->v.lineLength, ArgInfo("value", 0)) ? 0 : -1;
| 66705 | } |  | 66657 | }
| 66706 |  |  | 66658 |
| 66707 | static PyObject* pyopencv_line_descriptor_KeyLine_get_numOfPixels(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66659 | static PyObject* pyopencv_line_descriptor_KeyLine_get_numOfPixels(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66708 | { |  | 66660 | {
| 66709 | return pyopencv_from(p->v.numOfPixels); |  | 66661 | return pyopencv_from(p->v.numOfPixels);
| 66710 | } |  | 66662 | }
| 66711 |  |  | 66663 |
| 66712 | static int pyopencv_line_descriptor_KeyLine_set_numOfPixels(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66664 | static int pyopencv_line_descriptor_KeyLine_set_numOfPixels(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66713 | { |  | 66665 | {
| 66714 | if (!value) |  | 66666 | if (!value)
| 66715 | { |  | 66667 | {
| 66716 | PyErr_SetString(PyExc_TypeError, "Cannot delete the numOfPixels attribute"); |  | 66668 | PyErr_SetString(PyExc_TypeError, "Cannot delete the numOfPixels attribute");
| 66717 | return -1; |  | 66669 | return -1;
| 66718 | } |  | 66670 | }
| 66719 | return pyopencv_to_safe(value, p->v.numOfPixels, ArgInfo("value", 0)) ? 0 : -1; |  | 66671 | return pyopencv_to_safe(value, p->v.numOfPixels, ArgInfo("value", 0)) ? 0 : -1;
| 66720 | } |  | 66672 | }
| 66721 |  |  | 66673 |
| 66722 | static PyObject* pyopencv_line_descriptor_KeyLine_get_octave(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66674 | static PyObject* pyopencv_line_descriptor_KeyLine_get_octave(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66723 | { |  | 66675 | {
| 66724 | return pyopencv_from(p->v.octave); |  | 66676 | return pyopencv_from(p->v.octave);
| 66725 | } |  | 66677 | }
| 66726 |  |  | 66678 |
| 66727 | static int pyopencv_line_descriptor_KeyLine_set_octave(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66679 | static int pyopencv_line_descriptor_KeyLine_set_octave(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66728 | { |  | 66680 | {
| 66729 | if (!value) |  | 66681 | if (!value)
| 66730 | { |  | 66682 | {
| 66731 | PyErr_SetString(PyExc_TypeError, "Cannot delete the octave attribute"); |  | 66683 | PyErr_SetString(PyExc_TypeError, "Cannot delete the octave attribute");
| 66732 | return -1; |  | 66684 | return -1;
| 66733 | } |  | 66685 | }
| 66734 | return pyopencv_to_safe(value, p->v.octave, ArgInfo("value", 0)) ? 0 : -1; |  | 66686 | return pyopencv_to_safe(value, p->v.octave, ArgInfo("value", 0)) ? 0 : -1;
| 66735 | } |  | 66687 | }
| 66736 |  |  | 66688 |
| 66737 | static PyObject* pyopencv_line_descriptor_KeyLine_get_pt(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66689 | static PyObject* pyopencv_line_descriptor_KeyLine_get_pt(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66738 | { |  | 66690 | {
| 66739 | return pyopencv_from(p->v.pt); |  | 66691 | return pyopencv_from(p->v.pt);
| 66740 | } |  | 66692 | }
| 66741 |  |  | 66693 |
| 66742 | static int pyopencv_line_descriptor_KeyLine_set_pt(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66694 | static int pyopencv_line_descriptor_KeyLine_set_pt(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66743 | { |  | 66695 | {
| 66744 | if (!value) |  | 66696 | if (!value)
| 66745 | { |  | 66697 | {
| 66746 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt attribute"); |  | 66698 | PyErr_SetString(PyExc_TypeError, "Cannot delete the pt attribute");
| 66747 | return -1; |  | 66699 | return -1;
| 66748 | } |  | 66700 | }
| 66749 | return pyopencv_to_safe(value, p->v.pt, ArgInfo("value", 0)) ? 0 : -1; |  | 66701 | return pyopencv_to_safe(value, p->v.pt, ArgInfo("value", 0)) ? 0 : -1;
| 66750 | } |  | 66702 | }
| 66751 |  |  | 66703 |
| 66752 | static PyObject* pyopencv_line_descriptor_KeyLine_get_response(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66704 | static PyObject* pyopencv_line_descriptor_KeyLine_get_response(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66753 | { |  | 66705 | {
| 66754 | return pyopencv_from(p->v.response); |  | 66706 | return pyopencv_from(p->v.response);
| 66755 | } |  | 66707 | }
| 66756 |  |  | 66708 |
| 66757 | static int pyopencv_line_descriptor_KeyLine_set_response(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66709 | static int pyopencv_line_descriptor_KeyLine_set_response(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66758 | { |  | 66710 | {
| 66759 | if (!value) |  | 66711 | if (!value)
| 66760 | { |  | 66712 | {
| 66761 | PyErr_SetString(PyExc_TypeError, "Cannot delete the response attribute"); |  | 66713 | PyErr_SetString(PyExc_TypeError, "Cannot delete the response attribute");
| 66762 | return -1; |  | 66714 | return -1;
| 66763 | } |  | 66715 | }
| 66764 | return pyopencv_to_safe(value, p->v.response, ArgInfo("value", 0)) ? 0 : -1; |  | 66716 | return pyopencv_to_safe(value, p->v.response, ArgInfo("value", 0)) ? 0 : -1;
| 66765 | } |  | 66717 | }
| 66766 |  |  | 66718 |
| 66767 | static PyObject* pyopencv_line_descriptor_KeyLine_get_sPointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66719 | static PyObject* pyopencv_line_descriptor_KeyLine_get_sPointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66768 | { |  | 66720 | {
| 66769 | return pyopencv_from(p->v.sPointInOctaveX); |  | 66721 | return pyopencv_from(p->v.sPointInOctaveX);
| 66770 | } |  | 66722 | }
| 66771 |  |  | 66723 |
| 66772 | static int pyopencv_line_descriptor_KeyLine_set_sPointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66724 | static int pyopencv_line_descriptor_KeyLine_set_sPointInOctaveX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66773 | { |  | 66725 | {
| 66774 | if (!value) |  | 66726 | if (!value)
| 66775 | { |  | 66727 | {
| 66776 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sPointInOctaveX attribute"); |  | 66728 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sPointInOctaveX attribute");
| 66777 | return -1; |  | 66729 | return -1;
| 66778 | } |  | 66730 | }
| 66779 | return pyopencv_to_safe(value, p->v.sPointInOctaveX, ArgInfo("value", 0)) ? 0 : -1; |  | 66731 | return pyopencv_to_safe(value, p->v.sPointInOctaveX, ArgInfo("value", 0)) ? 0 : -1;
| 66780 | } |  | 66732 | }
| 66781 |  |  | 66733 |
| 66782 | static PyObject* pyopencv_line_descriptor_KeyLine_get_sPointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66734 | static PyObject* pyopencv_line_descriptor_KeyLine_get_sPointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66783 | { |  | 66735 | {
| 66784 | return pyopencv_from(p->v.sPointInOctaveY); |  | 66736 | return pyopencv_from(p->v.sPointInOctaveY);
| 66785 | } |  | 66737 | }
| 66786 |  |  | 66738 |
| 66787 | static int pyopencv_line_descriptor_KeyLine_set_sPointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66739 | static int pyopencv_line_descriptor_KeyLine_set_sPointInOctaveY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66788 | { |  | 66740 | {
| 66789 | if (!value) |  | 66741 | if (!value)
| 66790 | { |  | 66742 | {
| 66791 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sPointInOctaveY attribute"); |  | 66743 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sPointInOctaveY attribute");
| 66792 | return -1; |  | 66744 | return -1;
| 66793 | } |  | 66745 | }
| 66794 | return pyopencv_to_safe(value, p->v.sPointInOctaveY, ArgInfo("value", 0)) ? 0 : -1; |  | 66746 | return pyopencv_to_safe(value, p->v.sPointInOctaveY, ArgInfo("value", 0)) ? 0 : -1;
| 66795 | } |  | 66747 | }
| 66796 |  |  | 66748 |
| 66797 | static PyObject* pyopencv_line_descriptor_KeyLine_get_size(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66749 | static PyObject* pyopencv_line_descriptor_KeyLine_get_size(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66798 | { |  | 66750 | {
| 66799 | return pyopencv_from(p->v.size); |  | 66751 | return pyopencv_from(p->v.size);
| 66800 | } |  | 66752 | }
| 66801 |  |  | 66753 |
| 66802 | static int pyopencv_line_descriptor_KeyLine_set_size(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66754 | static int pyopencv_line_descriptor_KeyLine_set_size(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66803 | { |  | 66755 | {
| 66804 | if (!value) |  | 66756 | if (!value)
| 66805 | { |  | 66757 | {
| 66806 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute"); |  | 66758 | PyErr_SetString(PyExc_TypeError, "Cannot delete the size attribute");
| 66807 | return -1; |  | 66759 | return -1;
| 66808 | } |  | 66760 | }
| 66809 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1; |  | 66761 | return pyopencv_to_safe(value, p->v.size, ArgInfo("value", 0)) ? 0 : -1;
| 66810 | } |  | 66762 | }
| 66811 |  |  | 66763 |
| 66812 | static PyObject* pyopencv_line_descriptor_KeyLine_get_startPointX(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66764 | static PyObject* pyopencv_line_descriptor_KeyLine_get_startPointX(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66813 | { |  | 66765 | {
| 66814 | return pyopencv_from(p->v.startPointX); |  | 66766 | return pyopencv_from(p->v.startPointX);
| 66815 | } |  | 66767 | }
| 66816 |  |  | 66768 |
| 66817 | static int pyopencv_line_descriptor_KeyLine_set_startPointX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66769 | static int pyopencv_line_descriptor_KeyLine_set_startPointX(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66818 | { |  | 66770 | {
| 66819 | if (!value) |  | 66771 | if (!value)
| 66820 | { |  | 66772 | {
| 66821 | PyErr_SetString(PyExc_TypeError, "Cannot delete the startPointX attribute"); |  | 66773 | PyErr_SetString(PyExc_TypeError, "Cannot delete the startPointX attribute");
| 66822 | return -1; |  | 66774 | return -1;
| 66823 | } |  | 66775 | }
| 66824 | return pyopencv_to_safe(value, p->v.startPointX, ArgInfo("value", 0)) ? 0 : -1; |  | 66776 | return pyopencv_to_safe(value, p->v.startPointX, ArgInfo("value", 0)) ? 0 : -1;
| 66825 | } |  | 66777 | }
| 66826 |  |  | 66778 |
| 66827 | static PyObject* pyopencv_line_descriptor_KeyLine_get_startPointY(pyopencv_line_descriptor_KeyLine_t* p, void *closure) |  | 66779 | static PyObject* pyopencv_line_descriptor_KeyLine_get_startPointY(pyopencv_line_descriptor_KeyLine_t* p, void *closure)
| 66828 | { |  | 66780 | {
| 66829 | return pyopencv_from(p->v.startPointY); |  | 66781 | return pyopencv_from(p->v.startPointY);
| 66830 | } |  | 66782 | }
| 66831 |  |  | 66783 |
| 66832 | static int pyopencv_line_descriptor_KeyLine_set_startPointY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure) |  | 66784 | static int pyopencv_line_descriptor_KeyLine_set_startPointY(pyopencv_line_descriptor_KeyLine_t* p, PyObject *value, void *closure)
| 66833 | { |  | 66785 | {
| 66834 | if (!value) |  | 66786 | if (!value)
| 66835 | { |  | 66787 | {
| 66836 | PyErr_SetString(PyExc_TypeError, "Cannot delete the startPointY attribute"); |  | 66788 | PyErr_SetString(PyExc_TypeError, "Cannot delete the startPointY attribute");
| 66837 | return -1; |  | 66789 | return -1;
| 66838 | } |  | 66790 | }
| 66839 | return pyopencv_to_safe(value, p->v.startPointY, ArgInfo("value", 0)) ? 0 : -1; |  | 66791 | return pyopencv_to_safe(value, p->v.startPointY, ArgInfo("value", 0)) ? 0 : -1;
| 66840 | } |  | 66792 | }
| 66841 |  |  | 66793 |
| 66842 |  |  | 66794 |
| 66843 | // Methods (line_descriptor_KeyLine) |  | 66795 | // Methods (line_descriptor_KeyLine)
| 66844 |  |  | 66796 |
| 66845 | static int pyopencv_cv_line_descriptor_line_descriptor_KeyLine_KeyLine(pyopencv_line_descriptor_KeyLine_t* self, PyObject* py_args, PyObject* kw) |  | 66797 | static int pyopencv_cv_line_descriptor_line_descriptor_KeyLine_KeyLine(pyopencv_line_descriptor_KeyLine_t* self, PyObject* py_args, PyObject* kw)
| 66846 | { |  | 66798 | {
| 66847 | using namespace cv::line_descriptor; |  | 66799 | using namespace cv::line_descriptor;
| 66848 |  |  | 66800 |
| 66849 |  |  | 66801 |
| 66850 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66802 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66851 | { |  | 66803 | {
| 66852 | if(self) ERRWRAP2(new (&(self->v)) cv::line_descriptor::KeyLine()); |  | 66804 | if(self) ERRWRAP2(new (&(self->v)) cv::line_descriptor::KeyLine());
| 66853 | return 0; |  | 66805 | return 0;
| 66854 | } |  | 66806 | }
| 66855 |  |  | 66807 |
| 66856 | return -1; |  | 66808 | return -1;
| 66857 | } |  | 66809 | }
| 66858 |  |  | 66810 |
| 66859 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPoint(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66811 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPoint(PyObject* self, PyObject* py_args, PyObject* kw)
| 66860 | { |  | 66812 | {
| 66861 | using namespace cv::line_descriptor; |  | 66813 | using namespace cv::line_descriptor;
| 66862 |  |  | 66814 |
| 66863 |  |  | 66815 |
| 66864 | cv::line_descriptor::KeyLine * self1 = 0; |  | 66816 | cv::line_descriptor::KeyLine * self1 = 0;
| 66865 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1)) |  | 66817 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1))
| 66866 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)"); |  | 66818 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)");
| 66867 | cv::line_descriptor::KeyLine* _self_ = (self1); |  | 66819 | cv::line_descriptor::KeyLine* _self_ = (self1);
| 66868 | Point2f retval; |  | 66820 | Point2f retval;
| 66869 |  |  | 66821 |
| 66870 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66822 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66871 | { |  | 66823 | {
| 66872 | ERRWRAP2(retval = _self_->getEndPoint()); |  | 66824 | ERRWRAP2(retval = _self_->getEndPoint());
| 66873 | return pyopencv_from(retval); |  | 66825 | return pyopencv_from(retval);
| 66874 | } |  | 66826 | }
| 66875 |  |  | 66827 |
| 66876 | return NULL; |  | 66828 | return NULL;
| 66877 | } |  | 66829 | }
| 66878 |  |  | 66830 |
| 66879 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPointInOctave(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66831 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPointInOctave(PyObject* self, PyObject* py_args, PyObject* kw)
| 66880 | { |  | 66832 | {
| 66881 | using namespace cv::line_descriptor; |  | 66833 | using namespace cv::line_descriptor;
| 66882 |  |  | 66834 |
| 66883 |  |  | 66835 |
| 66884 | cv::line_descriptor::KeyLine * self1 = 0; |  | 66836 | cv::line_descriptor::KeyLine * self1 = 0;
| 66885 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1)) |  | 66837 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1))
| 66886 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)"); |  | 66838 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)");
| 66887 | cv::line_descriptor::KeyLine* _self_ = (self1); |  | 66839 | cv::line_descriptor::KeyLine* _self_ = (self1);
| 66888 | Point2f retval; |  | 66840 | Point2f retval;
| 66889 |  |  | 66841 |
| 66890 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66842 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66891 | { |  | 66843 | {
| 66892 | ERRWRAP2(retval = _self_->getEndPointInOctave()); |  | 66844 | ERRWRAP2(retval = _self_->getEndPointInOctave());
| 66893 | return pyopencv_from(retval); |  | 66845 | return pyopencv_from(retval);
| 66894 | } |  | 66846 | }
| 66895 |  |  | 66847 |
| 66896 | return NULL; |  | 66848 | return NULL;
| 66897 | } |  | 66849 | }
| 66898 |  |  | 66850 |
| 66899 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPoint(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66851 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPoint(PyObject* self, PyObject* py_args, PyObject* kw)
| 66900 | { |  | 66852 | {
| 66901 | using namespace cv::line_descriptor; |  | 66853 | using namespace cv::line_descriptor;
| 66902 |  |  | 66854 |
| 66903 |  |  | 66855 |
| 66904 | cv::line_descriptor::KeyLine * self1 = 0; |  | 66856 | cv::line_descriptor::KeyLine * self1 = 0;
| 66905 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1)) |  | 66857 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1))
| 66906 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)"); |  | 66858 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)");
| 66907 | cv::line_descriptor::KeyLine* _self_ = (self1); |  | 66859 | cv::line_descriptor::KeyLine* _self_ = (self1);
| 66908 | Point2f retval; |  | 66860 | Point2f retval;
| 66909 |  |  | 66861 |
| 66910 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66862 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66911 | { |  | 66863 | {
| 66912 | ERRWRAP2(retval = _self_->getStartPoint()); |  | 66864 | ERRWRAP2(retval = _self_->getStartPoint());
| 66913 | return pyopencv_from(retval); |  | 66865 | return pyopencv_from(retval);
| 66914 | } |  | 66866 | }
| 66915 |  |  | 66867 |
| 66916 | return NULL; |  | 66868 | return NULL;
| 66917 | } |  | 66869 | }
| 66918 |  |  | 66870 |
| 66919 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPointInOctave(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66871 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPointInOctave(PyObject* self, PyObject* py_args, PyObject* kw)
| 66920 | { |  | 66872 | {
| 66921 | using namespace cv::line_descriptor; |  | 66873 | using namespace cv::line_descriptor;
| 66922 |  |  | 66874 |
| 66923 |  |  | 66875 |
| 66924 | cv::line_descriptor::KeyLine * self1 = 0; |  | 66876 | cv::line_descriptor::KeyLine * self1 = 0;
| 66925 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1)) |  | 66877 | if (!pyopencv_line_descriptor_KeyLine_getp(self, self1))
| 66926 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)"); |  | 66878 | return failmsgp("Incorrect type of self (must be 'line_descriptor_KeyLine' or its derivative)");
| 66927 | cv::line_descriptor::KeyLine* _self_ = (self1); |  | 66879 | cv::line_descriptor::KeyLine* _self_ = (self1);
| 66928 | Point2f retval; |  | 66880 | Point2f retval;
| 66929 |  |  | 66881 |
| 66930 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66882 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 66931 | { |  | 66883 | {
| 66932 | ERRWRAP2(retval = _self_->getStartPointInOctave()); |  | 66884 | ERRWRAP2(retval = _self_->getStartPointInOctave());
| 66933 | return pyopencv_from(retval); |  | 66885 | return pyopencv_from(retval);
| 66934 | } |  | 66886 | }
| 66935 |  |  | 66887 |
| 66936 | return NULL; |  | 66888 | return NULL;
| 66937 | } |  | 66889 | }
| 66938 |  |  | 66890 |
| 66939 |  |  | 66891 |
| 66940 |  |  | 66892 |
| 66941 | // Tables (line_descriptor_KeyLine) |  | 66893 | // Tables (line_descriptor_KeyLine)
| 66942 |  |  | 66894 |
| 66943 | static PyGetSetDef pyopencv_line_descriptor_KeyLine_getseters[] = |  | 66895 | static PyGetSetDef pyopencv_line_descriptor_KeyLine_getseters[] =
| 66944 | { |  | 66896 | {
| 66945 | {(char*)"angle", (getter)pyopencv_line_descriptor_KeyLine_get_angle, (setter)pyopencv_line_descriptor_KeyLine_set_angle, (char*)"angle", NULL}, |  | 66897 | {(char*)"angle", (getter)pyopencv_line_descriptor_KeyLine_get_angle, (setter)pyopencv_line_descriptor_KeyLine_set_angle, (char*)"angle", NULL},
| 66946 | {(char*)"class_id", (getter)pyopencv_line_descriptor_KeyLine_get_class_id, (setter)pyopencv_line_descriptor_KeyLine_set_class_id, (char*)"class_id", NULL}, |  | 66898 | {(char*)"class_id", (getter)pyopencv_line_descriptor_KeyLine_get_class_id, (setter)pyopencv_line_descriptor_KeyLine_set_class_id, (char*)"class_id", NULL},
| 66947 | {(char*)"ePointInOctaveX", (getter)pyopencv_line_descriptor_KeyLine_get_ePointInOctaveX, (setter)pyopencv_line_descriptor_KeyLine_set_ePointInOctaveX, (char*)"ePointInOctaveX", NULL}, |  | 66899 | {(char*)"ePointInOctaveX", (getter)pyopencv_line_descriptor_KeyLine_get_ePointInOctaveX, (setter)pyopencv_line_descriptor_KeyLine_set_ePointInOctaveX, (char*)"ePointInOctaveX", NULL},
| 66948 | {(char*)"ePointInOctaveY", (getter)pyopencv_line_descriptor_KeyLine_get_ePointInOctaveY, (setter)pyopencv_line_descriptor_KeyLine_set_ePointInOctaveY, (char*)"ePointInOctaveY", NULL}, |  | 66900 | {(char*)"ePointInOctaveY", (getter)pyopencv_line_descriptor_KeyLine_get_ePointInOctaveY, (setter)pyopencv_line_descriptor_KeyLine_set_ePointInOctaveY, (char*)"ePointInOctaveY", NULL},
| 66949 | {(char*)"endPointX", (getter)pyopencv_line_descriptor_KeyLine_get_endPointX, (setter)pyopencv_line_descriptor_KeyLine_set_endPointX, (char*)"endPointX", NULL}, |  | 66901 | {(char*)"endPointX", (getter)pyopencv_line_descriptor_KeyLine_get_endPointX, (setter)pyopencv_line_descriptor_KeyLine_set_endPointX, (char*)"endPointX", NULL},
| 66950 | {(char*)"endPointY", (getter)pyopencv_line_descriptor_KeyLine_get_endPointY, (setter)pyopencv_line_descriptor_KeyLine_set_endPointY, (char*)"endPointY", NULL}, |  | 66902 | {(char*)"endPointY", (getter)pyopencv_line_descriptor_KeyLine_get_endPointY, (setter)pyopencv_line_descriptor_KeyLine_set_endPointY, (char*)"endPointY", NULL},
| 66951 | {(char*)"lineLength", (getter)pyopencv_line_descriptor_KeyLine_get_lineLength, (setter)pyopencv_line_descriptor_KeyLine_set_lineLength, (char*)"lineLength", NULL}, |  | 66903 | {(char*)"lineLength", (getter)pyopencv_line_descriptor_KeyLine_get_lineLength, (setter)pyopencv_line_descriptor_KeyLine_set_lineLength, (char*)"lineLength", NULL},
| 66952 | {(char*)"numOfPixels", (getter)pyopencv_line_descriptor_KeyLine_get_numOfPixels, (setter)pyopencv_line_descriptor_KeyLine_set_numOfPixels, (char*)"numOfPixels", NULL}, |  | 66904 | {(char*)"numOfPixels", (getter)pyopencv_line_descriptor_KeyLine_get_numOfPixels, (setter)pyopencv_line_descriptor_KeyLine_set_numOfPixels, (char*)"numOfPixels", NULL},
| 66953 | {(char*)"octave", (getter)pyopencv_line_descriptor_KeyLine_get_octave, (setter)pyopencv_line_descriptor_KeyLine_set_octave, (char*)"octave", NULL}, |  | 66905 | {(char*)"octave", (getter)pyopencv_line_descriptor_KeyLine_get_octave, (setter)pyopencv_line_descriptor_KeyLine_set_octave, (char*)"octave", NULL},
| 66954 | {(char*)"pt", (getter)pyopencv_line_descriptor_KeyLine_get_pt, (setter)pyopencv_line_descriptor_KeyLine_set_pt, (char*)"pt", NULL}, |  | 66906 | {(char*)"pt", (getter)pyopencv_line_descriptor_KeyLine_get_pt, (setter)pyopencv_line_descriptor_KeyLine_set_pt, (char*)"pt", NULL},
| 66955 | {(char*)"response", (getter)pyopencv_line_descriptor_KeyLine_get_response, (setter)pyopencv_line_descriptor_KeyLine_set_response, (char*)"response", NULL}, |  | 66907 | {(char*)"response", (getter)pyopencv_line_descriptor_KeyLine_get_response, (setter)pyopencv_line_descriptor_KeyLine_set_response, (char*)"response", NULL},
| 66956 | {(char*)"sPointInOctaveX", (getter)pyopencv_line_descriptor_KeyLine_get_sPointInOctaveX, (setter)pyopencv_line_descriptor_KeyLine_set_sPointInOctaveX, (char*)"sPointInOctaveX", NULL}, |  | 66908 | {(char*)"sPointInOctaveX", (getter)pyopencv_line_descriptor_KeyLine_get_sPointInOctaveX, (setter)pyopencv_line_descriptor_KeyLine_set_sPointInOctaveX, (char*)"sPointInOctaveX", NULL},
| 66957 | {(char*)"sPointInOctaveY", (getter)pyopencv_line_descriptor_KeyLine_get_sPointInOctaveY, (setter)pyopencv_line_descriptor_KeyLine_set_sPointInOctaveY, (char*)"sPointInOctaveY", NULL}, |  | 66909 | {(char*)"sPointInOctaveY", (getter)pyopencv_line_descriptor_KeyLine_get_sPointInOctaveY, (setter)pyopencv_line_descriptor_KeyLine_set_sPointInOctaveY, (char*)"sPointInOctaveY", NULL},
| 66958 | {(char*)"size", (getter)pyopencv_line_descriptor_KeyLine_get_size, (setter)pyopencv_line_descriptor_KeyLine_set_size, (char*)"size", NULL}, |  | 66910 | {(char*)"size", (getter)pyopencv_line_descriptor_KeyLine_get_size, (setter)pyopencv_line_descriptor_KeyLine_set_size, (char*)"size", NULL},
| 66959 | {(char*)"startPointX", (getter)pyopencv_line_descriptor_KeyLine_get_startPointX, (setter)pyopencv_line_descriptor_KeyLine_set_startPointX, (char*)"startPointX", NULL}, |  | 66911 | {(char*)"startPointX", (getter)pyopencv_line_descriptor_KeyLine_get_startPointX, (setter)pyopencv_line_descriptor_KeyLine_set_startPointX, (char*)"startPointX", NULL},
| 66960 | {(char*)"startPointY", (getter)pyopencv_line_descriptor_KeyLine_get_startPointY, (setter)pyopencv_line_descriptor_KeyLine_set_startPointY, (char*)"startPointY", NULL}, |  | 66912 | {(char*)"startPointY", (getter)pyopencv_line_descriptor_KeyLine_get_startPointY, (setter)pyopencv_line_descriptor_KeyLine_set_startPointY, (char*)"startPointY", NULL},
| 66961 | {NULL} /* Sentinel */ |  | 66913 | {NULL} /* Sentinel */
| 66962 | }; |  | 66914 | };
| 66963 |  |  | 66915 |
| 66964 | static PyMethodDef pyopencv_line_descriptor_KeyLine_methods[] = |  | 66916 | static PyMethodDef pyopencv_line_descriptor_KeyLine_methods[] =
| 66965 | { |  | 66917 | {
| 66966 | {"getEndPoint", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPoint, 0), "getEndPoint() -> retval\n. Returns the end point of the line in the original image"}, |  | 66918 | {"getEndPoint", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPoint, 0), "getEndPoint() -> retval\n. Returns the end point of the line in the original image"},
| 66967 | {"getEndPointInOctave", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPointInOctave, 0), "getEndPointInOctave() -> retval\n. Returns the end point of the line in the octave it was extracted from"}, |  | 66919 | {"getEndPointInOctave", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getEndPointInOctave, 0), "getEndPointInOctave() -> retval\n. Returns the end point of the line in the octave it was extracted from"},
| 66968 | {"getStartPoint", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPoint, 0), "getStartPoint() -> retval\n. Returns the start point of the line in the original image"}, |  | 66920 | {"getStartPoint", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPoint, 0), "getStartPoint() -> retval\n. Returns the start point of the line in the original image"},
| 66969 | {"getStartPointInOctave", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPointInOctave, 0), "getStartPointInOctave() -> retval\n. Returns the start point of the line in the octave it was extracted from"}, |  | 66921 | {"getStartPointInOctave", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_KeyLine_getStartPointInOctave, 0), "getStartPointInOctave() -> retval\n. Returns the start point of the line in the octave it was extracted from"},
| 66970 |  |  | 66922 |
| 66971 | {NULL, NULL} |  | 66923 | {NULL, NULL}
| 66972 | }; |  | 66924 | };
| 66973 |  |  | 66925 |
| 66974 | // Converter (line_descriptor_KeyLine) |  | 66926 | // Converter (line_descriptor_KeyLine)
| 66975 |  |  | 66927 |
| 66976 | template<> |  | 66928 | template<>
| 66977 | struct PyOpenCV_Converter< cv::line_descriptor::KeyLine > |  | 66929 | struct PyOpenCV_Converter< cv::line_descriptor::KeyLine >
| 66978 | { |  | 66930 | {
| 66979 | static PyObject* from(const cv::line_descriptor::KeyLine& r) |  | 66931 | static PyObject* from(const cv::line_descriptor::KeyLine& r)
| 66980 | { |  | 66932 | {
| 66981 | return pyopencv_line_descriptor_KeyLine_Instance(r); |  | 66933 | return pyopencv_line_descriptor_KeyLine_Instance(r);
| 66982 | } |  | 66934 | }
| 66983 | static bool to(PyObject* src, cv::line_descriptor::KeyLine& dst, const ArgInfo& info) |  | 66935 | static bool to(PyObject* src, cv::line_descriptor::KeyLine& dst, const ArgInfo& info)
| 66984 | { |  | 66936 | {
| 66985 | if(!src || src == Py_None) |  | 66937 | if(!src || src == Py_None)
| 66986 | return true; |  | 66938 | return true;
| 66987 | cv::line_descriptor::KeyLine * dst_; |  | 66939 | cv::line_descriptor::KeyLine * dst_;
| 66988 | if (pyopencv_line_descriptor_KeyLine_getp(src, dst_)) |  | 66940 | if (pyopencv_line_descriptor_KeyLine_getp(src, dst_))
| 66989 | { |  | 66941 | {
| 66990 | dst = *dst_; |  | 66942 | dst = *dst_;
| 66991 | return true; |  | 66943 | return true;
| 66992 | } |  | 66944 | }
| 66993 |  |  | 66945 |
| 66994 | failmsg("Expected cv::line_descriptor::KeyLine for argument '%s'", info.name); |  | 66946 | failmsg("Expected cv::line_descriptor::KeyLine for argument '%s'", info.name);
| 66995 | return false; |  | 66947 | return false;
| 66996 | } |  | 66948 | }
| 66997 | }; |  | 66949 | };
| 66998 |  |  | 66950 |
| 66999 | //================================================================================ |  | 66951 | //================================================================================
| 67000 | // line_descriptor_LSDDetector (Generic) |  | 66952 | // line_descriptor_LSDDetector (Generic)
| 67001 | //================================================================================ |  | 66953 | //================================================================================
| 67002 |  |  | 66954 |
| 67003 | // GetSet (line_descriptor_LSDDetector) |  | 66955 | // GetSet (line_descriptor_LSDDetector)
| 67004 |  |  | 66956 |
| 67005 |  |  | 66957 |
| 67006 |  |  | 66958 |
| 67007 | // Methods (line_descriptor_LSDDetector) |  | 66959 | // Methods (line_descriptor_LSDDetector)
| 67008 |  |  | 66960 |
| 67009 | static int pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_LSDDetectorWithParams(pyopencv_line_descriptor_LSDDetector_t* self, PyObject* py_args, PyObject* kw) |  | 66961 | static int pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_LSDDetectorWithParams(pyopencv_line_descriptor_LSDDetector_t* self, PyObject* py_args, PyObject* kw)
| 67010 | { |  | 66962 | {
| 67011 | using namespace cv::line_descriptor; |  | 66963 | using namespace cv::line_descriptor;
| 67012 |  |  | 66964 |
| 67013 | PyObject* pyobj__params = NULL; |  | 66965 | PyObject* pyobj__params = NULL;
| 67014 | LSDParam _params; |  | 66966 | LSDParam _params;
| 67015 |  |  | 66967 |
| 67016 | const char* keywords[] = { "_params", NULL }; |  | 66968 | const char* keywords[] = { "_params", NULL };
| 67017 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:LSDDetectorWithParams", (char**)keywords, &pyobj__params) && |  | 66969 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:LSDDetectorWithParams", (char**)keywords, &pyobj__params) &&
| 67018 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) ) |  | 66970 | pyopencv_to_safe(pyobj__params, _params, ArgInfo("_params", 0)) )
| 67019 | { |  | 66971 | {
| 67020 | new (&(self->v)) Ptr<cv::line_descriptor::LSDDetector>(); // init Ptr with placement new |  | 66972 | new (&(self->v)) Ptr<cv::line_descriptor::LSDDetector>(); // init Ptr with placement new
| 67021 | if(self) ERRWRAP2(self->v.reset(new cv::line_descriptor::LSDDetector(_params))); |  | 66973 | if(self) ERRWRAP2(self->v.reset(new cv::line_descriptor::LSDDetector(_params)));
| 67022 | return 0; |  | 66974 | return 0;
| 67023 | } |  | 66975 | }
| 67024 |  |  | 66976 |
| 67025 | return -1; |  | 66977 | return -1;
| 67026 | } |  | 66978 | }
| 67027 |  |  | 66979 |
| 67028 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetector_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66980 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetector_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 67029 | { |  | 66981 | {
| 67030 | using namespace cv::line_descriptor; |  | 66982 | using namespace cv::line_descriptor;
| 67031 |  |  | 66983 |
| 67032 | Ptr<LSDDetector> retval; |  | 66984 | Ptr<LSDDetector> retval;
| 67033 |  |  | 66985 |
| 67034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 66986 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67035 | { |  | 66987 | {
| 67036 | ERRWRAP2(retval = cv::line_descriptor::LSDDetector::createLSDDetector()); |  | 66988 | ERRWRAP2(retval = cv::line_descriptor::LSDDetector::createLSDDetector());
| 67037 | return pyopencv_from(retval); |  | 66989 | return pyopencv_from(retval);
| 67038 | } |  | 66990 | }
| 67039 |  |  | 66991 |
| 67040 | return NULL; |  | 66992 | return NULL;
| 67041 | } |  | 66993 | }
| 67042 |  |  | 66994 |
| 67043 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetectorWithParams_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 66995 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetectorWithParams_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 67044 | { |  | 66996 | {
| 67045 | using namespace cv::line_descriptor; |  | 66997 | using namespace cv::line_descriptor;
| 67046 |  |  | 66998 |
| 67047 | PyObject* pyobj_params = NULL; |  | 66999 | PyObject* pyobj_params = NULL;
| 67048 | LSDParam params; |  | 67000 | LSDParam params;
| 67049 | Ptr<LSDDetector> retval; |  | 67001 | Ptr<LSDDetector> retval;
| 67050 |  |  | 67002 |
| 67051 | const char* keywords[] = { "params", NULL }; |  | 67003 | const char* keywords[] = { "params", NULL };
| 67052 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_LSDDetector.createLSDDetectorWithParams", (char**)keywords, &pyobj_params) && |  | 67004 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:line_descriptor_LSDDetector.createLSDDetectorWithParams", (char**)keywords, &pyobj_params) &&
| 67053 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 67005 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 67054 | { |  | 67006 | {
| 67055 | ERRWRAP2(retval = cv::line_descriptor::LSDDetector::createLSDDetector(params)); |  | 67007 | ERRWRAP2(retval = cv::line_descriptor::LSDDetector::createLSDDetector(params));
| 67056 | return pyopencv_from(retval); |  | 67008 | return pyopencv_from(retval);
| 67057 | } |  | 67009 | }
| 67058 |  |  | 67010 |
| 67059 | return NULL; |  | 67011 | return NULL;
| 67060 | } |  | 67012 | }
| 67061 |  |  | 67013 |
| 67062 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_detect(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67014 | static PyObject* pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_detect(PyObject* self, PyObject* py_args, PyObject* kw)
| 67063 | { |  | 67015 | {
| 67064 | using namespace cv::line_descriptor; |  | 67016 | using namespace cv::line_descriptor;
| 67065 |  |  | 67017 |
| 67066 |  |  | 67018 |
| 67067 | Ptr<cv::line_descriptor::LSDDetector> * self1 = 0; |  | 67019 | Ptr<cv::line_descriptor::LSDDetector> * self1 = 0;
| 67068 | if (!pyopencv_line_descriptor_LSDDetector_getp(self, self1)) |  | 67020 | if (!pyopencv_line_descriptor_LSDDetector_getp(self, self1))
| 67069 | return failmsgp("Incorrect type of self (must be 'line_descriptor_LSDDetector' or its derivative)"); |  | 67021 | return failmsgp("Incorrect type of self (must be 'line_descriptor_LSDDetector' or its derivative)");
| 67070 | Ptr<cv::line_descriptor::LSDDetector> _self_ = *(self1); |  | 67022 | Ptr<cv::line_descriptor::LSDDetector> _self_ = *(self1);
| 67071 | pyPrepareArgumentConversionErrorsStorage(2); |  | 67023 | pyPrepareArgumentConversionErrorsStorage(2);
| 67072 |  |  | 67024 |
| 67073 | { |  | 67025 | {
| 67074 | PyObject* pyobj_image = NULL; |  | 67026 | PyObject* pyobj_image = NULL;
| 67075 | Mat image; |  | 67027 | Mat image;
| 67076 | vector_KeyLine keypoints; |  | 67028 | vector_KeyLine keypoints;
| 67077 | PyObject* pyobj_scale = NULL; |  | 67029 | PyObject* pyobj_scale = NULL;
| 67078 | int scale=0; |  | 67030 | int scale=0;
| 67079 | PyObject* pyobj_numOctaves = NULL; |  | 67031 | PyObject* pyobj_numOctaves = NULL;
| 67080 | int numOctaves=0; |  | 67032 | int numOctaves=0;
| 67081 | PyObject* pyobj_mask = NULL; |  | 67033 | PyObject* pyobj_mask = NULL;
| 67082 | Mat mask; |  | 67034 | Mat mask;
| 67083 |  |  | 67035 |
| 67084 | const char* keywords[] = { "image", "scale", "numOctaves", "mask", NULL }; |  | 67036 | const char* keywords[] = { "image", "scale", "numOctaves", "mask", NULL };
| 67085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:line_descriptor_LSDDetector.detect", (char**)keywords, &pyobj_image, &pyobj_scale, &pyobj_numOctaves, &pyobj_mask) && |  | 67037 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:line_descriptor_LSDDetector.detect", (char**)keywords, &pyobj_image, &pyobj_scale, &pyobj_numOctaves, &pyobj_mask) &&
| 67086 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 67038 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 67087 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) && |  | 67039 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) &&
| 67088 | pyopencv_to_safe(pyobj_numOctaves, numOctaves, ArgInfo("numOctaves", 0)) && |  | 67040 | pyopencv_to_safe(pyobj_numOctaves, numOctaves, ArgInfo("numOctaves", 0)) &&
| 67089 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 67041 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 67090 | { |  | 67042 | {
| 67091 | ERRWRAP2(_self_->detect(image, keypoints, scale, numOctaves, mask)); |  | 67043 | ERRWRAP2(_self_->detect(image, keypoints, scale, numOctaves, mask));
| 67092 | return pyopencv_from(keypoints); |  | 67044 | return pyopencv_from(keypoints);
| 67093 | } |  | 67045 | }
| 67094 |  |  | 67046 |
| 67095 |  |  | 67047 |
| 67096 | pyPopulateArgumentConversionErrors(); |  | 67048 | pyPopulateArgumentConversionErrors();
| 67097 | } |  | 67049 | }
| 67098 |  |  | 67050 |
| 67099 |  |  | 67051 |
| 67100 | { |  | 67052 | {
| 67101 | PyObject* pyobj_images = NULL; |  | 67053 | PyObject* pyobj_images = NULL;
| 67102 | vector_Mat images; |  | 67054 | vector_Mat images;
| 67103 | PyObject* pyobj_keylines = NULL; |  | 67055 | PyObject* pyobj_keylines = NULL;
| 67104 | vector_vector_KeyLine keylines; |  | 67056 | vector_vector_KeyLine keylines;
| 67105 | PyObject* pyobj_scale = NULL; |  | 67057 | PyObject* pyobj_scale = NULL;
| 67106 | int scale=0; |  | 67058 | int scale=0;
| 67107 | PyObject* pyobj_numOctaves = NULL; |  | 67059 | PyObject* pyobj_numOctaves = NULL;
| 67108 | int numOctaves=0; |  | 67060 | int numOctaves=0;
| 67109 | PyObject* pyobj_masks = NULL; |  | 67061 | PyObject* pyobj_masks = NULL;
| 67110 | vector_Mat masks=std::vector<Mat>(); |  | 67062 | vector_Mat masks=std::vector<Mat>();
| 67111 |  |  | 67063 |
| 67112 | const char* keywords[] = { "images", "keylines", "scale", "numOctaves", "masks", NULL }; |  | 67064 | const char* keywords[] = { "images", "keylines", "scale", "numOctaves", "masks", NULL };
| 67113 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:line_descriptor_LSDDetector.detect", (char**)keywords, &pyobj_images, &pyobj_keylines, &pyobj_scale, &pyobj_numOctaves, &pyobj_masks) && |  | 67065 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|O:line_descriptor_LSDDetector.detect", (char**)keywords, &pyobj_images, &pyobj_keylines, &pyobj_scale, &pyobj_numOctaves, &pyobj_masks) &&
| 67114 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) && |  | 67066 | pyopencv_to_safe(pyobj_images, images, ArgInfo("images", 0)) &&
| 67115 | pyopencv_to_safe(pyobj_keylines, keylines, ArgInfo("keylines", 0)) && |  | 67067 | pyopencv_to_safe(pyobj_keylines, keylines, ArgInfo("keylines", 0)) &&
| 67116 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) && |  | 67068 | pyopencv_to_safe(pyobj_scale, scale, ArgInfo("scale", 0)) &&
| 67117 | pyopencv_to_safe(pyobj_numOctaves, numOctaves, ArgInfo("numOctaves", 0)) && |  | 67069 | pyopencv_to_safe(pyobj_numOctaves, numOctaves, ArgInfo("numOctaves", 0)) &&
| 67118 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 67070 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 67119 | { |  | 67071 | {
| 67120 | ERRWRAP2(_self_->detect(images, keylines, scale, numOctaves, masks)); |  | 67072 | ERRWRAP2(_self_->detect(images, keylines, scale, numOctaves, masks));
| 67121 | Py_RETURN_NONE; |  | 67073 | Py_RETURN_NONE;
| 67122 | } |  | 67074 | }
| 67123 |  |  | 67075 |
| 67124 |  |  | 67076 |
| 67125 | pyPopulateArgumentConversionErrors(); |  | 67077 | pyPopulateArgumentConversionErrors();
| 67126 | } |  | 67078 | }
| 67127 | pyRaiseCVOverloadException("detect"); |  | 67079 | pyRaiseCVOverloadException("detect");
| 67128 |  |  | 67080 |
| 67129 | return NULL; |  | 67081 | return NULL;
| 67130 | } |  | 67082 | }
| 67131 |  |  | 67083 |
| 67132 |  |  | 67084 |
| 67133 |  |  | 67085 |
| 67134 | // Tables (line_descriptor_LSDDetector) |  | 67086 | // Tables (line_descriptor_LSDDetector)
| 67135 |  |  | 67087 |
| 67136 | static PyGetSetDef pyopencv_line_descriptor_LSDDetector_getseters[] = |  | 67088 | static PyGetSetDef pyopencv_line_descriptor_LSDDetector_getseters[] =
| 67137 | { |  | 67089 | {
| 67138 | {NULL} /* Sentinel */ |  | 67090 | {NULL} /* Sentinel */
| 67139 | }; |  | 67091 | };
| 67140 |  |  | 67092 |
| 67141 | static PyMethodDef pyopencv_line_descriptor_LSDDetector_methods[] = |  | 67093 | static PyMethodDef pyopencv_line_descriptor_LSDDetector_methods[] =
| 67142 | { |  | 67094 | {
| 67143 | {"createLSDDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetector_static, METH_STATIC), "createLSDDetector() -> retval\n. @brief Creates ad LSDDetector object, using smart pointers."}, |  | 67095 | {"createLSDDetector", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetector_static, METH_STATIC), "createLSDDetector() -> retval\n. @brief Creates ad LSDDetector object, using smart pointers."},
| 67144 | {"createLSDDetectorWithParams", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetectorWithParams_static, METH_STATIC), "createLSDDetectorWithParams(params) -> retval\n."}, |  | 67096 | {"createLSDDetectorWithParams", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_createLSDDetectorWithParams_static, METH_STATIC), "createLSDDetectorWithParams(params) -> retval\n."},
| 67145 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_detect, 0), "detect(image, scale, numOctaves[, mask]) -> keypoints\n. @brief Detect lines inside an image.\n. \n. @param image input image\n. @param keypoints vector that will store extracted lines for one or more images\n. @param scale scale factor used in pyramids generation\n. @param numOctaves number of octaves inside pyramid\n. @param mask mask matrix to detect only KeyLines of interest\n\n\n\ndetect(images, keylines, scale, numOctaves[, masks]) -> None\n. @overload\n. @param images input images\n. @param keylines set of vectors that will store extracted lines for one or more images\n. @param scale scale factor used in pyramids generation\n. @param numOctaves number of octaves inside pyramid\n. @param masks vector of mask matrices to detect only KeyLines of interest from each input image"}, |  | 67097 | {"detect", CV_PY_FN_WITH_KW_(pyopencv_cv_line_descriptor_line_descriptor_LSDDetector_detect, 0), "detect(image, scale, numOctaves[, mask]) -> keypoints\n. @brief Detect lines inside an image.\n. \n. @param image input image\n. @param keypoints vector that will store extracted lines for one or more images\n. @param scale scale factor used in pyramids generation\n. @param numOctaves number of octaves inside pyramid\n. @param mask mask matrix to detect only KeyLines of interest\n\n\n\ndetect(images, keylines, scale, numOctaves[, masks]) -> None\n. @overload\n. @param images input images\n. @param keylines set of vectors that will store extracted lines for one or more images\n. @param scale scale factor used in pyramids generation\n. @param numOctaves number of octaves inside pyramid\n. @param masks vector of mask matrices to detect only KeyLines of interest from each input image"},
| 67146 |  |  | 67098 |
| 67147 | {NULL, NULL} |  | 67099 | {NULL, NULL}
| 67148 | }; |  | 67100 | };
| 67149 |  |  | 67101 |
| 67150 | // Converter (line_descriptor_LSDDetector) |  | 67102 | // Converter (line_descriptor_LSDDetector)
| 67151 |  |  | 67103 |
| 67152 | template<> |  | 67104 | template<>
| 67153 | struct PyOpenCV_Converter< Ptr<cv::line_descriptor::LSDDetector> > |  | 67105 | struct PyOpenCV_Converter< Ptr<cv::line_descriptor::LSDDetector> >
| 67154 | { |  | 67106 | {
| 67155 | static PyObject* from(const Ptr<cv::line_descriptor::LSDDetector>& r) |  | 67107 | static PyObject* from(const Ptr<cv::line_descriptor::LSDDetector>& r)
| 67156 | { |  | 67108 | {
| 67157 | return pyopencv_line_descriptor_LSDDetector_Instance(r); |  | 67109 | return pyopencv_line_descriptor_LSDDetector_Instance(r);
| 67158 | } |  | 67110 | }
| 67159 | static bool to(PyObject* src, Ptr<cv::line_descriptor::LSDDetector>& dst, const ArgInfo& info) |  | 67111 | static bool to(PyObject* src, Ptr<cv::line_descriptor::LSDDetector>& dst, const ArgInfo& info)
| 67160 | { |  | 67112 | {
| 67161 | if(!src || src == Py_None) |  | 67113 | if(!src || src == Py_None)
| 67162 | return true; |  | 67114 | return true;
| 67163 | Ptr<cv::line_descriptor::LSDDetector> * dst_; |  | 67115 | Ptr<cv::line_descriptor::LSDDetector> * dst_;
| 67164 | if (pyopencv_line_descriptor_LSDDetector_getp(src, dst_)) |  | 67116 | if (pyopencv_line_descriptor_LSDDetector_getp(src, dst_))
| 67165 | { |  | 67117 | {
| 67166 | dst = *dst_; |  | 67118 | dst = *dst_;
| 67167 | return true; |  | 67119 | return true;
| 67168 | } |  | 67120 | }
| 67169 |  |  | 67121 |
| 67170 | failmsg("Expected Ptr<cv::line_descriptor::LSDDetector> for argument '%s'", info.name); |  | 67122 | failmsg("Expected Ptr<cv::line_descriptor::LSDDetector> for argument '%s'", info.name);
| 67171 | return false; |  | 67123 | return false;
| 67172 | } |  | 67124 | }
| 67173 | }; |  | 67125 | };
| 67174 |  |  | 67126 |
| 67175 | //================================================================================ |  | 67127 | //================================================================================
| 67176 | // line_descriptor_LSDParam (Generic) |  | 67128 | // line_descriptor_LSDParam (Generic)
| 67177 | //================================================================================ |  | 67129 | //================================================================================
| 67178 |  |  | 67130 |
| 67179 | // GetSet (line_descriptor_LSDParam) |  | 67131 | // GetSet (line_descriptor_LSDParam)
| 67180 |  |  | 67132 |
| 67181 |  |  | 67133 |
| 67182 | static PyObject* pyopencv_line_descriptor_LSDParam_get_ang_th(pyopencv_line_descriptor_LSDParam_t* p, void *closure) |  | 67134 | static PyObject* pyopencv_line_descriptor_LSDParam_get_ang_th(pyopencv_line_descriptor_LSDParam_t* p, void *closure)
| 67183 | { |  | 67135 | {
| 67184 | return pyopencv_from(p->v.ang_th); |  | 67136 | return pyopencv_from(p->v.ang_th);
| 67185 | } |  | 67137 | }
| 67186 |  |  | 67138 |
| 67187 | static int pyopencv_line_descriptor_LSDParam_set_ang_th(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure) |  | 67139 | static int pyopencv_line_descriptor_LSDParam_set_ang_th(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure)
| 67188 | { |  | 67140 | {
| 67189 | if (!value) |  | 67141 | if (!value)
| 67190 | { |  | 67142 | {
| 67191 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ang_th attribute"); |  | 67143 | PyErr_SetString(PyExc_TypeError, "Cannot delete the ang_th attribute");
| 67192 | return -1; |  | 67144 | return -1;
| 67193 | } |  | 67145 | }
| 67194 | return pyopencv_to_safe(value, p->v.ang_th, ArgInfo("value", 0)) ? 0 : -1; |  | 67146 | return pyopencv_to_safe(value, p->v.ang_th, ArgInfo("value", 0)) ? 0 : -1;
| 67195 | } |  | 67147 | }
| 67196 |  |  | 67148 |
| 67197 | static PyObject* pyopencv_line_descriptor_LSDParam_get_density_th(pyopencv_line_descriptor_LSDParam_t* p, void *closure) |  | 67149 | static PyObject* pyopencv_line_descriptor_LSDParam_get_density_th(pyopencv_line_descriptor_LSDParam_t* p, void *closure)
| 67198 | { |  | 67150 | {
| 67199 | return pyopencv_from(p->v.density_th); |  | 67151 | return pyopencv_from(p->v.density_th);
| 67200 | } |  | 67152 | }
| 67201 |  |  | 67153 |
| 67202 | static int pyopencv_line_descriptor_LSDParam_set_density_th(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure) |  | 67154 | static int pyopencv_line_descriptor_LSDParam_set_density_th(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure)
| 67203 | { |  | 67155 | {
| 67204 | if (!value) |  | 67156 | if (!value)
| 67205 | { |  | 67157 | {
| 67206 | PyErr_SetString(PyExc_TypeError, "Cannot delete the density_th attribute"); |  | 67158 | PyErr_SetString(PyExc_TypeError, "Cannot delete the density_th attribute");
| 67207 | return -1; |  | 67159 | return -1;
| 67208 | } |  | 67160 | }
| 67209 | return pyopencv_to_safe(value, p->v.density_th, ArgInfo("value", 0)) ? 0 : -1; |  | 67161 | return pyopencv_to_safe(value, p->v.density_th, ArgInfo("value", 0)) ? 0 : -1;
| 67210 | } |  | 67162 | }
| 67211 |  |  | 67163 |
| 67212 | static PyObject* pyopencv_line_descriptor_LSDParam_get_log_eps(pyopencv_line_descriptor_LSDParam_t* p, void *closure) |  | 67164 | static PyObject* pyopencv_line_descriptor_LSDParam_get_log_eps(pyopencv_line_descriptor_LSDParam_t* p, void *closure)
| 67213 | { |  | 67165 | {
| 67214 | return pyopencv_from(p->v.log_eps); |  | 67166 | return pyopencv_from(p->v.log_eps);
| 67215 | } |  | 67167 | }
| 67216 |  |  | 67168 |
| 67217 | static int pyopencv_line_descriptor_LSDParam_set_log_eps(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure) |  | 67169 | static int pyopencv_line_descriptor_LSDParam_set_log_eps(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure)
| 67218 | { |  | 67170 | {
| 67219 | if (!value) |  | 67171 | if (!value)
| 67220 | { |  | 67172 | {
| 67221 | PyErr_SetString(PyExc_TypeError, "Cannot delete the log_eps attribute"); |  | 67173 | PyErr_SetString(PyExc_TypeError, "Cannot delete the log_eps attribute");
| 67222 | return -1; |  | 67174 | return -1;
| 67223 | } |  | 67175 | }
| 67224 | return pyopencv_to_safe(value, p->v.log_eps, ArgInfo("value", 0)) ? 0 : -1; |  | 67176 | return pyopencv_to_safe(value, p->v.log_eps, ArgInfo("value", 0)) ? 0 : -1;
| 67225 | } |  | 67177 | }
| 67226 |  |  | 67178 |
| 67227 | static PyObject* pyopencv_line_descriptor_LSDParam_get_n_bins(pyopencv_line_descriptor_LSDParam_t* p, void *closure) |  | 67179 | static PyObject* pyopencv_line_descriptor_LSDParam_get_n_bins(pyopencv_line_descriptor_LSDParam_t* p, void *closure)
| 67228 | { |  | 67180 | {
| 67229 | return pyopencv_from(p->v.n_bins); |  | 67181 | return pyopencv_from(p->v.n_bins);
| 67230 | } |  | 67182 | }
| 67231 |  |  | 67183 |
| 67232 | static int pyopencv_line_descriptor_LSDParam_set_n_bins(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure) |  | 67184 | static int pyopencv_line_descriptor_LSDParam_set_n_bins(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure)
| 67233 | { |  | 67185 | {
| 67234 | if (!value) |  | 67186 | if (!value)
| 67235 | { |  | 67187 | {
| 67236 | PyErr_SetString(PyExc_TypeError, "Cannot delete the n_bins attribute"); |  | 67188 | PyErr_SetString(PyExc_TypeError, "Cannot delete the n_bins attribute");
| 67237 | return -1; |  | 67189 | return -1;
| 67238 | } |  | 67190 | }
| 67239 | return pyopencv_to_safe(value, p->v.n_bins, ArgInfo("value", 0)) ? 0 : -1; |  | 67191 | return pyopencv_to_safe(value, p->v.n_bins, ArgInfo("value", 0)) ? 0 : -1;
| 67240 | } |  | 67192 | }
| 67241 |  |  | 67193 |
| 67242 | static PyObject* pyopencv_line_descriptor_LSDParam_get_quant(pyopencv_line_descriptor_LSDParam_t* p, void *closure) |  | 67194 | static PyObject* pyopencv_line_descriptor_LSDParam_get_quant(pyopencv_line_descriptor_LSDParam_t* p, void *closure)
| 67243 | { |  | 67195 | {
| 67244 | return pyopencv_from(p->v.quant); |  | 67196 | return pyopencv_from(p->v.quant);
| 67245 | } |  | 67197 | }
| 67246 |  |  | 67198 |
| 67247 | static int pyopencv_line_descriptor_LSDParam_set_quant(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure) |  | 67199 | static int pyopencv_line_descriptor_LSDParam_set_quant(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure)
| 67248 | { |  | 67200 | {
| 67249 | if (!value) |  | 67201 | if (!value)
| 67250 | { |  | 67202 | {
| 67251 | PyErr_SetString(PyExc_TypeError, "Cannot delete the quant attribute"); |  | 67203 | PyErr_SetString(PyExc_TypeError, "Cannot delete the quant attribute");
| 67252 | return -1; |  | 67204 | return -1;
| 67253 | } |  | 67205 | }
| 67254 | return pyopencv_to_safe(value, p->v.quant, ArgInfo("value", 0)) ? 0 : -1; |  | 67206 | return pyopencv_to_safe(value, p->v.quant, ArgInfo("value", 0)) ? 0 : -1;
| 67255 | } |  | 67207 | }
| 67256 |  |  | 67208 |
| 67257 | static PyObject* pyopencv_line_descriptor_LSDParam_get_scale(pyopencv_line_descriptor_LSDParam_t* p, void *closure) |  | 67209 | static PyObject* pyopencv_line_descriptor_LSDParam_get_scale(pyopencv_line_descriptor_LSDParam_t* p, void *closure)
| 67258 | { |  | 67210 | {
| 67259 | return pyopencv_from(p->v.scale); |  | 67211 | return pyopencv_from(p->v.scale);
| 67260 | } |  | 67212 | }
| 67261 |  |  | 67213 |
| 67262 | static int pyopencv_line_descriptor_LSDParam_set_scale(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure) |  | 67214 | static int pyopencv_line_descriptor_LSDParam_set_scale(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure)
| 67263 | { |  | 67215 | {
| 67264 | if (!value) |  | 67216 | if (!value)
| 67265 | { |  | 67217 | {
| 67266 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale attribute"); |  | 67218 | PyErr_SetString(PyExc_TypeError, "Cannot delete the scale attribute");
| 67267 | return -1; |  | 67219 | return -1;
| 67268 | } |  | 67220 | }
| 67269 | return pyopencv_to_safe(value, p->v.scale, ArgInfo("value", 0)) ? 0 : -1; |  | 67221 | return pyopencv_to_safe(value, p->v.scale, ArgInfo("value", 0)) ? 0 : -1;
| 67270 | } |  | 67222 | }
| 67271 |  |  | 67223 |
| 67272 | static PyObject* pyopencv_line_descriptor_LSDParam_get_sigma_scale(pyopencv_line_descriptor_LSDParam_t* p, void *closure) |  | 67224 | static PyObject* pyopencv_line_descriptor_LSDParam_get_sigma_scale(pyopencv_line_descriptor_LSDParam_t* p, void *closure)
| 67273 | { |  | 67225 | {
| 67274 | return pyopencv_from(p->v.sigma_scale); |  | 67226 | return pyopencv_from(p->v.sigma_scale);
| 67275 | } |  | 67227 | }
| 67276 |  |  | 67228 |
| 67277 | static int pyopencv_line_descriptor_LSDParam_set_sigma_scale(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure) |  | 67229 | static int pyopencv_line_descriptor_LSDParam_set_sigma_scale(pyopencv_line_descriptor_LSDParam_t* p, PyObject *value, void *closure)
| 67278 | { |  | 67230 | {
| 67279 | if (!value) |  | 67231 | if (!value)
| 67280 | { |  | 67232 | {
| 67281 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sigma_scale attribute"); |  | 67233 | PyErr_SetString(PyExc_TypeError, "Cannot delete the sigma_scale attribute");
| 67282 | return -1; |  | 67234 | return -1;
| 67283 | } |  | 67235 | }
| 67284 | return pyopencv_to_safe(value, p->v.sigma_scale, ArgInfo("value", 0)) ? 0 : -1; |  | 67236 | return pyopencv_to_safe(value, p->v.sigma_scale, ArgInfo("value", 0)) ? 0 : -1;
| 67285 | } |  | 67237 | }
| 67286 |  |  | 67238 |
| 67287 |  |  | 67239 |
| 67288 | // Methods (line_descriptor_LSDParam) |  | 67240 | // Methods (line_descriptor_LSDParam)
| 67289 |  |  | 67241 |
| 67290 | static int pyopencv_cv_line_descriptor_line_descriptor_LSDParam_LSDParam(pyopencv_line_descriptor_LSDParam_t* self, PyObject* py_args, PyObject* kw) |  | 67242 | static int pyopencv_cv_line_descriptor_line_descriptor_LSDParam_LSDParam(pyopencv_line_descriptor_LSDParam_t* self, PyObject* py_args, PyObject* kw)
| 67291 | { |  | 67243 | {
| 67292 | using namespace cv::line_descriptor; |  | 67244 | using namespace cv::line_descriptor;
| 67293 |  |  | 67245 |
| 67294 |  |  | 67246 |
| 67295 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 67247 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67296 | { |  | 67248 | {
| 67297 | if(self) ERRWRAP2(new (&(self->v)) cv::line_descriptor::LSDParam()); |  | 67249 | if(self) ERRWRAP2(new (&(self->v)) cv::line_descriptor::LSDParam());
| 67298 | return 0; |  | 67250 | return 0;
| 67299 | } |  | 67251 | }
| 67300 |  |  | 67252 |
| 67301 | return -1; |  | 67253 | return -1;
| 67302 | } |  | 67254 | }
| 67303 |  |  | 67255 |
| 67304 |  |  | 67256 |
| 67305 |  |  | 67257 |
| 67306 | // Tables (line_descriptor_LSDParam) |  | 67258 | // Tables (line_descriptor_LSDParam)
| 67307 |  |  | 67259 |
| 67308 | static PyGetSetDef pyopencv_line_descriptor_LSDParam_getseters[] = |  | 67260 | static PyGetSetDef pyopencv_line_descriptor_LSDParam_getseters[] =
| 67309 | { |  | 67261 | {
| 67310 | {(char*)"ang_th", (getter)pyopencv_line_descriptor_LSDParam_get_ang_th, (setter)pyopencv_line_descriptor_LSDParam_set_ang_th, (char*)"ang_th", NULL}, |  | 67262 | {(char*)"ang_th", (getter)pyopencv_line_descriptor_LSDParam_get_ang_th, (setter)pyopencv_line_descriptor_LSDParam_set_ang_th, (char*)"ang_th", NULL},
| 67311 | {(char*)"density_th", (getter)pyopencv_line_descriptor_LSDParam_get_density_th, (setter)pyopencv_line_descriptor_LSDParam_set_density_th, (char*)"density_th", NULL}, |  | 67263 | {(char*)"density_th", (getter)pyopencv_line_descriptor_LSDParam_get_density_th, (setter)pyopencv_line_descriptor_LSDParam_set_density_th, (char*)"density_th", NULL},
| 67312 | {(char*)"log_eps", (getter)pyopencv_line_descriptor_LSDParam_get_log_eps, (setter)pyopencv_line_descriptor_LSDParam_set_log_eps, (char*)"log_eps", NULL}, |  | 67264 | {(char*)"log_eps", (getter)pyopencv_line_descriptor_LSDParam_get_log_eps, (setter)pyopencv_line_descriptor_LSDParam_set_log_eps, (char*)"log_eps", NULL},
| 67313 | {(char*)"n_bins", (getter)pyopencv_line_descriptor_LSDParam_get_n_bins, (setter)pyopencv_line_descriptor_LSDParam_set_n_bins, (char*)"n_bins", NULL}, |  | 67265 | {(char*)"n_bins", (getter)pyopencv_line_descriptor_LSDParam_get_n_bins, (setter)pyopencv_line_descriptor_LSDParam_set_n_bins, (char*)"n_bins", NULL},
| 67314 | {(char*)"quant", (getter)pyopencv_line_descriptor_LSDParam_get_quant, (setter)pyopencv_line_descriptor_LSDParam_set_quant, (char*)"quant", NULL}, |  | 67266 | {(char*)"quant", (getter)pyopencv_line_descriptor_LSDParam_get_quant, (setter)pyopencv_line_descriptor_LSDParam_set_quant, (char*)"quant", NULL},
| 67315 | {(char*)"scale", (getter)pyopencv_line_descriptor_LSDParam_get_scale, (setter)pyopencv_line_descriptor_LSDParam_set_scale, (char*)"scale", NULL}, |  | 67267 | {(char*)"scale", (getter)pyopencv_line_descriptor_LSDParam_get_scale, (setter)pyopencv_line_descriptor_LSDParam_set_scale, (char*)"scale", NULL},
| 67316 | {(char*)"sigma_scale", (getter)pyopencv_line_descriptor_LSDParam_get_sigma_scale, (setter)pyopencv_line_descriptor_LSDParam_set_sigma_scale, (char*)"sigma_scale", NULL}, |  | 67268 | {(char*)"sigma_scale", (getter)pyopencv_line_descriptor_LSDParam_get_sigma_scale, (setter)pyopencv_line_descriptor_LSDParam_set_sigma_scale, (char*)"sigma_scale", NULL},
| 67317 | {NULL} /* Sentinel */ |  | 67269 | {NULL} /* Sentinel */
| 67318 | }; |  | 67270 | };
| 67319 |  |  | 67271 |
| 67320 | static PyMethodDef pyopencv_line_descriptor_LSDParam_methods[] = |  | 67272 | static PyMethodDef pyopencv_line_descriptor_LSDParam_methods[] =
| 67321 | { |  | 67273 | {
| 67322 |  |  | 67274 |
| 67323 | {NULL, NULL} |  | 67275 | {NULL, NULL}
| 67324 | }; |  | 67276 | };
| 67325 |  |  | 67277 |
| 67326 | // Converter (line_descriptor_LSDParam) |  | 67278 | // Converter (line_descriptor_LSDParam)
| 67327 |  |  | 67279 |
| 67328 | template<> |  | 67280 | template<>
| 67329 | struct PyOpenCV_Converter< cv::line_descriptor::LSDParam > |  | 67281 | struct PyOpenCV_Converter< cv::line_descriptor::LSDParam >
| 67330 | { |  | 67282 | {
| 67331 | static PyObject* from(const cv::line_descriptor::LSDParam& r) |  | 67283 | static PyObject* from(const cv::line_descriptor::LSDParam& r)
| 67332 | { |  | 67284 | {
| 67333 | return pyopencv_line_descriptor_LSDParam_Instance(r); |  | 67285 | return pyopencv_line_descriptor_LSDParam_Instance(r);
| 67334 | } |  | 67286 | }
| 67335 | static bool to(PyObject* src, cv::line_descriptor::LSDParam& dst, const ArgInfo& info) |  | 67287 | static bool to(PyObject* src, cv::line_descriptor::LSDParam& dst, const ArgInfo& info)
| 67336 | { |  | 67288 | {
| 67337 | if(!src || src == Py_None) |  | 67289 | if(!src || src == Py_None)
| 67338 | return true; |  | 67290 | return true;
| 67339 | cv::line_descriptor::LSDParam * dst_; |  | 67291 | cv::line_descriptor::LSDParam * dst_;
| 67340 | if (pyopencv_line_descriptor_LSDParam_getp(src, dst_)) |  | 67292 | if (pyopencv_line_descriptor_LSDParam_getp(src, dst_))
| 67341 | { |  | 67293 | {
| 67342 | dst = *dst_; |  | 67294 | dst = *dst_;
| 67343 | return true; |  | 67295 | return true;
| 67344 | } |  | 67296 | }
| 67345 |  |  | 67297 |
| 67346 | failmsg("Expected cv::line_descriptor::LSDParam for argument '%s'", info.name); |  | 67298 | failmsg("Expected cv::line_descriptor::LSDParam for argument '%s'", info.name);
| 67347 | return false; |  | 67299 | return false;
| 67348 | } |  | 67300 | }
| 67349 | }; |  | 67301 | };
| 67350 |  |  | 67302 |
| 67351 | //================================================================================ |  | 67303 | //================================================================================
| 67352 | // linemod_ColorGradient (Generic) |  | 67304 | // linemod_ColorGradient (Generic)
| 67353 | //================================================================================ |  | 67305 | //================================================================================
| 67354 |  |  | 67306 |
| 67355 | // GetSet (linemod_ColorGradient) |  | 67307 | // GetSet (linemod_ColorGradient)
| 67356 |  |  | 67308 |
| 67357 |  |  | 67309 |
| 67358 | static PyObject* pyopencv_linemod_ColorGradient_get_num_features(pyopencv_linemod_ColorGradient_t* p, void *closure) |  | 67310 | static PyObject* pyopencv_linemod_ColorGradient_get_num_features(pyopencv_linemod_ColorGradient_t* p, void *closure)
| 67359 | { |  | 67311 | {
| 67360 | return pyopencv_from(p->v->num_features); |  | 67312 | return pyopencv_from(p->v->num_features);
| 67361 | } |  | 67313 | }
| 67362 |  |  | 67314 |
| 67363 | static PyObject* pyopencv_linemod_ColorGradient_get_strong_threshold(pyopencv_linemod_ColorGradient_t* p, void *closure) |  | 67315 | static PyObject* pyopencv_linemod_ColorGradient_get_strong_threshold(pyopencv_linemod_ColorGradient_t* p, void *closure)
| 67364 | { |  | 67316 | {
| 67365 | return pyopencv_from(p->v->strong_threshold); |  | 67317 | return pyopencv_from(p->v->strong_threshold);
| 67366 | } |  | 67318 | }
| 67367 |  |  | 67319 |
| 67368 | static PyObject* pyopencv_linemod_ColorGradient_get_weak_threshold(pyopencv_linemod_ColorGradient_t* p, void *closure) |  | 67320 | static PyObject* pyopencv_linemod_ColorGradient_get_weak_threshold(pyopencv_linemod_ColorGradient_t* p, void *closure)
| 67369 | { |  | 67321 | {
| 67370 | return pyopencv_from(p->v->weak_threshold); |  | 67322 | return pyopencv_from(p->v->weak_threshold);
| 67371 | } |  | 67323 | }
| 67372 |  |  | 67324 |
| 67373 |  |  | 67325 |
| 67374 | // Methods (linemod_ColorGradient) |  | 67326 | // Methods (linemod_ColorGradient)
| 67375 |  |  | 67327 |
| 67376 | static PyObject* pyopencv_cv_linemod_linemod_ColorGradient_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67328 | static PyObject* pyopencv_cv_linemod_linemod_ColorGradient_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 67377 | { |  | 67329 | {
| 67378 | using namespace cv::linemod; |  | 67330 | using namespace cv::linemod;
| 67379 |  |  | 67331 |
| 67380 | PyObject* pyobj_weak_threshold = NULL; |  | 67332 | PyObject* pyobj_weak_threshold = NULL;
| 67381 | float weak_threshold=0.f; |  | 67333 | float weak_threshold=0.f;
| 67382 | PyObject* pyobj_num_features = NULL; |  | 67334 | PyObject* pyobj_num_features = NULL;
| 67383 | size_t num_features=0; |  | 67335 | size_t num_features=0;
| 67384 | PyObject* pyobj_strong_threshold = NULL; |  | 67336 | PyObject* pyobj_strong_threshold = NULL;
| 67385 | float strong_threshold=0.f; |  | 67337 | float strong_threshold=0.f;
| 67386 | Ptr<ColorGradient> retval; |  | 67338 | Ptr<ColorGradient> retval;
| 67387 |  |  | 67339 |
| 67388 | const char* keywords[] = { "weak_threshold", "num_features", "strong_threshold", NULL }; |  | 67340 | const char* keywords[] = { "weak_threshold", "num_features", "strong_threshold", NULL };
| 67389 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:linemod_ColorGradient.create", (char**)keywords, &pyobj_weak_threshold, &pyobj_num_features, &pyobj_strong_threshold) && |  | 67341 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:linemod_ColorGradient.create", (char**)keywords, &pyobj_weak_threshold, &pyobj_num_features, &pyobj_strong_threshold) &&
| 67390 | pyopencv_to_safe(pyobj_weak_threshold, weak_threshold, ArgInfo("weak_threshold", 0)) && |  | 67342 | pyopencv_to_safe(pyobj_weak_threshold, weak_threshold, ArgInfo("weak_threshold", 0)) &&
| 67391 | pyopencv_to_safe(pyobj_num_features, num_features, ArgInfo("num_features", 0)) && |  | 67343 | pyopencv_to_safe(pyobj_num_features, num_features, ArgInfo("num_features", 0)) &&
| 67392 | pyopencv_to_safe(pyobj_strong_threshold, strong_threshold, ArgInfo("strong_threshold", 0)) ) |  | 67344 | pyopencv_to_safe(pyobj_strong_threshold, strong_threshold, ArgInfo("strong_threshold", 0)) )
| 67393 | { |  | 67345 | {
| 67394 | ERRWRAP2(retval = cv::linemod::ColorGradient::create(weak_threshold, num_features, strong_threshold)); |  | 67346 | ERRWRAP2(retval = cv::linemod::ColorGradient::create(weak_threshold, num_features, strong_threshold));
| 67395 | return pyopencv_from(retval); |  | 67347 | return pyopencv_from(retval);
| 67396 | } |  | 67348 | }
| 67397 |  |  | 67349 |
| 67398 | return NULL; |  | 67350 | return NULL;
| 67399 | } |  | 67351 | }
| 67400 |  |  | 67352 |
| 67401 |  |  | 67353 |
| 67402 |  |  | 67354 |
| 67403 | // Tables (linemod_ColorGradient) |  | 67355 | // Tables (linemod_ColorGradient)
| 67404 |  |  | 67356 |
| 67405 | static PyGetSetDef pyopencv_linemod_ColorGradient_getseters[] = |  | 67357 | static PyGetSetDef pyopencv_linemod_ColorGradient_getseters[] =
| 67406 | { |  | 67358 | {
| 67407 | {(char*)"num_features", (getter)pyopencv_linemod_ColorGradient_get_num_features, NULL, (char*)"num_features", NULL}, |  | 67359 | {(char*)"num_features", (getter)pyopencv_linemod_ColorGradient_get_num_features, NULL, (char*)"num_features", NULL},
| 67408 | {(char*)"strong_threshold", (getter)pyopencv_linemod_ColorGradient_get_strong_threshold, NULL, (char*)"strong_threshold", NULL}, |  | 67360 | {(char*)"strong_threshold", (getter)pyopencv_linemod_ColorGradient_get_strong_threshold, NULL, (char*)"strong_threshold", NULL},
| 67409 | {(char*)"weak_threshold", (getter)pyopencv_linemod_ColorGradient_get_weak_threshold, NULL, (char*)"weak_threshold", NULL}, |  | 67361 | {(char*)"weak_threshold", (getter)pyopencv_linemod_ColorGradient_get_weak_threshold, NULL, (char*)"weak_threshold", NULL},
| 67410 | {NULL} /* Sentinel */ |  | 67362 | {NULL} /* Sentinel */
| 67411 | }; |  | 67363 | };
| 67412 |  |  | 67364 |
| 67413 | static PyMethodDef pyopencv_linemod_ColorGradient_methods[] = |  | 67365 | static PyMethodDef pyopencv_linemod_ColorGradient_methods[] =
| 67414 | { |  | 67366 | {
| 67415 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_ColorGradient_create_static, METH_STATIC), "create(weak_threshold, num_features, strong_threshold) -> retval\n. * \\brief Constructor.\n. *\n. * \\param weak_threshold When quantizing, discard gradients with magnitude less than this.\n. * \\param num_features How many features a template must contain.\n. * \\param strong_threshold Consider as candidate features only gradients whose norms are\n. * larger than this."}, |  | 67367 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_ColorGradient_create_static, METH_STATIC), "create(weak_threshold, num_features, strong_threshold) -> retval\n. * \\brief Constructor.\n. *\n. * \\param weak_threshold When quantizing, discard gradients with magnitude less than this.\n. * \\param num_features How many features a template must contain.\n. * \\param strong_threshold Consider as candidate features only gradients whose norms are\n. * larger than this."},
| 67416 |  |  | 67368 |
| 67417 | {NULL, NULL} |  | 67369 | {NULL, NULL}
| 67418 | }; |  | 67370 | };
| 67419 |  |  | 67371 |
| 67420 | // Converter (linemod_ColorGradient) |  | 67372 | // Converter (linemod_ColorGradient)
| 67421 |  |  | 67373 |
| 67422 | template<> |  | 67374 | template<>
| 67423 | struct PyOpenCV_Converter< Ptr<cv::linemod::ColorGradient> > |  | 67375 | struct PyOpenCV_Converter< Ptr<cv::linemod::ColorGradient> >
| 67424 | { |  | 67376 | {
| 67425 | static PyObject* from(const Ptr<cv::linemod::ColorGradient>& r) |  | 67377 | static PyObject* from(const Ptr<cv::linemod::ColorGradient>& r)
| 67426 | { |  | 67378 | {
| 67427 | return pyopencv_linemod_ColorGradient_Instance(r); |  | 67379 | return pyopencv_linemod_ColorGradient_Instance(r);
| 67428 | } |  | 67380 | }
| 67429 | static bool to(PyObject* src, Ptr<cv::linemod::ColorGradient>& dst, const ArgInfo& info) |  | 67381 | static bool to(PyObject* src, Ptr<cv::linemod::ColorGradient>& dst, const ArgInfo& info)
| 67430 | { |  | 67382 | {
| 67431 | if(!src || src == Py_None) |  | 67383 | if(!src || src == Py_None)
| 67432 | return true; |  | 67384 | return true;
| 67433 | Ptr<cv::linemod::ColorGradient> * dst_; |  | 67385 | Ptr<cv::linemod::ColorGradient> * dst_;
| 67434 | if (pyopencv_linemod_ColorGradient_getp(src, dst_)) |  | 67386 | if (pyopencv_linemod_ColorGradient_getp(src, dst_))
| 67435 | { |  | 67387 | {
| 67436 | dst = *dst_; |  | 67388 | dst = *dst_;
| 67437 | return true; |  | 67389 | return true;
| 67438 | } |  | 67390 | }
| 67439 |  |  | 67391 |
| 67440 | failmsg("Expected Ptr<cv::linemod::ColorGradient> for argument '%s'", info.name); |  | 67392 | failmsg("Expected Ptr<cv::linemod::ColorGradient> for argument '%s'", info.name);
| 67441 | return false; |  | 67393 | return false;
| 67442 | } |  | 67394 | }
| 67443 | }; |  | 67395 | };
| 67444 |  |  | 67396 |
| 67445 | //================================================================================ |  | 67397 | //================================================================================
| 67446 | // linemod_DepthNormal (Generic) |  | 67398 | // linemod_DepthNormal (Generic)
| 67447 | //================================================================================ |  | 67399 | //================================================================================
| 67448 |  |  | 67400 |
| 67449 | // GetSet (linemod_DepthNormal) |  | 67401 | // GetSet (linemod_DepthNormal)
| 67450 |  |  | 67402 |
| 67451 |  |  | 67403 |
| 67452 | static PyObject* pyopencv_linemod_DepthNormal_get_difference_threshold(pyopencv_linemod_DepthNormal_t* p, void *closure) |  | 67404 | static PyObject* pyopencv_linemod_DepthNormal_get_difference_threshold(pyopencv_linemod_DepthNormal_t* p, void *closure)
| 67453 | { |  | 67405 | {
| 67454 | return pyopencv_from(p->v->difference_threshold); |  | 67406 | return pyopencv_from(p->v->difference_threshold);
| 67455 | } |  | 67407 | }
| 67456 |  |  | 67408 |
| 67457 | static PyObject* pyopencv_linemod_DepthNormal_get_distance_threshold(pyopencv_linemod_DepthNormal_t* p, void *closure) |  | 67409 | static PyObject* pyopencv_linemod_DepthNormal_get_distance_threshold(pyopencv_linemod_DepthNormal_t* p, void *closure)
| 67458 | { |  | 67410 | {
| 67459 | return pyopencv_from(p->v->distance_threshold); |  | 67411 | return pyopencv_from(p->v->distance_threshold);
| 67460 | } |  | 67412 | }
| 67461 |  |  | 67413 |
| 67462 | static PyObject* pyopencv_linemod_DepthNormal_get_extract_threshold(pyopencv_linemod_DepthNormal_t* p, void *closure) |  | 67414 | static PyObject* pyopencv_linemod_DepthNormal_get_extract_threshold(pyopencv_linemod_DepthNormal_t* p, void *closure)
| 67463 | { |  | 67415 | {
| 67464 | return pyopencv_from(p->v->extract_threshold); |  | 67416 | return pyopencv_from(p->v->extract_threshold);
| 67465 | } |  | 67417 | }
| 67466 |  |  | 67418 |
| 67467 | static PyObject* pyopencv_linemod_DepthNormal_get_num_features(pyopencv_linemod_DepthNormal_t* p, void *closure) |  | 67419 | static PyObject* pyopencv_linemod_DepthNormal_get_num_features(pyopencv_linemod_DepthNormal_t* p, void *closure)
| 67468 | { |  | 67420 | {
| 67469 | return pyopencv_from(p->v->num_features); |  | 67421 | return pyopencv_from(p->v->num_features);
| 67470 | } |  | 67422 | }
| 67471 |  |  | 67423 |
| 67472 |  |  | 67424 |
| 67473 | // Methods (linemod_DepthNormal) |  | 67425 | // Methods (linemod_DepthNormal)
| 67474 |  |  | 67426 |
| 67475 | static PyObject* pyopencv_cv_linemod_linemod_DepthNormal_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67427 | static PyObject* pyopencv_cv_linemod_linemod_DepthNormal_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 67476 | { |  | 67428 | {
| 67477 | using namespace cv::linemod; |  | 67429 | using namespace cv::linemod;
| 67478 |  |  | 67430 |
| 67479 | PyObject* pyobj_distance_threshold = NULL; |  | 67431 | PyObject* pyobj_distance_threshold = NULL;
| 67480 | int distance_threshold=0; |  | 67432 | int distance_threshold=0;
| 67481 | PyObject* pyobj_difference_threshold = NULL; |  | 67433 | PyObject* pyobj_difference_threshold = NULL;
| 67482 | int difference_threshold=0; |  | 67434 | int difference_threshold=0;
| 67483 | PyObject* pyobj_num_features = NULL; |  | 67435 | PyObject* pyobj_num_features = NULL;
| 67484 | size_t num_features=0; |  | 67436 | size_t num_features=0;
| 67485 | PyObject* pyobj_extract_threshold = NULL; |  | 67437 | PyObject* pyobj_extract_threshold = NULL;
| 67486 | int extract_threshold=0; |  | 67438 | int extract_threshold=0;
| 67487 | Ptr<DepthNormal> retval; |  | 67439 | Ptr<DepthNormal> retval;
| 67488 |  |  | 67440 |
| 67489 | const char* keywords[] = { "distance_threshold", "difference_threshold", "num_features", "extract_threshold", NULL }; |  | 67441 | const char* keywords[] = { "distance_threshold", "difference_threshold", "num_features", "extract_threshold", NULL };
| 67490 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:linemod_DepthNormal.create", (char**)keywords, &pyobj_distance_threshold, &pyobj_difference_threshold, &pyobj_num_features, &pyobj_extract_threshold) && |  | 67442 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO:linemod_DepthNormal.create", (char**)keywords, &pyobj_distance_threshold, &pyobj_difference_threshold, &pyobj_num_features, &pyobj_extract_threshold) &&
| 67491 | pyopencv_to_safe(pyobj_distance_threshold, distance_threshold, ArgInfo("distance_threshold", 0)) && |  | 67443 | pyopencv_to_safe(pyobj_distance_threshold, distance_threshold, ArgInfo("distance_threshold", 0)) &&
| 67492 | pyopencv_to_safe(pyobj_difference_threshold, difference_threshold, ArgInfo("difference_threshold", 0)) && |  | 67444 | pyopencv_to_safe(pyobj_difference_threshold, difference_threshold, ArgInfo("difference_threshold", 0)) &&
| 67493 | pyopencv_to_safe(pyobj_num_features, num_features, ArgInfo("num_features", 0)) && |  | 67445 | pyopencv_to_safe(pyobj_num_features, num_features, ArgInfo("num_features", 0)) &&
| 67494 | pyopencv_to_safe(pyobj_extract_threshold, extract_threshold, ArgInfo("extract_threshold", 0)) ) |  | 67446 | pyopencv_to_safe(pyobj_extract_threshold, extract_threshold, ArgInfo("extract_threshold", 0)) )
| 67495 | { |  | 67447 | {
| 67496 | ERRWRAP2(retval = cv::linemod::DepthNormal::create(distance_threshold, difference_threshold, num_features, extract_threshold)); |  | 67448 | ERRWRAP2(retval = cv::linemod::DepthNormal::create(distance_threshold, difference_threshold, num_features, extract_threshold));
| 67497 | return pyopencv_from(retval); |  | 67449 | return pyopencv_from(retval);
| 67498 | } |  | 67450 | }
| 67499 |  |  | 67451 |
| 67500 | return NULL; |  | 67452 | return NULL;
| 67501 | } |  | 67453 | }
| 67502 |  |  | 67454 |
| 67503 |  |  | 67455 |
| 67504 |  |  | 67456 |
| 67505 | // Tables (linemod_DepthNormal) |  | 67457 | // Tables (linemod_DepthNormal)
| 67506 |  |  | 67458 |
| 67507 | static PyGetSetDef pyopencv_linemod_DepthNormal_getseters[] = |  | 67459 | static PyGetSetDef pyopencv_linemod_DepthNormal_getseters[] =
| 67508 | { |  | 67460 | {
| 67509 | {(char*)"difference_threshold", (getter)pyopencv_linemod_DepthNormal_get_difference_threshold, NULL, (char*)"difference_threshold", NULL}, |  | 67461 | {(char*)"difference_threshold", (getter)pyopencv_linemod_DepthNormal_get_difference_threshold, NULL, (char*)"difference_threshold", NULL},
| 67510 | {(char*)"distance_threshold", (getter)pyopencv_linemod_DepthNormal_get_distance_threshold, NULL, (char*)"distance_threshold", NULL}, |  | 67462 | {(char*)"distance_threshold", (getter)pyopencv_linemod_DepthNormal_get_distance_threshold, NULL, (char*)"distance_threshold", NULL},
| 67511 | {(char*)"extract_threshold", (getter)pyopencv_linemod_DepthNormal_get_extract_threshold, NULL, (char*)"extract_threshold", NULL}, |  | 67463 | {(char*)"extract_threshold", (getter)pyopencv_linemod_DepthNormal_get_extract_threshold, NULL, (char*)"extract_threshold", NULL},
| 67512 | {(char*)"num_features", (getter)pyopencv_linemod_DepthNormal_get_num_features, NULL, (char*)"num_features", NULL}, |  | 67464 | {(char*)"num_features", (getter)pyopencv_linemod_DepthNormal_get_num_features, NULL, (char*)"num_features", NULL},
| 67513 | {NULL} /* Sentinel */ |  | 67465 | {NULL} /* Sentinel */
| 67514 | }; |  | 67466 | };
| 67515 |  |  | 67467 |
| 67516 | static PyMethodDef pyopencv_linemod_DepthNormal_methods[] = |  | 67468 | static PyMethodDef pyopencv_linemod_DepthNormal_methods[] =
| 67517 | { |  | 67469 | {
| 67518 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_DepthNormal_create_static, METH_STATIC), "create(distance_threshold, difference_threshold, num_features, extract_threshold) -> retval\n. * \\brief Constructor.\n. *\n. * \\param distance_threshold Ignore pixels beyond this distance.\n. * \\param difference_threshold When computing normals, ignore contributions of pixels whose\n. * depth difference with the central pixel is above this threshold.\n. * \\param num_features How many features a template must contain.\n. * \\param extract_threshold Consider as candidate feature only if there are no differing\n. * orientations within a distance of extract_threshold."}, |  | 67470 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_DepthNormal_create_static, METH_STATIC), "create(distance_threshold, difference_threshold, num_features, extract_threshold) -> retval\n. * \\brief Constructor.\n. *\n. * \\param distance_threshold Ignore pixels beyond this distance.\n. * \\param difference_threshold When computing normals, ignore contributions of pixels whose\n. * depth difference with the central pixel is above this threshold.\n. * \\param num_features How many features a template must contain.\n. * \\param extract_threshold Consider as candidate feature only if there are no differing\n. * orientations within a distance of extract_threshold."},
| 67519 |  |  | 67471 |
| 67520 | {NULL, NULL} |  | 67472 | {NULL, NULL}
| 67521 | }; |  | 67473 | };
| 67522 |  |  | 67474 |
| 67523 | // Converter (linemod_DepthNormal) |  | 67475 | // Converter (linemod_DepthNormal)
| 67524 |  |  | 67476 |
| 67525 | template<> |  | 67477 | template<>
| 67526 | struct PyOpenCV_Converter< Ptr<cv::linemod::DepthNormal> > |  | 67478 | struct PyOpenCV_Converter< Ptr<cv::linemod::DepthNormal> >
| 67527 | { |  | 67479 | {
| 67528 | static PyObject* from(const Ptr<cv::linemod::DepthNormal>& r) |  | 67480 | static PyObject* from(const Ptr<cv::linemod::DepthNormal>& r)
| 67529 | { |  | 67481 | {
| 67530 | return pyopencv_linemod_DepthNormal_Instance(r); |  | 67482 | return pyopencv_linemod_DepthNormal_Instance(r);
| 67531 | } |  | 67483 | }
| 67532 | static bool to(PyObject* src, Ptr<cv::linemod::DepthNormal>& dst, const ArgInfo& info) |  | 67484 | static bool to(PyObject* src, Ptr<cv::linemod::DepthNormal>& dst, const ArgInfo& info)
| 67533 | { |  | 67485 | {
| 67534 | if(!src || src == Py_None) |  | 67486 | if(!src || src == Py_None)
| 67535 | return true; |  | 67487 | return true;
| 67536 | Ptr<cv::linemod::DepthNormal> * dst_; |  | 67488 | Ptr<cv::linemod::DepthNormal> * dst_;
| 67537 | if (pyopencv_linemod_DepthNormal_getp(src, dst_)) |  | 67489 | if (pyopencv_linemod_DepthNormal_getp(src, dst_))
| 67538 | { |  | 67490 | {
| 67539 | dst = *dst_; |  | 67491 | dst = *dst_;
| 67540 | return true; |  | 67492 | return true;
| 67541 | } |  | 67493 | }
| 67542 |  |  | 67494 |
| 67543 | failmsg("Expected Ptr<cv::linemod::DepthNormal> for argument '%s'", info.name); |  | 67495 | failmsg("Expected Ptr<cv::linemod::DepthNormal> for argument '%s'", info.name);
| 67544 | return false; |  | 67496 | return false;
| 67545 | } |  | 67497 | }
| 67546 | }; |  | 67498 | };
| 67547 |  |  | 67499 |
| 67548 | //================================================================================ |  | 67500 | //================================================================================
| 67549 | // linemod_Detector (Generic) |  | 67501 | // linemod_Detector (Generic)
| 67550 | //================================================================================ |  | 67502 | //================================================================================
| 67551 |  |  | 67503 |
| 67552 | // GetSet (linemod_Detector) |  | 67504 | // GetSet (linemod_Detector)
| 67553 |  |  | 67505 |
| 67554 |  |  | 67506 |
| 67555 |  |  | 67507 |
| 67556 | // Methods (linemod_Detector) |  | 67508 | // Methods (linemod_Detector)
| 67557 |  |  | 67509 |
| 67558 | static int pyopencv_cv_linemod_linemod_Detector_Detector(pyopencv_linemod_Detector_t* self, PyObject* py_args, PyObject* kw) |  | 67510 | static int pyopencv_cv_linemod_linemod_Detector_Detector(pyopencv_linemod_Detector_t* self, PyObject* py_args, PyObject* kw)
| 67559 | { |  | 67511 | {
| 67560 | using namespace cv::linemod; |  | 67512 | using namespace cv::linemod;
| 67561 |  |  | 67513 |
| 67562 | pyPrepareArgumentConversionErrorsStorage(2); |  | 67514 | pyPrepareArgumentConversionErrorsStorage(2);
| 67563 |  |  | 67515 |
| 67564 | { |  | 67516 | {
| 67565 |  |  | 67517 |
| 67566 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 67518 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67567 | { |  | 67519 | {
| 67568 | new (&(self->v)) Ptr<cv::linemod::Detector>(); // init Ptr with placement new |  | 67520 | new (&(self->v)) Ptr<cv::linemod::Detector>(); // init Ptr with placement new
| 67569 | if(self) ERRWRAP2(self->v.reset(new cv::linemod::Detector())); |  | 67521 | if(self) ERRWRAP2(self->v.reset(new cv::linemod::Detector()));
| 67570 | return 0; |  | 67522 | return 0;
| 67571 | } |  | 67523 | }
| 67572 |  |  | 67524 |
| 67573 |  |  | 67525 |
| 67574 | pyPopulateArgumentConversionErrors(); |  | 67526 | pyPopulateArgumentConversionErrors();
| 67575 | } |  | 67527 | }
| 67576 |  |  | 67528 |
| 67577 |  |  | 67529 |
| 67578 | { |  | 67530 | {
| 67579 | PyObject* pyobj_modalities = NULL; |  | 67531 | PyObject* pyobj_modalities = NULL;
| 67580 | vector_Ptr_Modality modalities; |  | 67532 | vector_Ptr_Modality modalities;
| 67581 | PyObject* pyobj_T_pyramid = NULL; |  | 67533 | PyObject* pyobj_T_pyramid = NULL;
| 67582 | vector_int T_pyramid; |  | 67534 | vector_int T_pyramid;
| 67583 |  |  | 67535 |
| 67584 | const char* keywords[] = { "modalities", "T_pyramid", NULL }; |  | 67536 | const char* keywords[] = { "modalities", "T_pyramid", NULL };
| 67585 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Detector", (char**)keywords, &pyobj_modalities, &pyobj_T_pyramid) && |  | 67537 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:Detector", (char**)keywords, &pyobj_modalities, &pyobj_T_pyramid) &&
| 67586 | pyopencv_to_safe(pyobj_modalities, modalities, ArgInfo("modalities", 0)) && |  | 67538 | pyopencv_to_safe(pyobj_modalities, modalities, ArgInfo("modalities", 0)) &&
| 67587 | pyopencv_to_safe(pyobj_T_pyramid, T_pyramid, ArgInfo("T_pyramid", 0)) ) |  | 67539 | pyopencv_to_safe(pyobj_T_pyramid, T_pyramid, ArgInfo("T_pyramid", 0)) )
| 67588 | { |  | 67540 | {
| 67589 | new (&(self->v)) Ptr<cv::linemod::Detector>(); // init Ptr with placement new |  | 67541 | new (&(self->v)) Ptr<cv::linemod::Detector>(); // init Ptr with placement new
| 67590 | if(self) ERRWRAP2(self->v.reset(new cv::linemod::Detector(modalities, T_pyramid))); |  | 67542 | if(self) ERRWRAP2(self->v.reset(new cv::linemod::Detector(modalities, T_pyramid)));
| 67591 | return 0; |  | 67543 | return 0;
| 67592 | } |  | 67544 | }
| 67593 |  |  | 67545 |
| 67594 |  |  | 67546 |
| 67595 | pyPopulateArgumentConversionErrors(); |  | 67547 | pyPopulateArgumentConversionErrors();
| 67596 | } |  | 67548 | }
| 67597 | pyRaiseCVOverloadException("Detector"); |  | 67549 | pyRaiseCVOverloadException("Detector");
| 67598 |  |  | 67550 |
| 67599 | return -1; |  | 67551 | return -1;
| 67600 | } |  | 67552 | }
| 67601 |  |  | 67553 |
| 67602 | static PyObject* pyopencv_cv_linemod_linemod_Detector_addSyntheticTemplate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67554 | static PyObject* pyopencv_cv_linemod_linemod_Detector_addSyntheticTemplate(PyObject* self, PyObject* py_args, PyObject* kw)
| 67603 | { |  | 67555 | {
| 67604 | using namespace cv::linemod; |  | 67556 | using namespace cv::linemod;
| 67605 |  |  | 67557 |
| 67606 |  |  | 67558 |
| 67607 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67559 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67608 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67560 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67609 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67561 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67610 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67562 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67611 | PyObject* pyobj_templates = NULL; |  | 67563 | PyObject* pyobj_templates = NULL;
| 67612 | vector_Template templates; |  | 67564 | vector_Template templates;
| 67613 | PyObject* pyobj_class_id = NULL; |  | 67565 | PyObject* pyobj_class_id = NULL;
| 67614 | String class_id; |  | 67566 | String class_id;
| 67615 | int retval; |  | 67567 | int retval;
| 67616 |  |  | 67568 |
| 67617 | const char* keywords[] = { "templates", "class_id", NULL }; |  | 67569 | const char* keywords[] = { "templates", "class_id", NULL };
| 67618 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:linemod_Detector.addSyntheticTemplate", (char**)keywords, &pyobj_templates, &pyobj_class_id) && |  | 67570 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:linemod_Detector.addSyntheticTemplate", (char**)keywords, &pyobj_templates, &pyobj_class_id) &&
| 67619 | pyopencv_to_safe(pyobj_templates, templates, ArgInfo("templates", 0)) && |  | 67571 | pyopencv_to_safe(pyobj_templates, templates, ArgInfo("templates", 0)) &&
| 67620 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) ) |  | 67572 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) )
| 67621 | { |  | 67573 | {
| 67622 | ERRWRAP2(retval = _self_->addSyntheticTemplate(templates, class_id)); |  | 67574 | ERRWRAP2(retval = _self_->addSyntheticTemplate(templates, class_id));
| 67623 | return pyopencv_from(retval); |  | 67575 | return pyopencv_from(retval);
| 67624 | } |  | 67576 | }
| 67625 |  |  | 67577 |
| 67626 | return NULL; |  | 67578 | return NULL;
| 67627 | } |  | 67579 | }
| 67628 |  |  | 67580 |
| 67629 | static PyObject* pyopencv_cv_linemod_linemod_Detector_addTemplate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67581 | static PyObject* pyopencv_cv_linemod_linemod_Detector_addTemplate(PyObject* self, PyObject* py_args, PyObject* kw)
| 67630 | { |  | 67582 | {
| 67631 | using namespace cv::linemod; |  | 67583 | using namespace cv::linemod;
| 67632 |  |  | 67584 |
| 67633 |  |  | 67585 |
| 67634 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67586 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67635 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67587 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67636 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67588 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67637 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67589 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67638 | PyObject* pyobj_sources = NULL; |  | 67590 | PyObject* pyobj_sources = NULL;
| 67639 | vector_Mat sources; |  | 67591 | vector_Mat sources;
| 67640 | PyObject* pyobj_class_id = NULL; |  | 67592 | PyObject* pyobj_class_id = NULL;
| 67641 | String class_id; |  | 67593 | String class_id;
| 67642 | PyObject* pyobj_object_mask = NULL; |  | 67594 | PyObject* pyobj_object_mask = NULL;
| 67643 | Mat object_mask; |  | 67595 | Mat object_mask;
| 67644 | Rect bounding_box; |  | 67596 | Rect bounding_box;
| 67645 | int retval; |  | 67597 | int retval;
| 67646 |  |  | 67598 |
| 67647 | const char* keywords[] = { "sources", "class_id", "object_mask", NULL }; |  | 67599 | const char* keywords[] = { "sources", "class_id", "object_mask", NULL };
| 67648 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:linemod_Detector.addTemplate", (char**)keywords, &pyobj_sources, &pyobj_class_id, &pyobj_object_mask) && |  | 67600 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:linemod_Detector.addTemplate", (char**)keywords, &pyobj_sources, &pyobj_class_id, &pyobj_object_mask) &&
| 67649 | pyopencv_to_safe(pyobj_sources, sources, ArgInfo("sources", 0)) && |  | 67601 | pyopencv_to_safe(pyobj_sources, sources, ArgInfo("sources", 0)) &&
| 67650 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) && |  | 67602 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) &&
| 67651 | pyopencv_to_safe(pyobj_object_mask, object_mask, ArgInfo("object_mask", 0)) ) |  | 67603 | pyopencv_to_safe(pyobj_object_mask, object_mask, ArgInfo("object_mask", 0)) )
| 67652 | { |  | 67604 | {
| 67653 | ERRWRAP2(retval = _self_->addTemplate(sources, class_id, object_mask, &bounding_box)); |  | 67605 | ERRWRAP2(retval = _self_->addTemplate(sources, class_id, object_mask, &bounding_box));
| 67654 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(bounding_box)); |  | 67606 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(bounding_box));
| 67655 | } |  | 67607 | }
| 67656 |  |  | 67608 |
| 67657 | return NULL; |  | 67609 | return NULL;
| 67658 | } |  | 67610 | }
| 67659 |  |  | 67611 |
| 67660 | static PyObject* pyopencv_cv_linemod_linemod_Detector_classIds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67612 | static PyObject* pyopencv_cv_linemod_linemod_Detector_classIds(PyObject* self, PyObject* py_args, PyObject* kw)
| 67661 | { |  | 67613 | {
| 67662 | using namespace cv::linemod; |  | 67614 | using namespace cv::linemod;
| 67663 |  |  | 67615 |
| 67664 |  |  | 67616 |
| 67665 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67617 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67666 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67618 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67667 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67619 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67668 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67620 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67669 | std::vector<String> retval; |  | 67621 | std::vector<String> retval;
| 67670 |  |  | 67622 |
| 67671 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 67623 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67672 | { |  | 67624 | {
| 67673 | ERRWRAP2(retval = _self_->classIds()); |  | 67625 | ERRWRAP2(retval = _self_->classIds());
| 67674 | return pyopencv_from(retval); |  | 67626 | return pyopencv_from(retval);
| 67675 | } |  | 67627 | }
| 67676 |  |  | 67628 |
| 67677 | return NULL; |  | 67629 | return NULL;
| 67678 | } |  | 67630 | }
| 67679 |  |  | 67631 |
| 67680 | static PyObject* pyopencv_cv_linemod_linemod_Detector_getModalities(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67632 | static PyObject* pyopencv_cv_linemod_linemod_Detector_getModalities(PyObject* self, PyObject* py_args, PyObject* kw)
| 67681 | { |  | 67633 | {
| 67682 | using namespace cv::linemod; |  | 67634 | using namespace cv::linemod;
| 67683 |  |  | 67635 |
| 67684 |  |  | 67636 |
| 67685 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67637 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67686 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67638 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67687 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67639 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67688 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67640 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67689 | std::vector< Ptr<Modality> > retval; |  | 67641 | std::vector< Ptr<Modality> > retval;
| 67690 |  |  | 67642 |
| 67691 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 67643 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67692 | { |  | 67644 | {
| 67693 | ERRWRAP2(retval = _self_->getModalities()); |  | 67645 | ERRWRAP2(retval = _self_->getModalities());
| 67694 | return pyopencv_from(retval); |  | 67646 | return pyopencv_from(retval);
| 67695 | } |  | 67647 | }
| 67696 |  |  | 67648 |
| 67697 | return NULL; |  | 67649 | return NULL;
| 67698 | } |  | 67650 | }
| 67699 |  |  | 67651 |
| 67700 | static PyObject* pyopencv_cv_linemod_linemod_Detector_getT(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67652 | static PyObject* pyopencv_cv_linemod_linemod_Detector_getT(PyObject* self, PyObject* py_args, PyObject* kw)
| 67701 | { |  | 67653 | {
| 67702 | using namespace cv::linemod; |  | 67654 | using namespace cv::linemod;
| 67703 |  |  | 67655 |
| 67704 |  |  | 67656 |
| 67705 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67657 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67706 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67658 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67707 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67659 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67708 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67660 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67709 | PyObject* pyobj_pyramid_level = NULL; |  | 67661 | PyObject* pyobj_pyramid_level = NULL;
| 67710 | int pyramid_level=0; |  | 67662 | int pyramid_level=0;
| 67711 | int retval; |  | 67663 | int retval;
| 67712 |  |  | 67664 |
| 67713 | const char* keywords[] = { "pyramid_level", NULL }; |  | 67665 | const char* keywords[] = { "pyramid_level", NULL };
| 67714 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Detector.getT", (char**)keywords, &pyobj_pyramid_level) && |  | 67666 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Detector.getT", (char**)keywords, &pyobj_pyramid_level) &&
| 67715 | pyopencv_to_safe(pyobj_pyramid_level, pyramid_level, ArgInfo("pyramid_level", 0)) ) |  | 67667 | pyopencv_to_safe(pyobj_pyramid_level, pyramid_level, ArgInfo("pyramid_level", 0)) )
| 67716 | { |  | 67668 | {
| 67717 | ERRWRAP2(retval = _self_->getT(pyramid_level)); |  | 67669 | ERRWRAP2(retval = _self_->getT(pyramid_level));
| 67718 | return pyopencv_from(retval); |  | 67670 | return pyopencv_from(retval);
| 67719 | } |  | 67671 | }
| 67720 |  |  | 67672 |
| 67721 | return NULL; |  | 67673 | return NULL;
| 67722 | } |  | 67674 | }
| 67723 |  |  | 67675 |
| 67724 | static PyObject* pyopencv_cv_linemod_linemod_Detector_getTemplates(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67676 | static PyObject* pyopencv_cv_linemod_linemod_Detector_getTemplates(PyObject* self, PyObject* py_args, PyObject* kw)
| 67725 | { |  | 67677 | {
| 67726 | using namespace cv::linemod; |  | 67678 | using namespace cv::linemod;
| 67727 |  |  | 67679 |
| 67728 |  |  | 67680 |
| 67729 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67681 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67730 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67682 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67731 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67683 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67732 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67684 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67733 | PyObject* pyobj_class_id = NULL; |  | 67685 | PyObject* pyobj_class_id = NULL;
| 67734 | String class_id; |  | 67686 | String class_id;
| 67735 | PyObject* pyobj_template_id = NULL; |  | 67687 | PyObject* pyobj_template_id = NULL;
| 67736 | int template_id=0; |  | 67688 | int template_id=0;
| 67737 | std::vector<Template> retval; |  | 67689 | std::vector<Template> retval;
| 67738 |  |  | 67690 |
| 67739 | const char* keywords[] = { "class_id", "template_id", NULL }; |  | 67691 | const char* keywords[] = { "class_id", "template_id", NULL };
| 67740 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:linemod_Detector.getTemplates", (char**)keywords, &pyobj_class_id, &pyobj_template_id) && |  | 67692 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:linemod_Detector.getTemplates", (char**)keywords, &pyobj_class_id, &pyobj_template_id) &&
| 67741 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) && |  | 67693 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) &&
| 67742 | pyopencv_to_safe(pyobj_template_id, template_id, ArgInfo("template_id", 0)) ) |  | 67694 | pyopencv_to_safe(pyobj_template_id, template_id, ArgInfo("template_id", 0)) )
| 67743 | { |  | 67695 | {
| 67744 | ERRWRAP2(retval = _self_->getTemplates(class_id, template_id)); |  | 67696 | ERRWRAP2(retval = _self_->getTemplates(class_id, template_id));
| 67745 | return pyopencv_from(retval); |  | 67697 | return pyopencv_from(retval);
| 67746 | } |  | 67698 | }
| 67747 |  |  | 67699 |
| 67748 | return NULL; |  | 67700 | return NULL;
| 67749 | } |  | 67701 | }
| 67750 |  |  | 67702 |
| 67751 | static PyObject* pyopencv_cv_linemod_linemod_Detector_match(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67703 | static PyObject* pyopencv_cv_linemod_linemod_Detector_match(PyObject* self, PyObject* py_args, PyObject* kw)
| 67752 | { |  | 67704 | {
| 67753 | using namespace cv::linemod; |  | 67705 | using namespace cv::linemod;
| 67754 |  |  | 67706 |
| 67755 |  |  | 67707 |
| 67756 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67708 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67757 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67709 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67758 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67710 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67759 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67711 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67760 | pyPrepareArgumentConversionErrorsStorage(2); |  | 67712 | pyPrepareArgumentConversionErrorsStorage(2);
| 67761 |  |  | 67713 |
| 67762 | { |  | 67714 | {
| 67763 | PyObject* pyobj_sources = NULL; |  | 67715 | PyObject* pyobj_sources = NULL;
| 67764 | vector_Mat sources; |  | 67716 | vector_Mat sources;
| 67765 | PyObject* pyobj_threshold = NULL; |  | 67717 | PyObject* pyobj_threshold = NULL;
| 67766 | float threshold=0.f; |  | 67718 | float threshold=0.f;
| 67767 | vector_Match matches; |  | 67719 | vector_Match matches;
| 67768 | PyObject* pyobj_class_ids = NULL; |  | 67720 | PyObject* pyobj_class_ids = NULL;
| 67769 | vector_String class_ids=std::vector<String>(); |  | 67721 | vector_String class_ids=std::vector<String>();
| 67770 | PyObject* pyobj_quantized_images = NULL; |  | 67722 | PyObject* pyobj_quantized_images = NULL;
| 67771 | vector_Mat quantized_images; |  | 67723 | vector_Mat quantized_images;
| 67772 | PyObject* pyobj_masks = NULL; |  | 67724 | PyObject* pyobj_masks = NULL;
| 67773 | vector_Mat masks=std::vector<Mat>(); |  | 67725 | vector_Mat masks=std::vector<Mat>();
| 67774 |  |  | 67726 |
| 67775 | const char* keywords[] = { "sources", "threshold", "class_ids", "quantized_images", "masks", NULL }; |  | 67727 | const char* keywords[] = { "sources", "threshold", "class_ids", "quantized_images", "masks", NULL };
| 67776 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:linemod_Detector.match", (char**)keywords, &pyobj_sources, &pyobj_threshold, &pyobj_class_ids, &pyobj_quantized_images, &pyobj_masks) && |  | 67728 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:linemod_Detector.match", (char**)keywords, &pyobj_sources, &pyobj_threshold, &pyobj_class_ids, &pyobj_quantized_images, &pyobj_masks) &&
| 67777 | pyopencv_to_safe(pyobj_sources, sources, ArgInfo("sources", 0)) && |  | 67729 | pyopencv_to_safe(pyobj_sources, sources, ArgInfo("sources", 0)) &&
| 67778 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) && |  | 67730 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) &&
| 67779 | pyopencv_to_safe(pyobj_class_ids, class_ids, ArgInfo("class_ids", 0)) && |  | 67731 | pyopencv_to_safe(pyobj_class_ids, class_ids, ArgInfo("class_ids", 0)) &&
| 67780 | pyopencv_to_safe(pyobj_quantized_images, quantized_images, ArgInfo("quantized_images", 1)) && |  | 67732 | pyopencv_to_safe(pyobj_quantized_images, quantized_images, ArgInfo("quantized_images", 1)) &&
| 67781 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 67733 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 67782 | { |  | 67734 | {
| 67783 | ERRWRAP2(_self_->match(sources, threshold, matches, class_ids, quantized_images, masks)); |  | 67735 | ERRWRAP2(_self_->match(sources, threshold, matches, class_ids, quantized_images, masks));
| 67784 | return Py_BuildValue("(NN)", pyopencv_from(matches), pyopencv_from(quantized_images)); |  | 67736 | return Py_BuildValue("(NN)", pyopencv_from(matches), pyopencv_from(quantized_images));
| 67785 | } |  | 67737 | }
| 67786 |  |  | 67738 |
| 67787 |  |  | 67739 |
| 67788 | pyPopulateArgumentConversionErrors(); |  | 67740 | pyPopulateArgumentConversionErrors();
| 67789 | } |  | 67741 | }
| 67790 |  |  | 67742 |
| 67791 |  |  | 67743 |
| 67792 | { |  | 67744 | {
| 67793 | PyObject* pyobj_sources = NULL; |  | 67745 | PyObject* pyobj_sources = NULL;
| 67794 | vector_Mat sources; |  | 67746 | vector_Mat sources;
| 67795 | PyObject* pyobj_threshold = NULL; |  | 67747 | PyObject* pyobj_threshold = NULL;
| 67796 | float threshold=0.f; |  | 67748 | float threshold=0.f;
| 67797 | vector_Match matches; |  | 67749 | vector_Match matches;
| 67798 | PyObject* pyobj_class_ids = NULL; |  | 67750 | PyObject* pyobj_class_ids = NULL;
| 67799 | vector_String class_ids=std::vector<String>(); |  | 67751 | vector_String class_ids=std::vector<String>();
| 67800 | PyObject* pyobj_quantized_images = NULL; |  | 67752 | PyObject* pyobj_quantized_images = NULL;
| 67801 | vector_UMat quantized_images; |  | 67753 | vector_UMat quantized_images;
| 67802 | PyObject* pyobj_masks = NULL; |  | 67754 | PyObject* pyobj_masks = NULL;
| 67803 | vector_Mat masks=std::vector<Mat>(); |  | 67755 | vector_Mat masks=std::vector<Mat>();
| 67804 |  |  | 67756 |
| 67805 | const char* keywords[] = { "sources", "threshold", "class_ids", "quantized_images", "masks", NULL }; |  | 67757 | const char* keywords[] = { "sources", "threshold", "class_ids", "quantized_images", "masks", NULL };
| 67806 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:linemod_Detector.match", (char**)keywords, &pyobj_sources, &pyobj_threshold, &pyobj_class_ids, &pyobj_quantized_images, &pyobj_masks) && |  | 67758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:linemod_Detector.match", (char**)keywords, &pyobj_sources, &pyobj_threshold, &pyobj_class_ids, &pyobj_quantized_images, &pyobj_masks) &&
| 67807 | pyopencv_to_safe(pyobj_sources, sources, ArgInfo("sources", 0)) && |  | 67759 | pyopencv_to_safe(pyobj_sources, sources, ArgInfo("sources", 0)) &&
| 67808 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) && |  | 67760 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) &&
| 67809 | pyopencv_to_safe(pyobj_class_ids, class_ids, ArgInfo("class_ids", 0)) && |  | 67761 | pyopencv_to_safe(pyobj_class_ids, class_ids, ArgInfo("class_ids", 0)) &&
| 67810 | pyopencv_to_safe(pyobj_quantized_images, quantized_images, ArgInfo("quantized_images", 1)) && |  | 67762 | pyopencv_to_safe(pyobj_quantized_images, quantized_images, ArgInfo("quantized_images", 1)) &&
| 67811 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) ) |  | 67763 | pyopencv_to_safe(pyobj_masks, masks, ArgInfo("masks", 0)) )
| 67812 | { |  | 67764 | {
| 67813 | ERRWRAP2(_self_->match(sources, threshold, matches, class_ids, quantized_images, masks)); |  | 67765 | ERRWRAP2(_self_->match(sources, threshold, matches, class_ids, quantized_images, masks));
| 67814 | return Py_BuildValue("(NN)", pyopencv_from(matches), pyopencv_from(quantized_images)); |  | 67766 | return Py_BuildValue("(NN)", pyopencv_from(matches), pyopencv_from(quantized_images));
| 67815 | } |  | 67767 | }
| 67816 |  |  | 67768 |
| 67817 |  |  | 67769 |
| 67818 | pyPopulateArgumentConversionErrors(); |  | 67770 | pyPopulateArgumentConversionErrors();
| 67819 | } |  | 67771 | }
| 67820 | pyRaiseCVOverloadException("match"); |  | 67772 | pyRaiseCVOverloadException("match");
| 67821 |  |  | 67773 |
| 67822 | return NULL; |  | 67774 | return NULL;
| 67823 | } |  | 67775 | }
| 67824 |  |  | 67776 |
| 67825 | static PyObject* pyopencv_cv_linemod_linemod_Detector_numClasses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67777 | static PyObject* pyopencv_cv_linemod_linemod_Detector_numClasses(PyObject* self, PyObject* py_args, PyObject* kw)
| 67826 | { |  | 67778 | {
| 67827 | using namespace cv::linemod; |  | 67779 | using namespace cv::linemod;
| 67828 |  |  | 67780 |
| 67829 |  |  | 67781 |
| 67830 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67782 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67831 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67783 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67832 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67784 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67833 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67785 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67834 | int retval; |  | 67786 | int retval;
| 67835 |  |  | 67787 |
| 67836 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 67788 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67837 | { |  | 67789 | {
| 67838 | ERRWRAP2(retval = _self_->numClasses()); |  | 67790 | ERRWRAP2(retval = _self_->numClasses());
| 67839 | return pyopencv_from(retval); |  | 67791 | return pyopencv_from(retval);
| 67840 | } |  | 67792 | }
| 67841 |  |  | 67793 |
| 67842 | return NULL; |  | 67794 | return NULL;
| 67843 | } |  | 67795 | }
| 67844 |  |  | 67796 |
| 67845 | static PyObject* pyopencv_cv_linemod_linemod_Detector_numTemplates(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67797 | static PyObject* pyopencv_cv_linemod_linemod_Detector_numTemplates(PyObject* self, PyObject* py_args, PyObject* kw)
| 67846 | { |  | 67798 | {
| 67847 | using namespace cv::linemod; |  | 67799 | using namespace cv::linemod;
| 67848 |  |  | 67800 |
| 67849 |  |  | 67801 |
| 67850 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67802 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67851 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67803 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67852 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67804 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67853 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67805 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67854 | pyPrepareArgumentConversionErrorsStorage(2); |  | 67806 | pyPrepareArgumentConversionErrorsStorage(2);
| 67855 |  |  | 67807 |
| 67856 | { |  | 67808 | {
| 67857 | int retval; |  | 67809 | int retval;
| 67858 |  |  | 67810 |
| 67859 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 67811 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67860 | { |  | 67812 | {
| 67861 | ERRWRAP2(retval = _self_->numTemplates()); |  | 67813 | ERRWRAP2(retval = _self_->numTemplates());
| 67862 | return pyopencv_from(retval); |  | 67814 | return pyopencv_from(retval);
| 67863 | } |  | 67815 | }
| 67864 |  |  | 67816 |
| 67865 |  |  | 67817 |
| 67866 | pyPopulateArgumentConversionErrors(); |  | 67818 | pyPopulateArgumentConversionErrors();
| 67867 | } |  | 67819 | }
| 67868 |  |  | 67820 |
| 67869 |  |  | 67821 |
| 67870 | { |  | 67822 | {
| 67871 | PyObject* pyobj_class_id = NULL; |  | 67823 | PyObject* pyobj_class_id = NULL;
| 67872 | String class_id; |  | 67824 | String class_id;
| 67873 | int retval; |  | 67825 | int retval;
| 67874 |  |  | 67826 |
| 67875 | const char* keywords[] = { "class_id", NULL }; |  | 67827 | const char* keywords[] = { "class_id", NULL };
| 67876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Detector.numTemplates", (char**)keywords, &pyobj_class_id) && |  | 67828 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Detector.numTemplates", (char**)keywords, &pyobj_class_id) &&
| 67877 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) ) |  | 67829 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) )
| 67878 | { |  | 67830 | {
| 67879 | ERRWRAP2(retval = _self_->numTemplates(class_id)); |  | 67831 | ERRWRAP2(retval = _self_->numTemplates(class_id));
| 67880 | return pyopencv_from(retval); |  | 67832 | return pyopencv_from(retval);
| 67881 | } |  | 67833 | }
| 67882 |  |  | 67834 |
| 67883 |  |  | 67835 |
| 67884 | pyPopulateArgumentConversionErrors(); |  | 67836 | pyPopulateArgumentConversionErrors();
| 67885 | } |  | 67837 | }
| 67886 | pyRaiseCVOverloadException("numTemplates"); |  | 67838 | pyRaiseCVOverloadException("numTemplates");
| 67887 |  |  | 67839 |
| 67888 | return NULL; |  | 67840 | return NULL;
| 67889 | } |  | 67841 | }
| 67890 |  |  | 67842 |
| 67891 | static PyObject* pyopencv_cv_linemod_linemod_Detector_pyramidLevels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67843 | static PyObject* pyopencv_cv_linemod_linemod_Detector_pyramidLevels(PyObject* self, PyObject* py_args, PyObject* kw)
| 67892 | { |  | 67844 | {
| 67893 | using namespace cv::linemod; |  | 67845 | using namespace cv::linemod;
| 67894 |  |  | 67846 |
| 67895 |  |  | 67847 |
| 67896 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67848 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67897 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67849 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67898 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67850 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67899 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67851 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67900 | int retval; |  | 67852 | int retval;
| 67901 |  |  | 67853 |
| 67902 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 67854 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 67903 | { |  | 67855 | {
| 67904 | ERRWRAP2(retval = _self_->pyramidLevels()); |  | 67856 | ERRWRAP2(retval = _self_->pyramidLevels());
| 67905 | return pyopencv_from(retval); |  | 67857 | return pyopencv_from(retval);
| 67906 | } |  | 67858 | }
| 67907 |  |  | 67859 |
| 67908 | return NULL; |  | 67860 | return NULL;
| 67909 | } |  | 67861 | }
| 67910 |  |  | 67862 |
| 67911 | static PyObject* pyopencv_cv_linemod_linemod_Detector_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67863 | static PyObject* pyopencv_cv_linemod_linemod_Detector_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 67912 | { |  | 67864 | {
| 67913 | using namespace cv::linemod; |  | 67865 | using namespace cv::linemod;
| 67914 |  |  | 67866 |
| 67915 |  |  | 67867 |
| 67916 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67868 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67917 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67869 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67918 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67870 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67919 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67871 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67920 | PyObject* pyobj_fn = NULL; |  | 67872 | PyObject* pyobj_fn = NULL;
| 67921 | cv::FileNode fn; |  | 67873 | cv::FileNode fn;
| 67922 |  |  | 67874 |
| 67923 | const char* keywords[] = { "fn", NULL }; |  | 67875 | const char* keywords[] = { "fn", NULL };
| 67924 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Detector.read", (char**)keywords, &pyobj_fn) && |  | 67876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Detector.read", (char**)keywords, &pyobj_fn) &&
| 67925 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 67877 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 67926 | { |  | 67878 | {
| 67927 | ERRWRAP2(_self_->read(fn)); |  | 67879 | ERRWRAP2(_self_->read(fn));
| 67928 | Py_RETURN_NONE; |  | 67880 | Py_RETURN_NONE;
| 67929 | } |  | 67881 | }
| 67930 |  |  | 67882 |
| 67931 | return NULL; |  | 67883 | return NULL;
| 67932 | } |  | 67884 | }
| 67933 |  |  | 67885 |
| 67934 | static PyObject* pyopencv_cv_linemod_linemod_Detector_readClasses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67886 | static PyObject* pyopencv_cv_linemod_linemod_Detector_readClasses(PyObject* self, PyObject* py_args, PyObject* kw)
| 67935 | { |  | 67887 | {
| 67936 | using namespace cv::linemod; |  | 67888 | using namespace cv::linemod;
| 67937 |  |  | 67889 |
| 67938 |  |  | 67890 |
| 67939 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67891 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67940 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67892 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67941 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67893 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67942 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67894 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67943 | PyObject* pyobj_class_ids = NULL; |  | 67895 | PyObject* pyobj_class_ids = NULL;
| 67944 | vector_String class_ids; |  | 67896 | vector_String class_ids;
| 67945 | PyObject* pyobj_format = NULL; |  | 67897 | PyObject* pyobj_format = NULL;
| 67946 | String format="templates_%s.yml.gz"; |  | 67898 | String format="templates_%s.yml.gz";
| 67947 |  |  | 67899 |
| 67948 | const char* keywords[] = { "class_ids", "format", NULL }; |  | 67900 | const char* keywords[] = { "class_ids", "format", NULL };
| 67949 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:linemod_Detector.readClasses", (char**)keywords, &pyobj_class_ids, &pyobj_format) && |  | 67901 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:linemod_Detector.readClasses", (char**)keywords, &pyobj_class_ids, &pyobj_format) &&
| 67950 | pyopencv_to_safe(pyobj_class_ids, class_ids, ArgInfo("class_ids", 0)) && |  | 67902 | pyopencv_to_safe(pyobj_class_ids, class_ids, ArgInfo("class_ids", 0)) &&
| 67951 | pyopencv_to_safe(pyobj_format, format, ArgInfo("format", 0)) ) |  | 67903 | pyopencv_to_safe(pyobj_format, format, ArgInfo("format", 0)) )
| 67952 | { |  | 67904 | {
| 67953 | ERRWRAP2(_self_->readClasses(class_ids, format)); |  | 67905 | ERRWRAP2(_self_->readClasses(class_ids, format));
| 67954 | Py_RETURN_NONE; |  | 67906 | Py_RETURN_NONE;
| 67955 | } |  | 67907 | }
| 67956 |  |  | 67908 |
| 67957 | return NULL; |  | 67909 | return NULL;
| 67958 | } |  | 67910 | }
| 67959 |  |  | 67911 |
| 67960 | static PyObject* pyopencv_cv_linemod_linemod_Detector_writeClasses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 67912 | static PyObject* pyopencv_cv_linemod_linemod_Detector_writeClasses(PyObject* self, PyObject* py_args, PyObject* kw)
| 67961 | { |  | 67913 | {
| 67962 | using namespace cv::linemod; |  | 67914 | using namespace cv::linemod;
| 67963 |  |  | 67915 |
| 67964 |  |  | 67916 |
| 67965 | Ptr<cv::linemod::Detector> * self1 = 0; |  | 67917 | Ptr<cv::linemod::Detector> * self1 = 0;
| 67966 | if (!pyopencv_linemod_Detector_getp(self, self1)) |  | 67918 | if (!pyopencv_linemod_Detector_getp(self, self1))
| 67967 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)"); |  | 67919 | return failmsgp("Incorrect type of self (must be 'linemod_Detector' or its derivative)");
| 67968 | Ptr<cv::linemod::Detector> _self_ = *(self1); |  | 67920 | Ptr<cv::linemod::Detector> _self_ = *(self1);
| 67969 | PyObject* pyobj_format = NULL; |  | 67921 | PyObject* pyobj_format = NULL;
| 67970 | String format="templates_%s.yml.gz"; |  | 67922 | String format="templates_%s.yml.gz";
| 67971 |  |  | 67923 |
| 67972 | const char* keywords[] = { "format", NULL }; |  | 67924 | const char* keywords[] = { "format", NULL };
| 67973 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:linemod_Detector.writeClasses", (char**)keywords, &pyobj_format) && |  | 67925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:linemod_Detector.writeClasses", (char**)keywords, &pyobj_format) &&
| 67974 | pyopencv_to_safe(pyobj_format, format, ArgInfo("format", 0)) ) |  | 67926 | pyopencv_to_safe(pyobj_format, format, ArgInfo("format", 0)) )
| 67975 | { |  | 67927 | {
| 67976 | ERRWRAP2(_self_->writeClasses(format)); |  | 67928 | ERRWRAP2(_self_->writeClasses(format));
| 67977 | Py_RETURN_NONE; |  | 67929 | Py_RETURN_NONE;
| 67978 | } |  | 67930 | }
| 67979 |  |  | 67931 |
| 67980 | return NULL; |  | 67932 | return NULL;
| 67981 | } |  | 67933 | }
| 67982 |  |  | 67934 |
| 67983 |  |  | 67935 |
| 67984 |  |  | 67936 |
| 67985 | // Tables (linemod_Detector) |  | 67937 | // Tables (linemod_Detector)
| 67986 |  |  | 67938 |
| 67987 | static PyGetSetDef pyopencv_linemod_Detector_getseters[] = |  | 67939 | static PyGetSetDef pyopencv_linemod_Detector_getseters[] =
| 67988 | { |  | 67940 | {
| 67989 | {NULL} /* Sentinel */ |  | 67941 | {NULL} /* Sentinel */
| 67990 | }; |  | 67942 | };
| 67991 |  |  | 67943 |
| 67992 | static PyMethodDef pyopencv_linemod_Detector_methods[] = |  | 67944 | static PyMethodDef pyopencv_linemod_Detector_methods[] =
| 67993 | { |  | 67945 | {
| 67994 | {"addSyntheticTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_addSyntheticTemplate, 0), "addSyntheticTemplate(templates, class_id) -> retval\n. * \\brief Add a new object template computed by external means."}, |  | 67946 | {"addSyntheticTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_addSyntheticTemplate, 0), "addSyntheticTemplate(templates, class_id) -> retval\n. * \\brief Add a new object template computed by external means."},
| 67995 | {"addTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_addTemplate, 0), "addTemplate(sources, class_id, object_mask) -> retval, bounding_box\n. * \\brief Add new object template.\n. *\n. * \\param sources Source images, one for each modality.\n. * \\param class_id Object class ID.\n. * \\param object_mask Mask separating object from background.\n. * \\param[out] bounding_box Optionally return bounding box of the extracted features.\n. *\n. * \\return Template ID, or -1 if failed to extract a valid template."}, |  | 67947 | {"addTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_addTemplate, 0), "addTemplate(sources, class_id, object_mask) -> retval, bounding_box\n. * \\brief Add new object template.\n. *\n. * \\param sources Source images, one for each modality.\n. * \\param class_id Object class ID.\n. * \\param object_mask Mask separating object from background.\n. * \\param[out] bounding_box Optionally return bounding box of the extracted features.\n. *\n. * \\return Template ID, or -1 if failed to extract a valid template."},
| 67996 | {"classIds", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_classIds, 0), "classIds() -> retval\n."}, |  | 67948 | {"classIds", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_classIds, 0), "classIds() -> retval\n."},
| 67997 | {"getModalities", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_getModalities, 0), "getModalities() -> retval\n. * \\brief Get the modalities used by this detector.\n. *\n. * You are not permitted to add/remove modalities, but you may dynamic_cast them to\n. * tweak parameters."}, |  | 67949 | {"getModalities", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_getModalities, 0), "getModalities() -> retval\n. * \\brief Get the modalities used by this detector.\n. *\n. * You are not permitted to add/remove modalities, but you may dynamic_cast them to\n. * tweak parameters."},
| 67998 | {"getT", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_getT, 0), "getT(pyramid_level) -> retval\n. * \\brief Get sampling step T at pyramid_level."}, |  | 67950 | {"getT", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_getT, 0), "getT(pyramid_level) -> retval\n. * \\brief Get sampling step T at pyramid_level."},
| 67999 | {"getTemplates", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_getTemplates, 0), "getTemplates(class_id, template_id) -> retval\n. * \\brief Get the template pyramid identified by template_id.\n. *\n. * For example, with 2 modalities (Gradient, Normal) and two pyramid levels\n. * (L0, L1), the order is (GradientL0, NormalL0, GradientL1, NormalL1)."}, |  | 67951 | {"getTemplates", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_getTemplates, 0), "getTemplates(class_id, template_id) -> retval\n. * \\brief Get the template pyramid identified by template_id.\n. *\n. * For example, with 2 modalities (Gradient, Normal) and two pyramid levels\n. * (L0, L1), the order is (GradientL0, NormalL0, GradientL1, NormalL1)."},
| 68000 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_match, 0), "match(sources, threshold[, class_ids[, quantized_images[, masks]]]) -> matches, quantized_images\n. * \\brief Detect objects by template matching.\n. *\n. * Matches globally at the lowest pyramid level, then refines locally stepping up the pyramid.\n. *\n. * \\param sources Source images, one for each modality.\n. * \\param threshold Similarity threshold, a percentage between 0 and 100.\n. * \\param[out] matches Template matches, sorted by similarity score.\n. * \\param class_ids If non-empty, only search for the desired object classes.\n. * \\param[out] quantized_images Optionally return vector<Mat> of quantized images.\n. * \\param masks The masks for consideration during matching. The masks should be CV_8UC1\n. * where 255 represents a valid pixel. If non-empty, the vector must be\n. * the same size as sources. Each element must be\n. * empty or the same size as its corresponding source."}, |  | 67952 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_match, 0), "match(sources, threshold[, class_ids[, quantized_images[, masks]]]) -> matches, quantized_images\n. * \\brief Detect objects by template matching.\n. *\n. * Matches globally at the lowest pyramid level, then refines locally stepping up the pyramid.\n. *\n. * \\param sources Source images, one for each modality.\n. * \\param threshold Similarity threshold, a percentage between 0 and 100.\n. * \\param[out] matches Template matches, sorted by similarity score.\n. * \\param class_ids If non-empty, only search for the desired object classes.\n. * \\param[out] quantized_images Optionally return vector<Mat> of quantized images.\n. * \\param masks The masks for consideration during matching. The masks should be CV_8UC1\n. * where 255 represents a valid pixel. If non-empty, the vector must be\n. * the same size as sources. Each element must be\n. * empty or the same size as its corresponding source."},
| 68001 | {"numClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_numClasses, 0), "numClasses() -> retval\n."}, |  | 67953 | {"numClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_numClasses, 0), "numClasses() -> retval\n."},
| 68002 | {"numTemplates", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_numTemplates, 0), "numTemplates() -> retval\n. \n\n\n\nnumTemplates(class_id) -> retval\n."}, |  | 67954 | {"numTemplates", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_numTemplates, 0), "numTemplates() -> retval\n. \n\n\n\nnumTemplates(class_id) -> retval\n."},
| 68003 | {"pyramidLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_pyramidLevels, 0), "pyramidLevels() -> retval\n. * \\brief Get number of pyramid levels used by this detector."}, |  | 67955 | {"pyramidLevels", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_pyramidLevels, 0), "pyramidLevels() -> retval\n. * \\brief Get number of pyramid levels used by this detector."},
| 68004 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_read, 0), "read(fn) -> None\n."}, |  | 67956 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_read, 0), "read(fn) -> None\n."},
| 68005 | {"readClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_readClasses, 0), "readClasses(class_ids[, format]) -> None\n."}, |  | 67957 | {"readClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_readClasses, 0), "readClasses(class_ids[, format]) -> None\n."},
| 68006 | {"writeClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_writeClasses, 0), "writeClasses([, format]) -> None\n."}, |  | 67958 | {"writeClasses", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Detector_writeClasses, 0), "writeClasses([, format]) -> None\n."},
| 68007 |  |  | 67959 |
| 68008 | {NULL, NULL} |  | 67960 | {NULL, NULL}
| 68009 | }; |  | 67961 | };
| 68010 |  |  | 67962 |
| 68011 | // Converter (linemod_Detector) |  | 67963 | // Converter (linemod_Detector)
| 68012 |  |  | 67964 |
| 68013 | template<> |  | 67965 | template<>
| 68014 | struct PyOpenCV_Converter< Ptr<cv::linemod::Detector> > |  | 67966 | struct PyOpenCV_Converter< Ptr<cv::linemod::Detector> >
| 68015 | { |  | 67967 | {
| 68016 | static PyObject* from(const Ptr<cv::linemod::Detector>& r) |  | 67968 | static PyObject* from(const Ptr<cv::linemod::Detector>& r)
| 68017 | { |  | 67969 | {
| 68018 | return pyopencv_linemod_Detector_Instance(r); |  | 67970 | return pyopencv_linemod_Detector_Instance(r);
| 68019 | } |  | 67971 | }
| 68020 | static bool to(PyObject* src, Ptr<cv::linemod::Detector>& dst, const ArgInfo& info) |  | 67972 | static bool to(PyObject* src, Ptr<cv::linemod::Detector>& dst, const ArgInfo& info)
| 68021 | { |  | 67973 | {
| 68022 | if(!src || src == Py_None) |  | 67974 | if(!src || src == Py_None)
| 68023 | return true; |  | 67975 | return true;
| 68024 | Ptr<cv::linemod::Detector> * dst_; |  | 67976 | Ptr<cv::linemod::Detector> * dst_;
| 68025 | if (pyopencv_linemod_Detector_getp(src, dst_)) |  | 67977 | if (pyopencv_linemod_Detector_getp(src, dst_))
| 68026 | { |  | 67978 | {
| 68027 | dst = *dst_; |  | 67979 | dst = *dst_;
| 68028 | return true; |  | 67980 | return true;
| 68029 | } |  | 67981 | }
| 68030 |  |  | 67982 |
| 68031 | failmsg("Expected Ptr<cv::linemod::Detector> for argument '%s'", info.name); |  | 67983 | failmsg("Expected Ptr<cv::linemod::Detector> for argument '%s'", info.name);
| 68032 | return false; |  | 67984 | return false;
| 68033 | } |  | 67985 | }
| 68034 | }; |  | 67986 | };
| 68035 |  |  | 67987 |
| 68036 | //================================================================================ |  | 67988 | //================================================================================
| 68037 | // linemod_Feature (Generic) |  | 67989 | // linemod_Feature (Generic)
| 68038 | //================================================================================ |  | 67990 | //================================================================================
| 68039 |  |  | 67991 |
| 68040 | // GetSet (linemod_Feature) |  | 67992 | // GetSet (linemod_Feature)
| 68041 |  |  | 67993 |
| 68042 |  |  | 67994 |
| 68043 | static PyObject* pyopencv_linemod_Feature_get_label(pyopencv_linemod_Feature_t* p, void *closure) |  | 67995 | static PyObject* pyopencv_linemod_Feature_get_label(pyopencv_linemod_Feature_t* p, void *closure)
| 68044 | { |  | 67996 | {
| 68045 | return pyopencv_from(p->v.label); |  | 67997 | return pyopencv_from(p->v.label);
| 68046 | } |  | 67998 | }
| 68047 |  |  | 67999 |
| 68048 | static int pyopencv_linemod_Feature_set_label(pyopencv_linemod_Feature_t* p, PyObject *value, void *closure) |  | 68000 | static int pyopencv_linemod_Feature_set_label(pyopencv_linemod_Feature_t* p, PyObject *value, void *closure)
| 68049 | { |  | 68001 | {
| 68050 | if (!value) |  | 68002 | if (!value)
| 68051 | { |  | 68003 | {
| 68052 | PyErr_SetString(PyExc_TypeError, "Cannot delete the label attribute"); |  | 68004 | PyErr_SetString(PyExc_TypeError, "Cannot delete the label attribute");
| 68053 | return -1; |  | 68005 | return -1;
| 68054 | } |  | 68006 | }
| 68055 | return pyopencv_to_safe(value, p->v.label, ArgInfo("value", 0)) ? 0 : -1; |  | 68007 | return pyopencv_to_safe(value, p->v.label, ArgInfo("value", 0)) ? 0 : -1;
| 68056 | } |  | 68008 | }
| 68057 |  |  | 68009 |
| 68058 | static PyObject* pyopencv_linemod_Feature_get_x(pyopencv_linemod_Feature_t* p, void *closure) |  | 68010 | static PyObject* pyopencv_linemod_Feature_get_x(pyopencv_linemod_Feature_t* p, void *closure)
| 68059 | { |  | 68011 | {
| 68060 | return pyopencv_from(p->v.x); |  | 68012 | return pyopencv_from(p->v.x);
| 68061 | } |  | 68013 | }
| 68062 |  |  | 68014 |
| 68063 | static int pyopencv_linemod_Feature_set_x(pyopencv_linemod_Feature_t* p, PyObject *value, void *closure) |  | 68015 | static int pyopencv_linemod_Feature_set_x(pyopencv_linemod_Feature_t* p, PyObject *value, void *closure)
| 68064 | { |  | 68016 | {
| 68065 | if (!value) |  | 68017 | if (!value)
| 68066 | { |  | 68018 | {
| 68067 | PyErr_SetString(PyExc_TypeError, "Cannot delete the x attribute"); |  | 68019 | PyErr_SetString(PyExc_TypeError, "Cannot delete the x attribute");
| 68068 | return -1; |  | 68020 | return -1;
| 68069 | } |  | 68021 | }
| 68070 | return pyopencv_to_safe(value, p->v.x, ArgInfo("value", 0)) ? 0 : -1; |  | 68022 | return pyopencv_to_safe(value, p->v.x, ArgInfo("value", 0)) ? 0 : -1;
| 68071 | } |  | 68023 | }
| 68072 |  |  | 68024 |
| 68073 | static PyObject* pyopencv_linemod_Feature_get_y(pyopencv_linemod_Feature_t* p, void *closure) |  | 68025 | static PyObject* pyopencv_linemod_Feature_get_y(pyopencv_linemod_Feature_t* p, void *closure)
| 68074 | { |  | 68026 | {
| 68075 | return pyopencv_from(p->v.y); |  | 68027 | return pyopencv_from(p->v.y);
| 68076 | } |  | 68028 | }
| 68077 |  |  | 68029 |
| 68078 | static int pyopencv_linemod_Feature_set_y(pyopencv_linemod_Feature_t* p, PyObject *value, void *closure) |  | 68030 | static int pyopencv_linemod_Feature_set_y(pyopencv_linemod_Feature_t* p, PyObject *value, void *closure)
| 68079 | { |  | 68031 | {
| 68080 | if (!value) |  | 68032 | if (!value)
| 68081 | { |  | 68033 | {
| 68082 | PyErr_SetString(PyExc_TypeError, "Cannot delete the y attribute"); |  | 68034 | PyErr_SetString(PyExc_TypeError, "Cannot delete the y attribute");
| 68083 | return -1; |  | 68035 | return -1;
| 68084 | } |  | 68036 | }
| 68085 | return pyopencv_to_safe(value, p->v.y, ArgInfo("value", 0)) ? 0 : -1; |  | 68037 | return pyopencv_to_safe(value, p->v.y, ArgInfo("value", 0)) ? 0 : -1;
| 68086 | } |  | 68038 | }
| 68087 |  |  | 68039 |
| 68088 |  |  | 68040 |
| 68089 | // Methods (linemod_Feature) |  | 68041 | // Methods (linemod_Feature)
| 68090 |  |  | 68042 |
| 68091 | static int pyopencv_cv_linemod_linemod_Feature_Feature(pyopencv_linemod_Feature_t* self, PyObject* py_args, PyObject* kw) |  | 68043 | static int pyopencv_cv_linemod_linemod_Feature_Feature(pyopencv_linemod_Feature_t* self, PyObject* py_args, PyObject* kw)
| 68092 | { |  | 68044 | {
| 68093 | using namespace cv::linemod; |  | 68045 | using namespace cv::linemod;
| 68094 |  |  | 68046 |
| 68095 | pyPrepareArgumentConversionErrorsStorage(2); |  | 68047 | pyPrepareArgumentConversionErrorsStorage(2);
| 68096 |  |  | 68048 |
| 68097 | { |  | 68049 | {
| 68098 |  |  | 68050 |
| 68099 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68051 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68100 | { |  | 68052 | {
| 68101 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Feature()); |  | 68053 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Feature());
| 68102 | return 0; |  | 68054 | return 0;
| 68103 | } |  | 68055 | }
| 68104 |  |  | 68056 |
| 68105 |  |  | 68057 |
| 68106 | pyPopulateArgumentConversionErrors(); |  | 68058 | pyPopulateArgumentConversionErrors();
| 68107 | } |  | 68059 | }
| 68108 |  |  | 68060 |
| 68109 |  |  | 68061 |
| 68110 | { |  | 68062 | {
| 68111 | PyObject* pyobj_x = NULL; |  | 68063 | PyObject* pyobj_x = NULL;
| 68112 | int x=0; |  | 68064 | int x=0;
| 68113 | PyObject* pyobj_y = NULL; |  | 68065 | PyObject* pyobj_y = NULL;
| 68114 | int y=0; |  | 68066 | int y=0;
| 68115 | PyObject* pyobj_label = NULL; |  | 68067 | PyObject* pyobj_label = NULL;
| 68116 | int label=0; |  | 68068 | int label=0;
| 68117 |  |  | 68069 |
| 68118 | const char* keywords[] = { "x", "y", "label", NULL }; |  | 68070 | const char* keywords[] = { "x", "y", "label", NULL };
| 68119 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Feature", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_label) && |  | 68071 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:Feature", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_label) &&
| 68120 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) && |  | 68072 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) &&
| 68121 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) && |  | 68073 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) &&
| 68122 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) ) |  | 68074 | pyopencv_to_safe(pyobj_label, label, ArgInfo("label", 0)) )
| 68123 | { |  | 68075 | {
| 68124 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Feature(x, y, label)); |  | 68076 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Feature(x, y, label));
| 68125 | return 0; |  | 68077 | return 0;
| 68126 | } |  | 68078 | }
| 68127 |  |  | 68079 |
| 68128 |  |  | 68080 |
| 68129 | pyPopulateArgumentConversionErrors(); |  | 68081 | pyPopulateArgumentConversionErrors();
| 68130 | } |  | 68082 | }
| 68131 | pyRaiseCVOverloadException("Feature"); |  | 68083 | pyRaiseCVOverloadException("Feature");
| 68132 |  |  | 68084 |
| 68133 | return -1; |  | 68085 | return -1;
| 68134 | } |  | 68086 | }
| 68135 |  |  | 68087 |
| 68136 |  |  | 68088 |
| 68137 |  |  | 68089 |
| 68138 | // Tables (linemod_Feature) |  | 68090 | // Tables (linemod_Feature)
| 68139 |  |  | 68091 |
| 68140 | static PyGetSetDef pyopencv_linemod_Feature_getseters[] = |  | 68092 | static PyGetSetDef pyopencv_linemod_Feature_getseters[] =
| 68141 | { |  | 68093 | {
| 68142 | {(char*)"label", (getter)pyopencv_linemod_Feature_get_label, (setter)pyopencv_linemod_Feature_set_label, (char*)"label", NULL}, |  | 68094 | {(char*)"label", (getter)pyopencv_linemod_Feature_get_label, (setter)pyopencv_linemod_Feature_set_label, (char*)"label", NULL},
| 68143 | {(char*)"x", (getter)pyopencv_linemod_Feature_get_x, (setter)pyopencv_linemod_Feature_set_x, (char*)"x", NULL}, |  | 68095 | {(char*)"x", (getter)pyopencv_linemod_Feature_get_x, (setter)pyopencv_linemod_Feature_set_x, (char*)"x", NULL},
| 68144 | {(char*)"y", (getter)pyopencv_linemod_Feature_get_y, (setter)pyopencv_linemod_Feature_set_y, (char*)"y", NULL}, |  | 68096 | {(char*)"y", (getter)pyopencv_linemod_Feature_get_y, (setter)pyopencv_linemod_Feature_set_y, (char*)"y", NULL},
| 68145 | {NULL} /* Sentinel */ |  | 68097 | {NULL} /* Sentinel */
| 68146 | }; |  | 68098 | };
| 68147 |  |  | 68099 |
| 68148 | static PyMethodDef pyopencv_linemod_Feature_methods[] = |  | 68100 | static PyMethodDef pyopencv_linemod_Feature_methods[] =
| 68149 | { |  | 68101 | {
| 68150 |  |  | 68102 |
| 68151 | {NULL, NULL} |  | 68103 | {NULL, NULL}
| 68152 | }; |  | 68104 | };
| 68153 |  |  | 68105 |
| 68154 | // Converter (linemod_Feature) |  | 68106 | // Converter (linemod_Feature)
| 68155 |  |  | 68107 |
| 68156 | template<> |  | 68108 | template<>
| 68157 | struct PyOpenCV_Converter< cv::linemod::Feature > |  | 68109 | struct PyOpenCV_Converter< cv::linemod::Feature >
| 68158 | { |  | 68110 | {
| 68159 | static PyObject* from(const cv::linemod::Feature& r) |  | 68111 | static PyObject* from(const cv::linemod::Feature& r)
| 68160 | { |  | 68112 | {
| 68161 | return pyopencv_linemod_Feature_Instance(r); |  | 68113 | return pyopencv_linemod_Feature_Instance(r);
| 68162 | } |  | 68114 | }
| 68163 | static bool to(PyObject* src, cv::linemod::Feature& dst, const ArgInfo& info) |  | 68115 | static bool to(PyObject* src, cv::linemod::Feature& dst, const ArgInfo& info)
| 68164 | { |  | 68116 | {
| 68165 | if(!src || src == Py_None) |  | 68117 | if(!src || src == Py_None)
| 68166 | return true; |  | 68118 | return true;
| 68167 | cv::linemod::Feature * dst_; |  | 68119 | cv::linemod::Feature * dst_;
| 68168 | if (pyopencv_linemod_Feature_getp(src, dst_)) |  | 68120 | if (pyopencv_linemod_Feature_getp(src, dst_))
| 68169 | { |  | 68121 | {
| 68170 | dst = *dst_; |  | 68122 | dst = *dst_;
| 68171 | return true; |  | 68123 | return true;
| 68172 | } |  | 68124 | }
| 68173 |  |  | 68125 |
| 68174 | failmsg("Expected cv::linemod::Feature for argument '%s'", info.name); |  | 68126 | failmsg("Expected cv::linemod::Feature for argument '%s'", info.name);
| 68175 | return false; |  | 68127 | return false;
| 68176 | } |  | 68128 | }
| 68177 | }; |  | 68129 | };
| 68178 |  |  | 68130 |
| 68179 | //================================================================================ |  | 68131 | //================================================================================
| 68180 | // linemod_Match (Generic) |  | 68132 | // linemod_Match (Generic)
| 68181 | //================================================================================ |  | 68133 | //================================================================================
| 68182 |  |  | 68134 |
| 68183 | // GetSet (linemod_Match) |  | 68135 | // GetSet (linemod_Match)
| 68184 |  |  | 68136 |
| 68185 |  |  | 68137 |
| 68186 | static PyObject* pyopencv_linemod_Match_get_class_id(pyopencv_linemod_Match_t* p, void *closure) |  | 68138 | static PyObject* pyopencv_linemod_Match_get_class_id(pyopencv_linemod_Match_t* p, void *closure)
| 68187 | { |  | 68139 | {
| 68188 | return pyopencv_from(p->v.class_id); |  | 68140 | return pyopencv_from(p->v.class_id);
| 68189 | } |  | 68141 | }
| 68190 |  |  | 68142 |
| 68191 | static int pyopencv_linemod_Match_set_class_id(pyopencv_linemod_Match_t* p, PyObject *value, void *closure) |  | 68143 | static int pyopencv_linemod_Match_set_class_id(pyopencv_linemod_Match_t* p, PyObject *value, void *closure)
| 68192 | { |  | 68144 | {
| 68193 | if (!value) |  | 68145 | if (!value)
| 68194 | { |  | 68146 | {
| 68195 | PyErr_SetString(PyExc_TypeError, "Cannot delete the class_id attribute"); |  | 68147 | PyErr_SetString(PyExc_TypeError, "Cannot delete the class_id attribute");
| 68196 | return -1; |  | 68148 | return -1;
| 68197 | } |  | 68149 | }
| 68198 | return pyopencv_to_safe(value, p->v.class_id, ArgInfo("value", 0)) ? 0 : -1; |  | 68150 | return pyopencv_to_safe(value, p->v.class_id, ArgInfo("value", 0)) ? 0 : -1;
| 68199 | } |  | 68151 | }
| 68200 |  |  | 68152 |
| 68201 | static PyObject* pyopencv_linemod_Match_get_similarity(pyopencv_linemod_Match_t* p, void *closure) |  | 68153 | static PyObject* pyopencv_linemod_Match_get_similarity(pyopencv_linemod_Match_t* p, void *closure)
| 68202 | { |  | 68154 | {
| 68203 | return pyopencv_from(p->v.similarity); |  | 68155 | return pyopencv_from(p->v.similarity);
| 68204 | } |  | 68156 | }
| 68205 |  |  | 68157 |
| 68206 | static int pyopencv_linemod_Match_set_similarity(pyopencv_linemod_Match_t* p, PyObject *value, void *closure) |  | 68158 | static int pyopencv_linemod_Match_set_similarity(pyopencv_linemod_Match_t* p, PyObject *value, void *closure)
| 68207 | { |  | 68159 | {
| 68208 | if (!value) |  | 68160 | if (!value)
| 68209 | { |  | 68161 | {
| 68210 | PyErr_SetString(PyExc_TypeError, "Cannot delete the similarity attribute"); |  | 68162 | PyErr_SetString(PyExc_TypeError, "Cannot delete the similarity attribute");
| 68211 | return -1; |  | 68163 | return -1;
| 68212 | } |  | 68164 | }
| 68213 | return pyopencv_to_safe(value, p->v.similarity, ArgInfo("value", 0)) ? 0 : -1; |  | 68165 | return pyopencv_to_safe(value, p->v.similarity, ArgInfo("value", 0)) ? 0 : -1;
| 68214 | } |  | 68166 | }
| 68215 |  |  | 68167 |
| 68216 | static PyObject* pyopencv_linemod_Match_get_template_id(pyopencv_linemod_Match_t* p, void *closure) |  | 68168 | static PyObject* pyopencv_linemod_Match_get_template_id(pyopencv_linemod_Match_t* p, void *closure)
| 68217 | { |  | 68169 | {
| 68218 | return pyopencv_from(p->v.template_id); |  | 68170 | return pyopencv_from(p->v.template_id);
| 68219 | } |  | 68171 | }
| 68220 |  |  | 68172 |
| 68221 | static int pyopencv_linemod_Match_set_template_id(pyopencv_linemod_Match_t* p, PyObject *value, void *closure) |  | 68173 | static int pyopencv_linemod_Match_set_template_id(pyopencv_linemod_Match_t* p, PyObject *value, void *closure)
| 68222 | { |  | 68174 | {
| 68223 | if (!value) |  | 68175 | if (!value)
| 68224 | { |  | 68176 | {
| 68225 | PyErr_SetString(PyExc_TypeError, "Cannot delete the template_id attribute"); |  | 68177 | PyErr_SetString(PyExc_TypeError, "Cannot delete the template_id attribute");
| 68226 | return -1; |  | 68178 | return -1;
| 68227 | } |  | 68179 | }
| 68228 | return pyopencv_to_safe(value, p->v.template_id, ArgInfo("value", 0)) ? 0 : -1; |  | 68180 | return pyopencv_to_safe(value, p->v.template_id, ArgInfo("value", 0)) ? 0 : -1;
| 68229 | } |  | 68181 | }
| 68230 |  |  | 68182 |
| 68231 | static PyObject* pyopencv_linemod_Match_get_x(pyopencv_linemod_Match_t* p, void *closure) |  | 68183 | static PyObject* pyopencv_linemod_Match_get_x(pyopencv_linemod_Match_t* p, void *closure)
| 68232 | { |  | 68184 | {
| 68233 | return pyopencv_from(p->v.x); |  | 68185 | return pyopencv_from(p->v.x);
| 68234 | } |  | 68186 | }
| 68235 |  |  | 68187 |
| 68236 | static int pyopencv_linemod_Match_set_x(pyopencv_linemod_Match_t* p, PyObject *value, void *closure) |  | 68188 | static int pyopencv_linemod_Match_set_x(pyopencv_linemod_Match_t* p, PyObject *value, void *closure)
| 68237 | { |  | 68189 | {
| 68238 | if (!value) |  | 68190 | if (!value)
| 68239 | { |  | 68191 | {
| 68240 | PyErr_SetString(PyExc_TypeError, "Cannot delete the x attribute"); |  | 68192 | PyErr_SetString(PyExc_TypeError, "Cannot delete the x attribute");
| 68241 | return -1; |  | 68193 | return -1;
| 68242 | } |  | 68194 | }
| 68243 | return pyopencv_to_safe(value, p->v.x, ArgInfo("value", 0)) ? 0 : -1; |  | 68195 | return pyopencv_to_safe(value, p->v.x, ArgInfo("value", 0)) ? 0 : -1;
| 68244 | } |  | 68196 | }
| 68245 |  |  | 68197 |
| 68246 | static PyObject* pyopencv_linemod_Match_get_y(pyopencv_linemod_Match_t* p, void *closure) |  | 68198 | static PyObject* pyopencv_linemod_Match_get_y(pyopencv_linemod_Match_t* p, void *closure)
| 68247 | { |  | 68199 | {
| 68248 | return pyopencv_from(p->v.y); |  | 68200 | return pyopencv_from(p->v.y);
| 68249 | } |  | 68201 | }
| 68250 |  |  | 68202 |
| 68251 | static int pyopencv_linemod_Match_set_y(pyopencv_linemod_Match_t* p, PyObject *value, void *closure) |  | 68203 | static int pyopencv_linemod_Match_set_y(pyopencv_linemod_Match_t* p, PyObject *value, void *closure)
| 68252 | { |  | 68204 | {
| 68253 | if (!value) |  | 68205 | if (!value)
| 68254 | { |  | 68206 | {
| 68255 | PyErr_SetString(PyExc_TypeError, "Cannot delete the y attribute"); |  | 68207 | PyErr_SetString(PyExc_TypeError, "Cannot delete the y attribute");
| 68256 | return -1; |  | 68208 | return -1;
| 68257 | } |  | 68209 | }
| 68258 | return pyopencv_to_safe(value, p->v.y, ArgInfo("value", 0)) ? 0 : -1; |  | 68210 | return pyopencv_to_safe(value, p->v.y, ArgInfo("value", 0)) ? 0 : -1;
| 68259 | } |  | 68211 | }
| 68260 |  |  | 68212 |
| 68261 |  |  | 68213 |
| 68262 | // Methods (linemod_Match) |  | 68214 | // Methods (linemod_Match)
| 68263 |  |  | 68215 |
| 68264 | static int pyopencv_cv_linemod_linemod_Match_Match(pyopencv_linemod_Match_t* self, PyObject* py_args, PyObject* kw) |  | 68216 | static int pyopencv_cv_linemod_linemod_Match_Match(pyopencv_linemod_Match_t* self, PyObject* py_args, PyObject* kw)
| 68265 | { |  | 68217 | {
| 68266 | using namespace cv::linemod; |  | 68218 | using namespace cv::linemod;
| 68267 |  |  | 68219 |
| 68268 | pyPrepareArgumentConversionErrorsStorage(2); |  | 68220 | pyPrepareArgumentConversionErrorsStorage(2);
| 68269 |  |  | 68221 |
| 68270 | { |  | 68222 | {
| 68271 |  |  | 68223 |
| 68272 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68224 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68273 | { |  | 68225 | {
| 68274 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Match()); |  | 68226 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Match());
| 68275 | return 0; |  | 68227 | return 0;
| 68276 | } |  | 68228 | }
| 68277 |  |  | 68229 |
| 68278 |  |  | 68230 |
| 68279 | pyPopulateArgumentConversionErrors(); |  | 68231 | pyPopulateArgumentConversionErrors();
| 68280 | } |  | 68232 | }
| 68281 |  |  | 68233 |
| 68282 |  |  | 68234 |
| 68283 | { |  | 68235 | {
| 68284 | PyObject* pyobj_x = NULL; |  | 68236 | PyObject* pyobj_x = NULL;
| 68285 | int x=0; |  | 68237 | int x=0;
| 68286 | PyObject* pyobj_y = NULL; |  | 68238 | PyObject* pyobj_y = NULL;
| 68287 | int y=0; |  | 68239 | int y=0;
| 68288 | PyObject* pyobj_similarity = NULL; |  | 68240 | PyObject* pyobj_similarity = NULL;
| 68289 | float similarity=0.f; |  | 68241 | float similarity=0.f;
| 68290 | PyObject* pyobj_class_id = NULL; |  | 68242 | PyObject* pyobj_class_id = NULL;
| 68291 | String class_id; |  | 68243 | String class_id;
| 68292 | PyObject* pyobj_template_id = NULL; |  | 68244 | PyObject* pyobj_template_id = NULL;
| 68293 | int template_id=0; |  | 68245 | int template_id=0;
| 68294 |  |  | 68246 |
| 68295 | const char* keywords[] = { "x", "y", "similarity", "class_id", "template_id", NULL }; |  | 68247 | const char* keywords[] = { "x", "y", "similarity", "class_id", "template_id", NULL };
| 68296 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:Match", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_similarity, &pyobj_class_id, &pyobj_template_id) && |  | 68248 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOO:Match", (char**)keywords, &pyobj_x, &pyobj_y, &pyobj_similarity, &pyobj_class_id, &pyobj_template_id) &&
| 68297 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) && |  | 68249 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) &&
| 68298 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) && |  | 68250 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) &&
| 68299 | pyopencv_to_safe(pyobj_similarity, similarity, ArgInfo("similarity", 0)) && |  | 68251 | pyopencv_to_safe(pyobj_similarity, similarity, ArgInfo("similarity", 0)) &&
| 68300 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) && |  | 68252 | pyopencv_to_safe(pyobj_class_id, class_id, ArgInfo("class_id", 0)) &&
| 68301 | pyopencv_to_safe(pyobj_template_id, template_id, ArgInfo("template_id", 0)) ) |  | 68253 | pyopencv_to_safe(pyobj_template_id, template_id, ArgInfo("template_id", 0)) )
| 68302 | { |  | 68254 | {
| 68303 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Match(x, y, similarity, class_id, template_id)); |  | 68255 | if(self) ERRWRAP2(new (&(self->v)) cv::linemod::Match(x, y, similarity, class_id, template_id));
| 68304 | return 0; |  | 68256 | return 0;
| 68305 | } |  | 68257 | }
| 68306 |  |  | 68258 |
| 68307 |  |  | 68259 |
| 68308 | pyPopulateArgumentConversionErrors(); |  | 68260 | pyPopulateArgumentConversionErrors();
| 68309 | } |  | 68261 | }
| 68310 | pyRaiseCVOverloadException("Match"); |  | 68262 | pyRaiseCVOverloadException("Match");
| 68311 |  |  | 68263 |
| 68312 | return -1; |  | 68264 | return -1;
| 68313 | } |  | 68265 | }
| 68314 |  |  | 68266 |
| 68315 |  |  | 68267 |
| 68316 |  |  | 68268 |
| 68317 | // Tables (linemod_Match) |  | 68269 | // Tables (linemod_Match)
| 68318 |  |  | 68270 |
| 68319 | static PyGetSetDef pyopencv_linemod_Match_getseters[] = |  | 68271 | static PyGetSetDef pyopencv_linemod_Match_getseters[] =
| 68320 | { |  | 68272 | {
| 68321 | {(char*)"class_id", (getter)pyopencv_linemod_Match_get_class_id, (setter)pyopencv_linemod_Match_set_class_id, (char*)"class_id", NULL}, |  | 68273 | {(char*)"class_id", (getter)pyopencv_linemod_Match_get_class_id, (setter)pyopencv_linemod_Match_set_class_id, (char*)"class_id", NULL},
| 68322 | {(char*)"similarity", (getter)pyopencv_linemod_Match_get_similarity, (setter)pyopencv_linemod_Match_set_similarity, (char*)"similarity", NULL}, |  | 68274 | {(char*)"similarity", (getter)pyopencv_linemod_Match_get_similarity, (setter)pyopencv_linemod_Match_set_similarity, (char*)"similarity", NULL},
| 68323 | {(char*)"template_id", (getter)pyopencv_linemod_Match_get_template_id, (setter)pyopencv_linemod_Match_set_template_id, (char*)"template_id", NULL}, |  | 68275 | {(char*)"template_id", (getter)pyopencv_linemod_Match_get_template_id, (setter)pyopencv_linemod_Match_set_template_id, (char*)"template_id", NULL},
| 68324 | {(char*)"x", (getter)pyopencv_linemod_Match_get_x, (setter)pyopencv_linemod_Match_set_x, (char*)"x", NULL}, |  | 68276 | {(char*)"x", (getter)pyopencv_linemod_Match_get_x, (setter)pyopencv_linemod_Match_set_x, (char*)"x", NULL},
| 68325 | {(char*)"y", (getter)pyopencv_linemod_Match_get_y, (setter)pyopencv_linemod_Match_set_y, (char*)"y", NULL}, |  | 68277 | {(char*)"y", (getter)pyopencv_linemod_Match_get_y, (setter)pyopencv_linemod_Match_set_y, (char*)"y", NULL},
| 68326 | {NULL} /* Sentinel */ |  | 68278 | {NULL} /* Sentinel */
| 68327 | }; |  | 68279 | };
| 68328 |  |  | 68280 |
| 68329 | static PyMethodDef pyopencv_linemod_Match_methods[] = |  | 68281 | static PyMethodDef pyopencv_linemod_Match_methods[] =
| 68330 | { |  | 68282 | {
| 68331 |  |  | 68283 |
| 68332 | {NULL, NULL} |  | 68284 | {NULL, NULL}
| 68333 | }; |  | 68285 | };
| 68334 |  |  | 68286 |
| 68335 | // Converter (linemod_Match) |  | 68287 | // Converter (linemod_Match)
| 68336 |  |  | 68288 |
| 68337 | template<> |  | 68289 | template<>
| 68338 | struct PyOpenCV_Converter< cv::linemod::Match > |  | 68290 | struct PyOpenCV_Converter< cv::linemod::Match >
| 68339 | { |  | 68291 | {
| 68340 | static PyObject* from(const cv::linemod::Match& r) |  | 68292 | static PyObject* from(const cv::linemod::Match& r)
| 68341 | { |  | 68293 | {
| 68342 | return pyopencv_linemod_Match_Instance(r); |  | 68294 | return pyopencv_linemod_Match_Instance(r);
| 68343 | } |  | 68295 | }
| 68344 | static bool to(PyObject* src, cv::linemod::Match& dst, const ArgInfo& info) |  | 68296 | static bool to(PyObject* src, cv::linemod::Match& dst, const ArgInfo& info)
| 68345 | { |  | 68297 | {
| 68346 | if(!src || src == Py_None) |  | 68298 | if(!src || src == Py_None)
| 68347 | return true; |  | 68299 | return true;
| 68348 | cv::linemod::Match * dst_; |  | 68300 | cv::linemod::Match * dst_;
| 68349 | if (pyopencv_linemod_Match_getp(src, dst_)) |  | 68301 | if (pyopencv_linemod_Match_getp(src, dst_))
| 68350 | { |  | 68302 | {
| 68351 | dst = *dst_; |  | 68303 | dst = *dst_;
| 68352 | return true; |  | 68304 | return true;
| 68353 | } |  | 68305 | }
| 68354 |  |  | 68306 |
| 68355 | failmsg("Expected cv::linemod::Match for argument '%s'", info.name); |  | 68307 | failmsg("Expected cv::linemod::Match for argument '%s'", info.name);
| 68356 | return false; |  | 68308 | return false;
| 68357 | } |  | 68309 | }
| 68358 | }; |  | 68310 | };
| 68359 |  |  | 68311 |
| 68360 | //================================================================================ |  | 68312 | //================================================================================
| 68361 | // linemod_Modality (Generic) |  | 68313 | // linemod_Modality (Generic)
| 68362 | //================================================================================ |  | 68314 | //================================================================================
| 68363 |  |  | 68315 |
| 68364 | // GetSet (linemod_Modality) |  | 68316 | // GetSet (linemod_Modality)
| 68365 |  |  | 68317 |
| 68366 |  |  | 68318 |
| 68367 |  |  | 68319 |
| 68368 | // Methods (linemod_Modality) |  | 68320 | // Methods (linemod_Modality)
| 68369 |  |  | 68321 |
| 68370 | static PyObject* pyopencv_cv_linemod_linemod_Modality_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68322 | static PyObject* pyopencv_cv_linemod_linemod_Modality_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 68371 | { |  | 68323 | {
| 68372 | using namespace cv::linemod; |  | 68324 | using namespace cv::linemod;
| 68373 |  |  | 68325 |
| 68374 | pyPrepareArgumentConversionErrorsStorage(2); |  | 68326 | pyPrepareArgumentConversionErrorsStorage(2);
| 68375 |  |  | 68327 |
| 68376 | { |  | 68328 | {
| 68377 | PyObject* pyobj_modality_type = NULL; |  | 68329 | PyObject* pyobj_modality_type = NULL;
| 68378 | String modality_type; |  | 68330 | String modality_type;
| 68379 | Ptr<Modality> retval; |  | 68331 | Ptr<Modality> retval;
| 68380 |  |  | 68332 |
| 68381 | const char* keywords[] = { "modality_type", NULL }; |  | 68333 | const char* keywords[] = { "modality_type", NULL };
| 68382 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Modality.create", (char**)keywords, &pyobj_modality_type) && |  | 68334 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Modality.create", (char**)keywords, &pyobj_modality_type) &&
| 68383 | pyopencv_to_safe(pyobj_modality_type, modality_type, ArgInfo("modality_type", 0)) ) |  | 68335 | pyopencv_to_safe(pyobj_modality_type, modality_type, ArgInfo("modality_type", 0)) )
| 68384 | { |  | 68336 | {
| 68385 | ERRWRAP2(retval = cv::linemod::Modality::create(modality_type)); |  | 68337 | ERRWRAP2(retval = cv::linemod::Modality::create(modality_type));
| 68386 | return pyopencv_from(retval); |  | 68338 | return pyopencv_from(retval);
| 68387 | } |  | 68339 | }
| 68388 |  |  | 68340 |
| 68389 |  |  | 68341 |
| 68390 | pyPopulateArgumentConversionErrors(); |  | 68342 | pyPopulateArgumentConversionErrors();
| 68391 | } |  | 68343 | }
| 68392 |  |  | 68344 |
| 68393 |  |  | 68345 |
| 68394 | { |  | 68346 | {
| 68395 | PyObject* pyobj_fn = NULL; |  | 68347 | PyObject* pyobj_fn = NULL;
| 68396 | cv::FileNode fn; |  | 68348 | cv::FileNode fn;
| 68397 | Ptr<Modality> retval; |  | 68349 | Ptr<Modality> retval;
| 68398 |  |  | 68350 |
| 68399 | const char* keywords[] = { "fn", NULL }; |  | 68351 | const char* keywords[] = { "fn", NULL };
| 68400 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Modality.create", (char**)keywords, &pyobj_fn) && |  | 68352 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Modality.create", (char**)keywords, &pyobj_fn) &&
| 68401 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 68353 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 68402 | { |  | 68354 | {
| 68403 | ERRWRAP2(retval = cv::linemod::Modality::create(fn)); |  | 68355 | ERRWRAP2(retval = cv::linemod::Modality::create(fn));
| 68404 | return pyopencv_from(retval); |  | 68356 | return pyopencv_from(retval);
| 68405 | } |  | 68357 | }
| 68406 |  |  | 68358 |
| 68407 |  |  | 68359 |
| 68408 | pyPopulateArgumentConversionErrors(); |  | 68360 | pyPopulateArgumentConversionErrors();
| 68409 | } |  | 68361 | }
| 68410 | pyRaiseCVOverloadException("create"); |  | 68362 | pyRaiseCVOverloadException("create");
| 68411 |  |  | 68363 |
| 68412 | return NULL; |  | 68364 | return NULL;
| 68413 | } |  | 68365 | }
| 68414 |  |  | 68366 |
| 68415 | static PyObject* pyopencv_cv_linemod_linemod_Modality_name(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68367 | static PyObject* pyopencv_cv_linemod_linemod_Modality_name(PyObject* self, PyObject* py_args, PyObject* kw)
| 68416 | { |  | 68368 | {
| 68417 | using namespace cv::linemod; |  | 68369 | using namespace cv::linemod;
| 68418 |  |  | 68370 |
| 68419 |  |  | 68371 |
| 68420 | Ptr<cv::linemod::Modality> * self1 = 0; |  | 68372 | Ptr<cv::linemod::Modality> * self1 = 0;
| 68421 | if (!pyopencv_linemod_Modality_getp(self, self1)) |  | 68373 | if (!pyopencv_linemod_Modality_getp(self, self1))
| 68422 | return failmsgp("Incorrect type of self (must be 'linemod_Modality' or its derivative)"); |  | 68374 | return failmsgp("Incorrect type of self (must be 'linemod_Modality' or its derivative)");
| 68423 | Ptr<cv::linemod::Modality> _self_ = *(self1); |  | 68375 | Ptr<cv::linemod::Modality> _self_ = *(self1);
| 68424 | String retval; |  | 68376 | String retval;
| 68425 |  |  | 68377 |
| 68426 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68378 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68427 | { |  | 68379 | {
| 68428 | ERRWRAP2(retval = _self_->name()); |  | 68380 | ERRWRAP2(retval = _self_->name());
| 68429 | return pyopencv_from(retval); |  | 68381 | return pyopencv_from(retval);
| 68430 | } |  | 68382 | }
| 68431 |  |  | 68383 |
| 68432 | return NULL; |  | 68384 | return NULL;
| 68433 | } |  | 68385 | }
| 68434 |  |  | 68386 |
| 68435 | static PyObject* pyopencv_cv_linemod_linemod_Modality_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68387 | static PyObject* pyopencv_cv_linemod_linemod_Modality_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 68436 | { |  | 68388 | {
| 68437 | using namespace cv::linemod; |  | 68389 | using namespace cv::linemod;
| 68438 |  |  | 68390 |
| 68439 |  |  | 68391 |
| 68440 | Ptr<cv::linemod::Modality> * self1 = 0; |  | 68392 | Ptr<cv::linemod::Modality> * self1 = 0;
| 68441 | if (!pyopencv_linemod_Modality_getp(self, self1)) |  | 68393 | if (!pyopencv_linemod_Modality_getp(self, self1))
| 68442 | return failmsgp("Incorrect type of self (must be 'linemod_Modality' or its derivative)"); |  | 68394 | return failmsgp("Incorrect type of self (must be 'linemod_Modality' or its derivative)");
| 68443 | Ptr<cv::linemod::Modality> _self_ = *(self1); |  | 68395 | Ptr<cv::linemod::Modality> _self_ = *(self1);
| 68444 | PyObject* pyobj_src = NULL; |  | 68396 | PyObject* pyobj_src = NULL;
| 68445 | Mat src; |  | 68397 | Mat src;
| 68446 | PyObject* pyobj_mask = NULL; |  | 68398 | PyObject* pyobj_mask = NULL;
| 68447 | Mat mask; |  | 68399 | Mat mask;
| 68448 | Ptr<QuantizedPyramid> retval; |  | 68400 | Ptr<QuantizedPyramid> retval;
| 68449 |  |  | 68401 |
| 68450 | const char* keywords[] = { "src", "mask", NULL }; |  | 68402 | const char* keywords[] = { "src", "mask", NULL };
| 68451 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:linemod_Modality.process", (char**)keywords, &pyobj_src, &pyobj_mask) && |  | 68403 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:linemod_Modality.process", (char**)keywords, &pyobj_src, &pyobj_mask) &&
| 68452 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) && |  | 68404 | pyopencv_to_safe(pyobj_src, src, ArgInfo("src", 0)) &&
| 68453 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) ) |  | 68405 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) )
| 68454 | { |  | 68406 | {
| 68455 | ERRWRAP2(retval = _self_->process(src, mask)); |  | 68407 | ERRWRAP2(retval = _self_->process(src, mask));
| 68456 | return pyopencv_from(retval); |  | 68408 | return pyopencv_from(retval);
| 68457 | } |  | 68409 | }
| 68458 |  |  | 68410 |
| 68459 | return NULL; |  | 68411 | return NULL;
| 68460 | } |  | 68412 | }
| 68461 |  |  | 68413 |
| 68462 | static PyObject* pyopencv_cv_linemod_linemod_Modality_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68414 | static PyObject* pyopencv_cv_linemod_linemod_Modality_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 68463 | { |  | 68415 | {
| 68464 | using namespace cv::linemod; |  | 68416 | using namespace cv::linemod;
| 68465 |  |  | 68417 |
| 68466 |  |  | 68418 |
| 68467 | Ptr<cv::linemod::Modality> * self1 = 0; |  | 68419 | Ptr<cv::linemod::Modality> * self1 = 0;
| 68468 | if (!pyopencv_linemod_Modality_getp(self, self1)) |  | 68420 | if (!pyopencv_linemod_Modality_getp(self, self1))
| 68469 | return failmsgp("Incorrect type of self (must be 'linemod_Modality' or its derivative)"); |  | 68421 | return failmsgp("Incorrect type of self (must be 'linemod_Modality' or its derivative)");
| 68470 | Ptr<cv::linemod::Modality> _self_ = *(self1); |  | 68422 | Ptr<cv::linemod::Modality> _self_ = *(self1);
| 68471 | PyObject* pyobj_fn = NULL; |  | 68423 | PyObject* pyobj_fn = NULL;
| 68472 | cv::FileNode fn; |  | 68424 | cv::FileNode fn;
| 68473 |  |  | 68425 |
| 68474 | const char* keywords[] = { "fn", NULL }; |  | 68426 | const char* keywords[] = { "fn", NULL };
| 68475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Modality.read", (char**)keywords, &pyobj_fn) && |  | 68427 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:linemod_Modality.read", (char**)keywords, &pyobj_fn) &&
| 68476 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 68428 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 68477 | { |  | 68429 | {
| 68478 | ERRWRAP2(_self_->read(fn)); |  | 68430 | ERRWRAP2(_self_->read(fn));
| 68479 | Py_RETURN_NONE; |  | 68431 | Py_RETURN_NONE;
| 68480 | } |  | 68432 | }
| 68481 |  |  | 68433 |
| 68482 | return NULL; |  | 68434 | return NULL;
| 68483 | } |  | 68435 | }
| 68484 |  |  | 68436 |
| 68485 |  |  | 68437 |
| 68486 |  |  | 68438 |
| 68487 | // Tables (linemod_Modality) |  | 68439 | // Tables (linemod_Modality)
| 68488 |  |  | 68440 |
| 68489 | static PyGetSetDef pyopencv_linemod_Modality_getseters[] = |  | 68441 | static PyGetSetDef pyopencv_linemod_Modality_getseters[] =
| 68490 | { |  | 68442 | {
| 68491 | {NULL} /* Sentinel */ |  | 68443 | {NULL} /* Sentinel */
| 68492 | }; |  | 68444 | };
| 68493 |  |  | 68445 |
| 68494 | static PyMethodDef pyopencv_linemod_Modality_methods[] = |  | 68446 | static PyMethodDef pyopencv_linemod_Modality_methods[] =
| 68495 | { |  | 68447 | {
| 68496 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_create_static, METH_STATIC), "create(modality_type) -> retval\n. * \\brief Create modality by name.\n. *\n. * The following modality types are supported:\n. * - \"ColorGradient\"\n. * - \"DepthNormal\"\n\n\n\ncreate(fn) -> retval\n. * \\brief Load a modality from file."}, |  | 68448 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_create_static, METH_STATIC), "create(modality_type) -> retval\n. * \\brief Create modality by name.\n. *\n. * The following modality types are supported:\n. * - \"ColorGradient\"\n. * - \"DepthNormal\"\n\n\n\ncreate(fn) -> retval\n. * \\brief Load a modality from file."},
| 68497 | {"name", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_name, 0), "name() -> retval\n."}, |  | 68449 | {"name", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_name, 0), "name() -> retval\n."},
| 68498 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_process, 0), "process(src[, mask]) -> retval\n. * \\brief Form a quantized image pyramid from a source image.\n. *\n. * \\param[in] src The source image. Type depends on the modality.\n. * \\param[in] mask Optional mask. If not empty, unmasked pixels are set to zero\n. * in quantized image and cannot be extracted as features."}, |  | 68450 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_process, 0), "process(src[, mask]) -> retval\n. * \\brief Form a quantized image pyramid from a source image.\n. *\n. * \\param[in] src The source image. Type depends on the modality.\n. * \\param[in] mask Optional mask. If not empty, unmasked pixels are set to zero\n. * in quantized image and cannot be extracted as features."},
| 68499 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_read, 0), "read(fn) -> None\n."}, |  | 68451 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_Modality_read, 0), "read(fn) -> None\n."},
| 68500 |  |  | 68452 |
| 68501 | {NULL, NULL} |  | 68453 | {NULL, NULL}
| 68502 | }; |  | 68454 | };
| 68503 |  |  | 68455 |
| 68504 | // Converter (linemod_Modality) |  | 68456 | // Converter (linemod_Modality)
| 68505 |  |  | 68457 |
| 68506 | template<> |  | 68458 | template<>
| 68507 | struct PyOpenCV_Converter< Ptr<cv::linemod::Modality> > |  | 68459 | struct PyOpenCV_Converter< Ptr<cv::linemod::Modality> >
| 68508 | { |  | 68460 | {
| 68509 | static PyObject* from(const Ptr<cv::linemod::Modality>& r) |  | 68461 | static PyObject* from(const Ptr<cv::linemod::Modality>& r)
| 68510 | { |  | 68462 | {
| 68511 | return pyopencv_linemod_Modality_Instance(r); |  | 68463 | return pyopencv_linemod_Modality_Instance(r);
| 68512 | } |  | 68464 | }
| 68513 | static bool to(PyObject* src, Ptr<cv::linemod::Modality>& dst, const ArgInfo& info) |  | 68465 | static bool to(PyObject* src, Ptr<cv::linemod::Modality>& dst, const ArgInfo& info)
| 68514 | { |  | 68466 | {
| 68515 | if(!src || src == Py_None) |  | 68467 | if(!src || src == Py_None)
| 68516 | return true; |  | 68468 | return true;
| 68517 | Ptr<cv::linemod::Modality> * dst_; |  | 68469 | Ptr<cv::linemod::Modality> * dst_;
| 68518 | if (pyopencv_linemod_Modality_getp(src, dst_)) |  | 68470 | if (pyopencv_linemod_Modality_getp(src, dst_))
| 68519 | { |  | 68471 | {
| 68520 | dst = *dst_; |  | 68472 | dst = *dst_;
| 68521 | return true; |  | 68473 | return true;
| 68522 | } |  | 68474 | }
| 68523 |  |  | 68475 |
| 68524 | failmsg("Expected Ptr<cv::linemod::Modality> for argument '%s'", info.name); |  | 68476 | failmsg("Expected Ptr<cv::linemod::Modality> for argument '%s'", info.name);
| 68525 | return false; |  | 68477 | return false;
| 68526 | } |  | 68478 | }
| 68527 | }; |  | 68479 | };
| 68528 |  |  | 68480 |
| 68529 | //================================================================================ |  | 68481 | //================================================================================
| 68530 | // linemod_QuantizedPyramid (Generic) |  | 68482 | // linemod_QuantizedPyramid (Generic)
| 68531 | //================================================================================ |  | 68483 | //================================================================================
| 68532 |  |  | 68484 |
| 68533 | // GetSet (linemod_QuantizedPyramid) |  | 68485 | // GetSet (linemod_QuantizedPyramid)
| 68534 |  |  | 68486 |
| 68535 |  |  | 68487 |
| 68536 |  |  | 68488 |
| 68537 | // Methods (linemod_QuantizedPyramid) |  | 68489 | // Methods (linemod_QuantizedPyramid)
| 68538 |  |  | 68490 |
| 68539 | static PyObject* pyopencv_cv_linemod_linemod_QuantizedPyramid_extractTemplate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68491 | static PyObject* pyopencv_cv_linemod_linemod_QuantizedPyramid_extractTemplate(PyObject* self, PyObject* py_args, PyObject* kw)
| 68540 | { |  | 68492 | {
| 68541 | using namespace cv::linemod; |  | 68493 | using namespace cv::linemod;
| 68542 |  |  | 68494 |
| 68543 |  |  | 68495 |
| 68544 | Ptr<cv::linemod::QuantizedPyramid> * self1 = 0; |  | 68496 | Ptr<cv::linemod::QuantizedPyramid> * self1 = 0;
| 68545 | if (!pyopencv_linemod_QuantizedPyramid_getp(self, self1)) |  | 68497 | if (!pyopencv_linemod_QuantizedPyramid_getp(self, self1))
| 68546 | return failmsgp("Incorrect type of self (must be 'linemod_QuantizedPyramid' or its derivative)"); |  | 68498 | return failmsgp("Incorrect type of self (must be 'linemod_QuantizedPyramid' or its derivative)");
| 68547 | Ptr<cv::linemod::QuantizedPyramid> _self_ = *(self1); |  | 68499 | Ptr<cv::linemod::QuantizedPyramid> _self_ = *(self1);
| 68548 | Template templ; |  | 68500 | Template templ;
| 68549 | bool retval; |  | 68501 | bool retval;
| 68550 |  |  | 68502 |
| 68551 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68503 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68552 | { |  | 68504 | {
| 68553 | ERRWRAP2(retval = _self_->extractTemplate(templ)); |  | 68505 | ERRWRAP2(retval = _self_->extractTemplate(templ));
| 68554 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(templ)); |  | 68506 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(templ));
| 68555 | } |  | 68507 | }
| 68556 |  |  | 68508 |
| 68557 | return NULL; |  | 68509 | return NULL;
| 68558 | } |  | 68510 | }
| 68559 |  |  | 68511 |
| 68560 | static PyObject* pyopencv_cv_linemod_linemod_QuantizedPyramid_pyrDown(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68512 | static PyObject* pyopencv_cv_linemod_linemod_QuantizedPyramid_pyrDown(PyObject* self, PyObject* py_args, PyObject* kw)
| 68561 | { |  | 68513 | {
| 68562 | using namespace cv::linemod; |  | 68514 | using namespace cv::linemod;
| 68563 |  |  | 68515 |
| 68564 |  |  | 68516 |
| 68565 | Ptr<cv::linemod::QuantizedPyramid> * self1 = 0; |  | 68517 | Ptr<cv::linemod::QuantizedPyramid> * self1 = 0;
| 68566 | if (!pyopencv_linemod_QuantizedPyramid_getp(self, self1)) |  | 68518 | if (!pyopencv_linemod_QuantizedPyramid_getp(self, self1))
| 68567 | return failmsgp("Incorrect type of self (must be 'linemod_QuantizedPyramid' or its derivative)"); |  | 68519 | return failmsgp("Incorrect type of self (must be 'linemod_QuantizedPyramid' or its derivative)");
| 68568 | Ptr<cv::linemod::QuantizedPyramid> _self_ = *(self1); |  | 68520 | Ptr<cv::linemod::QuantizedPyramid> _self_ = *(self1);
| 68569 |  |  | 68521 |
| 68570 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68522 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68571 | { |  | 68523 | {
| 68572 | ERRWRAP2(_self_->pyrDown()); |  | 68524 | ERRWRAP2(_self_->pyrDown());
| 68573 | Py_RETURN_NONE; |  | 68525 | Py_RETURN_NONE;
| 68574 | } |  | 68526 | }
| 68575 |  |  | 68527 |
| 68576 | return NULL; |  | 68528 | return NULL;
| 68577 | } |  | 68529 | }
| 68578 |  |  | 68530 |
| 68579 | static PyObject* pyopencv_cv_linemod_linemod_QuantizedPyramid_quantize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68531 | static PyObject* pyopencv_cv_linemod_linemod_QuantizedPyramid_quantize(PyObject* self, PyObject* py_args, PyObject* kw)
| 68580 | { |  | 68532 | {
| 68581 | using namespace cv::linemod; |  | 68533 | using namespace cv::linemod;
| 68582 |  |  | 68534 |
| 68583 |  |  | 68535 |
| 68584 | Ptr<cv::linemod::QuantizedPyramid> * self1 = 0; |  | 68536 | Ptr<cv::linemod::QuantizedPyramid> * self1 = 0;
| 68585 | if (!pyopencv_linemod_QuantizedPyramid_getp(self, self1)) |  | 68537 | if (!pyopencv_linemod_QuantizedPyramid_getp(self, self1))
| 68586 | return failmsgp("Incorrect type of self (must be 'linemod_QuantizedPyramid' or its derivative)"); |  | 68538 | return failmsgp("Incorrect type of self (must be 'linemod_QuantizedPyramid' or its derivative)");
| 68587 | Ptr<cv::linemod::QuantizedPyramid> _self_ = *(self1); |  | 68539 | Ptr<cv::linemod::QuantizedPyramid> _self_ = *(self1);
| 68588 | PyObject* pyobj_dst = NULL; |  | 68540 | PyObject* pyobj_dst = NULL;
| 68589 | Mat dst; |  | 68541 | Mat dst;
| 68590 |  |  | 68542 |
| 68591 | const char* keywords[] = { "dst", NULL }; |  | 68543 | const char* keywords[] = { "dst", NULL };
| 68592 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:linemod_QuantizedPyramid.quantize", (char**)keywords, &pyobj_dst) && |  | 68544 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:linemod_QuantizedPyramid.quantize", (char**)keywords, &pyobj_dst) &&
| 68593 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 68545 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 68594 | { |  | 68546 | {
| 68595 | ERRWRAP2(_self_->quantize(dst)); |  | 68547 | ERRWRAP2(_self_->quantize(dst));
| 68596 | return pyopencv_from(dst); |  | 68548 | return pyopencv_from(dst);
| 68597 | } |  | 68549 | }
| 68598 |  |  | 68550 |
| 68599 | return NULL; |  | 68551 | return NULL;
| 68600 | } |  | 68552 | }
| 68601 |  |  | 68553 |
| 68602 |  |  | 68554 |
| 68603 |  |  | 68555 |
| 68604 | // Tables (linemod_QuantizedPyramid) |  | 68556 | // Tables (linemod_QuantizedPyramid)
| 68605 |  |  | 68557 |
| 68606 | static PyGetSetDef pyopencv_linemod_QuantizedPyramid_getseters[] = |  | 68558 | static PyGetSetDef pyopencv_linemod_QuantizedPyramid_getseters[] =
| 68607 | { |  | 68559 | {
| 68608 | {NULL} /* Sentinel */ |  | 68560 | {NULL} /* Sentinel */
| 68609 | }; |  | 68561 | };
| 68610 |  |  | 68562 |
| 68611 | static PyMethodDef pyopencv_linemod_QuantizedPyramid_methods[] = |  | 68563 | static PyMethodDef pyopencv_linemod_QuantizedPyramid_methods[] =
| 68612 | { |  | 68564 | {
| 68613 | {"extractTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_QuantizedPyramid_extractTemplate, 0), "extractTemplate() -> retval, templ\n. * \\brief Extract most discriminant features at current pyramid level to form a new template.\n. *\n. * \\param[out] templ The new template."}, |  | 68565 | {"extractTemplate", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_QuantizedPyramid_extractTemplate, 0), "extractTemplate() -> retval, templ\n. * \\brief Extract most discriminant features at current pyramid level to form a new template.\n. *\n. * \\param[out] templ The new template."},
| 68614 | {"pyrDown", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_QuantizedPyramid_pyrDown, 0), "pyrDown() -> None\n. * \\brief Go to the next pyramid level.\n. *\n. * \\todo Allow pyramid scale factor other than 2"}, |  | 68566 | {"pyrDown", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_QuantizedPyramid_pyrDown, 0), "pyrDown() -> None\n. * \\brief Go to the next pyramid level.\n. *\n. * \\todo Allow pyramid scale factor other than 2"},
| 68615 | {"quantize", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_QuantizedPyramid_quantize, 0), "quantize([, dst]) -> dst\n. * \\brief Compute quantized image at current pyramid level for online detection.\n. *\n. * \\param[out] dst The destination 8-bit image. For each pixel at most one bit is set,\n. * representing its classification."}, |  | 68567 | {"quantize", CV_PY_FN_WITH_KW_(pyopencv_cv_linemod_linemod_QuantizedPyramid_quantize, 0), "quantize([, dst]) -> dst\n. * \\brief Compute quantized image at current pyramid level for online detection.\n. *\n. * \\param[out] dst The destination 8-bit image. For each pixel at most one bit is set,\n. * representing its classification."},
| 68616 |  |  | 68568 |
| 68617 | {NULL, NULL} |  | 68569 | {NULL, NULL}
| 68618 | }; |  | 68570 | };
| 68619 |  |  | 68571 |
| 68620 | // Converter (linemod_QuantizedPyramid) |  | 68572 | // Converter (linemod_QuantizedPyramid)
| 68621 |  |  | 68573 |
| 68622 | template<> |  | 68574 | template<>
| 68623 | struct PyOpenCV_Converter< Ptr<cv::linemod::QuantizedPyramid> > |  | 68575 | struct PyOpenCV_Converter< Ptr<cv::linemod::QuantizedPyramid> >
| 68624 | { |  | 68576 | {
| 68625 | static PyObject* from(const Ptr<cv::linemod::QuantizedPyramid>& r) |  | 68577 | static PyObject* from(const Ptr<cv::linemod::QuantizedPyramid>& r)
| 68626 | { |  | 68578 | {
| 68627 | return pyopencv_linemod_QuantizedPyramid_Instance(r); |  | 68579 | return pyopencv_linemod_QuantizedPyramid_Instance(r);
| 68628 | } |  | 68580 | }
| 68629 | static bool to(PyObject* src, Ptr<cv::linemod::QuantizedPyramid>& dst, const ArgInfo& info) |  | 68581 | static bool to(PyObject* src, Ptr<cv::linemod::QuantizedPyramid>& dst, const ArgInfo& info)
| 68630 | { |  | 68582 | {
| 68631 | if(!src || src == Py_None) |  | 68583 | if(!src || src == Py_None)
| 68632 | return true; |  | 68584 | return true;
| 68633 | Ptr<cv::linemod::QuantizedPyramid> * dst_; |  | 68585 | Ptr<cv::linemod::QuantizedPyramid> * dst_;
| 68634 | if (pyopencv_linemod_QuantizedPyramid_getp(src, dst_)) |  | 68586 | if (pyopencv_linemod_QuantizedPyramid_getp(src, dst_))
| 68635 | { |  | 68587 | {
| 68636 | dst = *dst_; |  | 68588 | dst = *dst_;
| 68637 | return true; |  | 68589 | return true;
| 68638 | } |  | 68590 | }
| 68639 |  |  | 68591 |
| 68640 | failmsg("Expected Ptr<cv::linemod::QuantizedPyramid> for argument '%s'", info.name); |  | 68592 | failmsg("Expected Ptr<cv::linemod::QuantizedPyramid> for argument '%s'", info.name);
| 68641 | return false; |  | 68593 | return false;
| 68642 | } |  | 68594 | }
| 68643 | }; |  | 68595 | };
| 68644 |  |  | 68596 |
| 68645 | //================================================================================ |  | 68597 | //================================================================================
| 68646 | // linemod_Template (Generic) |  | 68598 | // linemod_Template (Generic)
| 68647 | //================================================================================ |  | 68599 | //================================================================================
| 68648 |  |  | 68600 |
| 68649 | // GetSet (linemod_Template) |  | 68601 | // GetSet (linemod_Template)
| 68650 |  |  | 68602 |
| 68651 |  |  | 68603 |
| 68652 | static PyObject* pyopencv_linemod_Template_get_features(pyopencv_linemod_Template_t* p, void *closure) |  | 68604 | static PyObject* pyopencv_linemod_Template_get_features(pyopencv_linemod_Template_t* p, void *closure)
| 68653 | { |  | 68605 | {
| 68654 | return pyopencv_from(p->v.features); |  | 68606 | return pyopencv_from(p->v.features);
| 68655 | } |  | 68607 | }
| 68656 |  |  | 68608 |
| 68657 | static PyObject* pyopencv_linemod_Template_get_height(pyopencv_linemod_Template_t* p, void *closure) |  | 68609 | static PyObject* pyopencv_linemod_Template_get_height(pyopencv_linemod_Template_t* p, void *closure)
| 68658 | { |  | 68610 | {
| 68659 | return pyopencv_from(p->v.height); |  | 68611 | return pyopencv_from(p->v.height);
| 68660 | } |  | 68612 | }
| 68661 |  |  | 68613 |
| 68662 | static PyObject* pyopencv_linemod_Template_get_pyramid_level(pyopencv_linemod_Template_t* p, void *closure) |  | 68614 | static PyObject* pyopencv_linemod_Template_get_pyramid_level(pyopencv_linemod_Template_t* p, void *closure)
| 68663 | { |  | 68615 | {
| 68664 | return pyopencv_from(p->v.pyramid_level); |  | 68616 | return pyopencv_from(p->v.pyramid_level);
| 68665 | } |  | 68617 | }
| 68666 |  |  | 68618 |
| 68667 | static PyObject* pyopencv_linemod_Template_get_width(pyopencv_linemod_Template_t* p, void *closure) |  | 68619 | static PyObject* pyopencv_linemod_Template_get_width(pyopencv_linemod_Template_t* p, void *closure)
| 68668 | { |  | 68620 | {
| 68669 | return pyopencv_from(p->v.width); |  | 68621 | return pyopencv_from(p->v.width);
| 68670 | } |  | 68622 | }
| 68671 |  |  | 68623 |
| 68672 |  |  | 68624 |
| 68673 | // Methods (linemod_Template) |  | 68625 | // Methods (linemod_Template)
| 68674 |  |  | 68626 |
| 68675 |  |  | 68627 |
| 68676 |  |  | 68628 |
| 68677 | // Tables (linemod_Template) |  | 68629 | // Tables (linemod_Template)
| 68678 |  |  | 68630 |
| 68679 | static PyGetSetDef pyopencv_linemod_Template_getseters[] = |  | 68631 | static PyGetSetDef pyopencv_linemod_Template_getseters[] =
| 68680 | { |  | 68632 | {
| 68681 | {(char*)"features", (getter)pyopencv_linemod_Template_get_features, NULL, (char*)"features", NULL}, |  | 68633 | {(char*)"features", (getter)pyopencv_linemod_Template_get_features, NULL, (char*)"features", NULL},
| 68682 | {(char*)"height", (getter)pyopencv_linemod_Template_get_height, NULL, (char*)"height", NULL}, |  | 68634 | {(char*)"height", (getter)pyopencv_linemod_Template_get_height, NULL, (char*)"height", NULL},
| 68683 | {(char*)"pyramid_level", (getter)pyopencv_linemod_Template_get_pyramid_level, NULL, (char*)"pyramid_level", NULL}, |  | 68635 | {(char*)"pyramid_level", (getter)pyopencv_linemod_Template_get_pyramid_level, NULL, (char*)"pyramid_level", NULL},
| 68684 | {(char*)"width", (getter)pyopencv_linemod_Template_get_width, NULL, (char*)"width", NULL}, |  | 68636 | {(char*)"width", (getter)pyopencv_linemod_Template_get_width, NULL, (char*)"width", NULL},
| 68685 | {NULL} /* Sentinel */ |  | 68637 | {NULL} /* Sentinel */
| 68686 | }; |  | 68638 | };
| 68687 |  |  | 68639 |
| 68688 | static PyMethodDef pyopencv_linemod_Template_methods[] = |  | 68640 | static PyMethodDef pyopencv_linemod_Template_methods[] =
| 68689 | { |  | 68641 | {
| 68690 |  |  | 68642 |
| 68691 | {NULL, NULL} |  | 68643 | {NULL, NULL}
| 68692 | }; |  | 68644 | };
| 68693 |  |  | 68645 |
| 68694 | // Converter (linemod_Template) |  | 68646 | // Converter (linemod_Template)
| 68695 |  |  | 68647 |
| 68696 | template<> |  | 68648 | template<>
| 68697 | struct PyOpenCV_Converter< cv::linemod::Template > |  | 68649 | struct PyOpenCV_Converter< cv::linemod::Template >
| 68698 | { |  | 68650 | {
| 68699 | static PyObject* from(const cv::linemod::Template& r) |  | 68651 | static PyObject* from(const cv::linemod::Template& r)
| 68700 | { |  | 68652 | {
| 68701 | return pyopencv_linemod_Template_Instance(r); |  | 68653 | return pyopencv_linemod_Template_Instance(r);
| 68702 | } |  | 68654 | }
| 68703 | static bool to(PyObject* src, cv::linemod::Template& dst, const ArgInfo& info) |  | 68655 | static bool to(PyObject* src, cv::linemod::Template& dst, const ArgInfo& info)
| 68704 | { |  | 68656 | {
| 68705 | if(!src || src == Py_None) |  | 68657 | if(!src || src == Py_None)
| 68706 | return true; |  | 68658 | return true;
| 68707 | cv::linemod::Template * dst_; |  | 68659 | cv::linemod::Template * dst_;
| 68708 | if (pyopencv_linemod_Template_getp(src, dst_)) |  | 68660 | if (pyopencv_linemod_Template_getp(src, dst_))
| 68709 | { |  | 68661 | {
| 68710 | dst = *dst_; |  | 68662 | dst = *dst_;
| 68711 | return true; |  | 68663 | return true;
| 68712 | } |  | 68664 | }
| 68713 |  |  | 68665 |
| 68714 | failmsg("Expected cv::linemod::Template for argument '%s'", info.name); |  | 68666 | failmsg("Expected cv::linemod::Template for argument '%s'", info.name);
| 68715 | return false; |  | 68667 | return false;
| 68716 | } |  | 68668 | }
| 68717 | }; |  | 68669 | };
| 68718 |  |  | 68670 |
| 68719 | //================================================================================ |  | 68671 | //================================================================================
| 68720 | // mcc_CChecker (Generic) |  | 68672 | // mcc_CChecker (Generic)
| 68721 | //================================================================================ |  | 68673 | //================================================================================
| 68722 |  |  | 68674 |
| 68723 | // GetSet (mcc_CChecker) |  | 68675 | // GetSet (mcc_CChecker)
| 68724 |  |  | 68676 |
| 68725 |  |  | 68677 |
| 68726 |  |  | 68678 |
| 68727 | // Methods (mcc_CChecker) |  | 68679 | // Methods (mcc_CChecker)
| 68728 |  |  | 68680 |
| 68729 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68681 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 68730 | { |  | 68682 | {
| 68731 | using namespace cv::mcc; |  | 68683 | using namespace cv::mcc;
| 68732 |  |  | 68684 |
| 68733 | Ptr<CChecker> retval; |  | 68685 | Ptr<CChecker> retval;
| 68734 |  |  | 68686 |
| 68735 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68687 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68736 | { |  | 68688 | {
| 68737 | ERRWRAP2(retval = cv::mcc::CChecker::create()); |  | 68689 | ERRWRAP2(retval = cv::mcc::CChecker::create());
| 68738 | return pyopencv_from(retval); |  | 68690 | return pyopencv_from(retval);
| 68739 | } |  | 68691 | }
| 68740 |  |  | 68692 |
| 68741 | return NULL; |  | 68693 | return NULL;
| 68742 | } |  | 68694 | }
| 68743 |  |  | 68695 |
| 68744 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getBox(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68696 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getBox(PyObject* self, PyObject* py_args, PyObject* kw)
| 68745 | { |  | 68697 | {
| 68746 | using namespace cv::mcc; |  | 68698 | using namespace cv::mcc;
| 68747 |  |  | 68699 |
| 68748 |  |  | 68700 |
| 68749 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68701 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68750 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68702 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68751 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68703 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68752 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68704 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68753 | std::vector<Point2f> retval; |  | 68705 | std::vector<Point2f> retval;
| 68754 |  |  | 68706 |
| 68755 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68707 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68756 | { |  | 68708 | {
| 68757 | ERRWRAP2(retval = _self_->getBox()); |  | 68709 | ERRWRAP2(retval = _self_->getBox());
| 68758 | return pyopencv_from(retval); |  | 68710 | return pyopencv_from(retval);
| 68759 | } |  | 68711 | }
| 68760 |  |  | 68712 |
| 68761 | return NULL; |  | 68713 | return NULL;
| 68762 | } |  | 68714 | }
| 68763 |  |  | 68715 |
| 68764 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getCenter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68716 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getCenter(PyObject* self, PyObject* py_args, PyObject* kw)
| 68765 | { |  | 68717 | {
| 68766 | using namespace cv::mcc; |  | 68718 | using namespace cv::mcc;
| 68767 |  |  | 68719 |
| 68768 |  |  | 68720 |
| 68769 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68721 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68770 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68722 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68771 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68723 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68772 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68724 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68773 | Point2f retval; |  | 68725 | Point2f retval;
| 68774 |  |  | 68726 |
| 68775 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68727 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68776 | { |  | 68728 | {
| 68777 | ERRWRAP2(retval = _self_->getCenter()); |  | 68729 | ERRWRAP2(retval = _self_->getCenter());
| 68778 | return pyopencv_from(retval); |  | 68730 | return pyopencv_from(retval);
| 68779 | } |  | 68731 | }
| 68780 |  |  | 68732 |
| 68781 | return NULL; |  | 68733 | return NULL;
| 68782 | } |  | 68734 | }
| 68783 |  |  | 68735 |
| 68784 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getChartsRGB(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68736 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getChartsRGB(PyObject* self, PyObject* py_args, PyObject* kw)
| 68785 | { |  | 68737 | {
| 68786 | using namespace cv::mcc; |  | 68738 | using namespace cv::mcc;
| 68787 |  |  | 68739 |
| 68788 |  |  | 68740 |
| 68789 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68741 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68790 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68742 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68791 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68743 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68792 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68744 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68793 | Mat retval; |  | 68745 | Mat retval;
| 68794 |  |  | 68746 |
| 68795 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68747 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68796 | { |  | 68748 | {
| 68797 | ERRWRAP2(retval = _self_->getChartsRGB()); |  | 68749 | ERRWRAP2(retval = _self_->getChartsRGB());
| 68798 | return pyopencv_from(retval); |  | 68750 | return pyopencv_from(retval);
| 68799 | } |  | 68751 | }
| 68800 |  |  | 68752 |
| 68801 | return NULL; |  | 68753 | return NULL;
| 68802 | } |  | 68754 | }
| 68803 |  |  | 68755 |
| 68804 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getChartsYCbCr(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68756 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getChartsYCbCr(PyObject* self, PyObject* py_args, PyObject* kw)
| 68805 | { |  | 68757 | {
| 68806 | using namespace cv::mcc; |  | 68758 | using namespace cv::mcc;
| 68807 |  |  | 68759 |
| 68808 |  |  | 68760 |
| 68809 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68761 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68810 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68762 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68811 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68763 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68812 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68764 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68813 | Mat retval; |  | 68765 | Mat retval;
| 68814 |  |  | 68766 |
| 68815 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68767 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68816 | { |  | 68768 | {
| 68817 | ERRWRAP2(retval = _self_->getChartsYCbCr()); |  | 68769 | ERRWRAP2(retval = _self_->getChartsYCbCr());
| 68818 | return pyopencv_from(retval); |  | 68770 | return pyopencv_from(retval);
| 68819 | } |  | 68771 | }
| 68820 |  |  | 68772 |
| 68821 | return NULL; |  | 68773 | return NULL;
| 68822 | } |  | 68774 | }
| 68823 |  |  | 68775 |
| 68824 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getColorCharts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68776 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getColorCharts(PyObject* self, PyObject* py_args, PyObject* kw)
| 68825 | { |  | 68777 | {
| 68826 | using namespace cv::mcc; |  | 68778 | using namespace cv::mcc;
| 68827 |  |  | 68779 |
| 68828 |  |  | 68780 |
| 68829 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68781 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68830 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68782 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68831 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68783 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68832 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68784 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68833 | std::vector<Point2f> retval; |  | 68785 | std::vector<Point2f> retval;
| 68834 |  |  | 68786 |
| 68835 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68787 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68836 | { |  | 68788 | {
| 68837 | ERRWRAP2(retval = _self_->getColorCharts()); |  | 68789 | ERRWRAP2(retval = _self_->getColorCharts());
| 68838 | return pyopencv_from(retval); |  | 68790 | return pyopencv_from(retval);
| 68839 | } |  | 68791 | }
| 68840 |  |  | 68792 |
| 68841 | return NULL; |  | 68793 | return NULL;
| 68842 | } |  | 68794 | }
| 68843 |  |  | 68795 |
| 68844 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getCost(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68796 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getCost(PyObject* self, PyObject* py_args, PyObject* kw)
| 68845 | { |  | 68797 | {
| 68846 | using namespace cv::mcc; |  | 68798 | using namespace cv::mcc;
| 68847 |  |  | 68799 |
| 68848 |  |  | 68800 |
| 68849 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68801 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68850 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68802 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68851 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68803 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68852 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68804 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68853 | float retval; |  | 68805 | float retval;
| 68854 |  |  | 68806 |
| 68855 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68807 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68856 | { |  | 68808 | {
| 68857 | ERRWRAP2(retval = _self_->getCost()); |  | 68809 | ERRWRAP2(retval = _self_->getCost());
| 68858 | return pyopencv_from(retval); |  | 68810 | return pyopencv_from(retval);
| 68859 | } |  | 68811 | }
| 68860 |  |  | 68812 |
| 68861 | return NULL; |  | 68813 | return NULL;
| 68862 | } |  | 68814 | }
| 68863 |  |  | 68815 |
| 68864 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getTarget(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68816 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_getTarget(PyObject* self, PyObject* py_args, PyObject* kw)
| 68865 | { |  | 68817 | {
| 68866 | using namespace cv::mcc; |  | 68818 | using namespace cv::mcc;
| 68867 |  |  | 68819 |
| 68868 |  |  | 68820 |
| 68869 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68821 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68870 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68822 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68871 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68823 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68872 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68824 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68873 | TYPECHART retval; |  | 68825 | TYPECHART retval;
| 68874 |  |  | 68826 |
| 68875 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 68827 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 68876 | { |  | 68828 | {
| 68877 | ERRWRAP2(retval = _self_->getTarget()); |  | 68829 | ERRWRAP2(retval = _self_->getTarget());
| 68878 | return pyopencv_from(retval); |  | 68830 | return pyopencv_from(retval);
| 68879 | } |  | 68831 | }
| 68880 |  |  | 68832 |
| 68881 | return NULL; |  | 68833 | return NULL;
| 68882 | } |  | 68834 | }
| 68883 |  |  | 68835 |
| 68884 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setBox(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68836 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setBox(PyObject* self, PyObject* py_args, PyObject* kw)
| 68885 | { |  | 68837 | {
| 68886 | using namespace cv::mcc; |  | 68838 | using namespace cv::mcc;
| 68887 |  |  | 68839 |
| 68888 |  |  | 68840 |
| 68889 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68841 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68890 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68842 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68891 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68843 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68892 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68844 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68893 | PyObject* pyobj__box = NULL; |  | 68845 | PyObject* pyobj__box = NULL;
| 68894 | vector_Point2f _box; |  | 68846 | vector_Point2f _box;
| 68895 |  |  | 68847 |
| 68896 | const char* keywords[] = { "_box", NULL }; |  | 68848 | const char* keywords[] = { "_box", NULL };
| 68897 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setBox", (char**)keywords, &pyobj__box) && |  | 68849 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setBox", (char**)keywords, &pyobj__box) &&
| 68898 | pyopencv_to_safe(pyobj__box, _box, ArgInfo("_box", 0)) ) |  | 68850 | pyopencv_to_safe(pyobj__box, _box, ArgInfo("_box", 0)) )
| 68899 | { |  | 68851 | {
| 68900 | ERRWRAP2(_self_->setBox(_box)); |  | 68852 | ERRWRAP2(_self_->setBox(_box));
| 68901 | Py_RETURN_NONE; |  | 68853 | Py_RETURN_NONE;
| 68902 | } |  | 68854 | }
| 68903 |  |  | 68855 |
| 68904 | return NULL; |  | 68856 | return NULL;
| 68905 | } |  | 68857 | }
| 68906 |  |  | 68858 |
| 68907 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setCenter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68859 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setCenter(PyObject* self, PyObject* py_args, PyObject* kw)
| 68908 | { |  | 68860 | {
| 68909 | using namespace cv::mcc; |  | 68861 | using namespace cv::mcc;
| 68910 |  |  | 68862 |
| 68911 |  |  | 68863 |
| 68912 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68864 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68913 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68865 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68914 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68866 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68915 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68867 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68916 | PyObject* pyobj__center = NULL; |  | 68868 | PyObject* pyobj__center = NULL;
| 68917 | Point2f _center; |  | 68869 | Point2f _center;
| 68918 |  |  | 68870 |
| 68919 | const char* keywords[] = { "_center", NULL }; |  | 68871 | const char* keywords[] = { "_center", NULL };
| 68920 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setCenter", (char**)keywords, &pyobj__center) && |  | 68872 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setCenter", (char**)keywords, &pyobj__center) &&
| 68921 | pyopencv_to_safe(pyobj__center, _center, ArgInfo("_center", 0)) ) |  | 68873 | pyopencv_to_safe(pyobj__center, _center, ArgInfo("_center", 0)) )
| 68922 | { |  | 68874 | {
| 68923 | ERRWRAP2(_self_->setCenter(_center)); |  | 68875 | ERRWRAP2(_self_->setCenter(_center));
| 68924 | Py_RETURN_NONE; |  | 68876 | Py_RETURN_NONE;
| 68925 | } |  | 68877 | }
| 68926 |  |  | 68878 |
| 68927 | return NULL; |  | 68879 | return NULL;
| 68928 | } |  | 68880 | }
| 68929 |  |  | 68881 |
| 68930 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setChartsRGB(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68882 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setChartsRGB(PyObject* self, PyObject* py_args, PyObject* kw)
| 68931 | { |  | 68883 | {
| 68932 | using namespace cv::mcc; |  | 68884 | using namespace cv::mcc;
| 68933 |  |  | 68885 |
| 68934 |  |  | 68886 |
| 68935 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68887 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68936 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68888 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68937 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68889 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68938 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68890 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68939 | PyObject* pyobj__chartsRGB = NULL; |  | 68891 | PyObject* pyobj__chartsRGB = NULL;
| 68940 | Mat _chartsRGB; |  | 68892 | Mat _chartsRGB;
| 68941 |  |  | 68893 |
| 68942 | const char* keywords[] = { "_chartsRGB", NULL }; |  | 68894 | const char* keywords[] = { "_chartsRGB", NULL };
| 68943 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setChartsRGB", (char**)keywords, &pyobj__chartsRGB) && |  | 68895 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setChartsRGB", (char**)keywords, &pyobj__chartsRGB) &&
| 68944 | pyopencv_to_safe(pyobj__chartsRGB, _chartsRGB, ArgInfo("_chartsRGB", 0)) ) |  | 68896 | pyopencv_to_safe(pyobj__chartsRGB, _chartsRGB, ArgInfo("_chartsRGB", 0)) )
| 68945 | { |  | 68897 | {
| 68946 | ERRWRAP2(_self_->setChartsRGB(_chartsRGB)); |  | 68898 | ERRWRAP2(_self_->setChartsRGB(_chartsRGB));
| 68947 | Py_RETURN_NONE; |  | 68899 | Py_RETURN_NONE;
| 68948 | } |  | 68900 | }
| 68949 |  |  | 68901 |
| 68950 | return NULL; |  | 68902 | return NULL;
| 68951 | } |  | 68903 | }
| 68952 |  |  | 68904 |
| 68953 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setChartsYCbCr(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68905 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setChartsYCbCr(PyObject* self, PyObject* py_args, PyObject* kw)
| 68954 | { |  | 68906 | {
| 68955 | using namespace cv::mcc; |  | 68907 | using namespace cv::mcc;
| 68956 |  |  | 68908 |
| 68957 |  |  | 68909 |
| 68958 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68910 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68959 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68911 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68960 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68912 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68961 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68913 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68962 | PyObject* pyobj__chartsYCbCr = NULL; |  | 68914 | PyObject* pyobj__chartsYCbCr = NULL;
| 68963 | Mat _chartsYCbCr; |  | 68915 | Mat _chartsYCbCr;
| 68964 |  |  | 68916 |
| 68965 | const char* keywords[] = { "_chartsYCbCr", NULL }; |  | 68917 | const char* keywords[] = { "_chartsYCbCr", NULL };
| 68966 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setChartsYCbCr", (char**)keywords, &pyobj__chartsYCbCr) && |  | 68918 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setChartsYCbCr", (char**)keywords, &pyobj__chartsYCbCr) &&
| 68967 | pyopencv_to_safe(pyobj__chartsYCbCr, _chartsYCbCr, ArgInfo("_chartsYCbCr", 0)) ) |  | 68919 | pyopencv_to_safe(pyobj__chartsYCbCr, _chartsYCbCr, ArgInfo("_chartsYCbCr", 0)) )
| 68968 | { |  | 68920 | {
| 68969 | ERRWRAP2(_self_->setChartsYCbCr(_chartsYCbCr)); |  | 68921 | ERRWRAP2(_self_->setChartsYCbCr(_chartsYCbCr));
| 68970 | Py_RETURN_NONE; |  | 68922 | Py_RETURN_NONE;
| 68971 | } |  | 68923 | }
| 68972 |  |  | 68924 |
| 68973 | return NULL; |  | 68925 | return NULL;
| 68974 | } |  | 68926 | }
| 68975 |  |  | 68927 |
| 68976 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setCost(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68928 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setCost(PyObject* self, PyObject* py_args, PyObject* kw)
| 68977 | { |  | 68929 | {
| 68978 | using namespace cv::mcc; |  | 68930 | using namespace cv::mcc;
| 68979 |  |  | 68931 |
| 68980 |  |  | 68932 |
| 68981 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68933 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 68982 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68934 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 68983 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68935 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 68984 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68936 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 68985 | PyObject* pyobj__cost = NULL; |  | 68937 | PyObject* pyobj__cost = NULL;
| 68986 | float _cost=0.f; |  | 68938 | float _cost=0.f;
| 68987 |  |  | 68939 |
| 68988 | const char* keywords[] = { "_cost", NULL }; |  | 68940 | const char* keywords[] = { "_cost", NULL };
| 68989 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setCost", (char**)keywords, &pyobj__cost) && |  | 68941 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setCost", (char**)keywords, &pyobj__cost) &&
| 68990 | pyopencv_to_safe(pyobj__cost, _cost, ArgInfo("_cost", 0)) ) |  | 68942 | pyopencv_to_safe(pyobj__cost, _cost, ArgInfo("_cost", 0)) )
| 68991 | { |  | 68943 | {
| 68992 | ERRWRAP2(_self_->setCost(_cost)); |  | 68944 | ERRWRAP2(_self_->setCost(_cost));
| 68993 | Py_RETURN_NONE; |  | 68945 | Py_RETURN_NONE;
| 68994 | } |  | 68946 | }
| 68995 |  |  | 68947 |
| 68996 | return NULL; |  | 68948 | return NULL;
| 68997 | } |  | 68949 | }
| 68998 |  |  | 68950 |
| 68999 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setTarget(PyObject* self, PyObject* py_args, PyObject* kw) |  | 68951 | static PyObject* pyopencv_cv_mcc_mcc_CChecker_setTarget(PyObject* self, PyObject* py_args, PyObject* kw)
| 69000 | { |  | 68952 | {
| 69001 | using namespace cv::mcc; |  | 68953 | using namespace cv::mcc;
| 69002 |  |  | 68954 |
| 69003 |  |  | 68955 |
| 69004 | Ptr<cv::mcc::CChecker> * self1 = 0; |  | 68956 | Ptr<cv::mcc::CChecker> * self1 = 0;
| 69005 | if (!pyopencv_mcc_CChecker_getp(self, self1)) |  | 68957 | if (!pyopencv_mcc_CChecker_getp(self, self1))
| 69006 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)"); |  | 68958 | return failmsgp("Incorrect type of self (must be 'mcc_CChecker' or its derivative)");
| 69007 | Ptr<cv::mcc::CChecker> _self_ = *(self1); |  | 68959 | Ptr<cv::mcc::CChecker> _self_ = *(self1);
| 69008 | PyObject* pyobj__target = NULL; |  | 68960 | PyObject* pyobj__target = NULL;
| 69009 | TYPECHART _target=static_cast<TYPECHART>(0); |  | 68961 | TYPECHART _target=static_cast<TYPECHART>(0);
| 69010 |  |  | 68962 |
| 69011 | const char* keywords[] = { "_target", NULL }; |  | 68963 | const char* keywords[] = { "_target", NULL };
| 69012 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setTarget", (char**)keywords, &pyobj__target) && |  | 68964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CChecker.setTarget", (char**)keywords, &pyobj__target) &&
| 69013 | pyopencv_to_safe(pyobj__target, _target, ArgInfo("_target", 0)) ) |  | 68965 | pyopencv_to_safe(pyobj__target, _target, ArgInfo("_target", 0)) )
| 69014 | { |  | 68966 | {
| 69015 | ERRWRAP2(_self_->setTarget(_target)); |  | 68967 | ERRWRAP2(_self_->setTarget(_target));
| 69016 | Py_RETURN_NONE; |  | 68968 | Py_RETURN_NONE;
| 69017 | } |  | 68969 | }
| 69018 |  |  | 68970 |
| 69019 | return NULL; |  | 68971 | return NULL;
| 69020 | } |  | 68972 | }
| 69021 |  |  | 68973 |
| 69022 |  |  | 68974 |
| 69023 |  |  | 68975 |
| 69024 | // Tables (mcc_CChecker) |  | 68976 | // Tables (mcc_CChecker)
| 69025 |  |  | 68977 |
| 69026 | static PyGetSetDef pyopencv_mcc_CChecker_getseters[] = |  | 68978 | static PyGetSetDef pyopencv_mcc_CChecker_getseters[] =
| 69027 | { |  | 68979 | {
| 69028 | {NULL} /* Sentinel */ |  | 68980 | {NULL} /* Sentinel */
| 69029 | }; |  | 68981 | };
| 69030 |  |  | 68982 |
| 69031 | static PyMethodDef pyopencv_mcc_CChecker_methods[] = |  | 68983 | static PyMethodDef pyopencv_mcc_CChecker_methods[] =
| 69032 | { |  | 68984 | {
| 69033 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_create_static, METH_STATIC), "create() -> retval\n. \\brief Create a new CChecker object.\n. * \\return A pointer to the implementation of the CChecker"}, |  | 68985 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_create_static, METH_STATIC), "create() -> retval\n. \\brief Create a new CChecker object.\n. * \\return A pointer to the implementation of the CChecker"},
| 69034 | {"getBox", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getBox, 0), "getBox() -> retval\n."}, |  | 68986 | {"getBox", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getBox, 0), "getBox() -> retval\n."},
| 69035 | {"getCenter", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getCenter, 0), "getCenter() -> retval\n."}, |  | 68987 | {"getCenter", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getCenter, 0), "getCenter() -> retval\n."},
| 69036 | {"getChartsRGB", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getChartsRGB, 0), "getChartsRGB() -> retval\n."}, |  | 68988 | {"getChartsRGB", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getChartsRGB, 0), "getChartsRGB() -> retval\n."},
| 69037 | {"getChartsYCbCr", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getChartsYCbCr, 0), "getChartsYCbCr() -> retval\n."}, |  | 68989 | {"getChartsYCbCr", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getChartsYCbCr, 0), "getChartsYCbCr() -> retval\n."},
| 69038 | {"getColorCharts", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getColorCharts, 0), "getColorCharts() -> retval\n. @brief Computes and returns the coordinates of the central parts of the charts modules.\n. *\n. * This method computes transformation matrix from the checkers's coordinates (`cv::mcc::CChecker::getBox()`)\n. * and find by this the coordinates of the central parts of the charts modules.\n. * It is used in `cv::mcc::CCheckerDraw::draw()` and in `ChartsRGB` calculation."}, |  | 68990 | {"getColorCharts", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getColorCharts, 0), "getColorCharts() -> retval\n. @brief Computes and returns the coordinates of the central parts of the charts modules.\n. *\n. * This method computes transformation matrix from the checkers's coordinates (`cv::mcc::CChecker::getBox()`)\n. * and find by this the coordinates of the central parts of the charts modules.\n. * It is used in `cv::mcc::CCheckerDraw::draw()` and in `ChartsRGB` calculation."},
| 69039 | {"getCost", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getCost, 0), "getCost() -> retval\n."}, |  | 68991 | {"getCost", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getCost, 0), "getCost() -> retval\n."},
| 69040 | {"getTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getTarget, 0), "getTarget() -> retval\n."}, |  | 68992 | {"getTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_getTarget, 0), "getTarget() -> retval\n."},
| 69041 | {"setBox", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setBox, 0), "setBox(_box) -> None\n."}, |  | 68993 | {"setBox", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setBox, 0), "setBox(_box) -> None\n."},
| 69042 | {"setCenter", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setCenter, 0), "setCenter(_center) -> None\n."}, |  | 68994 | {"setCenter", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setCenter, 0), "setCenter(_center) -> None\n."},
| 69043 | {"setChartsRGB", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setChartsRGB, 0), "setChartsRGB(_chartsRGB) -> None\n."}, |  | 68995 | {"setChartsRGB", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setChartsRGB, 0), "setChartsRGB(_chartsRGB) -> None\n."},
| 69044 | {"setChartsYCbCr", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setChartsYCbCr, 0), "setChartsYCbCr(_chartsYCbCr) -> None\n."}, |  | 68996 | {"setChartsYCbCr", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setChartsYCbCr, 0), "setChartsYCbCr(_chartsYCbCr) -> None\n."},
| 69045 | {"setCost", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setCost, 0), "setCost(_cost) -> None\n."}, |  | 68997 | {"setCost", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setCost, 0), "setCost(_cost) -> None\n."},
| 69046 | {"setTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setTarget, 0), "setTarget(_target) -> None\n."}, |  | 68998 | {"setTarget", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CChecker_setTarget, 0), "setTarget(_target) -> None\n."},
| 69047 |  |  | 68999 |
| 69048 | {NULL, NULL} |  | 69000 | {NULL, NULL}
| 69049 | }; |  | 69001 | };
| 69050 |  |  | 69002 |
| 69051 | // Converter (mcc_CChecker) |  | 69003 | // Converter (mcc_CChecker)
| 69052 |  |  | 69004 |
| 69053 | template<> |  | 69005 | template<>
| 69054 | struct PyOpenCV_Converter< Ptr<cv::mcc::CChecker> > |  | 69006 | struct PyOpenCV_Converter< Ptr<cv::mcc::CChecker> >
| 69055 | { |  | 69007 | {
| 69056 | static PyObject* from(const Ptr<cv::mcc::CChecker>& r) |  | 69008 | static PyObject* from(const Ptr<cv::mcc::CChecker>& r)
| 69057 | { |  | 69009 | {
| 69058 | return pyopencv_mcc_CChecker_Instance(r); |  | 69010 | return pyopencv_mcc_CChecker_Instance(r);
| 69059 | } |  | 69011 | }
| 69060 | static bool to(PyObject* src, Ptr<cv::mcc::CChecker>& dst, const ArgInfo& info) |  | 69012 | static bool to(PyObject* src, Ptr<cv::mcc::CChecker>& dst, const ArgInfo& info)
| 69061 | { |  | 69013 | {
| 69062 | if(!src || src == Py_None) |  | 69014 | if(!src || src == Py_None)
| 69063 | return true; |  | 69015 | return true;
| 69064 | Ptr<cv::mcc::CChecker> * dst_; |  | 69016 | Ptr<cv::mcc::CChecker> * dst_;
| 69065 | if (pyopencv_mcc_CChecker_getp(src, dst_)) |  | 69017 | if (pyopencv_mcc_CChecker_getp(src, dst_))
| 69066 | { |  | 69018 | {
| 69067 | dst = *dst_; |  | 69019 | dst = *dst_;
| 69068 | return true; |  | 69020 | return true;
| 69069 | } |  | 69021 | }
| 69070 |  |  | 69022 |
| 69071 | failmsg("Expected Ptr<cv::mcc::CChecker> for argument '%s'", info.name); |  | 69023 | failmsg("Expected Ptr<cv::mcc::CChecker> for argument '%s'", info.name);
| 69072 | return false; |  | 69024 | return false;
| 69073 | } |  | 69025 | }
| 69074 | }; |  | 69026 | };
| 69075 |  |  | 69027 |
| 69076 | //================================================================================ |  | 69028 | //================================================================================
| 69077 | // mcc_CCheckerDetector (Generic) |  | 69029 | // mcc_CCheckerDetector (Generic)
| 69078 | //================================================================================ |  | 69030 | //================================================================================
| 69079 |  |  | 69031 |
| 69080 | // GetSet (mcc_CCheckerDetector) |  | 69032 | // GetSet (mcc_CCheckerDetector)
| 69081 |  |  | 69033 |
| 69082 |  |  | 69034 |
| 69083 |  |  | 69035 |
| 69084 | // Methods (mcc_CCheckerDetector) |  | 69036 | // Methods (mcc_CCheckerDetector)
| 69085 |  |  | 69037 |
| 69086 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69038 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 69087 | { |  | 69039 | {
| 69088 | using namespace cv::mcc; |  | 69040 | using namespace cv::mcc;
| 69089 |  |  | 69041 |
| 69090 | Ptr<CCheckerDetector> retval; |  | 69042 | Ptr<CCheckerDetector> retval;
| 69091 |  |  | 69043 |
| 69092 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69044 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69093 | { |  | 69045 | {
| 69094 | ERRWRAP2(retval = cv::mcc::CCheckerDetector::create()); |  | 69046 | ERRWRAP2(retval = cv::mcc::CCheckerDetector::create());
| 69095 | return pyopencv_from(retval); |  | 69047 | return pyopencv_from(retval);
| 69096 | } |  | 69048 | }
| 69097 |  |  | 69049 |
| 69098 | return NULL; |  | 69050 | return NULL;
| 69099 | } |  | 69051 | }
| 69100 |  |  | 69052 |
| 69101 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_getBestColorChecker(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69053 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_getBestColorChecker(PyObject* self, PyObject* py_args, PyObject* kw)
| 69102 | { |  | 69054 | {
| 69103 | using namespace cv::mcc; |  | 69055 | using namespace cv::mcc;
| 69104 |  |  | 69056 |
| 69105 |  |  | 69057 |
| 69106 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0; |  | 69058 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0;
| 69107 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1)) |  | 69059 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1))
| 69108 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)"); |  | 69060 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)");
| 69109 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1); |  | 69061 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1);
| 69110 | Ptr<mcc::CChecker> retval; |  | 69062 | Ptr<mcc::CChecker> retval;
| 69111 |  |  | 69063 |
| 69112 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69064 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69113 | { |  | 69065 | {
| 69114 | ERRWRAP2(retval = _self_->getBestColorChecker()); |  | 69066 | ERRWRAP2(retval = _self_->getBestColorChecker());
| 69115 | return pyopencv_from(retval); |  | 69067 | return pyopencv_from(retval);
| 69116 | } |  | 69068 | }
| 69117 |  |  | 69069 |
| 69118 | return NULL; |  | 69070 | return NULL;
| 69119 | } |  | 69071 | }
| 69120 |  |  | 69072 |
| 69121 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_getListColorChecker(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69073 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_getListColorChecker(PyObject* self, PyObject* py_args, PyObject* kw)
| 69122 | { |  | 69074 | {
| 69123 | using namespace cv::mcc; |  | 69075 | using namespace cv::mcc;
| 69124 |  |  | 69076 |
| 69125 |  |  | 69077 |
| 69126 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0; |  | 69078 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0;
| 69127 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1)) |  | 69079 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1))
| 69128 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)"); |  | 69080 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)");
| 69129 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1); |  | 69081 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1);
| 69130 | std::vector<Ptr<CChecker>> retval; |  | 69082 | std::vector<Ptr<CChecker>> retval;
| 69131 |  |  | 69083 |
| 69132 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69084 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69133 | { |  | 69085 | {
| 69134 | ERRWRAP2(retval = _self_->getListColorChecker()); |  | 69086 | ERRWRAP2(retval = _self_->getListColorChecker());
| 69135 | return pyopencv_from(retval); |  | 69087 | return pyopencv_from(retval);
| 69136 | } |  | 69088 | }
| 69137 |  |  | 69089 |
| 69138 | return NULL; |  | 69090 | return NULL;
| 69139 | } |  | 69091 | }
| 69140 |  |  | 69092 |
| 69141 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69093 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 69142 | { |  | 69094 | {
| 69143 | using namespace cv::mcc; |  | 69095 | using namespace cv::mcc;
| 69144 |  |  | 69096 |
| 69145 |  |  | 69097 |
| 69146 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0; |  | 69098 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0;
| 69147 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1)) |  | 69099 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1))
| 69148 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)"); |  | 69100 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)");
| 69149 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1); |  | 69101 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1);
| 69150 | pyPrepareArgumentConversionErrorsStorage(2); |  | 69102 | pyPrepareArgumentConversionErrorsStorage(2);
| 69151 |  |  | 69103 |
| 69152 | { |  | 69104 | {
| 69153 | PyObject* pyobj_image = NULL; |  | 69105 | PyObject* pyobj_image = NULL;
| 69154 | Mat image; |  | 69106 | Mat image;
| 69155 | PyObject* pyobj_chartType = NULL; |  | 69107 | PyObject* pyobj_chartType = NULL;
| 69156 | TYPECHART chartType=static_cast<TYPECHART>(0); |  | 69108 | TYPECHART chartType=static_cast<TYPECHART>(0);
| 69157 | PyObject* pyobj_nc = NULL; |  | 69109 | PyObject* pyobj_nc = NULL;
| 69158 | int nc=1; |  | 69110 | int nc=1;
| 69159 | PyObject* pyobj_useNet = NULL; |  | 69111 | PyObject* pyobj_useNet = NULL;
| 69160 | bool useNet=false; |  | 69112 | bool useNet=false;
| 69161 | PyObject* pyobj_params = NULL; |  | 69113 | PyObject* pyobj_params = NULL;
| 69162 | Ptr<DetectorParameters> params=DetectorParameters::create(); |  | 69114 | Ptr<DetectorParameters> params=DetectorParameters::create();
| 69163 | bool retval; |  | 69115 | bool retval;
| 69164 |  |  | 69116 |
| 69165 | const char* keywords[] = { "image", "chartType", "nc", "useNet", "params", NULL }; |  | 69117 | const char* keywords[] = { "image", "chartType", "nc", "useNet", "params", NULL };
| 69166 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:mcc_CCheckerDetector.process", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_nc, &pyobj_useNet, &pyobj_params) && |  | 69118 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:mcc_CCheckerDetector.process", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_nc, &pyobj_useNet, &pyobj_params) &&
| 69167 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 69119 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 69168 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) && |  | 69120 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) &&
| 69169 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) && |  | 69121 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) &&
| 69170 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) && |  | 69122 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) &&
| 69171 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 69123 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 69172 | { |  | 69124 | {
| 69173 | ERRWRAP2(retval = _self_->process(image, chartType, nc, useNet, params)); |  | 69125 | ERRWRAP2(retval = _self_->process(image, chartType, nc, useNet, params));
| 69174 | return pyopencv_from(retval); |  | 69126 | return pyopencv_from(retval);
| 69175 | } |  | 69127 | }
| 69176 |  |  | 69128 |
| 69177 |  |  | 69129 |
| 69178 | pyPopulateArgumentConversionErrors(); |  | 69130 | pyPopulateArgumentConversionErrors();
| 69179 | } |  | 69131 | }
| 69180 |  |  | 69132 |
| 69181 |  |  | 69133 |
| 69182 | { |  | 69134 | {
| 69183 | PyObject* pyobj_image = NULL; |  | 69135 | PyObject* pyobj_image = NULL;
| 69184 | UMat image; |  | 69136 | UMat image;
| 69185 | PyObject* pyobj_chartType = NULL; |  | 69137 | PyObject* pyobj_chartType = NULL;
| 69186 | TYPECHART chartType=static_cast<TYPECHART>(0); |  | 69138 | TYPECHART chartType=static_cast<TYPECHART>(0);
| 69187 | PyObject* pyobj_nc = NULL; |  | 69139 | PyObject* pyobj_nc = NULL;
| 69188 | int nc=1; |  | 69140 | int nc=1;
| 69189 | PyObject* pyobj_useNet = NULL; |  | 69141 | PyObject* pyobj_useNet = NULL;
| 69190 | bool useNet=false; |  | 69142 | bool useNet=false;
| 69191 | PyObject* pyobj_params = NULL; |  | 69143 | PyObject* pyobj_params = NULL;
| 69192 | Ptr<DetectorParameters> params=DetectorParameters::create(); |  | 69144 | Ptr<DetectorParameters> params=DetectorParameters::create();
| 69193 | bool retval; |  | 69145 | bool retval;
| 69194 |  |  | 69146 |
| 69195 | const char* keywords[] = { "image", "chartType", "nc", "useNet", "params", NULL }; |  | 69147 | const char* keywords[] = { "image", "chartType", "nc", "useNet", "params", NULL };
| 69196 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:mcc_CCheckerDetector.process", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_nc, &pyobj_useNet, &pyobj_params) && |  | 69148 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:mcc_CCheckerDetector.process", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_nc, &pyobj_useNet, &pyobj_params) &&
| 69197 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 69149 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 69198 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) && |  | 69150 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) &&
| 69199 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) && |  | 69151 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) &&
| 69200 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) && |  | 69152 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) &&
| 69201 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 69153 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 69202 | { |  | 69154 | {
| 69203 | ERRWRAP2(retval = _self_->process(image, chartType, nc, useNet, params)); |  | 69155 | ERRWRAP2(retval = _self_->process(image, chartType, nc, useNet, params));
| 69204 | return pyopencv_from(retval); |  | 69156 | return pyopencv_from(retval);
| 69205 | } |  | 69157 | }
| 69206 |  |  | 69158 |
| 69207 |  |  | 69159 |
| 69208 | pyPopulateArgumentConversionErrors(); |  | 69160 | pyPopulateArgumentConversionErrors();
| 69209 | } |  | 69161 | }
| 69210 | pyRaiseCVOverloadException("process"); |  | 69162 | pyRaiseCVOverloadException("process");
| 69211 |  |  | 69163 |
| 69212 | return NULL; |  | 69164 | return NULL;
| 69213 | } |  | 69165 | }
| 69214 |  |  | 69166 |
| 69215 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_processWithROI(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69167 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_processWithROI(PyObject* self, PyObject* py_args, PyObject* kw)
| 69216 | { |  | 69168 | {
| 69217 | using namespace cv::mcc; |  | 69169 | using namespace cv::mcc;
| 69218 |  |  | 69170 |
| 69219 |  |  | 69171 |
| 69220 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0; |  | 69172 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0;
| 69221 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1)) |  | 69173 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1))
| 69222 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)"); |  | 69174 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)");
| 69223 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1); |  | 69175 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1);
| 69224 | pyPrepareArgumentConversionErrorsStorage(2); |  | 69176 | pyPrepareArgumentConversionErrorsStorage(2);
| 69225 |  |  | 69177 |
| 69226 | { |  | 69178 | {
| 69227 | PyObject* pyobj_image = NULL; |  | 69179 | PyObject* pyobj_image = NULL;
| 69228 | Mat image; |  | 69180 | Mat image;
| 69229 | PyObject* pyobj_chartType = NULL; |  | 69181 | PyObject* pyobj_chartType = NULL;
| 69230 | TYPECHART chartType=static_cast<TYPECHART>(0); |  | 69182 | TYPECHART chartType=static_cast<TYPECHART>(0);
| 69231 | PyObject* pyobj_regionsOfInterest = NULL; |  | 69183 | PyObject* pyobj_regionsOfInterest = NULL;
| 69232 | vector_Rect regionsOfInterest; |  | 69184 | vector_Rect regionsOfInterest;
| 69233 | PyObject* pyobj_nc = NULL; |  | 69185 | PyObject* pyobj_nc = NULL;
| 69234 | int nc=1; |  | 69186 | int nc=1;
| 69235 | PyObject* pyobj_useNet = NULL; |  | 69187 | PyObject* pyobj_useNet = NULL;
| 69236 | bool useNet=false; |  | 69188 | bool useNet=false;
| 69237 | PyObject* pyobj_params = NULL; |  | 69189 | PyObject* pyobj_params = NULL;
| 69238 | Ptr<DetectorParameters> params=DetectorParameters::create(); |  | 69190 | Ptr<DetectorParameters> params=DetectorParameters::create();
| 69239 | bool retval; |  | 69191 | bool retval;
| 69240 |  |  | 69192 |
| 69241 | const char* keywords[] = { "image", "chartType", "regionsOfInterest", "nc", "useNet", "params", NULL }; |  | 69193 | const char* keywords[] = { "image", "chartType", "regionsOfInterest", "nc", "useNet", "params", NULL };
| 69242 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:mcc_CCheckerDetector.processWithROI", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_regionsOfInterest, &pyobj_nc, &pyobj_useNet, &pyobj_params) && |  | 69194 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:mcc_CCheckerDetector.processWithROI", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_regionsOfInterest, &pyobj_nc, &pyobj_useNet, &pyobj_params) &&
| 69243 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 69195 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 69244 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) && |  | 69196 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) &&
| 69245 | pyopencv_to_safe(pyobj_regionsOfInterest, regionsOfInterest, ArgInfo("regionsOfInterest", 0)) && |  | 69197 | pyopencv_to_safe(pyobj_regionsOfInterest, regionsOfInterest, ArgInfo("regionsOfInterest", 0)) &&
| 69246 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) && |  | 69198 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) &&
| 69247 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) && |  | 69199 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) &&
| 69248 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 69200 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 69249 | { |  | 69201 | {
| 69250 | ERRWRAP2(retval = _self_->process(image, chartType, regionsOfInterest, nc, useNet, params)); |  | 69202 | ERRWRAP2(retval = _self_->process(image, chartType, regionsOfInterest, nc, useNet, params));
| 69251 | return pyopencv_from(retval); |  | 69203 | return pyopencv_from(retval);
| 69252 | } |  | 69204 | }
| 69253 |  |  | 69205 |
| 69254 |  |  | 69206 |
| 69255 | pyPopulateArgumentConversionErrors(); |  | 69207 | pyPopulateArgumentConversionErrors();
| 69256 | } |  | 69208 | }
| 69257 |  |  | 69209 |
| 69258 |  |  | 69210 |
| 69259 | { |  | 69211 | {
| 69260 | PyObject* pyobj_image = NULL; |  | 69212 | PyObject* pyobj_image = NULL;
| 69261 | UMat image; |  | 69213 | UMat image;
| 69262 | PyObject* pyobj_chartType = NULL; |  | 69214 | PyObject* pyobj_chartType = NULL;
| 69263 | TYPECHART chartType=static_cast<TYPECHART>(0); |  | 69215 | TYPECHART chartType=static_cast<TYPECHART>(0);
| 69264 | PyObject* pyobj_regionsOfInterest = NULL; |  | 69216 | PyObject* pyobj_regionsOfInterest = NULL;
| 69265 | vector_Rect regionsOfInterest; |  | 69217 | vector_Rect regionsOfInterest;
| 69266 | PyObject* pyobj_nc = NULL; |  | 69218 | PyObject* pyobj_nc = NULL;
| 69267 | int nc=1; |  | 69219 | int nc=1;
| 69268 | PyObject* pyobj_useNet = NULL; |  | 69220 | PyObject* pyobj_useNet = NULL;
| 69269 | bool useNet=false; |  | 69221 | bool useNet=false;
| 69270 | PyObject* pyobj_params = NULL; |  | 69222 | PyObject* pyobj_params = NULL;
| 69271 | Ptr<DetectorParameters> params=DetectorParameters::create(); |  | 69223 | Ptr<DetectorParameters> params=DetectorParameters::create();
| 69272 | bool retval; |  | 69224 | bool retval;
| 69273 |  |  | 69225 |
| 69274 | const char* keywords[] = { "image", "chartType", "regionsOfInterest", "nc", "useNet", "params", NULL }; |  | 69226 | const char* keywords[] = { "image", "chartType", "regionsOfInterest", "nc", "useNet", "params", NULL };
| 69275 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:mcc_CCheckerDetector.processWithROI", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_regionsOfInterest, &pyobj_nc, &pyobj_useNet, &pyobj_params) && |  | 69227 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOO:mcc_CCheckerDetector.processWithROI", (char**)keywords, &pyobj_image, &pyobj_chartType, &pyobj_regionsOfInterest, &pyobj_nc, &pyobj_useNet, &pyobj_params) &&
| 69276 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 69228 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 69277 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) && |  | 69229 | pyopencv_to_safe(pyobj_chartType, chartType, ArgInfo("chartType", 0)) &&
| 69278 | pyopencv_to_safe(pyobj_regionsOfInterest, regionsOfInterest, ArgInfo("regionsOfInterest", 0)) && |  | 69230 | pyopencv_to_safe(pyobj_regionsOfInterest, regionsOfInterest, ArgInfo("regionsOfInterest", 0)) &&
| 69279 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) && |  | 69231 | pyopencv_to_safe(pyobj_nc, nc, ArgInfo("nc", 0)) &&
| 69280 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) && |  | 69232 | pyopencv_to_safe(pyobj_useNet, useNet, ArgInfo("useNet", 0)) &&
| 69281 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) ) |  | 69233 | pyopencv_to_safe(pyobj_params, params, ArgInfo("params", 0)) )
| 69282 | { |  | 69234 | {
| 69283 | ERRWRAP2(retval = _self_->process(image, chartType, regionsOfInterest, nc, useNet, params)); |  | 69235 | ERRWRAP2(retval = _self_->process(image, chartType, regionsOfInterest, nc, useNet, params));
| 69284 | return pyopencv_from(retval); |  | 69236 | return pyopencv_from(retval);
| 69285 | } |  | 69237 | }
| 69286 |  |  | 69238 |
| 69287 |  |  | 69239 |
| 69288 | pyPopulateArgumentConversionErrors(); |  | 69240 | pyPopulateArgumentConversionErrors();
| 69289 | } |  | 69241 | }
| 69290 | pyRaiseCVOverloadException("processWithROI"); |  | 69242 | pyRaiseCVOverloadException("processWithROI");
| 69291 |  |  | 69243 |
| 69292 | return NULL; |  | 69244 | return NULL;
| 69293 | } |  | 69245 | }
| 69294 |  |  | 69246 |
| 69295 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_setNet(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69247 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDetector_setNet(PyObject* self, PyObject* py_args, PyObject* kw)
| 69296 | { |  | 69248 | {
| 69297 | using namespace cv::mcc; |  | 69249 | using namespace cv::mcc;
| 69298 |  |  | 69250 |
| 69299 |  |  | 69251 |
| 69300 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0; |  | 69252 | Ptr<cv::mcc::CCheckerDetector> * self1 = 0;
| 69301 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1)) |  | 69253 | if (!pyopencv_mcc_CCheckerDetector_getp(self, self1))
| 69302 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)"); |  | 69254 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDetector' or its derivative)");
| 69303 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1); |  | 69255 | Ptr<cv::mcc::CCheckerDetector> _self_ = *(self1);
| 69304 | PyObject* pyobj_net = NULL; |  | 69256 | PyObject* pyobj_net = NULL;
| 69305 | cv::dnn::Net net; |  | 69257 | cv::dnn::Net net;
| 69306 | bool retval; |  | 69258 | bool retval;
| 69307 |  |  | 69259 |
| 69308 | const char* keywords[] = { "net", NULL }; |  | 69260 | const char* keywords[] = { "net", NULL };
| 69309 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CCheckerDetector.setNet", (char**)keywords, &pyobj_net) && |  | 69261 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CCheckerDetector.setNet", (char**)keywords, &pyobj_net) &&
| 69310 | pyopencv_to_safe(pyobj_net, net, ArgInfo("net", 0)) ) |  | 69262 | pyopencv_to_safe(pyobj_net, net, ArgInfo("net", 0)) )
| 69311 | { |  | 69263 | {
| 69312 | ERRWRAP2(retval = _self_->setNet(net)); |  | 69264 | ERRWRAP2(retval = _self_->setNet(net));
| 69313 | return pyopencv_from(retval); |  | 69265 | return pyopencv_from(retval);
| 69314 | } |  | 69266 | }
| 69315 |  |  | 69267 |
| 69316 | return NULL; |  | 69268 | return NULL;
| 69317 | } |  | 69269 | }
| 69318 |  |  | 69270 |
| 69319 |  |  | 69271 |
| 69320 |  |  | 69272 |
| 69321 | // Tables (mcc_CCheckerDetector) |  | 69273 | // Tables (mcc_CCheckerDetector)
| 69322 |  |  | 69274 |
| 69323 | static PyGetSetDef pyopencv_mcc_CCheckerDetector_getseters[] = |  | 69275 | static PyGetSetDef pyopencv_mcc_CCheckerDetector_getseters[] =
| 69324 | { |  | 69276 | {
| 69325 | {NULL} /* Sentinel */ |  | 69277 | {NULL} /* Sentinel */
| 69326 | }; |  | 69278 | };
| 69327 |  |  | 69279 |
| 69328 | static PyMethodDef pyopencv_mcc_CCheckerDetector_methods[] = |  | 69280 | static PyMethodDef pyopencv_mcc_CCheckerDetector_methods[] =
| 69329 | { |  | 69281 | {
| 69330 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_create_static, METH_STATIC), "create() -> retval\n. \\brief Returns the implementation of the CCheckerDetector.\n. *"}, |  | 69282 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_create_static, METH_STATIC), "create() -> retval\n. \\brief Returns the implementation of the CCheckerDetector.\n. *"},
| 69331 | {"getBestColorChecker", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_getBestColorChecker, 0), "getBestColorChecker() -> retval\n. \\brief Get the best color checker. By the best it means the one\n. * detected with the highest confidence.\n. * \\return checker A single colorchecker, if atleast one colorchecker\n. * was detected, 'nullptr' otherwise."}, |  | 69283 | {"getBestColorChecker", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_getBestColorChecker, 0), "getBestColorChecker() -> retval\n. \\brief Get the best color checker. By the best it means the one\n. * detected with the highest confidence.\n. * \\return checker A single colorchecker, if atleast one colorchecker\n. * was detected, 'nullptr' otherwise."},
| 69332 | {"getListColorChecker", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_getListColorChecker, 0), "getListColorChecker() -> retval\n. \\brief Get the list of all detected colorcheckers\n. * \\return checkers vector of colorcheckers"}, |  | 69284 | {"getListColorChecker", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_getListColorChecker, 0), "getListColorChecker() -> retval\n. \\brief Get the list of all detected colorcheckers\n. * \\return checkers vector of colorcheckers"},
| 69333 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_process, 0), "process(image, chartType[, nc[, useNet[, params]]]) -> retval\n. \\brief Find the ColorCharts in the given image.\n. *\n. * Differs from the above one only in the arguments.\n. *\n. * This version searches for the chart in the full image.\n. *\n. * The found charts are not returned but instead stored in the\n. * detector, these can be accessed later on using getBestColorChecker()\n. * and getListColorChecker()\n. * \\param image image in color space BGR\n. * \\param chartType type of the chart to detect\n. * \\param nc number of charts in the image, if you don't know the exact\n. * then keeping this number high helps.\n. * \\param useNet if it is true the network provided using the setNet()\n. * is used for preliminary search for regions where chart\n. * could be present, inside the regionsOfInterest provied.\n. * \\param params parameters of the detection system. More information\n. * about them can be found in the struct DetectorParameters.\n. * \\return true if atleast one chart is detected otherwise false"}, |  | 69285 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_process, 0), "process(image, chartType[, nc[, useNet[, params]]]) -> retval\n. \\brief Find the ColorCharts in the given image.\n. *\n. * Differs from the above one only in the arguments.\n. *\n. * This version searches for the chart in the full image.\n. *\n. * The found charts are not returned but instead stored in the\n. * detector, these can be accessed later on using getBestColorChecker()\n. * and getListColorChecker()\n. * \\param image image in color space BGR\n. * \\param chartType type of the chart to detect\n. * \\param nc number of charts in the image, if you don't know the exact\n. * then keeping this number high helps.\n. * \\param useNet if it is true the network provided using the setNet()\n. * is used for preliminary search for regions where chart\n. * could be present, inside the regionsOfInterest provied.\n. * \\param params parameters of the detection system. More information\n. * about them can be found in the struct DetectorParameters.\n. * \\return true if atleast one chart is detected otherwise false"},
| 69334 | {"processWithROI", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_processWithROI, 0), "processWithROI(image, chartType, regionsOfInterest[, nc[, useNet[, params]]]) -> retval\n. \\brief Find the ColorCharts in the given image.\n. *\n. * The found charts are not returned but instead stored in the\n. * detector, these can be accessed later on using getBestColorChecker()\n. * and getListColorChecker()\n. * \\param image image in color space BGR\n. * \\param chartType type of the chart to detect\n. * \\param regionsOfInterest regions of image to look for the chart, if\n. * it is empty, charts are looked for in the\n. * entire image\n. * \\param nc number of charts in the image, if you don't know the exact\n. * then keeping this number high helps.\n. * \\param useNet if it is true the network provided using the setNet()\n. * is used for preliminary search for regions where chart\n. * could be present, inside the regionsOfInterest provied.\n. * \\param params parameters of the detection system. More information\n. * about them can be found in the struct DetectorParameters.\n. * \\return true if atleast one chart is detected otherwise false"}, |  | 69286 | {"processWithROI", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_processWithROI, 0), "processWithROI(image, chartType, regionsOfInterest[, nc[, useNet[, params]]]) -> retval\n. \\brief Find the ColorCharts in the given image.\n. *\n. * The found charts are not returned but instead stored in the\n. * detector, these can be accessed later on using getBestColorChecker()\n. * and getListColorChecker()\n. * \\param image image in color space BGR\n. * \\param chartType type of the chart to detect\n. * \\param regionsOfInterest regions of image to look for the chart, if\n. * it is empty, charts are looked for in the\n. * entire image\n. * \\param nc number of charts in the image, if you don't know the exact\n. * then keeping this number high helps.\n. * \\param useNet if it is true the network provided using the setNet()\n. * is used for preliminary search for regions where chart\n. * could be present, inside the regionsOfInterest provied.\n. * \\param params parameters of the detection system. More information\n. * about them can be found in the struct DetectorParameters.\n. * \\return true if atleast one chart is detected otherwise false"},
| 69335 | {"setNet", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_setNet, 0), "setNet(net) -> retval\n. \\brief Set the net which will be used to find the approximate\n. * bounding boxes for the color charts.\n. *\n. * It is not necessary to use this, but this usually results in\n. * better detection rate.\n. *\n. * \\param net the neural network, if the network in empty, then\n. * the function will return false.\n. * \\return true if it was able to set the detector's network,\n. * false otherwise."}, |  | 69287 | {"setNet", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDetector_setNet, 0), "setNet(net) -> retval\n. \\brief Set the net which will be used to find the approximate\n. * bounding boxes for the color charts.\n. *\n. * It is not necessary to use this, but this usually results in\n. * better detection rate.\n. *\n. * \\param net the neural network, if the network in empty, then\n. * the function will return false.\n. * \\return true if it was able to set the detector's network,\n. * false otherwise."},
| 69336 |  |  | 69288 |
| 69337 | {NULL, NULL} |  | 69289 | {NULL, NULL}
| 69338 | }; |  | 69290 | };
| 69339 |  |  | 69291 |
| 69340 | // Converter (mcc_CCheckerDetector) |  | 69292 | // Converter (mcc_CCheckerDetector)
| 69341 |  |  | 69293 |
| 69342 | template<> |  | 69294 | template<>
| 69343 | struct PyOpenCV_Converter< Ptr<cv::mcc::CCheckerDetector> > |  | 69295 | struct PyOpenCV_Converter< Ptr<cv::mcc::CCheckerDetector> >
| 69344 | { |  | 69296 | {
| 69345 | static PyObject* from(const Ptr<cv::mcc::CCheckerDetector>& r) |  | 69297 | static PyObject* from(const Ptr<cv::mcc::CCheckerDetector>& r)
| 69346 | { |  | 69298 | {
| 69347 | return pyopencv_mcc_CCheckerDetector_Instance(r); |  | 69299 | return pyopencv_mcc_CCheckerDetector_Instance(r);
| 69348 | } |  | 69300 | }
| 69349 | static bool to(PyObject* src, Ptr<cv::mcc::CCheckerDetector>& dst, const ArgInfo& info) |  | 69301 | static bool to(PyObject* src, Ptr<cv::mcc::CCheckerDetector>& dst, const ArgInfo& info)
| 69350 | { |  | 69302 | {
| 69351 | if(!src || src == Py_None) |  | 69303 | if(!src || src == Py_None)
| 69352 | return true; |  | 69304 | return true;
| 69353 | Ptr<cv::mcc::CCheckerDetector> * dst_; |  | 69305 | Ptr<cv::mcc::CCheckerDetector> * dst_;
| 69354 | if (pyopencv_mcc_CCheckerDetector_getp(src, dst_)) |  | 69306 | if (pyopencv_mcc_CCheckerDetector_getp(src, dst_))
| 69355 | { |  | 69307 | {
| 69356 | dst = *dst_; |  | 69308 | dst = *dst_;
| 69357 | return true; |  | 69309 | return true;
| 69358 | } |  | 69310 | }
| 69359 |  |  | 69311 |
| 69360 | failmsg("Expected Ptr<cv::mcc::CCheckerDetector> for argument '%s'", info.name); |  | 69312 | failmsg("Expected Ptr<cv::mcc::CCheckerDetector> for argument '%s'", info.name);
| 69361 | return false; |  | 69313 | return false;
| 69362 | } |  | 69314 | }
| 69363 | }; |  | 69315 | };
| 69364 |  |  | 69316 |
| 69365 | //================================================================================ |  | 69317 | //================================================================================
| 69366 | // mcc_CCheckerDraw (Generic) |  | 69318 | // mcc_CCheckerDraw (Generic)
| 69367 | //================================================================================ |  | 69319 | //================================================================================
| 69368 |  |  | 69320 |
| 69369 | // GetSet (mcc_CCheckerDraw) |  | 69321 | // GetSet (mcc_CCheckerDraw)
| 69370 |  |  | 69322 |
| 69371 |  |  | 69323 |
| 69372 |  |  | 69324 |
| 69373 | // Methods (mcc_CCheckerDraw) |  | 69325 | // Methods (mcc_CCheckerDraw)
| 69374 |  |  | 69326 |
| 69375 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDraw_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69327 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDraw_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 69376 | { |  | 69328 | {
| 69377 | using namespace cv::mcc; |  | 69329 | using namespace cv::mcc;
| 69378 |  |  | 69330 |
| 69379 | PyObject* pyobj_pChecker = NULL; |  | 69331 | PyObject* pyobj_pChecker = NULL;
| 69380 | Ptr<CChecker> pChecker; |  | 69332 | Ptr<CChecker> pChecker;
| 69381 | PyObject* pyobj_color = NULL; |  | 69333 | PyObject* pyobj_color = NULL;
| 69382 | Scalar color=CV_RGB(0, 250, 0); |  | 69334 | Scalar color=CV_RGB(0, 250, 0);
| 69383 | PyObject* pyobj_thickness = NULL; |  | 69335 | PyObject* pyobj_thickness = NULL;
| 69384 | int thickness=2; |  | 69336 | int thickness=2;
| 69385 | Ptr<CCheckerDraw> retval; |  | 69337 | Ptr<CCheckerDraw> retval;
| 69386 |  |  | 69338 |
| 69387 | const char* keywords[] = { "pChecker", "color", "thickness", NULL }; |  | 69339 | const char* keywords[] = { "pChecker", "color", "thickness", NULL };
| 69388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:mcc_CCheckerDraw.create", (char**)keywords, &pyobj_pChecker, &pyobj_color, &pyobj_thickness) && |  | 69340 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:mcc_CCheckerDraw.create", (char**)keywords, &pyobj_pChecker, &pyobj_color, &pyobj_thickness) &&
| 69389 | pyopencv_to_safe(pyobj_pChecker, pChecker, ArgInfo("pChecker", 0)) && |  | 69341 | pyopencv_to_safe(pyobj_pChecker, pChecker, ArgInfo("pChecker", 0)) &&
| 69390 | pyopencv_to_safe(pyobj_color, color, ArgInfo("color", 0)) && |  | 69342 | pyopencv_to_safe(pyobj_color, color, ArgInfo("color", 0)) &&
| 69391 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) ) |  | 69343 | pyopencv_to_safe(pyobj_thickness, thickness, ArgInfo("thickness", 0)) )
| 69392 | { |  | 69344 | {
| 69393 | ERRWRAP2(retval = cv::mcc::CCheckerDraw::create(pChecker, color, thickness)); |  | 69345 | ERRWRAP2(retval = cv::mcc::CCheckerDraw::create(pChecker, color, thickness));
| 69394 | return pyopencv_from(retval); |  | 69346 | return pyopencv_from(retval);
| 69395 | } |  | 69347 | }
| 69396 |  |  | 69348 |
| 69397 | return NULL; |  | 69349 | return NULL;
| 69398 | } |  | 69350 | }
| 69399 |  |  | 69351 |
| 69400 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDraw_draw(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69352 | static PyObject* pyopencv_cv_mcc_mcc_CCheckerDraw_draw(PyObject* self, PyObject* py_args, PyObject* kw)
| 69401 | { |  | 69353 | {
| 69402 | using namespace cv::mcc; |  | 69354 | using namespace cv::mcc;
| 69403 |  |  | 69355 |
| 69404 |  |  | 69356 |
| 69405 | Ptr<cv::mcc::CCheckerDraw> * self1 = 0; |  | 69357 | Ptr<cv::mcc::CCheckerDraw> * self1 = 0;
| 69406 | if (!pyopencv_mcc_CCheckerDraw_getp(self, self1)) |  | 69358 | if (!pyopencv_mcc_CCheckerDraw_getp(self, self1))
| 69407 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDraw' or its derivative)"); |  | 69359 | return failmsgp("Incorrect type of self (must be 'mcc_CCheckerDraw' or its derivative)");
| 69408 | Ptr<cv::mcc::CCheckerDraw> _self_ = *(self1); |  | 69360 | Ptr<cv::mcc::CCheckerDraw> _self_ = *(self1);
| 69409 | pyPrepareArgumentConversionErrorsStorage(2); |  | 69361 | pyPrepareArgumentConversionErrorsStorage(2);
| 69410 |  |  | 69362 |
| 69411 | { |  | 69363 | {
| 69412 | PyObject* pyobj_img = NULL; |  | 69364 | PyObject* pyobj_img = NULL;
| 69413 | Mat img; |  | 69365 | Mat img;
| 69414 |  |  | 69366 |
| 69415 | const char* keywords[] = { "img", NULL }; |  | 69367 | const char* keywords[] = { "img", NULL };
| 69416 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CCheckerDraw.draw", (char**)keywords, &pyobj_img) && |  | 69368 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CCheckerDraw.draw", (char**)keywords, &pyobj_img) &&
| 69417 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) ) |  | 69369 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) )
| 69418 | { |  | 69370 | {
| 69419 | ERRWRAP2(_self_->draw(img)); |  | 69371 | ERRWRAP2(_self_->draw(img));
| 69420 | return pyopencv_from(img); |  | 69372 | return pyopencv_from(img);
| 69421 | } |  | 69373 | }
| 69422 |  |  | 69374 |
| 69423 |  |  | 69375 |
| 69424 | pyPopulateArgumentConversionErrors(); |  | 69376 | pyPopulateArgumentConversionErrors();
| 69425 | } |  | 69377 | }
| 69426 |  |  | 69378 |
| 69427 |  |  | 69379 |
| 69428 | { |  | 69380 | {
| 69429 | PyObject* pyobj_img = NULL; |  | 69381 | PyObject* pyobj_img = NULL;
| 69430 | UMat img; |  | 69382 | UMat img;
| 69431 |  |  | 69383 |
| 69432 | const char* keywords[] = { "img", NULL }; |  | 69384 | const char* keywords[] = { "img", NULL };
| 69433 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CCheckerDraw.draw", (char**)keywords, &pyobj_img) && |  | 69385 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:mcc_CCheckerDraw.draw", (char**)keywords, &pyobj_img) &&
| 69434 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) ) |  | 69386 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 1)) )
| 69435 | { |  | 69387 | {
| 69436 | ERRWRAP2(_self_->draw(img)); |  | 69388 | ERRWRAP2(_self_->draw(img));
| 69437 | return pyopencv_from(img); |  | 69389 | return pyopencv_from(img);
| 69438 | } |  | 69390 | }
| 69439 |  |  | 69391 |
| 69440 |  |  | 69392 |
| 69441 | pyPopulateArgumentConversionErrors(); |  | 69393 | pyPopulateArgumentConversionErrors();
| 69442 | } |  | 69394 | }
| 69443 | pyRaiseCVOverloadException("draw"); |  | 69395 | pyRaiseCVOverloadException("draw");
| 69444 |  |  | 69396 |
| 69445 | return NULL; |  | 69397 | return NULL;
| 69446 | } |  | 69398 | }
| 69447 |  |  | 69399 |
| 69448 |  |  | 69400 |
| 69449 |  |  | 69401 |
| 69450 | // Tables (mcc_CCheckerDraw) |  | 69402 | // Tables (mcc_CCheckerDraw)
| 69451 |  |  | 69403 |
| 69452 | static PyGetSetDef pyopencv_mcc_CCheckerDraw_getseters[] = |  | 69404 | static PyGetSetDef pyopencv_mcc_CCheckerDraw_getseters[] =
| 69453 | { |  | 69405 | {
| 69454 | {NULL} /* Sentinel */ |  | 69406 | {NULL} /* Sentinel */
| 69455 | }; |  | 69407 | };
| 69456 |  |  | 69408 |
| 69457 | static PyMethodDef pyopencv_mcc_CCheckerDraw_methods[] = |  | 69409 | static PyMethodDef pyopencv_mcc_CCheckerDraw_methods[] =
| 69458 | { |  | 69410 | {
| 69459 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDraw_create_static, METH_STATIC), "create(pChecker[, color[, thickness]]) -> retval\n. \\brief Create a new CCheckerDraw object.\n. * \\param pChecker The checker which will be drawn by this object.\n. * \\param color The color by with which the squares of the checker\n. * will be drawn\n. * \\param thickness The thickness with which the sqaures will be\n. * drawn\n. * \\return A pointer to the implementation of the CCheckerDraw"}, |  | 69411 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDraw_create_static, METH_STATIC), "create(pChecker[, color[, thickness]]) -> retval\n. \\brief Create a new CCheckerDraw object.\n. * \\param pChecker The checker which will be drawn by this object.\n. * \\param color The color by with which the squares of the checker\n. * will be drawn\n. * \\param thickness The thickness with which the sqaures will be\n. * drawn\n. * \\return A pointer to the implementation of the CCheckerDraw"},
| 69460 | {"draw", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDraw_draw, 0), "draw(img) -> img\n. \\brief Draws the checker to the given image.\n. * \\param img image in color space BGR"}, |  | 69412 | {"draw", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_CCheckerDraw_draw, 0), "draw(img) -> img\n. \\brief Draws the checker to the given image.\n. * \\param img image in color space BGR"},
| 69461 |  |  | 69413 |
| 69462 | {NULL, NULL} |  | 69414 | {NULL, NULL}
| 69463 | }; |  | 69415 | };
| 69464 |  |  | 69416 |
| 69465 | // Converter (mcc_CCheckerDraw) |  | 69417 | // Converter (mcc_CCheckerDraw)
| 69466 |  |  | 69418 |
| 69467 | template<> |  | 69419 | template<>
| 69468 | struct PyOpenCV_Converter< Ptr<cv::mcc::CCheckerDraw> > |  | 69420 | struct PyOpenCV_Converter< Ptr<cv::mcc::CCheckerDraw> >
| 69469 | { |  | 69421 | {
| 69470 | static PyObject* from(const Ptr<cv::mcc::CCheckerDraw>& r) |  | 69422 | static PyObject* from(const Ptr<cv::mcc::CCheckerDraw>& r)
| 69471 | { |  | 69423 | {
| 69472 | return pyopencv_mcc_CCheckerDraw_Instance(r); |  | 69424 | return pyopencv_mcc_CCheckerDraw_Instance(r);
| 69473 | } |  | 69425 | }
| 69474 | static bool to(PyObject* src, Ptr<cv::mcc::CCheckerDraw>& dst, const ArgInfo& info) |  | 69426 | static bool to(PyObject* src, Ptr<cv::mcc::CCheckerDraw>& dst, const ArgInfo& info)
| 69475 | { |  | 69427 | {
| 69476 | if(!src || src == Py_None) |  | 69428 | if(!src || src == Py_None)
| 69477 | return true; |  | 69429 | return true;
| 69478 | Ptr<cv::mcc::CCheckerDraw> * dst_; |  | 69430 | Ptr<cv::mcc::CCheckerDraw> * dst_;
| 69479 | if (pyopencv_mcc_CCheckerDraw_getp(src, dst_)) |  | 69431 | if (pyopencv_mcc_CCheckerDraw_getp(src, dst_))
| 69480 | { |  | 69432 | {
| 69481 | dst = *dst_; |  | 69433 | dst = *dst_;
| 69482 | return true; |  | 69434 | return true;
| 69483 | } |  | 69435 | }
| 69484 |  |  | 69436 |
| 69485 | failmsg("Expected Ptr<cv::mcc::CCheckerDraw> for argument '%s'", info.name); |  | 69437 | failmsg("Expected Ptr<cv::mcc::CCheckerDraw> for argument '%s'", info.name);
| 69486 | return false; |  | 69438 | return false;
| 69487 | } |  | 69439 | }
| 69488 | }; |  | 69440 | };
| 69489 |  |  | 69441 |
| 69490 | //================================================================================ |  | 69442 | //================================================================================
| 69491 | // mcc_DetectorParameters (Generic) |  | 69443 | // mcc_DetectorParameters (Generic)
| 69492 | //================================================================================ |  | 69444 | //================================================================================
| 69493 |  |  | 69445 |
| 69494 | // GetSet (mcc_DetectorParameters) |  | 69446 | // GetSet (mcc_DetectorParameters)
| 69495 |  |  | 69447 |
| 69496 |  |  | 69448 |
| 69497 | static PyObject* pyopencv_mcc_DetectorParameters_get_B0factor(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69449 | static PyObject* pyopencv_mcc_DetectorParameters_get_B0factor(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69498 | { |  | 69450 | {
| 69499 | return pyopencv_from(p->v->B0factor); |  | 69451 | return pyopencv_from(p->v->B0factor);
| 69500 | } |  | 69452 | }
| 69501 |  |  | 69453 |
| 69502 | static int pyopencv_mcc_DetectorParameters_set_B0factor(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69454 | static int pyopencv_mcc_DetectorParameters_set_B0factor(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69503 | { |  | 69455 | {
| 69504 | if (!value) |  | 69456 | if (!value)
| 69505 | { |  | 69457 | {
| 69506 | PyErr_SetString(PyExc_TypeError, "Cannot delete the B0factor attribute"); |  | 69458 | PyErr_SetString(PyExc_TypeError, "Cannot delete the B0factor attribute");
| 69507 | return -1; |  | 69459 | return -1;
| 69508 | } |  | 69460 | }
| 69509 | return pyopencv_to_safe(value, p->v->B0factor, ArgInfo("value", 0)) ? 0 : -1; |  | 69461 | return pyopencv_to_safe(value, p->v->B0factor, ArgInfo("value", 0)) ? 0 : -1;
| 69510 | } |  | 69462 | }
| 69511 |  |  | 69463 |
| 69512 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshConstant(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69464 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshConstant(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69513 | { |  | 69465 | {
| 69514 | return pyopencv_from(p->v->adaptiveThreshConstant); |  | 69466 | return pyopencv_from(p->v->adaptiveThreshConstant);
| 69515 | } |  | 69467 | }
| 69516 |  |  | 69468 |
| 69517 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshConstant(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69469 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshConstant(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69518 | { |  | 69470 | {
| 69519 | if (!value) |  | 69471 | if (!value)
| 69520 | { |  | 69472 | {
| 69521 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshConstant attribute"); |  | 69473 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshConstant attribute");
| 69522 | return -1; |  | 69474 | return -1;
| 69523 | } |  | 69475 | }
| 69524 | return pyopencv_to_safe(value, p->v->adaptiveThreshConstant, ArgInfo("value", 0)) ? 0 : -1; |  | 69476 | return pyopencv_to_safe(value, p->v->adaptiveThreshConstant, ArgInfo("value", 0)) ? 0 : -1;
| 69525 | } |  | 69477 | }
| 69526 |  |  | 69478 |
| 69527 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMax(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69479 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMax(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69528 | { |  | 69480 | {
| 69529 | return pyopencv_from(p->v->adaptiveThreshWinSizeMax); |  | 69481 | return pyopencv_from(p->v->adaptiveThreshWinSizeMax);
| 69530 | } |  | 69482 | }
| 69531 |  |  | 69483 |
| 69532 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMax(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69484 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMax(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69533 | { |  | 69485 | {
| 69534 | if (!value) |  | 69486 | if (!value)
| 69535 | { |  | 69487 | {
| 69536 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMax attribute"); |  | 69488 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMax attribute");
| 69537 | return -1; |  | 69489 | return -1;
| 69538 | } |  | 69490 | }
| 69539 | return pyopencv_to_safe(value, p->v->adaptiveThreshWinSizeMax, ArgInfo("value", 0)) ? 0 : -1; |  | 69491 | return pyopencv_to_safe(value, p->v->adaptiveThreshWinSizeMax, ArgInfo("value", 0)) ? 0 : -1;
| 69540 | } |  | 69492 | }
| 69541 |  |  | 69493 |
| 69542 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMin(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69494 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMin(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69543 | { |  | 69495 | {
| 69544 | return pyopencv_from(p->v->adaptiveThreshWinSizeMin); |  | 69496 | return pyopencv_from(p->v->adaptiveThreshWinSizeMin);
| 69545 | } |  | 69497 | }
| 69546 |  |  | 69498 |
| 69547 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMin(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69499 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMin(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69548 | { |  | 69500 | {
| 69549 | if (!value) |  | 69501 | if (!value)
| 69550 | { |  | 69502 | {
| 69551 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMin attribute"); |  | 69503 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeMin attribute");
| 69552 | return -1; |  | 69504 | return -1;
| 69553 | } |  | 69505 | }
| 69554 | return pyopencv_to_safe(value, p->v->adaptiveThreshWinSizeMin, ArgInfo("value", 0)) ? 0 : -1; |  | 69506 | return pyopencv_to_safe(value, p->v->adaptiveThreshWinSizeMin, ArgInfo("value", 0)) ? 0 : -1;
| 69555 | } |  | 69507 | }
| 69556 |  |  | 69508 |
| 69557 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeStep(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69509 | static PyObject* pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeStep(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69558 | { |  | 69510 | {
| 69559 | return pyopencv_from(p->v->adaptiveThreshWinSizeStep); |  | 69511 | return pyopencv_from(p->v->adaptiveThreshWinSizeStep);
| 69560 | } |  | 69512 | }
| 69561 |  |  | 69513 |
| 69562 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeStep(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69514 | static int pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeStep(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69563 | { |  | 69515 | {
| 69564 | if (!value) |  | 69516 | if (!value)
| 69565 | { |  | 69517 | {
| 69566 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeStep attribute"); |  | 69518 | PyErr_SetString(PyExc_TypeError, "Cannot delete the adaptiveThreshWinSizeStep attribute");
| 69567 | return -1; |  | 69519 | return -1;
| 69568 | } |  | 69520 | }
| 69569 | return pyopencv_to_safe(value, p->v->adaptiveThreshWinSizeStep, ArgInfo("value", 0)) ? 0 : -1; |  | 69521 | return pyopencv_to_safe(value, p->v->adaptiveThreshWinSizeStep, ArgInfo("value", 0)) ? 0 : -1;
| 69570 | } |  | 69522 | }
| 69571 |  |  | 69523 |
| 69572 | static PyObject* pyopencv_mcc_DetectorParameters_get_borderWidth(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69524 | static PyObject* pyopencv_mcc_DetectorParameters_get_borderWidth(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69573 | { |  | 69525 | {
| 69574 | return pyopencv_from(p->v->borderWidth); |  | 69526 | return pyopencv_from(p->v->borderWidth);
| 69575 | } |  | 69527 | }
| 69576 |  |  | 69528 |
| 69577 | static int pyopencv_mcc_DetectorParameters_set_borderWidth(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69529 | static int pyopencv_mcc_DetectorParameters_set_borderWidth(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69578 | { |  | 69530 | {
| 69579 | if (!value) |  | 69531 | if (!value)
| 69580 | { |  | 69532 | {
| 69581 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderWidth attribute"); |  | 69533 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderWidth attribute");
| 69582 | return -1; |  | 69534 | return -1;
| 69583 | } |  | 69535 | }
| 69584 | return pyopencv_to_safe(value, p->v->borderWidth, ArgInfo("value", 0)) ? 0 : -1; |  | 69536 | return pyopencv_to_safe(value, p->v->borderWidth, ArgInfo("value", 0)) ? 0 : -1;
| 69585 | } |  | 69537 | }
| 69586 |  |  | 69538 |
| 69587 | static PyObject* pyopencv_mcc_DetectorParameters_get_confidenceThreshold(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69539 | static PyObject* pyopencv_mcc_DetectorParameters_get_confidenceThreshold(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69588 | { |  | 69540 | {
| 69589 | return pyopencv_from(p->v->confidenceThreshold); |  | 69541 | return pyopencv_from(p->v->confidenceThreshold);
| 69590 | } |  | 69542 | }
| 69591 |  |  | 69543 |
| 69592 | static int pyopencv_mcc_DetectorParameters_set_confidenceThreshold(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69544 | static int pyopencv_mcc_DetectorParameters_set_confidenceThreshold(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69593 | { |  | 69545 | {
| 69594 | if (!value) |  | 69546 | if (!value)
| 69595 | { |  | 69547 | {
| 69596 | PyErr_SetString(PyExc_TypeError, "Cannot delete the confidenceThreshold attribute"); |  | 69548 | PyErr_SetString(PyExc_TypeError, "Cannot delete the confidenceThreshold attribute");
| 69597 | return -1; |  | 69549 | return -1;
| 69598 | } |  | 69550 | }
| 69599 | return pyopencv_to_safe(value, p->v->confidenceThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 69551 | return pyopencv_to_safe(value, p->v->confidenceThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 69600 | } |  | 69552 | }
| 69601 |  |  | 69553 |
| 69602 | static PyObject* pyopencv_mcc_DetectorParameters_get_findCandidatesApproxPolyDPEpsMultiplier(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69554 | static PyObject* pyopencv_mcc_DetectorParameters_get_findCandidatesApproxPolyDPEpsMultiplier(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69603 | { |  | 69555 | {
| 69604 | return pyopencv_from(p->v->findCandidatesApproxPolyDPEpsMultiplier); |  | 69556 | return pyopencv_from(p->v->findCandidatesApproxPolyDPEpsMultiplier);
| 69605 | } |  | 69557 | }
| 69606 |  |  | 69558 |
| 69607 | static int pyopencv_mcc_DetectorParameters_set_findCandidatesApproxPolyDPEpsMultiplier(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69559 | static int pyopencv_mcc_DetectorParameters_set_findCandidatesApproxPolyDPEpsMultiplier(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69608 | { |  | 69560 | {
| 69609 | if (!value) |  | 69561 | if (!value)
| 69610 | { |  | 69562 | {
| 69611 | PyErr_SetString(PyExc_TypeError, "Cannot delete the findCandidatesApproxPolyDPEpsMultiplier attribute"); |  | 69563 | PyErr_SetString(PyExc_TypeError, "Cannot delete the findCandidatesApproxPolyDPEpsMultiplier attribute");
| 69612 | return -1; |  | 69564 | return -1;
| 69613 | } |  | 69565 | }
| 69614 | return pyopencv_to_safe(value, p->v->findCandidatesApproxPolyDPEpsMultiplier, ArgInfo("value", 0)) ? 0 : -1; |  | 69566 | return pyopencv_to_safe(value, p->v->findCandidatesApproxPolyDPEpsMultiplier, ArgInfo("value", 0)) ? 0 : -1;
| 69615 | } |  | 69567 | }
| 69616 |  |  | 69568 |
| 69617 | static PyObject* pyopencv_mcc_DetectorParameters_get_maxError(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69569 | static PyObject* pyopencv_mcc_DetectorParameters_get_maxError(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69618 | { |  | 69570 | {
| 69619 | return pyopencv_from(p->v->maxError); |  | 69571 | return pyopencv_from(p->v->maxError);
| 69620 | } |  | 69572 | }
| 69621 |  |  | 69573 |
| 69622 | static int pyopencv_mcc_DetectorParameters_set_maxError(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69574 | static int pyopencv_mcc_DetectorParameters_set_maxError(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69623 | { |  | 69575 | {
| 69624 | if (!value) |  | 69576 | if (!value)
| 69625 | { |  | 69577 | {
| 69626 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxError attribute"); |  | 69578 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxError attribute");
| 69627 | return -1; |  | 69579 | return -1;
| 69628 | } |  | 69580 | }
| 69629 | return pyopencv_to_safe(value, p->v->maxError, ArgInfo("value", 0)) ? 0 : -1; |  | 69581 | return pyopencv_to_safe(value, p->v->maxError, ArgInfo("value", 0)) ? 0 : -1;
| 69630 | } |  | 69582 | }
| 69631 |  |  | 69583 |
| 69632 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContourLengthAllowed(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69584 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContourLengthAllowed(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69633 | { |  | 69585 | {
| 69634 | return pyopencv_from(p->v->minContourLengthAllowed); |  | 69586 | return pyopencv_from(p->v->minContourLengthAllowed);
| 69635 | } |  | 69587 | }
| 69636 |  |  | 69588 |
| 69637 | static int pyopencv_mcc_DetectorParameters_set_minContourLengthAllowed(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69589 | static int pyopencv_mcc_DetectorParameters_set_minContourLengthAllowed(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69638 | { |  | 69590 | {
| 69639 | if (!value) |  | 69591 | if (!value)
| 69640 | { |  | 69592 | {
| 69641 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContourLengthAllowed attribute"); |  | 69593 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContourLengthAllowed attribute");
| 69642 | return -1; |  | 69594 | return -1;
| 69643 | } |  | 69595 | }
| 69644 | return pyopencv_to_safe(value, p->v->minContourLengthAllowed, ArgInfo("value", 0)) ? 0 : -1; |  | 69596 | return pyopencv_to_safe(value, p->v->minContourLengthAllowed, ArgInfo("value", 0)) ? 0 : -1;
| 69645 | } |  | 69597 | }
| 69646 |  |  | 69598 |
| 69647 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContourPointsAllowed(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69599 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContourPointsAllowed(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69648 | { |  | 69600 | {
| 69649 | return pyopencv_from(p->v->minContourPointsAllowed); |  | 69601 | return pyopencv_from(p->v->minContourPointsAllowed);
| 69650 | } |  | 69602 | }
| 69651 |  |  | 69603 |
| 69652 | static int pyopencv_mcc_DetectorParameters_set_minContourPointsAllowed(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69604 | static int pyopencv_mcc_DetectorParameters_set_minContourPointsAllowed(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69653 | { |  | 69605 | {
| 69654 | if (!value) |  | 69606 | if (!value)
| 69655 | { |  | 69607 | {
| 69656 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContourPointsAllowed attribute"); |  | 69608 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContourPointsAllowed attribute");
| 69657 | return -1; |  | 69609 | return -1;
| 69658 | } |  | 69610 | }
| 69659 | return pyopencv_to_safe(value, p->v->minContourPointsAllowed, ArgInfo("value", 0)) ? 0 : -1; |  | 69611 | return pyopencv_to_safe(value, p->v->minContourPointsAllowed, ArgInfo("value", 0)) ? 0 : -1;
| 69660 | } |  | 69612 | }
| 69661 |  |  | 69613 |
| 69662 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContourSolidity(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69614 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContourSolidity(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69663 | { |  | 69615 | {
| 69664 | return pyopencv_from(p->v->minContourSolidity); |  | 69616 | return pyopencv_from(p->v->minContourSolidity);
| 69665 | } |  | 69617 | }
| 69666 |  |  | 69618 |
| 69667 | static int pyopencv_mcc_DetectorParameters_set_minContourSolidity(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69619 | static int pyopencv_mcc_DetectorParameters_set_minContourSolidity(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69668 | { |  | 69620 | {
| 69669 | if (!value) |  | 69621 | if (!value)
| 69670 | { |  | 69622 | {
| 69671 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContourSolidity attribute"); |  | 69623 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContourSolidity attribute");
| 69672 | return -1; |  | 69624 | return -1;
| 69673 | } |  | 69625 | }
| 69674 | return pyopencv_to_safe(value, p->v->minContourSolidity, ArgInfo("value", 0)) ? 0 : -1; |  | 69626 | return pyopencv_to_safe(value, p->v->minContourSolidity, ArgInfo("value", 0)) ? 0 : -1;
| 69675 | } |  | 69627 | }
| 69676 |  |  | 69628 |
| 69677 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContoursArea(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69629 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContoursArea(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69678 | { |  | 69630 | {
| 69679 | return pyopencv_from(p->v->minContoursArea); |  | 69631 | return pyopencv_from(p->v->minContoursArea);
| 69680 | } |  | 69632 | }
| 69681 |  |  | 69633 |
| 69682 | static int pyopencv_mcc_DetectorParameters_set_minContoursArea(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69634 | static int pyopencv_mcc_DetectorParameters_set_minContoursArea(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69683 | { |  | 69635 | {
| 69684 | if (!value) |  | 69636 | if (!value)
| 69685 | { |  | 69637 | {
| 69686 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContoursArea attribute"); |  | 69638 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContoursArea attribute");
| 69687 | return -1; |  | 69639 | return -1;
| 69688 | } |  | 69640 | }
| 69689 | return pyopencv_to_safe(value, p->v->minContoursArea, ArgInfo("value", 0)) ? 0 : -1; |  | 69641 | return pyopencv_to_safe(value, p->v->minContoursArea, ArgInfo("value", 0)) ? 0 : -1;
| 69690 | } |  | 69642 | }
| 69691 |  |  | 69643 |
| 69692 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContoursAreaRate(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69644 | static PyObject* pyopencv_mcc_DetectorParameters_get_minContoursAreaRate(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69693 | { |  | 69645 | {
| 69694 | return pyopencv_from(p->v->minContoursAreaRate); |  | 69646 | return pyopencv_from(p->v->minContoursAreaRate);
| 69695 | } |  | 69647 | }
| 69696 |  |  | 69648 |
| 69697 | static int pyopencv_mcc_DetectorParameters_set_minContoursAreaRate(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69649 | static int pyopencv_mcc_DetectorParameters_set_minContoursAreaRate(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69698 | { |  | 69650 | {
| 69699 | if (!value) |  | 69651 | if (!value)
| 69700 | { |  | 69652 | {
| 69701 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContoursAreaRate attribute"); |  | 69653 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minContoursAreaRate attribute");
| 69702 | return -1; |  | 69654 | return -1;
| 69703 | } |  | 69655 | }
| 69704 | return pyopencv_to_safe(value, p->v->minContoursAreaRate, ArgInfo("value", 0)) ? 0 : -1; |  | 69656 | return pyopencv_to_safe(value, p->v->minContoursAreaRate, ArgInfo("value", 0)) ? 0 : -1;
| 69705 | } |  | 69657 | }
| 69706 |  |  | 69658 |
| 69707 | static PyObject* pyopencv_mcc_DetectorParameters_get_minGroupSize(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69659 | static PyObject* pyopencv_mcc_DetectorParameters_get_minGroupSize(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69708 | { |  | 69660 | {
| 69709 | return pyopencv_from(p->v->minGroupSize); |  | 69661 | return pyopencv_from(p->v->minGroupSize);
| 69710 | } |  | 69662 | }
| 69711 |  |  | 69663 |
| 69712 | static int pyopencv_mcc_DetectorParameters_set_minGroupSize(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69664 | static int pyopencv_mcc_DetectorParameters_set_minGroupSize(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69713 | { |  | 69665 | {
| 69714 | if (!value) |  | 69666 | if (!value)
| 69715 | { |  | 69667 | {
| 69716 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minGroupSize attribute"); |  | 69668 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minGroupSize attribute");
| 69717 | return -1; |  | 69669 | return -1;
| 69718 | } |  | 69670 | }
| 69719 | return pyopencv_to_safe(value, p->v->minGroupSize, ArgInfo("value", 0)) ? 0 : -1; |  | 69671 | return pyopencv_to_safe(value, p->v->minGroupSize, ArgInfo("value", 0)) ? 0 : -1;
| 69720 | } |  | 69672 | }
| 69721 |  |  | 69673 |
| 69722 | static PyObject* pyopencv_mcc_DetectorParameters_get_minImageSize(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69674 | static PyObject* pyopencv_mcc_DetectorParameters_get_minImageSize(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69723 | { |  | 69675 | {
| 69724 | return pyopencv_from(p->v->minImageSize); |  | 69676 | return pyopencv_from(p->v->minImageSize);
| 69725 | } |  | 69677 | }
| 69726 |  |  | 69678 |
| 69727 | static int pyopencv_mcc_DetectorParameters_set_minImageSize(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69679 | static int pyopencv_mcc_DetectorParameters_set_minImageSize(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69728 | { |  | 69680 | {
| 69729 | if (!value) |  | 69681 | if (!value)
| 69730 | { |  | 69682 | {
| 69731 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minImageSize attribute"); |  | 69683 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minImageSize attribute");
| 69732 | return -1; |  | 69684 | return -1;
| 69733 | } |  | 69685 | }
| 69734 | return pyopencv_to_safe(value, p->v->minImageSize, ArgInfo("value", 0)) ? 0 : -1; |  | 69686 | return pyopencv_to_safe(value, p->v->minImageSize, ArgInfo("value", 0)) ? 0 : -1;
| 69735 | } |  | 69687 | }
| 69736 |  |  | 69688 |
| 69737 | static PyObject* pyopencv_mcc_DetectorParameters_get_minInterCheckerDistance(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69689 | static PyObject* pyopencv_mcc_DetectorParameters_get_minInterCheckerDistance(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69738 | { |  | 69690 | {
| 69739 | return pyopencv_from(p->v->minInterCheckerDistance); |  | 69691 | return pyopencv_from(p->v->minInterCheckerDistance);
| 69740 | } |  | 69692 | }
| 69741 |  |  | 69693 |
| 69742 | static int pyopencv_mcc_DetectorParameters_set_minInterCheckerDistance(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69694 | static int pyopencv_mcc_DetectorParameters_set_minInterCheckerDistance(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69743 | { |  | 69695 | {
| 69744 | if (!value) |  | 69696 | if (!value)
| 69745 | { |  | 69697 | {
| 69746 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minInterCheckerDistance attribute"); |  | 69698 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minInterCheckerDistance attribute");
| 69747 | return -1; |  | 69699 | return -1;
| 69748 | } |  | 69700 | }
| 69749 | return pyopencv_to_safe(value, p->v->minInterCheckerDistance, ArgInfo("value", 0)) ? 0 : -1; |  | 69701 | return pyopencv_to_safe(value, p->v->minInterCheckerDistance, ArgInfo("value", 0)) ? 0 : -1;
| 69750 | } |  | 69702 | }
| 69751 |  |  | 69703 |
| 69752 | static PyObject* pyopencv_mcc_DetectorParameters_get_minInterContourDistance(pyopencv_mcc_DetectorParameters_t* p, void *closure) |  | 69704 | static PyObject* pyopencv_mcc_DetectorParameters_get_minInterContourDistance(pyopencv_mcc_DetectorParameters_t* p, void *closure)
| 69753 | { |  | 69705 | {
| 69754 | return pyopencv_from(p->v->minInterContourDistance); |  | 69706 | return pyopencv_from(p->v->minInterContourDistance);
| 69755 | } |  | 69707 | }
| 69756 |  |  | 69708 |
| 69757 | static int pyopencv_mcc_DetectorParameters_set_minInterContourDistance(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure) |  | 69709 | static int pyopencv_mcc_DetectorParameters_set_minInterContourDistance(pyopencv_mcc_DetectorParameters_t* p, PyObject *value, void *closure)
| 69758 | { |  | 69710 | {
| 69759 | if (!value) |  | 69711 | if (!value)
| 69760 | { |  | 69712 | {
| 69761 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minInterContourDistance attribute"); |  | 69713 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minInterContourDistance attribute");
| 69762 | return -1; |  | 69714 | return -1;
| 69763 | } |  | 69715 | }
| 69764 | return pyopencv_to_safe(value, p->v->minInterContourDistance, ArgInfo("value", 0)) ? 0 : -1; |  | 69716 | return pyopencv_to_safe(value, p->v->minInterContourDistance, ArgInfo("value", 0)) ? 0 : -1;
| 69765 | } |  | 69717 | }
| 69766 |  |  | 69718 |
| 69767 |  |  | 69719 |
| 69768 | // Methods (mcc_DetectorParameters) |  | 69720 | // Methods (mcc_DetectorParameters)
| 69769 |  |  | 69721 |
| 69770 | static PyObject* pyopencv_cv_mcc_mcc_DetectorParameters_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69722 | static PyObject* pyopencv_cv_mcc_mcc_DetectorParameters_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 69771 | { |  | 69723 | {
| 69772 | using namespace cv::mcc; |  | 69724 | using namespace cv::mcc;
| 69773 |  |  | 69725 |
| 69774 | Ptr<DetectorParameters> retval; |  | 69726 | Ptr<DetectorParameters> retval;
| 69775 |  |  | 69727 |
| 69776 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69728 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69777 | { |  | 69729 | {
| 69778 | ERRWRAP2(retval = cv::mcc::DetectorParameters::create()); |  | 69730 | ERRWRAP2(retval = cv::mcc::DetectorParameters::create());
| 69779 | return pyopencv_from(retval); |  | 69731 | return pyopencv_from(retval);
| 69780 | } |  | 69732 | }
| 69781 |  |  | 69733 |
| 69782 | return NULL; |  | 69734 | return NULL;
| 69783 | } |  | 69735 | }
| 69784 |  |  | 69736 |
| 69785 |  |  | 69737 |
| 69786 |  |  | 69738 |
| 69787 | // Tables (mcc_DetectorParameters) |  | 69739 | // Tables (mcc_DetectorParameters)
| 69788 |  |  | 69740 |
| 69789 | static PyGetSetDef pyopencv_mcc_DetectorParameters_getseters[] = |  | 69741 | static PyGetSetDef pyopencv_mcc_DetectorParameters_getseters[] =
| 69790 | { |  | 69742 | {
| 69791 | {(char*)"B0factor", (getter)pyopencv_mcc_DetectorParameters_get_B0factor, (setter)pyopencv_mcc_DetectorParameters_set_B0factor, (char*)"B0factor", NULL}, |  | 69743 | {(char*)"B0factor", (getter)pyopencv_mcc_DetectorParameters_get_B0factor, (setter)pyopencv_mcc_DetectorParameters_set_B0factor, (char*)"B0factor", NULL},
| 69792 | {(char*)"adaptiveThreshConstant", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshConstant, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshConstant, (char*)"adaptiveThreshConstant", NULL}, |  | 69744 | {(char*)"adaptiveThreshConstant", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshConstant, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshConstant, (char*)"adaptiveThreshConstant", NULL},
| 69793 | {(char*)"adaptiveThreshWinSizeMax", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMax, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMax, (char*)"adaptiveThreshWinSizeMax", NULL}, |  | 69745 | {(char*)"adaptiveThreshWinSizeMax", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMax, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMax, (char*)"adaptiveThreshWinSizeMax", NULL},
| 69794 | {(char*)"adaptiveThreshWinSizeMin", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMin, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMin, (char*)"adaptiveThreshWinSizeMin", NULL}, |  | 69746 | {(char*)"adaptiveThreshWinSizeMin", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeMin, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeMin, (char*)"adaptiveThreshWinSizeMin", NULL},
| 69795 | {(char*)"adaptiveThreshWinSizeStep", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeStep, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeStep, (char*)"adaptiveThreshWinSizeStep", NULL}, |  | 69747 | {(char*)"adaptiveThreshWinSizeStep", (getter)pyopencv_mcc_DetectorParameters_get_adaptiveThreshWinSizeStep, (setter)pyopencv_mcc_DetectorParameters_set_adaptiveThreshWinSizeStep, (char*)"adaptiveThreshWinSizeStep", NULL},
| 69796 | {(char*)"borderWidth", (getter)pyopencv_mcc_DetectorParameters_get_borderWidth, (setter)pyopencv_mcc_DetectorParameters_set_borderWidth, (char*)"borderWidth", NULL}, |  | 69748 | {(char*)"borderWidth", (getter)pyopencv_mcc_DetectorParameters_get_borderWidth, (setter)pyopencv_mcc_DetectorParameters_set_borderWidth, (char*)"borderWidth", NULL},
| 69797 | {(char*)"confidenceThreshold", (getter)pyopencv_mcc_DetectorParameters_get_confidenceThreshold, (setter)pyopencv_mcc_DetectorParameters_set_confidenceThreshold, (char*)"confidenceThreshold", NULL}, |  | 69749 | {(char*)"confidenceThreshold", (getter)pyopencv_mcc_DetectorParameters_get_confidenceThreshold, (setter)pyopencv_mcc_DetectorParameters_set_confidenceThreshold, (char*)"confidenceThreshold", NULL},
| 69798 | {(char*)"findCandidatesApproxPolyDPEpsMultiplier", (getter)pyopencv_mcc_DetectorParameters_get_findCandidatesApproxPolyDPEpsMultiplier, (setter)pyopencv_mcc_DetectorParameters_set_findCandidatesApproxPolyDPEpsMultiplier, (char*)"findCandidatesApproxPolyDPEpsMultiplier", NULL}, |  | 69750 | {(char*)"findCandidatesApproxPolyDPEpsMultiplier", (getter)pyopencv_mcc_DetectorParameters_get_findCandidatesApproxPolyDPEpsMultiplier, (setter)pyopencv_mcc_DetectorParameters_set_findCandidatesApproxPolyDPEpsMultiplier, (char*)"findCandidatesApproxPolyDPEpsMultiplier", NULL},
| 69799 | {(char*)"maxError", (getter)pyopencv_mcc_DetectorParameters_get_maxError, (setter)pyopencv_mcc_DetectorParameters_set_maxError, (char*)"maxError", NULL}, |  | 69751 | {(char*)"maxError", (getter)pyopencv_mcc_DetectorParameters_get_maxError, (setter)pyopencv_mcc_DetectorParameters_set_maxError, (char*)"maxError", NULL},
| 69800 | {(char*)"minContourLengthAllowed", (getter)pyopencv_mcc_DetectorParameters_get_minContourLengthAllowed, (setter)pyopencv_mcc_DetectorParameters_set_minContourLengthAllowed, (char*)"minContourLengthAllowed", NULL}, |  | 69752 | {(char*)"minContourLengthAllowed", (getter)pyopencv_mcc_DetectorParameters_get_minContourLengthAllowed, (setter)pyopencv_mcc_DetectorParameters_set_minContourLengthAllowed, (char*)"minContourLengthAllowed", NULL},
| 69801 | {(char*)"minContourPointsAllowed", (getter)pyopencv_mcc_DetectorParameters_get_minContourPointsAllowed, (setter)pyopencv_mcc_DetectorParameters_set_minContourPointsAllowed, (char*)"minContourPointsAllowed", NULL}, |  | 69753 | {(char*)"minContourPointsAllowed", (getter)pyopencv_mcc_DetectorParameters_get_minContourPointsAllowed, (setter)pyopencv_mcc_DetectorParameters_set_minContourPointsAllowed, (char*)"minContourPointsAllowed", NULL},
| 69802 | {(char*)"minContourSolidity", (getter)pyopencv_mcc_DetectorParameters_get_minContourSolidity, (setter)pyopencv_mcc_DetectorParameters_set_minContourSolidity, (char*)"minContourSolidity", NULL}, |  | 69754 | {(char*)"minContourSolidity", (getter)pyopencv_mcc_DetectorParameters_get_minContourSolidity, (setter)pyopencv_mcc_DetectorParameters_set_minContourSolidity, (char*)"minContourSolidity", NULL},
| 69803 | {(char*)"minContoursArea", (getter)pyopencv_mcc_DetectorParameters_get_minContoursArea, (setter)pyopencv_mcc_DetectorParameters_set_minContoursArea, (char*)"minContoursArea", NULL}, |  | 69755 | {(char*)"minContoursArea", (getter)pyopencv_mcc_DetectorParameters_get_minContoursArea, (setter)pyopencv_mcc_DetectorParameters_set_minContoursArea, (char*)"minContoursArea", NULL},
| 69804 | {(char*)"minContoursAreaRate", (getter)pyopencv_mcc_DetectorParameters_get_minContoursAreaRate, (setter)pyopencv_mcc_DetectorParameters_set_minContoursAreaRate, (char*)"minContoursAreaRate", NULL}, |  | 69756 | {(char*)"minContoursAreaRate", (getter)pyopencv_mcc_DetectorParameters_get_minContoursAreaRate, (setter)pyopencv_mcc_DetectorParameters_set_minContoursAreaRate, (char*)"minContoursAreaRate", NULL},
| 69805 | {(char*)"minGroupSize", (getter)pyopencv_mcc_DetectorParameters_get_minGroupSize, (setter)pyopencv_mcc_DetectorParameters_set_minGroupSize, (char*)"minGroupSize", NULL}, |  | 69757 | {(char*)"minGroupSize", (getter)pyopencv_mcc_DetectorParameters_get_minGroupSize, (setter)pyopencv_mcc_DetectorParameters_set_minGroupSize, (char*)"minGroupSize", NULL},
| 69806 | {(char*)"minImageSize", (getter)pyopencv_mcc_DetectorParameters_get_minImageSize, (setter)pyopencv_mcc_DetectorParameters_set_minImageSize, (char*)"minImageSize", NULL}, |  | 69758 | {(char*)"minImageSize", (getter)pyopencv_mcc_DetectorParameters_get_minImageSize, (setter)pyopencv_mcc_DetectorParameters_set_minImageSize, (char*)"minImageSize", NULL},
| 69807 | {(char*)"minInterCheckerDistance", (getter)pyopencv_mcc_DetectorParameters_get_minInterCheckerDistance, (setter)pyopencv_mcc_DetectorParameters_set_minInterCheckerDistance, (char*)"minInterCheckerDistance", NULL}, |  | 69759 | {(char*)"minInterCheckerDistance", (getter)pyopencv_mcc_DetectorParameters_get_minInterCheckerDistance, (setter)pyopencv_mcc_DetectorParameters_set_minInterCheckerDistance, (char*)"minInterCheckerDistance", NULL},
| 69808 | {(char*)"minInterContourDistance", (getter)pyopencv_mcc_DetectorParameters_get_minInterContourDistance, (setter)pyopencv_mcc_DetectorParameters_set_minInterContourDistance, (char*)"minInterContourDistance", NULL}, |  | 69760 | {(char*)"minInterContourDistance", (getter)pyopencv_mcc_DetectorParameters_get_minInterContourDistance, (setter)pyopencv_mcc_DetectorParameters_set_minInterContourDistance, (char*)"minInterContourDistance", NULL},
| 69809 | {NULL} /* Sentinel */ |  | 69761 | {NULL} /* Sentinel */
| 69810 | }; |  | 69762 | };
| 69811 |  |  | 69763 |
| 69812 | static PyMethodDef pyopencv_mcc_DetectorParameters_methods[] = |  | 69764 | static PyMethodDef pyopencv_mcc_DetectorParameters_methods[] =
| 69813 | { |  | 69765 | {
| 69814 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_DetectorParameters_create_static, METH_STATIC), "create() -> retval\n."}, |  | 69766 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_mcc_mcc_DetectorParameters_create_static, METH_STATIC), "create() -> retval\n."},
| 69815 |  |  | 69767 |
| 69816 | {NULL, NULL} |  | 69768 | {NULL, NULL}
| 69817 | }; |  | 69769 | };
| 69818 |  |  | 69770 |
| 69819 | // Converter (mcc_DetectorParameters) |  | 69771 | // Converter (mcc_DetectorParameters)
| 69820 |  |  | 69772 |
| 69821 | template<> |  | 69773 | template<>
| 69822 | struct PyOpenCV_Converter< Ptr<cv::mcc::DetectorParameters> > |  | 69774 | struct PyOpenCV_Converter< Ptr<cv::mcc::DetectorParameters> >
| 69823 | { |  | 69775 | {
| 69824 | static PyObject* from(const Ptr<cv::mcc::DetectorParameters>& r) |  | 69776 | static PyObject* from(const Ptr<cv::mcc::DetectorParameters>& r)
| 69825 | { |  | 69777 | {
| 69826 | return pyopencv_mcc_DetectorParameters_Instance(r); |  | 69778 | return pyopencv_mcc_DetectorParameters_Instance(r);
| 69827 | } |  | 69779 | }
| 69828 | static bool to(PyObject* src, Ptr<cv::mcc::DetectorParameters>& dst, const ArgInfo& info) |  | 69780 | static bool to(PyObject* src, Ptr<cv::mcc::DetectorParameters>& dst, const ArgInfo& info)
| 69829 | { |  | 69781 | {
| 69830 | if(!src || src == Py_None) |  | 69782 | if(!src || src == Py_None)
| 69831 | return true; |  | 69783 | return true;
| 69832 | Ptr<cv::mcc::DetectorParameters> * dst_; |  | 69784 | Ptr<cv::mcc::DetectorParameters> * dst_;
| 69833 | if (pyopencv_mcc_DetectorParameters_getp(src, dst_)) |  | 69785 | if (pyopencv_mcc_DetectorParameters_getp(src, dst_))
| 69834 | { |  | 69786 | {
| 69835 | dst = *dst_; |  | 69787 | dst = *dst_;
| 69836 | return true; |  | 69788 | return true;
| 69837 | } |  | 69789 | }
| 69838 |  |  | 69790 |
| 69839 | failmsg("Expected Ptr<cv::mcc::DetectorParameters> for argument '%s'", info.name); |  | 69791 | failmsg("Expected Ptr<cv::mcc::DetectorParameters> for argument '%s'", info.name);
| 69840 | return false; |  | 69792 | return false;
| 69841 | } |  | 69793 | }
| 69842 | }; |  | 69794 | };
| 69843 |  |  | 69795 |
| 69844 | //================================================================================ |  | 69796 | //================================================================================
| 69845 | // ml_ANN_MLP (Generic) |  | 69797 | // ml_ANN_MLP (Generic)
| 69846 | //================================================================================ |  | 69798 | //================================================================================
| 69847 |  |  | 69799 |
| 69848 | // GetSet (ml_ANN_MLP) |  | 69800 | // GetSet (ml_ANN_MLP)
| 69849 |  |  | 69801 |
| 69850 |  |  | 69802 |
| 69851 |  |  | 69803 |
| 69852 | // Methods (ml_ANN_MLP) |  | 69804 | // Methods (ml_ANN_MLP)
| 69853 |  |  | 69805 |
| 69854 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69806 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 69855 | { |  | 69807 | {
| 69856 | using namespace cv::ml; |  | 69808 | using namespace cv::ml;
| 69857 |  |  | 69809 |
| 69858 | Ptr<ANN_MLP> retval; |  | 69810 | Ptr<ANN_MLP> retval;
| 69859 |  |  | 69811 |
| 69860 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69812 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69861 | { |  | 69813 | {
| 69862 | ERRWRAP2(retval = cv::ml::ANN_MLP::create()); |  | 69814 | ERRWRAP2(retval = cv::ml::ANN_MLP::create());
| 69863 | return pyopencv_from(retval); |  | 69815 | return pyopencv_from(retval);
| 69864 | } |  | 69816 | }
| 69865 |  |  | 69817 |
| 69866 | return NULL; |  | 69818 | return NULL;
| 69867 | } |  | 69819 | }
| 69868 |  |  | 69820 |
| 69869 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealCoolingRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69821 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealCoolingRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 69870 | { |  | 69822 | {
| 69871 | using namespace cv::ml; |  | 69823 | using namespace cv::ml;
| 69872 |  |  | 69824 |
| 69873 |  |  | 69825 |
| 69874 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69826 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 69875 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69827 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 69876 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69828 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 69877 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69829 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 69878 | double retval; |  | 69830 | double retval;
| 69879 |  |  | 69831 |
| 69880 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69832 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69881 | { |  | 69833 | {
| 69882 | ERRWRAP2(retval = _self_->getAnnealCoolingRatio()); |  | 69834 | ERRWRAP2(retval = _self_->getAnnealCoolingRatio());
| 69883 | return pyopencv_from(retval); |  | 69835 | return pyopencv_from(retval);
| 69884 | } |  | 69836 | }
| 69885 |  |  | 69837 |
| 69886 | return NULL; |  | 69838 | return NULL;
| 69887 | } |  | 69839 | }
| 69888 |  |  | 69840 |
| 69889 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealFinalT(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69841 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealFinalT(PyObject* self, PyObject* py_args, PyObject* kw)
| 69890 | { |  | 69842 | {
| 69891 | using namespace cv::ml; |  | 69843 | using namespace cv::ml;
| 69892 |  |  | 69844 |
| 69893 |  |  | 69845 |
| 69894 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69846 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 69895 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69847 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 69896 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69848 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 69897 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69849 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 69898 | double retval; |  | 69850 | double retval;
| 69899 |  |  | 69851 |
| 69900 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69852 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69901 | { |  | 69853 | {
| 69902 | ERRWRAP2(retval = _self_->getAnnealFinalT()); |  | 69854 | ERRWRAP2(retval = _self_->getAnnealFinalT());
| 69903 | return pyopencv_from(retval); |  | 69855 | return pyopencv_from(retval);
| 69904 | } |  | 69856 | }
| 69905 |  |  | 69857 |
| 69906 | return NULL; |  | 69858 | return NULL;
| 69907 | } |  | 69859 | }
| 69908 |  |  | 69860 |
| 69909 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealInitialT(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69861 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealInitialT(PyObject* self, PyObject* py_args, PyObject* kw)
| 69910 | { |  | 69862 | {
| 69911 | using namespace cv::ml; |  | 69863 | using namespace cv::ml;
| 69912 |  |  | 69864 |
| 69913 |  |  | 69865 |
| 69914 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69866 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 69915 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69867 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 69916 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69868 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 69917 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69869 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 69918 | double retval; |  | 69870 | double retval;
| 69919 |  |  | 69871 |
| 69920 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69872 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69921 | { |  | 69873 | {
| 69922 | ERRWRAP2(retval = _self_->getAnnealInitialT()); |  | 69874 | ERRWRAP2(retval = _self_->getAnnealInitialT());
| 69923 | return pyopencv_from(retval); |  | 69875 | return pyopencv_from(retval);
| 69924 | } |  | 69876 | }
| 69925 |  |  | 69877 |
| 69926 | return NULL; |  | 69878 | return NULL;
| 69927 | } |  | 69879 | }
| 69928 |  |  | 69880 |
| 69929 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealItePerStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69881 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getAnnealItePerStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 69930 | { |  | 69882 | {
| 69931 | using namespace cv::ml; |  | 69883 | using namespace cv::ml;
| 69932 |  |  | 69884 |
| 69933 |  |  | 69885 |
| 69934 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69886 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 69935 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69887 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 69936 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69888 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 69937 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69889 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 69938 | int retval; |  | 69890 | int retval;
| 69939 |  |  | 69891 |
| 69940 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69892 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69941 | { |  | 69893 | {
| 69942 | ERRWRAP2(retval = _self_->getAnnealItePerStep()); |  | 69894 | ERRWRAP2(retval = _self_->getAnnealItePerStep());
| 69943 | return pyopencv_from(retval); |  | 69895 | return pyopencv_from(retval);
| 69944 | } |  | 69896 | }
| 69945 |  |  | 69897 |
| 69946 | return NULL; |  | 69898 | return NULL;
| 69947 | } |  | 69899 | }
| 69948 |  |  | 69900 |
| 69949 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getBackpropMomentumScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69901 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getBackpropMomentumScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 69950 | { |  | 69902 | {
| 69951 | using namespace cv::ml; |  | 69903 | using namespace cv::ml;
| 69952 |  |  | 69904 |
| 69953 |  |  | 69905 |
| 69954 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69906 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 69955 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69907 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 69956 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69908 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 69957 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69909 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 69958 | double retval; |  | 69910 | double retval;
| 69959 |  |  | 69911 |
| 69960 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69912 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69961 | { |  | 69913 | {
| 69962 | ERRWRAP2(retval = _self_->getBackpropMomentumScale()); |  | 69914 | ERRWRAP2(retval = _self_->getBackpropMomentumScale());
| 69963 | return pyopencv_from(retval); |  | 69915 | return pyopencv_from(retval);
| 69964 | } |  | 69916 | }
| 69965 |  |  | 69917 |
| 69966 | return NULL; |  | 69918 | return NULL;
| 69967 | } |  | 69919 | }
| 69968 |  |  | 69920 |
| 69969 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getBackpropWeightScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69921 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getBackpropWeightScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 69970 | { |  | 69922 | {
| 69971 | using namespace cv::ml; |  | 69923 | using namespace cv::ml;
| 69972 |  |  | 69924 |
| 69973 |  |  | 69925 |
| 69974 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69926 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 69975 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69927 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 69976 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69928 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 69977 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69929 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 69978 | double retval; |  | 69930 | double retval;
| 69979 |  |  | 69931 |
| 69980 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69932 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 69981 | { |  | 69933 | {
| 69982 | ERRWRAP2(retval = _self_->getBackpropWeightScale()); |  | 69934 | ERRWRAP2(retval = _self_->getBackpropWeightScale());
| 69983 | return pyopencv_from(retval); |  | 69935 | return pyopencv_from(retval);
| 69984 | } |  | 69936 | }
| 69985 |  |  | 69937 |
| 69986 | return NULL; |  | 69938 | return NULL;
| 69987 | } |  | 69939 | }
| 69988 |  |  | 69940 |
| 69989 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getLayerSizes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69941 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getLayerSizes(PyObject* self, PyObject* py_args, PyObject* kw)
| 69990 | { |  | 69942 | {
| 69991 | using namespace cv::ml; |  | 69943 | using namespace cv::ml;
| 69992 |  |  | 69944 |
| 69993 |  |  | 69945 |
| 69994 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69946 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 69995 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69947 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 69996 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69948 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 69997 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69949 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 69998 | cv::Mat retval; |  | 69950 | cv::Mat retval;
| 69999 |  |  | 69951 |
| 70000 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69952 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70001 | { |  | 69953 | {
| 70002 | ERRWRAP2(retval = _self_->getLayerSizes()); |  | 69954 | ERRWRAP2(retval = _self_->getLayerSizes());
| 70003 | return pyopencv_from(retval); |  | 69955 | return pyopencv_from(retval);
| 70004 | } |  | 69956 | }
| 70005 |  |  | 69957 |
| 70006 | return NULL; |  | 69958 | return NULL;
| 70007 | } |  | 69959 | }
| 70008 |  |  | 69960 |
| 70009 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDW0(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69961 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDW0(PyObject* self, PyObject* py_args, PyObject* kw)
| 70010 | { |  | 69962 | {
| 70011 | using namespace cv::ml; |  | 69963 | using namespace cv::ml;
| 70012 |  |  | 69964 |
| 70013 |  |  | 69965 |
| 70014 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69966 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70015 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69967 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70016 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69968 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70017 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69969 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70018 | double retval; |  | 69970 | double retval;
| 70019 |  |  | 69971 |
| 70020 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69972 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70021 | { |  | 69973 | {
| 70022 | ERRWRAP2(retval = _self_->getRpropDW0()); |  | 69974 | ERRWRAP2(retval = _self_->getRpropDW0());
| 70023 | return pyopencv_from(retval); |  | 69975 | return pyopencv_from(retval);
| 70024 | } |  | 69976 | }
| 70025 |  |  | 69977 |
| 70026 | return NULL; |  | 69978 | return NULL;
| 70027 | } |  | 69979 | }
| 70028 |  |  | 69980 |
| 70029 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMax(PyObject* self, PyObject* py_args, PyObject* kw) |  | 69981 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMax(PyObject* self, PyObject* py_args, PyObject* kw)
| 70030 | { |  | 69982 | {
| 70031 | using namespace cv::ml; |  | 69983 | using namespace cv::ml;
| 70032 |  |  | 69984 |
| 70033 |  |  | 69985 |
| 70034 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 69986 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70035 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 69987 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70036 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 69988 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70037 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 69989 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70038 | double retval; |  | 69990 | double retval;
| 70039 |  |  | 69991 |
| 70040 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 69992 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70041 | { |  | 69993 | {
| 70042 | ERRWRAP2(retval = _self_->getRpropDWMax()); |  | 69994 | ERRWRAP2(retval = _self_->getRpropDWMax());
| 70043 | return pyopencv_from(retval); |  | 69995 | return pyopencv_from(retval);
| 70044 | } |  | 69996 | }
| 70045 |  |  | 69997 |
| 70046 | return NULL; |  | 69998 | return NULL;
| 70047 | } |  | 69999 | }
| 70048 |  |  | 70000 |
| 70049 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMin(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70001 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMin(PyObject* self, PyObject* py_args, PyObject* kw)
| 70050 | { |  | 70002 | {
| 70051 | using namespace cv::ml; |  | 70003 | using namespace cv::ml;
| 70052 |  |  | 70004 |
| 70053 |  |  | 70005 |
| 70054 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70006 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70055 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70007 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70056 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70008 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70057 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70009 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70058 | double retval; |  | 70010 | double retval;
| 70059 |  |  | 70011 |
| 70060 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70012 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70061 | { |  | 70013 | {
| 70062 | ERRWRAP2(retval = _self_->getRpropDWMin()); |  | 70014 | ERRWRAP2(retval = _self_->getRpropDWMin());
| 70063 | return pyopencv_from(retval); |  | 70015 | return pyopencv_from(retval);
| 70064 | } |  | 70016 | }
| 70065 |  |  | 70017 |
| 70066 | return NULL; |  | 70018 | return NULL;
| 70067 | } |  | 70019 | }
| 70068 |  |  | 70020 |
| 70069 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMinus(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70021 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMinus(PyObject* self, PyObject* py_args, PyObject* kw)
| 70070 | { |  | 70022 | {
| 70071 | using namespace cv::ml; |  | 70023 | using namespace cv::ml;
| 70072 |  |  | 70024 |
| 70073 |  |  | 70025 |
| 70074 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70026 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70075 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70027 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70076 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70028 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70077 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70029 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70078 | double retval; |  | 70030 | double retval;
| 70079 |  |  | 70031 |
| 70080 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70032 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70081 | { |  | 70033 | {
| 70082 | ERRWRAP2(retval = _self_->getRpropDWMinus()); |  | 70034 | ERRWRAP2(retval = _self_->getRpropDWMinus());
| 70083 | return pyopencv_from(retval); |  | 70035 | return pyopencv_from(retval);
| 70084 | } |  | 70036 | }
| 70085 |  |  | 70037 |
| 70086 | return NULL; |  | 70038 | return NULL;
| 70087 | } |  | 70039 | }
| 70088 |  |  | 70040 |
| 70089 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWPlus(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70041 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getRpropDWPlus(PyObject* self, PyObject* py_args, PyObject* kw)
| 70090 | { |  | 70042 | {
| 70091 | using namespace cv::ml; |  | 70043 | using namespace cv::ml;
| 70092 |  |  | 70044 |
| 70093 |  |  | 70045 |
| 70094 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70046 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70095 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70047 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70096 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70048 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70097 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70049 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70098 | double retval; |  | 70050 | double retval;
| 70099 |  |  | 70051 |
| 70100 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70052 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70101 | { |  | 70053 | {
| 70102 | ERRWRAP2(retval = _self_->getRpropDWPlus()); |  | 70054 | ERRWRAP2(retval = _self_->getRpropDWPlus());
| 70103 | return pyopencv_from(retval); |  | 70055 | return pyopencv_from(retval);
| 70104 | } |  | 70056 | }
| 70105 |  |  | 70057 |
| 70106 | return NULL; |  | 70058 | return NULL;
| 70107 | } |  | 70059 | }
| 70108 |  |  | 70060 |
| 70109 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70061 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 70110 | { |  | 70062 | {
| 70111 | using namespace cv::ml; |  | 70063 | using namespace cv::ml;
| 70112 |  |  | 70064 |
| 70113 |  |  | 70065 |
| 70114 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70066 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70115 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70067 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70116 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70068 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70117 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70069 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70118 | TermCriteria retval; |  | 70070 | TermCriteria retval;
| 70119 |  |  | 70071 |
| 70120 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70072 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70121 | { |  | 70073 | {
| 70122 | ERRWRAP2(retval = _self_->getTermCriteria()); |  | 70074 | ERRWRAP2(retval = _self_->getTermCriteria());
| 70123 | return pyopencv_from(retval); |  | 70075 | return pyopencv_from(retval);
| 70124 | } |  | 70076 | }
| 70125 |  |  | 70077 |
| 70126 | return NULL; |  | 70078 | return NULL;
| 70127 | } |  | 70079 | }
| 70128 |  |  | 70080 |
| 70129 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70081 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 70130 | { |  | 70082 | {
| 70131 | using namespace cv::ml; |  | 70083 | using namespace cv::ml;
| 70132 |  |  | 70084 |
| 70133 |  |  | 70085 |
| 70134 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70086 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70135 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70087 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70136 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70088 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70137 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70089 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70138 | int retval; |  | 70090 | int retval;
| 70139 |  |  | 70091 |
| 70140 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70092 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70141 | { |  | 70093 | {
| 70142 | ERRWRAP2(retval = _self_->getTrainMethod()); |  | 70094 | ERRWRAP2(retval = _self_->getTrainMethod());
| 70143 | return pyopencv_from(retval); |  | 70095 | return pyopencv_from(retval);
| 70144 | } |  | 70096 | }
| 70145 |  |  | 70097 |
| 70146 | return NULL; |  | 70098 | return NULL;
| 70147 | } |  | 70099 | }
| 70148 |  |  | 70100 |
| 70149 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70101 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_getWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 70150 | { |  | 70102 | {
| 70151 | using namespace cv::ml; |  | 70103 | using namespace cv::ml;
| 70152 |  |  | 70104 |
| 70153 |  |  | 70105 |
| 70154 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70106 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70155 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70107 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70156 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70108 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70157 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70109 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70158 | PyObject* pyobj_layerIdx = NULL; |  | 70110 | PyObject* pyobj_layerIdx = NULL;
| 70159 | int layerIdx=0; |  | 70111 | int layerIdx=0;
| 70160 | Mat retval; |  | 70112 | Mat retval;
| 70161 |  |  | 70113 |
| 70162 | const char* keywords[] = { "layerIdx", NULL }; |  | 70114 | const char* keywords[] = { "layerIdx", NULL };
| 70163 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.getWeights", (char**)keywords, &pyobj_layerIdx) && |  | 70115 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.getWeights", (char**)keywords, &pyobj_layerIdx) &&
| 70164 | pyopencv_to_safe(pyobj_layerIdx, layerIdx, ArgInfo("layerIdx", 0)) ) |  | 70116 | pyopencv_to_safe(pyobj_layerIdx, layerIdx, ArgInfo("layerIdx", 0)) )
| 70165 | { |  | 70117 | {
| 70166 | ERRWRAP2(retval = _self_->getWeights(layerIdx)); |  | 70118 | ERRWRAP2(retval = _self_->getWeights(layerIdx));
| 70167 | return pyopencv_from(retval); |  | 70119 | return pyopencv_from(retval);
| 70168 | } |  | 70120 | }
| 70169 |  |  | 70121 |
| 70170 | return NULL; |  | 70122 | return NULL;
| 70171 | } |  | 70123 | }
| 70172 |  |  | 70124 |
| 70173 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70125 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 70174 | { |  | 70126 | {
| 70175 | using namespace cv::ml; |  | 70127 | using namespace cv::ml;
| 70176 |  |  | 70128 |
| 70177 | PyObject* pyobj_filepath = NULL; |  | 70129 | PyObject* pyobj_filepath = NULL;
| 70178 | String filepath; |  | 70130 | String filepath;
| 70179 | Ptr<ANN_MLP> retval; |  | 70131 | Ptr<ANN_MLP> retval;
| 70180 |  |  | 70132 |
| 70181 | const char* keywords[] = { "filepath", NULL }; |  | 70133 | const char* keywords[] = { "filepath", NULL };
| 70182 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.load", (char**)keywords, &pyobj_filepath) && |  | 70134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.load", (char**)keywords, &pyobj_filepath) &&
| 70183 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) ) |  | 70135 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) )
| 70184 | { |  | 70136 | {
| 70185 | ERRWRAP2(retval = cv::ml::ANN_MLP::load(filepath)); |  | 70137 | ERRWRAP2(retval = cv::ml::ANN_MLP::load(filepath));
| 70186 | return pyopencv_from(retval); |  | 70138 | return pyopencv_from(retval);
| 70187 | } |  | 70139 | }
| 70188 |  |  | 70140 |
| 70189 | return NULL; |  | 70141 | return NULL;
| 70190 | } |  | 70142 | }
| 70191 |  |  | 70143 |
| 70192 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setActivationFunction(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70144 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setActivationFunction(PyObject* self, PyObject* py_args, PyObject* kw)
| 70193 | { |  | 70145 | {
| 70194 | using namespace cv::ml; |  | 70146 | using namespace cv::ml;
| 70195 |  |  | 70147 |
| 70196 |  |  | 70148 |
| 70197 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70149 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70198 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70150 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70199 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70151 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70200 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70152 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70201 | PyObject* pyobj_type = NULL; |  | 70153 | PyObject* pyobj_type = NULL;
| 70202 | int type=0; |  | 70154 | int type=0;
| 70203 | PyObject* pyobj_param1 = NULL; |  | 70155 | PyObject* pyobj_param1 = NULL;
| 70204 | double param1=0; |  | 70156 | double param1=0;
| 70205 | PyObject* pyobj_param2 = NULL; |  | 70157 | PyObject* pyobj_param2 = NULL;
| 70206 | double param2=0; |  | 70158 | double param2=0;
| 70207 |  |  | 70159 |
| 70208 | const char* keywords[] = { "type", "param1", "param2", NULL }; |  | 70160 | const char* keywords[] = { "type", "param1", "param2", NULL };
| 70209 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_ANN_MLP.setActivationFunction", (char**)keywords, &pyobj_type, &pyobj_param1, &pyobj_param2) && |  | 70161 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_ANN_MLP.setActivationFunction", (char**)keywords, &pyobj_type, &pyobj_param1, &pyobj_param2) &&
| 70210 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) && |  | 70162 | pyopencv_to_safe(pyobj_type, type, ArgInfo("type", 0)) &&
| 70211 | pyopencv_to_safe(pyobj_param1, param1, ArgInfo("param1", 0)) && |  | 70163 | pyopencv_to_safe(pyobj_param1, param1, ArgInfo("param1", 0)) &&
| 70212 | pyopencv_to_safe(pyobj_param2, param2, ArgInfo("param2", 0)) ) |  | 70164 | pyopencv_to_safe(pyobj_param2, param2, ArgInfo("param2", 0)) )
| 70213 | { |  | 70165 | {
| 70214 | ERRWRAP2(_self_->setActivationFunction(type, param1, param2)); |  | 70166 | ERRWRAP2(_self_->setActivationFunction(type, param1, param2));
| 70215 | Py_RETURN_NONE; |  | 70167 | Py_RETURN_NONE;
| 70216 | } |  | 70168 | }
| 70217 |  |  | 70169 |
| 70218 | return NULL; |  | 70170 | return NULL;
| 70219 | } |  | 70171 | }
| 70220 |  |  | 70172 |
| 70221 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealCoolingRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70173 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealCoolingRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 70222 | { |  | 70174 | {
| 70223 | using namespace cv::ml; |  | 70175 | using namespace cv::ml;
| 70224 |  |  | 70176 |
| 70225 |  |  | 70177 |
| 70226 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70178 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70227 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70179 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70228 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70180 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70229 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70181 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70230 | PyObject* pyobj_val = NULL; |  | 70182 | PyObject* pyobj_val = NULL;
| 70231 | double val=0; |  | 70183 | double val=0;
| 70232 |  |  | 70184 |
| 70233 | const char* keywords[] = { "val", NULL }; |  | 70185 | const char* keywords[] = { "val", NULL };
| 70234 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealCoolingRatio", (char**)keywords, &pyobj_val) && |  | 70186 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealCoolingRatio", (char**)keywords, &pyobj_val) &&
| 70235 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70187 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70236 | { |  | 70188 | {
| 70237 | ERRWRAP2(_self_->setAnnealCoolingRatio(val)); |  | 70189 | ERRWRAP2(_self_->setAnnealCoolingRatio(val));
| 70238 | Py_RETURN_NONE; |  | 70190 | Py_RETURN_NONE;
| 70239 | } |  | 70191 | }
| 70240 |  |  | 70192 |
| 70241 | return NULL; |  | 70193 | return NULL;
| 70242 | } |  | 70194 | }
| 70243 |  |  | 70195 |
| 70244 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealFinalT(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70196 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealFinalT(PyObject* self, PyObject* py_args, PyObject* kw)
| 70245 | { |  | 70197 | {
| 70246 | using namespace cv::ml; |  | 70198 | using namespace cv::ml;
| 70247 |  |  | 70199 |
| 70248 |  |  | 70200 |
| 70249 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70201 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70250 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70202 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70251 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70203 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70252 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70204 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70253 | PyObject* pyobj_val = NULL; |  | 70205 | PyObject* pyobj_val = NULL;
| 70254 | double val=0; |  | 70206 | double val=0;
| 70255 |  |  | 70207 |
| 70256 | const char* keywords[] = { "val", NULL }; |  | 70208 | const char* keywords[] = { "val", NULL };
| 70257 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealFinalT", (char**)keywords, &pyobj_val) && |  | 70209 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealFinalT", (char**)keywords, &pyobj_val) &&
| 70258 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70210 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70259 | { |  | 70211 | {
| 70260 | ERRWRAP2(_self_->setAnnealFinalT(val)); |  | 70212 | ERRWRAP2(_self_->setAnnealFinalT(val));
| 70261 | Py_RETURN_NONE; |  | 70213 | Py_RETURN_NONE;
| 70262 | } |  | 70214 | }
| 70263 |  |  | 70215 |
| 70264 | return NULL; |  | 70216 | return NULL;
| 70265 | } |  | 70217 | }
| 70266 |  |  | 70218 |
| 70267 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealInitialT(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70219 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealInitialT(PyObject* self, PyObject* py_args, PyObject* kw)
| 70268 | { |  | 70220 | {
| 70269 | using namespace cv::ml; |  | 70221 | using namespace cv::ml;
| 70270 |  |  | 70222 |
| 70271 |  |  | 70223 |
| 70272 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70224 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70273 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70225 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70274 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70226 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70275 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70227 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70276 | PyObject* pyobj_val = NULL; |  | 70228 | PyObject* pyobj_val = NULL;
| 70277 | double val=0; |  | 70229 | double val=0;
| 70278 |  |  | 70230 |
| 70279 | const char* keywords[] = { "val", NULL }; |  | 70231 | const char* keywords[] = { "val", NULL };
| 70280 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealInitialT", (char**)keywords, &pyobj_val) && |  | 70232 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealInitialT", (char**)keywords, &pyobj_val) &&
| 70281 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70233 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70282 | { |  | 70234 | {
| 70283 | ERRWRAP2(_self_->setAnnealInitialT(val)); |  | 70235 | ERRWRAP2(_self_->setAnnealInitialT(val));
| 70284 | Py_RETURN_NONE; |  | 70236 | Py_RETURN_NONE;
| 70285 | } |  | 70237 | }
| 70286 |  |  | 70238 |
| 70287 | return NULL; |  | 70239 | return NULL;
| 70288 | } |  | 70240 | }
| 70289 |  |  | 70241 |
| 70290 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealItePerStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70242 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setAnnealItePerStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 70291 | { |  | 70243 | {
| 70292 | using namespace cv::ml; |  | 70244 | using namespace cv::ml;
| 70293 |  |  | 70245 |
| 70294 |  |  | 70246 |
| 70295 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70247 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70296 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70248 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70297 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70249 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70298 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70250 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70299 | PyObject* pyobj_val = NULL; |  | 70251 | PyObject* pyobj_val = NULL;
| 70300 | int val=0; |  | 70252 | int val=0;
| 70301 |  |  | 70253 |
| 70302 | const char* keywords[] = { "val", NULL }; |  | 70254 | const char* keywords[] = { "val", NULL };
| 70303 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealItePerStep", (char**)keywords, &pyobj_val) && |  | 70255 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setAnnealItePerStep", (char**)keywords, &pyobj_val) &&
| 70304 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70256 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70305 | { |  | 70257 | {
| 70306 | ERRWRAP2(_self_->setAnnealItePerStep(val)); |  | 70258 | ERRWRAP2(_self_->setAnnealItePerStep(val));
| 70307 | Py_RETURN_NONE; |  | 70259 | Py_RETURN_NONE;
| 70308 | } |  | 70260 | }
| 70309 |  |  | 70261 |
| 70310 | return NULL; |  | 70262 | return NULL;
| 70311 | } |  | 70263 | }
| 70312 |  |  | 70264 |
| 70313 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setBackpropMomentumScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70265 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setBackpropMomentumScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 70314 | { |  | 70266 | {
| 70315 | using namespace cv::ml; |  | 70267 | using namespace cv::ml;
| 70316 |  |  | 70268 |
| 70317 |  |  | 70269 |
| 70318 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70270 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70319 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70271 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70320 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70272 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70321 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70273 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70322 | PyObject* pyobj_val = NULL; |  | 70274 | PyObject* pyobj_val = NULL;
| 70323 | double val=0; |  | 70275 | double val=0;
| 70324 |  |  | 70276 |
| 70325 | const char* keywords[] = { "val", NULL }; |  | 70277 | const char* keywords[] = { "val", NULL };
| 70326 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setBackpropMomentumScale", (char**)keywords, &pyobj_val) && |  | 70278 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setBackpropMomentumScale", (char**)keywords, &pyobj_val) &&
| 70327 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70279 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70328 | { |  | 70280 | {
| 70329 | ERRWRAP2(_self_->setBackpropMomentumScale(val)); |  | 70281 | ERRWRAP2(_self_->setBackpropMomentumScale(val));
| 70330 | Py_RETURN_NONE; |  | 70282 | Py_RETURN_NONE;
| 70331 | } |  | 70283 | }
| 70332 |  |  | 70284 |
| 70333 | return NULL; |  | 70285 | return NULL;
| 70334 | } |  | 70286 | }
| 70335 |  |  | 70287 |
| 70336 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setBackpropWeightScale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70288 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setBackpropWeightScale(PyObject* self, PyObject* py_args, PyObject* kw)
| 70337 | { |  | 70289 | {
| 70338 | using namespace cv::ml; |  | 70290 | using namespace cv::ml;
| 70339 |  |  | 70291 |
| 70340 |  |  | 70292 |
| 70341 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70293 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70342 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70294 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70343 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70295 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70344 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70296 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70345 | PyObject* pyobj_val = NULL; |  | 70297 | PyObject* pyobj_val = NULL;
| 70346 | double val=0; |  | 70298 | double val=0;
| 70347 |  |  | 70299 |
| 70348 | const char* keywords[] = { "val", NULL }; |  | 70300 | const char* keywords[] = { "val", NULL };
| 70349 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setBackpropWeightScale", (char**)keywords, &pyobj_val) && |  | 70301 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setBackpropWeightScale", (char**)keywords, &pyobj_val) &&
| 70350 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70302 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70351 | { |  | 70303 | {
| 70352 | ERRWRAP2(_self_->setBackpropWeightScale(val)); |  | 70304 | ERRWRAP2(_self_->setBackpropWeightScale(val));
| 70353 | Py_RETURN_NONE; |  | 70305 | Py_RETURN_NONE;
| 70354 | } |  | 70306 | }
| 70355 |  |  | 70307 |
| 70356 | return NULL; |  | 70308 | return NULL;
| 70357 | } |  | 70309 | }
| 70358 |  |  | 70310 |
| 70359 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setLayerSizes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70311 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setLayerSizes(PyObject* self, PyObject* py_args, PyObject* kw)
| 70360 | { |  | 70312 | {
| 70361 | using namespace cv::ml; |  | 70313 | using namespace cv::ml;
| 70362 |  |  | 70314 |
| 70363 |  |  | 70315 |
| 70364 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70316 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70365 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70317 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70366 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70318 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70367 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70319 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70368 | pyPrepareArgumentConversionErrorsStorage(2); |  | 70320 | pyPrepareArgumentConversionErrorsStorage(2);
| 70369 |  |  | 70321 |
| 70370 | { |  | 70322 | {
| 70371 | PyObject* pyobj__layer_sizes = NULL; |  | 70323 | PyObject* pyobj__layer_sizes = NULL;
| 70372 | Mat _layer_sizes; |  | 70324 | Mat _layer_sizes;
| 70373 |  |  | 70325 |
| 70374 | const char* keywords[] = { "_layer_sizes", NULL }; |  | 70326 | const char* keywords[] = { "_layer_sizes", NULL };
| 70375 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setLayerSizes", (char**)keywords, &pyobj__layer_sizes) && |  | 70327 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setLayerSizes", (char**)keywords, &pyobj__layer_sizes) &&
| 70376 | pyopencv_to_safe(pyobj__layer_sizes, _layer_sizes, ArgInfo("_layer_sizes", 0)) ) |  | 70328 | pyopencv_to_safe(pyobj__layer_sizes, _layer_sizes, ArgInfo("_layer_sizes", 0)) )
| 70377 | { |  | 70329 | {
| 70378 | ERRWRAP2(_self_->setLayerSizes(_layer_sizes)); |  | 70330 | ERRWRAP2(_self_->setLayerSizes(_layer_sizes));
| 70379 | Py_RETURN_NONE; |  | 70331 | Py_RETURN_NONE;
| 70380 | } |  | 70332 | }
| 70381 |  |  | 70333 |
| 70382 |  |  | 70334 |
| 70383 | pyPopulateArgumentConversionErrors(); |  | 70335 | pyPopulateArgumentConversionErrors();
| 70384 | } |  | 70336 | }
| 70385 |  |  | 70337 |
| 70386 |  |  | 70338 |
| 70387 | { |  | 70339 | {
| 70388 | PyObject* pyobj__layer_sizes = NULL; |  | 70340 | PyObject* pyobj__layer_sizes = NULL;
| 70389 | UMat _layer_sizes; |  | 70341 | UMat _layer_sizes;
| 70390 |  |  | 70342 |
| 70391 | const char* keywords[] = { "_layer_sizes", NULL }; |  | 70343 | const char* keywords[] = { "_layer_sizes", NULL };
| 70392 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setLayerSizes", (char**)keywords, &pyobj__layer_sizes) && |  | 70344 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setLayerSizes", (char**)keywords, &pyobj__layer_sizes) &&
| 70393 | pyopencv_to_safe(pyobj__layer_sizes, _layer_sizes, ArgInfo("_layer_sizes", 0)) ) |  | 70345 | pyopencv_to_safe(pyobj__layer_sizes, _layer_sizes, ArgInfo("_layer_sizes", 0)) )
| 70394 | { |  | 70346 | {
| 70395 | ERRWRAP2(_self_->setLayerSizes(_layer_sizes)); |  | 70347 | ERRWRAP2(_self_->setLayerSizes(_layer_sizes));
| 70396 | Py_RETURN_NONE; |  | 70348 | Py_RETURN_NONE;
| 70397 | } |  | 70349 | }
| 70398 |  |  | 70350 |
| 70399 |  |  | 70351 |
| 70400 | pyPopulateArgumentConversionErrors(); |  | 70352 | pyPopulateArgumentConversionErrors();
| 70401 | } |  | 70353 | }
| 70402 | pyRaiseCVOverloadException("setLayerSizes"); |  | 70354 | pyRaiseCVOverloadException("setLayerSizes");
| 70403 |  |  | 70355 |
| 70404 | return NULL; |  | 70356 | return NULL;
| 70405 | } |  | 70357 | }
| 70406 |  |  | 70358 |
| 70407 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDW0(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70359 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDW0(PyObject* self, PyObject* py_args, PyObject* kw)
| 70408 | { |  | 70360 | {
| 70409 | using namespace cv::ml; |  | 70361 | using namespace cv::ml;
| 70410 |  |  | 70362 |
| 70411 |  |  | 70363 |
| 70412 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70364 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70413 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70365 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70414 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70366 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70415 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70367 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70416 | PyObject* pyobj_val = NULL; |  | 70368 | PyObject* pyobj_val = NULL;
| 70417 | double val=0; |  | 70369 | double val=0;
| 70418 |  |  | 70370 |
| 70419 | const char* keywords[] = { "val", NULL }; |  | 70371 | const char* keywords[] = { "val", NULL };
| 70420 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDW0", (char**)keywords, &pyobj_val) && |  | 70372 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDW0", (char**)keywords, &pyobj_val) &&
| 70421 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70373 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70422 | { |  | 70374 | {
| 70423 | ERRWRAP2(_self_->setRpropDW0(val)); |  | 70375 | ERRWRAP2(_self_->setRpropDW0(val));
| 70424 | Py_RETURN_NONE; |  | 70376 | Py_RETURN_NONE;
| 70425 | } |  | 70377 | }
| 70426 |  |  | 70378 |
| 70427 | return NULL; |  | 70379 | return NULL;
| 70428 | } |  | 70380 | }
| 70429 |  |  | 70381 |
| 70430 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMax(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70382 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMax(PyObject* self, PyObject* py_args, PyObject* kw)
| 70431 | { |  | 70383 | {
| 70432 | using namespace cv::ml; |  | 70384 | using namespace cv::ml;
| 70433 |  |  | 70385 |
| 70434 |  |  | 70386 |
| 70435 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70387 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70436 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70388 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70437 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70389 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70438 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70390 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70439 | PyObject* pyobj_val = NULL; |  | 70391 | PyObject* pyobj_val = NULL;
| 70440 | double val=0; |  | 70392 | double val=0;
| 70441 |  |  | 70393 |
| 70442 | const char* keywords[] = { "val", NULL }; |  | 70394 | const char* keywords[] = { "val", NULL };
| 70443 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWMax", (char**)keywords, &pyobj_val) && |  | 70395 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWMax", (char**)keywords, &pyobj_val) &&
| 70444 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70396 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70445 | { |  | 70397 | {
| 70446 | ERRWRAP2(_self_->setRpropDWMax(val)); |  | 70398 | ERRWRAP2(_self_->setRpropDWMax(val));
| 70447 | Py_RETURN_NONE; |  | 70399 | Py_RETURN_NONE;
| 70448 | } |  | 70400 | }
| 70449 |  |  | 70401 |
| 70450 | return NULL; |  | 70402 | return NULL;
| 70451 | } |  | 70403 | }
| 70452 |  |  | 70404 |
| 70453 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMin(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70405 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMin(PyObject* self, PyObject* py_args, PyObject* kw)
| 70454 | { |  | 70406 | {
| 70455 | using namespace cv::ml; |  | 70407 | using namespace cv::ml;
| 70456 |  |  | 70408 |
| 70457 |  |  | 70409 |
| 70458 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70410 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70459 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70411 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70460 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70412 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70461 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70413 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70462 | PyObject* pyobj_val = NULL; |  | 70414 | PyObject* pyobj_val = NULL;
| 70463 | double val=0; |  | 70415 | double val=0;
| 70464 |  |  | 70416 |
| 70465 | const char* keywords[] = { "val", NULL }; |  | 70417 | const char* keywords[] = { "val", NULL };
| 70466 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWMin", (char**)keywords, &pyobj_val) && |  | 70418 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWMin", (char**)keywords, &pyobj_val) &&
| 70467 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70419 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70468 | { |  | 70420 | {
| 70469 | ERRWRAP2(_self_->setRpropDWMin(val)); |  | 70421 | ERRWRAP2(_self_->setRpropDWMin(val));
| 70470 | Py_RETURN_NONE; |  | 70422 | Py_RETURN_NONE;
| 70471 | } |  | 70423 | }
| 70472 |  |  | 70424 |
| 70473 | return NULL; |  | 70425 | return NULL;
| 70474 | } |  | 70426 | }
| 70475 |  |  | 70427 |
| 70476 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMinus(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70428 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMinus(PyObject* self, PyObject* py_args, PyObject* kw)
| 70477 | { |  | 70429 | {
| 70478 | using namespace cv::ml; |  | 70430 | using namespace cv::ml;
| 70479 |  |  | 70431 |
| 70480 |  |  | 70432 |
| 70481 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70433 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70482 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70434 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70483 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70435 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70484 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70436 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70485 | PyObject* pyobj_val = NULL; |  | 70437 | PyObject* pyobj_val = NULL;
| 70486 | double val=0; |  | 70438 | double val=0;
| 70487 |  |  | 70439 |
| 70488 | const char* keywords[] = { "val", NULL }; |  | 70440 | const char* keywords[] = { "val", NULL };
| 70489 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWMinus", (char**)keywords, &pyobj_val) && |  | 70441 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWMinus", (char**)keywords, &pyobj_val) &&
| 70490 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70442 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70491 | { |  | 70443 | {
| 70492 | ERRWRAP2(_self_->setRpropDWMinus(val)); |  | 70444 | ERRWRAP2(_self_->setRpropDWMinus(val));
| 70493 | Py_RETURN_NONE; |  | 70445 | Py_RETURN_NONE;
| 70494 | } |  | 70446 | }
| 70495 |  |  | 70447 |
| 70496 | return NULL; |  | 70448 | return NULL;
| 70497 | } |  | 70449 | }
| 70498 |  |  | 70450 |
| 70499 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWPlus(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70451 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setRpropDWPlus(PyObject* self, PyObject* py_args, PyObject* kw)
| 70500 | { |  | 70452 | {
| 70501 | using namespace cv::ml; |  | 70453 | using namespace cv::ml;
| 70502 |  |  | 70454 |
| 70503 |  |  | 70455 |
| 70504 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70456 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70505 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70457 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70506 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70458 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70507 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70459 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70508 | PyObject* pyobj_val = NULL; |  | 70460 | PyObject* pyobj_val = NULL;
| 70509 | double val=0; |  | 70461 | double val=0;
| 70510 |  |  | 70462 |
| 70511 | const char* keywords[] = { "val", NULL }; |  | 70463 | const char* keywords[] = { "val", NULL };
| 70512 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWPlus", (char**)keywords, &pyobj_val) && |  | 70464 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setRpropDWPlus", (char**)keywords, &pyobj_val) &&
| 70513 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70465 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70514 | { |  | 70466 | {
| 70515 | ERRWRAP2(_self_->setRpropDWPlus(val)); |  | 70467 | ERRWRAP2(_self_->setRpropDWPlus(val));
| 70516 | Py_RETURN_NONE; |  | 70468 | Py_RETURN_NONE;
| 70517 | } |  | 70469 | }
| 70518 |  |  | 70470 |
| 70519 | return NULL; |  | 70471 | return NULL;
| 70520 | } |  | 70472 | }
| 70521 |  |  | 70473 |
| 70522 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70474 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 70523 | { |  | 70475 | {
| 70524 | using namespace cv::ml; |  | 70476 | using namespace cv::ml;
| 70525 |  |  | 70477 |
| 70526 |  |  | 70478 |
| 70527 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70479 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70528 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70480 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70529 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70481 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70530 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70482 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70531 | PyObject* pyobj_val = NULL; |  | 70483 | PyObject* pyobj_val = NULL;
| 70532 | TermCriteria val; |  | 70484 | TermCriteria val;
| 70533 |  |  | 70485 |
| 70534 | const char* keywords[] = { "val", NULL }; |  | 70486 | const char* keywords[] = { "val", NULL };
| 70535 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setTermCriteria", (char**)keywords, &pyobj_val) && |  | 70487 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_ANN_MLP.setTermCriteria", (char**)keywords, &pyobj_val) &&
| 70536 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70488 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70537 | { |  | 70489 | {
| 70538 | ERRWRAP2(_self_->setTermCriteria(val)); |  | 70490 | ERRWRAP2(_self_->setTermCriteria(val));
| 70539 | Py_RETURN_NONE; |  | 70491 | Py_RETURN_NONE;
| 70540 | } |  | 70492 | }
| 70541 |  |  | 70493 |
| 70542 | return NULL; |  | 70494 | return NULL;
| 70543 | } |  | 70495 | }
| 70544 |  |  | 70496 |
| 70545 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70497 | static PyObject* pyopencv_cv_ml_ml_ANN_MLP_setTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 70546 | { |  | 70498 | {
| 70547 | using namespace cv::ml; |  | 70499 | using namespace cv::ml;
| 70548 |  |  | 70500 |
| 70549 |  |  | 70501 |
| 70550 | Ptr<cv::ml::ANN_MLP> * self1 = 0; |  | 70502 | Ptr<cv::ml::ANN_MLP> * self1 = 0;
| 70551 | if (!pyopencv_ml_ANN_MLP_getp(self, self1)) |  | 70503 | if (!pyopencv_ml_ANN_MLP_getp(self, self1))
| 70552 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)"); |  | 70504 | return failmsgp("Incorrect type of self (must be 'ml_ANN_MLP' or its derivative)");
| 70553 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1); |  | 70505 | Ptr<cv::ml::ANN_MLP> _self_ = *(self1);
| 70554 | PyObject* pyobj_method = NULL; |  | 70506 | PyObject* pyobj_method = NULL;
| 70555 | int method=0; |  | 70507 | int method=0;
| 70556 | PyObject* pyobj_param1 = NULL; |  | 70508 | PyObject* pyobj_param1 = NULL;
| 70557 | double param1=0; |  | 70509 | double param1=0;
| 70558 | PyObject* pyobj_param2 = NULL; |  | 70510 | PyObject* pyobj_param2 = NULL;
| 70559 | double param2=0; |  | 70511 | double param2=0;
| 70560 |  |  | 70512 |
| 70561 | const char* keywords[] = { "method", "param1", "param2", NULL }; |  | 70513 | const char* keywords[] = { "method", "param1", "param2", NULL };
| 70562 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_ANN_MLP.setTrainMethod", (char**)keywords, &pyobj_method, &pyobj_param1, &pyobj_param2) && |  | 70514 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_ANN_MLP.setTrainMethod", (char**)keywords, &pyobj_method, &pyobj_param1, &pyobj_param2) &&
| 70563 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) && |  | 70515 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) &&
| 70564 | pyopencv_to_safe(pyobj_param1, param1, ArgInfo("param1", 0)) && |  | 70516 | pyopencv_to_safe(pyobj_param1, param1, ArgInfo("param1", 0)) &&
| 70565 | pyopencv_to_safe(pyobj_param2, param2, ArgInfo("param2", 0)) ) |  | 70517 | pyopencv_to_safe(pyobj_param2, param2, ArgInfo("param2", 0)) )
| 70566 | { |  | 70518 | {
| 70567 | ERRWRAP2(_self_->setTrainMethod(method, param1, param2)); |  | 70519 | ERRWRAP2(_self_->setTrainMethod(method, param1, param2));
| 70568 | Py_RETURN_NONE; |  | 70520 | Py_RETURN_NONE;
| 70569 | } |  | 70521 | }
| 70570 |  |  | 70522 |
| 70571 | return NULL; |  | 70523 | return NULL;
| 70572 | } |  | 70524 | }
| 70573 |  |  | 70525 |
| 70574 |  |  | 70526 |
| 70575 |  |  | 70527 |
| 70576 | // Tables (ml_ANN_MLP) |  | 70528 | // Tables (ml_ANN_MLP)
| 70577 |  |  | 70529 |
| 70578 | static PyGetSetDef pyopencv_ml_ANN_MLP_getseters[] = |  | 70530 | static PyGetSetDef pyopencv_ml_ANN_MLP_getseters[] =
| 70579 | { |  | 70531 | {
| 70580 | {NULL} /* Sentinel */ |  | 70532 | {NULL} /* Sentinel */
| 70581 | }; |  | 70533 | };
| 70582 |  |  | 70534 |
| 70583 | static PyMethodDef pyopencv_ml_ANN_MLP_methods[] = |  | 70535 | static PyMethodDef pyopencv_ml_ANN_MLP_methods[] =
| 70584 | { |  | 70536 | {
| 70585 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_create_static, METH_STATIC), "create() -> retval\n. @brief Creates empty model\n. \n. Use StatModel::train to train the model, Algorithm::load\\<ANN_MLP\\>(filename) to load the pre-trained model.\n. Note that the train method has optional flags: ANN_MLP::TrainFlags."}, |  | 70537 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_create_static, METH_STATIC), "create() -> retval\n. @brief Creates empty model\n. \n. Use StatModel::train to train the model, Algorithm::load\\<ANN_MLP\\>(filename) to load the pre-trained model.\n. Note that the train method has optional flags: ANN_MLP::TrainFlags."},
| 70586 | {"getAnnealCoolingRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealCoolingRatio, 0), "getAnnealCoolingRatio() -> retval\n. @see setAnnealCoolingRatio"}, |  | 70538 | {"getAnnealCoolingRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealCoolingRatio, 0), "getAnnealCoolingRatio() -> retval\n. @see setAnnealCoolingRatio"},
| 70587 | {"getAnnealFinalT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealFinalT, 0), "getAnnealFinalT() -> retval\n. @see setAnnealFinalT"}, |  | 70539 | {"getAnnealFinalT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealFinalT, 0), "getAnnealFinalT() -> retval\n. @see setAnnealFinalT"},
| 70588 | {"getAnnealInitialT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealInitialT, 0), "getAnnealInitialT() -> retval\n. @see setAnnealInitialT"}, |  | 70540 | {"getAnnealInitialT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealInitialT, 0), "getAnnealInitialT() -> retval\n. @see setAnnealInitialT"},
| 70589 | {"getAnnealItePerStep", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealItePerStep, 0), "getAnnealItePerStep() -> retval\n. @see setAnnealItePerStep"}, |  | 70541 | {"getAnnealItePerStep", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getAnnealItePerStep, 0), "getAnnealItePerStep() -> retval\n. @see setAnnealItePerStep"},
| 70590 | {"getBackpropMomentumScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getBackpropMomentumScale, 0), "getBackpropMomentumScale() -> retval\n. @see setBackpropMomentumScale"}, |  | 70542 | {"getBackpropMomentumScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getBackpropMomentumScale, 0), "getBackpropMomentumScale() -> retval\n. @see setBackpropMomentumScale"},
| 70591 | {"getBackpropWeightScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getBackpropWeightScale, 0), "getBackpropWeightScale() -> retval\n. @see setBackpropWeightScale"}, |  | 70543 | {"getBackpropWeightScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getBackpropWeightScale, 0), "getBackpropWeightScale() -> retval\n. @see setBackpropWeightScale"},
| 70592 | {"getLayerSizes", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getLayerSizes, 0), "getLayerSizes() -> retval\n. Integer vector specifying the number of neurons in each layer including the input and output layers.\n. The very first element specifies the number of elements in the input layer.\n. The last element - number of elements in the output layer.\n. @sa setLayerSizes"}, |  | 70544 | {"getLayerSizes", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getLayerSizes, 0), "getLayerSizes() -> retval\n. Integer vector specifying the number of neurons in each layer including the input and output layers.\n. The very first element specifies the number of elements in the input layer.\n. The last element - number of elements in the output layer.\n. @sa setLayerSizes"},
| 70593 | {"getRpropDW0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDW0, 0), "getRpropDW0() -> retval\n. @see setRpropDW0"}, |  | 70545 | {"getRpropDW0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDW0, 0), "getRpropDW0() -> retval\n. @see setRpropDW0"},
| 70594 | {"getRpropDWMax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMax, 0), "getRpropDWMax() -> retval\n. @see setRpropDWMax"}, |  | 70546 | {"getRpropDWMax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMax, 0), "getRpropDWMax() -> retval\n. @see setRpropDWMax"},
| 70595 | {"getRpropDWMin", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMin, 0), "getRpropDWMin() -> retval\n. @see setRpropDWMin"}, |  | 70547 | {"getRpropDWMin", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMin, 0), "getRpropDWMin() -> retval\n. @see setRpropDWMin"},
| 70596 | {"getRpropDWMinus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMinus, 0), "getRpropDWMinus() -> retval\n. @see setRpropDWMinus"}, |  | 70548 | {"getRpropDWMinus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWMinus, 0), "getRpropDWMinus() -> retval\n. @see setRpropDWMinus"},
| 70597 | {"getRpropDWPlus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWPlus, 0), "getRpropDWPlus() -> retval\n. @see setRpropDWPlus"}, |  | 70549 | {"getRpropDWPlus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getRpropDWPlus, 0), "getRpropDWPlus() -> retval\n. @see setRpropDWPlus"},
| 70598 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"}, |  | 70550 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"},
| 70599 | {"getTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getTrainMethod, 0), "getTrainMethod() -> retval\n. Returns current training method"}, |  | 70551 | {"getTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getTrainMethod, 0), "getTrainMethod() -> retval\n. Returns current training method"},
| 70600 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getWeights, 0), "getWeights(layerIdx) -> retval\n."}, |  | 70552 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_getWeights, 0), "getWeights(layerIdx) -> retval\n."},
| 70601 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_load_static, METH_STATIC), "load(filepath) -> retval\n. @brief Loads and creates a serialized ANN from a file\n. *\n. * Use ANN::save to serialize and store an ANN to disk.\n. * Load the ANN from this file again, by calling this function with the path to the file.\n. *\n. * @param filepath path to serialized ANN"}, |  | 70553 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_load_static, METH_STATIC), "load(filepath) -> retval\n. @brief Loads and creates a serialized ANN from a file\n. *\n. * Use ANN::save to serialize and store an ANN to disk.\n. * Load the ANN from this file again, by calling this function with the path to the file.\n. *\n. * @param filepath path to serialized ANN"},
| 70602 | {"setActivationFunction", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setActivationFunction, 0), "setActivationFunction(type[, param1[, param2]]) -> None\n. Initialize the activation function for each neuron.\n. Currently the default and the only fully supported activation function is ANN_MLP::SIGMOID_SYM.\n. @param type The type of activation function. See ANN_MLP::ActivationFunctions.\n. @param param1 The first parameter of the activation function, \\f$\\alpha\\f$. Default value is 0.\n. @param param2 The second parameter of the activation function, \\f$\\beta\\f$. Default value is 0."}, |  | 70554 | {"setActivationFunction", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setActivationFunction, 0), "setActivationFunction(type[, param1[, param2]]) -> None\n. Initialize the activation function for each neuron.\n. Currently the default and the only fully supported activation function is ANN_MLP::SIGMOID_SYM.\n. @param type The type of activation function. See ANN_MLP::ActivationFunctions.\n. @param param1 The first parameter of the activation function, \\f$\\alpha\\f$. Default value is 0.\n. @param param2 The second parameter of the activation function, \\f$\\beta\\f$. Default value is 0."},
| 70603 | {"setAnnealCoolingRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealCoolingRatio, 0), "setAnnealCoolingRatio(val) -> None\n. @copybrief getAnnealCoolingRatio @see getAnnealCoolingRatio"}, |  | 70555 | {"setAnnealCoolingRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealCoolingRatio, 0), "setAnnealCoolingRatio(val) -> None\n. @copybrief getAnnealCoolingRatio @see getAnnealCoolingRatio"},
| 70604 | {"setAnnealFinalT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealFinalT, 0), "setAnnealFinalT(val) -> None\n. @copybrief getAnnealFinalT @see getAnnealFinalT"}, |  | 70556 | {"setAnnealFinalT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealFinalT, 0), "setAnnealFinalT(val) -> None\n. @copybrief getAnnealFinalT @see getAnnealFinalT"},
| 70605 | {"setAnnealInitialT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealInitialT, 0), "setAnnealInitialT(val) -> None\n. @copybrief getAnnealInitialT @see getAnnealInitialT"}, |  | 70557 | {"setAnnealInitialT", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealInitialT, 0), "setAnnealInitialT(val) -> None\n. @copybrief getAnnealInitialT @see getAnnealInitialT"},
| 70606 | {"setAnnealItePerStep", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealItePerStep, 0), "setAnnealItePerStep(val) -> None\n. @copybrief getAnnealItePerStep @see getAnnealItePerStep"}, |  | 70558 | {"setAnnealItePerStep", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setAnnealItePerStep, 0), "setAnnealItePerStep(val) -> None\n. @copybrief getAnnealItePerStep @see getAnnealItePerStep"},
| 70607 | {"setBackpropMomentumScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setBackpropMomentumScale, 0), "setBackpropMomentumScale(val) -> None\n. @copybrief getBackpropMomentumScale @see getBackpropMomentumScale"}, |  | 70559 | {"setBackpropMomentumScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setBackpropMomentumScale, 0), "setBackpropMomentumScale(val) -> None\n. @copybrief getBackpropMomentumScale @see getBackpropMomentumScale"},
| 70608 | {"setBackpropWeightScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setBackpropWeightScale, 0), "setBackpropWeightScale(val) -> None\n. @copybrief getBackpropWeightScale @see getBackpropWeightScale"}, |  | 70560 | {"setBackpropWeightScale", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setBackpropWeightScale, 0), "setBackpropWeightScale(val) -> None\n. @copybrief getBackpropWeightScale @see getBackpropWeightScale"},
| 70609 | {"setLayerSizes", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setLayerSizes, 0), "setLayerSizes(_layer_sizes) -> None\n. Integer vector specifying the number of neurons in each layer including the input and output layers.\n. The very first element specifies the number of elements in the input layer.\n. The last element - number of elements in the output layer. Default value is empty Mat.\n. @sa getLayerSizes"}, |  | 70561 | {"setLayerSizes", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setLayerSizes, 0), "setLayerSizes(_layer_sizes) -> None\n. Integer vector specifying the number of neurons in each layer including the input and output layers.\n. The very first element specifies the number of elements in the input layer.\n. The last element - number of elements in the output layer. Default value is empty Mat.\n. @sa getLayerSizes"},
| 70610 | {"setRpropDW0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDW0, 0), "setRpropDW0(val) -> None\n. @copybrief getRpropDW0 @see getRpropDW0"}, |  | 70562 | {"setRpropDW0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDW0, 0), "setRpropDW0(val) -> None\n. @copybrief getRpropDW0 @see getRpropDW0"},
| 70611 | {"setRpropDWMax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMax, 0), "setRpropDWMax(val) -> None\n. @copybrief getRpropDWMax @see getRpropDWMax"}, |  | 70563 | {"setRpropDWMax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMax, 0), "setRpropDWMax(val) -> None\n. @copybrief getRpropDWMax @see getRpropDWMax"},
| 70612 | {"setRpropDWMin", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMin, 0), "setRpropDWMin(val) -> None\n. @copybrief getRpropDWMin @see getRpropDWMin"}, |  | 70564 | {"setRpropDWMin", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMin, 0), "setRpropDWMin(val) -> None\n. @copybrief getRpropDWMin @see getRpropDWMin"},
| 70613 | {"setRpropDWMinus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMinus, 0), "setRpropDWMinus(val) -> None\n. @copybrief getRpropDWMinus @see getRpropDWMinus"}, |  | 70565 | {"setRpropDWMinus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWMinus, 0), "setRpropDWMinus(val) -> None\n. @copybrief getRpropDWMinus @see getRpropDWMinus"},
| 70614 | {"setRpropDWPlus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWPlus, 0), "setRpropDWPlus(val) -> None\n. @copybrief getRpropDWPlus @see getRpropDWPlus"}, |  | 70566 | {"setRpropDWPlus", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setRpropDWPlus, 0), "setRpropDWPlus(val) -> None\n. @copybrief getRpropDWPlus @see getRpropDWPlus"},
| 70615 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"}, |  | 70567 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"},
| 70616 | {"setTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setTrainMethod, 0), "setTrainMethod(method[, param1[, param2]]) -> None\n. Sets training method and common parameters.\n. @param method Default value is ANN_MLP::RPROP. See ANN_MLP::TrainingMethods.\n. @param param1 passed to setRpropDW0 for ANN_MLP::RPROP and to setBackpropWeightScale for ANN_MLP::BACKPROP and to initialT for ANN_MLP::ANNEAL.\n. @param param2 passed to setRpropDWMin for ANN_MLP::RPROP and to setBackpropMomentumScale for ANN_MLP::BACKPROP and to finalT for ANN_MLP::ANNEAL."}, |  | 70568 | {"setTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ANN_MLP_setTrainMethod, 0), "setTrainMethod(method[, param1[, param2]]) -> None\n. Sets training method and common parameters.\n. @param method Default value is ANN_MLP::RPROP. See ANN_MLP::TrainingMethods.\n. @param param1 passed to setRpropDW0 for ANN_MLP::RPROP and to setBackpropWeightScale for ANN_MLP::BACKPROP and to initialT for ANN_MLP::ANNEAL.\n. @param param2 passed to setRpropDWMin for ANN_MLP::RPROP and to setBackpropMomentumScale for ANN_MLP::BACKPROP and to finalT for ANN_MLP::ANNEAL."},
| 70617 |  |  | 70569 |
| 70618 | {NULL, NULL} |  | 70570 | {NULL, NULL}
| 70619 | }; |  | 70571 | };
| 70620 |  |  | 70572 |
| 70621 | // Converter (ml_ANN_MLP) |  | 70573 | // Converter (ml_ANN_MLP)
| 70622 |  |  | 70574 |
| 70623 | template<> |  | 70575 | template<>
| 70624 | struct PyOpenCV_Converter< Ptr<cv::ml::ANN_MLP> > |  | 70576 | struct PyOpenCV_Converter< Ptr<cv::ml::ANN_MLP> >
| 70625 | { |  | 70577 | {
| 70626 | static PyObject* from(const Ptr<cv::ml::ANN_MLP>& r) |  | 70578 | static PyObject* from(const Ptr<cv::ml::ANN_MLP>& r)
| 70627 | { |  | 70579 | {
| 70628 | return pyopencv_ml_ANN_MLP_Instance(r); |  | 70580 | return pyopencv_ml_ANN_MLP_Instance(r);
| 70629 | } |  | 70581 | }
| 70630 | static bool to(PyObject* src, Ptr<cv::ml::ANN_MLP>& dst, const ArgInfo& info) |  | 70582 | static bool to(PyObject* src, Ptr<cv::ml::ANN_MLP>& dst, const ArgInfo& info)
| 70631 | { |  | 70583 | {
| 70632 | if(!src || src == Py_None) |  | 70584 | if(!src || src == Py_None)
| 70633 | return true; |  | 70585 | return true;
| 70634 | Ptr<cv::ml::ANN_MLP> * dst_; |  | 70586 | Ptr<cv::ml::ANN_MLP> * dst_;
| 70635 | if (pyopencv_ml_ANN_MLP_getp(src, dst_)) |  | 70587 | if (pyopencv_ml_ANN_MLP_getp(src, dst_))
| 70636 | { |  | 70588 | {
| 70637 | dst = *dst_; |  | 70589 | dst = *dst_;
| 70638 | return true; |  | 70590 | return true;
| 70639 | } |  | 70591 | }
| 70640 |  |  | 70592 |
| 70641 | failmsg("Expected Ptr<cv::ml::ANN_MLP> for argument '%s'", info.name); |  | 70593 | failmsg("Expected Ptr<cv::ml::ANN_MLP> for argument '%s'", info.name);
| 70642 | return false; |  | 70594 | return false;
| 70643 | } |  | 70595 | }
| 70644 | }; |  | 70596 | };
| 70645 |  |  | 70597 |
| 70646 | //================================================================================ |  | 70598 | //================================================================================
| 70647 | // ml_Boost (Generic) |  | 70599 | // ml_Boost (Generic)
| 70648 | //================================================================================ |  | 70600 | //================================================================================
| 70649 |  |  | 70601 |
| 70650 | // GetSet (ml_Boost) |  | 70602 | // GetSet (ml_Boost)
| 70651 |  |  | 70603 |
| 70652 |  |  | 70604 |
| 70653 |  |  | 70605 |
| 70654 | // Methods (ml_Boost) |  | 70606 | // Methods (ml_Boost)
| 70655 |  |  | 70607 |
| 70656 | static PyObject* pyopencv_cv_ml_ml_Boost_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70608 | static PyObject* pyopencv_cv_ml_ml_Boost_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 70657 | { |  | 70609 | {
| 70658 | using namespace cv::ml; |  | 70610 | using namespace cv::ml;
| 70659 |  |  | 70611 |
| 70660 | Ptr<Boost> retval; |  | 70612 | Ptr<Boost> retval;
| 70661 |  |  | 70613 |
| 70662 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70614 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70663 | { |  | 70615 | {
| 70664 | ERRWRAP2(retval = cv::ml::Boost::create()); |  | 70616 | ERRWRAP2(retval = cv::ml::Boost::create());
| 70665 | return pyopencv_from(retval); |  | 70617 | return pyopencv_from(retval);
| 70666 | } |  | 70618 | }
| 70667 |  |  | 70619 |
| 70668 | return NULL; |  | 70620 | return NULL;
| 70669 | } |  | 70621 | }
| 70670 |  |  | 70622 |
| 70671 | static PyObject* pyopencv_cv_ml_ml_Boost_getBoostType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70623 | static PyObject* pyopencv_cv_ml_ml_Boost_getBoostType(PyObject* self, PyObject* py_args, PyObject* kw)
| 70672 | { |  | 70624 | {
| 70673 | using namespace cv::ml; |  | 70625 | using namespace cv::ml;
| 70674 |  |  | 70626 |
| 70675 |  |  | 70627 |
| 70676 | Ptr<cv::ml::Boost> * self1 = 0; |  | 70628 | Ptr<cv::ml::Boost> * self1 = 0;
| 70677 | if (!pyopencv_ml_Boost_getp(self, self1)) |  | 70629 | if (!pyopencv_ml_Boost_getp(self, self1))
| 70678 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)"); |  | 70630 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)");
| 70679 | Ptr<cv::ml::Boost> _self_ = *(self1); |  | 70631 | Ptr<cv::ml::Boost> _self_ = *(self1);
| 70680 | int retval; |  | 70632 | int retval;
| 70681 |  |  | 70633 |
| 70682 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70634 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70683 | { |  | 70635 | {
| 70684 | ERRWRAP2(retval = _self_->getBoostType()); |  | 70636 | ERRWRAP2(retval = _self_->getBoostType());
| 70685 | return pyopencv_from(retval); |  | 70637 | return pyopencv_from(retval);
| 70686 | } |  | 70638 | }
| 70687 |  |  | 70639 |
| 70688 | return NULL; |  | 70640 | return NULL;
| 70689 | } |  | 70641 | }
| 70690 |  |  | 70642 |
| 70691 | static PyObject* pyopencv_cv_ml_ml_Boost_getWeakCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70643 | static PyObject* pyopencv_cv_ml_ml_Boost_getWeakCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 70692 | { |  | 70644 | {
| 70693 | using namespace cv::ml; |  | 70645 | using namespace cv::ml;
| 70694 |  |  | 70646 |
| 70695 |  |  | 70647 |
| 70696 | Ptr<cv::ml::Boost> * self1 = 0; |  | 70648 | Ptr<cv::ml::Boost> * self1 = 0;
| 70697 | if (!pyopencv_ml_Boost_getp(self, self1)) |  | 70649 | if (!pyopencv_ml_Boost_getp(self, self1))
| 70698 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)"); |  | 70650 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)");
| 70699 | Ptr<cv::ml::Boost> _self_ = *(self1); |  | 70651 | Ptr<cv::ml::Boost> _self_ = *(self1);
| 70700 | int retval; |  | 70652 | int retval;
| 70701 |  |  | 70653 |
| 70702 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70654 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70703 | { |  | 70655 | {
| 70704 | ERRWRAP2(retval = _self_->getWeakCount()); |  | 70656 | ERRWRAP2(retval = _self_->getWeakCount());
| 70705 | return pyopencv_from(retval); |  | 70657 | return pyopencv_from(retval);
| 70706 | } |  | 70658 | }
| 70707 |  |  | 70659 |
| 70708 | return NULL; |  | 70660 | return NULL;
| 70709 | } |  | 70661 | }
| 70710 |  |  | 70662 |
| 70711 | static PyObject* pyopencv_cv_ml_ml_Boost_getWeightTrimRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70663 | static PyObject* pyopencv_cv_ml_ml_Boost_getWeightTrimRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 70712 | { |  | 70664 | {
| 70713 | using namespace cv::ml; |  | 70665 | using namespace cv::ml;
| 70714 |  |  | 70666 |
| 70715 |  |  | 70667 |
| 70716 | Ptr<cv::ml::Boost> * self1 = 0; |  | 70668 | Ptr<cv::ml::Boost> * self1 = 0;
| 70717 | if (!pyopencv_ml_Boost_getp(self, self1)) |  | 70669 | if (!pyopencv_ml_Boost_getp(self, self1))
| 70718 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)"); |  | 70670 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)");
| 70719 | Ptr<cv::ml::Boost> _self_ = *(self1); |  | 70671 | Ptr<cv::ml::Boost> _self_ = *(self1);
| 70720 | double retval; |  | 70672 | double retval;
| 70721 |  |  | 70673 |
| 70722 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70674 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70723 | { |  | 70675 | {
| 70724 | ERRWRAP2(retval = _self_->getWeightTrimRate()); |  | 70676 | ERRWRAP2(retval = _self_->getWeightTrimRate());
| 70725 | return pyopencv_from(retval); |  | 70677 | return pyopencv_from(retval);
| 70726 | } |  | 70678 | }
| 70727 |  |  | 70679 |
| 70728 | return NULL; |  | 70680 | return NULL;
| 70729 | } |  | 70681 | }
| 70730 |  |  | 70682 |
| 70731 | static PyObject* pyopencv_cv_ml_ml_Boost_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70683 | static PyObject* pyopencv_cv_ml_ml_Boost_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 70732 | { |  | 70684 | {
| 70733 | using namespace cv::ml; |  | 70685 | using namespace cv::ml;
| 70734 |  |  | 70686 |
| 70735 | PyObject* pyobj_filepath = NULL; |  | 70687 | PyObject* pyobj_filepath = NULL;
| 70736 | String filepath; |  | 70688 | String filepath;
| 70737 | PyObject* pyobj_nodeName = NULL; |  | 70689 | PyObject* pyobj_nodeName = NULL;
| 70738 | String nodeName; |  | 70690 | String nodeName;
| 70739 | Ptr<Boost> retval; |  | 70691 | Ptr<Boost> retval;
| 70740 |  |  | 70692 |
| 70741 | const char* keywords[] = { "filepath", "nodeName", NULL }; |  | 70693 | const char* keywords[] = { "filepath", "nodeName", NULL };
| 70742 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_Boost.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) && |  | 70694 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_Boost.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) &&
| 70743 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) && |  | 70695 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) &&
| 70744 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) ) |  | 70696 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) )
| 70745 | { |  | 70697 | {
| 70746 | ERRWRAP2(retval = cv::ml::Boost::load(filepath, nodeName)); |  | 70698 | ERRWRAP2(retval = cv::ml::Boost::load(filepath, nodeName));
| 70747 | return pyopencv_from(retval); |  | 70699 | return pyopencv_from(retval);
| 70748 | } |  | 70700 | }
| 70749 |  |  | 70701 |
| 70750 | return NULL; |  | 70702 | return NULL;
| 70751 | } |  | 70703 | }
| 70752 |  |  | 70704 |
| 70753 | static PyObject* pyopencv_cv_ml_ml_Boost_setBoostType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70705 | static PyObject* pyopencv_cv_ml_ml_Boost_setBoostType(PyObject* self, PyObject* py_args, PyObject* kw)
| 70754 | { |  | 70706 | {
| 70755 | using namespace cv::ml; |  | 70707 | using namespace cv::ml;
| 70756 |  |  | 70708 |
| 70757 |  |  | 70709 |
| 70758 | Ptr<cv::ml::Boost> * self1 = 0; |  | 70710 | Ptr<cv::ml::Boost> * self1 = 0;
| 70759 | if (!pyopencv_ml_Boost_getp(self, self1)) |  | 70711 | if (!pyopencv_ml_Boost_getp(self, self1))
| 70760 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)"); |  | 70712 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)");
| 70761 | Ptr<cv::ml::Boost> _self_ = *(self1); |  | 70713 | Ptr<cv::ml::Boost> _self_ = *(self1);
| 70762 | PyObject* pyobj_val = NULL; |  | 70714 | PyObject* pyobj_val = NULL;
| 70763 | int val=0; |  | 70715 | int val=0;
| 70764 |  |  | 70716 |
| 70765 | const char* keywords[] = { "val", NULL }; |  | 70717 | const char* keywords[] = { "val", NULL };
| 70766 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_Boost.setBoostType", (char**)keywords, &pyobj_val) && |  | 70718 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_Boost.setBoostType", (char**)keywords, &pyobj_val) &&
| 70767 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70719 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70768 | { |  | 70720 | {
| 70769 | ERRWRAP2(_self_->setBoostType(val)); |  | 70721 | ERRWRAP2(_self_->setBoostType(val));
| 70770 | Py_RETURN_NONE; |  | 70722 | Py_RETURN_NONE;
| 70771 | } |  | 70723 | }
| 70772 |  |  | 70724 |
| 70773 | return NULL; |  | 70725 | return NULL;
| 70774 | } |  | 70726 | }
| 70775 |  |  | 70727 |
| 70776 | static PyObject* pyopencv_cv_ml_ml_Boost_setWeakCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70728 | static PyObject* pyopencv_cv_ml_ml_Boost_setWeakCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 70777 | { |  | 70729 | {
| 70778 | using namespace cv::ml; |  | 70730 | using namespace cv::ml;
| 70779 |  |  | 70731 |
| 70780 |  |  | 70732 |
| 70781 | Ptr<cv::ml::Boost> * self1 = 0; |  | 70733 | Ptr<cv::ml::Boost> * self1 = 0;
| 70782 | if (!pyopencv_ml_Boost_getp(self, self1)) |  | 70734 | if (!pyopencv_ml_Boost_getp(self, self1))
| 70783 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)"); |  | 70735 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)");
| 70784 | Ptr<cv::ml::Boost> _self_ = *(self1); |  | 70736 | Ptr<cv::ml::Boost> _self_ = *(self1);
| 70785 | PyObject* pyobj_val = NULL; |  | 70737 | PyObject* pyobj_val = NULL;
| 70786 | int val=0; |  | 70738 | int val=0;
| 70787 |  |  | 70739 |
| 70788 | const char* keywords[] = { "val", NULL }; |  | 70740 | const char* keywords[] = { "val", NULL };
| 70789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_Boost.setWeakCount", (char**)keywords, &pyobj_val) && |  | 70741 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_Boost.setWeakCount", (char**)keywords, &pyobj_val) &&
| 70790 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70742 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70791 | { |  | 70743 | {
| 70792 | ERRWRAP2(_self_->setWeakCount(val)); |  | 70744 | ERRWRAP2(_self_->setWeakCount(val));
| 70793 | Py_RETURN_NONE; |  | 70745 | Py_RETURN_NONE;
| 70794 | } |  | 70746 | }
| 70795 |  |  | 70747 |
| 70796 | return NULL; |  | 70748 | return NULL;
| 70797 | } |  | 70749 | }
| 70798 |  |  | 70750 |
| 70799 | static PyObject* pyopencv_cv_ml_ml_Boost_setWeightTrimRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70751 | static PyObject* pyopencv_cv_ml_ml_Boost_setWeightTrimRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 70800 | { |  | 70752 | {
| 70801 | using namespace cv::ml; |  | 70753 | using namespace cv::ml;
| 70802 |  |  | 70754 |
| 70803 |  |  | 70755 |
| 70804 | Ptr<cv::ml::Boost> * self1 = 0; |  | 70756 | Ptr<cv::ml::Boost> * self1 = 0;
| 70805 | if (!pyopencv_ml_Boost_getp(self, self1)) |  | 70757 | if (!pyopencv_ml_Boost_getp(self, self1))
| 70806 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)"); |  | 70758 | return failmsgp("Incorrect type of self (must be 'ml_Boost' or its derivative)");
| 70807 | Ptr<cv::ml::Boost> _self_ = *(self1); |  | 70759 | Ptr<cv::ml::Boost> _self_ = *(self1);
| 70808 | PyObject* pyobj_val = NULL; |  | 70760 | PyObject* pyobj_val = NULL;
| 70809 | double val=0; |  | 70761 | double val=0;
| 70810 |  |  | 70762 |
| 70811 | const char* keywords[] = { "val", NULL }; |  | 70763 | const char* keywords[] = { "val", NULL };
| 70812 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_Boost.setWeightTrimRate", (char**)keywords, &pyobj_val) && |  | 70764 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_Boost.setWeightTrimRate", (char**)keywords, &pyobj_val) &&
| 70813 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 70765 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 70814 | { |  | 70766 | {
| 70815 | ERRWRAP2(_self_->setWeightTrimRate(val)); |  | 70767 | ERRWRAP2(_self_->setWeightTrimRate(val));
| 70816 | Py_RETURN_NONE; |  | 70768 | Py_RETURN_NONE;
| 70817 | } |  | 70769 | }
| 70818 |  |  | 70770 |
| 70819 | return NULL; |  | 70771 | return NULL;
| 70820 | } |  | 70772 | }
| 70821 |  |  | 70773 |
| 70822 |  |  | 70774 |
| 70823 |  |  | 70775 |
| 70824 | // Tables (ml_Boost) |  | 70776 | // Tables (ml_Boost)
| 70825 |  |  | 70777 |
| 70826 | static PyGetSetDef pyopencv_ml_Boost_getseters[] = |  | 70778 | static PyGetSetDef pyopencv_ml_Boost_getseters[] =
| 70827 | { |  | 70779 | {
| 70828 | {NULL} /* Sentinel */ |  | 70780 | {NULL} /* Sentinel */
| 70829 | }; |  | 70781 | };
| 70830 |  |  | 70782 |
| 70831 | static PyMethodDef pyopencv_ml_Boost_methods[] = |  | 70783 | static PyMethodDef pyopencv_ml_Boost_methods[] =
| 70832 | { |  | 70784 | {
| 70833 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_create_static, METH_STATIC), "create() -> retval\n. Creates the empty model.\n. Use StatModel::train to train the model, Algorithm::load\\<Boost\\>(filename) to load the pre-trained model."}, |  | 70785 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_create_static, METH_STATIC), "create() -> retval\n. Creates the empty model.\n. Use StatModel::train to train the model, Algorithm::load\\<Boost\\>(filename) to load the pre-trained model."},
| 70834 | {"getBoostType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_getBoostType, 0), "getBoostType() -> retval\n. @see setBoostType"}, |  | 70786 | {"getBoostType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_getBoostType, 0), "getBoostType() -> retval\n. @see setBoostType"},
| 70835 | {"getWeakCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_getWeakCount, 0), "getWeakCount() -> retval\n. @see setWeakCount"}, |  | 70787 | {"getWeakCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_getWeakCount, 0), "getWeakCount() -> retval\n. @see setWeakCount"},
| 70836 | {"getWeightTrimRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_getWeightTrimRate, 0), "getWeightTrimRate() -> retval\n. @see setWeightTrimRate"}, |  | 70788 | {"getWeightTrimRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_getWeightTrimRate, 0), "getWeightTrimRate() -> retval\n. @see setWeightTrimRate"},
| 70837 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized Boost from a file\n. *\n. * Use Boost::save to serialize and store an RTree to disk.\n. * Load the Boost from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized Boost\n. * @param nodeName name of node containing the classifier"}, |  | 70789 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized Boost from a file\n. *\n. * Use Boost::save to serialize and store an RTree to disk.\n. * Load the Boost from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized Boost\n. * @param nodeName name of node containing the classifier"},
| 70838 | {"setBoostType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_setBoostType, 0), "setBoostType(val) -> None\n. @copybrief getBoostType @see getBoostType"}, |  | 70790 | {"setBoostType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_setBoostType, 0), "setBoostType(val) -> None\n. @copybrief getBoostType @see getBoostType"},
| 70839 | {"setWeakCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_setWeakCount, 0), "setWeakCount(val) -> None\n. @copybrief getWeakCount @see getWeakCount"}, |  | 70791 | {"setWeakCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_setWeakCount, 0), "setWeakCount(val) -> None\n. @copybrief getWeakCount @see getWeakCount"},
| 70840 | {"setWeightTrimRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_setWeightTrimRate, 0), "setWeightTrimRate(val) -> None\n. @copybrief getWeightTrimRate @see getWeightTrimRate"}, |  | 70792 | {"setWeightTrimRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_Boost_setWeightTrimRate, 0), "setWeightTrimRate(val) -> None\n. @copybrief getWeightTrimRate @see getWeightTrimRate"},
| 70841 |  |  | 70793 |
| 70842 | {NULL, NULL} |  | 70794 | {NULL, NULL}
| 70843 | }; |  | 70795 | };
| 70844 |  |  | 70796 |
| 70845 | // Converter (ml_Boost) |  | 70797 | // Converter (ml_Boost)
| 70846 |  |  | 70798 |
| 70847 | template<> |  | 70799 | template<>
| 70848 | struct PyOpenCV_Converter< Ptr<cv::ml::Boost> > |  | 70800 | struct PyOpenCV_Converter< Ptr<cv::ml::Boost> >
| 70849 | { |  | 70801 | {
| 70850 | static PyObject* from(const Ptr<cv::ml::Boost>& r) |  | 70802 | static PyObject* from(const Ptr<cv::ml::Boost>& r)
| 70851 | { |  | 70803 | {
| 70852 | return pyopencv_ml_Boost_Instance(r); |  | 70804 | return pyopencv_ml_Boost_Instance(r);
| 70853 | } |  | 70805 | }
| 70854 | static bool to(PyObject* src, Ptr<cv::ml::Boost>& dst, const ArgInfo& info) |  | 70806 | static bool to(PyObject* src, Ptr<cv::ml::Boost>& dst, const ArgInfo& info)
| 70855 | { |  | 70807 | {
| 70856 | if(!src || src == Py_None) |  | 70808 | if(!src || src == Py_None)
| 70857 | return true; |  | 70809 | return true;
| 70858 | Ptr<cv::ml::Boost> * dst_; |  | 70810 | Ptr<cv::ml::Boost> * dst_;
| 70859 | if (pyopencv_ml_Boost_getp(src, dst_)) |  | 70811 | if (pyopencv_ml_Boost_getp(src, dst_))
| 70860 | { |  | 70812 | {
| 70861 | dst = *dst_; |  | 70813 | dst = *dst_;
| 70862 | return true; |  | 70814 | return true;
| 70863 | } |  | 70815 | }
| 70864 |  |  | 70816 |
| 70865 | failmsg("Expected Ptr<cv::ml::Boost> for argument '%s'", info.name); |  | 70817 | failmsg("Expected Ptr<cv::ml::Boost> for argument '%s'", info.name);
| 70866 | return false; |  | 70818 | return false;
| 70867 | } |  | 70819 | }
| 70868 | }; |  | 70820 | };
| 70869 |  |  | 70821 |
| 70870 | //================================================================================ |  | 70822 | //================================================================================
| 70871 | // ml_DTrees (Generic) |  | 70823 | // ml_DTrees (Generic)
| 70872 | //================================================================================ |  | 70824 | //================================================================================
| 70873 |  |  | 70825 |
| 70874 | // GetSet (ml_DTrees) |  | 70826 | // GetSet (ml_DTrees)
| 70875 |  |  | 70827 |
| 70876 |  |  | 70828 |
| 70877 |  |  | 70829 |
| 70878 | // Methods (ml_DTrees) |  | 70830 | // Methods (ml_DTrees)
| 70879 |  |  | 70831 |
| 70880 | static PyObject* pyopencv_cv_ml_ml_DTrees_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70832 | static PyObject* pyopencv_cv_ml_ml_DTrees_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 70881 | { |  | 70833 | {
| 70882 | using namespace cv::ml; |  | 70834 | using namespace cv::ml;
| 70883 |  |  | 70835 |
| 70884 | Ptr<DTrees> retval; |  | 70836 | Ptr<DTrees> retval;
| 70885 |  |  | 70837 |
| 70886 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70838 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70887 | { |  | 70839 | {
| 70888 | ERRWRAP2(retval = cv::ml::DTrees::create()); |  | 70840 | ERRWRAP2(retval = cv::ml::DTrees::create());
| 70889 | return pyopencv_from(retval); |  | 70841 | return pyopencv_from(retval);
| 70890 | } |  | 70842 | }
| 70891 |  |  | 70843 |
| 70892 | return NULL; |  | 70844 | return NULL;
| 70893 | } |  | 70845 | }
| 70894 |  |  | 70846 |
| 70895 | static PyObject* pyopencv_cv_ml_ml_DTrees_getCVFolds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70847 | static PyObject* pyopencv_cv_ml_ml_DTrees_getCVFolds(PyObject* self, PyObject* py_args, PyObject* kw)
| 70896 | { |  | 70848 | {
| 70897 | using namespace cv::ml; |  | 70849 | using namespace cv::ml;
| 70898 |  |  | 70850 |
| 70899 |  |  | 70851 |
| 70900 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70852 | Ptr<cv::ml::DTrees> * self1 = 0;
| 70901 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70853 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 70902 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70854 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 70903 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70855 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 70904 | int retval; |  | 70856 | int retval;
| 70905 |  |  | 70857 |
| 70906 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70858 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70907 | { |  | 70859 | {
| 70908 | ERRWRAP2(retval = _self_->getCVFolds()); |  | 70860 | ERRWRAP2(retval = _self_->getCVFolds());
| 70909 | return pyopencv_from(retval); |  | 70861 | return pyopencv_from(retval);
| 70910 | } |  | 70862 | }
| 70911 |  |  | 70863 |
| 70912 | return NULL; |  | 70864 | return NULL;
| 70913 | } |  | 70865 | }
| 70914 |  |  | 70866 |
| 70915 | static PyObject* pyopencv_cv_ml_ml_DTrees_getMaxCategories(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70867 | static PyObject* pyopencv_cv_ml_ml_DTrees_getMaxCategories(PyObject* self, PyObject* py_args, PyObject* kw)
| 70916 | { |  | 70868 | {
| 70917 | using namespace cv::ml; |  | 70869 | using namespace cv::ml;
| 70918 |  |  | 70870 |
| 70919 |  |  | 70871 |
| 70920 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70872 | Ptr<cv::ml::DTrees> * self1 = 0;
| 70921 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70873 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 70922 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70874 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 70923 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70875 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 70924 | int retval; |  | 70876 | int retval;
| 70925 |  |  | 70877 |
| 70926 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70878 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70927 | { |  | 70879 | {
| 70928 | ERRWRAP2(retval = _self_->getMaxCategories()); |  | 70880 | ERRWRAP2(retval = _self_->getMaxCategories());
| 70929 | return pyopencv_from(retval); |  | 70881 | return pyopencv_from(retval);
| 70930 | } |  | 70882 | }
| 70931 |  |  | 70883 |
| 70932 | return NULL; |  | 70884 | return NULL;
| 70933 | } |  | 70885 | }
| 70934 |  |  | 70886 |
| 70935 | static PyObject* pyopencv_cv_ml_ml_DTrees_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70887 | static PyObject* pyopencv_cv_ml_ml_DTrees_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 70936 | { |  | 70888 | {
| 70937 | using namespace cv::ml; |  | 70889 | using namespace cv::ml;
| 70938 |  |  | 70890 |
| 70939 |  |  | 70891 |
| 70940 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70892 | Ptr<cv::ml::DTrees> * self1 = 0;
| 70941 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70893 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 70942 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70894 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 70943 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70895 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 70944 | int retval; |  | 70896 | int retval;
| 70945 |  |  | 70897 |
| 70946 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70898 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70947 | { |  | 70899 | {
| 70948 | ERRWRAP2(retval = _self_->getMaxDepth()); |  | 70900 | ERRWRAP2(retval = _self_->getMaxDepth());
| 70949 | return pyopencv_from(retval); |  | 70901 | return pyopencv_from(retval);
| 70950 | } |  | 70902 | }
| 70951 |  |  | 70903 |
| 70952 | return NULL; |  | 70904 | return NULL;
| 70953 | } |  | 70905 | }
| 70954 |  |  | 70906 |
| 70955 | static PyObject* pyopencv_cv_ml_ml_DTrees_getMinSampleCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70907 | static PyObject* pyopencv_cv_ml_ml_DTrees_getMinSampleCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 70956 | { |  | 70908 | {
| 70957 | using namespace cv::ml; |  | 70909 | using namespace cv::ml;
| 70958 |  |  | 70910 |
| 70959 |  |  | 70911 |
| 70960 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70912 | Ptr<cv::ml::DTrees> * self1 = 0;
| 70961 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70913 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 70962 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70914 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 70963 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70915 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 70964 | int retval; |  | 70916 | int retval;
| 70965 |  |  | 70917 |
| 70966 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70918 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70967 | { |  | 70919 | {
| 70968 | ERRWRAP2(retval = _self_->getMinSampleCount()); |  | 70920 | ERRWRAP2(retval = _self_->getMinSampleCount());
| 70969 | return pyopencv_from(retval); |  | 70921 | return pyopencv_from(retval);
| 70970 | } |  | 70922 | }
| 70971 |  |  | 70923 |
| 70972 | return NULL; |  | 70924 | return NULL;
| 70973 | } |  | 70925 | }
| 70974 |  |  | 70926 |
| 70975 | static PyObject* pyopencv_cv_ml_ml_DTrees_getPriors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70927 | static PyObject* pyopencv_cv_ml_ml_DTrees_getPriors(PyObject* self, PyObject* py_args, PyObject* kw)
| 70976 | { |  | 70928 | {
| 70977 | using namespace cv::ml; |  | 70929 | using namespace cv::ml;
| 70978 |  |  | 70930 |
| 70979 |  |  | 70931 |
| 70980 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70932 | Ptr<cv::ml::DTrees> * self1 = 0;
| 70981 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70933 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 70982 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70934 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 70983 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70935 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 70984 | cv::Mat retval; |  | 70936 | cv::Mat retval;
| 70985 |  |  | 70937 |
| 70986 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70938 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 70987 | { |  | 70939 | {
| 70988 | ERRWRAP2(retval = _self_->getPriors()); |  | 70940 | ERRWRAP2(retval = _self_->getPriors());
| 70989 | return pyopencv_from(retval); |  | 70941 | return pyopencv_from(retval);
| 70990 | } |  | 70942 | }
| 70991 |  |  | 70943 |
| 70992 | return NULL; |  | 70944 | return NULL;
| 70993 | } |  | 70945 | }
| 70994 |  |  | 70946 |
| 70995 | static PyObject* pyopencv_cv_ml_ml_DTrees_getRegressionAccuracy(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70947 | static PyObject* pyopencv_cv_ml_ml_DTrees_getRegressionAccuracy(PyObject* self, PyObject* py_args, PyObject* kw)
| 70996 | { |  | 70948 | {
| 70997 | using namespace cv::ml; |  | 70949 | using namespace cv::ml;
| 70998 |  |  | 70950 |
| 70999 |  |  | 70951 |
| 71000 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70952 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71001 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70953 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71002 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70954 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71003 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70955 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71004 | float retval; |  | 70956 | float retval;
| 71005 |  |  | 70957 |
| 71006 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70958 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71007 | { |  | 70959 | {
| 71008 | ERRWRAP2(retval = _self_->getRegressionAccuracy()); |  | 70960 | ERRWRAP2(retval = _self_->getRegressionAccuracy());
| 71009 | return pyopencv_from(retval); |  | 70961 | return pyopencv_from(retval);
| 71010 | } |  | 70962 | }
| 71011 |  |  | 70963 |
| 71012 | return NULL; |  | 70964 | return NULL;
| 71013 | } |  | 70965 | }
| 71014 |  |  | 70966 |
| 71015 | static PyObject* pyopencv_cv_ml_ml_DTrees_getTruncatePrunedTree(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70967 | static PyObject* pyopencv_cv_ml_ml_DTrees_getTruncatePrunedTree(PyObject* self, PyObject* py_args, PyObject* kw)
| 71016 | { |  | 70968 | {
| 71017 | using namespace cv::ml; |  | 70969 | using namespace cv::ml;
| 71018 |  |  | 70970 |
| 71019 |  |  | 70971 |
| 71020 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70972 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71021 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70973 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71022 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70974 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71023 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70975 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71024 | bool retval; |  | 70976 | bool retval;
| 71025 |  |  | 70977 |
| 71026 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70978 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71027 | { |  | 70979 | {
| 71028 | ERRWRAP2(retval = _self_->getTruncatePrunedTree()); |  | 70980 | ERRWRAP2(retval = _self_->getTruncatePrunedTree());
| 71029 | return pyopencv_from(retval); |  | 70981 | return pyopencv_from(retval);
| 71030 | } |  | 70982 | }
| 71031 |  |  | 70983 |
| 71032 | return NULL; |  | 70984 | return NULL;
| 71033 | } |  | 70985 | }
| 71034 |  |  | 70986 |
| 71035 | static PyObject* pyopencv_cv_ml_ml_DTrees_getUse1SERule(PyObject* self, PyObject* py_args, PyObject* kw) |  | 70987 | static PyObject* pyopencv_cv_ml_ml_DTrees_getUse1SERule(PyObject* self, PyObject* py_args, PyObject* kw)
| 71036 | { |  | 70988 | {
| 71037 | using namespace cv::ml; |  | 70989 | using namespace cv::ml;
| 71038 |  |  | 70990 |
| 71039 |  |  | 70991 |
| 71040 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 70992 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71041 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 70993 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71042 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 70994 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71043 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 70995 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71044 | bool retval; |  | 70996 | bool retval;
| 71045 |  |  | 70997 |
| 71046 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 70998 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71047 | { |  | 70999 | {
| 71048 | ERRWRAP2(retval = _self_->getUse1SERule()); |  | 71000 | ERRWRAP2(retval = _self_->getUse1SERule());
| 71049 | return pyopencv_from(retval); |  | 71001 | return pyopencv_from(retval);
| 71050 | } |  | 71002 | }
| 71051 |  |  | 71003 |
| 71052 | return NULL; |  | 71004 | return NULL;
| 71053 | } |  | 71005 | }
| 71054 |  |  | 71006 |
| 71055 | static PyObject* pyopencv_cv_ml_ml_DTrees_getUseSurrogates(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71007 | static PyObject* pyopencv_cv_ml_ml_DTrees_getUseSurrogates(PyObject* self, PyObject* py_args, PyObject* kw)
| 71056 | { |  | 71008 | {
| 71057 | using namespace cv::ml; |  | 71009 | using namespace cv::ml;
| 71058 |  |  | 71010 |
| 71059 |  |  | 71011 |
| 71060 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71012 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71061 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71013 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71062 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71014 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71063 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71015 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71064 | bool retval; |  | 71016 | bool retval;
| 71065 |  |  | 71017 |
| 71066 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71018 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71067 | { |  | 71019 | {
| 71068 | ERRWRAP2(retval = _self_->getUseSurrogates()); |  | 71020 | ERRWRAP2(retval = _self_->getUseSurrogates());
| 71069 | return pyopencv_from(retval); |  | 71021 | return pyopencv_from(retval);
| 71070 | } |  | 71022 | }
| 71071 |  |  | 71023 |
| 71072 | return NULL; |  | 71024 | return NULL;
| 71073 | } |  | 71025 | }
| 71074 |  |  | 71026 |
| 71075 | static PyObject* pyopencv_cv_ml_ml_DTrees_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71027 | static PyObject* pyopencv_cv_ml_ml_DTrees_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 71076 | { |  | 71028 | {
| 71077 | using namespace cv::ml; |  | 71029 | using namespace cv::ml;
| 71078 |  |  | 71030 |
| 71079 | PyObject* pyobj_filepath = NULL; |  | 71031 | PyObject* pyobj_filepath = NULL;
| 71080 | String filepath; |  | 71032 | String filepath;
| 71081 | PyObject* pyobj_nodeName = NULL; |  | 71033 | PyObject* pyobj_nodeName = NULL;
| 71082 | String nodeName; |  | 71034 | String nodeName;
| 71083 | Ptr<DTrees> retval; |  | 71035 | Ptr<DTrees> retval;
| 71084 |  |  | 71036 |
| 71085 | const char* keywords[] = { "filepath", "nodeName", NULL }; |  | 71037 | const char* keywords[] = { "filepath", "nodeName", NULL };
| 71086 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_DTrees.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) && |  | 71038 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_DTrees.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) &&
| 71087 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) && |  | 71039 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) &&
| 71088 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) ) |  | 71040 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) )
| 71089 | { |  | 71041 | {
| 71090 | ERRWRAP2(retval = cv::ml::DTrees::load(filepath, nodeName)); |  | 71042 | ERRWRAP2(retval = cv::ml::DTrees::load(filepath, nodeName));
| 71091 | return pyopencv_from(retval); |  | 71043 | return pyopencv_from(retval);
| 71092 | } |  | 71044 | }
| 71093 |  |  | 71045 |
| 71094 | return NULL; |  | 71046 | return NULL;
| 71095 | } |  | 71047 | }
| 71096 |  |  | 71048 |
| 71097 | static PyObject* pyopencv_cv_ml_ml_DTrees_setCVFolds(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71049 | static PyObject* pyopencv_cv_ml_ml_DTrees_setCVFolds(PyObject* self, PyObject* py_args, PyObject* kw)
| 71098 | { |  | 71050 | {
| 71099 | using namespace cv::ml; |  | 71051 | using namespace cv::ml;
| 71100 |  |  | 71052 |
| 71101 |  |  | 71053 |
| 71102 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71054 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71103 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71055 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71104 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71056 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71105 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71057 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71106 | PyObject* pyobj_val = NULL; |  | 71058 | PyObject* pyobj_val = NULL;
| 71107 | int val=0; |  | 71059 | int val=0;
| 71108 |  |  | 71060 |
| 71109 | const char* keywords[] = { "val", NULL }; |  | 71061 | const char* keywords[] = { "val", NULL };
| 71110 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setCVFolds", (char**)keywords, &pyobj_val) && |  | 71062 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setCVFolds", (char**)keywords, &pyobj_val) &&
| 71111 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71063 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71112 | { |  | 71064 | {
| 71113 | ERRWRAP2(_self_->setCVFolds(val)); |  | 71065 | ERRWRAP2(_self_->setCVFolds(val));
| 71114 | Py_RETURN_NONE; |  | 71066 | Py_RETURN_NONE;
| 71115 | } |  | 71067 | }
| 71116 |  |  | 71068 |
| 71117 | return NULL; |  | 71069 | return NULL;
| 71118 | } |  | 71070 | }
| 71119 |  |  | 71071 |
| 71120 | static PyObject* pyopencv_cv_ml_ml_DTrees_setMaxCategories(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71072 | static PyObject* pyopencv_cv_ml_ml_DTrees_setMaxCategories(PyObject* self, PyObject* py_args, PyObject* kw)
| 71121 | { |  | 71073 | {
| 71122 | using namespace cv::ml; |  | 71074 | using namespace cv::ml;
| 71123 |  |  | 71075 |
| 71124 |  |  | 71076 |
| 71125 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71077 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71126 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71078 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71127 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71079 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71128 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71080 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71129 | PyObject* pyobj_val = NULL; |  | 71081 | PyObject* pyobj_val = NULL;
| 71130 | int val=0; |  | 71082 | int val=0;
| 71131 |  |  | 71083 |
| 71132 | const char* keywords[] = { "val", NULL }; |  | 71084 | const char* keywords[] = { "val", NULL };
| 71133 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setMaxCategories", (char**)keywords, &pyobj_val) && |  | 71085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setMaxCategories", (char**)keywords, &pyobj_val) &&
| 71134 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71086 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71135 | { |  | 71087 | {
| 71136 | ERRWRAP2(_self_->setMaxCategories(val)); |  | 71088 | ERRWRAP2(_self_->setMaxCategories(val));
| 71137 | Py_RETURN_NONE; |  | 71089 | Py_RETURN_NONE;
| 71138 | } |  | 71090 | }
| 71139 |  |  | 71091 |
| 71140 | return NULL; |  | 71092 | return NULL;
| 71141 | } |  | 71093 | }
| 71142 |  |  | 71094 |
| 71143 | static PyObject* pyopencv_cv_ml_ml_DTrees_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71095 | static PyObject* pyopencv_cv_ml_ml_DTrees_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 71144 | { |  | 71096 | {
| 71145 | using namespace cv::ml; |  | 71097 | using namespace cv::ml;
| 71146 |  |  | 71098 |
| 71147 |  |  | 71099 |
| 71148 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71100 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71149 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71101 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71150 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71102 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71151 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71103 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71152 | PyObject* pyobj_val = NULL; |  | 71104 | PyObject* pyobj_val = NULL;
| 71153 | int val=0; |  | 71105 | int val=0;
| 71154 |  |  | 71106 |
| 71155 | const char* keywords[] = { "val", NULL }; |  | 71107 | const char* keywords[] = { "val", NULL };
| 71156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setMaxDepth", (char**)keywords, &pyobj_val) && |  | 71108 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setMaxDepth", (char**)keywords, &pyobj_val) &&
| 71157 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71109 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71158 | { |  | 71110 | {
| 71159 | ERRWRAP2(_self_->setMaxDepth(val)); |  | 71111 | ERRWRAP2(_self_->setMaxDepth(val));
| 71160 | Py_RETURN_NONE; |  | 71112 | Py_RETURN_NONE;
| 71161 | } |  | 71113 | }
| 71162 |  |  | 71114 |
| 71163 | return NULL; |  | 71115 | return NULL;
| 71164 | } |  | 71116 | }
| 71165 |  |  | 71117 |
| 71166 | static PyObject* pyopencv_cv_ml_ml_DTrees_setMinSampleCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71118 | static PyObject* pyopencv_cv_ml_ml_DTrees_setMinSampleCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 71167 | { |  | 71119 | {
| 71168 | using namespace cv::ml; |  | 71120 | using namespace cv::ml;
| 71169 |  |  | 71121 |
| 71170 |  |  | 71122 |
| 71171 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71123 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71172 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71124 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71173 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71125 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71174 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71126 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71175 | PyObject* pyobj_val = NULL; |  | 71127 | PyObject* pyobj_val = NULL;
| 71176 | int val=0; |  | 71128 | int val=0;
| 71177 |  |  | 71129 |
| 71178 | const char* keywords[] = { "val", NULL }; |  | 71130 | const char* keywords[] = { "val", NULL };
| 71179 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setMinSampleCount", (char**)keywords, &pyobj_val) && |  | 71131 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setMinSampleCount", (char**)keywords, &pyobj_val) &&
| 71180 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71132 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71181 | { |  | 71133 | {
| 71182 | ERRWRAP2(_self_->setMinSampleCount(val)); |  | 71134 | ERRWRAP2(_self_->setMinSampleCount(val));
| 71183 | Py_RETURN_NONE; |  | 71135 | Py_RETURN_NONE;
| 71184 | } |  | 71136 | }
| 71185 |  |  | 71137 |
| 71186 | return NULL; |  | 71138 | return NULL;
| 71187 | } |  | 71139 | }
| 71188 |  |  | 71140 |
| 71189 | static PyObject* pyopencv_cv_ml_ml_DTrees_setPriors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71141 | static PyObject* pyopencv_cv_ml_ml_DTrees_setPriors(PyObject* self, PyObject* py_args, PyObject* kw)
| 71190 | { |  | 71142 | {
| 71191 | using namespace cv::ml; |  | 71143 | using namespace cv::ml;
| 71192 |  |  | 71144 |
| 71193 |  |  | 71145 |
| 71194 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71146 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71195 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71147 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71196 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71148 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71197 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71149 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71198 | PyObject* pyobj_val = NULL; |  | 71150 | PyObject* pyobj_val = NULL;
| 71199 | Mat val; |  | 71151 | Mat val;
| 71200 |  |  | 71152 |
| 71201 | const char* keywords[] = { "val", NULL }; |  | 71153 | const char* keywords[] = { "val", NULL };
| 71202 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setPriors", (char**)keywords, &pyobj_val) && |  | 71154 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setPriors", (char**)keywords, &pyobj_val) &&
| 71203 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71155 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71204 | { |  | 71156 | {
| 71205 | ERRWRAP2(_self_->setPriors(val)); |  | 71157 | ERRWRAP2(_self_->setPriors(val));
| 71206 | Py_RETURN_NONE; |  | 71158 | Py_RETURN_NONE;
| 71207 | } |  | 71159 | }
| 71208 |  |  | 71160 |
| 71209 | return NULL; |  | 71161 | return NULL;
| 71210 | } |  | 71162 | }
| 71211 |  |  | 71163 |
| 71212 | static PyObject* pyopencv_cv_ml_ml_DTrees_setRegressionAccuracy(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71164 | static PyObject* pyopencv_cv_ml_ml_DTrees_setRegressionAccuracy(PyObject* self, PyObject* py_args, PyObject* kw)
| 71213 | { |  | 71165 | {
| 71214 | using namespace cv::ml; |  | 71166 | using namespace cv::ml;
| 71215 |  |  | 71167 |
| 71216 |  |  | 71168 |
| 71217 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71169 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71218 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71170 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71219 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71171 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71220 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71172 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71221 | PyObject* pyobj_val = NULL; |  | 71173 | PyObject* pyobj_val = NULL;
| 71222 | float val=0.f; |  | 71174 | float val=0.f;
| 71223 |  |  | 71175 |
| 71224 | const char* keywords[] = { "val", NULL }; |  | 71176 | const char* keywords[] = { "val", NULL };
| 71225 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setRegressionAccuracy", (char**)keywords, &pyobj_val) && |  | 71177 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setRegressionAccuracy", (char**)keywords, &pyobj_val) &&
| 71226 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71178 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71227 | { |  | 71179 | {
| 71228 | ERRWRAP2(_self_->setRegressionAccuracy(val)); |  | 71180 | ERRWRAP2(_self_->setRegressionAccuracy(val));
| 71229 | Py_RETURN_NONE; |  | 71181 | Py_RETURN_NONE;
| 71230 | } |  | 71182 | }
| 71231 |  |  | 71183 |
| 71232 | return NULL; |  | 71184 | return NULL;
| 71233 | } |  | 71185 | }
| 71234 |  |  | 71186 |
| 71235 | static PyObject* pyopencv_cv_ml_ml_DTrees_setTruncatePrunedTree(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71187 | static PyObject* pyopencv_cv_ml_ml_DTrees_setTruncatePrunedTree(PyObject* self, PyObject* py_args, PyObject* kw)
| 71236 | { |  | 71188 | {
| 71237 | using namespace cv::ml; |  | 71189 | using namespace cv::ml;
| 71238 |  |  | 71190 |
| 71239 |  |  | 71191 |
| 71240 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71192 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71241 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71193 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71242 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71194 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71243 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71195 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71244 | PyObject* pyobj_val = NULL; |  | 71196 | PyObject* pyobj_val = NULL;
| 71245 | bool val=0; |  | 71197 | bool val=0;
| 71246 |  |  | 71198 |
| 71247 | const char* keywords[] = { "val", NULL }; |  | 71199 | const char* keywords[] = { "val", NULL };
| 71248 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setTruncatePrunedTree", (char**)keywords, &pyobj_val) && |  | 71200 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setTruncatePrunedTree", (char**)keywords, &pyobj_val) &&
| 71249 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71201 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71250 | { |  | 71202 | {
| 71251 | ERRWRAP2(_self_->setTruncatePrunedTree(val)); |  | 71203 | ERRWRAP2(_self_->setTruncatePrunedTree(val));
| 71252 | Py_RETURN_NONE; |  | 71204 | Py_RETURN_NONE;
| 71253 | } |  | 71205 | }
| 71254 |  |  | 71206 |
| 71255 | return NULL; |  | 71207 | return NULL;
| 71256 | } |  | 71208 | }
| 71257 |  |  | 71209 |
| 71258 | static PyObject* pyopencv_cv_ml_ml_DTrees_setUse1SERule(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71210 | static PyObject* pyopencv_cv_ml_ml_DTrees_setUse1SERule(PyObject* self, PyObject* py_args, PyObject* kw)
| 71259 | { |  | 71211 | {
| 71260 | using namespace cv::ml; |  | 71212 | using namespace cv::ml;
| 71261 |  |  | 71213 |
| 71262 |  |  | 71214 |
| 71263 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71215 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71264 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71216 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71265 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71217 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71266 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71218 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71267 | PyObject* pyobj_val = NULL; |  | 71219 | PyObject* pyobj_val = NULL;
| 71268 | bool val=0; |  | 71220 | bool val=0;
| 71269 |  |  | 71221 |
| 71270 | const char* keywords[] = { "val", NULL }; |  | 71222 | const char* keywords[] = { "val", NULL };
| 71271 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setUse1SERule", (char**)keywords, &pyobj_val) && |  | 71223 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setUse1SERule", (char**)keywords, &pyobj_val) &&
| 71272 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71224 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71273 | { |  | 71225 | {
| 71274 | ERRWRAP2(_self_->setUse1SERule(val)); |  | 71226 | ERRWRAP2(_self_->setUse1SERule(val));
| 71275 | Py_RETURN_NONE; |  | 71227 | Py_RETURN_NONE;
| 71276 | } |  | 71228 | }
| 71277 |  |  | 71229 |
| 71278 | return NULL; |  | 71230 | return NULL;
| 71279 | } |  | 71231 | }
| 71280 |  |  | 71232 |
| 71281 | static PyObject* pyopencv_cv_ml_ml_DTrees_setUseSurrogates(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71233 | static PyObject* pyopencv_cv_ml_ml_DTrees_setUseSurrogates(PyObject* self, PyObject* py_args, PyObject* kw)
| 71282 | { |  | 71234 | {
| 71283 | using namespace cv::ml; |  | 71235 | using namespace cv::ml;
| 71284 |  |  | 71236 |
| 71285 |  |  | 71237 |
| 71286 | Ptr<cv::ml::DTrees> * self1 = 0; |  | 71238 | Ptr<cv::ml::DTrees> * self1 = 0;
| 71287 | if (!pyopencv_ml_DTrees_getp(self, self1)) |  | 71239 | if (!pyopencv_ml_DTrees_getp(self, self1))
| 71288 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)"); |  | 71240 | return failmsgp("Incorrect type of self (must be 'ml_DTrees' or its derivative)");
| 71289 | Ptr<cv::ml::DTrees> _self_ = *(self1); |  | 71241 | Ptr<cv::ml::DTrees> _self_ = *(self1);
| 71290 | PyObject* pyobj_val = NULL; |  | 71242 | PyObject* pyobj_val = NULL;
| 71291 | bool val=0; |  | 71243 | bool val=0;
| 71292 |  |  | 71244 |
| 71293 | const char* keywords[] = { "val", NULL }; |  | 71245 | const char* keywords[] = { "val", NULL };
| 71294 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setUseSurrogates", (char**)keywords, &pyobj_val) && |  | 71246 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_DTrees.setUseSurrogates", (char**)keywords, &pyobj_val) &&
| 71295 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71247 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71296 | { |  | 71248 | {
| 71297 | ERRWRAP2(_self_->setUseSurrogates(val)); |  | 71249 | ERRWRAP2(_self_->setUseSurrogates(val));
| 71298 | Py_RETURN_NONE; |  | 71250 | Py_RETURN_NONE;
| 71299 | } |  | 71251 | }
| 71300 |  |  | 71252 |
| 71301 | return NULL; |  | 71253 | return NULL;
| 71302 | } |  | 71254 | }
| 71303 |  |  | 71255 |
| 71304 |  |  | 71256 |
| 71305 |  |  | 71257 |
| 71306 | // Tables (ml_DTrees) |  | 71258 | // Tables (ml_DTrees)
| 71307 |  |  | 71259 |
| 71308 | static PyGetSetDef pyopencv_ml_DTrees_getseters[] = |  | 71260 | static PyGetSetDef pyopencv_ml_DTrees_getseters[] =
| 71309 | { |  | 71261 | {
| 71310 | {NULL} /* Sentinel */ |  | 71262 | {NULL} /* Sentinel */
| 71311 | }; |  | 71263 | };
| 71312 |  |  | 71264 |
| 71313 | static PyMethodDef pyopencv_ml_DTrees_methods[] = |  | 71265 | static PyMethodDef pyopencv_ml_DTrees_methods[] =
| 71314 | { |  | 71266 | {
| 71315 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_create_static, METH_STATIC), "create() -> retval\n. @brief Creates the empty model\n. \n. The static method creates empty decision tree with the specified parameters. It should be then\n. trained using train method (see StatModel::train). Alternatively, you can load the model from\n. file using Algorithm::load\\<DTrees\\>(filename)."}, |  | 71267 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_create_static, METH_STATIC), "create() -> retval\n. @brief Creates the empty model\n. \n. The static method creates empty decision tree with the specified parameters. It should be then\n. trained using train method (see StatModel::train). Alternatively, you can load the model from\n. file using Algorithm::load\\<DTrees\\>(filename)."},
| 71316 | {"getCVFolds", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getCVFolds, 0), "getCVFolds() -> retval\n. @see setCVFolds"}, |  | 71268 | {"getCVFolds", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getCVFolds, 0), "getCVFolds() -> retval\n. @see setCVFolds"},
| 71317 | {"getMaxCategories", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getMaxCategories, 0), "getMaxCategories() -> retval\n. @see setMaxCategories"}, |  | 71269 | {"getMaxCategories", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getMaxCategories, 0), "getMaxCategories() -> retval\n. @see setMaxCategories"},
| 71318 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getMaxDepth, 0), "getMaxDepth() -> retval\n. @see setMaxDepth"}, |  | 71270 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getMaxDepth, 0), "getMaxDepth() -> retval\n. @see setMaxDepth"},
| 71319 | {"getMinSampleCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getMinSampleCount, 0), "getMinSampleCount() -> retval\n. @see setMinSampleCount"}, |  | 71271 | {"getMinSampleCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getMinSampleCount, 0), "getMinSampleCount() -> retval\n. @see setMinSampleCount"},
| 71320 | {"getPriors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getPriors, 0), "getPriors() -> retval\n. @see setPriors"}, |  | 71272 | {"getPriors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getPriors, 0), "getPriors() -> retval\n. @see setPriors"},
| 71321 | {"getRegressionAccuracy", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getRegressionAccuracy, 0), "getRegressionAccuracy() -> retval\n. @see setRegressionAccuracy"}, |  | 71273 | {"getRegressionAccuracy", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getRegressionAccuracy, 0), "getRegressionAccuracy() -> retval\n. @see setRegressionAccuracy"},
| 71322 | {"getTruncatePrunedTree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getTruncatePrunedTree, 0), "getTruncatePrunedTree() -> retval\n. @see setTruncatePrunedTree"}, |  | 71274 | {"getTruncatePrunedTree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getTruncatePrunedTree, 0), "getTruncatePrunedTree() -> retval\n. @see setTruncatePrunedTree"},
| 71323 | {"getUse1SERule", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getUse1SERule, 0), "getUse1SERule() -> retval\n. @see setUse1SERule"}, |  | 71275 | {"getUse1SERule", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getUse1SERule, 0), "getUse1SERule() -> retval\n. @see setUse1SERule"},
| 71324 | {"getUseSurrogates", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getUseSurrogates, 0), "getUseSurrogates() -> retval\n. @see setUseSurrogates"}, |  | 71276 | {"getUseSurrogates", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_getUseSurrogates, 0), "getUseSurrogates() -> retval\n. @see setUseSurrogates"},
| 71325 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized DTrees from a file\n. *\n. * Use DTree::save to serialize and store an DTree to disk.\n. * Load the DTree from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized DTree\n. * @param nodeName name of node containing the classifier"}, |  | 71277 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized DTrees from a file\n. *\n. * Use DTree::save to serialize and store an DTree to disk.\n. * Load the DTree from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized DTree\n. * @param nodeName name of node containing the classifier"},
| 71326 | {"setCVFolds", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setCVFolds, 0), "setCVFolds(val) -> None\n. @copybrief getCVFolds @see getCVFolds"}, |  | 71278 | {"setCVFolds", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setCVFolds, 0), "setCVFolds(val) -> None\n. @copybrief getCVFolds @see getCVFolds"},
| 71327 | {"setMaxCategories", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setMaxCategories, 0), "setMaxCategories(val) -> None\n. @copybrief getMaxCategories @see getMaxCategories"}, |  | 71279 | {"setMaxCategories", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setMaxCategories, 0), "setMaxCategories(val) -> None\n. @copybrief getMaxCategories @see getMaxCategories"},
| 71328 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setMaxDepth, 0), "setMaxDepth(val) -> None\n. @copybrief getMaxDepth @see getMaxDepth"}, |  | 71280 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setMaxDepth, 0), "setMaxDepth(val) -> None\n. @copybrief getMaxDepth @see getMaxDepth"},
| 71329 | {"setMinSampleCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setMinSampleCount, 0), "setMinSampleCount(val) -> None\n. @copybrief getMinSampleCount @see getMinSampleCount"}, |  | 71281 | {"setMinSampleCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setMinSampleCount, 0), "setMinSampleCount(val) -> None\n. @copybrief getMinSampleCount @see getMinSampleCount"},
| 71330 | {"setPriors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setPriors, 0), "setPriors(val) -> None\n. @copybrief getPriors @see getPriors"}, |  | 71282 | {"setPriors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setPriors, 0), "setPriors(val) -> None\n. @copybrief getPriors @see getPriors"},
| 71331 | {"setRegressionAccuracy", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setRegressionAccuracy, 0), "setRegressionAccuracy(val) -> None\n. @copybrief getRegressionAccuracy @see getRegressionAccuracy"}, |  | 71283 | {"setRegressionAccuracy", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setRegressionAccuracy, 0), "setRegressionAccuracy(val) -> None\n. @copybrief getRegressionAccuracy @see getRegressionAccuracy"},
| 71332 | {"setTruncatePrunedTree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setTruncatePrunedTree, 0), "setTruncatePrunedTree(val) -> None\n. @copybrief getTruncatePrunedTree @see getTruncatePrunedTree"}, |  | 71284 | {"setTruncatePrunedTree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setTruncatePrunedTree, 0), "setTruncatePrunedTree(val) -> None\n. @copybrief getTruncatePrunedTree @see getTruncatePrunedTree"},
| 71333 | {"setUse1SERule", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setUse1SERule, 0), "setUse1SERule(val) -> None\n. @copybrief getUse1SERule @see getUse1SERule"}, |  | 71285 | {"setUse1SERule", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setUse1SERule, 0), "setUse1SERule(val) -> None\n. @copybrief getUse1SERule @see getUse1SERule"},
| 71334 | {"setUseSurrogates", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setUseSurrogates, 0), "setUseSurrogates(val) -> None\n. @copybrief getUseSurrogates @see getUseSurrogates"}, |  | 71286 | {"setUseSurrogates", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_DTrees_setUseSurrogates, 0), "setUseSurrogates(val) -> None\n. @copybrief getUseSurrogates @see getUseSurrogates"},
| 71335 |  |  | 71287 |
| 71336 | {NULL, NULL} |  | 71288 | {NULL, NULL}
| 71337 | }; |  | 71289 | };
| 71338 |  |  | 71290 |
| 71339 | // Converter (ml_DTrees) |  | 71291 | // Converter (ml_DTrees)
| 71340 |  |  | 71292 |
| 71341 | template<> |  | 71293 | template<>
| 71342 | struct PyOpenCV_Converter< Ptr<cv::ml::DTrees> > |  | 71294 | struct PyOpenCV_Converter< Ptr<cv::ml::DTrees> >
| 71343 | { |  | 71295 | {
| 71344 | static PyObject* from(const Ptr<cv::ml::DTrees>& r) |  | 71296 | static PyObject* from(const Ptr<cv::ml::DTrees>& r)
| 71345 | { |  | 71297 | {
| 71346 | return pyopencv_ml_DTrees_Instance(r); |  | 71298 | return pyopencv_ml_DTrees_Instance(r);
| 71347 | } |  | 71299 | }
| 71348 | static bool to(PyObject* src, Ptr<cv::ml::DTrees>& dst, const ArgInfo& info) |  | 71300 | static bool to(PyObject* src, Ptr<cv::ml::DTrees>& dst, const ArgInfo& info)
| 71349 | { |  | 71301 | {
| 71350 | if(!src || src == Py_None) |  | 71302 | if(!src || src == Py_None)
| 71351 | return true; |  | 71303 | return true;
| 71352 | Ptr<cv::ml::DTrees> * dst_; |  | 71304 | Ptr<cv::ml::DTrees> * dst_;
| 71353 | if (pyopencv_ml_DTrees_getp(src, dst_)) |  | 71305 | if (pyopencv_ml_DTrees_getp(src, dst_))
| 71354 | { |  | 71306 | {
| 71355 | dst = *dst_; |  | 71307 | dst = *dst_;
| 71356 | return true; |  | 71308 | return true;
| 71357 | } |  | 71309 | }
| 71358 |  |  | 71310 |
| 71359 | failmsg("Expected Ptr<cv::ml::DTrees> for argument '%s'", info.name); |  | 71311 | failmsg("Expected Ptr<cv::ml::DTrees> for argument '%s'", info.name);
| 71360 | return false; |  | 71312 | return false;
| 71361 | } |  | 71313 | }
| 71362 | }; |  | 71314 | };
| 71363 |  |  | 71315 |
| 71364 | //================================================================================ |  | 71316 | //================================================================================
| 71365 | // ml_EM (Generic) |  | 71317 | // ml_EM (Generic)
| 71366 | //================================================================================ |  | 71318 | //================================================================================
| 71367 |  |  | 71319 |
| 71368 | // GetSet (ml_EM) |  | 71320 | // GetSet (ml_EM)
| 71369 |  |  | 71321 |
| 71370 |  |  | 71322 |
| 71371 |  |  | 71323 |
| 71372 | // Methods (ml_EM) |  | 71324 | // Methods (ml_EM)
| 71373 |  |  | 71325 |
| 71374 | static PyObject* pyopencv_cv_ml_ml_EM_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71326 | static PyObject* pyopencv_cv_ml_ml_EM_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 71375 | { |  | 71327 | {
| 71376 | using namespace cv::ml; |  | 71328 | using namespace cv::ml;
| 71377 |  |  | 71329 |
| 71378 | Ptr<EM> retval; |  | 71330 | Ptr<EM> retval;
| 71379 |  |  | 71331 |
| 71380 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71332 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71381 | { |  | 71333 | {
| 71382 | ERRWRAP2(retval = cv::ml::EM::create()); |  | 71334 | ERRWRAP2(retval = cv::ml::EM::create());
| 71383 | return pyopencv_from(retval); |  | 71335 | return pyopencv_from(retval);
| 71384 | } |  | 71336 | }
| 71385 |  |  | 71337 |
| 71386 | return NULL; |  | 71338 | return NULL;
| 71387 | } |  | 71339 | }
| 71388 |  |  | 71340 |
| 71389 | static PyObject* pyopencv_cv_ml_ml_EM_getClustersNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71341 | static PyObject* pyopencv_cv_ml_ml_EM_getClustersNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 71390 | { |  | 71342 | {
| 71391 | using namespace cv::ml; |  | 71343 | using namespace cv::ml;
| 71392 |  |  | 71344 |
| 71393 |  |  | 71345 |
| 71394 | Ptr<cv::ml::EM> * self1 = 0; |  | 71346 | Ptr<cv::ml::EM> * self1 = 0;
| 71395 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71347 | if (!pyopencv_ml_EM_getp(self, self1))
| 71396 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71348 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71397 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71349 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71398 | int retval; |  | 71350 | int retval;
| 71399 |  |  | 71351 |
| 71400 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71352 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71401 | { |  | 71353 | {
| 71402 | ERRWRAP2(retval = _self_->getClustersNumber()); |  | 71354 | ERRWRAP2(retval = _self_->getClustersNumber());
| 71403 | return pyopencv_from(retval); |  | 71355 | return pyopencv_from(retval);
| 71404 | } |  | 71356 | }
| 71405 |  |  | 71357 |
| 71406 | return NULL; |  | 71358 | return NULL;
| 71407 | } |  | 71359 | }
| 71408 |  |  | 71360 |
| 71409 | static PyObject* pyopencv_cv_ml_ml_EM_getCovarianceMatrixType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71361 | static PyObject* pyopencv_cv_ml_ml_EM_getCovarianceMatrixType(PyObject* self, PyObject* py_args, PyObject* kw)
| 71410 | { |  | 71362 | {
| 71411 | using namespace cv::ml; |  | 71363 | using namespace cv::ml;
| 71412 |  |  | 71364 |
| 71413 |  |  | 71365 |
| 71414 | Ptr<cv::ml::EM> * self1 = 0; |  | 71366 | Ptr<cv::ml::EM> * self1 = 0;
| 71415 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71367 | if (!pyopencv_ml_EM_getp(self, self1))
| 71416 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71368 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71417 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71369 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71418 | int retval; |  | 71370 | int retval;
| 71419 |  |  | 71371 |
| 71420 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71372 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71421 | { |  | 71373 | {
| 71422 | ERRWRAP2(retval = _self_->getCovarianceMatrixType()); |  | 71374 | ERRWRAP2(retval = _self_->getCovarianceMatrixType());
| 71423 | return pyopencv_from(retval); |  | 71375 | return pyopencv_from(retval);
| 71424 | } |  | 71376 | }
| 71425 |  |  | 71377 |
| 71426 | return NULL; |  | 71378 | return NULL;
| 71427 | } |  | 71379 | }
| 71428 |  |  | 71380 |
| 71429 | static PyObject* pyopencv_cv_ml_ml_EM_getCovs(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71381 | static PyObject* pyopencv_cv_ml_ml_EM_getCovs(PyObject* self, PyObject* py_args, PyObject* kw)
| 71430 | { |  | 71382 | {
| 71431 | using namespace cv::ml; |  | 71383 | using namespace cv::ml;
| 71432 |  |  | 71384 |
| 71433 |  |  | 71385 |
| 71434 | Ptr<cv::ml::EM> * self1 = 0; |  | 71386 | Ptr<cv::ml::EM> * self1 = 0;
| 71435 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71387 | if (!pyopencv_ml_EM_getp(self, self1))
| 71436 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71388 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71437 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71389 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71438 | PyObject* pyobj_covs = NULL; |  | 71390 | PyObject* pyobj_covs = NULL;
| 71439 | vector_Mat covs; |  | 71391 | vector_Mat covs;
| 71440 |  |  | 71392 |
| 71441 | const char* keywords[] = { "covs", NULL }; |  | 71393 | const char* keywords[] = { "covs", NULL };
| 71442 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:ml_EM.getCovs", (char**)keywords, &pyobj_covs) && |  | 71394 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:ml_EM.getCovs", (char**)keywords, &pyobj_covs) &&
| 71443 | pyopencv_to_safe(pyobj_covs, covs, ArgInfo("covs", 1)) ) |  | 71395 | pyopencv_to_safe(pyobj_covs, covs, ArgInfo("covs", 1)) )
| 71444 | { |  | 71396 | {
| 71445 | ERRWRAP2(_self_->getCovs(covs)); |  | 71397 | ERRWRAP2(_self_->getCovs(covs));
| 71446 | return pyopencv_from(covs); |  | 71398 | return pyopencv_from(covs);
| 71447 | } |  | 71399 | }
| 71448 |  |  | 71400 |
| 71449 | return NULL; |  | 71401 | return NULL;
| 71450 | } |  | 71402 | }
| 71451 |  |  | 71403 |
| 71452 | static PyObject* pyopencv_cv_ml_ml_EM_getMeans(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71404 | static PyObject* pyopencv_cv_ml_ml_EM_getMeans(PyObject* self, PyObject* py_args, PyObject* kw)
| 71453 | { |  | 71405 | {
| 71454 | using namespace cv::ml; |  | 71406 | using namespace cv::ml;
| 71455 |  |  | 71407 |
| 71456 |  |  | 71408 |
| 71457 | Ptr<cv::ml::EM> * self1 = 0; |  | 71409 | Ptr<cv::ml::EM> * self1 = 0;
| 71458 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71410 | if (!pyopencv_ml_EM_getp(self, self1))
| 71459 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71411 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71460 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71412 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71461 | Mat retval; |  | 71413 | Mat retval;
| 71462 |  |  | 71414 |
| 71463 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71415 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71464 | { |  | 71416 | {
| 71465 | ERRWRAP2(retval = _self_->getMeans()); |  | 71417 | ERRWRAP2(retval = _self_->getMeans());
| 71466 | return pyopencv_from(retval); |  | 71418 | return pyopencv_from(retval);
| 71467 | } |  | 71419 | }
| 71468 |  |  | 71420 |
| 71469 | return NULL; |  | 71421 | return NULL;
| 71470 | } |  | 71422 | }
| 71471 |  |  | 71423 |
| 71472 | static PyObject* pyopencv_cv_ml_ml_EM_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71424 | static PyObject* pyopencv_cv_ml_ml_EM_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 71473 | { |  | 71425 | {
| 71474 | using namespace cv::ml; |  | 71426 | using namespace cv::ml;
| 71475 |  |  | 71427 |
| 71476 |  |  | 71428 |
| 71477 | Ptr<cv::ml::EM> * self1 = 0; |  | 71429 | Ptr<cv::ml::EM> * self1 = 0;
| 71478 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71430 | if (!pyopencv_ml_EM_getp(self, self1))
| 71479 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71431 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71480 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71432 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71481 | TermCriteria retval; |  | 71433 | TermCriteria retval;
| 71482 |  |  | 71434 |
| 71483 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71435 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71484 | { |  | 71436 | {
| 71485 | ERRWRAP2(retval = _self_->getTermCriteria()); |  | 71437 | ERRWRAP2(retval = _self_->getTermCriteria());
| 71486 | return pyopencv_from(retval); |  | 71438 | return pyopencv_from(retval);
| 71487 | } |  | 71439 | }
| 71488 |  |  | 71440 |
| 71489 | return NULL; |  | 71441 | return NULL;
| 71490 | } |  | 71442 | }
| 71491 |  |  | 71443 |
| 71492 | static PyObject* pyopencv_cv_ml_ml_EM_getWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71444 | static PyObject* pyopencv_cv_ml_ml_EM_getWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 71493 | { |  | 71445 | {
| 71494 | using namespace cv::ml; |  | 71446 | using namespace cv::ml;
| 71495 |  |  | 71447 |
| 71496 |  |  | 71448 |
| 71497 | Ptr<cv::ml::EM> * self1 = 0; |  | 71449 | Ptr<cv::ml::EM> * self1 = 0;
| 71498 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71450 | if (!pyopencv_ml_EM_getp(self, self1))
| 71499 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71451 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71500 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71452 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71501 | Mat retval; |  | 71453 | Mat retval;
| 71502 |  |  | 71454 |
| 71503 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71455 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 71504 | { |  | 71456 | {
| 71505 | ERRWRAP2(retval = _self_->getWeights()); |  | 71457 | ERRWRAP2(retval = _self_->getWeights());
| 71506 | return pyopencv_from(retval); |  | 71458 | return pyopencv_from(retval);
| 71507 | } |  | 71459 | }
| 71508 |  |  | 71460 |
| 71509 | return NULL; |  | 71461 | return NULL;
| 71510 | } |  | 71462 | }
| 71511 |  |  | 71463 |
| 71512 | static PyObject* pyopencv_cv_ml_ml_EM_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71464 | static PyObject* pyopencv_cv_ml_ml_EM_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 71513 | { |  | 71465 | {
| 71514 | using namespace cv::ml; |  | 71466 | using namespace cv::ml;
| 71515 |  |  | 71467 |
| 71516 | PyObject* pyobj_filepath = NULL; |  | 71468 | PyObject* pyobj_filepath = NULL;
| 71517 | String filepath; |  | 71469 | String filepath;
| 71518 | PyObject* pyobj_nodeName = NULL; |  | 71470 | PyObject* pyobj_nodeName = NULL;
| 71519 | String nodeName; |  | 71471 | String nodeName;
| 71520 | Ptr<EM> retval; |  | 71472 | Ptr<EM> retval;
| 71521 |  |  | 71473 |
| 71522 | const char* keywords[] = { "filepath", "nodeName", NULL }; |  | 71474 | const char* keywords[] = { "filepath", "nodeName", NULL };
| 71523 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_EM.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) && |  | 71475 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_EM.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) &&
| 71524 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) && |  | 71476 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) &&
| 71525 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) ) |  | 71477 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) )
| 71526 | { |  | 71478 | {
| 71527 | ERRWRAP2(retval = cv::ml::EM::load(filepath, nodeName)); |  | 71479 | ERRWRAP2(retval = cv::ml::EM::load(filepath, nodeName));
| 71528 | return pyopencv_from(retval); |  | 71480 | return pyopencv_from(retval);
| 71529 | } |  | 71481 | }
| 71530 |  |  | 71482 |
| 71531 | return NULL; |  | 71483 | return NULL;
| 71532 | } |  | 71484 | }
| 71533 |  |  | 71485 |
| 71534 | static PyObject* pyopencv_cv_ml_ml_EM_predict(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71486 | static PyObject* pyopencv_cv_ml_ml_EM_predict(PyObject* self, PyObject* py_args, PyObject* kw)
| 71535 | { |  | 71487 | {
| 71536 | using namespace cv::ml; |  | 71488 | using namespace cv::ml;
| 71537 |  |  | 71489 |
| 71538 |  |  | 71490 |
| 71539 | Ptr<cv::ml::EM> * self1 = 0; |  | 71491 | Ptr<cv::ml::EM> * self1 = 0;
| 71540 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71492 | if (!pyopencv_ml_EM_getp(self, self1))
| 71541 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71493 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71542 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71494 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71543 | pyPrepareArgumentConversionErrorsStorage(2); |  | 71495 | pyPrepareArgumentConversionErrorsStorage(2);
| 71544 |  |  | 71496 |
| 71545 | { |  | 71497 | {
| 71546 | PyObject* pyobj_samples = NULL; |  | 71498 | PyObject* pyobj_samples = NULL;
| 71547 | Mat samples; |  | 71499 | Mat samples;
| 71548 | PyObject* pyobj_results = NULL; |  | 71500 | PyObject* pyobj_results = NULL;
| 71549 | Mat results; |  | 71501 | Mat results;
| 71550 | PyObject* pyobj_flags = NULL; |  | 71502 | PyObject* pyobj_flags = NULL;
| 71551 | int flags=0; |  | 71503 | int flags=0;
| 71552 | float retval; |  | 71504 | float retval;
| 71553 |  |  | 71505 |
| 71554 | const char* keywords[] = { "samples", "results", "flags", NULL }; |  | 71506 | const char* keywords[] = { "samples", "results", "flags", NULL };
| 71555 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_EM.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) && |  | 71507 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_EM.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) &&
| 71556 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71508 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71557 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 71509 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 71558 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 71510 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 71559 | { |  | 71511 | {
| 71560 | ERRWRAP2(retval = _self_->predict(samples, results, flags)); |  | 71512 | ERRWRAP2(retval = _self_->predict(samples, results, flags));
| 71561 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results)); |  | 71513 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results));
| 71562 | } |  | 71514 | }
| 71563 |  |  | 71515 |
| 71564 |  |  | 71516 |
| 71565 | pyPopulateArgumentConversionErrors(); |  | 71517 | pyPopulateArgumentConversionErrors();
| 71566 | } |  | 71518 | }
| 71567 |  |  | 71519 |
| 71568 |  |  | 71520 |
| 71569 | { |  | 71521 | {
| 71570 | PyObject* pyobj_samples = NULL; |  | 71522 | PyObject* pyobj_samples = NULL;
| 71571 | UMat samples; |  | 71523 | UMat samples;
| 71572 | PyObject* pyobj_results = NULL; |  | 71524 | PyObject* pyobj_results = NULL;
| 71573 | UMat results; |  | 71525 | UMat results;
| 71574 | PyObject* pyobj_flags = NULL; |  | 71526 | PyObject* pyobj_flags = NULL;
| 71575 | int flags=0; |  | 71527 | int flags=0;
| 71576 | float retval; |  | 71528 | float retval;
| 71577 |  |  | 71529 |
| 71578 | const char* keywords[] = { "samples", "results", "flags", NULL }; |  | 71530 | const char* keywords[] = { "samples", "results", "flags", NULL };
| 71579 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_EM.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) && |  | 71531 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_EM.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) &&
| 71580 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71532 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71581 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 71533 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 71582 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 71534 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 71583 | { |  | 71535 | {
| 71584 | ERRWRAP2(retval = _self_->predict(samples, results, flags)); |  | 71536 | ERRWRAP2(retval = _self_->predict(samples, results, flags));
| 71585 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results)); |  | 71537 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results));
| 71586 | } |  | 71538 | }
| 71587 |  |  | 71539 |
| 71588 |  |  | 71540 |
| 71589 | pyPopulateArgumentConversionErrors(); |  | 71541 | pyPopulateArgumentConversionErrors();
| 71590 | } |  | 71542 | }
| 71591 | pyRaiseCVOverloadException("predict"); |  | 71543 | pyRaiseCVOverloadException("predict");
| 71592 |  |  | 71544 |
| 71593 | return NULL; |  | 71545 | return NULL;
| 71594 | } |  | 71546 | }
| 71595 |  |  | 71547 |
| 71596 | static PyObject* pyopencv_cv_ml_ml_EM_predict2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71548 | static PyObject* pyopencv_cv_ml_ml_EM_predict2(PyObject* self, PyObject* py_args, PyObject* kw)
| 71597 | { |  | 71549 | {
| 71598 | using namespace cv::ml; |  | 71550 | using namespace cv::ml;
| 71599 |  |  | 71551 |
| 71600 |  |  | 71552 |
| 71601 | Ptr<cv::ml::EM> * self1 = 0; |  | 71553 | Ptr<cv::ml::EM> * self1 = 0;
| 71602 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71554 | if (!pyopencv_ml_EM_getp(self, self1))
| 71603 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71555 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71604 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71556 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71605 | pyPrepareArgumentConversionErrorsStorage(2); |  | 71557 | pyPrepareArgumentConversionErrorsStorage(2);
| 71606 |  |  | 71558 |
| 71607 | { |  | 71559 | {
| 71608 | PyObject* pyobj_sample = NULL; |  | 71560 | PyObject* pyobj_sample = NULL;
| 71609 | Mat sample; |  | 71561 | Mat sample;
| 71610 | PyObject* pyobj_probs = NULL; |  | 71562 | PyObject* pyobj_probs = NULL;
| 71611 | Mat probs; |  | 71563 | Mat probs;
| 71612 | Vec2d retval; |  | 71564 | Vec2d retval;
| 71613 |  |  | 71565 |
| 71614 | const char* keywords[] = { "sample", "probs", NULL }; |  | 71566 | const char* keywords[] = { "sample", "probs", NULL };
| 71615 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_EM.predict2", (char**)keywords, &pyobj_sample, &pyobj_probs) && |  | 71567 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_EM.predict2", (char**)keywords, &pyobj_sample, &pyobj_probs) &&
| 71616 | pyopencv_to_safe(pyobj_sample, sample, ArgInfo("sample", 0)) && |  | 71568 | pyopencv_to_safe(pyobj_sample, sample, ArgInfo("sample", 0)) &&
| 71617 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71569 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71618 | { |  | 71570 | {
| 71619 | ERRWRAP2(retval = _self_->predict2(sample, probs)); |  | 71571 | ERRWRAP2(retval = _self_->predict2(sample, probs));
| 71620 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(probs)); |  | 71572 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(probs));
| 71621 | } |  | 71573 | }
| 71622 |  |  | 71574 |
| 71623 |  |  | 71575 |
| 71624 | pyPopulateArgumentConversionErrors(); |  | 71576 | pyPopulateArgumentConversionErrors();
| 71625 | } |  | 71577 | }
| 71626 |  |  | 71578 |
| 71627 |  |  | 71579 |
| 71628 | { |  | 71580 | {
| 71629 | PyObject* pyobj_sample = NULL; |  | 71581 | PyObject* pyobj_sample = NULL;
| 71630 | UMat sample; |  | 71582 | UMat sample;
| 71631 | PyObject* pyobj_probs = NULL; |  | 71583 | PyObject* pyobj_probs = NULL;
| 71632 | UMat probs; |  | 71584 | UMat probs;
| 71633 | Vec2d retval; |  | 71585 | Vec2d retval;
| 71634 |  |  | 71586 |
| 71635 | const char* keywords[] = { "sample", "probs", NULL }; |  | 71587 | const char* keywords[] = { "sample", "probs", NULL };
| 71636 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_EM.predict2", (char**)keywords, &pyobj_sample, &pyobj_probs) && |  | 71588 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_EM.predict2", (char**)keywords, &pyobj_sample, &pyobj_probs) &&
| 71637 | pyopencv_to_safe(pyobj_sample, sample, ArgInfo("sample", 0)) && |  | 71589 | pyopencv_to_safe(pyobj_sample, sample, ArgInfo("sample", 0)) &&
| 71638 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71590 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71639 | { |  | 71591 | {
| 71640 | ERRWRAP2(retval = _self_->predict2(sample, probs)); |  | 71592 | ERRWRAP2(retval = _self_->predict2(sample, probs));
| 71641 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(probs)); |  | 71593 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(probs));
| 71642 | } |  | 71594 | }
| 71643 |  |  | 71595 |
| 71644 |  |  | 71596 |
| 71645 | pyPopulateArgumentConversionErrors(); |  | 71597 | pyPopulateArgumentConversionErrors();
| 71646 | } |  | 71598 | }
| 71647 | pyRaiseCVOverloadException("predict2"); |  | 71599 | pyRaiseCVOverloadException("predict2");
| 71648 |  |  | 71600 |
| 71649 | return NULL; |  | 71601 | return NULL;
| 71650 | } |  | 71602 | }
| 71651 |  |  | 71603 |
| 71652 | static PyObject* pyopencv_cv_ml_ml_EM_setClustersNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71604 | static PyObject* pyopencv_cv_ml_ml_EM_setClustersNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 71653 | { |  | 71605 | {
| 71654 | using namespace cv::ml; |  | 71606 | using namespace cv::ml;
| 71655 |  |  | 71607 |
| 71656 |  |  | 71608 |
| 71657 | Ptr<cv::ml::EM> * self1 = 0; |  | 71609 | Ptr<cv::ml::EM> * self1 = 0;
| 71658 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71610 | if (!pyopencv_ml_EM_getp(self, self1))
| 71659 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71611 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71660 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71612 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71661 | PyObject* pyobj_val = NULL; |  | 71613 | PyObject* pyobj_val = NULL;
| 71662 | int val=0; |  | 71614 | int val=0;
| 71663 |  |  | 71615 |
| 71664 | const char* keywords[] = { "val", NULL }; |  | 71616 | const char* keywords[] = { "val", NULL };
| 71665 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_EM.setClustersNumber", (char**)keywords, &pyobj_val) && |  | 71617 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_EM.setClustersNumber", (char**)keywords, &pyobj_val) &&
| 71666 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71618 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71667 | { |  | 71619 | {
| 71668 | ERRWRAP2(_self_->setClustersNumber(val)); |  | 71620 | ERRWRAP2(_self_->setClustersNumber(val));
| 71669 | Py_RETURN_NONE; |  | 71621 | Py_RETURN_NONE;
| 71670 | } |  | 71622 | }
| 71671 |  |  | 71623 |
| 71672 | return NULL; |  | 71624 | return NULL;
| 71673 | } |  | 71625 | }
| 71674 |  |  | 71626 |
| 71675 | static PyObject* pyopencv_cv_ml_ml_EM_setCovarianceMatrixType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71627 | static PyObject* pyopencv_cv_ml_ml_EM_setCovarianceMatrixType(PyObject* self, PyObject* py_args, PyObject* kw)
| 71676 | { |  | 71628 | {
| 71677 | using namespace cv::ml; |  | 71629 | using namespace cv::ml;
| 71678 |  |  | 71630 |
| 71679 |  |  | 71631 |
| 71680 | Ptr<cv::ml::EM> * self1 = 0; |  | 71632 | Ptr<cv::ml::EM> * self1 = 0;
| 71681 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71633 | if (!pyopencv_ml_EM_getp(self, self1))
| 71682 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71634 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71683 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71635 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71684 | PyObject* pyobj_val = NULL; |  | 71636 | PyObject* pyobj_val = NULL;
| 71685 | int val=0; |  | 71637 | int val=0;
| 71686 |  |  | 71638 |
| 71687 | const char* keywords[] = { "val", NULL }; |  | 71639 | const char* keywords[] = { "val", NULL };
| 71688 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_EM.setCovarianceMatrixType", (char**)keywords, &pyobj_val) && |  | 71640 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_EM.setCovarianceMatrixType", (char**)keywords, &pyobj_val) &&
| 71689 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71641 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71690 | { |  | 71642 | {
| 71691 | ERRWRAP2(_self_->setCovarianceMatrixType(val)); |  | 71643 | ERRWRAP2(_self_->setCovarianceMatrixType(val));
| 71692 | Py_RETURN_NONE; |  | 71644 | Py_RETURN_NONE;
| 71693 | } |  | 71645 | }
| 71694 |  |  | 71646 |
| 71695 | return NULL; |  | 71647 | return NULL;
| 71696 | } |  | 71648 | }
| 71697 |  |  | 71649 |
| 71698 | static PyObject* pyopencv_cv_ml_ml_EM_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71650 | static PyObject* pyopencv_cv_ml_ml_EM_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 71699 | { |  | 71651 | {
| 71700 | using namespace cv::ml; |  | 71652 | using namespace cv::ml;
| 71701 |  |  | 71653 |
| 71702 |  |  | 71654 |
| 71703 | Ptr<cv::ml::EM> * self1 = 0; |  | 71655 | Ptr<cv::ml::EM> * self1 = 0;
| 71704 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71656 | if (!pyopencv_ml_EM_getp(self, self1))
| 71705 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71657 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71706 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71658 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71707 | PyObject* pyobj_val = NULL; |  | 71659 | PyObject* pyobj_val = NULL;
| 71708 | TermCriteria val; |  | 71660 | TermCriteria val;
| 71709 |  |  | 71661 |
| 71710 | const char* keywords[] = { "val", NULL }; |  | 71662 | const char* keywords[] = { "val", NULL };
| 71711 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_EM.setTermCriteria", (char**)keywords, &pyobj_val) && |  | 71663 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_EM.setTermCriteria", (char**)keywords, &pyobj_val) &&
| 71712 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 71664 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 71713 | { |  | 71665 | {
| 71714 | ERRWRAP2(_self_->setTermCriteria(val)); |  | 71666 | ERRWRAP2(_self_->setTermCriteria(val));
| 71715 | Py_RETURN_NONE; |  | 71667 | Py_RETURN_NONE;
| 71716 | } |  | 71668 | }
| 71717 |  |  | 71669 |
| 71718 | return NULL; |  | 71670 | return NULL;
| 71719 | } |  | 71671 | }
| 71720 |  |  | 71672 |
| 71721 | static PyObject* pyopencv_cv_ml_ml_EM_trainE(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71673 | static PyObject* pyopencv_cv_ml_ml_EM_trainE(PyObject* self, PyObject* py_args, PyObject* kw)
| 71722 | { |  | 71674 | {
| 71723 | using namespace cv::ml; |  | 71675 | using namespace cv::ml;
| 71724 |  |  | 71676 |
| 71725 |  |  | 71677 |
| 71726 | Ptr<cv::ml::EM> * self1 = 0; |  | 71678 | Ptr<cv::ml::EM> * self1 = 0;
| 71727 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71679 | if (!pyopencv_ml_EM_getp(self, self1))
| 71728 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71680 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71729 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71681 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71730 | pyPrepareArgumentConversionErrorsStorage(2); |  | 71682 | pyPrepareArgumentConversionErrorsStorage(2);
| 71731 |  |  | 71683 |
| 71732 | { |  | 71684 | {
| 71733 | PyObject* pyobj_samples = NULL; |  | 71685 | PyObject* pyobj_samples = NULL;
| 71734 | Mat samples; |  | 71686 | Mat samples;
| 71735 | PyObject* pyobj_means0 = NULL; |  | 71687 | PyObject* pyobj_means0 = NULL;
| 71736 | Mat means0; |  | 71688 | Mat means0;
| 71737 | PyObject* pyobj_covs0 = NULL; |  | 71689 | PyObject* pyobj_covs0 = NULL;
| 71738 | Mat covs0; |  | 71690 | Mat covs0;
| 71739 | PyObject* pyobj_weights0 = NULL; |  | 71691 | PyObject* pyobj_weights0 = NULL;
| 71740 | Mat weights0; |  | 71692 | Mat weights0;
| 71741 | PyObject* pyobj_logLikelihoods = NULL; |  | 71693 | PyObject* pyobj_logLikelihoods = NULL;
| 71742 | Mat logLikelihoods; |  | 71694 | Mat logLikelihoods;
| 71743 | PyObject* pyobj_labels = NULL; |  | 71695 | PyObject* pyobj_labels = NULL;
| 71744 | Mat labels; |  | 71696 | Mat labels;
| 71745 | PyObject* pyobj_probs = NULL; |  | 71697 | PyObject* pyobj_probs = NULL;
| 71746 | Mat probs; |  | 71698 | Mat probs;
| 71747 | bool retval; |  | 71699 | bool retval;
| 71748 |  |  | 71700 |
| 71749 | const char* keywords[] = { "samples", "means0", "covs0", "weights0", "logLikelihoods", "labels", "probs", NULL }; |  | 71701 | const char* keywords[] = { "samples", "means0", "covs0", "weights0", "logLikelihoods", "labels", "probs", NULL };
| 71750 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOOO:ml_EM.trainE", (char**)keywords, &pyobj_samples, &pyobj_means0, &pyobj_covs0, &pyobj_weights0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) && |  | 71702 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOOO:ml_EM.trainE", (char**)keywords, &pyobj_samples, &pyobj_means0, &pyobj_covs0, &pyobj_weights0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) &&
| 71751 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71703 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71752 | pyopencv_to_safe(pyobj_means0, means0, ArgInfo("means0", 0)) && |  | 71704 | pyopencv_to_safe(pyobj_means0, means0, ArgInfo("means0", 0)) &&
| 71753 | pyopencv_to_safe(pyobj_covs0, covs0, ArgInfo("covs0", 0)) && |  | 71705 | pyopencv_to_safe(pyobj_covs0, covs0, ArgInfo("covs0", 0)) &&
| 71754 | pyopencv_to_safe(pyobj_weights0, weights0, ArgInfo("weights0", 0)) && |  | 71706 | pyopencv_to_safe(pyobj_weights0, weights0, ArgInfo("weights0", 0)) &&
| 71755 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) && |  | 71707 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) &&
| 71756 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) && |  | 71708 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) &&
| 71757 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71709 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71758 | { |  | 71710 | {
| 71759 | ERRWRAP2(retval = _self_->trainE(samples, means0, covs0, weights0, logLikelihoods, labels, probs)); |  | 71711 | ERRWRAP2(retval = _self_->trainE(samples, means0, covs0, weights0, logLikelihoods, labels, probs));
| 71760 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs)); |  | 71712 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs));
| 71761 | } |  | 71713 | }
| 71762 |  |  | 71714 |
| 71763 |  |  | 71715 |
| 71764 | pyPopulateArgumentConversionErrors(); |  | 71716 | pyPopulateArgumentConversionErrors();
| 71765 | } |  | 71717 | }
| 71766 |  |  | 71718 |
| 71767 |  |  | 71719 |
| 71768 | { |  | 71720 | {
| 71769 | PyObject* pyobj_samples = NULL; |  | 71721 | PyObject* pyobj_samples = NULL;
| 71770 | UMat samples; |  | 71722 | UMat samples;
| 71771 | PyObject* pyobj_means0 = NULL; |  | 71723 | PyObject* pyobj_means0 = NULL;
| 71772 | UMat means0; |  | 71724 | UMat means0;
| 71773 | PyObject* pyobj_covs0 = NULL; |  | 71725 | PyObject* pyobj_covs0 = NULL;
| 71774 | UMat covs0; |  | 71726 | UMat covs0;
| 71775 | PyObject* pyobj_weights0 = NULL; |  | 71727 | PyObject* pyobj_weights0 = NULL;
| 71776 | UMat weights0; |  | 71728 | UMat weights0;
| 71777 | PyObject* pyobj_logLikelihoods = NULL; |  | 71729 | PyObject* pyobj_logLikelihoods = NULL;
| 71778 | UMat logLikelihoods; |  | 71730 | UMat logLikelihoods;
| 71779 | PyObject* pyobj_labels = NULL; |  | 71731 | PyObject* pyobj_labels = NULL;
| 71780 | UMat labels; |  | 71732 | UMat labels;
| 71781 | PyObject* pyobj_probs = NULL; |  | 71733 | PyObject* pyobj_probs = NULL;
| 71782 | UMat probs; |  | 71734 | UMat probs;
| 71783 | bool retval; |  | 71735 | bool retval;
| 71784 |  |  | 71736 |
| 71785 | const char* keywords[] = { "samples", "means0", "covs0", "weights0", "logLikelihoods", "labels", "probs", NULL }; |  | 71737 | const char* keywords[] = { "samples", "means0", "covs0", "weights0", "logLikelihoods", "labels", "probs", NULL };
| 71786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOOO:ml_EM.trainE", (char**)keywords, &pyobj_samples, &pyobj_means0, &pyobj_covs0, &pyobj_weights0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) && |  | 71738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOOOO:ml_EM.trainE", (char**)keywords, &pyobj_samples, &pyobj_means0, &pyobj_covs0, &pyobj_weights0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) &&
| 71787 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71739 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71788 | pyopencv_to_safe(pyobj_means0, means0, ArgInfo("means0", 0)) && |  | 71740 | pyopencv_to_safe(pyobj_means0, means0, ArgInfo("means0", 0)) &&
| 71789 | pyopencv_to_safe(pyobj_covs0, covs0, ArgInfo("covs0", 0)) && |  | 71741 | pyopencv_to_safe(pyobj_covs0, covs0, ArgInfo("covs0", 0)) &&
| 71790 | pyopencv_to_safe(pyobj_weights0, weights0, ArgInfo("weights0", 0)) && |  | 71742 | pyopencv_to_safe(pyobj_weights0, weights0, ArgInfo("weights0", 0)) &&
| 71791 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) && |  | 71743 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) &&
| 71792 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) && |  | 71744 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) &&
| 71793 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71745 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71794 | { |  | 71746 | {
| 71795 | ERRWRAP2(retval = _self_->trainE(samples, means0, covs0, weights0, logLikelihoods, labels, probs)); |  | 71747 | ERRWRAP2(retval = _self_->trainE(samples, means0, covs0, weights0, logLikelihoods, labels, probs));
| 71796 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs)); |  | 71748 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs));
| 71797 | } |  | 71749 | }
| 71798 |  |  | 71750 |
| 71799 |  |  | 71751 |
| 71800 | pyPopulateArgumentConversionErrors(); |  | 71752 | pyPopulateArgumentConversionErrors();
| 71801 | } |  | 71753 | }
| 71802 | pyRaiseCVOverloadException("trainE"); |  | 71754 | pyRaiseCVOverloadException("trainE");
| 71803 |  |  | 71755 |
| 71804 | return NULL; |  | 71756 | return NULL;
| 71805 | } |  | 71757 | }
| 71806 |  |  | 71758 |
| 71807 | static PyObject* pyopencv_cv_ml_ml_EM_trainEM(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71759 | static PyObject* pyopencv_cv_ml_ml_EM_trainEM(PyObject* self, PyObject* py_args, PyObject* kw)
| 71808 | { |  | 71760 | {
| 71809 | using namespace cv::ml; |  | 71761 | using namespace cv::ml;
| 71810 |  |  | 71762 |
| 71811 |  |  | 71763 |
| 71812 | Ptr<cv::ml::EM> * self1 = 0; |  | 71764 | Ptr<cv::ml::EM> * self1 = 0;
| 71813 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71765 | if (!pyopencv_ml_EM_getp(self, self1))
| 71814 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71766 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71815 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71767 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71816 | pyPrepareArgumentConversionErrorsStorage(2); |  | 71768 | pyPrepareArgumentConversionErrorsStorage(2);
| 71817 |  |  | 71769 |
| 71818 | { |  | 71770 | {
| 71819 | PyObject* pyobj_samples = NULL; |  | 71771 | PyObject* pyobj_samples = NULL;
| 71820 | Mat samples; |  | 71772 | Mat samples;
| 71821 | PyObject* pyobj_logLikelihoods = NULL; |  | 71773 | PyObject* pyobj_logLikelihoods = NULL;
| 71822 | Mat logLikelihoods; |  | 71774 | Mat logLikelihoods;
| 71823 | PyObject* pyobj_labels = NULL; |  | 71775 | PyObject* pyobj_labels = NULL;
| 71824 | Mat labels; |  | 71776 | Mat labels;
| 71825 | PyObject* pyobj_probs = NULL; |  | 71777 | PyObject* pyobj_probs = NULL;
| 71826 | Mat probs; |  | 71778 | Mat probs;
| 71827 | bool retval; |  | 71779 | bool retval;
| 71828 |  |  | 71780 |
| 71829 | const char* keywords[] = { "samples", "logLikelihoods", "labels", "probs", NULL }; |  | 71781 | const char* keywords[] = { "samples", "logLikelihoods", "labels", "probs", NULL };
| 71830 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_EM.trainEM", (char**)keywords, &pyobj_samples, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) && |  | 71782 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_EM.trainEM", (char**)keywords, &pyobj_samples, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) &&
| 71831 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71783 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71832 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) && |  | 71784 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) &&
| 71833 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) && |  | 71785 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) &&
| 71834 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71786 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71835 | { |  | 71787 | {
| 71836 | ERRWRAP2(retval = _self_->trainEM(samples, logLikelihoods, labels, probs)); |  | 71788 | ERRWRAP2(retval = _self_->trainEM(samples, logLikelihoods, labels, probs));
| 71837 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs)); |  | 71789 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs));
| 71838 | } |  | 71790 | }
| 71839 |  |  | 71791 |
| 71840 |  |  | 71792 |
| 71841 | pyPopulateArgumentConversionErrors(); |  | 71793 | pyPopulateArgumentConversionErrors();
| 71842 | } |  | 71794 | }
| 71843 |  |  | 71795 |
| 71844 |  |  | 71796 |
| 71845 | { |  | 71797 | {
| 71846 | PyObject* pyobj_samples = NULL; |  | 71798 | PyObject* pyobj_samples = NULL;
| 71847 | UMat samples; |  | 71799 | UMat samples;
| 71848 | PyObject* pyobj_logLikelihoods = NULL; |  | 71800 | PyObject* pyobj_logLikelihoods = NULL;
| 71849 | UMat logLikelihoods; |  | 71801 | UMat logLikelihoods;
| 71850 | PyObject* pyobj_labels = NULL; |  | 71802 | PyObject* pyobj_labels = NULL;
| 71851 | UMat labels; |  | 71803 | UMat labels;
| 71852 | PyObject* pyobj_probs = NULL; |  | 71804 | PyObject* pyobj_probs = NULL;
| 71853 | UMat probs; |  | 71805 | UMat probs;
| 71854 | bool retval; |  | 71806 | bool retval;
| 71855 |  |  | 71807 |
| 71856 | const char* keywords[] = { "samples", "logLikelihoods", "labels", "probs", NULL }; |  | 71808 | const char* keywords[] = { "samples", "logLikelihoods", "labels", "probs", NULL };
| 71857 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_EM.trainEM", (char**)keywords, &pyobj_samples, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) && |  | 71809 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_EM.trainEM", (char**)keywords, &pyobj_samples, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) &&
| 71858 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71810 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71859 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) && |  | 71811 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) &&
| 71860 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) && |  | 71812 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) &&
| 71861 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71813 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71862 | { |  | 71814 | {
| 71863 | ERRWRAP2(retval = _self_->trainEM(samples, logLikelihoods, labels, probs)); |  | 71815 | ERRWRAP2(retval = _self_->trainEM(samples, logLikelihoods, labels, probs));
| 71864 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs)); |  | 71816 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs));
| 71865 | } |  | 71817 | }
| 71866 |  |  | 71818 |
| 71867 |  |  | 71819 |
| 71868 | pyPopulateArgumentConversionErrors(); |  | 71820 | pyPopulateArgumentConversionErrors();
| 71869 | } |  | 71821 | }
| 71870 | pyRaiseCVOverloadException("trainEM"); |  | 71822 | pyRaiseCVOverloadException("trainEM");
| 71871 |  |  | 71823 |
| 71872 | return NULL; |  | 71824 | return NULL;
| 71873 | } |  | 71825 | }
| 71874 |  |  | 71826 |
| 71875 | static PyObject* pyopencv_cv_ml_ml_EM_trainM(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71827 | static PyObject* pyopencv_cv_ml_ml_EM_trainM(PyObject* self, PyObject* py_args, PyObject* kw)
| 71876 | { |  | 71828 | {
| 71877 | using namespace cv::ml; |  | 71829 | using namespace cv::ml;
| 71878 |  |  | 71830 |
| 71879 |  |  | 71831 |
| 71880 | Ptr<cv::ml::EM> * self1 = 0; |  | 71832 | Ptr<cv::ml::EM> * self1 = 0;
| 71881 | if (!pyopencv_ml_EM_getp(self, self1)) |  | 71833 | if (!pyopencv_ml_EM_getp(self, self1))
| 71882 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)"); |  | 71834 | return failmsgp("Incorrect type of self (must be 'ml_EM' or its derivative)");
| 71883 | Ptr<cv::ml::EM> _self_ = *(self1); |  | 71835 | Ptr<cv::ml::EM> _self_ = *(self1);
| 71884 | pyPrepareArgumentConversionErrorsStorage(2); |  | 71836 | pyPrepareArgumentConversionErrorsStorage(2);
| 71885 |  |  | 71837 |
| 71886 | { |  | 71838 | {
| 71887 | PyObject* pyobj_samples = NULL; |  | 71839 | PyObject* pyobj_samples = NULL;
| 71888 | Mat samples; |  | 71840 | Mat samples;
| 71889 | PyObject* pyobj_probs0 = NULL; |  | 71841 | PyObject* pyobj_probs0 = NULL;
| 71890 | Mat probs0; |  | 71842 | Mat probs0;
| 71891 | PyObject* pyobj_logLikelihoods = NULL; |  | 71843 | PyObject* pyobj_logLikelihoods = NULL;
| 71892 | Mat logLikelihoods; |  | 71844 | Mat logLikelihoods;
| 71893 | PyObject* pyobj_labels = NULL; |  | 71845 | PyObject* pyobj_labels = NULL;
| 71894 | Mat labels; |  | 71846 | Mat labels;
| 71895 | PyObject* pyobj_probs = NULL; |  | 71847 | PyObject* pyobj_probs = NULL;
| 71896 | Mat probs; |  | 71848 | Mat probs;
| 71897 | bool retval; |  | 71849 | bool retval;
| 71898 |  |  | 71850 |
| 71899 | const char* keywords[] = { "samples", "probs0", "logLikelihoods", "labels", "probs", NULL }; |  | 71851 | const char* keywords[] = { "samples", "probs0", "logLikelihoods", "labels", "probs", NULL };
| 71900 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_EM.trainM", (char**)keywords, &pyobj_samples, &pyobj_probs0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) && |  | 71852 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_EM.trainM", (char**)keywords, &pyobj_samples, &pyobj_probs0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) &&
| 71901 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71853 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71902 | pyopencv_to_safe(pyobj_probs0, probs0, ArgInfo("probs0", 0)) && |  | 71854 | pyopencv_to_safe(pyobj_probs0, probs0, ArgInfo("probs0", 0)) &&
| 71903 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) && |  | 71855 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) &&
| 71904 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) && |  | 71856 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) &&
| 71905 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71857 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71906 | { |  | 71858 | {
| 71907 | ERRWRAP2(retval = _self_->trainM(samples, probs0, logLikelihoods, labels, probs)); |  | 71859 | ERRWRAP2(retval = _self_->trainM(samples, probs0, logLikelihoods, labels, probs));
| 71908 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs)); |  | 71860 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs));
| 71909 | } |  | 71861 | }
| 71910 |  |  | 71862 |
| 71911 |  |  | 71863 |
| 71912 | pyPopulateArgumentConversionErrors(); |  | 71864 | pyPopulateArgumentConversionErrors();
| 71913 | } |  | 71865 | }
| 71914 |  |  | 71866 |
| 71915 |  |  | 71867 |
| 71916 | { |  | 71868 | {
| 71917 | PyObject* pyobj_samples = NULL; |  | 71869 | PyObject* pyobj_samples = NULL;
| 71918 | UMat samples; |  | 71870 | UMat samples;
| 71919 | PyObject* pyobj_probs0 = NULL; |  | 71871 | PyObject* pyobj_probs0 = NULL;
| 71920 | UMat probs0; |  | 71872 | UMat probs0;
| 71921 | PyObject* pyobj_logLikelihoods = NULL; |  | 71873 | PyObject* pyobj_logLikelihoods = NULL;
| 71922 | UMat logLikelihoods; |  | 71874 | UMat logLikelihoods;
| 71923 | PyObject* pyobj_labels = NULL; |  | 71875 | PyObject* pyobj_labels = NULL;
| 71924 | UMat labels; |  | 71876 | UMat labels;
| 71925 | PyObject* pyobj_probs = NULL; |  | 71877 | PyObject* pyobj_probs = NULL;
| 71926 | UMat probs; |  | 71878 | UMat probs;
| 71927 | bool retval; |  | 71879 | bool retval;
| 71928 |  |  | 71880 |
| 71929 | const char* keywords[] = { "samples", "probs0", "logLikelihoods", "labels", "probs", NULL }; |  | 71881 | const char* keywords[] = { "samples", "probs0", "logLikelihoods", "labels", "probs", NULL };
| 71930 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_EM.trainM", (char**)keywords, &pyobj_samples, &pyobj_probs0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) && |  | 71882 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_EM.trainM", (char**)keywords, &pyobj_samples, &pyobj_probs0, &pyobj_logLikelihoods, &pyobj_labels, &pyobj_probs) &&
| 71931 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 71883 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 71932 | pyopencv_to_safe(pyobj_probs0, probs0, ArgInfo("probs0", 0)) && |  | 71884 | pyopencv_to_safe(pyobj_probs0, probs0, ArgInfo("probs0", 0)) &&
| 71933 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) && |  | 71885 | pyopencv_to_safe(pyobj_logLikelihoods, logLikelihoods, ArgInfo("logLikelihoods", 1)) &&
| 71934 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) && |  | 71886 | pyopencv_to_safe(pyobj_labels, labels, ArgInfo("labels", 1)) &&
| 71935 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) ) |  | 71887 | pyopencv_to_safe(pyobj_probs, probs, ArgInfo("probs", 1)) )
| 71936 | { |  | 71888 | {
| 71937 | ERRWRAP2(retval = _self_->trainM(samples, probs0, logLikelihoods, labels, probs)); |  | 71889 | ERRWRAP2(retval = _self_->trainM(samples, probs0, logLikelihoods, labels, probs));
| 71938 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs)); |  | 71890 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(logLikelihoods), pyopencv_from(labels), pyopencv_from(probs));
| 71939 | } |  | 71891 | }
| 71940 |  |  | 71892 |
| 71941 |  |  | 71893 |
| 71942 | pyPopulateArgumentConversionErrors(); |  | 71894 | pyPopulateArgumentConversionErrors();
| 71943 | } |  | 71895 | }
| 71944 | pyRaiseCVOverloadException("trainM"); |  | 71896 | pyRaiseCVOverloadException("trainM");
| 71945 |  |  | 71897 |
| 71946 | return NULL; |  | 71898 | return NULL;
| 71947 | } |  | 71899 | }
| 71948 |  |  | 71900 |
| 71949 |  |  | 71901 |
| 71950 |  |  | 71902 |
| 71951 | // Tables (ml_EM) |  | 71903 | // Tables (ml_EM)
| 71952 |  |  | 71904 |
| 71953 | static PyGetSetDef pyopencv_ml_EM_getseters[] = |  | 71905 | static PyGetSetDef pyopencv_ml_EM_getseters[] =
| 71954 | { |  | 71906 | {
| 71955 | {NULL} /* Sentinel */ |  | 71907 | {NULL} /* Sentinel */
| 71956 | }; |  | 71908 | };
| 71957 |  |  | 71909 |
| 71958 | static PyMethodDef pyopencv_ml_EM_methods[] = |  | 71910 | static PyMethodDef pyopencv_ml_EM_methods[] =
| 71959 | { |  | 71911 | {
| 71960 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_create_static, METH_STATIC), "create() -> retval\n. Creates empty %EM model.\n. The model should be trained then using StatModel::train(traindata, flags) method. Alternatively, you\n. can use one of the EM::train\\* methods or load it from file using Algorithm::load\\<EM\\>(filename)."}, |  | 71912 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_create_static, METH_STATIC), "create() -> retval\n. Creates empty %EM model.\n. The model should be trained then using StatModel::train(traindata, flags) method. Alternatively, you\n. can use one of the EM::train\\* methods or load it from file using Algorithm::load\\<EM\\>(filename)."},
| 71961 | {"getClustersNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getClustersNumber, 0), "getClustersNumber() -> retval\n. @see setClustersNumber"}, |  | 71913 | {"getClustersNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getClustersNumber, 0), "getClustersNumber() -> retval\n. @see setClustersNumber"},
| 71962 | {"getCovarianceMatrixType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getCovarianceMatrixType, 0), "getCovarianceMatrixType() -> retval\n. @see setCovarianceMatrixType"}, |  | 71914 | {"getCovarianceMatrixType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getCovarianceMatrixType, 0), "getCovarianceMatrixType() -> retval\n. @see setCovarianceMatrixType"},
| 71963 | {"getCovs", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getCovs, 0), "getCovs([, covs]) -> covs\n. @brief Returns covariation matrices\n. \n. Returns vector of covariation matrices. Number of matrices is the number of gaussian mixtures,\n. each matrix is a square floating-point matrix NxN, where N is the space dimensionality."}, |  | 71915 | {"getCovs", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getCovs, 0), "getCovs([, covs]) -> covs\n. @brief Returns covariation matrices\n. \n. Returns vector of covariation matrices. Number of matrices is the number of gaussian mixtures,\n. each matrix is a square floating-point matrix NxN, where N is the space dimensionality."},
| 71964 | {"getMeans", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getMeans, 0), "getMeans() -> retval\n. @brief Returns the cluster centers (means of the Gaussian mixture)\n. \n. Returns matrix with the number of rows equal to the number of mixtures and number of columns\n. equal to the space dimensionality."}, |  | 71916 | {"getMeans", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getMeans, 0), "getMeans() -> retval\n. @brief Returns the cluster centers (means of the Gaussian mixture)\n. \n. Returns matrix with the number of rows equal to the number of mixtures and number of columns\n. equal to the space dimensionality."},
| 71965 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"}, |  | 71917 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"},
| 71966 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getWeights, 0), "getWeights() -> retval\n. @brief Returns weights of the mixtures\n. \n. Returns vector with the number of elements equal to the number of mixtures."}, |  | 71918 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_getWeights, 0), "getWeights() -> retval\n. @brief Returns weights of the mixtures\n. \n. Returns vector with the number of elements equal to the number of mixtures."},
| 71967 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized EM from a file\n. *\n. * Use EM::save to serialize and store an EM to disk.\n. * Load the EM from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized EM\n. * @param nodeName name of node containing the classifier"}, |  | 71919 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized EM from a file\n. *\n. * Use EM::save to serialize and store an EM to disk.\n. * Load the EM from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized EM\n. * @param nodeName name of node containing the classifier"},
| 71968 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_predict, 0), "predict(samples[, results[, flags]]) -> retval, results\n. @brief Returns posterior probabilities for the provided samples\n. \n. @param samples The input samples, floating-point matrix\n. @param results The optional output \\f$ nSamples \\times nClusters\\f$ matrix of results. It contains\n. posterior probabilities for each sample from the input\n. @param flags This parameter will be ignored"}, |  | 71920 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_predict, 0), "predict(samples[, results[, flags]]) -> retval, results\n. @brief Returns posterior probabilities for the provided samples\n. \n. @param samples The input samples, floating-point matrix\n. @param results The optional output \\f$ nSamples \\times nClusters\\f$ matrix of results. It contains\n. posterior probabilities for each sample from the input\n. @param flags This parameter will be ignored"},
| 71969 | {"predict2", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_predict2, 0), "predict2(sample[, probs]) -> retval, probs\n. @brief Returns a likelihood logarithm value and an index of the most probable mixture component\n. for the given sample.\n. \n. @param sample A sample for classification. It should be a one-channel matrix of\n. \\f$1 \\times dims\\f$ or \\f$dims \\times 1\\f$ size.\n. @param probs Optional output matrix that contains posterior probabilities of each component\n. given the sample. It has \\f$1 \\times nclusters\\f$ size and CV_64FC1 type.\n. \n. The method returns a two-element double vector. Zero element is a likelihood logarithm value for\n. the sample. First element is an index of the most probable mixture component for the given\n. sample."}, |  | 71921 | {"predict2", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_predict2, 0), "predict2(sample[, probs]) -> retval, probs\n. @brief Returns a likelihood logarithm value and an index of the most probable mixture component\n. for the given sample.\n. \n. @param sample A sample for classification. It should be a one-channel matrix of\n. \\f$1 \\times dims\\f$ or \\f$dims \\times 1\\f$ size.\n. @param probs Optional output matrix that contains posterior probabilities of each component\n. given the sample. It has \\f$1 \\times nclusters\\f$ size and CV_64FC1 type.\n. \n. The method returns a two-element double vector. Zero element is a likelihood logarithm value for\n. the sample. First element is an index of the most probable mixture component for the given\n. sample."},
| 71970 | {"setClustersNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_setClustersNumber, 0), "setClustersNumber(val) -> None\n. @copybrief getClustersNumber @see getClustersNumber"}, |  | 71922 | {"setClustersNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_setClustersNumber, 0), "setClustersNumber(val) -> None\n. @copybrief getClustersNumber @see getClustersNumber"},
| 71971 | {"setCovarianceMatrixType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_setCovarianceMatrixType, 0), "setCovarianceMatrixType(val) -> None\n. @copybrief getCovarianceMatrixType @see getCovarianceMatrixType"}, |  | 71923 | {"setCovarianceMatrixType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_setCovarianceMatrixType, 0), "setCovarianceMatrixType(val) -> None\n. @copybrief getCovarianceMatrixType @see getCovarianceMatrixType"},
| 71972 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"}, |  | 71924 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"},
| 71973 | {"trainE", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_trainE, 0), "trainE(samples, means0[, covs0[, weights0[, logLikelihoods[, labels[, probs]]]]]) -> retval, logLikelihoods, labels, probs\n. @brief Estimate the Gaussian mixture parameters from a samples set.\n. \n. This variation starts with Expectation step. You need to provide initial means \\f$a_k\\f$ of\n. mixture components. Optionally you can pass initial weights \\f$\\pi_k\\f$ and covariance matrices\n. \\f$S_k\\f$ of mixture components.\n. \n. @param samples Samples from which the Gaussian mixture model will be estimated. It should be a\n. one-channel matrix, each row of which is a sample. If the matrix does not have CV_64F type\n. it will be converted to the inner matrix of such type for the further computing.\n. @param means0 Initial means \\f$a_k\\f$ of mixture components. It is a one-channel matrix of\n. \\f$nclusters \\times dims\\f$ size. If the matrix does not have CV_64F type it will be\n. converted to the inner matrix of such type for the further computing.\n. @param covs0 The vector of initial covariance matrices \\f$S_k\\f$ of mixture components. Each of\n. covariance matrices is a one-channel matrix of \\f$dims \\times dims\\f$ size. If the matrices\n. do not have CV_64F type they will be converted to the inner matrices of such type for the\n. further computing.\n. @param weights0 Initial weights \\f$\\pi_k\\f$ of mixture components. It should be a one-channel\n. floating-point matrix with \\f$1 \\times nclusters\\f$ or \\f$nclusters \\times 1\\f$ size.\n. @param logLikelihoods The optional output matrix that contains a likelihood logarithm value for\n. each sample. It has \\f$nsamples \\times 1\\f$ size and CV_64FC1 type.\n. @param labels The optional output \"class label\" for each sample:\n. \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most probable\n. mixture component for each sample). It has \\f$nsamples \\times 1\\f$ size and CV_32SC1 type.\n. @param probs The optional output matrix that contains posterior probabilities of each Gaussian\n. mixture component given the each sample. It has \\f$nsamples \\times nclusters\\f$ size and\n. CV_64FC1 type."}, |  | 71925 | {"trainE", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_trainE, 0), "trainE(samples, means0[, covs0[, weights0[, logLikelihoods[, labels[, probs]]]]]) -> retval, logLikelihoods, labels, probs\n. @brief Estimate the Gaussian mixture parameters from a samples set.\n. \n. This variation starts with Expectation step. You need to provide initial means \\f$a_k\\f$ of\n. mixture components. Optionally you can pass initial weights \\f$\\pi_k\\f$ and covariance matrices\n. \\f$S_k\\f$ of mixture components.\n. \n. @param samples Samples from which the Gaussian mixture model will be estimated. It should be a\n. one-channel matrix, each row of which is a sample. If the matrix does not have CV_64F type\n. it will be converted to the inner matrix of such type for the further computing.\n. @param means0 Initial means \\f$a_k\\f$ of mixture components. It is a one-channel matrix of\n. \\f$nclusters \\times dims\\f$ size. If the matrix does not have CV_64F type it will be\n. converted to the inner matrix of such type for the further computing.\n. @param covs0 The vector of initial covariance matrices \\f$S_k\\f$ of mixture components. Each of\n. covariance matrices is a one-channel matrix of \\f$dims \\times dims\\f$ size. If the matrices\n. do not have CV_64F type they will be converted to the inner matrices of such type for the\n. further computing.\n. @param weights0 Initial weights \\f$\\pi_k\\f$ of mixture components. It should be a one-channel\n. floating-point matrix with \\f$1 \\times nclusters\\f$ or \\f$nclusters \\times 1\\f$ size.\n. @param logLikelihoods The optional output matrix that contains a likelihood logarithm value for\n. each sample. It has \\f$nsamples \\times 1\\f$ size and CV_64FC1 type.\n. @param labels The optional output \"class label\" for each sample:\n. \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most probable\n. mixture component for each sample). It has \\f$nsamples \\times 1\\f$ size and CV_32SC1 type.\n. @param probs The optional output matrix that contains posterior probabilities of each Gaussian\n. mixture component given the each sample. It has \\f$nsamples \\times nclusters\\f$ size and\n. CV_64FC1 type."},
| 71974 | {"trainEM", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_trainEM, 0), "trainEM(samples[, logLikelihoods[, labels[, probs]]]) -> retval, logLikelihoods, labels, probs\n. @brief Estimate the Gaussian mixture parameters from a samples set.\n. \n. This variation starts with Expectation step. Initial values of the model parameters will be\n. estimated by the k-means algorithm.\n. \n. Unlike many of the ML models, %EM is an unsupervised learning algorithm and it does not take\n. responses (class labels or function values) as input. Instead, it computes the *Maximum\n. Likelihood Estimate* of the Gaussian mixture parameters from an input sample set, stores all the\n. parameters inside the structure: \\f$p_{i,k}\\f$ in probs, \\f$a_k\\f$ in means , \\f$S_k\\f$ in\n. covs[k], \\f$\\pi_k\\f$ in weights , and optionally computes the output \"class label\" for each\n. sample: \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most\n. probable mixture component for each sample).\n. \n. The trained model can be used further for prediction, just like any other classifier. The\n. trained model is similar to the NormalBayesClassifier.\n. \n. @param samples Samples from which the Gaussian mixture model will be estimated. It should be a\n. one-channel matrix, each row of which is a sample. If the matrix does not have CV_64F type\n. it will be converted to the inner matrix of such type for the further computing.\n. @param logLikelihoods The optional output matrix that contains a likelihood logarithm value for\n. each sample. It has \\f$nsamples \\times 1\\f$ size and CV_64FC1 type.\n. @param labels The optional output \"class label\" for each sample:\n. \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most probable\n. mixture component for each sample). It has \\f$nsamples \\times 1\\f$ size and CV_32SC1 type.\n. @param probs The optional output matrix that contains posterior probabilities of each Gaussian\n. mixture component given the each sample. It has \\f$nsamples \\times nclusters\\f$ size and\n. CV_64FC1 type."}, |  | 71926 | {"trainEM", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_trainEM, 0), "trainEM(samples[, logLikelihoods[, labels[, probs]]]) -> retval, logLikelihoods, labels, probs\n. @brief Estimate the Gaussian mixture parameters from a samples set.\n. \n. This variation starts with Expectation step. Initial values of the model parameters will be\n. estimated by the k-means algorithm.\n. \n. Unlike many of the ML models, %EM is an unsupervised learning algorithm and it does not take\n. responses (class labels or function values) as input. Instead, it computes the *Maximum\n. Likelihood Estimate* of the Gaussian mixture parameters from an input sample set, stores all the\n. parameters inside the structure: \\f$p_{i,k}\\f$ in probs, \\f$a_k\\f$ in means , \\f$S_k\\f$ in\n. covs[k], \\f$\\pi_k\\f$ in weights , and optionally computes the output \"class label\" for each\n. sample: \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most\n. probable mixture component for each sample).\n. \n. The trained model can be used further for prediction, just like any other classifier. The\n. trained model is similar to the NormalBayesClassifier.\n. \n. @param samples Samples from which the Gaussian mixture model will be estimated. It should be a\n. one-channel matrix, each row of which is a sample. If the matrix does not have CV_64F type\n. it will be converted to the inner matrix of such type for the further computing.\n. @param logLikelihoods The optional output matrix that contains a likelihood logarithm value for\n. each sample. It has \\f$nsamples \\times 1\\f$ size and CV_64FC1 type.\n. @param labels The optional output \"class label\" for each sample:\n. \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most probable\n. mixture component for each sample). It has \\f$nsamples \\times 1\\f$ size and CV_32SC1 type.\n. @param probs The optional output matrix that contains posterior probabilities of each Gaussian\n. mixture component given the each sample. It has \\f$nsamples \\times nclusters\\f$ size and\n. CV_64FC1 type."},
| 71975 | {"trainM", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_trainM, 0), "trainM(samples, probs0[, logLikelihoods[, labels[, probs]]]) -> retval, logLikelihoods, labels, probs\n. @brief Estimate the Gaussian mixture parameters from a samples set.\n. \n. This variation starts with Maximization step. You need to provide initial probabilities\n. \\f$p_{i,k}\\f$ to use this option.\n. \n. @param samples Samples from which the Gaussian mixture model will be estimated. It should be a\n. one-channel matrix, each row of which is a sample. If the matrix does not have CV_64F type\n. it will be converted to the inner matrix of such type for the further computing.\n. @param probs0 the probabilities\n. @param logLikelihoods The optional output matrix that contains a likelihood logarithm value for\n. each sample. It has \\f$nsamples \\times 1\\f$ size and CV_64FC1 type.\n. @param labels The optional output \"class label\" for each sample:\n. \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most probable\n. mixture component for each sample). It has \\f$nsamples \\times 1\\f$ size and CV_32SC1 type.\n. @param probs The optional output matrix that contains posterior probabilities of each Gaussian\n. mixture component given the each sample. It has \\f$nsamples \\times nclusters\\f$ size and\n. CV_64FC1 type."}, |  | 71927 | {"trainM", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_EM_trainM, 0), "trainM(samples, probs0[, logLikelihoods[, labels[, probs]]]) -> retval, logLikelihoods, labels, probs\n. @brief Estimate the Gaussian mixture parameters from a samples set.\n. \n. This variation starts with Maximization step. You need to provide initial probabilities\n. \\f$p_{i,k}\\f$ to use this option.\n. \n. @param samples Samples from which the Gaussian mixture model will be estimated. It should be a\n. one-channel matrix, each row of which is a sample. If the matrix does not have CV_64F type\n. it will be converted to the inner matrix of such type for the further computing.\n. @param probs0 the probabilities\n. @param logLikelihoods The optional output matrix that contains a likelihood logarithm value for\n. each sample. It has \\f$nsamples \\times 1\\f$ size and CV_64FC1 type.\n. @param labels The optional output \"class label\" for each sample:\n. \\f$\\texttt{labels}_i=\\texttt{arg max}_k(p_{i,k}), i=1..N\\f$ (indices of the most probable\n. mixture component for each sample). It has \\f$nsamples \\times 1\\f$ size and CV_32SC1 type.\n. @param probs The optional output matrix that contains posterior probabilities of each Gaussian\n. mixture component given the each sample. It has \\f$nsamples \\times nclusters\\f$ size and\n. CV_64FC1 type."},
| 71976 |  |  | 71928 |
| 71977 | {NULL, NULL} |  | 71929 | {NULL, NULL}
| 71978 | }; |  | 71930 | };
| 71979 |  |  | 71931 |
| 71980 | // Converter (ml_EM) |  | 71932 | // Converter (ml_EM)
| 71981 |  |  | 71933 |
| 71982 | template<> |  | 71934 | template<>
| 71983 | struct PyOpenCV_Converter< Ptr<cv::ml::EM> > |  | 71935 | struct PyOpenCV_Converter< Ptr<cv::ml::EM> >
| 71984 | { |  | 71936 | {
| 71985 | static PyObject* from(const Ptr<cv::ml::EM>& r) |  | 71937 | static PyObject* from(const Ptr<cv::ml::EM>& r)
| 71986 | { |  | 71938 | {
| 71987 | return pyopencv_ml_EM_Instance(r); |  | 71939 | return pyopencv_ml_EM_Instance(r);
| 71988 | } |  | 71940 | }
| 71989 | static bool to(PyObject* src, Ptr<cv::ml::EM>& dst, const ArgInfo& info) |  | 71941 | static bool to(PyObject* src, Ptr<cv::ml::EM>& dst, const ArgInfo& info)
| 71990 | { |  | 71942 | {
| 71991 | if(!src || src == Py_None) |  | 71943 | if(!src || src == Py_None)
| 71992 | return true; |  | 71944 | return true;
| 71993 | Ptr<cv::ml::EM> * dst_; |  | 71945 | Ptr<cv::ml::EM> * dst_;
| 71994 | if (pyopencv_ml_EM_getp(src, dst_)) |  | 71946 | if (pyopencv_ml_EM_getp(src, dst_))
| 71995 | { |  | 71947 | {
| 71996 | dst = *dst_; |  | 71948 | dst = *dst_;
| 71997 | return true; |  | 71949 | return true;
| 71998 | } |  | 71950 | }
| 71999 |  |  | 71951 |
| 72000 | failmsg("Expected Ptr<cv::ml::EM> for argument '%s'", info.name); |  | 71952 | failmsg("Expected Ptr<cv::ml::EM> for argument '%s'", info.name);
| 72001 | return false; |  | 71953 | return false;
| 72002 | } |  | 71954 | }
| 72003 | }; |  | 71955 | };
| 72004 |  |  | 71956 |
| 72005 | //================================================================================ |  | 71957 | //================================================================================
| 72006 | // ml_KNearest (Generic) |  | 71958 | // ml_KNearest (Generic)
| 72007 | //================================================================================ |  | 71959 | //================================================================================
| 72008 |  |  | 71960 |
| 72009 | // GetSet (ml_KNearest) |  | 71961 | // GetSet (ml_KNearest)
| 72010 |  |  | 71962 |
| 72011 |  |  | 71963 |
| 72012 |  |  | 71964 |
| 72013 | // Methods (ml_KNearest) |  | 71965 | // Methods (ml_KNearest)
| 72014 |  |  | 71966 |
| 72015 | static PyObject* pyopencv_cv_ml_ml_KNearest_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71967 | static PyObject* pyopencv_cv_ml_ml_KNearest_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 72016 | { |  | 71968 | {
| 72017 | using namespace cv::ml; |  | 71969 | using namespace cv::ml;
| 72018 |  |  | 71970 |
| 72019 | Ptr<KNearest> retval; |  | 71971 | Ptr<KNearest> retval;
| 72020 |  |  | 71972 |
| 72021 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 71973 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72022 | { |  | 71974 | {
| 72023 | ERRWRAP2(retval = cv::ml::KNearest::create()); |  | 71975 | ERRWRAP2(retval = cv::ml::KNearest::create());
| 72024 | return pyopencv_from(retval); |  | 71976 | return pyopencv_from(retval);
| 72025 | } |  | 71977 | }
| 72026 |  |  | 71978 |
| 72027 | return NULL; |  | 71979 | return NULL;
| 72028 | } |  | 71980 | }
| 72029 |  |  | 71981 |
| 72030 | static PyObject* pyopencv_cv_ml_ml_KNearest_findNearest(PyObject* self, PyObject* py_args, PyObject* kw) |  | 71982 | static PyObject* pyopencv_cv_ml_ml_KNearest_findNearest(PyObject* self, PyObject* py_args, PyObject* kw)
| 72031 | { |  | 71983 | {
| 72032 | using namespace cv::ml; |  | 71984 | using namespace cv::ml;
| 72033 |  |  | 71985 |
| 72034 |  |  | 71986 |
| 72035 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 71987 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72036 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 71988 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72037 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 71989 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72038 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 71990 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72039 | pyPrepareArgumentConversionErrorsStorage(2); |  | 71991 | pyPrepareArgumentConversionErrorsStorage(2);
| 72040 |  |  | 71992 |
| 72041 | { |  | 71993 | {
| 72042 | PyObject* pyobj_samples = NULL; |  | 71994 | PyObject* pyobj_samples = NULL;
| 72043 | Mat samples; |  | 71995 | Mat samples;
| 72044 | PyObject* pyobj_k = NULL; |  | 71996 | PyObject* pyobj_k = NULL;
| 72045 | int k=0; |  | 71997 | int k=0;
| 72046 | PyObject* pyobj_results = NULL; |  | 71998 | PyObject* pyobj_results = NULL;
| 72047 | Mat results; |  | 71999 | Mat results;
| 72048 | PyObject* pyobj_neighborResponses = NULL; |  | 72000 | PyObject* pyobj_neighborResponses = NULL;
| 72049 | Mat neighborResponses; |  | 72001 | Mat neighborResponses;
| 72050 | PyObject* pyobj_dist = NULL; |  | 72002 | PyObject* pyobj_dist = NULL;
| 72051 | Mat dist; |  | 72003 | Mat dist;
| 72052 | float retval; |  | 72004 | float retval;
| 72053 |  |  | 72005 |
| 72054 | const char* keywords[] = { "samples", "k", "results", "neighborResponses", "dist", NULL }; |  | 72006 | const char* keywords[] = { "samples", "k", "results", "neighborResponses", "dist", NULL };
| 72055 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_KNearest.findNearest", (char**)keywords, &pyobj_samples, &pyobj_k, &pyobj_results, &pyobj_neighborResponses, &pyobj_dist) && |  | 72007 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_KNearest.findNearest", (char**)keywords, &pyobj_samples, &pyobj_k, &pyobj_results, &pyobj_neighborResponses, &pyobj_dist) &&
| 72056 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 72008 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 72057 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 72009 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 72058 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 72010 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 72059 | pyopencv_to_safe(pyobj_neighborResponses, neighborResponses, ArgInfo("neighborResponses", 1)) && |  | 72011 | pyopencv_to_safe(pyobj_neighborResponses, neighborResponses, ArgInfo("neighborResponses", 1)) &&
| 72060 | pyopencv_to_safe(pyobj_dist, dist, ArgInfo("dist", 1)) ) |  | 72012 | pyopencv_to_safe(pyobj_dist, dist, ArgInfo("dist", 1)) )
| 72061 | { |  | 72013 | {
| 72062 | ERRWRAP2(retval = _self_->findNearest(samples, k, results, neighborResponses, dist)); |  | 72014 | ERRWRAP2(retval = _self_->findNearest(samples, k, results, neighborResponses, dist));
| 72063 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(results), pyopencv_from(neighborResponses), pyopencv_from(dist)); |  | 72015 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(results), pyopencv_from(neighborResponses), pyopencv_from(dist));
| 72064 | } |  | 72016 | }
| 72065 |  |  | 72017 |
| 72066 |  |  | 72018 |
| 72067 | pyPopulateArgumentConversionErrors(); |  | 72019 | pyPopulateArgumentConversionErrors();
| 72068 | } |  | 72020 | }
| 72069 |  |  | 72021 |
| 72070 |  |  | 72022 |
| 72071 | { |  | 72023 | {
| 72072 | PyObject* pyobj_samples = NULL; |  | 72024 | PyObject* pyobj_samples = NULL;
| 72073 | UMat samples; |  | 72025 | UMat samples;
| 72074 | PyObject* pyobj_k = NULL; |  | 72026 | PyObject* pyobj_k = NULL;
| 72075 | int k=0; |  | 72027 | int k=0;
| 72076 | PyObject* pyobj_results = NULL; |  | 72028 | PyObject* pyobj_results = NULL;
| 72077 | UMat results; |  | 72029 | UMat results;
| 72078 | PyObject* pyobj_neighborResponses = NULL; |  | 72030 | PyObject* pyobj_neighborResponses = NULL;
| 72079 | UMat neighborResponses; |  | 72031 | UMat neighborResponses;
| 72080 | PyObject* pyobj_dist = NULL; |  | 72032 | PyObject* pyobj_dist = NULL;
| 72081 | UMat dist; |  | 72033 | UMat dist;
| 72082 | float retval; |  | 72034 | float retval;
| 72083 |  |  | 72035 |
| 72084 | const char* keywords[] = { "samples", "k", "results", "neighborResponses", "dist", NULL }; |  | 72036 | const char* keywords[] = { "samples", "k", "results", "neighborResponses", "dist", NULL };
| 72085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_KNearest.findNearest", (char**)keywords, &pyobj_samples, &pyobj_k, &pyobj_results, &pyobj_neighborResponses, &pyobj_dist) && |  | 72037 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OOO:ml_KNearest.findNearest", (char**)keywords, &pyobj_samples, &pyobj_k, &pyobj_results, &pyobj_neighborResponses, &pyobj_dist) &&
| 72086 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 72038 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 72087 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) && |  | 72039 | pyopencv_to_safe(pyobj_k, k, ArgInfo("k", 0)) &&
| 72088 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 72040 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 72089 | pyopencv_to_safe(pyobj_neighborResponses, neighborResponses, ArgInfo("neighborResponses", 1)) && |  | 72041 | pyopencv_to_safe(pyobj_neighborResponses, neighborResponses, ArgInfo("neighborResponses", 1)) &&
| 72090 | pyopencv_to_safe(pyobj_dist, dist, ArgInfo("dist", 1)) ) |  | 72042 | pyopencv_to_safe(pyobj_dist, dist, ArgInfo("dist", 1)) )
| 72091 | { |  | 72043 | {
| 72092 | ERRWRAP2(retval = _self_->findNearest(samples, k, results, neighborResponses, dist)); |  | 72044 | ERRWRAP2(retval = _self_->findNearest(samples, k, results, neighborResponses, dist));
| 72093 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(results), pyopencv_from(neighborResponses), pyopencv_from(dist)); |  | 72045 | return Py_BuildValue("(NNNN)", pyopencv_from(retval), pyopencv_from(results), pyopencv_from(neighborResponses), pyopencv_from(dist));
| 72094 | } |  | 72046 | }
| 72095 |  |  | 72047 |
| 72096 |  |  | 72048 |
| 72097 | pyPopulateArgumentConversionErrors(); |  | 72049 | pyPopulateArgumentConversionErrors();
| 72098 | } |  | 72050 | }
| 72099 | pyRaiseCVOverloadException("findNearest"); |  | 72051 | pyRaiseCVOverloadException("findNearest");
| 72100 |  |  | 72052 |
| 72101 | return NULL; |  | 72053 | return NULL;
| 72102 | } |  | 72054 | }
| 72103 |  |  | 72055 |
| 72104 | static PyObject* pyopencv_cv_ml_ml_KNearest_getAlgorithmType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72056 | static PyObject* pyopencv_cv_ml_ml_KNearest_getAlgorithmType(PyObject* self, PyObject* py_args, PyObject* kw)
| 72105 | { |  | 72057 | {
| 72106 | using namespace cv::ml; |  | 72058 | using namespace cv::ml;
| 72107 |  |  | 72059 |
| 72108 |  |  | 72060 |
| 72109 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72061 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72110 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72062 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72111 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72063 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72112 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72064 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72113 | int retval; |  | 72065 | int retval;
| 72114 |  |  | 72066 |
| 72115 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72067 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72116 | { |  | 72068 | {
| 72117 | ERRWRAP2(retval = _self_->getAlgorithmType()); |  | 72069 | ERRWRAP2(retval = _self_->getAlgorithmType());
| 72118 | return pyopencv_from(retval); |  | 72070 | return pyopencv_from(retval);
| 72119 | } |  | 72071 | }
| 72120 |  |  | 72072 |
| 72121 | return NULL; |  | 72073 | return NULL;
| 72122 | } |  | 72074 | }
| 72123 |  |  | 72075 |
| 72124 | static PyObject* pyopencv_cv_ml_ml_KNearest_getDefaultK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72076 | static PyObject* pyopencv_cv_ml_ml_KNearest_getDefaultK(PyObject* self, PyObject* py_args, PyObject* kw)
| 72125 | { |  | 72077 | {
| 72126 | using namespace cv::ml; |  | 72078 | using namespace cv::ml;
| 72127 |  |  | 72079 |
| 72128 |  |  | 72080 |
| 72129 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72081 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72130 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72082 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72131 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72083 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72132 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72084 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72133 | int retval; |  | 72085 | int retval;
| 72134 |  |  | 72086 |
| 72135 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72087 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72136 | { |  | 72088 | {
| 72137 | ERRWRAP2(retval = _self_->getDefaultK()); |  | 72089 | ERRWRAP2(retval = _self_->getDefaultK());
| 72138 | return pyopencv_from(retval); |  | 72090 | return pyopencv_from(retval);
| 72139 | } |  | 72091 | }
| 72140 |  |  | 72092 |
| 72141 | return NULL; |  | 72093 | return NULL;
| 72142 | } |  | 72094 | }
| 72143 |  |  | 72095 |
| 72144 | static PyObject* pyopencv_cv_ml_ml_KNearest_getEmax(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72096 | static PyObject* pyopencv_cv_ml_ml_KNearest_getEmax(PyObject* self, PyObject* py_args, PyObject* kw)
| 72145 | { |  | 72097 | {
| 72146 | using namespace cv::ml; |  | 72098 | using namespace cv::ml;
| 72147 |  |  | 72099 |
| 72148 |  |  | 72100 |
| 72149 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72101 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72150 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72102 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72151 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72103 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72152 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72104 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72153 | int retval; |  | 72105 | int retval;
| 72154 |  |  | 72106 |
| 72155 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72107 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72156 | { |  | 72108 | {
| 72157 | ERRWRAP2(retval = _self_->getEmax()); |  | 72109 | ERRWRAP2(retval = _self_->getEmax());
| 72158 | return pyopencv_from(retval); |  | 72110 | return pyopencv_from(retval);
| 72159 | } |  | 72111 | }
| 72160 |  |  | 72112 |
| 72161 | return NULL; |  | 72113 | return NULL;
| 72162 | } |  | 72114 | }
| 72163 |  |  | 72115 |
| 72164 | static PyObject* pyopencv_cv_ml_ml_KNearest_getIsClassifier(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72116 | static PyObject* pyopencv_cv_ml_ml_KNearest_getIsClassifier(PyObject* self, PyObject* py_args, PyObject* kw)
| 72165 | { |  | 72117 | {
| 72166 | using namespace cv::ml; |  | 72118 | using namespace cv::ml;
| 72167 |  |  | 72119 |
| 72168 |  |  | 72120 |
| 72169 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72121 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72170 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72122 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72171 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72123 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72172 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72124 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72173 | bool retval; |  | 72125 | bool retval;
| 72174 |  |  | 72126 |
| 72175 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72127 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72176 | { |  | 72128 | {
| 72177 | ERRWRAP2(retval = _self_->getIsClassifier()); |  | 72129 | ERRWRAP2(retval = _self_->getIsClassifier());
| 72178 | return pyopencv_from(retval); |  | 72130 | return pyopencv_from(retval);
| 72179 | } |  | 72131 | }
| 72180 |  |  | 72132 |
| 72181 | return NULL; |  | 72133 | return NULL;
| 72182 | } |  | 72134 | }
| 72183 |  |  | 72135 |
| 72184 | static PyObject* pyopencv_cv_ml_ml_KNearest_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72136 | static PyObject* pyopencv_cv_ml_ml_KNearest_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 72185 | { |  | 72137 | {
| 72186 | using namespace cv::ml; |  | 72138 | using namespace cv::ml;
| 72187 |  |  | 72139 |
| 72188 | PyObject* pyobj_filepath = NULL; |  | 72140 | PyObject* pyobj_filepath = NULL;
| 72189 | String filepath; |  | 72141 | String filepath;
| 72190 | Ptr<KNearest> retval; |  | 72142 | Ptr<KNearest> retval;
| 72191 |  |  | 72143 |
| 72192 | const char* keywords[] = { "filepath", NULL }; |  | 72144 | const char* keywords[] = { "filepath", NULL };
| 72193 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.load", (char**)keywords, &pyobj_filepath) && |  | 72145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.load", (char**)keywords, &pyobj_filepath) &&
| 72194 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) ) |  | 72146 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) )
| 72195 | { |  | 72147 | {
| 72196 | ERRWRAP2(retval = cv::ml::KNearest::load(filepath)); |  | 72148 | ERRWRAP2(retval = cv::ml::KNearest::load(filepath));
| 72197 | return pyopencv_from(retval); |  | 72149 | return pyopencv_from(retval);
| 72198 | } |  | 72150 | }
| 72199 |  |  | 72151 |
| 72200 | return NULL; |  | 72152 | return NULL;
| 72201 | } |  | 72153 | }
| 72202 |  |  | 72154 |
| 72203 | static PyObject* pyopencv_cv_ml_ml_KNearest_setAlgorithmType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72155 | static PyObject* pyopencv_cv_ml_ml_KNearest_setAlgorithmType(PyObject* self, PyObject* py_args, PyObject* kw)
| 72204 | { |  | 72156 | {
| 72205 | using namespace cv::ml; |  | 72157 | using namespace cv::ml;
| 72206 |  |  | 72158 |
| 72207 |  |  | 72159 |
| 72208 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72160 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72209 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72161 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72210 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72162 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72211 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72163 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72212 | PyObject* pyobj_val = NULL; |  | 72164 | PyObject* pyobj_val = NULL;
| 72213 | int val=0; |  | 72165 | int val=0;
| 72214 |  |  | 72166 |
| 72215 | const char* keywords[] = { "val", NULL }; |  | 72167 | const char* keywords[] = { "val", NULL };
| 72216 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setAlgorithmType", (char**)keywords, &pyobj_val) && |  | 72168 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setAlgorithmType", (char**)keywords, &pyobj_val) &&
| 72217 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72169 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72218 | { |  | 72170 | {
| 72219 | ERRWRAP2(_self_->setAlgorithmType(val)); |  | 72171 | ERRWRAP2(_self_->setAlgorithmType(val));
| 72220 | Py_RETURN_NONE; |  | 72172 | Py_RETURN_NONE;
| 72221 | } |  | 72173 | }
| 72222 |  |  | 72174 |
| 72223 | return NULL; |  | 72175 | return NULL;
| 72224 | } |  | 72176 | }
| 72225 |  |  | 72177 |
| 72226 | static PyObject* pyopencv_cv_ml_ml_KNearest_setDefaultK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72178 | static PyObject* pyopencv_cv_ml_ml_KNearest_setDefaultK(PyObject* self, PyObject* py_args, PyObject* kw)
| 72227 | { |  | 72179 | {
| 72228 | using namespace cv::ml; |  | 72180 | using namespace cv::ml;
| 72229 |  |  | 72181 |
| 72230 |  |  | 72182 |
| 72231 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72183 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72232 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72184 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72233 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72185 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72234 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72186 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72235 | PyObject* pyobj_val = NULL; |  | 72187 | PyObject* pyobj_val = NULL;
| 72236 | int val=0; |  | 72188 | int val=0;
| 72237 |  |  | 72189 |
| 72238 | const char* keywords[] = { "val", NULL }; |  | 72190 | const char* keywords[] = { "val", NULL };
| 72239 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setDefaultK", (char**)keywords, &pyobj_val) && |  | 72191 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setDefaultK", (char**)keywords, &pyobj_val) &&
| 72240 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72192 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72241 | { |  | 72193 | {
| 72242 | ERRWRAP2(_self_->setDefaultK(val)); |  | 72194 | ERRWRAP2(_self_->setDefaultK(val));
| 72243 | Py_RETURN_NONE; |  | 72195 | Py_RETURN_NONE;
| 72244 | } |  | 72196 | }
| 72245 |  |  | 72197 |
| 72246 | return NULL; |  | 72198 | return NULL;
| 72247 | } |  | 72199 | }
| 72248 |  |  | 72200 |
| 72249 | static PyObject* pyopencv_cv_ml_ml_KNearest_setEmax(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72201 | static PyObject* pyopencv_cv_ml_ml_KNearest_setEmax(PyObject* self, PyObject* py_args, PyObject* kw)
| 72250 | { |  | 72202 | {
| 72251 | using namespace cv::ml; |  | 72203 | using namespace cv::ml;
| 72252 |  |  | 72204 |
| 72253 |  |  | 72205 |
| 72254 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72206 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72255 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72207 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72256 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72208 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72257 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72209 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72258 | PyObject* pyobj_val = NULL; |  | 72210 | PyObject* pyobj_val = NULL;
| 72259 | int val=0; |  | 72211 | int val=0;
| 72260 |  |  | 72212 |
| 72261 | const char* keywords[] = { "val", NULL }; |  | 72213 | const char* keywords[] = { "val", NULL };
| 72262 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setEmax", (char**)keywords, &pyobj_val) && |  | 72214 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setEmax", (char**)keywords, &pyobj_val) &&
| 72263 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72215 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72264 | { |  | 72216 | {
| 72265 | ERRWRAP2(_self_->setEmax(val)); |  | 72217 | ERRWRAP2(_self_->setEmax(val));
| 72266 | Py_RETURN_NONE; |  | 72218 | Py_RETURN_NONE;
| 72267 | } |  | 72219 | }
| 72268 |  |  | 72220 |
| 72269 | return NULL; |  | 72221 | return NULL;
| 72270 | } |  | 72222 | }
| 72271 |  |  | 72223 |
| 72272 | static PyObject* pyopencv_cv_ml_ml_KNearest_setIsClassifier(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72224 | static PyObject* pyopencv_cv_ml_ml_KNearest_setIsClassifier(PyObject* self, PyObject* py_args, PyObject* kw)
| 72273 | { |  | 72225 | {
| 72274 | using namespace cv::ml; |  | 72226 | using namespace cv::ml;
| 72275 |  |  | 72227 |
| 72276 |  |  | 72228 |
| 72277 | Ptr<cv::ml::KNearest> * self1 = 0; |  | 72229 | Ptr<cv::ml::KNearest> * self1 = 0;
| 72278 | if (!pyopencv_ml_KNearest_getp(self, self1)) |  | 72230 | if (!pyopencv_ml_KNearest_getp(self, self1))
| 72279 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)"); |  | 72231 | return failmsgp("Incorrect type of self (must be 'ml_KNearest' or its derivative)");
| 72280 | Ptr<cv::ml::KNearest> _self_ = *(self1); |  | 72232 | Ptr<cv::ml::KNearest> _self_ = *(self1);
| 72281 | PyObject* pyobj_val = NULL; |  | 72233 | PyObject* pyobj_val = NULL;
| 72282 | bool val=0; |  | 72234 | bool val=0;
| 72283 |  |  | 72235 |
| 72284 | const char* keywords[] = { "val", NULL }; |  | 72236 | const char* keywords[] = { "val", NULL };
| 72285 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setIsClassifier", (char**)keywords, &pyobj_val) && |  | 72237 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_KNearest.setIsClassifier", (char**)keywords, &pyobj_val) &&
| 72286 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72238 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72287 | { |  | 72239 | {
| 72288 | ERRWRAP2(_self_->setIsClassifier(val)); |  | 72240 | ERRWRAP2(_self_->setIsClassifier(val));
| 72289 | Py_RETURN_NONE; |  | 72241 | Py_RETURN_NONE;
| 72290 | } |  | 72242 | }
| 72291 |  |  | 72243 |
| 72292 | return NULL; |  | 72244 | return NULL;
| 72293 | } |  | 72245 | }
| 72294 |  |  | 72246 |
| 72295 |  |  | 72247 |
| 72296 |  |  | 72248 |
| 72297 | // Tables (ml_KNearest) |  | 72249 | // Tables (ml_KNearest)
| 72298 |  |  | 72250 |
| 72299 | static PyGetSetDef pyopencv_ml_KNearest_getseters[] = |  | 72251 | static PyGetSetDef pyopencv_ml_KNearest_getseters[] =
| 72300 | { |  | 72252 | {
| 72301 | {NULL} /* Sentinel */ |  | 72253 | {NULL} /* Sentinel */
| 72302 | }; |  | 72254 | };
| 72303 |  |  | 72255 |
| 72304 | static PyMethodDef pyopencv_ml_KNearest_methods[] = |  | 72256 | static PyMethodDef pyopencv_ml_KNearest_methods[] =
| 72305 | { |  | 72257 | {
| 72306 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_create_static, METH_STATIC), "create() -> retval\n. @brief Creates the empty model\n. \n. The static method creates empty %KNearest classifier. It should be then trained using StatModel::train method."}, |  | 72258 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_create_static, METH_STATIC), "create() -> retval\n. @brief Creates the empty model\n. \n. The static method creates empty %KNearest classifier. It should be then trained using StatModel::train method."},
| 72307 | {"findNearest", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_findNearest, 0), "findNearest(samples, k[, results[, neighborResponses[, dist]]]) -> retval, results, neighborResponses, dist\n. @brief Finds the neighbors and predicts responses for input vectors.\n. \n. @param samples Input samples stored by rows. It is a single-precision floating-point matrix of\n. `<number_of_samples> * k` size.\n. @param k Number of used nearest neighbors. Should be greater than 1.\n. @param results Vector with results of prediction (regression or classification) for each input\n. sample. It is a single-precision floating-point vector with `<number_of_samples>` elements.\n. @param neighborResponses Optional output values for corresponding neighbors. It is a single-\n. precision floating-point matrix of `<number_of_samples> * k` size.\n. @param dist Optional output distances from the input vectors to the corresponding neighbors. It\n. is a single-precision floating-point matrix of `<number_of_samples> * k` size.\n. \n. For each input vector (a row of the matrix samples), the method finds the k nearest neighbors.\n. In case of regression, the predicted result is a mean value of the particular vector's neighbor\n. responses. In case of classification, the class is determined by voting.\n. \n. For each input vector, the neighbors are sorted by their distances to the vector.\n. \n. In case of C++ interface you can use output pointers to empty matrices and the function will\n. allocate memory itself.\n. \n. If only a single input vector is passed, all output matrices are optional and the predicted\n. value is returned by the method.\n. \n. The function is parallelized with the TBB library."}, |  | 72259 | {"findNearest", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_findNearest, 0), "findNearest(samples, k[, results[, neighborResponses[, dist]]]) -> retval, results, neighborResponses, dist\n. @brief Finds the neighbors and predicts responses for input vectors.\n. \n. @param samples Input samples stored by rows. It is a single-precision floating-point matrix of\n. `<number_of_samples> * k` size.\n. @param k Number of used nearest neighbors. Should be greater than 1.\n. @param results Vector with results of prediction (regression or classification) for each input\n. sample. It is a single-precision floating-point vector with `<number_of_samples>` elements.\n. @param neighborResponses Optional output values for corresponding neighbors. It is a single-\n. precision floating-point matrix of `<number_of_samples> * k` size.\n. @param dist Optional output distances from the input vectors to the corresponding neighbors. It\n. is a single-precision floating-point matrix of `<number_of_samples> * k` size.\n. \n. For each input vector (a row of the matrix samples), the method finds the k nearest neighbors.\n. In case of regression, the predicted result is a mean value of the particular vector's neighbor\n. responses. In case of classification, the class is determined by voting.\n. \n. For each input vector, the neighbors are sorted by their distances to the vector.\n. \n. In case of C++ interface you can use output pointers to empty matrices and the function will\n. allocate memory itself.\n. \n. If only a single input vector is passed, all output matrices are optional and the predicted\n. value is returned by the method.\n. \n. The function is parallelized with the TBB library."},
| 72308 | {"getAlgorithmType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getAlgorithmType, 0), "getAlgorithmType() -> retval\n. @see setAlgorithmType"}, |  | 72260 | {"getAlgorithmType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getAlgorithmType, 0), "getAlgorithmType() -> retval\n. @see setAlgorithmType"},
| 72309 | {"getDefaultK", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getDefaultK, 0), "getDefaultK() -> retval\n. @see setDefaultK"}, |  | 72261 | {"getDefaultK", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getDefaultK, 0), "getDefaultK() -> retval\n. @see setDefaultK"},
| 72310 | {"getEmax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getEmax, 0), "getEmax() -> retval\n. @see setEmax"}, |  | 72262 | {"getEmax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getEmax, 0), "getEmax() -> retval\n. @see setEmax"},
| 72311 | {"getIsClassifier", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getIsClassifier, 0), "getIsClassifier() -> retval\n. @see setIsClassifier"}, |  | 72263 | {"getIsClassifier", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_getIsClassifier, 0), "getIsClassifier() -> retval\n. @see setIsClassifier"},
| 72312 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_load_static, METH_STATIC), "load(filepath) -> retval\n. @brief Loads and creates a serialized knearest from a file\n. *\n. * Use KNearest::save to serialize and store an KNearest to disk.\n. * Load the KNearest from this file again, by calling this function with the path to the file.\n. *\n. * @param filepath path to serialized KNearest"}, |  | 72264 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_load_static, METH_STATIC), "load(filepath) -> retval\n. @brief Loads and creates a serialized knearest from a file\n. *\n. * Use KNearest::save to serialize and store an KNearest to disk.\n. * Load the KNearest from this file again, by calling this function with the path to the file.\n. *\n. * @param filepath path to serialized KNearest"},
| 72313 | {"setAlgorithmType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setAlgorithmType, 0), "setAlgorithmType(val) -> None\n. @copybrief getAlgorithmType @see getAlgorithmType"}, |  | 72265 | {"setAlgorithmType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setAlgorithmType, 0), "setAlgorithmType(val) -> None\n. @copybrief getAlgorithmType @see getAlgorithmType"},
| 72314 | {"setDefaultK", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setDefaultK, 0), "setDefaultK(val) -> None\n. @copybrief getDefaultK @see getDefaultK"}, |  | 72266 | {"setDefaultK", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setDefaultK, 0), "setDefaultK(val) -> None\n. @copybrief getDefaultK @see getDefaultK"},
| 72315 | {"setEmax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setEmax, 0), "setEmax(val) -> None\n. @copybrief getEmax @see getEmax"}, |  | 72267 | {"setEmax", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setEmax, 0), "setEmax(val) -> None\n. @copybrief getEmax @see getEmax"},
| 72316 | {"setIsClassifier", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setIsClassifier, 0), "setIsClassifier(val) -> None\n. @copybrief getIsClassifier @see getIsClassifier"}, |  | 72268 | {"setIsClassifier", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_KNearest_setIsClassifier, 0), "setIsClassifier(val) -> None\n. @copybrief getIsClassifier @see getIsClassifier"},
| 72317 |  |  | 72269 |
| 72318 | {NULL, NULL} |  | 72270 | {NULL, NULL}
| 72319 | }; |  | 72271 | };
| 72320 |  |  | 72272 |
| 72321 | // Converter (ml_KNearest) |  | 72273 | // Converter (ml_KNearest)
| 72322 |  |  | 72274 |
| 72323 | template<> |  | 72275 | template<>
| 72324 | struct PyOpenCV_Converter< Ptr<cv::ml::KNearest> > |  | 72276 | struct PyOpenCV_Converter< Ptr<cv::ml::KNearest> >
| 72325 | { |  | 72277 | {
| 72326 | static PyObject* from(const Ptr<cv::ml::KNearest>& r) |  | 72278 | static PyObject* from(const Ptr<cv::ml::KNearest>& r)
| 72327 | { |  | 72279 | {
| 72328 | return pyopencv_ml_KNearest_Instance(r); |  | 72280 | return pyopencv_ml_KNearest_Instance(r);
| 72329 | } |  | 72281 | }
| 72330 | static bool to(PyObject* src, Ptr<cv::ml::KNearest>& dst, const ArgInfo& info) |  | 72282 | static bool to(PyObject* src, Ptr<cv::ml::KNearest>& dst, const ArgInfo& info)
| 72331 | { |  | 72283 | {
| 72332 | if(!src || src == Py_None) |  | 72284 | if(!src || src == Py_None)
| 72333 | return true; |  | 72285 | return true;
| 72334 | Ptr<cv::ml::KNearest> * dst_; |  | 72286 | Ptr<cv::ml::KNearest> * dst_;
| 72335 | if (pyopencv_ml_KNearest_getp(src, dst_)) |  | 72287 | if (pyopencv_ml_KNearest_getp(src, dst_))
| 72336 | { |  | 72288 | {
| 72337 | dst = *dst_; |  | 72289 | dst = *dst_;
| 72338 | return true; |  | 72290 | return true;
| 72339 | } |  | 72291 | }
| 72340 |  |  | 72292 |
| 72341 | failmsg("Expected Ptr<cv::ml::KNearest> for argument '%s'", info.name); |  | 72293 | failmsg("Expected Ptr<cv::ml::KNearest> for argument '%s'", info.name);
| 72342 | return false; |  | 72294 | return false;
| 72343 | } |  | 72295 | }
| 72344 | }; |  | 72296 | };
| 72345 |  |  | 72297 |
| 72346 | //================================================================================ |  | 72298 | //================================================================================
| 72347 | // ml_LogisticRegression (Generic) |  | 72299 | // ml_LogisticRegression (Generic)
| 72348 | //================================================================================ |  | 72300 | //================================================================================
| 72349 |  |  | 72301 |
| 72350 | // GetSet (ml_LogisticRegression) |  | 72302 | // GetSet (ml_LogisticRegression)
| 72351 |  |  | 72303 |
| 72352 |  |  | 72304 |
| 72353 |  |  | 72305 |
| 72354 | // Methods (ml_LogisticRegression) |  | 72306 | // Methods (ml_LogisticRegression)
| 72355 |  |  | 72307 |
| 72356 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72308 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 72357 | { |  | 72309 | {
| 72358 | using namespace cv::ml; |  | 72310 | using namespace cv::ml;
| 72359 |  |  | 72311 |
| 72360 | Ptr<LogisticRegression> retval; |  | 72312 | Ptr<LogisticRegression> retval;
| 72361 |  |  | 72313 |
| 72362 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72314 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72363 | { |  | 72315 | {
| 72364 | ERRWRAP2(retval = cv::ml::LogisticRegression::create()); |  | 72316 | ERRWRAP2(retval = cv::ml::LogisticRegression::create());
| 72365 | return pyopencv_from(retval); |  | 72317 | return pyopencv_from(retval);
| 72366 | } |  | 72318 | }
| 72367 |  |  | 72319 |
| 72368 | return NULL; |  | 72320 | return NULL;
| 72369 | } |  | 72321 | }
| 72370 |  |  | 72322 |
| 72371 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72323 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 72372 | { |  | 72324 | {
| 72373 | using namespace cv::ml; |  | 72325 | using namespace cv::ml;
| 72374 |  |  | 72326 |
| 72375 |  |  | 72327 |
| 72376 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72328 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72377 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72329 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72378 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72330 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72379 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72331 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72380 | int retval; |  | 72332 | int retval;
| 72381 |  |  | 72333 |
| 72382 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72334 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72383 | { |  | 72335 | {
| 72384 | ERRWRAP2(retval = _self_->getIterations()); |  | 72336 | ERRWRAP2(retval = _self_->getIterations());
| 72385 | return pyopencv_from(retval); |  | 72337 | return pyopencv_from(retval);
| 72386 | } |  | 72338 | }
| 72387 |  |  | 72339 |
| 72388 | return NULL; |  | 72340 | return NULL;
| 72389 | } |  | 72341 | }
| 72390 |  |  | 72342 |
| 72391 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getLearningRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72343 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getLearningRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 72392 | { |  | 72344 | {
| 72393 | using namespace cv::ml; |  | 72345 | using namespace cv::ml;
| 72394 |  |  | 72346 |
| 72395 |  |  | 72347 |
| 72396 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72348 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72397 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72349 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72398 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72350 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72399 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72351 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72400 | double retval; |  | 72352 | double retval;
| 72401 |  |  | 72353 |
| 72402 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72354 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72403 | { |  | 72355 | {
| 72404 | ERRWRAP2(retval = _self_->getLearningRate()); |  | 72356 | ERRWRAP2(retval = _self_->getLearningRate());
| 72405 | return pyopencv_from(retval); |  | 72357 | return pyopencv_from(retval);
| 72406 | } |  | 72358 | }
| 72407 |  |  | 72359 |
| 72408 | return NULL; |  | 72360 | return NULL;
| 72409 | } |  | 72361 | }
| 72410 |  |  | 72362 |
| 72411 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getMiniBatchSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72363 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getMiniBatchSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 72412 | { |  | 72364 | {
| 72413 | using namespace cv::ml; |  | 72365 | using namespace cv::ml;
| 72414 |  |  | 72366 |
| 72415 |  |  | 72367 |
| 72416 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72368 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72417 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72369 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72418 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72370 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72419 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72371 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72420 | int retval; |  | 72372 | int retval;
| 72421 |  |  | 72373 |
| 72422 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72374 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72423 | { |  | 72375 | {
| 72424 | ERRWRAP2(retval = _self_->getMiniBatchSize()); |  | 72376 | ERRWRAP2(retval = _self_->getMiniBatchSize());
| 72425 | return pyopencv_from(retval); |  | 72377 | return pyopencv_from(retval);
| 72426 | } |  | 72378 | }
| 72427 |  |  | 72379 |
| 72428 | return NULL; |  | 72380 | return NULL;
| 72429 | } |  | 72381 | }
| 72430 |  |  | 72382 |
| 72431 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getRegularization(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72383 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getRegularization(PyObject* self, PyObject* py_args, PyObject* kw)
| 72432 | { |  | 72384 | {
| 72433 | using namespace cv::ml; |  | 72385 | using namespace cv::ml;
| 72434 |  |  | 72386 |
| 72435 |  |  | 72387 |
| 72436 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72388 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72437 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72389 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72438 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72390 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72439 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72391 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72440 | int retval; |  | 72392 | int retval;
| 72441 |  |  | 72393 |
| 72442 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72394 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72443 | { |  | 72395 | {
| 72444 | ERRWRAP2(retval = _self_->getRegularization()); |  | 72396 | ERRWRAP2(retval = _self_->getRegularization());
| 72445 | return pyopencv_from(retval); |  | 72397 | return pyopencv_from(retval);
| 72446 | } |  | 72398 | }
| 72447 |  |  | 72399 |
| 72448 | return NULL; |  | 72400 | return NULL;
| 72449 | } |  | 72401 | }
| 72450 |  |  | 72402 |
| 72451 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72403 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 72452 | { |  | 72404 | {
| 72453 | using namespace cv::ml; |  | 72405 | using namespace cv::ml;
| 72454 |  |  | 72406 |
| 72455 |  |  | 72407 |
| 72456 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72408 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72457 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72409 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72458 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72410 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72459 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72411 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72460 | TermCriteria retval; |  | 72412 | TermCriteria retval;
| 72461 |  |  | 72413 |
| 72462 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72414 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72463 | { |  | 72415 | {
| 72464 | ERRWRAP2(retval = _self_->getTermCriteria()); |  | 72416 | ERRWRAP2(retval = _self_->getTermCriteria());
| 72465 | return pyopencv_from(retval); |  | 72417 | return pyopencv_from(retval);
| 72466 | } |  | 72418 | }
| 72467 |  |  | 72419 |
| 72468 | return NULL; |  | 72420 | return NULL;
| 72469 | } |  | 72421 | }
| 72470 |  |  | 72422 |
| 72471 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72423 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_getTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 72472 | { |  | 72424 | {
| 72473 | using namespace cv::ml; |  | 72425 | using namespace cv::ml;
| 72474 |  |  | 72426 |
| 72475 |  |  | 72427 |
| 72476 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72428 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72477 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72429 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72478 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72430 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72479 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72431 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72480 | int retval; |  | 72432 | int retval;
| 72481 |  |  | 72433 |
| 72482 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72434 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72483 | { |  | 72435 | {
| 72484 | ERRWRAP2(retval = _self_->getTrainMethod()); |  | 72436 | ERRWRAP2(retval = _self_->getTrainMethod());
| 72485 | return pyopencv_from(retval); |  | 72437 | return pyopencv_from(retval);
| 72486 | } |  | 72438 | }
| 72487 |  |  | 72439 |
| 72488 | return NULL; |  | 72440 | return NULL;
| 72489 | } |  | 72441 | }
| 72490 |  |  | 72442 |
| 72491 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_get_learnt_thetas(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72443 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_get_learnt_thetas(PyObject* self, PyObject* py_args, PyObject* kw)
| 72492 | { |  | 72444 | {
| 72493 | using namespace cv::ml; |  | 72445 | using namespace cv::ml;
| 72494 |  |  | 72446 |
| 72495 |  |  | 72447 |
| 72496 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72448 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72497 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72449 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72498 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72450 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72499 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72451 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72500 | Mat retval; |  | 72452 | Mat retval;
| 72501 |  |  | 72453 |
| 72502 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72454 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72503 | { |  | 72455 | {
| 72504 | ERRWRAP2(retval = _self_->get_learnt_thetas()); |  | 72456 | ERRWRAP2(retval = _self_->get_learnt_thetas());
| 72505 | return pyopencv_from(retval); |  | 72457 | return pyopencv_from(retval);
| 72506 | } |  | 72458 | }
| 72507 |  |  | 72459 |
| 72508 | return NULL; |  | 72460 | return NULL;
| 72509 | } |  | 72461 | }
| 72510 |  |  | 72462 |
| 72511 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72463 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 72512 | { |  | 72464 | {
| 72513 | using namespace cv::ml; |  | 72465 | using namespace cv::ml;
| 72514 |  |  | 72466 |
| 72515 | PyObject* pyobj_filepath = NULL; |  | 72467 | PyObject* pyobj_filepath = NULL;
| 72516 | String filepath; |  | 72468 | String filepath;
| 72517 | PyObject* pyobj_nodeName = NULL; |  | 72469 | PyObject* pyobj_nodeName = NULL;
| 72518 | String nodeName; |  | 72470 | String nodeName;
| 72519 | Ptr<LogisticRegression> retval; |  | 72471 | Ptr<LogisticRegression> retval;
| 72520 |  |  | 72472 |
| 72521 | const char* keywords[] = { "filepath", "nodeName", NULL }; |  | 72473 | const char* keywords[] = { "filepath", "nodeName", NULL };
| 72522 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_LogisticRegression.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) && |  | 72474 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_LogisticRegression.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) &&
| 72523 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) && |  | 72475 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) &&
| 72524 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) ) |  | 72476 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) )
| 72525 | { |  | 72477 | {
| 72526 | ERRWRAP2(retval = cv::ml::LogisticRegression::load(filepath, nodeName)); |  | 72478 | ERRWRAP2(retval = cv::ml::LogisticRegression::load(filepath, nodeName));
| 72527 | return pyopencv_from(retval); |  | 72479 | return pyopencv_from(retval);
| 72528 | } |  | 72480 | }
| 72529 |  |  | 72481 |
| 72530 | return NULL; |  | 72482 | return NULL;
| 72531 | } |  | 72483 | }
| 72532 |  |  | 72484 |
| 72533 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_predict(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72485 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_predict(PyObject* self, PyObject* py_args, PyObject* kw)
| 72534 | { |  | 72486 | {
| 72535 | using namespace cv::ml; |  | 72487 | using namespace cv::ml;
| 72536 |  |  | 72488 |
| 72537 |  |  | 72489 |
| 72538 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72490 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72539 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72491 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72540 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72492 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72541 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72493 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72542 | pyPrepareArgumentConversionErrorsStorage(2); |  | 72494 | pyPrepareArgumentConversionErrorsStorage(2);
| 72543 |  |  | 72495 |
| 72544 | { |  | 72496 | {
| 72545 | PyObject* pyobj_samples = NULL; |  | 72497 | PyObject* pyobj_samples = NULL;
| 72546 | Mat samples; |  | 72498 | Mat samples;
| 72547 | PyObject* pyobj_results = NULL; |  | 72499 | PyObject* pyobj_results = NULL;
| 72548 | Mat results; |  | 72500 | Mat results;
| 72549 | PyObject* pyobj_flags = NULL; |  | 72501 | PyObject* pyobj_flags = NULL;
| 72550 | int flags=0; |  | 72502 | int flags=0;
| 72551 | float retval; |  | 72503 | float retval;
| 72552 |  |  | 72504 |
| 72553 | const char* keywords[] = { "samples", "results", "flags", NULL }; |  | 72505 | const char* keywords[] = { "samples", "results", "flags", NULL };
| 72554 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_LogisticRegression.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) && |  | 72506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_LogisticRegression.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) &&
| 72555 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 72507 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 72556 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 72508 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 72557 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 72509 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 72558 | { |  | 72510 | {
| 72559 | ERRWRAP2(retval = _self_->predict(samples, results, flags)); |  | 72511 | ERRWRAP2(retval = _self_->predict(samples, results, flags));
| 72560 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results)); |  | 72512 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results));
| 72561 | } |  | 72513 | }
| 72562 |  |  | 72514 |
| 72563 |  |  | 72515 |
| 72564 | pyPopulateArgumentConversionErrors(); |  | 72516 | pyPopulateArgumentConversionErrors();
| 72565 | } |  | 72517 | }
| 72566 |  |  | 72518 |
| 72567 |  |  | 72519 |
| 72568 | { |  | 72520 | {
| 72569 | PyObject* pyobj_samples = NULL; |  | 72521 | PyObject* pyobj_samples = NULL;
| 72570 | UMat samples; |  | 72522 | UMat samples;
| 72571 | PyObject* pyobj_results = NULL; |  | 72523 | PyObject* pyobj_results = NULL;
| 72572 | UMat results; |  | 72524 | UMat results;
| 72573 | PyObject* pyobj_flags = NULL; |  | 72525 | PyObject* pyobj_flags = NULL;
| 72574 | int flags=0; |  | 72526 | int flags=0;
| 72575 | float retval; |  | 72527 | float retval;
| 72576 |  |  | 72528 |
| 72577 | const char* keywords[] = { "samples", "results", "flags", NULL }; |  | 72529 | const char* keywords[] = { "samples", "results", "flags", NULL };
| 72578 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_LogisticRegression.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) && |  | 72530 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_LogisticRegression.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) &&
| 72579 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 72531 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 72580 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 72532 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 72581 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 72533 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 72582 | { |  | 72534 | {
| 72583 | ERRWRAP2(retval = _self_->predict(samples, results, flags)); |  | 72535 | ERRWRAP2(retval = _self_->predict(samples, results, flags));
| 72584 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results)); |  | 72536 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results));
| 72585 | } |  | 72537 | }
| 72586 |  |  | 72538 |
| 72587 |  |  | 72539 |
| 72588 | pyPopulateArgumentConversionErrors(); |  | 72540 | pyPopulateArgumentConversionErrors();
| 72589 | } |  | 72541 | }
| 72590 | pyRaiseCVOverloadException("predict"); |  | 72542 | pyRaiseCVOverloadException("predict");
| 72591 |  |  | 72543 |
| 72592 | return NULL; |  | 72544 | return NULL;
| 72593 | } |  | 72545 | }
| 72594 |  |  | 72546 |
| 72595 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72547 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 72596 | { |  | 72548 | {
| 72597 | using namespace cv::ml; |  | 72549 | using namespace cv::ml;
| 72598 |  |  | 72550 |
| 72599 |  |  | 72551 |
| 72600 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72552 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72601 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72553 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72602 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72554 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72603 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72555 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72604 | PyObject* pyobj_val = NULL; |  | 72556 | PyObject* pyobj_val = NULL;
| 72605 | int val=0; |  | 72557 | int val=0;
| 72606 |  |  | 72558 |
| 72607 | const char* keywords[] = { "val", NULL }; |  | 72559 | const char* keywords[] = { "val", NULL };
| 72608 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setIterations", (char**)keywords, &pyobj_val) && |  | 72560 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setIterations", (char**)keywords, &pyobj_val) &&
| 72609 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72561 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72610 | { |  | 72562 | {
| 72611 | ERRWRAP2(_self_->setIterations(val)); |  | 72563 | ERRWRAP2(_self_->setIterations(val));
| 72612 | Py_RETURN_NONE; |  | 72564 | Py_RETURN_NONE;
| 72613 | } |  | 72565 | }
| 72614 |  |  | 72566 |
| 72615 | return NULL; |  | 72567 | return NULL;
| 72616 | } |  | 72568 | }
| 72617 |  |  | 72569 |
| 72618 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setLearningRate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72570 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setLearningRate(PyObject* self, PyObject* py_args, PyObject* kw)
| 72619 | { |  | 72571 | {
| 72620 | using namespace cv::ml; |  | 72572 | using namespace cv::ml;
| 72621 |  |  | 72573 |
| 72622 |  |  | 72574 |
| 72623 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72575 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72624 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72576 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72625 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72577 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72626 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72578 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72627 | PyObject* pyobj_val = NULL; |  | 72579 | PyObject* pyobj_val = NULL;
| 72628 | double val=0; |  | 72580 | double val=0;
| 72629 |  |  | 72581 |
| 72630 | const char* keywords[] = { "val", NULL }; |  | 72582 | const char* keywords[] = { "val", NULL };
| 72631 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setLearningRate", (char**)keywords, &pyobj_val) && |  | 72583 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setLearningRate", (char**)keywords, &pyobj_val) &&
| 72632 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72584 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72633 | { |  | 72585 | {
| 72634 | ERRWRAP2(_self_->setLearningRate(val)); |  | 72586 | ERRWRAP2(_self_->setLearningRate(val));
| 72635 | Py_RETURN_NONE; |  | 72587 | Py_RETURN_NONE;
| 72636 | } |  | 72588 | }
| 72637 |  |  | 72589 |
| 72638 | return NULL; |  | 72590 | return NULL;
| 72639 | } |  | 72591 | }
| 72640 |  |  | 72592 |
| 72641 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setMiniBatchSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72593 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setMiniBatchSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 72642 | { |  | 72594 | {
| 72643 | using namespace cv::ml; |  | 72595 | using namespace cv::ml;
| 72644 |  |  | 72596 |
| 72645 |  |  | 72597 |
| 72646 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72598 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72647 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72599 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72648 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72600 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72649 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72601 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72650 | PyObject* pyobj_val = NULL; |  | 72602 | PyObject* pyobj_val = NULL;
| 72651 | int val=0; |  | 72603 | int val=0;
| 72652 |  |  | 72604 |
| 72653 | const char* keywords[] = { "val", NULL }; |  | 72605 | const char* keywords[] = { "val", NULL };
| 72654 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setMiniBatchSize", (char**)keywords, &pyobj_val) && |  | 72606 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setMiniBatchSize", (char**)keywords, &pyobj_val) &&
| 72655 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72607 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72656 | { |  | 72608 | {
| 72657 | ERRWRAP2(_self_->setMiniBatchSize(val)); |  | 72609 | ERRWRAP2(_self_->setMiniBatchSize(val));
| 72658 | Py_RETURN_NONE; |  | 72610 | Py_RETURN_NONE;
| 72659 | } |  | 72611 | }
| 72660 |  |  | 72612 |
| 72661 | return NULL; |  | 72613 | return NULL;
| 72662 | } |  | 72614 | }
| 72663 |  |  | 72615 |
| 72664 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setRegularization(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72616 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setRegularization(PyObject* self, PyObject* py_args, PyObject* kw)
| 72665 | { |  | 72617 | {
| 72666 | using namespace cv::ml; |  | 72618 | using namespace cv::ml;
| 72667 |  |  | 72619 |
| 72668 |  |  | 72620 |
| 72669 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72621 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72670 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72622 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72671 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72623 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72672 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72624 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72673 | PyObject* pyobj_val = NULL; |  | 72625 | PyObject* pyobj_val = NULL;
| 72674 | int val=0; |  | 72626 | int val=0;
| 72675 |  |  | 72627 |
| 72676 | const char* keywords[] = { "val", NULL }; |  | 72628 | const char* keywords[] = { "val", NULL };
| 72677 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setRegularization", (char**)keywords, &pyobj_val) && |  | 72629 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setRegularization", (char**)keywords, &pyobj_val) &&
| 72678 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72630 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72679 | { |  | 72631 | {
| 72680 | ERRWRAP2(_self_->setRegularization(val)); |  | 72632 | ERRWRAP2(_self_->setRegularization(val));
| 72681 | Py_RETURN_NONE; |  | 72633 | Py_RETURN_NONE;
| 72682 | } |  | 72634 | }
| 72683 |  |  | 72635 |
| 72684 | return NULL; |  | 72636 | return NULL;
| 72685 | } |  | 72637 | }
| 72686 |  |  | 72638 |
| 72687 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72639 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 72688 | { |  | 72640 | {
| 72689 | using namespace cv::ml; |  | 72641 | using namespace cv::ml;
| 72690 |  |  | 72642 |
| 72691 |  |  | 72643 |
| 72692 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72644 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72693 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72645 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72694 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72646 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72695 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72647 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72696 | PyObject* pyobj_val = NULL; |  | 72648 | PyObject* pyobj_val = NULL;
| 72697 | TermCriteria val; |  | 72649 | TermCriteria val;
| 72698 |  |  | 72650 |
| 72699 | const char* keywords[] = { "val", NULL }; |  | 72651 | const char* keywords[] = { "val", NULL };
| 72700 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setTermCriteria", (char**)keywords, &pyobj_val) && |  | 72652 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setTermCriteria", (char**)keywords, &pyobj_val) &&
| 72701 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72653 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72702 | { |  | 72654 | {
| 72703 | ERRWRAP2(_self_->setTermCriteria(val)); |  | 72655 | ERRWRAP2(_self_->setTermCriteria(val));
| 72704 | Py_RETURN_NONE; |  | 72656 | Py_RETURN_NONE;
| 72705 | } |  | 72657 | }
| 72706 |  |  | 72658 |
| 72707 | return NULL; |  | 72659 | return NULL;
| 72708 | } |  | 72660 | }
| 72709 |  |  | 72661 |
| 72710 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72662 | static PyObject* pyopencv_cv_ml_ml_LogisticRegression_setTrainMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 72711 | { |  | 72663 | {
| 72712 | using namespace cv::ml; |  | 72664 | using namespace cv::ml;
| 72713 |  |  | 72665 |
| 72714 |  |  | 72666 |
| 72715 | Ptr<cv::ml::LogisticRegression> * self1 = 0; |  | 72667 | Ptr<cv::ml::LogisticRegression> * self1 = 0;
| 72716 | if (!pyopencv_ml_LogisticRegression_getp(self, self1)) |  | 72668 | if (!pyopencv_ml_LogisticRegression_getp(self, self1))
| 72717 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)"); |  | 72669 | return failmsgp("Incorrect type of self (must be 'ml_LogisticRegression' or its derivative)");
| 72718 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1); |  | 72670 | Ptr<cv::ml::LogisticRegression> _self_ = *(self1);
| 72719 | PyObject* pyobj_val = NULL; |  | 72671 | PyObject* pyobj_val = NULL;
| 72720 | int val=0; |  | 72672 | int val=0;
| 72721 |  |  | 72673 |
| 72722 | const char* keywords[] = { "val", NULL }; |  | 72674 | const char* keywords[] = { "val", NULL };
| 72723 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setTrainMethod", (char**)keywords, &pyobj_val) && |  | 72675 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_LogisticRegression.setTrainMethod", (char**)keywords, &pyobj_val) &&
| 72724 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 72676 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 72725 | { |  | 72677 | {
| 72726 | ERRWRAP2(_self_->setTrainMethod(val)); |  | 72678 | ERRWRAP2(_self_->setTrainMethod(val));
| 72727 | Py_RETURN_NONE; |  | 72679 | Py_RETURN_NONE;
| 72728 | } |  | 72680 | }
| 72729 |  |  | 72681 |
| 72730 | return NULL; |  | 72682 | return NULL;
| 72731 | } |  | 72683 | }
| 72732 |  |  | 72684 |
| 72733 |  |  | 72685 |
| 72734 |  |  | 72686 |
| 72735 | // Tables (ml_LogisticRegression) |  | 72687 | // Tables (ml_LogisticRegression)
| 72736 |  |  | 72688 |
| 72737 | static PyGetSetDef pyopencv_ml_LogisticRegression_getseters[] = |  | 72689 | static PyGetSetDef pyopencv_ml_LogisticRegression_getseters[] =
| 72738 | { |  | 72690 | {
| 72739 | {NULL} /* Sentinel */ |  | 72691 | {NULL} /* Sentinel */
| 72740 | }; |  | 72692 | };
| 72741 |  |  | 72693 |
| 72742 | static PyMethodDef pyopencv_ml_LogisticRegression_methods[] = |  | 72694 | static PyMethodDef pyopencv_ml_LogisticRegression_methods[] =
| 72743 | { |  | 72695 | {
| 72744 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_create_static, METH_STATIC), "create() -> retval\n. @brief Creates empty model.\n. \n. Creates Logistic Regression model with parameters given."}, |  | 72696 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_create_static, METH_STATIC), "create() -> retval\n. @brief Creates empty model.\n. \n. Creates Logistic Regression model with parameters given."},
| 72745 | {"getIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getIterations, 0), "getIterations() -> retval\n. @see setIterations"}, |  | 72697 | {"getIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getIterations, 0), "getIterations() -> retval\n. @see setIterations"},
| 72746 | {"getLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getLearningRate, 0), "getLearningRate() -> retval\n. @see setLearningRate"}, |  | 72698 | {"getLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getLearningRate, 0), "getLearningRate() -> retval\n. @see setLearningRate"},
| 72747 | {"getMiniBatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getMiniBatchSize, 0), "getMiniBatchSize() -> retval\n. @see setMiniBatchSize"}, |  | 72699 | {"getMiniBatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getMiniBatchSize, 0), "getMiniBatchSize() -> retval\n. @see setMiniBatchSize"},
| 72748 | {"getRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getRegularization, 0), "getRegularization() -> retval\n. @see setRegularization"}, |  | 72700 | {"getRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getRegularization, 0), "getRegularization() -> retval\n. @see setRegularization"},
| 72749 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"}, |  | 72701 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"},
| 72750 | {"getTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getTrainMethod, 0), "getTrainMethod() -> retval\n. @see setTrainMethod"}, |  | 72702 | {"getTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_getTrainMethod, 0), "getTrainMethod() -> retval\n. @see setTrainMethod"},
| 72751 | {"get_learnt_thetas", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_get_learnt_thetas, 0), "get_learnt_thetas() -> retval\n. @brief This function returns the trained parameters arranged across rows.\n. \n. For a two class classification problem, it returns a row matrix. It returns learnt parameters of\n. the Logistic Regression as a matrix of type CV_32F."}, |  | 72703 | {"get_learnt_thetas", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_get_learnt_thetas, 0), "get_learnt_thetas() -> retval\n. @brief This function returns the trained parameters arranged across rows.\n. \n. For a two class classification problem, it returns a row matrix. It returns learnt parameters of\n. the Logistic Regression as a matrix of type CV_32F."},
| 72752 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized LogisticRegression from a file\n. *\n. * Use LogisticRegression::save to serialize and store an LogisticRegression to disk.\n. * Load the LogisticRegression from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized LogisticRegression\n. * @param nodeName name of node containing the classifier"}, |  | 72704 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized LogisticRegression from a file\n. *\n. * Use LogisticRegression::save to serialize and store an LogisticRegression to disk.\n. * Load the LogisticRegression from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized LogisticRegression\n. * @param nodeName name of node containing the classifier"},
| 72753 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_predict, 0), "predict(samples[, results[, flags]]) -> retval, results\n. @brief Predicts responses for input samples and returns a float type.\n. \n. @param samples The input data for the prediction algorithm. Matrix [m x n], where each row\n. contains variables (features) of one object being classified. Should have data type CV_32F.\n. @param results Predicted labels as a column matrix of type CV_32S.\n. @param flags Not used."}, |  | 72705 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_predict, 0), "predict(samples[, results[, flags]]) -> retval, results\n. @brief Predicts responses for input samples and returns a float type.\n. \n. @param samples The input data for the prediction algorithm. Matrix [m x n], where each row\n. contains variables (features) of one object being classified. Should have data type CV_32F.\n. @param results Predicted labels as a column matrix of type CV_32S.\n. @param flags Not used."},
| 72754 | {"setIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setIterations, 0), "setIterations(val) -> None\n. @copybrief getIterations @see getIterations"}, |  | 72706 | {"setIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setIterations, 0), "setIterations(val) -> None\n. @copybrief getIterations @see getIterations"},
| 72755 | {"setLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setLearningRate, 0), "setLearningRate(val) -> None\n. @copybrief getLearningRate @see getLearningRate"}, |  | 72707 | {"setLearningRate", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setLearningRate, 0), "setLearningRate(val) -> None\n. @copybrief getLearningRate @see getLearningRate"},
| 72756 | {"setMiniBatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setMiniBatchSize, 0), "setMiniBatchSize(val) -> None\n. @copybrief getMiniBatchSize @see getMiniBatchSize"}, |  | 72708 | {"setMiniBatchSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setMiniBatchSize, 0), "setMiniBatchSize(val) -> None\n. @copybrief getMiniBatchSize @see getMiniBatchSize"},
| 72757 | {"setRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setRegularization, 0), "setRegularization(val) -> None\n. @copybrief getRegularization @see getRegularization"}, |  | 72709 | {"setRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setRegularization, 0), "setRegularization(val) -> None\n. @copybrief getRegularization @see getRegularization"},
| 72758 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"}, |  | 72710 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"},
| 72759 | {"setTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setTrainMethod, 0), "setTrainMethod(val) -> None\n. @copybrief getTrainMethod @see getTrainMethod"}, |  | 72711 | {"setTrainMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_LogisticRegression_setTrainMethod, 0), "setTrainMethod(val) -> None\n. @copybrief getTrainMethod @see getTrainMethod"},
| 72760 |  |  | 72712 |
| 72761 | {NULL, NULL} |  | 72713 | {NULL, NULL}
| 72762 | }; |  | 72714 | };
| 72763 |  |  | 72715 |
| 72764 | // Converter (ml_LogisticRegression) |  | 72716 | // Converter (ml_LogisticRegression)
| 72765 |  |  | 72717 |
| 72766 | template<> |  | 72718 | template<>
| 72767 | struct PyOpenCV_Converter< Ptr<cv::ml::LogisticRegression> > |  | 72719 | struct PyOpenCV_Converter< Ptr<cv::ml::LogisticRegression> >
| 72768 | { |  | 72720 | {
| 72769 | static PyObject* from(const Ptr<cv::ml::LogisticRegression>& r) |  | 72721 | static PyObject* from(const Ptr<cv::ml::LogisticRegression>& r)
| 72770 | { |  | 72722 | {
| 72771 | return pyopencv_ml_LogisticRegression_Instance(r); |  | 72723 | return pyopencv_ml_LogisticRegression_Instance(r);
| 72772 | } |  | 72724 | }
| 72773 | static bool to(PyObject* src, Ptr<cv::ml::LogisticRegression>& dst, const ArgInfo& info) |  | 72725 | static bool to(PyObject* src, Ptr<cv::ml::LogisticRegression>& dst, const ArgInfo& info)
| 72774 | { |  | 72726 | {
| 72775 | if(!src || src == Py_None) |  | 72727 | if(!src || src == Py_None)
| 72776 | return true; |  | 72728 | return true;
| 72777 | Ptr<cv::ml::LogisticRegression> * dst_; |  | 72729 | Ptr<cv::ml::LogisticRegression> * dst_;
| 72778 | if (pyopencv_ml_LogisticRegression_getp(src, dst_)) |  | 72730 | if (pyopencv_ml_LogisticRegression_getp(src, dst_))
| 72779 | { |  | 72731 | {
| 72780 | dst = *dst_; |  | 72732 | dst = *dst_;
| 72781 | return true; |  | 72733 | return true;
| 72782 | } |  | 72734 | }
| 72783 |  |  | 72735 |
| 72784 | failmsg("Expected Ptr<cv::ml::LogisticRegression> for argument '%s'", info.name); |  | 72736 | failmsg("Expected Ptr<cv::ml::LogisticRegression> for argument '%s'", info.name);
| 72785 | return false; |  | 72737 | return false;
| 72786 | } |  | 72738 | }
| 72787 | }; |  | 72739 | };
| 72788 |  |  | 72740 |
| 72789 | //================================================================================ |  | 72741 | //================================================================================
| 72790 | // ml_NormalBayesClassifier (Generic) |  | 72742 | // ml_NormalBayesClassifier (Generic)
| 72791 | //================================================================================ |  | 72743 | //================================================================================
| 72792 |  |  | 72744 |
| 72793 | // GetSet (ml_NormalBayesClassifier) |  | 72745 | // GetSet (ml_NormalBayesClassifier)
| 72794 |  |  | 72746 |
| 72795 |  |  | 72747 |
| 72796 |  |  | 72748 |
| 72797 | // Methods (ml_NormalBayesClassifier) |  | 72749 | // Methods (ml_NormalBayesClassifier)
| 72798 |  |  | 72750 |
| 72799 | static PyObject* pyopencv_cv_ml_ml_NormalBayesClassifier_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72751 | static PyObject* pyopencv_cv_ml_ml_NormalBayesClassifier_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 72800 | { |  | 72752 | {
| 72801 | using namespace cv::ml; |  | 72753 | using namespace cv::ml;
| 72802 |  |  | 72754 |
| 72803 | Ptr<NormalBayesClassifier> retval; |  | 72755 | Ptr<NormalBayesClassifier> retval;
| 72804 |  |  | 72756 |
| 72805 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 72757 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 72806 | { |  | 72758 | {
| 72807 | ERRWRAP2(retval = cv::ml::NormalBayesClassifier::create()); |  | 72759 | ERRWRAP2(retval = cv::ml::NormalBayesClassifier::create());
| 72808 | return pyopencv_from(retval); |  | 72760 | return pyopencv_from(retval);
| 72809 | } |  | 72761 | }
| 72810 |  |  | 72762 |
| 72811 | return NULL; |  | 72763 | return NULL;
| 72812 | } |  | 72764 | }
| 72813 |  |  | 72765 |
| 72814 | static PyObject* pyopencv_cv_ml_ml_NormalBayesClassifier_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72766 | static PyObject* pyopencv_cv_ml_ml_NormalBayesClassifier_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 72815 | { |  | 72767 | {
| 72816 | using namespace cv::ml; |  | 72768 | using namespace cv::ml;
| 72817 |  |  | 72769 |
| 72818 | PyObject* pyobj_filepath = NULL; |  | 72770 | PyObject* pyobj_filepath = NULL;
| 72819 | String filepath; |  | 72771 | String filepath;
| 72820 | PyObject* pyobj_nodeName = NULL; |  | 72772 | PyObject* pyobj_nodeName = NULL;
| 72821 | String nodeName; |  | 72773 | String nodeName;
| 72822 | Ptr<NormalBayesClassifier> retval; |  | 72774 | Ptr<NormalBayesClassifier> retval;
| 72823 |  |  | 72775 |
| 72824 | const char* keywords[] = { "filepath", "nodeName", NULL }; |  | 72776 | const char* keywords[] = { "filepath", "nodeName", NULL };
| 72825 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_NormalBayesClassifier.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) && |  | 72777 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_NormalBayesClassifier.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) &&
| 72826 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) && |  | 72778 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) &&
| 72827 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) ) |  | 72779 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) )
| 72828 | { |  | 72780 | {
| 72829 | ERRWRAP2(retval = cv::ml::NormalBayesClassifier::load(filepath, nodeName)); |  | 72781 | ERRWRAP2(retval = cv::ml::NormalBayesClassifier::load(filepath, nodeName));
| 72830 | return pyopencv_from(retval); |  | 72782 | return pyopencv_from(retval);
| 72831 | } |  | 72783 | }
| 72832 |  |  | 72784 |
| 72833 | return NULL; |  | 72785 | return NULL;
| 72834 | } |  | 72786 | }
| 72835 |  |  | 72787 |
| 72836 | static PyObject* pyopencv_cv_ml_ml_NormalBayesClassifier_predictProb(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72788 | static PyObject* pyopencv_cv_ml_ml_NormalBayesClassifier_predictProb(PyObject* self, PyObject* py_args, PyObject* kw)
| 72837 | { |  | 72789 | {
| 72838 | using namespace cv::ml; |  | 72790 | using namespace cv::ml;
| 72839 |  |  | 72791 |
| 72840 |  |  | 72792 |
| 72841 | Ptr<cv::ml::NormalBayesClassifier> * self1 = 0; |  | 72793 | Ptr<cv::ml::NormalBayesClassifier> * self1 = 0;
| 72842 | if (!pyopencv_ml_NormalBayesClassifier_getp(self, self1)) |  | 72794 | if (!pyopencv_ml_NormalBayesClassifier_getp(self, self1))
| 72843 | return failmsgp("Incorrect type of self (must be 'ml_NormalBayesClassifier' or its derivative)"); |  | 72795 | return failmsgp("Incorrect type of self (must be 'ml_NormalBayesClassifier' or its derivative)");
| 72844 | Ptr<cv::ml::NormalBayesClassifier> _self_ = *(self1); |  | 72796 | Ptr<cv::ml::NormalBayesClassifier> _self_ = *(self1);
| 72845 | pyPrepareArgumentConversionErrorsStorage(2); |  | 72797 | pyPrepareArgumentConversionErrorsStorage(2);
| 72846 |  |  | 72798 |
| 72847 | { |  | 72799 | {
| 72848 | PyObject* pyobj_inputs = NULL; |  | 72800 | PyObject* pyobj_inputs = NULL;
| 72849 | Mat inputs; |  | 72801 | Mat inputs;
| 72850 | PyObject* pyobj_outputs = NULL; |  | 72802 | PyObject* pyobj_outputs = NULL;
| 72851 | Mat outputs; |  | 72803 | Mat outputs;
| 72852 | PyObject* pyobj_outputProbs = NULL; |  | 72804 | PyObject* pyobj_outputProbs = NULL;
| 72853 | Mat outputProbs; |  | 72805 | Mat outputProbs;
| 72854 | PyObject* pyobj_flags = NULL; |  | 72806 | PyObject* pyobj_flags = NULL;
| 72855 | int flags=0; |  | 72807 | int flags=0;
| 72856 | float retval; |  | 72808 | float retval;
| 72857 |  |  | 72809 |
| 72858 | const char* keywords[] = { "inputs", "outputs", "outputProbs", "flags", NULL }; |  | 72810 | const char* keywords[] = { "inputs", "outputs", "outputProbs", "flags", NULL };
| 72859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_NormalBayesClassifier.predictProb", (char**)keywords, &pyobj_inputs, &pyobj_outputs, &pyobj_outputProbs, &pyobj_flags) && |  | 72811 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_NormalBayesClassifier.predictProb", (char**)keywords, &pyobj_inputs, &pyobj_outputs, &pyobj_outputProbs, &pyobj_flags) &&
| 72860 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) && |  | 72812 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) &&
| 72861 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) && |  | 72813 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) &&
| 72862 | pyopencv_to_safe(pyobj_outputProbs, outputProbs, ArgInfo("outputProbs", 1)) && |  | 72814 | pyopencv_to_safe(pyobj_outputProbs, outputProbs, ArgInfo("outputProbs", 1)) &&
| 72863 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 72815 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 72864 | { |  | 72816 | {
| 72865 | ERRWRAP2(retval = _self_->predictProb(inputs, outputs, outputProbs, flags)); |  | 72817 | ERRWRAP2(retval = _self_->predictProb(inputs, outputs, outputProbs, flags));
| 72866 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(outputs), pyopencv_from(outputProbs)); |  | 72818 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(outputs), pyopencv_from(outputProbs));
| 72867 | } |  | 72819 | }
| 72868 |  |  | 72820 |
| 72869 |  |  | 72821 |
| 72870 | pyPopulateArgumentConversionErrors(); |  | 72822 | pyPopulateArgumentConversionErrors();
| 72871 | } |  | 72823 | }
| 72872 |  |  | 72824 |
| 72873 |  |  | 72825 |
| 72874 | { |  | 72826 | {
| 72875 | PyObject* pyobj_inputs = NULL; |  | 72827 | PyObject* pyobj_inputs = NULL;
| 72876 | UMat inputs; |  | 72828 | UMat inputs;
| 72877 | PyObject* pyobj_outputs = NULL; |  | 72829 | PyObject* pyobj_outputs = NULL;
| 72878 | UMat outputs; |  | 72830 | UMat outputs;
| 72879 | PyObject* pyobj_outputProbs = NULL; |  | 72831 | PyObject* pyobj_outputProbs = NULL;
| 72880 | UMat outputProbs; |  | 72832 | UMat outputProbs;
| 72881 | PyObject* pyobj_flags = NULL; |  | 72833 | PyObject* pyobj_flags = NULL;
| 72882 | int flags=0; |  | 72834 | int flags=0;
| 72883 | float retval; |  | 72835 | float retval;
| 72884 |  |  | 72836 |
| 72885 | const char* keywords[] = { "inputs", "outputs", "outputProbs", "flags", NULL }; |  | 72837 | const char* keywords[] = { "inputs", "outputs", "outputProbs", "flags", NULL };
| 72886 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_NormalBayesClassifier.predictProb", (char**)keywords, &pyobj_inputs, &pyobj_outputs, &pyobj_outputProbs, &pyobj_flags) && |  | 72838 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOO:ml_NormalBayesClassifier.predictProb", (char**)keywords, &pyobj_inputs, &pyobj_outputs, &pyobj_outputProbs, &pyobj_flags) &&
| 72887 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) && |  | 72839 | pyopencv_to_safe(pyobj_inputs, inputs, ArgInfo("inputs", 0)) &&
| 72888 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) && |  | 72840 | pyopencv_to_safe(pyobj_outputs, outputs, ArgInfo("outputs", 1)) &&
| 72889 | pyopencv_to_safe(pyobj_outputProbs, outputProbs, ArgInfo("outputProbs", 1)) && |  | 72841 | pyopencv_to_safe(pyobj_outputProbs, outputProbs, ArgInfo("outputProbs", 1)) &&
| 72890 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 72842 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 72891 | { |  | 72843 | {
| 72892 | ERRWRAP2(retval = _self_->predictProb(inputs, outputs, outputProbs, flags)); |  | 72844 | ERRWRAP2(retval = _self_->predictProb(inputs, outputs, outputProbs, flags));
| 72893 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(outputs), pyopencv_from(outputProbs)); |  | 72845 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(outputs), pyopencv_from(outputProbs));
| 72894 | } |  | 72846 | }
| 72895 |  |  | 72847 |
| 72896 |  |  | 72848 |
| 72897 | pyPopulateArgumentConversionErrors(); |  | 72849 | pyPopulateArgumentConversionErrors();
| 72898 | } |  | 72850 | }
| 72899 | pyRaiseCVOverloadException("predictProb"); |  | 72851 | pyRaiseCVOverloadException("predictProb");
| 72900 |  |  | 72852 |
| 72901 | return NULL; |  | 72853 | return NULL;
| 72902 | } |  | 72854 | }
| 72903 |  |  | 72855 |
| 72904 |  |  | 72856 |
| 72905 |  |  | 72857 |
| 72906 | // Tables (ml_NormalBayesClassifier) |  | 72858 | // Tables (ml_NormalBayesClassifier)
| 72907 |  |  | 72859 |
| 72908 | static PyGetSetDef pyopencv_ml_NormalBayesClassifier_getseters[] = |  | 72860 | static PyGetSetDef pyopencv_ml_NormalBayesClassifier_getseters[] =
| 72909 | { |  | 72861 | {
| 72910 | {NULL} /* Sentinel */ |  | 72862 | {NULL} /* Sentinel */
| 72911 | }; |  | 72863 | };
| 72912 |  |  | 72864 |
| 72913 | static PyMethodDef pyopencv_ml_NormalBayesClassifier_methods[] = |  | 72865 | static PyMethodDef pyopencv_ml_NormalBayesClassifier_methods[] =
| 72914 | { |  | 72866 | {
| 72915 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_NormalBayesClassifier_create_static, METH_STATIC), "create() -> retval\n. Creates empty model\n. Use StatModel::train to train the model after creation."}, |  | 72867 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_NormalBayesClassifier_create_static, METH_STATIC), "create() -> retval\n. Creates empty model\n. Use StatModel::train to train the model after creation."},
| 72916 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_NormalBayesClassifier_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized NormalBayesClassifier from a file\n. *\n. * Use NormalBayesClassifier::save to serialize and store an NormalBayesClassifier to disk.\n. * Load the NormalBayesClassifier from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized NormalBayesClassifier\n. * @param nodeName name of node containing the classifier"}, |  | 72868 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_NormalBayesClassifier_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized NormalBayesClassifier from a file\n. *\n. * Use NormalBayesClassifier::save to serialize and store an NormalBayesClassifier to disk.\n. * Load the NormalBayesClassifier from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized NormalBayesClassifier\n. * @param nodeName name of node containing the classifier"},
| 72917 | {"predictProb", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_NormalBayesClassifier_predictProb, 0), "predictProb(inputs[, outputs[, outputProbs[, flags]]]) -> retval, outputs, outputProbs\n. @brief Predicts the response for sample(s).\n. \n. The method estimates the most probable classes for input vectors. Input vectors (one or more)\n. are stored as rows of the matrix inputs. In case of multiple input vectors, there should be one\n. output vector outputs. The predicted class for a single input vector is returned by the method.\n. The vector outputProbs contains the output probabilities corresponding to each element of\n. result."}, |  | 72869 | {"predictProb", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_NormalBayesClassifier_predictProb, 0), "predictProb(inputs[, outputs[, outputProbs[, flags]]]) -> retval, outputs, outputProbs\n. @brief Predicts the response for sample(s).\n. \n. The method estimates the most probable classes for input vectors. Input vectors (one or more)\n. are stored as rows of the matrix inputs. In case of multiple input vectors, there should be one\n. output vector outputs. The predicted class for a single input vector is returned by the method.\n. The vector outputProbs contains the output probabilities corresponding to each element of\n. result."},
| 72918 |  |  | 72870 |
| 72919 | {NULL, NULL} |  | 72871 | {NULL, NULL}
| 72920 | }; |  | 72872 | };
| 72921 |  |  | 72873 |
| 72922 | // Converter (ml_NormalBayesClassifier) |  | 72874 | // Converter (ml_NormalBayesClassifier)
| 72923 |  |  | 72875 |
| 72924 | template<> |  | 72876 | template<>
| 72925 | struct PyOpenCV_Converter< Ptr<cv::ml::NormalBayesClassifier> > |  | 72877 | struct PyOpenCV_Converter< Ptr<cv::ml::NormalBayesClassifier> >
| 72926 | { |  | 72878 | {
| 72927 | static PyObject* from(const Ptr<cv::ml::NormalBayesClassifier>& r) |  | 72879 | static PyObject* from(const Ptr<cv::ml::NormalBayesClassifier>& r)
| 72928 | { |  | 72880 | {
| 72929 | return pyopencv_ml_NormalBayesClassifier_Instance(r); |  | 72881 | return pyopencv_ml_NormalBayesClassifier_Instance(r);
| 72930 | } |  | 72882 | }
| 72931 | static bool to(PyObject* src, Ptr<cv::ml::NormalBayesClassifier>& dst, const ArgInfo& info) |  | 72883 | static bool to(PyObject* src, Ptr<cv::ml::NormalBayesClassifier>& dst, const ArgInfo& info)
| 72932 | { |  | 72884 | {
| 72933 | if(!src || src == Py_None) |  | 72885 | if(!src || src == Py_None)
| 72934 | return true; |  | 72886 | return true;
| 72935 | Ptr<cv::ml::NormalBayesClassifier> * dst_; |  | 72887 | Ptr<cv::ml::NormalBayesClassifier> * dst_;
| 72936 | if (pyopencv_ml_NormalBayesClassifier_getp(src, dst_)) |  | 72888 | if (pyopencv_ml_NormalBayesClassifier_getp(src, dst_))
| 72937 | { |  | 72889 | {
| 72938 | dst = *dst_; |  | 72890 | dst = *dst_;
| 72939 | return true; |  | 72891 | return true;
| 72940 | } |  | 72892 | }
| 72941 |  |  | 72893 |
| 72942 | failmsg("Expected Ptr<cv::ml::NormalBayesClassifier> for argument '%s'", info.name); |  | 72894 | failmsg("Expected Ptr<cv::ml::NormalBayesClassifier> for argument '%s'", info.name);
| 72943 | return false; |  | 72895 | return false;
| 72944 | } |  | 72896 | }
| 72945 | }; |  | 72897 | };
| 72946 |  |  | 72898 |
| 72947 | //================================================================================ |  | 72899 | //================================================================================
| 72948 | // ml_ParamGrid (Generic) |  | 72900 | // ml_ParamGrid (Generic)
| 72949 | //================================================================================ |  | 72901 | //================================================================================
| 72950 |  |  | 72902 |
| 72951 | // GetSet (ml_ParamGrid) |  | 72903 | // GetSet (ml_ParamGrid)
| 72952 |  |  | 72904 |
| 72953 |  |  | 72905 |
| 72954 | static PyObject* pyopencv_ml_ParamGrid_get_logStep(pyopencv_ml_ParamGrid_t* p, void *closure) |  | 72906 | static PyObject* pyopencv_ml_ParamGrid_get_logStep(pyopencv_ml_ParamGrid_t* p, void *closure)
| 72955 | { |  | 72907 | {
| 72956 | return pyopencv_from(p->v->logStep); |  | 72908 | return pyopencv_from(p->v->logStep);
| 72957 | } |  | 72909 | }
| 72958 |  |  | 72910 |
| 72959 | static int pyopencv_ml_ParamGrid_set_logStep(pyopencv_ml_ParamGrid_t* p, PyObject *value, void *closure) |  | 72911 | static int pyopencv_ml_ParamGrid_set_logStep(pyopencv_ml_ParamGrid_t* p, PyObject *value, void *closure)
| 72960 | { |  | 72912 | {
| 72961 | if (!value) |  | 72913 | if (!value)
| 72962 | { |  | 72914 | {
| 72963 | PyErr_SetString(PyExc_TypeError, "Cannot delete the logStep attribute"); |  | 72915 | PyErr_SetString(PyExc_TypeError, "Cannot delete the logStep attribute");
| 72964 | return -1; |  | 72916 | return -1;
| 72965 | } |  | 72917 | }
| 72966 | return pyopencv_to_safe(value, p->v->logStep, ArgInfo("value", 0)) ? 0 : -1; |  | 72918 | return pyopencv_to_safe(value, p->v->logStep, ArgInfo("value", 0)) ? 0 : -1;
| 72967 | } |  | 72919 | }
| 72968 |  |  | 72920 |
| 72969 | static PyObject* pyopencv_ml_ParamGrid_get_maxVal(pyopencv_ml_ParamGrid_t* p, void *closure) |  | 72921 | static PyObject* pyopencv_ml_ParamGrid_get_maxVal(pyopencv_ml_ParamGrid_t* p, void *closure)
| 72970 | { |  | 72922 | {
| 72971 | return pyopencv_from(p->v->maxVal); |  | 72923 | return pyopencv_from(p->v->maxVal);
| 72972 | } |  | 72924 | }
| 72973 |  |  | 72925 |
| 72974 | static int pyopencv_ml_ParamGrid_set_maxVal(pyopencv_ml_ParamGrid_t* p, PyObject *value, void *closure) |  | 72926 | static int pyopencv_ml_ParamGrid_set_maxVal(pyopencv_ml_ParamGrid_t* p, PyObject *value, void *closure)
| 72975 | { |  | 72927 | {
| 72976 | if (!value) |  | 72928 | if (!value)
| 72977 | { |  | 72929 | {
| 72978 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxVal attribute"); |  | 72930 | PyErr_SetString(PyExc_TypeError, "Cannot delete the maxVal attribute");
| 72979 | return -1; |  | 72931 | return -1;
| 72980 | } |  | 72932 | }
| 72981 | return pyopencv_to_safe(value, p->v->maxVal, ArgInfo("value", 0)) ? 0 : -1; |  | 72933 | return pyopencv_to_safe(value, p->v->maxVal, ArgInfo("value", 0)) ? 0 : -1;
| 72982 | } |  | 72934 | }
| 72983 |  |  | 72935 |
| 72984 | static PyObject* pyopencv_ml_ParamGrid_get_minVal(pyopencv_ml_ParamGrid_t* p, void *closure) |  | 72936 | static PyObject* pyopencv_ml_ParamGrid_get_minVal(pyopencv_ml_ParamGrid_t* p, void *closure)
| 72985 | { |  | 72937 | {
| 72986 | return pyopencv_from(p->v->minVal); |  | 72938 | return pyopencv_from(p->v->minVal);
| 72987 | } |  | 72939 | }
| 72988 |  |  | 72940 |
| 72989 | static int pyopencv_ml_ParamGrid_set_minVal(pyopencv_ml_ParamGrid_t* p, PyObject *value, void *closure) |  | 72941 | static int pyopencv_ml_ParamGrid_set_minVal(pyopencv_ml_ParamGrid_t* p, PyObject *value, void *closure)
| 72990 | { |  | 72942 | {
| 72991 | if (!value) |  | 72943 | if (!value)
| 72992 | { |  | 72944 | {
| 72993 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minVal attribute"); |  | 72945 | PyErr_SetString(PyExc_TypeError, "Cannot delete the minVal attribute");
| 72994 | return -1; |  | 72946 | return -1;
| 72995 | } |  | 72947 | }
| 72996 | return pyopencv_to_safe(value, p->v->minVal, ArgInfo("value", 0)) ? 0 : -1; |  | 72948 | return pyopencv_to_safe(value, p->v->minVal, ArgInfo("value", 0)) ? 0 : -1;
| 72997 | } |  | 72949 | }
| 72998 |  |  | 72950 |
| 72999 |  |  | 72951 |
| 73000 | // Methods (ml_ParamGrid) |  | 72952 | // Methods (ml_ParamGrid)
| 73001 |  |  | 72953 |
| 73002 | static PyObject* pyopencv_cv_ml_ml_ParamGrid_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 72954 | static PyObject* pyopencv_cv_ml_ml_ParamGrid_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 73003 | { |  | 72955 | {
| 73004 | using namespace cv::ml; |  | 72956 | using namespace cv::ml;
| 73005 |  |  | 72957 |
| 73006 | PyObject* pyobj_minVal = NULL; |  | 72958 | PyObject* pyobj_minVal = NULL;
| 73007 | double minVal=0.; |  | 72959 | double minVal=0.;
| 73008 | PyObject* pyobj_maxVal = NULL; |  | 72960 | PyObject* pyobj_maxVal = NULL;
| 73009 | double maxVal=0.; |  | 72961 | double maxVal=0.;
| 73010 | PyObject* pyobj_logstep = NULL; |  | 72962 | PyObject* pyobj_logstep = NULL;
| 73011 | double logstep=1.; |  | 72963 | double logstep=1.;
| 73012 | Ptr<ParamGrid> retval; |  | 72964 | Ptr<ParamGrid> retval;
| 73013 |  |  | 72965 |
| 73014 | const char* keywords[] = { "minVal", "maxVal", "logstep", NULL }; |  | 72966 | const char* keywords[] = { "minVal", "maxVal", "logstep", NULL };
| 73015 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:ml_ParamGrid.create", (char**)keywords, &pyobj_minVal, &pyobj_maxVal, &pyobj_logstep) && |  | 72967 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:ml_ParamGrid.create", (char**)keywords, &pyobj_minVal, &pyobj_maxVal, &pyobj_logstep) &&
| 73016 | pyopencv_to_safe(pyobj_minVal, minVal, ArgInfo("minVal", 0)) && |  | 72968 | pyopencv_to_safe(pyobj_minVal, minVal, ArgInfo("minVal", 0)) &&
| 73017 | pyopencv_to_safe(pyobj_maxVal, maxVal, ArgInfo("maxVal", 0)) && |  | 72969 | pyopencv_to_safe(pyobj_maxVal, maxVal, ArgInfo("maxVal", 0)) &&
| 73018 | pyopencv_to_safe(pyobj_logstep, logstep, ArgInfo("logstep", 0)) ) |  | 72970 | pyopencv_to_safe(pyobj_logstep, logstep, ArgInfo("logstep", 0)) )
| 73019 | { |  | 72971 | {
| 73020 | ERRWRAP2(retval = cv::ml::ParamGrid::create(minVal, maxVal, logstep)); |  | 72972 | ERRWRAP2(retval = cv::ml::ParamGrid::create(minVal, maxVal, logstep));
| 73021 | return pyopencv_from(retval); |  | 72973 | return pyopencv_from(retval);
| 73022 | } |  | 72974 | }
| 73023 |  |  | 72975 |
| 73024 | return NULL; |  | 72976 | return NULL;
| 73025 | } |  | 72977 | }
| 73026 |  |  | 72978 |
| 73027 |  |  | 72979 |
| 73028 |  |  | 72980 |
| 73029 | // Tables (ml_ParamGrid) |  | 72981 | // Tables (ml_ParamGrid)
| 73030 |  |  | 72982 |
| 73031 | static PyGetSetDef pyopencv_ml_ParamGrid_getseters[] = |  | 72983 | static PyGetSetDef pyopencv_ml_ParamGrid_getseters[] =
| 73032 | { |  | 72984 | {
| 73033 | {(char*)"logStep", (getter)pyopencv_ml_ParamGrid_get_logStep, (setter)pyopencv_ml_ParamGrid_set_logStep, (char*)"logStep", NULL}, |  | 72985 | {(char*)"logStep", (getter)pyopencv_ml_ParamGrid_get_logStep, (setter)pyopencv_ml_ParamGrid_set_logStep, (char*)"logStep", NULL},
| 73034 | {(char*)"maxVal", (getter)pyopencv_ml_ParamGrid_get_maxVal, (setter)pyopencv_ml_ParamGrid_set_maxVal, (char*)"maxVal", NULL}, |  | 72986 | {(char*)"maxVal", (getter)pyopencv_ml_ParamGrid_get_maxVal, (setter)pyopencv_ml_ParamGrid_set_maxVal, (char*)"maxVal", NULL},
| 73035 | {(char*)"minVal", (getter)pyopencv_ml_ParamGrid_get_minVal, (setter)pyopencv_ml_ParamGrid_set_minVal, (char*)"minVal", NULL}, |  | 72987 | {(char*)"minVal", (getter)pyopencv_ml_ParamGrid_get_minVal, (setter)pyopencv_ml_ParamGrid_set_minVal, (char*)"minVal", NULL},
| 73036 | {NULL} /* Sentinel */ |  | 72988 | {NULL} /* Sentinel */
| 73037 | }; |  | 72989 | };
| 73038 |  |  | 72990 |
| 73039 | static PyMethodDef pyopencv_ml_ParamGrid_methods[] = |  | 72991 | static PyMethodDef pyopencv_ml_ParamGrid_methods[] =
| 73040 | { |  | 72992 | {
| 73041 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ParamGrid_create_static, METH_STATIC), "create([, minVal[, maxVal[, logstep]]]) -> retval\n. @brief Creates a ParamGrid Ptr that can be given to the %SVM::trainAuto method\n. \n. @param minVal minimum value of the parameter grid\n. @param maxVal maximum value of the parameter grid\n. @param logstep Logarithmic step for iterating the statmodel parameter"}, |  | 72993 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_ParamGrid_create_static, METH_STATIC), "create([, minVal[, maxVal[, logstep]]]) -> retval\n. @brief Creates a ParamGrid Ptr that can be given to the %SVM::trainAuto method\n. \n. @param minVal minimum value of the parameter grid\n. @param maxVal maximum value of the parameter grid\n. @param logstep Logarithmic step for iterating the statmodel parameter"},
| 73042 |  |  | 72994 |
| 73043 | {NULL, NULL} |  | 72995 | {NULL, NULL}
| 73044 | }; |  | 72996 | };
| 73045 |  |  | 72997 |
| 73046 | // Converter (ml_ParamGrid) |  | 72998 | // Converter (ml_ParamGrid)
| 73047 |  |  | 72999 |
| 73048 | template<> |  | 73000 | template<>
| 73049 | struct PyOpenCV_Converter< Ptr<cv::ml::ParamGrid> > |  | 73001 | struct PyOpenCV_Converter< Ptr<cv::ml::ParamGrid> >
| 73050 | { |  | 73002 | {
| 73051 | static PyObject* from(const Ptr<cv::ml::ParamGrid>& r) |  | 73003 | static PyObject* from(const Ptr<cv::ml::ParamGrid>& r)
| 73052 | { |  | 73004 | {
| 73053 | return pyopencv_ml_ParamGrid_Instance(r); |  | 73005 | return pyopencv_ml_ParamGrid_Instance(r);
| 73054 | } |  | 73006 | }
| 73055 | static bool to(PyObject* src, Ptr<cv::ml::ParamGrid>& dst, const ArgInfo& info) |  | 73007 | static bool to(PyObject* src, Ptr<cv::ml::ParamGrid>& dst, const ArgInfo& info)
| 73056 | { |  | 73008 | {
| 73057 | if(!src || src == Py_None) |  | 73009 | if(!src || src == Py_None)
| 73058 | return true; |  | 73010 | return true;
| 73059 | Ptr<cv::ml::ParamGrid> * dst_; |  | 73011 | Ptr<cv::ml::ParamGrid> * dst_;
| 73060 | if (pyopencv_ml_ParamGrid_getp(src, dst_)) |  | 73012 | if (pyopencv_ml_ParamGrid_getp(src, dst_))
| 73061 | { |  | 73013 | {
| 73062 | dst = *dst_; |  | 73014 | dst = *dst_;
| 73063 | return true; |  | 73015 | return true;
| 73064 | } |  | 73016 | }
| 73065 |  |  | 73017 |
| 73066 | failmsg("Expected Ptr<cv::ml::ParamGrid> for argument '%s'", info.name); |  | 73018 | failmsg("Expected Ptr<cv::ml::ParamGrid> for argument '%s'", info.name);
| 73067 | return false; |  | 73019 | return false;
| 73068 | } |  | 73020 | }
| 73069 | }; |  | 73021 | };
| 73070 |  |  | 73022 |
| 73071 | //================================================================================ |  | 73023 | //================================================================================
| 73072 | // ml_RTrees (Generic) |  | 73024 | // ml_RTrees (Generic)
| 73073 | //================================================================================ |  | 73025 | //================================================================================
| 73074 |  |  | 73026 |
| 73075 | // GetSet (ml_RTrees) |  | 73027 | // GetSet (ml_RTrees)
| 73076 |  |  | 73028 |
| 73077 |  |  | 73029 |
| 73078 |  |  | 73030 |
| 73079 | // Methods (ml_RTrees) |  | 73031 | // Methods (ml_RTrees)
| 73080 |  |  | 73032 |
| 73081 | static PyObject* pyopencv_cv_ml_ml_RTrees_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73033 | static PyObject* pyopencv_cv_ml_ml_RTrees_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 73082 | { |  | 73034 | {
| 73083 | using namespace cv::ml; |  | 73035 | using namespace cv::ml;
| 73084 |  |  | 73036 |
| 73085 | Ptr<RTrees> retval; |  | 73037 | Ptr<RTrees> retval;
| 73086 |  |  | 73038 |
| 73087 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73039 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73088 | { |  | 73040 | {
| 73089 | ERRWRAP2(retval = cv::ml::RTrees::create()); |  | 73041 | ERRWRAP2(retval = cv::ml::RTrees::create());
| 73090 | return pyopencv_from(retval); |  | 73042 | return pyopencv_from(retval);
| 73091 | } |  | 73043 | }
| 73092 |  |  | 73044 |
| 73093 | return NULL; |  | 73045 | return NULL;
| 73094 | } |  | 73046 | }
| 73095 |  |  | 73047 |
| 73096 | static PyObject* pyopencv_cv_ml_ml_RTrees_getActiveVarCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73048 | static PyObject* pyopencv_cv_ml_ml_RTrees_getActiveVarCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 73097 | { |  | 73049 | {
| 73098 | using namespace cv::ml; |  | 73050 | using namespace cv::ml;
| 73099 |  |  | 73051 |
| 73100 |  |  | 73052 |
| 73101 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73053 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73102 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73054 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73103 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73055 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73104 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73056 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73105 | int retval; |  | 73057 | int retval;
| 73106 |  |  | 73058 |
| 73107 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73059 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73108 | { |  | 73060 | {
| 73109 | ERRWRAP2(retval = _self_->getActiveVarCount()); |  | 73061 | ERRWRAP2(retval = _self_->getActiveVarCount());
| 73110 | return pyopencv_from(retval); |  | 73062 | return pyopencv_from(retval);
| 73111 | } |  | 73063 | }
| 73112 |  |  | 73064 |
| 73113 | return NULL; |  | 73065 | return NULL;
| 73114 | } |  | 73066 | }
| 73115 |  |  | 73067 |
| 73116 | static PyObject* pyopencv_cv_ml_ml_RTrees_getCalculateVarImportance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73068 | static PyObject* pyopencv_cv_ml_ml_RTrees_getCalculateVarImportance(PyObject* self, PyObject* py_args, PyObject* kw)
| 73117 | { |  | 73069 | {
| 73118 | using namespace cv::ml; |  | 73070 | using namespace cv::ml;
| 73119 |  |  | 73071 |
| 73120 |  |  | 73072 |
| 73121 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73073 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73122 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73074 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73123 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73075 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73124 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73076 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73125 | bool retval; |  | 73077 | bool retval;
| 73126 |  |  | 73078 |
| 73127 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73079 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73128 | { |  | 73080 | {
| 73129 | ERRWRAP2(retval = _self_->getCalculateVarImportance()); |  | 73081 | ERRWRAP2(retval = _self_->getCalculateVarImportance());
| 73130 | return pyopencv_from(retval); |  | 73082 | return pyopencv_from(retval);
| 73131 | } |  | 73083 | }
| 73132 |  |  | 73084 |
| 73133 | return NULL; |  | 73085 | return NULL;
| 73134 | } |  | 73086 | }
| 73135 |  |  | 73087 |
| 73136 | static PyObject* pyopencv_cv_ml_ml_RTrees_getOOBError(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73088 | static PyObject* pyopencv_cv_ml_ml_RTrees_getOOBError(PyObject* self, PyObject* py_args, PyObject* kw)
| 73137 | { |  | 73089 | {
| 73138 | using namespace cv::ml; |  | 73090 | using namespace cv::ml;
| 73139 |  |  | 73091 |
| 73140 |  |  | 73092 |
| 73141 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73093 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73142 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73094 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73143 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73095 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73144 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73096 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73145 | double retval; |  | 73097 | double retval;
| 73146 |  |  | 73098 |
| 73147 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73099 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73148 | { |  | 73100 | {
| 73149 | ERRWRAP2(retval = _self_->getOOBError()); |  | 73101 | ERRWRAP2(retval = _self_->getOOBError());
| 73150 | return pyopencv_from(retval); |  | 73102 | return pyopencv_from(retval);
| 73151 | } |  | 73103 | }
| 73152 |  |  | 73104 |
| 73153 | return NULL; |  | 73105 | return NULL;
| 73154 | } |  | 73106 | }
| 73155 |  |  | 73107 |
| 73156 | static PyObject* pyopencv_cv_ml_ml_RTrees_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73108 | static PyObject* pyopencv_cv_ml_ml_RTrees_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 73157 | { |  | 73109 | {
| 73158 | using namespace cv::ml; |  | 73110 | using namespace cv::ml;
| 73159 |  |  | 73111 |
| 73160 |  |  | 73112 |
| 73161 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73113 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73162 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73114 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73163 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73115 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73164 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73116 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73165 | TermCriteria retval; |  | 73117 | TermCriteria retval;
| 73166 |  |  | 73118 |
| 73167 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73119 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73168 | { |  | 73120 | {
| 73169 | ERRWRAP2(retval = _self_->getTermCriteria()); |  | 73121 | ERRWRAP2(retval = _self_->getTermCriteria());
| 73170 | return pyopencv_from(retval); |  | 73122 | return pyopencv_from(retval);
| 73171 | } |  | 73123 | }
| 73172 |  |  | 73124 |
| 73173 | return NULL; |  | 73125 | return NULL;
| 73174 | } |  | 73126 | }
| 73175 |  |  | 73127 |
| 73176 | static PyObject* pyopencv_cv_ml_ml_RTrees_getVarImportance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73128 | static PyObject* pyopencv_cv_ml_ml_RTrees_getVarImportance(PyObject* self, PyObject* py_args, PyObject* kw)
| 73177 | { |  | 73129 | {
| 73178 | using namespace cv::ml; |  | 73130 | using namespace cv::ml;
| 73179 |  |  | 73131 |
| 73180 |  |  | 73132 |
| 73181 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73133 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73182 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73134 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73183 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73135 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73184 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73136 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73185 | Mat retval; |  | 73137 | Mat retval;
| 73186 |  |  | 73138 |
| 73187 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73139 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73188 | { |  | 73140 | {
| 73189 | ERRWRAP2(retval = _self_->getVarImportance()); |  | 73141 | ERRWRAP2(retval = _self_->getVarImportance());
| 73190 | return pyopencv_from(retval); |  | 73142 | return pyopencv_from(retval);
| 73191 | } |  | 73143 | }
| 73192 |  |  | 73144 |
| 73193 | return NULL; |  | 73145 | return NULL;
| 73194 | } |  | 73146 | }
| 73195 |  |  | 73147 |
| 73196 | static PyObject* pyopencv_cv_ml_ml_RTrees_getVotes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73148 | static PyObject* pyopencv_cv_ml_ml_RTrees_getVotes(PyObject* self, PyObject* py_args, PyObject* kw)
| 73197 | { |  | 73149 | {
| 73198 | using namespace cv::ml; |  | 73150 | using namespace cv::ml;
| 73199 |  |  | 73151 |
| 73200 |  |  | 73152 |
| 73201 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73153 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73202 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73154 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73203 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73155 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73204 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73156 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73205 | pyPrepareArgumentConversionErrorsStorage(2); |  | 73157 | pyPrepareArgumentConversionErrorsStorage(2);
| 73206 |  |  | 73158 |
| 73207 | { |  | 73159 | {
| 73208 | PyObject* pyobj_samples = NULL; |  | 73160 | PyObject* pyobj_samples = NULL;
| 73209 | Mat samples; |  | 73161 | Mat samples;
| 73210 | PyObject* pyobj_results = NULL; |  | 73162 | PyObject* pyobj_results = NULL;
| 73211 | Mat results; |  | 73163 | Mat results;
| 73212 | PyObject* pyobj_flags = NULL; |  | 73164 | PyObject* pyobj_flags = NULL;
| 73213 | int flags=0; |  | 73165 | int flags=0;
| 73214 |  |  | 73166 |
| 73215 | const char* keywords[] = { "samples", "flags", "results", NULL }; |  | 73167 | const char* keywords[] = { "samples", "flags", "results", NULL };
| 73216 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_RTrees.getVotes", (char**)keywords, &pyobj_samples, &pyobj_flags, &pyobj_results) && |  | 73168 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_RTrees.getVotes", (char**)keywords, &pyobj_samples, &pyobj_flags, &pyobj_results) &&
| 73217 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 73169 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 73218 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 73170 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 73219 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 73171 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 73220 | { |  | 73172 | {
| 73221 | ERRWRAP2(_self_->getVotes(samples, results, flags)); |  | 73173 | ERRWRAP2(_self_->getVotes(samples, results, flags));
| 73222 | return pyopencv_from(results); |  | 73174 | return pyopencv_from(results);
| 73223 | } |  | 73175 | }
| 73224 |  |  | 73176 |
| 73225 |  |  | 73177 |
| 73226 | pyPopulateArgumentConversionErrors(); |  | 73178 | pyPopulateArgumentConversionErrors();
| 73227 | } |  | 73179 | }
| 73228 |  |  | 73180 |
| 73229 |  |  | 73181 |
| 73230 | { |  | 73182 | {
| 73231 | PyObject* pyobj_samples = NULL; |  | 73183 | PyObject* pyobj_samples = NULL;
| 73232 | UMat samples; |  | 73184 | UMat samples;
| 73233 | PyObject* pyobj_results = NULL; |  | 73185 | PyObject* pyobj_results = NULL;
| 73234 | UMat results; |  | 73186 | UMat results;
| 73235 | PyObject* pyobj_flags = NULL; |  | 73187 | PyObject* pyobj_flags = NULL;
| 73236 | int flags=0; |  | 73188 | int flags=0;
| 73237 |  |  | 73189 |
| 73238 | const char* keywords[] = { "samples", "flags", "results", NULL }; |  | 73190 | const char* keywords[] = { "samples", "flags", "results", NULL };
| 73239 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_RTrees.getVotes", (char**)keywords, &pyobj_samples, &pyobj_flags, &pyobj_results) && |  | 73191 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_RTrees.getVotes", (char**)keywords, &pyobj_samples, &pyobj_flags, &pyobj_results) &&
| 73240 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 73192 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 73241 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 73193 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 73242 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 73194 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 73243 | { |  | 73195 | {
| 73244 | ERRWRAP2(_self_->getVotes(samples, results, flags)); |  | 73196 | ERRWRAP2(_self_->getVotes(samples, results, flags));
| 73245 | return pyopencv_from(results); |  | 73197 | return pyopencv_from(results);
| 73246 | } |  | 73198 | }
| 73247 |  |  | 73199 |
| 73248 |  |  | 73200 |
| 73249 | pyPopulateArgumentConversionErrors(); |  | 73201 | pyPopulateArgumentConversionErrors();
| 73250 | } |  | 73202 | }
| 73251 | pyRaiseCVOverloadException("getVotes"); |  | 73203 | pyRaiseCVOverloadException("getVotes");
| 73252 |  |  | 73204 |
| 73253 | return NULL; |  | 73205 | return NULL;
| 73254 | } |  | 73206 | }
| 73255 |  |  | 73207 |
| 73256 | static PyObject* pyopencv_cv_ml_ml_RTrees_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73208 | static PyObject* pyopencv_cv_ml_ml_RTrees_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 73257 | { |  | 73209 | {
| 73258 | using namespace cv::ml; |  | 73210 | using namespace cv::ml;
| 73259 |  |  | 73211 |
| 73260 | PyObject* pyobj_filepath = NULL; |  | 73212 | PyObject* pyobj_filepath = NULL;
| 73261 | String filepath; |  | 73213 | String filepath;
| 73262 | PyObject* pyobj_nodeName = NULL; |  | 73214 | PyObject* pyobj_nodeName = NULL;
| 73263 | String nodeName; |  | 73215 | String nodeName;
| 73264 | Ptr<RTrees> retval; |  | 73216 | Ptr<RTrees> retval;
| 73265 |  |  | 73217 |
| 73266 | const char* keywords[] = { "filepath", "nodeName", NULL }; |  | 73218 | const char* keywords[] = { "filepath", "nodeName", NULL };
| 73267 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_RTrees.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) && |  | 73219 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_RTrees.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) &&
| 73268 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) && |  | 73220 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) &&
| 73269 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) ) |  | 73221 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) )
| 73270 | { |  | 73222 | {
| 73271 | ERRWRAP2(retval = cv::ml::RTrees::load(filepath, nodeName)); |  | 73223 | ERRWRAP2(retval = cv::ml::RTrees::load(filepath, nodeName));
| 73272 | return pyopencv_from(retval); |  | 73224 | return pyopencv_from(retval);
| 73273 | } |  | 73225 | }
| 73274 |  |  | 73226 |
| 73275 | return NULL; |  | 73227 | return NULL;
| 73276 | } |  | 73228 | }
| 73277 |  |  | 73229 |
| 73278 | static PyObject* pyopencv_cv_ml_ml_RTrees_setActiveVarCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73230 | static PyObject* pyopencv_cv_ml_ml_RTrees_setActiveVarCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 73279 | { |  | 73231 | {
| 73280 | using namespace cv::ml; |  | 73232 | using namespace cv::ml;
| 73281 |  |  | 73233 |
| 73282 |  |  | 73234 |
| 73283 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73235 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73284 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73236 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73285 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73237 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73286 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73238 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73287 | PyObject* pyobj_val = NULL; |  | 73239 | PyObject* pyobj_val = NULL;
| 73288 | int val=0; |  | 73240 | int val=0;
| 73289 |  |  | 73241 |
| 73290 | const char* keywords[] = { "val", NULL }; |  | 73242 | const char* keywords[] = { "val", NULL };
| 73291 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_RTrees.setActiveVarCount", (char**)keywords, &pyobj_val) && |  | 73243 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_RTrees.setActiveVarCount", (char**)keywords, &pyobj_val) &&
| 73292 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73244 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73293 | { |  | 73245 | {
| 73294 | ERRWRAP2(_self_->setActiveVarCount(val)); |  | 73246 | ERRWRAP2(_self_->setActiveVarCount(val));
| 73295 | Py_RETURN_NONE; |  | 73247 | Py_RETURN_NONE;
| 73296 | } |  | 73248 | }
| 73297 |  |  | 73249 |
| 73298 | return NULL; |  | 73250 | return NULL;
| 73299 | } |  | 73251 | }
| 73300 |  |  | 73252 |
| 73301 | static PyObject* pyopencv_cv_ml_ml_RTrees_setCalculateVarImportance(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73253 | static PyObject* pyopencv_cv_ml_ml_RTrees_setCalculateVarImportance(PyObject* self, PyObject* py_args, PyObject* kw)
| 73302 | { |  | 73254 | {
| 73303 | using namespace cv::ml; |  | 73255 | using namespace cv::ml;
| 73304 |  |  | 73256 |
| 73305 |  |  | 73257 |
| 73306 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73258 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73307 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73259 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73308 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73260 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73309 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73261 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73310 | PyObject* pyobj_val = NULL; |  | 73262 | PyObject* pyobj_val = NULL;
| 73311 | bool val=0; |  | 73263 | bool val=0;
| 73312 |  |  | 73264 |
| 73313 | const char* keywords[] = { "val", NULL }; |  | 73265 | const char* keywords[] = { "val", NULL };
| 73314 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_RTrees.setCalculateVarImportance", (char**)keywords, &pyobj_val) && |  | 73266 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_RTrees.setCalculateVarImportance", (char**)keywords, &pyobj_val) &&
| 73315 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73267 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73316 | { |  | 73268 | {
| 73317 | ERRWRAP2(_self_->setCalculateVarImportance(val)); |  | 73269 | ERRWRAP2(_self_->setCalculateVarImportance(val));
| 73318 | Py_RETURN_NONE; |  | 73270 | Py_RETURN_NONE;
| 73319 | } |  | 73271 | }
| 73320 |  |  | 73272 |
| 73321 | return NULL; |  | 73273 | return NULL;
| 73322 | } |  | 73274 | }
| 73323 |  |  | 73275 |
| 73324 | static PyObject* pyopencv_cv_ml_ml_RTrees_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73276 | static PyObject* pyopencv_cv_ml_ml_RTrees_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 73325 | { |  | 73277 | {
| 73326 | using namespace cv::ml; |  | 73278 | using namespace cv::ml;
| 73327 |  |  | 73279 |
| 73328 |  |  | 73280 |
| 73329 | Ptr<cv::ml::RTrees> * self1 = 0; |  | 73281 | Ptr<cv::ml::RTrees> * self1 = 0;
| 73330 | if (!pyopencv_ml_RTrees_getp(self, self1)) |  | 73282 | if (!pyopencv_ml_RTrees_getp(self, self1))
| 73331 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)"); |  | 73283 | return failmsgp("Incorrect type of self (must be 'ml_RTrees' or its derivative)");
| 73332 | Ptr<cv::ml::RTrees> _self_ = *(self1); |  | 73284 | Ptr<cv::ml::RTrees> _self_ = *(self1);
| 73333 | PyObject* pyobj_val = NULL; |  | 73285 | PyObject* pyobj_val = NULL;
| 73334 | TermCriteria val; |  | 73286 | TermCriteria val;
| 73335 |  |  | 73287 |
| 73336 | const char* keywords[] = { "val", NULL }; |  | 73288 | const char* keywords[] = { "val", NULL };
| 73337 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_RTrees.setTermCriteria", (char**)keywords, &pyobj_val) && |  | 73289 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_RTrees.setTermCriteria", (char**)keywords, &pyobj_val) &&
| 73338 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73290 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73339 | { |  | 73291 | {
| 73340 | ERRWRAP2(_self_->setTermCriteria(val)); |  | 73292 | ERRWRAP2(_self_->setTermCriteria(val));
| 73341 | Py_RETURN_NONE; |  | 73293 | Py_RETURN_NONE;
| 73342 | } |  | 73294 | }
| 73343 |  |  | 73295 |
| 73344 | return NULL; |  | 73296 | return NULL;
| 73345 | } |  | 73297 | }
| 73346 |  |  | 73298 |
| 73347 |  |  | 73299 |
| 73348 |  |  | 73300 |
| 73349 | // Tables (ml_RTrees) |  | 73301 | // Tables (ml_RTrees)
| 73350 |  |  | 73302 |
| 73351 | static PyGetSetDef pyopencv_ml_RTrees_getseters[] = |  | 73303 | static PyGetSetDef pyopencv_ml_RTrees_getseters[] =
| 73352 | { |  | 73304 | {
| 73353 | {NULL} /* Sentinel */ |  | 73305 | {NULL} /* Sentinel */
| 73354 | }; |  | 73306 | };
| 73355 |  |  | 73307 |
| 73356 | static PyMethodDef pyopencv_ml_RTrees_methods[] = |  | 73308 | static PyMethodDef pyopencv_ml_RTrees_methods[] =
| 73357 | { |  | 73309 | {
| 73358 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_create_static, METH_STATIC), "create() -> retval\n. Creates the empty model.\n. Use StatModel::train to train the model, StatModel::train to create and train the model,\n. Algorithm::load to load the pre-trained model."}, |  | 73310 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_create_static, METH_STATIC), "create() -> retval\n. Creates the empty model.\n. Use StatModel::train to train the model, StatModel::train to create and train the model,\n. Algorithm::load to load the pre-trained model."},
| 73359 | {"getActiveVarCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getActiveVarCount, 0), "getActiveVarCount() -> retval\n. @see setActiveVarCount"}, |  | 73311 | {"getActiveVarCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getActiveVarCount, 0), "getActiveVarCount() -> retval\n. @see setActiveVarCount"},
| 73360 | {"getCalculateVarImportance", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getCalculateVarImportance, 0), "getCalculateVarImportance() -> retval\n. @see setCalculateVarImportance"}, |  | 73312 | {"getCalculateVarImportance", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getCalculateVarImportance, 0), "getCalculateVarImportance() -> retval\n. @see setCalculateVarImportance"},
| 73361 | {"getOOBError", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getOOBError, 0), "getOOBError() -> retval\n. Returns the OOB error value, computed at the training stage when calcOOBError is set to true.\n. * If this flag was set to false, 0 is returned. The OOB error is also scaled by sample weighting."}, |  | 73313 | {"getOOBError", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getOOBError, 0), "getOOBError() -> retval\n. Returns the OOB error value, computed at the training stage when calcOOBError is set to true.\n. * If this flag was set to false, 0 is returned. The OOB error is also scaled by sample weighting."},
| 73362 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"}, |  | 73314 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"},
| 73363 | {"getVarImportance", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getVarImportance, 0), "getVarImportance() -> retval\n. Returns the variable importance array.\n. The method returns the variable importance vector, computed at the training stage when\n. CalculateVarImportance is set to true. If this flag was set to false, the empty matrix is\n. returned."}, |  | 73315 | {"getVarImportance", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getVarImportance, 0), "getVarImportance() -> retval\n. Returns the variable importance array.\n. The method returns the variable importance vector, computed at the training stage when\n. CalculateVarImportance is set to true. If this flag was set to false, the empty matrix is\n. returned."},
| 73364 | {"getVotes", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getVotes, 0), "getVotes(samples, flags[, results]) -> results\n. Returns the result of each individual tree in the forest.\n. In case the model is a regression problem, the method will return each of the trees'\n. results for each of the sample cases. If the model is a classifier, it will return\n. a Mat with samples + 1 rows, where the first row gives the class number and the\n. following rows return the votes each class had for each sample.\n. @param samples Array containing the samples for which votes will be calculated.\n. @param results Array where the result of the calculation will be written.\n. @param flags Flags for defining the type of RTrees."}, |  | 73316 | {"getVotes", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_getVotes, 0), "getVotes(samples, flags[, results]) -> results\n. Returns the result of each individual tree in the forest.\n. In case the model is a regression problem, the method will return each of the trees'\n. results for each of the sample cases. If the model is a classifier, it will return\n. a Mat with samples + 1 rows, where the first row gives the class number and the\n. following rows return the votes each class had for each sample.\n. @param samples Array containing the samples for which votes will be calculated.\n. @param results Array where the result of the calculation will be written.\n. @param flags Flags for defining the type of RTrees."},
| 73365 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized RTree from a file\n. *\n. * Use RTree::save to serialize and store an RTree to disk.\n. * Load the RTree from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized RTree\n. * @param nodeName name of node containing the classifier"}, |  | 73317 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized RTree from a file\n. *\n. * Use RTree::save to serialize and store an RTree to disk.\n. * Load the RTree from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized RTree\n. * @param nodeName name of node containing the classifier"},
| 73366 | {"setActiveVarCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_setActiveVarCount, 0), "setActiveVarCount(val) -> None\n. @copybrief getActiveVarCount @see getActiveVarCount"}, |  | 73318 | {"setActiveVarCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_setActiveVarCount, 0), "setActiveVarCount(val) -> None\n. @copybrief getActiveVarCount @see getActiveVarCount"},
| 73367 | {"setCalculateVarImportance", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_setCalculateVarImportance, 0), "setCalculateVarImportance(val) -> None\n. @copybrief getCalculateVarImportance @see getCalculateVarImportance"}, |  | 73319 | {"setCalculateVarImportance", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_setCalculateVarImportance, 0), "setCalculateVarImportance(val) -> None\n. @copybrief getCalculateVarImportance @see getCalculateVarImportance"},
| 73368 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"}, |  | 73320 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_RTrees_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"},
| 73369 |  |  | 73321 |
| 73370 | {NULL, NULL} |  | 73322 | {NULL, NULL}
| 73371 | }; |  | 73323 | };
| 73372 |  |  | 73324 |
| 73373 | // Converter (ml_RTrees) |  | 73325 | // Converter (ml_RTrees)
| 73374 |  |  | 73326 |
| 73375 | template<> |  | 73327 | template<>
| 73376 | struct PyOpenCV_Converter< Ptr<cv::ml::RTrees> > |  | 73328 | struct PyOpenCV_Converter< Ptr<cv::ml::RTrees> >
| 73377 | { |  | 73329 | {
| 73378 | static PyObject* from(const Ptr<cv::ml::RTrees>& r) |  | 73330 | static PyObject* from(const Ptr<cv::ml::RTrees>& r)
| 73379 | { |  | 73331 | {
| 73380 | return pyopencv_ml_RTrees_Instance(r); |  | 73332 | return pyopencv_ml_RTrees_Instance(r);
| 73381 | } |  | 73333 | }
| 73382 | static bool to(PyObject* src, Ptr<cv::ml::RTrees>& dst, const ArgInfo& info) |  | 73334 | static bool to(PyObject* src, Ptr<cv::ml::RTrees>& dst, const ArgInfo& info)
| 73383 | { |  | 73335 | {
| 73384 | if(!src || src == Py_None) |  | 73336 | if(!src || src == Py_None)
| 73385 | return true; |  | 73337 | return true;
| 73386 | Ptr<cv::ml::RTrees> * dst_; |  | 73338 | Ptr<cv::ml::RTrees> * dst_;
| 73387 | if (pyopencv_ml_RTrees_getp(src, dst_)) |  | 73339 | if (pyopencv_ml_RTrees_getp(src, dst_))
| 73388 | { |  | 73340 | {
| 73389 | dst = *dst_; |  | 73341 | dst = *dst_;
| 73390 | return true; |  | 73342 | return true;
| 73391 | } |  | 73343 | }
| 73392 |  |  | 73344 |
| 73393 | failmsg("Expected Ptr<cv::ml::RTrees> for argument '%s'", info.name); |  | 73345 | failmsg("Expected Ptr<cv::ml::RTrees> for argument '%s'", info.name);
| 73394 | return false; |  | 73346 | return false;
| 73395 | } |  | 73347 | }
| 73396 | }; |  | 73348 | };
| 73397 |  |  | 73349 |
| 73398 | //================================================================================ |  | 73350 | //================================================================================
| 73399 | // ml_SVM (Generic) |  | 73351 | // ml_SVM (Generic)
| 73400 | //================================================================================ |  | 73352 | //================================================================================
| 73401 |  |  | 73353 |
| 73402 | // GetSet (ml_SVM) |  | 73354 | // GetSet (ml_SVM)
| 73403 |  |  | 73355 |
| 73404 |  |  | 73356 |
| 73405 |  |  | 73357 |
| 73406 | // Methods (ml_SVM) |  | 73358 | // Methods (ml_SVM)
| 73407 |  |  | 73359 |
| 73408 | static PyObject* pyopencv_cv_ml_ml_SVM_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73360 | static PyObject* pyopencv_cv_ml_ml_SVM_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 73409 | { |  | 73361 | {
| 73410 | using namespace cv::ml; |  | 73362 | using namespace cv::ml;
| 73411 |  |  | 73363 |
| 73412 | Ptr<SVM> retval; |  | 73364 | Ptr<SVM> retval;
| 73413 |  |  | 73365 |
| 73414 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73366 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73415 | { |  | 73367 | {
| 73416 | ERRWRAP2(retval = cv::ml::SVM::create()); |  | 73368 | ERRWRAP2(retval = cv::ml::SVM::create());
| 73417 | return pyopencv_from(retval); |  | 73369 | return pyopencv_from(retval);
| 73418 | } |  | 73370 | }
| 73419 |  |  | 73371 |
| 73420 | return NULL; |  | 73372 | return NULL;
| 73421 | } |  | 73373 | }
| 73422 |  |  | 73374 |
| 73423 | static PyObject* pyopencv_cv_ml_ml_SVM_getC(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73375 | static PyObject* pyopencv_cv_ml_ml_SVM_getC(PyObject* self, PyObject* py_args, PyObject* kw)
| 73424 | { |  | 73376 | {
| 73425 | using namespace cv::ml; |  | 73377 | using namespace cv::ml;
| 73426 |  |  | 73378 |
| 73427 |  |  | 73379 |
| 73428 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73380 | Ptr<cv::ml::SVM> * self1 = 0;
| 73429 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73381 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73430 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73382 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73431 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73383 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73432 | double retval; |  | 73384 | double retval;
| 73433 |  |  | 73385 |
| 73434 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73386 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73435 | { |  | 73387 | {
| 73436 | ERRWRAP2(retval = _self_->getC()); |  | 73388 | ERRWRAP2(retval = _self_->getC());
| 73437 | return pyopencv_from(retval); |  | 73389 | return pyopencv_from(retval);
| 73438 | } |  | 73390 | }
| 73439 |  |  | 73391 |
| 73440 | return NULL; |  | 73392 | return NULL;
| 73441 | } |  | 73393 | }
| 73442 |  |  | 73394 |
| 73443 | static PyObject* pyopencv_cv_ml_ml_SVM_getClassWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73395 | static PyObject* pyopencv_cv_ml_ml_SVM_getClassWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 73444 | { |  | 73396 | {
| 73445 | using namespace cv::ml; |  | 73397 | using namespace cv::ml;
| 73446 |  |  | 73398 |
| 73447 |  |  | 73399 |
| 73448 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73400 | Ptr<cv::ml::SVM> * self1 = 0;
| 73449 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73401 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73450 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73402 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73451 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73403 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73452 | cv::Mat retval; |  | 73404 | cv::Mat retval;
| 73453 |  |  | 73405 |
| 73454 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73406 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73455 | { |  | 73407 | {
| 73456 | ERRWRAP2(retval = _self_->getClassWeights()); |  | 73408 | ERRWRAP2(retval = _self_->getClassWeights());
| 73457 | return pyopencv_from(retval); |  | 73409 | return pyopencv_from(retval);
| 73458 | } |  | 73410 | }
| 73459 |  |  | 73411 |
| 73460 | return NULL; |  | 73412 | return NULL;
| 73461 | } |  | 73413 | }
| 73462 |  |  | 73414 |
| 73463 | static PyObject* pyopencv_cv_ml_ml_SVM_getCoef0(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73415 | static PyObject* pyopencv_cv_ml_ml_SVM_getCoef0(PyObject* self, PyObject* py_args, PyObject* kw)
| 73464 | { |  | 73416 | {
| 73465 | using namespace cv::ml; |  | 73417 | using namespace cv::ml;
| 73466 |  |  | 73418 |
| 73467 |  |  | 73419 |
| 73468 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73420 | Ptr<cv::ml::SVM> * self1 = 0;
| 73469 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73421 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73470 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73422 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73471 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73423 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73472 | double retval; |  | 73424 | double retval;
| 73473 |  |  | 73425 |
| 73474 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73426 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73475 | { |  | 73427 | {
| 73476 | ERRWRAP2(retval = _self_->getCoef0()); |  | 73428 | ERRWRAP2(retval = _self_->getCoef0());
| 73477 | return pyopencv_from(retval); |  | 73429 | return pyopencv_from(retval);
| 73478 | } |  | 73430 | }
| 73479 |  |  | 73431 |
| 73480 | return NULL; |  | 73432 | return NULL;
| 73481 | } |  | 73433 | }
| 73482 |  |  | 73434 |
| 73483 | static PyObject* pyopencv_cv_ml_ml_SVM_getDecisionFunction(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73435 | static PyObject* pyopencv_cv_ml_ml_SVM_getDecisionFunction(PyObject* self, PyObject* py_args, PyObject* kw)
| 73484 | { |  | 73436 | {
| 73485 | using namespace cv::ml; |  | 73437 | using namespace cv::ml;
| 73486 |  |  | 73438 |
| 73487 |  |  | 73439 |
| 73488 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73440 | Ptr<cv::ml::SVM> * self1 = 0;
| 73489 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73441 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73490 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73442 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73491 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73443 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73492 | pyPrepareArgumentConversionErrorsStorage(2); |  | 73444 | pyPrepareArgumentConversionErrorsStorage(2);
| 73493 |  |  | 73445 |
| 73494 | { |  | 73446 | {
| 73495 | PyObject* pyobj_i = NULL; |  | 73447 | PyObject* pyobj_i = NULL;
| 73496 | int i=0; |  | 73448 | int i=0;
| 73497 | PyObject* pyobj_alpha = NULL; |  | 73449 | PyObject* pyobj_alpha = NULL;
| 73498 | Mat alpha; |  | 73450 | Mat alpha;
| 73499 | PyObject* pyobj_svidx = NULL; |  | 73451 | PyObject* pyobj_svidx = NULL;
| 73500 | Mat svidx; |  | 73452 | Mat svidx;
| 73501 | double retval; |  | 73453 | double retval;
| 73502 |  |  | 73454 |
| 73503 | const char* keywords[] = { "i", "alpha", "svidx", NULL }; |  | 73455 | const char* keywords[] = { "i", "alpha", "svidx", NULL };
| 73504 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_SVM.getDecisionFunction", (char**)keywords, &pyobj_i, &pyobj_alpha, &pyobj_svidx) && |  | 73456 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_SVM.getDecisionFunction", (char**)keywords, &pyobj_i, &pyobj_alpha, &pyobj_svidx) &&
| 73505 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) && |  | 73457 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) &&
| 73506 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 1)) && |  | 73458 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 1)) &&
| 73507 | pyopencv_to_safe(pyobj_svidx, svidx, ArgInfo("svidx", 1)) ) |  | 73459 | pyopencv_to_safe(pyobj_svidx, svidx, ArgInfo("svidx", 1)) )
| 73508 | { |  | 73460 | {
| 73509 | ERRWRAP2(retval = _self_->getDecisionFunction(i, alpha, svidx)); |  | 73461 | ERRWRAP2(retval = _self_->getDecisionFunction(i, alpha, svidx));
| 73510 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(alpha), pyopencv_from(svidx)); |  | 73462 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(alpha), pyopencv_from(svidx));
| 73511 | } |  | 73463 | }
| 73512 |  |  | 73464 |
| 73513 |  |  | 73465 |
| 73514 | pyPopulateArgumentConversionErrors(); |  | 73466 | pyPopulateArgumentConversionErrors();
| 73515 | } |  | 73467 | }
| 73516 |  |  | 73468 |
| 73517 |  |  | 73469 |
| 73518 | { |  | 73470 | {
| 73519 | PyObject* pyobj_i = NULL; |  | 73471 | PyObject* pyobj_i = NULL;
| 73520 | int i=0; |  | 73472 | int i=0;
| 73521 | PyObject* pyobj_alpha = NULL; |  | 73473 | PyObject* pyobj_alpha = NULL;
| 73522 | UMat alpha; |  | 73474 | UMat alpha;
| 73523 | PyObject* pyobj_svidx = NULL; |  | 73475 | PyObject* pyobj_svidx = NULL;
| 73524 | UMat svidx; |  | 73476 | UMat svidx;
| 73525 | double retval; |  | 73477 | double retval;
| 73526 |  |  | 73478 |
| 73527 | const char* keywords[] = { "i", "alpha", "svidx", NULL }; |  | 73479 | const char* keywords[] = { "i", "alpha", "svidx", NULL };
| 73528 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_SVM.getDecisionFunction", (char**)keywords, &pyobj_i, &pyobj_alpha, &pyobj_svidx) && |  | 73480 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_SVM.getDecisionFunction", (char**)keywords, &pyobj_i, &pyobj_alpha, &pyobj_svidx) &&
| 73529 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) && |  | 73481 | pyopencv_to_safe(pyobj_i, i, ArgInfo("i", 0)) &&
| 73530 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 1)) && |  | 73482 | pyopencv_to_safe(pyobj_alpha, alpha, ArgInfo("alpha", 1)) &&
| 73531 | pyopencv_to_safe(pyobj_svidx, svidx, ArgInfo("svidx", 1)) ) |  | 73483 | pyopencv_to_safe(pyobj_svidx, svidx, ArgInfo("svidx", 1)) )
| 73532 | { |  | 73484 | {
| 73533 | ERRWRAP2(retval = _self_->getDecisionFunction(i, alpha, svidx)); |  | 73485 | ERRWRAP2(retval = _self_->getDecisionFunction(i, alpha, svidx));
| 73534 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(alpha), pyopencv_from(svidx)); |  | 73486 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(alpha), pyopencv_from(svidx));
| 73535 | } |  | 73487 | }
| 73536 |  |  | 73488 |
| 73537 |  |  | 73489 |
| 73538 | pyPopulateArgumentConversionErrors(); |  | 73490 | pyPopulateArgumentConversionErrors();
| 73539 | } |  | 73491 | }
| 73540 | pyRaiseCVOverloadException("getDecisionFunction"); |  | 73492 | pyRaiseCVOverloadException("getDecisionFunction");
| 73541 |  |  | 73493 |
| 73542 | return NULL; |  | 73494 | return NULL;
| 73543 | } |  | 73495 | }
| 73544 |  |  | 73496 |
| 73545 | static PyObject* pyopencv_cv_ml_ml_SVM_getDefaultGridPtr_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73497 | static PyObject* pyopencv_cv_ml_ml_SVM_getDefaultGridPtr_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 73546 | { |  | 73498 | {
| 73547 | using namespace cv::ml; |  | 73499 | using namespace cv::ml;
| 73548 |  |  | 73500 |
| 73549 | PyObject* pyobj_param_id = NULL; |  | 73501 | PyObject* pyobj_param_id = NULL;
| 73550 | int param_id=0; |  | 73502 | int param_id=0;
| 73551 | Ptr<ParamGrid> retval; |  | 73503 | Ptr<ParamGrid> retval;
| 73552 |  |  | 73504 |
| 73553 | const char* keywords[] = { "param_id", NULL }; |  | 73505 | const char* keywords[] = { "param_id", NULL };
| 73554 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.getDefaultGridPtr", (char**)keywords, &pyobj_param_id) && |  | 73506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.getDefaultGridPtr", (char**)keywords, &pyobj_param_id) &&
| 73555 | pyopencv_to_safe(pyobj_param_id, param_id, ArgInfo("param_id", 0)) ) |  | 73507 | pyopencv_to_safe(pyobj_param_id, param_id, ArgInfo("param_id", 0)) )
| 73556 | { |  | 73508 | {
| 73557 | ERRWRAP2(retval = cv::ml::SVM::getDefaultGridPtr(param_id)); |  | 73509 | ERRWRAP2(retval = cv::ml::SVM::getDefaultGridPtr(param_id));
| 73558 | return pyopencv_from(retval); |  | 73510 | return pyopencv_from(retval);
| 73559 | } |  | 73511 | }
| 73560 |  |  | 73512 |
| 73561 | return NULL; |  | 73513 | return NULL;
| 73562 | } |  | 73514 | }
| 73563 |  |  | 73515 |
| 73564 | static PyObject* pyopencv_cv_ml_ml_SVM_getDegree(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73516 | static PyObject* pyopencv_cv_ml_ml_SVM_getDegree(PyObject* self, PyObject* py_args, PyObject* kw)
| 73565 | { |  | 73517 | {
| 73566 | using namespace cv::ml; |  | 73518 | using namespace cv::ml;
| 73567 |  |  | 73519 |
| 73568 |  |  | 73520 |
| 73569 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73521 | Ptr<cv::ml::SVM> * self1 = 0;
| 73570 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73522 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73571 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73523 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73572 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73524 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73573 | double retval; |  | 73525 | double retval;
| 73574 |  |  | 73526 |
| 73575 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73527 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73576 | { |  | 73528 | {
| 73577 | ERRWRAP2(retval = _self_->getDegree()); |  | 73529 | ERRWRAP2(retval = _self_->getDegree());
| 73578 | return pyopencv_from(retval); |  | 73530 | return pyopencv_from(retval);
| 73579 | } |  | 73531 | }
| 73580 |  |  | 73532 |
| 73581 | return NULL; |  | 73533 | return NULL;
| 73582 | } |  | 73534 | }
| 73583 |  |  | 73535 |
| 73584 | static PyObject* pyopencv_cv_ml_ml_SVM_getGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73536 | static PyObject* pyopencv_cv_ml_ml_SVM_getGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 73585 | { |  | 73537 | {
| 73586 | using namespace cv::ml; |  | 73538 | using namespace cv::ml;
| 73587 |  |  | 73539 |
| 73588 |  |  | 73540 |
| 73589 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73541 | Ptr<cv::ml::SVM> * self1 = 0;
| 73590 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73542 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73591 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73543 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73592 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73544 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73593 | double retval; |  | 73545 | double retval;
| 73594 |  |  | 73546 |
| 73595 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73547 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73596 | { |  | 73548 | {
| 73597 | ERRWRAP2(retval = _self_->getGamma()); |  | 73549 | ERRWRAP2(retval = _self_->getGamma());
| 73598 | return pyopencv_from(retval); |  | 73550 | return pyopencv_from(retval);
| 73599 | } |  | 73551 | }
| 73600 |  |  | 73552 |
| 73601 | return NULL; |  | 73553 | return NULL;
| 73602 | } |  | 73554 | }
| 73603 |  |  | 73555 |
| 73604 | static PyObject* pyopencv_cv_ml_ml_SVM_getKernelType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73556 | static PyObject* pyopencv_cv_ml_ml_SVM_getKernelType(PyObject* self, PyObject* py_args, PyObject* kw)
| 73605 | { |  | 73557 | {
| 73606 | using namespace cv::ml; |  | 73558 | using namespace cv::ml;
| 73607 |  |  | 73559 |
| 73608 |  |  | 73560 |
| 73609 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73561 | Ptr<cv::ml::SVM> * self1 = 0;
| 73610 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73562 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73611 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73563 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73612 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73564 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73613 | int retval; |  | 73565 | int retval;
| 73614 |  |  | 73566 |
| 73615 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73567 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73616 | { |  | 73568 | {
| 73617 | ERRWRAP2(retval = _self_->getKernelType()); |  | 73569 | ERRWRAP2(retval = _self_->getKernelType());
| 73618 | return pyopencv_from(retval); |  | 73570 | return pyopencv_from(retval);
| 73619 | } |  | 73571 | }
| 73620 |  |  | 73572 |
| 73621 | return NULL; |  | 73573 | return NULL;
| 73622 | } |  | 73574 | }
| 73623 |  |  | 73575 |
| 73624 | static PyObject* pyopencv_cv_ml_ml_SVM_getNu(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73576 | static PyObject* pyopencv_cv_ml_ml_SVM_getNu(PyObject* self, PyObject* py_args, PyObject* kw)
| 73625 | { |  | 73577 | {
| 73626 | using namespace cv::ml; |  | 73578 | using namespace cv::ml;
| 73627 |  |  | 73579 |
| 73628 |  |  | 73580 |
| 73629 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73581 | Ptr<cv::ml::SVM> * self1 = 0;
| 73630 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73582 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73631 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73583 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73632 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73584 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73633 | double retval; |  | 73585 | double retval;
| 73634 |  |  | 73586 |
| 73635 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73587 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73636 | { |  | 73588 | {
| 73637 | ERRWRAP2(retval = _self_->getNu()); |  | 73589 | ERRWRAP2(retval = _self_->getNu());
| 73638 | return pyopencv_from(retval); |  | 73590 | return pyopencv_from(retval);
| 73639 | } |  | 73591 | }
| 73640 |  |  | 73592 |
| 73641 | return NULL; |  | 73593 | return NULL;
| 73642 | } |  | 73594 | }
| 73643 |  |  | 73595 |
| 73644 | static PyObject* pyopencv_cv_ml_ml_SVM_getP(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73596 | static PyObject* pyopencv_cv_ml_ml_SVM_getP(PyObject* self, PyObject* py_args, PyObject* kw)
| 73645 | { |  | 73597 | {
| 73646 | using namespace cv::ml; |  | 73598 | using namespace cv::ml;
| 73647 |  |  | 73599 |
| 73648 |  |  | 73600 |
| 73649 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73601 | Ptr<cv::ml::SVM> * self1 = 0;
| 73650 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73602 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73651 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73603 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73652 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73604 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73653 | double retval; |  | 73605 | double retval;
| 73654 |  |  | 73606 |
| 73655 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73607 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73656 | { |  | 73608 | {
| 73657 | ERRWRAP2(retval = _self_->getP()); |  | 73609 | ERRWRAP2(retval = _self_->getP());
| 73658 | return pyopencv_from(retval); |  | 73610 | return pyopencv_from(retval);
| 73659 | } |  | 73611 | }
| 73660 |  |  | 73612 |
| 73661 | return NULL; |  | 73613 | return NULL;
| 73662 | } |  | 73614 | }
| 73663 |  |  | 73615 |
| 73664 | static PyObject* pyopencv_cv_ml_ml_SVM_getSupportVectors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73616 | static PyObject* pyopencv_cv_ml_ml_SVM_getSupportVectors(PyObject* self, PyObject* py_args, PyObject* kw)
| 73665 | { |  | 73617 | {
| 73666 | using namespace cv::ml; |  | 73618 | using namespace cv::ml;
| 73667 |  |  | 73619 |
| 73668 |  |  | 73620 |
| 73669 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73621 | Ptr<cv::ml::SVM> * self1 = 0;
| 73670 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73622 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73671 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73623 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73672 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73624 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73673 | Mat retval; |  | 73625 | Mat retval;
| 73674 |  |  | 73626 |
| 73675 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73627 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73676 | { |  | 73628 | {
| 73677 | ERRWRAP2(retval = _self_->getSupportVectors()); |  | 73629 | ERRWRAP2(retval = _self_->getSupportVectors());
| 73678 | return pyopencv_from(retval); |  | 73630 | return pyopencv_from(retval);
| 73679 | } |  | 73631 | }
| 73680 |  |  | 73632 |
| 73681 | return NULL; |  | 73633 | return NULL;
| 73682 | } |  | 73634 | }
| 73683 |  |  | 73635 |
| 73684 | static PyObject* pyopencv_cv_ml_ml_SVM_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73636 | static PyObject* pyopencv_cv_ml_ml_SVM_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 73685 | { |  | 73637 | {
| 73686 | using namespace cv::ml; |  | 73638 | using namespace cv::ml;
| 73687 |  |  | 73639 |
| 73688 |  |  | 73640 |
| 73689 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73641 | Ptr<cv::ml::SVM> * self1 = 0;
| 73690 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73642 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73691 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73643 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73692 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73644 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73693 | cv::TermCriteria retval; |  | 73645 | cv::TermCriteria retval;
| 73694 |  |  | 73646 |
| 73695 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73647 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73696 | { |  | 73648 | {
| 73697 | ERRWRAP2(retval = _self_->getTermCriteria()); |  | 73649 | ERRWRAP2(retval = _self_->getTermCriteria());
| 73698 | return pyopencv_from(retval); |  | 73650 | return pyopencv_from(retval);
| 73699 | } |  | 73651 | }
| 73700 |  |  | 73652 |
| 73701 | return NULL; |  | 73653 | return NULL;
| 73702 | } |  | 73654 | }
| 73703 |  |  | 73655 |
| 73704 | static PyObject* pyopencv_cv_ml_ml_SVM_getType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73656 | static PyObject* pyopencv_cv_ml_ml_SVM_getType(PyObject* self, PyObject* py_args, PyObject* kw)
| 73705 | { |  | 73657 | {
| 73706 | using namespace cv::ml; |  | 73658 | using namespace cv::ml;
| 73707 |  |  | 73659 |
| 73708 |  |  | 73660 |
| 73709 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73661 | Ptr<cv::ml::SVM> * self1 = 0;
| 73710 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73662 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73711 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73663 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73712 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73664 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73713 | int retval; |  | 73665 | int retval;
| 73714 |  |  | 73666 |
| 73715 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73667 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73716 | { |  | 73668 | {
| 73717 | ERRWRAP2(retval = _self_->getType()); |  | 73669 | ERRWRAP2(retval = _self_->getType());
| 73718 | return pyopencv_from(retval); |  | 73670 | return pyopencv_from(retval);
| 73719 | } |  | 73671 | }
| 73720 |  |  | 73672 |
| 73721 | return NULL; |  | 73673 | return NULL;
| 73722 | } |  | 73674 | }
| 73723 |  |  | 73675 |
| 73724 | static PyObject* pyopencv_cv_ml_ml_SVM_getUncompressedSupportVectors(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73676 | static PyObject* pyopencv_cv_ml_ml_SVM_getUncompressedSupportVectors(PyObject* self, PyObject* py_args, PyObject* kw)
| 73725 | { |  | 73677 | {
| 73726 | using namespace cv::ml; |  | 73678 | using namespace cv::ml;
| 73727 |  |  | 73679 |
| 73728 |  |  | 73680 |
| 73729 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73681 | Ptr<cv::ml::SVM> * self1 = 0;
| 73730 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73682 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73731 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73683 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73732 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73684 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73733 | Mat retval; |  | 73685 | Mat retval;
| 73734 |  |  | 73686 |
| 73735 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 73687 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 73736 | { |  | 73688 | {
| 73737 | ERRWRAP2(retval = _self_->getUncompressedSupportVectors()); |  | 73689 | ERRWRAP2(retval = _self_->getUncompressedSupportVectors());
| 73738 | return pyopencv_from(retval); |  | 73690 | return pyopencv_from(retval);
| 73739 | } |  | 73691 | }
| 73740 |  |  | 73692 |
| 73741 | return NULL; |  | 73693 | return NULL;
| 73742 | } |  | 73694 | }
| 73743 |  |  | 73695 |
| 73744 | static PyObject* pyopencv_cv_ml_ml_SVM_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73696 | static PyObject* pyopencv_cv_ml_ml_SVM_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 73745 | { |  | 73697 | {
| 73746 | using namespace cv::ml; |  | 73698 | using namespace cv::ml;
| 73747 |  |  | 73699 |
| 73748 | PyObject* pyobj_filepath = NULL; |  | 73700 | PyObject* pyobj_filepath = NULL;
| 73749 | String filepath; |  | 73701 | String filepath;
| 73750 | Ptr<SVM> retval; |  | 73702 | Ptr<SVM> retval;
| 73751 |  |  | 73703 |
| 73752 | const char* keywords[] = { "filepath", NULL }; |  | 73704 | const char* keywords[] = { "filepath", NULL };
| 73753 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.load", (char**)keywords, &pyobj_filepath) && |  | 73705 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.load", (char**)keywords, &pyobj_filepath) &&
| 73754 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) ) |  | 73706 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) )
| 73755 | { |  | 73707 | {
| 73756 | ERRWRAP2(retval = cv::ml::SVM::load(filepath)); |  | 73708 | ERRWRAP2(retval = cv::ml::SVM::load(filepath));
| 73757 | return pyopencv_from(retval); |  | 73709 | return pyopencv_from(retval);
| 73758 | } |  | 73710 | }
| 73759 |  |  | 73711 |
| 73760 | return NULL; |  | 73712 | return NULL;
| 73761 | } |  | 73713 | }
| 73762 |  |  | 73714 |
| 73763 | static PyObject* pyopencv_cv_ml_ml_SVM_setC(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73715 | static PyObject* pyopencv_cv_ml_ml_SVM_setC(PyObject* self, PyObject* py_args, PyObject* kw)
| 73764 | { |  | 73716 | {
| 73765 | using namespace cv::ml; |  | 73717 | using namespace cv::ml;
| 73766 |  |  | 73718 |
| 73767 |  |  | 73719 |
| 73768 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73720 | Ptr<cv::ml::SVM> * self1 = 0;
| 73769 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73721 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73770 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73722 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73771 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73723 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73772 | PyObject* pyobj_val = NULL; |  | 73724 | PyObject* pyobj_val = NULL;
| 73773 | double val=0; |  | 73725 | double val=0;
| 73774 |  |  | 73726 |
| 73775 | const char* keywords[] = { "val", NULL }; |  | 73727 | const char* keywords[] = { "val", NULL };
| 73776 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setC", (char**)keywords, &pyobj_val) && |  | 73728 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setC", (char**)keywords, &pyobj_val) &&
| 73777 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73729 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73778 | { |  | 73730 | {
| 73779 | ERRWRAP2(_self_->setC(val)); |  | 73731 | ERRWRAP2(_self_->setC(val));
| 73780 | Py_RETURN_NONE; |  | 73732 | Py_RETURN_NONE;
| 73781 | } |  | 73733 | }
| 73782 |  |  | 73734 |
| 73783 | return NULL; |  | 73735 | return NULL;
| 73784 | } |  | 73736 | }
| 73785 |  |  | 73737 |
| 73786 | static PyObject* pyopencv_cv_ml_ml_SVM_setClassWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73738 | static PyObject* pyopencv_cv_ml_ml_SVM_setClassWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 73787 | { |  | 73739 | {
| 73788 | using namespace cv::ml; |  | 73740 | using namespace cv::ml;
| 73789 |  |  | 73741 |
| 73790 |  |  | 73742 |
| 73791 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73743 | Ptr<cv::ml::SVM> * self1 = 0;
| 73792 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73744 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73793 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73745 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73794 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73746 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73795 | PyObject* pyobj_val = NULL; |  | 73747 | PyObject* pyobj_val = NULL;
| 73796 | Mat val; |  | 73748 | Mat val;
| 73797 |  |  | 73749 |
| 73798 | const char* keywords[] = { "val", NULL }; |  | 73750 | const char* keywords[] = { "val", NULL };
| 73799 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setClassWeights", (char**)keywords, &pyobj_val) && |  | 73751 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setClassWeights", (char**)keywords, &pyobj_val) &&
| 73800 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73752 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73801 | { |  | 73753 | {
| 73802 | ERRWRAP2(_self_->setClassWeights(val)); |  | 73754 | ERRWRAP2(_self_->setClassWeights(val));
| 73803 | Py_RETURN_NONE; |  | 73755 | Py_RETURN_NONE;
| 73804 | } |  | 73756 | }
| 73805 |  |  | 73757 |
| 73806 | return NULL; |  | 73758 | return NULL;
| 73807 | } |  | 73759 | }
| 73808 |  |  | 73760 |
| 73809 | static PyObject* pyopencv_cv_ml_ml_SVM_setCoef0(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73761 | static PyObject* pyopencv_cv_ml_ml_SVM_setCoef0(PyObject* self, PyObject* py_args, PyObject* kw)
| 73810 | { |  | 73762 | {
| 73811 | using namespace cv::ml; |  | 73763 | using namespace cv::ml;
| 73812 |  |  | 73764 |
| 73813 |  |  | 73765 |
| 73814 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73766 | Ptr<cv::ml::SVM> * self1 = 0;
| 73815 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73767 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73816 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73768 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73817 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73769 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73818 | PyObject* pyobj_val = NULL; |  | 73770 | PyObject* pyobj_val = NULL;
| 73819 | double val=0; |  | 73771 | double val=0;
| 73820 |  |  | 73772 |
| 73821 | const char* keywords[] = { "val", NULL }; |  | 73773 | const char* keywords[] = { "val", NULL };
| 73822 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setCoef0", (char**)keywords, &pyobj_val) && |  | 73774 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setCoef0", (char**)keywords, &pyobj_val) &&
| 73823 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73775 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73824 | { |  | 73776 | {
| 73825 | ERRWRAP2(_self_->setCoef0(val)); |  | 73777 | ERRWRAP2(_self_->setCoef0(val));
| 73826 | Py_RETURN_NONE; |  | 73778 | Py_RETURN_NONE;
| 73827 | } |  | 73779 | }
| 73828 |  |  | 73780 |
| 73829 | return NULL; |  | 73781 | return NULL;
| 73830 | } |  | 73782 | }
| 73831 |  |  | 73783 |
| 73832 | static PyObject* pyopencv_cv_ml_ml_SVM_setDegree(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73784 | static PyObject* pyopencv_cv_ml_ml_SVM_setDegree(PyObject* self, PyObject* py_args, PyObject* kw)
| 73833 | { |  | 73785 | {
| 73834 | using namespace cv::ml; |  | 73786 | using namespace cv::ml;
| 73835 |  |  | 73787 |
| 73836 |  |  | 73788 |
| 73837 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73789 | Ptr<cv::ml::SVM> * self1 = 0;
| 73838 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73790 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73839 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73791 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73840 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73792 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73841 | PyObject* pyobj_val = NULL; |  | 73793 | PyObject* pyobj_val = NULL;
| 73842 | double val=0; |  | 73794 | double val=0;
| 73843 |  |  | 73795 |
| 73844 | const char* keywords[] = { "val", NULL }; |  | 73796 | const char* keywords[] = { "val", NULL };
| 73845 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setDegree", (char**)keywords, &pyobj_val) && |  | 73797 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setDegree", (char**)keywords, &pyobj_val) &&
| 73846 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73798 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73847 | { |  | 73799 | {
| 73848 | ERRWRAP2(_self_->setDegree(val)); |  | 73800 | ERRWRAP2(_self_->setDegree(val));
| 73849 | Py_RETURN_NONE; |  | 73801 | Py_RETURN_NONE;
| 73850 | } |  | 73802 | }
| 73851 |  |  | 73803 |
| 73852 | return NULL; |  | 73804 | return NULL;
| 73853 | } |  | 73805 | }
| 73854 |  |  | 73806 |
| 73855 | static PyObject* pyopencv_cv_ml_ml_SVM_setGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73807 | static PyObject* pyopencv_cv_ml_ml_SVM_setGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 73856 | { |  | 73808 | {
| 73857 | using namespace cv::ml; |  | 73809 | using namespace cv::ml;
| 73858 |  |  | 73810 |
| 73859 |  |  | 73811 |
| 73860 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73812 | Ptr<cv::ml::SVM> * self1 = 0;
| 73861 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73813 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73862 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73814 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73863 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73815 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73864 | PyObject* pyobj_val = NULL; |  | 73816 | PyObject* pyobj_val = NULL;
| 73865 | double val=0; |  | 73817 | double val=0;
| 73866 |  |  | 73818 |
| 73867 | const char* keywords[] = { "val", NULL }; |  | 73819 | const char* keywords[] = { "val", NULL };
| 73868 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setGamma", (char**)keywords, &pyobj_val) && |  | 73820 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setGamma", (char**)keywords, &pyobj_val) &&
| 73869 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73821 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73870 | { |  | 73822 | {
| 73871 | ERRWRAP2(_self_->setGamma(val)); |  | 73823 | ERRWRAP2(_self_->setGamma(val));
| 73872 | Py_RETURN_NONE; |  | 73824 | Py_RETURN_NONE;
| 73873 | } |  | 73825 | }
| 73874 |  |  | 73826 |
| 73875 | return NULL; |  | 73827 | return NULL;
| 73876 | } |  | 73828 | }
| 73877 |  |  | 73829 |
| 73878 | static PyObject* pyopencv_cv_ml_ml_SVM_setKernel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73830 | static PyObject* pyopencv_cv_ml_ml_SVM_setKernel(PyObject* self, PyObject* py_args, PyObject* kw)
| 73879 | { |  | 73831 | {
| 73880 | using namespace cv::ml; |  | 73832 | using namespace cv::ml;
| 73881 |  |  | 73833 |
| 73882 |  |  | 73834 |
| 73883 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73835 | Ptr<cv::ml::SVM> * self1 = 0;
| 73884 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73836 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73885 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73837 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73886 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73838 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73887 | PyObject* pyobj_kernelType = NULL; |  | 73839 | PyObject* pyobj_kernelType = NULL;
| 73888 | int kernelType=0; |  | 73840 | int kernelType=0;
| 73889 |  |  | 73841 |
| 73890 | const char* keywords[] = { "kernelType", NULL }; |  | 73842 | const char* keywords[] = { "kernelType", NULL };
| 73891 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setKernel", (char**)keywords, &pyobj_kernelType) && |  | 73843 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setKernel", (char**)keywords, &pyobj_kernelType) &&
| 73892 | pyopencv_to_safe(pyobj_kernelType, kernelType, ArgInfo("kernelType", 0)) ) |  | 73844 | pyopencv_to_safe(pyobj_kernelType, kernelType, ArgInfo("kernelType", 0)) )
| 73893 | { |  | 73845 | {
| 73894 | ERRWRAP2(_self_->setKernel(kernelType)); |  | 73846 | ERRWRAP2(_self_->setKernel(kernelType));
| 73895 | Py_RETURN_NONE; |  | 73847 | Py_RETURN_NONE;
| 73896 | } |  | 73848 | }
| 73897 |  |  | 73849 |
| 73898 | return NULL; |  | 73850 | return NULL;
| 73899 | } |  | 73851 | }
| 73900 |  |  | 73852 |
| 73901 | static PyObject* pyopencv_cv_ml_ml_SVM_setNu(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73853 | static PyObject* pyopencv_cv_ml_ml_SVM_setNu(PyObject* self, PyObject* py_args, PyObject* kw)
| 73902 | { |  | 73854 | {
| 73903 | using namespace cv::ml; |  | 73855 | using namespace cv::ml;
| 73904 |  |  | 73856 |
| 73905 |  |  | 73857 |
| 73906 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73858 | Ptr<cv::ml::SVM> * self1 = 0;
| 73907 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73859 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73908 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73860 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73909 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73861 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73910 | PyObject* pyobj_val = NULL; |  | 73862 | PyObject* pyobj_val = NULL;
| 73911 | double val=0; |  | 73863 | double val=0;
| 73912 |  |  | 73864 |
| 73913 | const char* keywords[] = { "val", NULL }; |  | 73865 | const char* keywords[] = { "val", NULL };
| 73914 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setNu", (char**)keywords, &pyobj_val) && |  | 73866 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setNu", (char**)keywords, &pyobj_val) &&
| 73915 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73867 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73916 | { |  | 73868 | {
| 73917 | ERRWRAP2(_self_->setNu(val)); |  | 73869 | ERRWRAP2(_self_->setNu(val));
| 73918 | Py_RETURN_NONE; |  | 73870 | Py_RETURN_NONE;
| 73919 | } |  | 73871 | }
| 73920 |  |  | 73872 |
| 73921 | return NULL; |  | 73873 | return NULL;
| 73922 | } |  | 73874 | }
| 73923 |  |  | 73875 |
| 73924 | static PyObject* pyopencv_cv_ml_ml_SVM_setP(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73876 | static PyObject* pyopencv_cv_ml_ml_SVM_setP(PyObject* self, PyObject* py_args, PyObject* kw)
| 73925 | { |  | 73877 | {
| 73926 | using namespace cv::ml; |  | 73878 | using namespace cv::ml;
| 73927 |  |  | 73879 |
| 73928 |  |  | 73880 |
| 73929 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73881 | Ptr<cv::ml::SVM> * self1 = 0;
| 73930 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73882 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73931 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73883 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73932 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73884 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73933 | PyObject* pyobj_val = NULL; |  | 73885 | PyObject* pyobj_val = NULL;
| 73934 | double val=0; |  | 73886 | double val=0;
| 73935 |  |  | 73887 |
| 73936 | const char* keywords[] = { "val", NULL }; |  | 73888 | const char* keywords[] = { "val", NULL };
| 73937 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setP", (char**)keywords, &pyobj_val) && |  | 73889 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setP", (char**)keywords, &pyobj_val) &&
| 73938 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73890 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73939 | { |  | 73891 | {
| 73940 | ERRWRAP2(_self_->setP(val)); |  | 73892 | ERRWRAP2(_self_->setP(val));
| 73941 | Py_RETURN_NONE; |  | 73893 | Py_RETURN_NONE;
| 73942 | } |  | 73894 | }
| 73943 |  |  | 73895 |
| 73944 | return NULL; |  | 73896 | return NULL;
| 73945 | } |  | 73897 | }
| 73946 |  |  | 73898 |
| 73947 | static PyObject* pyopencv_cv_ml_ml_SVM_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73899 | static PyObject* pyopencv_cv_ml_ml_SVM_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 73948 | { |  | 73900 | {
| 73949 | using namespace cv::ml; |  | 73901 | using namespace cv::ml;
| 73950 |  |  | 73902 |
| 73951 |  |  | 73903 |
| 73952 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73904 | Ptr<cv::ml::SVM> * self1 = 0;
| 73953 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73905 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73954 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73906 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73955 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73907 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73956 | PyObject* pyobj_val = NULL; |  | 73908 | PyObject* pyobj_val = NULL;
| 73957 | TermCriteria val; |  | 73909 | TermCriteria val;
| 73958 |  |  | 73910 |
| 73959 | const char* keywords[] = { "val", NULL }; |  | 73911 | const char* keywords[] = { "val", NULL };
| 73960 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setTermCriteria", (char**)keywords, &pyobj_val) && |  | 73912 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setTermCriteria", (char**)keywords, &pyobj_val) &&
| 73961 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73913 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73962 | { |  | 73914 | {
| 73963 | ERRWRAP2(_self_->setTermCriteria(val)); |  | 73915 | ERRWRAP2(_self_->setTermCriteria(val));
| 73964 | Py_RETURN_NONE; |  | 73916 | Py_RETURN_NONE;
| 73965 | } |  | 73917 | }
| 73966 |  |  | 73918 |
| 73967 | return NULL; |  | 73919 | return NULL;
| 73968 | } |  | 73920 | }
| 73969 |  |  | 73921 |
| 73970 | static PyObject* pyopencv_cv_ml_ml_SVM_setType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73922 | static PyObject* pyopencv_cv_ml_ml_SVM_setType(PyObject* self, PyObject* py_args, PyObject* kw)
| 73971 | { |  | 73923 | {
| 73972 | using namespace cv::ml; |  | 73924 | using namespace cv::ml;
| 73973 |  |  | 73925 |
| 73974 |  |  | 73926 |
| 73975 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73927 | Ptr<cv::ml::SVM> * self1 = 0;
| 73976 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73928 | if (!pyopencv_ml_SVM_getp(self, self1))
| 73977 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73929 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 73978 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73930 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 73979 | PyObject* pyobj_val = NULL; |  | 73931 | PyObject* pyobj_val = NULL;
| 73980 | int val=0; |  | 73932 | int val=0;
| 73981 |  |  | 73933 |
| 73982 | const char* keywords[] = { "val", NULL }; |  | 73934 | const char* keywords[] = { "val", NULL };
| 73983 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setType", (char**)keywords, &pyobj_val) && |  | 73935 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVM.setType", (char**)keywords, &pyobj_val) &&
| 73984 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 73936 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 73985 | { |  | 73937 | {
| 73986 | ERRWRAP2(_self_->setType(val)); |  | 73938 | ERRWRAP2(_self_->setType(val));
| 73987 | Py_RETURN_NONE; |  | 73939 | Py_RETURN_NONE;
| 73988 | } |  | 73940 | }
| 73989 |  |  | 73941 |
| 73990 | return NULL; |  | 73942 | return NULL;
| 73991 | } |  | 73943 | }
| 73992 |  |  | 73944 |
| 73993 | static PyObject* pyopencv_cv_ml_ml_SVM_trainAuto(PyObject* self, PyObject* py_args, PyObject* kw) |  | 73945 | static PyObject* pyopencv_cv_ml_ml_SVM_trainAuto(PyObject* self, PyObject* py_args, PyObject* kw)
| 73994 | { |  | 73946 | {
| 73995 | using namespace cv::ml; |  | 73947 | using namespace cv::ml;
| 73996 |  |  | 73948 |
| 73997 |  |  | 73949 |
| 73998 | Ptr<cv::ml::SVM> * self1 = 0; |  | 73950 | Ptr<cv::ml::SVM> * self1 = 0;
| 73999 | if (!pyopencv_ml_SVM_getp(self, self1)) |  | 73951 | if (!pyopencv_ml_SVM_getp(self, self1))
| 74000 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)"); |  | 73952 | return failmsgp("Incorrect type of self (must be 'ml_SVM' or its derivative)");
| 74001 | Ptr<cv::ml::SVM> _self_ = *(self1); |  | 73953 | Ptr<cv::ml::SVM> _self_ = *(self1);
| 74002 | pyPrepareArgumentConversionErrorsStorage(2); |  | 73954 | pyPrepareArgumentConversionErrorsStorage(2);
| 74003 |  |  | 73955 |
| 74004 | { |  | 73956 | {
| 74005 | PyObject* pyobj_samples = NULL; |  | 73957 | PyObject* pyobj_samples = NULL;
| 74006 | Mat samples; |  | 73958 | Mat samples;
| 74007 | PyObject* pyobj_layout = NULL; |  | 73959 | PyObject* pyobj_layout = NULL;
| 74008 | int layout=0; |  | 73960 | int layout=0;
| 74009 | PyObject* pyobj_responses = NULL; |  | 73961 | PyObject* pyobj_responses = NULL;
| 74010 | Mat responses; |  | 73962 | Mat responses;
| 74011 | PyObject* pyobj_kFold = NULL; |  | 73963 | PyObject* pyobj_kFold = NULL;
| 74012 | int kFold=10; |  | 73964 | int kFold=10;
| 74013 | PyObject* pyobj_Cgrid = NULL; |  | 73965 | PyObject* pyobj_Cgrid = NULL;
| 74014 | Ptr<ParamGrid> Cgrid=SVM::getDefaultGridPtr(SVM::C); |  | 73966 | Ptr<ParamGrid> Cgrid=SVM::getDefaultGridPtr(SVM::C);
| 74015 | PyObject* pyobj_gammaGrid = NULL; |  | 73967 | PyObject* pyobj_gammaGrid = NULL;
| 74016 | Ptr<ParamGrid> gammaGrid=SVM::getDefaultGridPtr(SVM::GAMMA); |  | 73968 | Ptr<ParamGrid> gammaGrid=SVM::getDefaultGridPtr(SVM::GAMMA);
| 74017 | PyObject* pyobj_pGrid = NULL; |  | 73969 | PyObject* pyobj_pGrid = NULL;
| 74018 | Ptr<ParamGrid> pGrid=SVM::getDefaultGridPtr(SVM::P); |  | 73970 | Ptr<ParamGrid> pGrid=SVM::getDefaultGridPtr(SVM::P);
| 74019 | PyObject* pyobj_nuGrid = NULL; |  | 73971 | PyObject* pyobj_nuGrid = NULL;
| 74020 | Ptr<ParamGrid> nuGrid=SVM::getDefaultGridPtr(SVM::NU); |  | 73972 | Ptr<ParamGrid> nuGrid=SVM::getDefaultGridPtr(SVM::NU);
| 74021 | PyObject* pyobj_coeffGrid = NULL; |  | 73973 | PyObject* pyobj_coeffGrid = NULL;
| 74022 | Ptr<ParamGrid> coeffGrid=SVM::getDefaultGridPtr(SVM::COEF); |  | 73974 | Ptr<ParamGrid> coeffGrid=SVM::getDefaultGridPtr(SVM::COEF);
| 74023 | PyObject* pyobj_degreeGrid = NULL; |  | 73975 | PyObject* pyobj_degreeGrid = NULL;
| 74024 | Ptr<ParamGrid> degreeGrid=SVM::getDefaultGridPtr(SVM::DEGREE); |  | 73976 | Ptr<ParamGrid> degreeGrid=SVM::getDefaultGridPtr(SVM::DEGREE);
| 74025 | PyObject* pyobj_balanced = NULL; |  | 73977 | PyObject* pyobj_balanced = NULL;
| 74026 | bool balanced=false; |  | 73978 | bool balanced=false;
| 74027 | bool retval; |  | 73979 | bool retval;
| 74028 |  |  | 73980 |
| 74029 | const char* keywords[] = { "samples", "layout", "responses", "kFold", "Cgrid", "gammaGrid", "pGrid", "nuGrid", "coeffGrid", "degreeGrid", "balanced", NULL }; |  | 73981 | const char* keywords[] = { "samples", "layout", "responses", "kFold", "Cgrid", "gammaGrid", "pGrid", "nuGrid", "coeffGrid", "degreeGrid", "balanced", NULL };
| 74030 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOOOOOO:ml_SVM.trainAuto", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_kFold, &pyobj_Cgrid, &pyobj_gammaGrid, &pyobj_pGrid, &pyobj_nuGrid, &pyobj_coeffGrid, &pyobj_degreeGrid, &pyobj_balanced) && |  | 73982 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOOOOOO:ml_SVM.trainAuto", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_kFold, &pyobj_Cgrid, &pyobj_gammaGrid, &pyobj_pGrid, &pyobj_nuGrid, &pyobj_coeffGrid, &pyobj_degreeGrid, &pyobj_balanced) &&
| 74031 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 73983 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 74032 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) && |  | 73984 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) &&
| 74033 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) && |  | 73985 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) &&
| 74034 | pyopencv_to_safe(pyobj_kFold, kFold, ArgInfo("kFold", 0)) && |  | 73986 | pyopencv_to_safe(pyobj_kFold, kFold, ArgInfo("kFold", 0)) &&
| 74035 | pyopencv_to_safe(pyobj_Cgrid, Cgrid, ArgInfo("Cgrid", 0)) && |  | 73987 | pyopencv_to_safe(pyobj_Cgrid, Cgrid, ArgInfo("Cgrid", 0)) &&
| 74036 | pyopencv_to_safe(pyobj_gammaGrid, gammaGrid, ArgInfo("gammaGrid", 0)) && |  | 73988 | pyopencv_to_safe(pyobj_gammaGrid, gammaGrid, ArgInfo("gammaGrid", 0)) &&
| 74037 | pyopencv_to_safe(pyobj_pGrid, pGrid, ArgInfo("pGrid", 0)) && |  | 73989 | pyopencv_to_safe(pyobj_pGrid, pGrid, ArgInfo("pGrid", 0)) &&
| 74038 | pyopencv_to_safe(pyobj_nuGrid, nuGrid, ArgInfo("nuGrid", 0)) && |  | 73990 | pyopencv_to_safe(pyobj_nuGrid, nuGrid, ArgInfo("nuGrid", 0)) &&
| 74039 | pyopencv_to_safe(pyobj_coeffGrid, coeffGrid, ArgInfo("coeffGrid", 0)) && |  | 73991 | pyopencv_to_safe(pyobj_coeffGrid, coeffGrid, ArgInfo("coeffGrid", 0)) &&
| 74040 | pyopencv_to_safe(pyobj_degreeGrid, degreeGrid, ArgInfo("degreeGrid", 0)) && |  | 73992 | pyopencv_to_safe(pyobj_degreeGrid, degreeGrid, ArgInfo("degreeGrid", 0)) &&
| 74041 | pyopencv_to_safe(pyobj_balanced, balanced, ArgInfo("balanced", 0)) ) |  | 73993 | pyopencv_to_safe(pyobj_balanced, balanced, ArgInfo("balanced", 0)) )
| 74042 | { |  | 73994 | {
| 74043 | ERRWRAP2(retval = _self_->trainAuto(samples, layout, responses, kFold, Cgrid, gammaGrid, pGrid, nuGrid, coeffGrid, degreeGrid, balanced)); |  | 73995 | ERRWRAP2(retval = _self_->trainAuto(samples, layout, responses, kFold, Cgrid, gammaGrid, pGrid, nuGrid, coeffGrid, degreeGrid, balanced));
| 74044 | return pyopencv_from(retval); |  | 73996 | return pyopencv_from(retval);
| 74045 | } |  | 73997 | }
| 74046 |  |  | 73998 |
| 74047 |  |  | 73999 |
| 74048 | pyPopulateArgumentConversionErrors(); |  | 74000 | pyPopulateArgumentConversionErrors();
| 74049 | } |  | 74001 | }
| 74050 |  |  | 74002 |
| 74051 |  |  | 74003 |
| 74052 | { |  | 74004 | {
| 74053 | PyObject* pyobj_samples = NULL; |  | 74005 | PyObject* pyobj_samples = NULL;
| 74054 | UMat samples; |  | 74006 | UMat samples;
| 74055 | PyObject* pyobj_layout = NULL; |  | 74007 | PyObject* pyobj_layout = NULL;
| 74056 | int layout=0; |  | 74008 | int layout=0;
| 74057 | PyObject* pyobj_responses = NULL; |  | 74009 | PyObject* pyobj_responses = NULL;
| 74058 | UMat responses; |  | 74010 | UMat responses;
| 74059 | PyObject* pyobj_kFold = NULL; |  | 74011 | PyObject* pyobj_kFold = NULL;
| 74060 | int kFold=10; |  | 74012 | int kFold=10;
| 74061 | PyObject* pyobj_Cgrid = NULL; |  | 74013 | PyObject* pyobj_Cgrid = NULL;
| 74062 | Ptr<ParamGrid> Cgrid=SVM::getDefaultGridPtr(SVM::C); |  | 74014 | Ptr<ParamGrid> Cgrid=SVM::getDefaultGridPtr(SVM::C);
| 74063 | PyObject* pyobj_gammaGrid = NULL; |  | 74015 | PyObject* pyobj_gammaGrid = NULL;
| 74064 | Ptr<ParamGrid> gammaGrid=SVM::getDefaultGridPtr(SVM::GAMMA); |  | 74016 | Ptr<ParamGrid> gammaGrid=SVM::getDefaultGridPtr(SVM::GAMMA);
| 74065 | PyObject* pyobj_pGrid = NULL; |  | 74017 | PyObject* pyobj_pGrid = NULL;
| 74066 | Ptr<ParamGrid> pGrid=SVM::getDefaultGridPtr(SVM::P); |  | 74018 | Ptr<ParamGrid> pGrid=SVM::getDefaultGridPtr(SVM::P);
| 74067 | PyObject* pyobj_nuGrid = NULL; |  | 74019 | PyObject* pyobj_nuGrid = NULL;
| 74068 | Ptr<ParamGrid> nuGrid=SVM::getDefaultGridPtr(SVM::NU); |  | 74020 | Ptr<ParamGrid> nuGrid=SVM::getDefaultGridPtr(SVM::NU);
| 74069 | PyObject* pyobj_coeffGrid = NULL; |  | 74021 | PyObject* pyobj_coeffGrid = NULL;
| 74070 | Ptr<ParamGrid> coeffGrid=SVM::getDefaultGridPtr(SVM::COEF); |  | 74022 | Ptr<ParamGrid> coeffGrid=SVM::getDefaultGridPtr(SVM::COEF);
| 74071 | PyObject* pyobj_degreeGrid = NULL; |  | 74023 | PyObject* pyobj_degreeGrid = NULL;
| 74072 | Ptr<ParamGrid> degreeGrid=SVM::getDefaultGridPtr(SVM::DEGREE); |  | 74024 | Ptr<ParamGrid> degreeGrid=SVM::getDefaultGridPtr(SVM::DEGREE);
| 74073 | PyObject* pyobj_balanced = NULL; |  | 74025 | PyObject* pyobj_balanced = NULL;
| 74074 | bool balanced=false; |  | 74026 | bool balanced=false;
| 74075 | bool retval; |  | 74027 | bool retval;
| 74076 |  |  | 74028 |
| 74077 | const char* keywords[] = { "samples", "layout", "responses", "kFold", "Cgrid", "gammaGrid", "pGrid", "nuGrid", "coeffGrid", "degreeGrid", "balanced", NULL }; |  | 74029 | const char* keywords[] = { "samples", "layout", "responses", "kFold", "Cgrid", "gammaGrid", "pGrid", "nuGrid", "coeffGrid", "degreeGrid", "balanced", NULL };
| 74078 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOOOOOO:ml_SVM.trainAuto", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_kFold, &pyobj_Cgrid, &pyobj_gammaGrid, &pyobj_pGrid, &pyobj_nuGrid, &pyobj_coeffGrid, &pyobj_degreeGrid, &pyobj_balanced) && |  | 74030 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOOOOOO:ml_SVM.trainAuto", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_kFold, &pyobj_Cgrid, &pyobj_gammaGrid, &pyobj_pGrid, &pyobj_nuGrid, &pyobj_coeffGrid, &pyobj_degreeGrid, &pyobj_balanced) &&
| 74079 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 74031 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 74080 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) && |  | 74032 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) &&
| 74081 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) && |  | 74033 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) &&
| 74082 | pyopencv_to_safe(pyobj_kFold, kFold, ArgInfo("kFold", 0)) && |  | 74034 | pyopencv_to_safe(pyobj_kFold, kFold, ArgInfo("kFold", 0)) &&
| 74083 | pyopencv_to_safe(pyobj_Cgrid, Cgrid, ArgInfo("Cgrid", 0)) && |  | 74035 | pyopencv_to_safe(pyobj_Cgrid, Cgrid, ArgInfo("Cgrid", 0)) &&
| 74084 | pyopencv_to_safe(pyobj_gammaGrid, gammaGrid, ArgInfo("gammaGrid", 0)) && |  | 74036 | pyopencv_to_safe(pyobj_gammaGrid, gammaGrid, ArgInfo("gammaGrid", 0)) &&
| 74085 | pyopencv_to_safe(pyobj_pGrid, pGrid, ArgInfo("pGrid", 0)) && |  | 74037 | pyopencv_to_safe(pyobj_pGrid, pGrid, ArgInfo("pGrid", 0)) &&
| 74086 | pyopencv_to_safe(pyobj_nuGrid, nuGrid, ArgInfo("nuGrid", 0)) && |  | 74038 | pyopencv_to_safe(pyobj_nuGrid, nuGrid, ArgInfo("nuGrid", 0)) &&
| 74087 | pyopencv_to_safe(pyobj_coeffGrid, coeffGrid, ArgInfo("coeffGrid", 0)) && |  | 74039 | pyopencv_to_safe(pyobj_coeffGrid, coeffGrid, ArgInfo("coeffGrid", 0)) &&
| 74088 | pyopencv_to_safe(pyobj_degreeGrid, degreeGrid, ArgInfo("degreeGrid", 0)) && |  | 74040 | pyopencv_to_safe(pyobj_degreeGrid, degreeGrid, ArgInfo("degreeGrid", 0)) &&
| 74089 | pyopencv_to_safe(pyobj_balanced, balanced, ArgInfo("balanced", 0)) ) |  | 74041 | pyopencv_to_safe(pyobj_balanced, balanced, ArgInfo("balanced", 0)) )
| 74090 | { |  | 74042 | {
| 74091 | ERRWRAP2(retval = _self_->trainAuto(samples, layout, responses, kFold, Cgrid, gammaGrid, pGrid, nuGrid, coeffGrid, degreeGrid, balanced)); |  | 74043 | ERRWRAP2(retval = _self_->trainAuto(samples, layout, responses, kFold, Cgrid, gammaGrid, pGrid, nuGrid, coeffGrid, degreeGrid, balanced));
| 74092 | return pyopencv_from(retval); |  | 74044 | return pyopencv_from(retval);
| 74093 | } |  | 74045 | }
| 74094 |  |  | 74046 |
| 74095 |  |  | 74047 |
| 74096 | pyPopulateArgumentConversionErrors(); |  | 74048 | pyPopulateArgumentConversionErrors();
| 74097 | } |  | 74049 | }
| 74098 | pyRaiseCVOverloadException("trainAuto"); |  | 74050 | pyRaiseCVOverloadException("trainAuto");
| 74099 |  |  | 74051 |
| 74100 | return NULL; |  | 74052 | return NULL;
| 74101 | } |  | 74053 | }
| 74102 |  |  | 74054 |
| 74103 |  |  | 74055 |
| 74104 |  |  | 74056 |
| 74105 | // Tables (ml_SVM) |  | 74057 | // Tables (ml_SVM)
| 74106 |  |  | 74058 |
| 74107 | static PyGetSetDef pyopencv_ml_SVM_getseters[] = |  | 74059 | static PyGetSetDef pyopencv_ml_SVM_getseters[] =
| 74108 | { |  | 74060 | {
| 74109 | {NULL} /* Sentinel */ |  | 74061 | {NULL} /* Sentinel */
| 74110 | }; |  | 74062 | };
| 74111 |  |  | 74063 |
| 74112 | static PyMethodDef pyopencv_ml_SVM_methods[] = |  | 74064 | static PyMethodDef pyopencv_ml_SVM_methods[] =
| 74113 | { |  | 74065 | {
| 74114 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_create_static, METH_STATIC), "create() -> retval\n. Creates empty model.\n. Use StatModel::train to train the model. Since %SVM has several parameters, you may want to\n. find the best parameters for your problem, it can be done with SVM::trainAuto."}, |  | 74066 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_create_static, METH_STATIC), "create() -> retval\n. Creates empty model.\n. Use StatModel::train to train the model. Since %SVM has several parameters, you may want to\n. find the best parameters for your problem, it can be done with SVM::trainAuto."},
| 74115 | {"getC", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getC, 0), "getC() -> retval\n. @see setC"}, |  | 74067 | {"getC", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getC, 0), "getC() -> retval\n. @see setC"},
| 74116 | {"getClassWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getClassWeights, 0), "getClassWeights() -> retval\n. @see setClassWeights"}, |  | 74068 | {"getClassWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getClassWeights, 0), "getClassWeights() -> retval\n. @see setClassWeights"},
| 74117 | {"getCoef0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getCoef0, 0), "getCoef0() -> retval\n. @see setCoef0"}, |  | 74069 | {"getCoef0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getCoef0, 0), "getCoef0() -> retval\n. @see setCoef0"},
| 74118 | {"getDecisionFunction", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getDecisionFunction, 0), "getDecisionFunction(i[, alpha[, svidx]]) -> retval, alpha, svidx\n. @brief Retrieves the decision function\n. \n. @param i the index of the decision function. If the problem solved is regression, 1-class or\n. 2-class classification, then there will be just one decision function and the index should\n. always be 0. Otherwise, in the case of N-class classification, there will be \\f$N(N-1)/2\\f$\n. decision functions.\n. @param alpha the optional output vector for weights, corresponding to different support vectors.\n. In the case of linear %SVM all the alpha's will be 1's.\n. @param svidx the optional output vector of indices of support vectors within the matrix of\n. support vectors (which can be retrieved by SVM::getSupportVectors). In the case of linear\n. %SVM each decision function consists of a single \"compressed\" support vector.\n. \n. The method returns rho parameter of the decision function, a scalar subtracted from the weighted\n. sum of kernel responses."}, |  | 74070 | {"getDecisionFunction", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getDecisionFunction, 0), "getDecisionFunction(i[, alpha[, svidx]]) -> retval, alpha, svidx\n. @brief Retrieves the decision function\n. \n. @param i the index of the decision function. If the problem solved is regression, 1-class or\n. 2-class classification, then there will be just one decision function and the index should\n. always be 0. Otherwise, in the case of N-class classification, there will be \\f$N(N-1)/2\\f$\n. decision functions.\n. @param alpha the optional output vector for weights, corresponding to different support vectors.\n. In the case of linear %SVM all the alpha's will be 1's.\n. @param svidx the optional output vector of indices of support vectors within the matrix of\n. support vectors (which can be retrieved by SVM::getSupportVectors). In the case of linear\n. %SVM each decision function consists of a single \"compressed\" support vector.\n. \n. The method returns rho parameter of the decision function, a scalar subtracted from the weighted\n. sum of kernel responses."},
| 74119 | {"getDefaultGridPtr", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getDefaultGridPtr_static, METH_STATIC), "getDefaultGridPtr(param_id) -> retval\n. @brief Generates a grid for %SVM parameters.\n. \n. @param param_id %SVM parameters IDs that must be one of the SVM::ParamTypes. The grid is\n. generated for the parameter with this ID.\n. \n. The function generates a grid pointer for the specified parameter of the %SVM algorithm.\n. The grid may be passed to the function SVM::trainAuto."}, |  | 74071 | {"getDefaultGridPtr", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getDefaultGridPtr_static, METH_STATIC), "getDefaultGridPtr(param_id) -> retval\n. @brief Generates a grid for %SVM parameters.\n. \n. @param param_id %SVM parameters IDs that must be one of the SVM::ParamTypes. The grid is\n. generated for the parameter with this ID.\n. \n. The function generates a grid pointer for the specified parameter of the %SVM algorithm.\n. The grid may be passed to the function SVM::trainAuto."},
| 74120 | {"getDegree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getDegree, 0), "getDegree() -> retval\n. @see setDegree"}, |  | 74072 | {"getDegree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getDegree, 0), "getDegree() -> retval\n. @see setDegree"},
| 74121 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getGamma, 0), "getGamma() -> retval\n. @see setGamma"}, |  | 74073 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getGamma, 0), "getGamma() -> retval\n. @see setGamma"},
| 74122 | {"getKernelType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getKernelType, 0), "getKernelType() -> retval\n. Type of a %SVM kernel.\n. See SVM::KernelTypes. Default value is SVM::RBF."}, |  | 74074 | {"getKernelType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getKernelType, 0), "getKernelType() -> retval\n. Type of a %SVM kernel.\n. See SVM::KernelTypes. Default value is SVM::RBF."},
| 74123 | {"getNu", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getNu, 0), "getNu() -> retval\n. @see setNu"}, |  | 74075 | {"getNu", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getNu, 0), "getNu() -> retval\n. @see setNu"},
| 74124 | {"getP", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getP, 0), "getP() -> retval\n. @see setP"}, |  | 74076 | {"getP", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getP, 0), "getP() -> retval\n. @see setP"},
| 74125 | {"getSupportVectors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getSupportVectors, 0), "getSupportVectors() -> retval\n. @brief Retrieves all the support vectors\n. \n. The method returns all the support vectors as a floating-point matrix, where support vectors are\n. stored as matrix rows."}, |  | 74077 | {"getSupportVectors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getSupportVectors, 0), "getSupportVectors() -> retval\n. @brief Retrieves all the support vectors\n. \n. The method returns all the support vectors as a floating-point matrix, where support vectors are\n. stored as matrix rows."},
| 74126 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"}, |  | 74078 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"},
| 74127 | {"getType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getType, 0), "getType() -> retval\n. @see setType"}, |  | 74079 | {"getType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getType, 0), "getType() -> retval\n. @see setType"},
| 74128 | {"getUncompressedSupportVectors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getUncompressedSupportVectors, 0), "getUncompressedSupportVectors() -> retval\n. @brief Retrieves all the uncompressed support vectors of a linear %SVM\n. \n. The method returns all the uncompressed support vectors of a linear %SVM that the compressed\n. support vector, used for prediction, was derived from. They are returned in a floating-point\n. matrix, where the support vectors are stored as matrix rows."}, |  | 74080 | {"getUncompressedSupportVectors", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_getUncompressedSupportVectors, 0), "getUncompressedSupportVectors() -> retval\n. @brief Retrieves all the uncompressed support vectors of a linear %SVM\n. \n. The method returns all the uncompressed support vectors of a linear %SVM that the compressed\n. support vector, used for prediction, was derived from. They are returned in a floating-point\n. matrix, where the support vectors are stored as matrix rows."},
| 74129 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_load_static, METH_STATIC), "load(filepath) -> retval\n. @brief Loads and creates a serialized svm from a file\n. *\n. * Use SVM::save to serialize and store an SVM to disk.\n. * Load the SVM from this file again, by calling this function with the path to the file.\n. *\n. * @param filepath path to serialized svm"}, |  | 74081 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_load_static, METH_STATIC), "load(filepath) -> retval\n. @brief Loads and creates a serialized svm from a file\n. *\n. * Use SVM::save to serialize and store an SVM to disk.\n. * Load the SVM from this file again, by calling this function with the path to the file.\n. *\n. * @param filepath path to serialized svm"},
| 74130 | {"setC", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setC, 0), "setC(val) -> None\n. @copybrief getC @see getC"}, |  | 74082 | {"setC", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setC, 0), "setC(val) -> None\n. @copybrief getC @see getC"},
| 74131 | {"setClassWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setClassWeights, 0), "setClassWeights(val) -> None\n. @copybrief getClassWeights @see getClassWeights"}, |  | 74083 | {"setClassWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setClassWeights, 0), "setClassWeights(val) -> None\n. @copybrief getClassWeights @see getClassWeights"},
| 74132 | {"setCoef0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setCoef0, 0), "setCoef0(val) -> None\n. @copybrief getCoef0 @see getCoef0"}, |  | 74084 | {"setCoef0", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setCoef0, 0), "setCoef0(val) -> None\n. @copybrief getCoef0 @see getCoef0"},
| 74133 | {"setDegree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setDegree, 0), "setDegree(val) -> None\n. @copybrief getDegree @see getDegree"}, |  | 74085 | {"setDegree", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setDegree, 0), "setDegree(val) -> None\n. @copybrief getDegree @see getDegree"},
| 74134 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setGamma, 0), "setGamma(val) -> None\n. @copybrief getGamma @see getGamma"}, |  | 74086 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setGamma, 0), "setGamma(val) -> None\n. @copybrief getGamma @see getGamma"},
| 74135 | {"setKernel", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setKernel, 0), "setKernel(kernelType) -> None\n. Initialize with one of predefined kernels.\n. See SVM::KernelTypes."}, |  | 74087 | {"setKernel", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setKernel, 0), "setKernel(kernelType) -> None\n. Initialize with one of predefined kernels.\n. See SVM::KernelTypes."},
| 74136 | {"setNu", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setNu, 0), "setNu(val) -> None\n. @copybrief getNu @see getNu"}, |  | 74088 | {"setNu", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setNu, 0), "setNu(val) -> None\n. @copybrief getNu @see getNu"},
| 74137 | {"setP", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setP, 0), "setP(val) -> None\n. @copybrief getP @see getP"}, |  | 74089 | {"setP", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setP, 0), "setP(val) -> None\n. @copybrief getP @see getP"},
| 74138 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"}, |  | 74090 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"},
| 74139 | {"setType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setType, 0), "setType(val) -> None\n. @copybrief getType @see getType"}, |  | 74091 | {"setType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_setType, 0), "setType(val) -> None\n. @copybrief getType @see getType"},
| 74140 | {"trainAuto", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_trainAuto, 0), "trainAuto(samples, layout, responses[, kFold[, Cgrid[, gammaGrid[, pGrid[, nuGrid[, coeffGrid[, degreeGrid[, balanced]]]]]]]]) -> retval\n. @brief Trains an %SVM with optimal parameters\n. \n. @param samples training samples\n. @param layout See ml::SampleTypes.\n. @param responses vector of responses associated with the training samples.\n. @param kFold Cross-validation parameter. The training set is divided into kFold subsets. One\n. subset is used to test the model, the others form the train set. So, the %SVM algorithm is\n. @param Cgrid grid for C\n. @param gammaGrid grid for gamma\n. @param pGrid grid for p\n. @param nuGrid grid for nu\n. @param coeffGrid grid for coeff\n. @param degreeGrid grid for degree\n. @param balanced If true and the problem is 2-class classification then the method creates more\n. balanced cross-validation subsets that is proportions between classes in subsets are close\n. to such proportion in the whole train dataset.\n. \n. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p,\n. nu, coef0, degree. Parameters are considered optimal when the cross-validation\n. estimate of the test set error is minimal.\n. \n. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only\n. offers rudimentary parameter options.\n. \n. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the\n. regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and\n. the usual %SVM with parameters specified in params is executed."}, |  | 74092 | {"trainAuto", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVM_trainAuto, 0), "trainAuto(samples, layout, responses[, kFold[, Cgrid[, gammaGrid[, pGrid[, nuGrid[, coeffGrid[, degreeGrid[, balanced]]]]]]]]) -> retval\n. @brief Trains an %SVM with optimal parameters\n. \n. @param samples training samples\n. @param layout See ml::SampleTypes.\n. @param responses vector of responses associated with the training samples.\n. @param kFold Cross-validation parameter. The training set is divided into kFold subsets. One\n. subset is used to test the model, the others form the train set. So, the %SVM algorithm is\n. @param Cgrid grid for C\n. @param gammaGrid grid for gamma\n. @param pGrid grid for p\n. @param nuGrid grid for nu\n. @param coeffGrid grid for coeff\n. @param degreeGrid grid for degree\n. @param balanced If true and the problem is 2-class classification then the method creates more\n. balanced cross-validation subsets that is proportions between classes in subsets are close\n. to such proportion in the whole train dataset.\n. \n. The method trains the %SVM model automatically by choosing the optimal parameters C, gamma, p,\n. nu, coef0, degree. Parameters are considered optimal when the cross-validation\n. estimate of the test set error is minimal.\n. \n. This function only makes use of SVM::getDefaultGrid for parameter optimization and thus only\n. offers rudimentary parameter options.\n. \n. This function works for the classification (SVM::C_SVC or SVM::NU_SVC) as well as for the\n. regression (SVM::EPS_SVR or SVM::NU_SVR). If it is SVM::ONE_CLASS, no optimization is made and\n. the usual %SVM with parameters specified in params is executed."},
| 74141 |  |  | 74093 |
| 74142 | {NULL, NULL} |  | 74094 | {NULL, NULL}
| 74143 | }; |  | 74095 | };
| 74144 |  |  | 74096 |
| 74145 | // Converter (ml_SVM) |  | 74097 | // Converter (ml_SVM)
| 74146 |  |  | 74098 |
| 74147 | template<> |  | 74099 | template<>
| 74148 | struct PyOpenCV_Converter< Ptr<cv::ml::SVM> > |  | 74100 | struct PyOpenCV_Converter< Ptr<cv::ml::SVM> >
| 74149 | { |  | 74101 | {
| 74150 | static PyObject* from(const Ptr<cv::ml::SVM>& r) |  | 74102 | static PyObject* from(const Ptr<cv::ml::SVM>& r)
| 74151 | { |  | 74103 | {
| 74152 | return pyopencv_ml_SVM_Instance(r); |  | 74104 | return pyopencv_ml_SVM_Instance(r);
| 74153 | } |  | 74105 | }
| 74154 | static bool to(PyObject* src, Ptr<cv::ml::SVM>& dst, const ArgInfo& info) |  | 74106 | static bool to(PyObject* src, Ptr<cv::ml::SVM>& dst, const ArgInfo& info)
| 74155 | { |  | 74107 | {
| 74156 | if(!src || src == Py_None) |  | 74108 | if(!src || src == Py_None)
| 74157 | return true; |  | 74109 | return true;
| 74158 | Ptr<cv::ml::SVM> * dst_; |  | 74110 | Ptr<cv::ml::SVM> * dst_;
| 74159 | if (pyopencv_ml_SVM_getp(src, dst_)) |  | 74111 | if (pyopencv_ml_SVM_getp(src, dst_))
| 74160 | { |  | 74112 | {
| 74161 | dst = *dst_; |  | 74113 | dst = *dst_;
| 74162 | return true; |  | 74114 | return true;
| 74163 | } |  | 74115 | }
| 74164 |  |  | 74116 |
| 74165 | failmsg("Expected Ptr<cv::ml::SVM> for argument '%s'", info.name); |  | 74117 | failmsg("Expected Ptr<cv::ml::SVM> for argument '%s'", info.name);
| 74166 | return false; |  | 74118 | return false;
| 74167 | } |  | 74119 | }
| 74168 | }; |  | 74120 | };
| 74169 |  |  | 74121 |
| 74170 | //================================================================================ |  | 74122 | //================================================================================
| 74171 | // ml_SVMSGD (Generic) |  | 74123 | // ml_SVMSGD (Generic)
| 74172 | //================================================================================ |  | 74124 | //================================================================================
| 74173 |  |  | 74125 |
| 74174 | // GetSet (ml_SVMSGD) |  | 74126 | // GetSet (ml_SVMSGD)
| 74175 |  |  | 74127 |
| 74176 |  |  | 74128 |
| 74177 |  |  | 74129 |
| 74178 | // Methods (ml_SVMSGD) |  | 74130 | // Methods (ml_SVMSGD)
| 74179 |  |  | 74131 |
| 74180 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74132 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 74181 | { |  | 74133 | {
| 74182 | using namespace cv::ml; |  | 74134 | using namespace cv::ml;
| 74183 |  |  | 74135 |
| 74184 | Ptr<SVMSGD> retval; |  | 74136 | Ptr<SVMSGD> retval;
| 74185 |  |  | 74137 |
| 74186 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74138 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74187 | { |  | 74139 | {
| 74188 | ERRWRAP2(retval = cv::ml::SVMSGD::create()); |  | 74140 | ERRWRAP2(retval = cv::ml::SVMSGD::create());
| 74189 | return pyopencv_from(retval); |  | 74141 | return pyopencv_from(retval);
| 74190 | } |  | 74142 | }
| 74191 |  |  | 74143 |
| 74192 | return NULL; |  | 74144 | return NULL;
| 74193 | } |  | 74145 | }
| 74194 |  |  | 74146 |
| 74195 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getInitialStepSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74147 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getInitialStepSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 74196 | { |  | 74148 | {
| 74197 | using namespace cv::ml; |  | 74149 | using namespace cv::ml;
| 74198 |  |  | 74150 |
| 74199 |  |  | 74151 |
| 74200 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74152 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74201 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74153 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74202 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74154 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74203 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74155 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74204 | float retval; |  | 74156 | float retval;
| 74205 |  |  | 74157 |
| 74206 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74158 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74207 | { |  | 74159 | {
| 74208 | ERRWRAP2(retval = _self_->getInitialStepSize()); |  | 74160 | ERRWRAP2(retval = _self_->getInitialStepSize());
| 74209 | return pyopencv_from(retval); |  | 74161 | return pyopencv_from(retval);
| 74210 | } |  | 74162 | }
| 74211 |  |  | 74163 |
| 74212 | return NULL; |  | 74164 | return NULL;
| 74213 | } |  | 74165 | }
| 74214 |  |  | 74166 |
| 74215 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getMarginRegularization(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74167 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getMarginRegularization(PyObject* self, PyObject* py_args, PyObject* kw)
| 74216 | { |  | 74168 | {
| 74217 | using namespace cv::ml; |  | 74169 | using namespace cv::ml;
| 74218 |  |  | 74170 |
| 74219 |  |  | 74171 |
| 74220 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74172 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74221 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74173 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74222 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74174 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74223 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74175 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74224 | float retval; |  | 74176 | float retval;
| 74225 |  |  | 74177 |
| 74226 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74178 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74227 | { |  | 74179 | {
| 74228 | ERRWRAP2(retval = _self_->getMarginRegularization()); |  | 74180 | ERRWRAP2(retval = _self_->getMarginRegularization());
| 74229 | return pyopencv_from(retval); |  | 74181 | return pyopencv_from(retval);
| 74230 | } |  | 74182 | }
| 74231 |  |  | 74183 |
| 74232 | return NULL; |  | 74184 | return NULL;
| 74233 | } |  | 74185 | }
| 74234 |  |  | 74186 |
| 74235 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getMarginType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74187 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getMarginType(PyObject* self, PyObject* py_args, PyObject* kw)
| 74236 | { |  | 74188 | {
| 74237 | using namespace cv::ml; |  | 74189 | using namespace cv::ml;
| 74238 |  |  | 74190 |
| 74239 |  |  | 74191 |
| 74240 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74192 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74241 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74193 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74242 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74194 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74243 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74195 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74244 | int retval; |  | 74196 | int retval;
| 74245 |  |  | 74197 |
| 74246 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74198 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74247 | { |  | 74199 | {
| 74248 | ERRWRAP2(retval = _self_->getMarginType()); |  | 74200 | ERRWRAP2(retval = _self_->getMarginType());
| 74249 | return pyopencv_from(retval); |  | 74201 | return pyopencv_from(retval);
| 74250 | } |  | 74202 | }
| 74251 |  |  | 74203 |
| 74252 | return NULL; |  | 74204 | return NULL;
| 74253 | } |  | 74205 | }
| 74254 |  |  | 74206 |
| 74255 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getShift(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74207 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getShift(PyObject* self, PyObject* py_args, PyObject* kw)
| 74256 | { |  | 74208 | {
| 74257 | using namespace cv::ml; |  | 74209 | using namespace cv::ml;
| 74258 |  |  | 74210 |
| 74259 |  |  | 74211 |
| 74260 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74212 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74261 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74213 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74262 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74214 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74263 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74215 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74264 | float retval; |  | 74216 | float retval;
| 74265 |  |  | 74217 |
| 74266 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74218 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74267 | { |  | 74219 | {
| 74268 | ERRWRAP2(retval = _self_->getShift()); |  | 74220 | ERRWRAP2(retval = _self_->getShift());
| 74269 | return pyopencv_from(retval); |  | 74221 | return pyopencv_from(retval);
| 74270 | } |  | 74222 | }
| 74271 |  |  | 74223 |
| 74272 | return NULL; |  | 74224 | return NULL;
| 74273 | } |  | 74225 | }
| 74274 |  |  | 74226 |
| 74275 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getStepDecreasingPower(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74227 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getStepDecreasingPower(PyObject* self, PyObject* py_args, PyObject* kw)
| 74276 | { |  | 74228 | {
| 74277 | using namespace cv::ml; |  | 74229 | using namespace cv::ml;
| 74278 |  |  | 74230 |
| 74279 |  |  | 74231 |
| 74280 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74232 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74281 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74233 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74282 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74234 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74283 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74235 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74284 | float retval; |  | 74236 | float retval;
| 74285 |  |  | 74237 |
| 74286 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74238 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74287 | { |  | 74239 | {
| 74288 | ERRWRAP2(retval = _self_->getStepDecreasingPower()); |  | 74240 | ERRWRAP2(retval = _self_->getStepDecreasingPower());
| 74289 | return pyopencv_from(retval); |  | 74241 | return pyopencv_from(retval);
| 74290 | } |  | 74242 | }
| 74291 |  |  | 74243 |
| 74292 | return NULL; |  | 74244 | return NULL;
| 74293 | } |  | 74245 | }
| 74294 |  |  | 74246 |
| 74295 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getSvmsgdType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74247 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getSvmsgdType(PyObject* self, PyObject* py_args, PyObject* kw)
| 74296 | { |  | 74248 | {
| 74297 | using namespace cv::ml; |  | 74249 | using namespace cv::ml;
| 74298 |  |  | 74250 |
| 74299 |  |  | 74251 |
| 74300 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74252 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74301 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74253 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74302 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74254 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74303 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74255 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74304 | int retval; |  | 74256 | int retval;
| 74305 |  |  | 74257 |
| 74306 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74258 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74307 | { |  | 74259 | {
| 74308 | ERRWRAP2(retval = _self_->getSvmsgdType()); |  | 74260 | ERRWRAP2(retval = _self_->getSvmsgdType());
| 74309 | return pyopencv_from(retval); |  | 74261 | return pyopencv_from(retval);
| 74310 | } |  | 74262 | }
| 74311 |  |  | 74263 |
| 74312 | return NULL; |  | 74264 | return NULL;
| 74313 | } |  | 74265 | }
| 74314 |  |  | 74266 |
| 74315 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74267 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 74316 | { |  | 74268 | {
| 74317 | using namespace cv::ml; |  | 74269 | using namespace cv::ml;
| 74318 |  |  | 74270 |
| 74319 |  |  | 74271 |
| 74320 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74272 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74321 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74273 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74322 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74274 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74323 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74275 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74324 | TermCriteria retval; |  | 74276 | TermCriteria retval;
| 74325 |  |  | 74277 |
| 74326 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74278 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74327 | { |  | 74279 | {
| 74328 | ERRWRAP2(retval = _self_->getTermCriteria()); |  | 74280 | ERRWRAP2(retval = _self_->getTermCriteria());
| 74329 | return pyopencv_from(retval); |  | 74281 | return pyopencv_from(retval);
| 74330 | } |  | 74282 | }
| 74331 |  |  | 74283 |
| 74332 | return NULL; |  | 74284 | return NULL;
| 74333 | } |  | 74285 | }
| 74334 |  |  | 74286 |
| 74335 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74287 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_getWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 74336 | { |  | 74288 | {
| 74337 | using namespace cv::ml; |  | 74289 | using namespace cv::ml;
| 74338 |  |  | 74290 |
| 74339 |  |  | 74291 |
| 74340 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74292 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74341 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74293 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74342 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74294 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74343 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74295 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74344 | Mat retval; |  | 74296 | Mat retval;
| 74345 |  |  | 74297 |
| 74346 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74298 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74347 | { |  | 74299 | {
| 74348 | ERRWRAP2(retval = _self_->getWeights()); |  | 74300 | ERRWRAP2(retval = _self_->getWeights());
| 74349 | return pyopencv_from(retval); |  | 74301 | return pyopencv_from(retval);
| 74350 | } |  | 74302 | }
| 74351 |  |  | 74303 |
| 74352 | return NULL; |  | 74304 | return NULL;
| 74353 | } |  | 74305 | }
| 74354 |  |  | 74306 |
| 74355 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_load_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74307 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_load_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 74356 | { |  | 74308 | {
| 74357 | using namespace cv::ml; |  | 74309 | using namespace cv::ml;
| 74358 |  |  | 74310 |
| 74359 | PyObject* pyobj_filepath = NULL; |  | 74311 | PyObject* pyobj_filepath = NULL;
| 74360 | String filepath; |  | 74312 | String filepath;
| 74361 | PyObject* pyobj_nodeName = NULL; |  | 74313 | PyObject* pyobj_nodeName = NULL;
| 74362 | String nodeName; |  | 74314 | String nodeName;
| 74363 | Ptr<SVMSGD> retval; |  | 74315 | Ptr<SVMSGD> retval;
| 74364 |  |  | 74316 |
| 74365 | const char* keywords[] = { "filepath", "nodeName", NULL }; |  | 74317 | const char* keywords[] = { "filepath", "nodeName", NULL };
| 74366 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_SVMSGD.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) && |  | 74318 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_SVMSGD.load", (char**)keywords, &pyobj_filepath, &pyobj_nodeName) &&
| 74367 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) && |  | 74319 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) &&
| 74368 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) ) |  | 74320 | pyopencv_to_safe(pyobj_nodeName, nodeName, ArgInfo("nodeName", 0)) )
| 74369 | { |  | 74321 | {
| 74370 | ERRWRAP2(retval = cv::ml::SVMSGD::load(filepath, nodeName)); |  | 74322 | ERRWRAP2(retval = cv::ml::SVMSGD::load(filepath, nodeName));
| 74371 | return pyopencv_from(retval); |  | 74323 | return pyopencv_from(retval);
| 74372 | } |  | 74324 | }
| 74373 |  |  | 74325 |
| 74374 | return NULL; |  | 74326 | return NULL;
| 74375 | } |  | 74327 | }
| 74376 |  |  | 74328 |
| 74377 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setInitialStepSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74329 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setInitialStepSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 74378 | { |  | 74330 | {
| 74379 | using namespace cv::ml; |  | 74331 | using namespace cv::ml;
| 74380 |  |  | 74332 |
| 74381 |  |  | 74333 |
| 74382 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74334 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74383 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74335 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74384 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74336 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74385 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74337 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74386 | PyObject* pyobj_InitialStepSize = NULL; |  | 74338 | PyObject* pyobj_InitialStepSize = NULL;
| 74387 | float InitialStepSize=0.f; |  | 74339 | float InitialStepSize=0.f;
| 74388 |  |  | 74340 |
| 74389 | const char* keywords[] = { "InitialStepSize", NULL }; |  | 74341 | const char* keywords[] = { "InitialStepSize", NULL };
| 74390 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setInitialStepSize", (char**)keywords, &pyobj_InitialStepSize) && |  | 74342 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setInitialStepSize", (char**)keywords, &pyobj_InitialStepSize) &&
| 74391 | pyopencv_to_safe(pyobj_InitialStepSize, InitialStepSize, ArgInfo("InitialStepSize", 0)) ) |  | 74343 | pyopencv_to_safe(pyobj_InitialStepSize, InitialStepSize, ArgInfo("InitialStepSize", 0)) )
| 74392 | { |  | 74344 | {
| 74393 | ERRWRAP2(_self_->setInitialStepSize(InitialStepSize)); |  | 74345 | ERRWRAP2(_self_->setInitialStepSize(InitialStepSize));
| 74394 | Py_RETURN_NONE; |  | 74346 | Py_RETURN_NONE;
| 74395 | } |  | 74347 | }
| 74396 |  |  | 74348 |
| 74397 | return NULL; |  | 74349 | return NULL;
| 74398 | } |  | 74350 | }
| 74399 |  |  | 74351 |
| 74400 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setMarginRegularization(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74352 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setMarginRegularization(PyObject* self, PyObject* py_args, PyObject* kw)
| 74401 | { |  | 74353 | {
| 74402 | using namespace cv::ml; |  | 74354 | using namespace cv::ml;
| 74403 |  |  | 74355 |
| 74404 |  |  | 74356 |
| 74405 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74357 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74406 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74358 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74407 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74359 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74408 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74360 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74409 | PyObject* pyobj_marginRegularization = NULL; |  | 74361 | PyObject* pyobj_marginRegularization = NULL;
| 74410 | float marginRegularization=0.f; |  | 74362 | float marginRegularization=0.f;
| 74411 |  |  | 74363 |
| 74412 | const char* keywords[] = { "marginRegularization", NULL }; |  | 74364 | const char* keywords[] = { "marginRegularization", NULL };
| 74413 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setMarginRegularization", (char**)keywords, &pyobj_marginRegularization) && |  | 74365 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setMarginRegularization", (char**)keywords, &pyobj_marginRegularization) &&
| 74414 | pyopencv_to_safe(pyobj_marginRegularization, marginRegularization, ArgInfo("marginRegularization", 0)) ) |  | 74366 | pyopencv_to_safe(pyobj_marginRegularization, marginRegularization, ArgInfo("marginRegularization", 0)) )
| 74415 | { |  | 74367 | {
| 74416 | ERRWRAP2(_self_->setMarginRegularization(marginRegularization)); |  | 74368 | ERRWRAP2(_self_->setMarginRegularization(marginRegularization));
| 74417 | Py_RETURN_NONE; |  | 74369 | Py_RETURN_NONE;
| 74418 | } |  | 74370 | }
| 74419 |  |  | 74371 |
| 74420 | return NULL; |  | 74372 | return NULL;
| 74421 | } |  | 74373 | }
| 74422 |  |  | 74374 |
| 74423 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setMarginType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74375 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setMarginType(PyObject* self, PyObject* py_args, PyObject* kw)
| 74424 | { |  | 74376 | {
| 74425 | using namespace cv::ml; |  | 74377 | using namespace cv::ml;
| 74426 |  |  | 74378 |
| 74427 |  |  | 74379 |
| 74428 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74380 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74429 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74381 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74430 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74382 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74431 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74383 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74432 | PyObject* pyobj_marginType = NULL; |  | 74384 | PyObject* pyobj_marginType = NULL;
| 74433 | int marginType=0; |  | 74385 | int marginType=0;
| 74434 |  |  | 74386 |
| 74435 | const char* keywords[] = { "marginType", NULL }; |  | 74387 | const char* keywords[] = { "marginType", NULL };
| 74436 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setMarginType", (char**)keywords, &pyobj_marginType) && |  | 74388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setMarginType", (char**)keywords, &pyobj_marginType) &&
| 74437 | pyopencv_to_safe(pyobj_marginType, marginType, ArgInfo("marginType", 0)) ) |  | 74389 | pyopencv_to_safe(pyobj_marginType, marginType, ArgInfo("marginType", 0)) )
| 74438 | { |  | 74390 | {
| 74439 | ERRWRAP2(_self_->setMarginType(marginType)); |  | 74391 | ERRWRAP2(_self_->setMarginType(marginType));
| 74440 | Py_RETURN_NONE; |  | 74392 | Py_RETURN_NONE;
| 74441 | } |  | 74393 | }
| 74442 |  |  | 74394 |
| 74443 | return NULL; |  | 74395 | return NULL;
| 74444 | } |  | 74396 | }
| 74445 |  |  | 74397 |
| 74446 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setOptimalParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74398 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setOptimalParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 74447 | { |  | 74399 | {
| 74448 | using namespace cv::ml; |  | 74400 | using namespace cv::ml;
| 74449 |  |  | 74401 |
| 74450 |  |  | 74402 |
| 74451 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74403 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74452 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74404 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74453 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74405 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74454 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74406 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74455 | PyObject* pyobj_svmsgdType = NULL; |  | 74407 | PyObject* pyobj_svmsgdType = NULL;
| 74456 | int svmsgdType=SVMSGD::ASGD; |  | 74408 | int svmsgdType=SVMSGD::ASGD;
| 74457 | PyObject* pyobj_marginType = NULL; |  | 74409 | PyObject* pyobj_marginType = NULL;
| 74458 | int marginType=SVMSGD::SOFT_MARGIN; |  | 74410 | int marginType=SVMSGD::SOFT_MARGIN;
| 74459 |  |  | 74411 |
| 74460 | const char* keywords[] = { "svmsgdType", "marginType", NULL }; |  | 74412 | const char* keywords[] = { "svmsgdType", "marginType", NULL };
| 74461 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:ml_SVMSGD.setOptimalParameters", (char**)keywords, &pyobj_svmsgdType, &pyobj_marginType) && |  | 74413 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:ml_SVMSGD.setOptimalParameters", (char**)keywords, &pyobj_svmsgdType, &pyobj_marginType) &&
| 74462 | pyopencv_to_safe(pyobj_svmsgdType, svmsgdType, ArgInfo("svmsgdType", 0)) && |  | 74414 | pyopencv_to_safe(pyobj_svmsgdType, svmsgdType, ArgInfo("svmsgdType", 0)) &&
| 74463 | pyopencv_to_safe(pyobj_marginType, marginType, ArgInfo("marginType", 0)) ) |  | 74415 | pyopencv_to_safe(pyobj_marginType, marginType, ArgInfo("marginType", 0)) )
| 74464 | { |  | 74416 | {
| 74465 | ERRWRAP2(_self_->setOptimalParameters(svmsgdType, marginType)); |  | 74417 | ERRWRAP2(_self_->setOptimalParameters(svmsgdType, marginType));
| 74466 | Py_RETURN_NONE; |  | 74418 | Py_RETURN_NONE;
| 74467 | } |  | 74419 | }
| 74468 |  |  | 74420 |
| 74469 | return NULL; |  | 74421 | return NULL;
| 74470 | } |  | 74422 | }
| 74471 |  |  | 74423 |
| 74472 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setStepDecreasingPower(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74424 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setStepDecreasingPower(PyObject* self, PyObject* py_args, PyObject* kw)
| 74473 | { |  | 74425 | {
| 74474 | using namespace cv::ml; |  | 74426 | using namespace cv::ml;
| 74475 |  |  | 74427 |
| 74476 |  |  | 74428 |
| 74477 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74429 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74478 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74430 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74479 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74431 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74480 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74432 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74481 | PyObject* pyobj_stepDecreasingPower = NULL; |  | 74433 | PyObject* pyobj_stepDecreasingPower = NULL;
| 74482 | float stepDecreasingPower=0.f; |  | 74434 | float stepDecreasingPower=0.f;
| 74483 |  |  | 74435 |
| 74484 | const char* keywords[] = { "stepDecreasingPower", NULL }; |  | 74436 | const char* keywords[] = { "stepDecreasingPower", NULL };
| 74485 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setStepDecreasingPower", (char**)keywords, &pyobj_stepDecreasingPower) && |  | 74437 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setStepDecreasingPower", (char**)keywords, &pyobj_stepDecreasingPower) &&
| 74486 | pyopencv_to_safe(pyobj_stepDecreasingPower, stepDecreasingPower, ArgInfo("stepDecreasingPower", 0)) ) |  | 74438 | pyopencv_to_safe(pyobj_stepDecreasingPower, stepDecreasingPower, ArgInfo("stepDecreasingPower", 0)) )
| 74487 | { |  | 74439 | {
| 74488 | ERRWRAP2(_self_->setStepDecreasingPower(stepDecreasingPower)); |  | 74440 | ERRWRAP2(_self_->setStepDecreasingPower(stepDecreasingPower));
| 74489 | Py_RETURN_NONE; |  | 74441 | Py_RETURN_NONE;
| 74490 | } |  | 74442 | }
| 74491 |  |  | 74443 |
| 74492 | return NULL; |  | 74444 | return NULL;
| 74493 | } |  | 74445 | }
| 74494 |  |  | 74446 |
| 74495 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setSvmsgdType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74447 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setSvmsgdType(PyObject* self, PyObject* py_args, PyObject* kw)
| 74496 | { |  | 74448 | {
| 74497 | using namespace cv::ml; |  | 74449 | using namespace cv::ml;
| 74498 |  |  | 74450 |
| 74499 |  |  | 74451 |
| 74500 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74452 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74501 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74453 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74502 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74454 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74503 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74455 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74504 | PyObject* pyobj_svmsgdType = NULL; |  | 74456 | PyObject* pyobj_svmsgdType = NULL;
| 74505 | int svmsgdType=0; |  | 74457 | int svmsgdType=0;
| 74506 |  |  | 74458 |
| 74507 | const char* keywords[] = { "svmsgdType", NULL }; |  | 74459 | const char* keywords[] = { "svmsgdType", NULL };
| 74508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setSvmsgdType", (char**)keywords, &pyobj_svmsgdType) && |  | 74460 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setSvmsgdType", (char**)keywords, &pyobj_svmsgdType) &&
| 74509 | pyopencv_to_safe(pyobj_svmsgdType, svmsgdType, ArgInfo("svmsgdType", 0)) ) |  | 74461 | pyopencv_to_safe(pyobj_svmsgdType, svmsgdType, ArgInfo("svmsgdType", 0)) )
| 74510 | { |  | 74462 | {
| 74511 | ERRWRAP2(_self_->setSvmsgdType(svmsgdType)); |  | 74463 | ERRWRAP2(_self_->setSvmsgdType(svmsgdType));
| 74512 | Py_RETURN_NONE; |  | 74464 | Py_RETURN_NONE;
| 74513 | } |  | 74465 | }
| 74514 |  |  | 74466 |
| 74515 | return NULL; |  | 74467 | return NULL;
| 74516 | } |  | 74468 | }
| 74517 |  |  | 74469 |
| 74518 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74470 | static PyObject* pyopencv_cv_ml_ml_SVMSGD_setTermCriteria(PyObject* self, PyObject* py_args, PyObject* kw)
| 74519 | { |  | 74471 | {
| 74520 | using namespace cv::ml; |  | 74472 | using namespace cv::ml;
| 74521 |  |  | 74473 |
| 74522 |  |  | 74474 |
| 74523 | Ptr<cv::ml::SVMSGD> * self1 = 0; |  | 74475 | Ptr<cv::ml::SVMSGD> * self1 = 0;
| 74524 | if (!pyopencv_ml_SVMSGD_getp(self, self1)) |  | 74476 | if (!pyopencv_ml_SVMSGD_getp(self, self1))
| 74525 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)"); |  | 74477 | return failmsgp("Incorrect type of self (must be 'ml_SVMSGD' or its derivative)");
| 74526 | Ptr<cv::ml::SVMSGD> _self_ = *(self1); |  | 74478 | Ptr<cv::ml::SVMSGD> _self_ = *(self1);
| 74527 | PyObject* pyobj_val = NULL; |  | 74479 | PyObject* pyobj_val = NULL;
| 74528 | TermCriteria val; |  | 74480 | TermCriteria val;
| 74529 |  |  | 74481 |
| 74530 | const char* keywords[] = { "val", NULL }; |  | 74482 | const char* keywords[] = { "val", NULL };
| 74531 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setTermCriteria", (char**)keywords, &pyobj_val) && |  | 74483 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_SVMSGD.setTermCriteria", (char**)keywords, &pyobj_val) &&
| 74532 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 74484 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 74533 | { |  | 74485 | {
| 74534 | ERRWRAP2(_self_->setTermCriteria(val)); |  | 74486 | ERRWRAP2(_self_->setTermCriteria(val));
| 74535 | Py_RETURN_NONE; |  | 74487 | Py_RETURN_NONE;
| 74536 | } |  | 74488 | }
| 74537 |  |  | 74489 |
| 74538 | return NULL; |  | 74490 | return NULL;
| 74539 | } |  | 74491 | }
| 74540 |  |  | 74492 |
| 74541 |  |  | 74493 |
| 74542 |  |  | 74494 |
| 74543 | // Tables (ml_SVMSGD) |  | 74495 | // Tables (ml_SVMSGD)
| 74544 |  |  | 74496 |
| 74545 | static PyGetSetDef pyopencv_ml_SVMSGD_getseters[] = |  | 74497 | static PyGetSetDef pyopencv_ml_SVMSGD_getseters[] =
| 74546 | { |  | 74498 | {
| 74547 | {NULL} /* Sentinel */ |  | 74499 | {NULL} /* Sentinel */
| 74548 | }; |  | 74500 | };
| 74549 |  |  | 74501 |
| 74550 | static PyMethodDef pyopencv_ml_SVMSGD_methods[] = |  | 74502 | static PyMethodDef pyopencv_ml_SVMSGD_methods[] =
| 74551 | { |  | 74503 | {
| 74552 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_create_static, METH_STATIC), "create() -> retval\n. @brief Creates empty model.\n. * Use StatModel::train to train the model. Since %SVMSGD has several parameters, you may want to\n. * find the best parameters for your problem or use setOptimalParameters() to set some default parameters."}, |  | 74504 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_create_static, METH_STATIC), "create() -> retval\n. @brief Creates empty model.\n. * Use StatModel::train to train the model. Since %SVMSGD has several parameters, you may want to\n. * find the best parameters for your problem or use setOptimalParameters() to set some default parameters."},
| 74553 | {"getInitialStepSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getInitialStepSize, 0), "getInitialStepSize() -> retval\n. @see setInitialStepSize"}, |  | 74505 | {"getInitialStepSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getInitialStepSize, 0), "getInitialStepSize() -> retval\n. @see setInitialStepSize"},
| 74554 | {"getMarginRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getMarginRegularization, 0), "getMarginRegularization() -> retval\n. @see setMarginRegularization"}, |  | 74506 | {"getMarginRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getMarginRegularization, 0), "getMarginRegularization() -> retval\n. @see setMarginRegularization"},
| 74555 | {"getMarginType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getMarginType, 0), "getMarginType() -> retval\n. @see setMarginType"}, |  | 74507 | {"getMarginType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getMarginType, 0), "getMarginType() -> retval\n. @see setMarginType"},
| 74556 | {"getShift", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getShift, 0), "getShift() -> retval\n. * @return the shift of the trained model (decision function f(x) = weights * x + shift)."}, |  | 74508 | {"getShift", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getShift, 0), "getShift() -> retval\n. * @return the shift of the trained model (decision function f(x) = weights * x + shift)."},
| 74557 | {"getStepDecreasingPower", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getStepDecreasingPower, 0), "getStepDecreasingPower() -> retval\n. @see setStepDecreasingPower"}, |  | 74509 | {"getStepDecreasingPower", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getStepDecreasingPower, 0), "getStepDecreasingPower() -> retval\n. @see setStepDecreasingPower"},
| 74558 | {"getSvmsgdType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getSvmsgdType, 0), "getSvmsgdType() -> retval\n. @see setSvmsgdType"}, |  | 74510 | {"getSvmsgdType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getSvmsgdType, 0), "getSvmsgdType() -> retval\n. @see setSvmsgdType"},
| 74559 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"}, |  | 74511 | {"getTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getTermCriteria, 0), "getTermCriteria() -> retval\n. @see setTermCriteria"},
| 74560 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getWeights, 0), "getWeights() -> retval\n. * @return the weights of the trained model (decision function f(x) = weights * x + shift)."}, |  | 74512 | {"getWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_getWeights, 0), "getWeights() -> retval\n. * @return the weights of the trained model (decision function f(x) = weights * x + shift)."},
| 74561 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized SVMSGD from a file\n. *\n. * Use SVMSGD::save to serialize and store an SVMSGD to disk.\n. * Load the SVMSGD from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized SVMSGD\n. * @param nodeName name of node containing the classifier"}, |  | 74513 | {"load", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_load_static, METH_STATIC), "load(filepath[, nodeName]) -> retval\n. @brief Loads and creates a serialized SVMSGD from a file\n. *\n. * Use SVMSGD::save to serialize and store an SVMSGD to disk.\n. * Load the SVMSGD from this file again, by calling this function with the path to the file.\n. * Optionally specify the node for the file containing the classifier\n. *\n. * @param filepath path to serialized SVMSGD\n. * @param nodeName name of node containing the classifier"},
| 74562 | {"setInitialStepSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setInitialStepSize, 0), "setInitialStepSize(InitialStepSize) -> None\n. @copybrief getInitialStepSize @see getInitialStepSize"}, |  | 74514 | {"setInitialStepSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setInitialStepSize, 0), "setInitialStepSize(InitialStepSize) -> None\n. @copybrief getInitialStepSize @see getInitialStepSize"},
| 74563 | {"setMarginRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setMarginRegularization, 0), "setMarginRegularization(marginRegularization) -> None\n. @copybrief getMarginRegularization @see getMarginRegularization"}, |  | 74515 | {"setMarginRegularization", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setMarginRegularization, 0), "setMarginRegularization(marginRegularization) -> None\n. @copybrief getMarginRegularization @see getMarginRegularization"},
| 74564 | {"setMarginType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setMarginType, 0), "setMarginType(marginType) -> None\n. @copybrief getMarginType @see getMarginType"}, |  | 74516 | {"setMarginType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setMarginType, 0), "setMarginType(marginType) -> None\n. @copybrief getMarginType @see getMarginType"},
| 74565 | {"setOptimalParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setOptimalParameters, 0), "setOptimalParameters([, svmsgdType[, marginType]]) -> None\n. @brief Function sets optimal parameters values for chosen SVM SGD model.\n. * @param svmsgdType is the type of SVMSGD classifier.\n. * @param marginType is the type of margin constraint."}, |  | 74517 | {"setOptimalParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setOptimalParameters, 0), "setOptimalParameters([, svmsgdType[, marginType]]) -> None\n. @brief Function sets optimal parameters values for chosen SVM SGD model.\n. * @param svmsgdType is the type of SVMSGD classifier.\n. * @param marginType is the type of margin constraint."},
| 74566 | {"setStepDecreasingPower", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setStepDecreasingPower, 0), "setStepDecreasingPower(stepDecreasingPower) -> None\n. @copybrief getStepDecreasingPower @see getStepDecreasingPower"}, |  | 74518 | {"setStepDecreasingPower", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setStepDecreasingPower, 0), "setStepDecreasingPower(stepDecreasingPower) -> None\n. @copybrief getStepDecreasingPower @see getStepDecreasingPower"},
| 74567 | {"setSvmsgdType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setSvmsgdType, 0), "setSvmsgdType(svmsgdType) -> None\n. @copybrief getSvmsgdType @see getSvmsgdType"}, |  | 74519 | {"setSvmsgdType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setSvmsgdType, 0), "setSvmsgdType(svmsgdType) -> None\n. @copybrief getSvmsgdType @see getSvmsgdType"},
| 74568 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"}, |  | 74520 | {"setTermCriteria", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_SVMSGD_setTermCriteria, 0), "setTermCriteria(val) -> None\n. @copybrief getTermCriteria @see getTermCriteria"},
| 74569 |  |  | 74521 |
| 74570 | {NULL, NULL} |  | 74522 | {NULL, NULL}
| 74571 | }; |  | 74523 | };
| 74572 |  |  | 74524 |
| 74573 | // Converter (ml_SVMSGD) |  | 74525 | // Converter (ml_SVMSGD)
| 74574 |  |  | 74526 |
| 74575 | template<> |  | 74527 | template<>
| 74576 | struct PyOpenCV_Converter< Ptr<cv::ml::SVMSGD> > |  | 74528 | struct PyOpenCV_Converter< Ptr<cv::ml::SVMSGD> >
| 74577 | { |  | 74529 | {
| 74578 | static PyObject* from(const Ptr<cv::ml::SVMSGD>& r) |  | 74530 | static PyObject* from(const Ptr<cv::ml::SVMSGD>& r)
| 74579 | { |  | 74531 | {
| 74580 | return pyopencv_ml_SVMSGD_Instance(r); |  | 74532 | return pyopencv_ml_SVMSGD_Instance(r);
| 74581 | } |  | 74533 | }
| 74582 | static bool to(PyObject* src, Ptr<cv::ml::SVMSGD>& dst, const ArgInfo& info) |  | 74534 | static bool to(PyObject* src, Ptr<cv::ml::SVMSGD>& dst, const ArgInfo& info)
| 74583 | { |  | 74535 | {
| 74584 | if(!src || src == Py_None) |  | 74536 | if(!src || src == Py_None)
| 74585 | return true; |  | 74537 | return true;
| 74586 | Ptr<cv::ml::SVMSGD> * dst_; |  | 74538 | Ptr<cv::ml::SVMSGD> * dst_;
| 74587 | if (pyopencv_ml_SVMSGD_getp(src, dst_)) |  | 74539 | if (pyopencv_ml_SVMSGD_getp(src, dst_))
| 74588 | { |  | 74540 | {
| 74589 | dst = *dst_; |  | 74541 | dst = *dst_;
| 74590 | return true; |  | 74542 | return true;
| 74591 | } |  | 74543 | }
| 74592 |  |  | 74544 |
| 74593 | failmsg("Expected Ptr<cv::ml::SVMSGD> for argument '%s'", info.name); |  | 74545 | failmsg("Expected Ptr<cv::ml::SVMSGD> for argument '%s'", info.name);
| 74594 | return false; |  | 74546 | return false;
| 74595 | } |  | 74547 | }
| 74596 | }; |  | 74548 | };
| 74597 |  |  | 74549 |
| 74598 | //================================================================================ |  | 74550 | //================================================================================
| 74599 | // ml_StatModel (Generic) |  | 74551 | // ml_StatModel (Generic)
| 74600 | //================================================================================ |  | 74552 | //================================================================================
| 74601 |  |  | 74553 |
| 74602 | // GetSet (ml_StatModel) |  | 74554 | // GetSet (ml_StatModel)
| 74603 |  |  | 74555 |
| 74604 |  |  | 74556 |
| 74605 |  |  | 74557 |
| 74606 | // Methods (ml_StatModel) |  | 74558 | // Methods (ml_StatModel)
| 74607 |  |  | 74559 |
| 74608 | static PyObject* pyopencv_cv_ml_ml_StatModel_calcError(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74560 | static PyObject* pyopencv_cv_ml_ml_StatModel_calcError(PyObject* self, PyObject* py_args, PyObject* kw)
| 74609 | { |  | 74561 | {
| 74610 | using namespace cv::ml; |  | 74562 | using namespace cv::ml;
| 74611 |  |  | 74563 |
| 74612 |  |  | 74564 |
| 74613 | Ptr<cv::ml::StatModel> * self1 = 0; |  | 74565 | Ptr<cv::ml::StatModel> * self1 = 0;
| 74614 | if (!pyopencv_ml_StatModel_getp(self, self1)) |  | 74566 | if (!pyopencv_ml_StatModel_getp(self, self1))
| 74615 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)"); |  | 74567 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)");
| 74616 | Ptr<cv::ml::StatModel> _self_ = *(self1); |  | 74568 | Ptr<cv::ml::StatModel> _self_ = *(self1);
| 74617 | pyPrepareArgumentConversionErrorsStorage(2); |  | 74569 | pyPrepareArgumentConversionErrorsStorage(2);
| 74618 |  |  | 74570 |
| 74619 | { |  | 74571 | {
| 74620 | PyObject* pyobj_data = NULL; |  | 74572 | PyObject* pyobj_data = NULL;
| 74621 | Ptr<TrainData> data; |  | 74573 | Ptr<TrainData> data;
| 74622 | PyObject* pyobj_test = NULL; |  | 74574 | PyObject* pyobj_test = NULL;
| 74623 | bool test=0; |  | 74575 | bool test=0;
| 74624 | PyObject* pyobj_resp = NULL; |  | 74576 | PyObject* pyobj_resp = NULL;
| 74625 | Mat resp; |  | 74577 | Mat resp;
| 74626 | float retval; |  | 74578 | float retval;
| 74627 |  |  | 74579 |
| 74628 | const char* keywords[] = { "data", "test", "resp", NULL }; |  | 74580 | const char* keywords[] = { "data", "test", "resp", NULL };
| 74629 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_StatModel.calcError", (char**)keywords, &pyobj_data, &pyobj_test, &pyobj_resp) && |  | 74581 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_StatModel.calcError", (char**)keywords, &pyobj_data, &pyobj_test, &pyobj_resp) &&
| 74630 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) && |  | 74582 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) &&
| 74631 | pyopencv_to_safe(pyobj_test, test, ArgInfo("test", 0)) && |  | 74583 | pyopencv_to_safe(pyobj_test, test, ArgInfo("test", 0)) &&
| 74632 | pyopencv_to_safe(pyobj_resp, resp, ArgInfo("resp", 1)) ) |  | 74584 | pyopencv_to_safe(pyobj_resp, resp, ArgInfo("resp", 1)) )
| 74633 | { |  | 74585 | {
| 74634 | ERRWRAP2(retval = _self_->calcError(data, test, resp)); |  | 74586 | ERRWRAP2(retval = _self_->calcError(data, test, resp));
| 74635 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(resp)); |  | 74587 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(resp));
| 74636 | } |  | 74588 | }
| 74637 |  |  | 74589 |
| 74638 |  |  | 74590 |
| 74639 | pyPopulateArgumentConversionErrors(); |  | 74591 | pyPopulateArgumentConversionErrors();
| 74640 | } |  | 74592 | }
| 74641 |  |  | 74593 |
| 74642 |  |  | 74594 |
| 74643 | { |  | 74595 | {
| 74644 | PyObject* pyobj_data = NULL; |  | 74596 | PyObject* pyobj_data = NULL;
| 74645 | Ptr<TrainData> data; |  | 74597 | Ptr<TrainData> data;
| 74646 | PyObject* pyobj_test = NULL; |  | 74598 | PyObject* pyobj_test = NULL;
| 74647 | bool test=0; |  | 74599 | bool test=0;
| 74648 | PyObject* pyobj_resp = NULL; |  | 74600 | PyObject* pyobj_resp = NULL;
| 74649 | UMat resp; |  | 74601 | UMat resp;
| 74650 | float retval; |  | 74602 | float retval;
| 74651 |  |  | 74603 |
| 74652 | const char* keywords[] = { "data", "test", "resp", NULL }; |  | 74604 | const char* keywords[] = { "data", "test", "resp", NULL };
| 74653 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_StatModel.calcError", (char**)keywords, &pyobj_data, &pyobj_test, &pyobj_resp) && |  | 74605 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:ml_StatModel.calcError", (char**)keywords, &pyobj_data, &pyobj_test, &pyobj_resp) &&
| 74654 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) && |  | 74606 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) &&
| 74655 | pyopencv_to_safe(pyobj_test, test, ArgInfo("test", 0)) && |  | 74607 | pyopencv_to_safe(pyobj_test, test, ArgInfo("test", 0)) &&
| 74656 | pyopencv_to_safe(pyobj_resp, resp, ArgInfo("resp", 1)) ) |  | 74608 | pyopencv_to_safe(pyobj_resp, resp, ArgInfo("resp", 1)) )
| 74657 | { |  | 74609 | {
| 74658 | ERRWRAP2(retval = _self_->calcError(data, test, resp)); |  | 74610 | ERRWRAP2(retval = _self_->calcError(data, test, resp));
| 74659 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(resp)); |  | 74611 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(resp));
| 74660 | } |  | 74612 | }
| 74661 |  |  | 74613 |
| 74662 |  |  | 74614 |
| 74663 | pyPopulateArgumentConversionErrors(); |  | 74615 | pyPopulateArgumentConversionErrors();
| 74664 | } |  | 74616 | }
| 74665 | pyRaiseCVOverloadException("calcError"); |  | 74617 | pyRaiseCVOverloadException("calcError");
| 74666 |  |  | 74618 |
| 74667 | return NULL; |  | 74619 | return NULL;
| 74668 | } |  | 74620 | }
| 74669 |  |  | 74621 |
| 74670 | static PyObject* pyopencv_cv_ml_ml_StatModel_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74622 | static PyObject* pyopencv_cv_ml_ml_StatModel_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 74671 | { |  | 74623 | {
| 74672 | using namespace cv::ml; |  | 74624 | using namespace cv::ml;
| 74673 |  |  | 74625 |
| 74674 |  |  | 74626 |
| 74675 | Ptr<cv::ml::StatModel> * self1 = 0; |  | 74627 | Ptr<cv::ml::StatModel> * self1 = 0;
| 74676 | if (!pyopencv_ml_StatModel_getp(self, self1)) |  | 74628 | if (!pyopencv_ml_StatModel_getp(self, self1))
| 74677 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)"); |  | 74629 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)");
| 74678 | Ptr<cv::ml::StatModel> _self_ = *(self1); |  | 74630 | Ptr<cv::ml::StatModel> _self_ = *(self1);
| 74679 | bool retval; |  | 74631 | bool retval;
| 74680 |  |  | 74632 |
| 74681 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74633 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74682 | { |  | 74634 | {
| 74683 | ERRWRAP2(retval = _self_->empty()); |  | 74635 | ERRWRAP2(retval = _self_->empty());
| 74684 | return pyopencv_from(retval); |  | 74636 | return pyopencv_from(retval);
| 74685 | } |  | 74637 | }
| 74686 |  |  | 74638 |
| 74687 | return NULL; |  | 74639 | return NULL;
| 74688 | } |  | 74640 | }
| 74689 |  |  | 74641 |
| 74690 | static PyObject* pyopencv_cv_ml_ml_StatModel_getVarCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74642 | static PyObject* pyopencv_cv_ml_ml_StatModel_getVarCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 74691 | { |  | 74643 | {
| 74692 | using namespace cv::ml; |  | 74644 | using namespace cv::ml;
| 74693 |  |  | 74645 |
| 74694 |  |  | 74646 |
| 74695 | Ptr<cv::ml::StatModel> * self1 = 0; |  | 74647 | Ptr<cv::ml::StatModel> * self1 = 0;
| 74696 | if (!pyopencv_ml_StatModel_getp(self, self1)) |  | 74648 | if (!pyopencv_ml_StatModel_getp(self, self1))
| 74697 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)"); |  | 74649 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)");
| 74698 | Ptr<cv::ml::StatModel> _self_ = *(self1); |  | 74650 | Ptr<cv::ml::StatModel> _self_ = *(self1);
| 74699 | int retval; |  | 74651 | int retval;
| 74700 |  |  | 74652 |
| 74701 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74653 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74702 | { |  | 74654 | {
| 74703 | ERRWRAP2(retval = _self_->getVarCount()); |  | 74655 | ERRWRAP2(retval = _self_->getVarCount());
| 74704 | return pyopencv_from(retval); |  | 74656 | return pyopencv_from(retval);
| 74705 | } |  | 74657 | }
| 74706 |  |  | 74658 |
| 74707 | return NULL; |  | 74659 | return NULL;
| 74708 | } |  | 74660 | }
| 74709 |  |  | 74661 |
| 74710 | static PyObject* pyopencv_cv_ml_ml_StatModel_isClassifier(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74662 | static PyObject* pyopencv_cv_ml_ml_StatModel_isClassifier(PyObject* self, PyObject* py_args, PyObject* kw)
| 74711 | { |  | 74663 | {
| 74712 | using namespace cv::ml; |  | 74664 | using namespace cv::ml;
| 74713 |  |  | 74665 |
| 74714 |  |  | 74666 |
| 74715 | Ptr<cv::ml::StatModel> * self1 = 0; |  | 74667 | Ptr<cv::ml::StatModel> * self1 = 0;
| 74716 | if (!pyopencv_ml_StatModel_getp(self, self1)) |  | 74668 | if (!pyopencv_ml_StatModel_getp(self, self1))
| 74717 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)"); |  | 74669 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)");
| 74718 | Ptr<cv::ml::StatModel> _self_ = *(self1); |  | 74670 | Ptr<cv::ml::StatModel> _self_ = *(self1);
| 74719 | bool retval; |  | 74671 | bool retval;
| 74720 |  |  | 74672 |
| 74721 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74673 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74722 | { |  | 74674 | {
| 74723 | ERRWRAP2(retval = _self_->isClassifier()); |  | 74675 | ERRWRAP2(retval = _self_->isClassifier());
| 74724 | return pyopencv_from(retval); |  | 74676 | return pyopencv_from(retval);
| 74725 | } |  | 74677 | }
| 74726 |  |  | 74678 |
| 74727 | return NULL; |  | 74679 | return NULL;
| 74728 | } |  | 74680 | }
| 74729 |  |  | 74681 |
| 74730 | static PyObject* pyopencv_cv_ml_ml_StatModel_isTrained(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74682 | static PyObject* pyopencv_cv_ml_ml_StatModel_isTrained(PyObject* self, PyObject* py_args, PyObject* kw)
| 74731 | { |  | 74683 | {
| 74732 | using namespace cv::ml; |  | 74684 | using namespace cv::ml;
| 74733 |  |  | 74685 |
| 74734 |  |  | 74686 |
| 74735 | Ptr<cv::ml::StatModel> * self1 = 0; |  | 74687 | Ptr<cv::ml::StatModel> * self1 = 0;
| 74736 | if (!pyopencv_ml_StatModel_getp(self, self1)) |  | 74688 | if (!pyopencv_ml_StatModel_getp(self, self1))
| 74737 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)"); |  | 74689 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)");
| 74738 | Ptr<cv::ml::StatModel> _self_ = *(self1); |  | 74690 | Ptr<cv::ml::StatModel> _self_ = *(self1);
| 74739 | bool retval; |  | 74691 | bool retval;
| 74740 |  |  | 74692 |
| 74741 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 74693 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 74742 | { |  | 74694 | {
| 74743 | ERRWRAP2(retval = _self_->isTrained()); |  | 74695 | ERRWRAP2(retval = _self_->isTrained());
| 74744 | return pyopencv_from(retval); |  | 74696 | return pyopencv_from(retval);
| 74745 | } |  | 74697 | }
| 74746 |  |  | 74698 |
| 74747 | return NULL; |  | 74699 | return NULL;
| 74748 | } |  | 74700 | }
| 74749 |  |  | 74701 |
| 74750 | static PyObject* pyopencv_cv_ml_ml_StatModel_predict(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74702 | static PyObject* pyopencv_cv_ml_ml_StatModel_predict(PyObject* self, PyObject* py_args, PyObject* kw)
| 74751 | { |  | 74703 | {
| 74752 | using namespace cv::ml; |  | 74704 | using namespace cv::ml;
| 74753 |  |  | 74705 |
| 74754 |  |  | 74706 |
| 74755 | Ptr<cv::ml::StatModel> * self1 = 0; |  | 74707 | Ptr<cv::ml::StatModel> * self1 = 0;
| 74756 | if (!pyopencv_ml_StatModel_getp(self, self1)) |  | 74708 | if (!pyopencv_ml_StatModel_getp(self, self1))
| 74757 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)"); |  | 74709 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)");
| 74758 | Ptr<cv::ml::StatModel> _self_ = *(self1); |  | 74710 | Ptr<cv::ml::StatModel> _self_ = *(self1);
| 74759 | pyPrepareArgumentConversionErrorsStorage(2); |  | 74711 | pyPrepareArgumentConversionErrorsStorage(2);
| 74760 |  |  | 74712 |
| 74761 | { |  | 74713 | {
| 74762 | PyObject* pyobj_samples = NULL; |  | 74714 | PyObject* pyobj_samples = NULL;
| 74763 | Mat samples; |  | 74715 | Mat samples;
| 74764 | PyObject* pyobj_results = NULL; |  | 74716 | PyObject* pyobj_results = NULL;
| 74765 | Mat results; |  | 74717 | Mat results;
| 74766 | PyObject* pyobj_flags = NULL; |  | 74718 | PyObject* pyobj_flags = NULL;
| 74767 | int flags=0; |  | 74719 | int flags=0;
| 74768 | float retval; |  | 74720 | float retval;
| 74769 |  |  | 74721 |
| 74770 | const char* keywords[] = { "samples", "results", "flags", NULL }; |  | 74722 | const char* keywords[] = { "samples", "results", "flags", NULL };
| 74771 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_StatModel.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) && |  | 74723 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_StatModel.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) &&
| 74772 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 74724 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 74773 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 74725 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 74774 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 74726 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 74775 | { |  | 74727 | {
| 74776 | ERRWRAP2(retval = _self_->predict(samples, results, flags)); |  | 74728 | ERRWRAP2(retval = _self_->predict(samples, results, flags));
| 74777 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results)); |  | 74729 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results));
| 74778 | } |  | 74730 | }
| 74779 |  |  | 74731 |
| 74780 |  |  | 74732 |
| 74781 | pyPopulateArgumentConversionErrors(); |  | 74733 | pyPopulateArgumentConversionErrors();
| 74782 | } |  | 74734 | }
| 74783 |  |  | 74735 |
| 74784 |  |  | 74736 |
| 74785 | { |  | 74737 | {
| 74786 | PyObject* pyobj_samples = NULL; |  | 74738 | PyObject* pyobj_samples = NULL;
| 74787 | UMat samples; |  | 74739 | UMat samples;
| 74788 | PyObject* pyobj_results = NULL; |  | 74740 | PyObject* pyobj_results = NULL;
| 74789 | UMat results; |  | 74741 | UMat results;
| 74790 | PyObject* pyobj_flags = NULL; |  | 74742 | PyObject* pyobj_flags = NULL;
| 74791 | int flags=0; |  | 74743 | int flags=0;
| 74792 | float retval; |  | 74744 | float retval;
| 74793 |  |  | 74745 |
| 74794 | const char* keywords[] = { "samples", "results", "flags", NULL }; |  | 74746 | const char* keywords[] = { "samples", "results", "flags", NULL };
| 74795 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_StatModel.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) && |  | 74747 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ml_StatModel.predict", (char**)keywords, &pyobj_samples, &pyobj_results, &pyobj_flags) &&
| 74796 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 74748 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 74797 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) && |  | 74749 | pyopencv_to_safe(pyobj_results, results, ArgInfo("results", 1)) &&
| 74798 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 74750 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 74799 | { |  | 74751 | {
| 74800 | ERRWRAP2(retval = _self_->predict(samples, results, flags)); |  | 74752 | ERRWRAP2(retval = _self_->predict(samples, results, flags));
| 74801 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results)); |  | 74753 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(results));
| 74802 | } |  | 74754 | }
| 74803 |  |  | 74755 |
| 74804 |  |  | 74756 |
| 74805 | pyPopulateArgumentConversionErrors(); |  | 74757 | pyPopulateArgumentConversionErrors();
| 74806 | } |  | 74758 | }
| 74807 | pyRaiseCVOverloadException("predict"); |  | 74759 | pyRaiseCVOverloadException("predict");
| 74808 |  |  | 74760 |
| 74809 | return NULL; |  | 74761 | return NULL;
| 74810 | } |  | 74762 | }
| 74811 |  |  | 74763 |
| 74812 | static PyObject* pyopencv_cv_ml_ml_StatModel_train(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74764 | static PyObject* pyopencv_cv_ml_ml_StatModel_train(PyObject* self, PyObject* py_args, PyObject* kw)
| 74813 | { |  | 74765 | {
| 74814 | using namespace cv::ml; |  | 74766 | using namespace cv::ml;
| 74815 |  |  | 74767 |
| 74816 |  |  | 74768 |
| 74817 | Ptr<cv::ml::StatModel> * self1 = 0; |  | 74769 | Ptr<cv::ml::StatModel> * self1 = 0;
| 74818 | if (!pyopencv_ml_StatModel_getp(self, self1)) |  | 74770 | if (!pyopencv_ml_StatModel_getp(self, self1))
| 74819 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)"); |  | 74771 | return failmsgp("Incorrect type of self (must be 'ml_StatModel' or its derivative)");
| 74820 | Ptr<cv::ml::StatModel> _self_ = *(self1); |  | 74772 | Ptr<cv::ml::StatModel> _self_ = *(self1);
| 74821 | pyPrepareArgumentConversionErrorsStorage(3); |  | 74773 | pyPrepareArgumentConversionErrorsStorage(3);
| 74822 |  |  | 74774 |
| 74823 | { |  | 74775 | {
| 74824 | PyObject* pyobj_trainData = NULL; |  | 74776 | PyObject* pyobj_trainData = NULL;
| 74825 | Ptr<TrainData> trainData; |  | 74777 | Ptr<TrainData> trainData;
| 74826 | PyObject* pyobj_flags = NULL; |  | 74778 | PyObject* pyobj_flags = NULL;
| 74827 | int flags=0; |  | 74779 | int flags=0;
| 74828 | bool retval; |  | 74780 | bool retval;
| 74829 |  |  | 74781 |
| 74830 | const char* keywords[] = { "trainData", "flags", NULL }; |  | 74782 | const char* keywords[] = { "trainData", "flags", NULL };
| 74831 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_StatModel.train", (char**)keywords, &pyobj_trainData, &pyobj_flags) && |  | 74783 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_StatModel.train", (char**)keywords, &pyobj_trainData, &pyobj_flags) &&
| 74832 | pyopencv_to_safe(pyobj_trainData, trainData, ArgInfo("trainData", 0)) && |  | 74784 | pyopencv_to_safe(pyobj_trainData, trainData, ArgInfo("trainData", 0)) &&
| 74833 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) ) |  | 74785 | pyopencv_to_safe(pyobj_flags, flags, ArgInfo("flags", 0)) )
| 74834 | { |  | 74786 | {
| 74835 | ERRWRAP2(retval = _self_->train(trainData, flags)); |  | 74787 | ERRWRAP2(retval = _self_->train(trainData, flags));
| 74836 | return pyopencv_from(retval); |  | 74788 | return pyopencv_from(retval);
| 74837 | } |  | 74789 | }
| 74838 |  |  | 74790 |
| 74839 |  |  | 74791 |
| 74840 | pyPopulateArgumentConversionErrors(); |  | 74792 | pyPopulateArgumentConversionErrors();
| 74841 | } |  | 74793 | }
| 74842 |  |  | 74794 |
| 74843 |  |  | 74795 |
| 74844 | { |  | 74796 | {
| 74845 | PyObject* pyobj_samples = NULL; |  | 74797 | PyObject* pyobj_samples = NULL;
| 74846 | Mat samples; |  | 74798 | Mat samples;
| 74847 | PyObject* pyobj_layout = NULL; |  | 74799 | PyObject* pyobj_layout = NULL;
| 74848 | int layout=0; |  | 74800 | int layout=0;
| 74849 | PyObject* pyobj_responses = NULL; |  | 74801 | PyObject* pyobj_responses = NULL;
| 74850 | Mat responses; |  | 74802 | Mat responses;
| 74851 | bool retval; |  | 74803 | bool retval;
| 74852 |  |  | 74804 |
| 74853 | const char* keywords[] = { "samples", "layout", "responses", NULL }; |  | 74805 | const char* keywords[] = { "samples", "layout", "responses", NULL };
| 74854 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_StatModel.train", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses) && |  | 74806 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_StatModel.train", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses) &&
| 74855 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 74807 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 74856 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) && |  | 74808 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) &&
| 74857 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) ) |  | 74809 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) )
| 74858 | { |  | 74810 | {
| 74859 | ERRWRAP2(retval = _self_->train(samples, layout, responses)); |  | 74811 | ERRWRAP2(retval = _self_->train(samples, layout, responses));
| 74860 | return pyopencv_from(retval); |  | 74812 | return pyopencv_from(retval);
| 74861 | } |  | 74813 | }
| 74862 |  |  | 74814 |
| 74863 |  |  | 74815 |
| 74864 | pyPopulateArgumentConversionErrors(); |  | 74816 | pyPopulateArgumentConversionErrors();
| 74865 | } |  | 74817 | }
| 74866 |  |  | 74818 |
| 74867 |  |  | 74819 |
| 74868 | { |  | 74820 | {
| 74869 | PyObject* pyobj_samples = NULL; |  | 74821 | PyObject* pyobj_samples = NULL;
| 74870 | UMat samples; |  | 74822 | UMat samples;
| 74871 | PyObject* pyobj_layout = NULL; |  | 74823 | PyObject* pyobj_layout = NULL;
| 74872 | int layout=0; |  | 74824 | int layout=0;
| 74873 | PyObject* pyobj_responses = NULL; |  | 74825 | PyObject* pyobj_responses = NULL;
| 74874 | UMat responses; |  | 74826 | UMat responses;
| 74875 | bool retval; |  | 74827 | bool retval;
| 74876 |  |  | 74828 |
| 74877 | const char* keywords[] = { "samples", "layout", "responses", NULL }; |  | 74829 | const char* keywords[] = { "samples", "layout", "responses", NULL };
| 74878 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_StatModel.train", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses) && |  | 74830 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_StatModel.train", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses) &&
| 74879 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 74831 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 74880 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) && |  | 74832 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) &&
| 74881 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) ) |  | 74833 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) )
| 74882 | { |  | 74834 | {
| 74883 | ERRWRAP2(retval = _self_->train(samples, layout, responses)); |  | 74835 | ERRWRAP2(retval = _self_->train(samples, layout, responses));
| 74884 | return pyopencv_from(retval); |  | 74836 | return pyopencv_from(retval);
| 74885 | } |  | 74837 | }
| 74886 |  |  | 74838 |
| 74887 |  |  | 74839 |
| 74888 | pyPopulateArgumentConversionErrors(); |  | 74840 | pyPopulateArgumentConversionErrors();
| 74889 | } |  | 74841 | }
| 74890 | pyRaiseCVOverloadException("train"); |  | 74842 | pyRaiseCVOverloadException("train");
| 74891 |  |  | 74843 |
| 74892 | return NULL; |  | 74844 | return NULL;
| 74893 | } |  | 74845 | }
| 74894 |  |  | 74846 |
| 74895 |  |  | 74847 |
| 74896 |  |  | 74848 |
| 74897 | // Tables (ml_StatModel) |  | 74849 | // Tables (ml_StatModel)
| 74898 |  |  | 74850 |
| 74899 | static PyGetSetDef pyopencv_ml_StatModel_getseters[] = |  | 74851 | static PyGetSetDef pyopencv_ml_StatModel_getseters[] =
| 74900 | { |  | 74852 | {
| 74901 | {NULL} /* Sentinel */ |  | 74853 | {NULL} /* Sentinel */
| 74902 | }; |  | 74854 | };
| 74903 |  |  | 74855 |
| 74904 | static PyMethodDef pyopencv_ml_StatModel_methods[] = |  | 74856 | static PyMethodDef pyopencv_ml_StatModel_methods[] =
| 74905 | { |  | 74857 | {
| 74906 | {"calcError", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_calcError, 0), "calcError(data, test[, resp]) -> retval, resp\n. @brief Computes error on the training or test dataset\n. \n. @param data the training data\n. @param test if true, the error is computed over the test subset of the data, otherwise it's\n. computed over the training subset of the data. Please note that if you loaded a completely\n. different dataset to evaluate already trained classifier, you will probably want not to set\n. the test subset at all with TrainData::setTrainTestSplitRatio and specify test=false, so\n. that the error is computed for the whole new set. Yes, this sounds a bit confusing.\n. @param resp the optional output responses.\n. \n. The method uses StatModel::predict to compute the error. For regression models the error is\n. computed as RMS, for classifiers - as a percent of missclassified samples (0%-100%)."}, |  | 74858 | {"calcError", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_calcError, 0), "calcError(data, test[, resp]) -> retval, resp\n. @brief Computes error on the training or test dataset\n. \n. @param data the training data\n. @param test if true, the error is computed over the test subset of the data, otherwise it's\n. computed over the training subset of the data. Please note that if you loaded a completely\n. different dataset to evaluate already trained classifier, you will probably want not to set\n. the test subset at all with TrainData::setTrainTestSplitRatio and specify test=false, so\n. that the error is computed for the whole new set. Yes, this sounds a bit confusing.\n. @param resp the optional output responses.\n. \n. The method uses StatModel::predict to compute the error. For regression models the error is\n. computed as RMS, for classifiers - as a percent of missclassified samples (0%-100%)."},
| 74907 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_empty, 0), "empty() -> retval\n."}, |  | 74859 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_empty, 0), "empty() -> retval\n."},
| 74908 | {"getVarCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_getVarCount, 0), "getVarCount() -> retval\n. @brief Returns the number of variables in training samples"}, |  | 74860 | {"getVarCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_getVarCount, 0), "getVarCount() -> retval\n. @brief Returns the number of variables in training samples"},
| 74909 | {"isClassifier", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_isClassifier, 0), "isClassifier() -> retval\n. @brief Returns true if the model is classifier"}, |  | 74861 | {"isClassifier", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_isClassifier, 0), "isClassifier() -> retval\n. @brief Returns true if the model is classifier"},
| 74910 | {"isTrained", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_isTrained, 0), "isTrained() -> retval\n. @brief Returns true if the model is trained"}, |  | 74862 | {"isTrained", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_isTrained, 0), "isTrained() -> retval\n. @brief Returns true if the model is trained"},
| 74911 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_predict, 0), "predict(samples[, results[, flags]]) -> retval, results\n. @brief Predicts response(s) for the provided sample(s)\n. \n. @param samples The input samples, floating-point matrix\n. @param results The optional output matrix of results.\n. @param flags The optional flags, model-dependent. See cv::ml::StatModel::Flags."}, |  | 74863 | {"predict", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_predict, 0), "predict(samples[, results[, flags]]) -> retval, results\n. @brief Predicts response(s) for the provided sample(s)\n. \n. @param samples The input samples, floating-point matrix\n. @param results The optional output matrix of results.\n. @param flags The optional flags, model-dependent. See cv::ml::StatModel::Flags."},
| 74912 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_train, 0), "train(trainData[, flags]) -> retval\n. @brief Trains the statistical model\n. \n. @param trainData training data that can be loaded from file using TrainData::loadFromCSV or\n. created with TrainData::create.\n. @param flags optional flags, depending on the model. Some of the models can be updated with the\n. new training samples, not completely overwritten (such as NormalBayesClassifier or ANN_MLP).\n\n\n\ntrain(samples, layout, responses) -> retval\n. @brief Trains the statistical model\n. \n. @param samples training samples\n. @param layout See ml::SampleTypes.\n. @param responses vector of responses associated with the training samples."}, |  | 74864 | {"train", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_StatModel_train, 0), "train(trainData[, flags]) -> retval\n. @brief Trains the statistical model\n. \n. @param trainData training data that can be loaded from file using TrainData::loadFromCSV or\n. created with TrainData::create.\n. @param flags optional flags, depending on the model. Some of the models can be updated with the\n. new training samples, not completely overwritten (such as NormalBayesClassifier or ANN_MLP).\n\n\n\ntrain(samples, layout, responses) -> retval\n. @brief Trains the statistical model\n. \n. @param samples training samples\n. @param layout See ml::SampleTypes.\n. @param responses vector of responses associated with the training samples."},
| 74913 |  |  | 74865 |
| 74914 | {NULL, NULL} |  | 74866 | {NULL, NULL}
| 74915 | }; |  | 74867 | };
| 74916 |  |  | 74868 |
| 74917 | // Converter (ml_StatModel) |  | 74869 | // Converter (ml_StatModel)
| 74918 |  |  | 74870 |
| 74919 | template<> |  | 74871 | template<>
| 74920 | struct PyOpenCV_Converter< Ptr<cv::ml::StatModel> > |  | 74872 | struct PyOpenCV_Converter< Ptr<cv::ml::StatModel> >
| 74921 | { |  | 74873 | {
| 74922 | static PyObject* from(const Ptr<cv::ml::StatModel>& r) |  | 74874 | static PyObject* from(const Ptr<cv::ml::StatModel>& r)
| 74923 | { |  | 74875 | {
| 74924 | return pyopencv_ml_StatModel_Instance(r); |  | 74876 | return pyopencv_ml_StatModel_Instance(r);
| 74925 | } |  | 74877 | }
| 74926 | static bool to(PyObject* src, Ptr<cv::ml::StatModel>& dst, const ArgInfo& info) |  | 74878 | static bool to(PyObject* src, Ptr<cv::ml::StatModel>& dst, const ArgInfo& info)
| 74927 | { |  | 74879 | {
| 74928 | if(!src || src == Py_None) |  | 74880 | if(!src || src == Py_None)
| 74929 | return true; |  | 74881 | return true;
| 74930 | Ptr<cv::ml::StatModel> * dst_; |  | 74882 | Ptr<cv::ml::StatModel> * dst_;
| 74931 | if (pyopencv_ml_StatModel_getp(src, dst_)) |  | 74883 | if (pyopencv_ml_StatModel_getp(src, dst_))
| 74932 | { |  | 74884 | {
| 74933 | dst = *dst_; |  | 74885 | dst = *dst_;
| 74934 | return true; |  | 74886 | return true;
| 74935 | } |  | 74887 | }
| 74936 |  |  | 74888 |
| 74937 | failmsg("Expected Ptr<cv::ml::StatModel> for argument '%s'", info.name); |  | 74889 | failmsg("Expected Ptr<cv::ml::StatModel> for argument '%s'", info.name);
| 74938 | return false; |  | 74890 | return false;
| 74939 | } |  | 74891 | }
| 74940 | }; |  | 74892 | };
| 74941 |  |  | 74893 |
| 74942 | //================================================================================ |  | 74894 | //================================================================================
| 74943 | // ml_TrainData (Generic) |  | 74895 | // ml_TrainData (Generic)
| 74944 | //================================================================================ |  | 74896 | //================================================================================
| 74945 |  |  | 74897 |
| 74946 | // GetSet (ml_TrainData) |  | 74898 | // GetSet (ml_TrainData)
| 74947 |  |  | 74899 |
| 74948 |  |  | 74900 |
| 74949 |  |  | 74901 |
| 74950 | // Methods (ml_TrainData) |  | 74902 | // Methods (ml_TrainData)
| 74951 |  |  | 74903 |
| 74952 | static PyObject* pyopencv_cv_ml_ml_TrainData_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74904 | static PyObject* pyopencv_cv_ml_ml_TrainData_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 74953 | { |  | 74905 | {
| 74954 | using namespace cv::ml; |  | 74906 | using namespace cv::ml;
| 74955 |  |  | 74907 |
| 74956 | pyPrepareArgumentConversionErrorsStorage(2); |  | 74908 | pyPrepareArgumentConversionErrorsStorage(2);
| 74957 |  |  | 74909 |
| 74958 | { |  | 74910 | {
| 74959 | PyObject* pyobj_samples = NULL; |  | 74911 | PyObject* pyobj_samples = NULL;
| 74960 | Mat samples; |  | 74912 | Mat samples;
| 74961 | PyObject* pyobj_layout = NULL; |  | 74913 | PyObject* pyobj_layout = NULL;
| 74962 | int layout=0; |  | 74914 | int layout=0;
| 74963 | PyObject* pyobj_responses = NULL; |  | 74915 | PyObject* pyobj_responses = NULL;
| 74964 | Mat responses; |  | 74916 | Mat responses;
| 74965 | PyObject* pyobj_varIdx = NULL; |  | 74917 | PyObject* pyobj_varIdx = NULL;
| 74966 | Mat varIdx; |  | 74918 | Mat varIdx;
| 74967 | PyObject* pyobj_sampleIdx = NULL; |  | 74919 | PyObject* pyobj_sampleIdx = NULL;
| 74968 | Mat sampleIdx; |  | 74920 | Mat sampleIdx;
| 74969 | PyObject* pyobj_sampleWeights = NULL; |  | 74921 | PyObject* pyobj_sampleWeights = NULL;
| 74970 | Mat sampleWeights; |  | 74922 | Mat sampleWeights;
| 74971 | PyObject* pyobj_varType = NULL; |  | 74923 | PyObject* pyobj_varType = NULL;
| 74972 | Mat varType; |  | 74924 | Mat varType;
| 74973 | Ptr<TrainData> retval; |  | 74925 | Ptr<TrainData> retval;
| 74974 |  |  | 74926 |
| 74975 | const char* keywords[] = { "samples", "layout", "responses", "varIdx", "sampleIdx", "sampleWeights", "varType", NULL }; |  | 74927 | const char* keywords[] = { "samples", "layout", "responses", "varIdx", "sampleIdx", "sampleWeights", "varType", NULL };
| 74976 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOO:ml_TrainData.create", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_varIdx, &pyobj_sampleIdx, &pyobj_sampleWeights, &pyobj_varType) && |  | 74928 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOO:ml_TrainData.create", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_varIdx, &pyobj_sampleIdx, &pyobj_sampleWeights, &pyobj_varType) &&
| 74977 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 74929 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 74978 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) && |  | 74930 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) &&
| 74979 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) && |  | 74931 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) &&
| 74980 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) && |  | 74932 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) &&
| 74981 | pyopencv_to_safe(pyobj_sampleIdx, sampleIdx, ArgInfo("sampleIdx", 0)) && |  | 74933 | pyopencv_to_safe(pyobj_sampleIdx, sampleIdx, ArgInfo("sampleIdx", 0)) &&
| 74982 | pyopencv_to_safe(pyobj_sampleWeights, sampleWeights, ArgInfo("sampleWeights", 0)) && |  | 74934 | pyopencv_to_safe(pyobj_sampleWeights, sampleWeights, ArgInfo("sampleWeights", 0)) &&
| 74983 | pyopencv_to_safe(pyobj_varType, varType, ArgInfo("varType", 0)) ) |  | 74935 | pyopencv_to_safe(pyobj_varType, varType, ArgInfo("varType", 0)) )
| 74984 | { |  | 74936 | {
| 74985 | ERRWRAP2(retval = cv::ml::TrainData::create(samples, layout, responses, varIdx, sampleIdx, sampleWeights, varType)); |  | 74937 | ERRWRAP2(retval = cv::ml::TrainData::create(samples, layout, responses, varIdx, sampleIdx, sampleWeights, varType));
| 74986 | return pyopencv_from(retval); |  | 74938 | return pyopencv_from(retval);
| 74987 | } |  | 74939 | }
| 74988 |  |  | 74940 |
| 74989 |  |  | 74941 |
| 74990 | pyPopulateArgumentConversionErrors(); |  | 74942 | pyPopulateArgumentConversionErrors();
| 74991 | } |  | 74943 | }
| 74992 |  |  | 74944 |
| 74993 |  |  | 74945 |
| 74994 | { |  | 74946 | {
| 74995 | PyObject* pyobj_samples = NULL; |  | 74947 | PyObject* pyobj_samples = NULL;
| 74996 | UMat samples; |  | 74948 | UMat samples;
| 74997 | PyObject* pyobj_layout = NULL; |  | 74949 | PyObject* pyobj_layout = NULL;
| 74998 | int layout=0; |  | 74950 | int layout=0;
| 74999 | PyObject* pyobj_responses = NULL; |  | 74951 | PyObject* pyobj_responses = NULL;
| 75000 | UMat responses; |  | 74952 | UMat responses;
| 75001 | PyObject* pyobj_varIdx = NULL; |  | 74953 | PyObject* pyobj_varIdx = NULL;
| 75002 | UMat varIdx; |  | 74954 | UMat varIdx;
| 75003 | PyObject* pyobj_sampleIdx = NULL; |  | 74955 | PyObject* pyobj_sampleIdx = NULL;
| 75004 | UMat sampleIdx; |  | 74956 | UMat sampleIdx;
| 75005 | PyObject* pyobj_sampleWeights = NULL; |  | 74957 | PyObject* pyobj_sampleWeights = NULL;
| 75006 | UMat sampleWeights; |  | 74958 | UMat sampleWeights;
| 75007 | PyObject* pyobj_varType = NULL; |  | 74959 | PyObject* pyobj_varType = NULL;
| 75008 | UMat varType; |  | 74960 | UMat varType;
| 75009 | Ptr<TrainData> retval; |  | 74961 | Ptr<TrainData> retval;
| 75010 |  |  | 74962 |
| 75011 | const char* keywords[] = { "samples", "layout", "responses", "varIdx", "sampleIdx", "sampleWeights", "varType", NULL }; |  | 74963 | const char* keywords[] = { "samples", "layout", "responses", "varIdx", "sampleIdx", "sampleWeights", "varType", NULL };
| 75012 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOO:ml_TrainData.create", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_varIdx, &pyobj_sampleIdx, &pyobj_sampleWeights, &pyobj_varType) && |  | 74964 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|OOOO:ml_TrainData.create", (char**)keywords, &pyobj_samples, &pyobj_layout, &pyobj_responses, &pyobj_varIdx, &pyobj_sampleIdx, &pyobj_sampleWeights, &pyobj_varType) &&
| 75013 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) && |  | 74965 | pyopencv_to_safe(pyobj_samples, samples, ArgInfo("samples", 0)) &&
| 75014 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) && |  | 74966 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) &&
| 75015 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) && |  | 74967 | pyopencv_to_safe(pyobj_responses, responses, ArgInfo("responses", 0)) &&
| 75016 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) && |  | 74968 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) &&
| 75017 | pyopencv_to_safe(pyobj_sampleIdx, sampleIdx, ArgInfo("sampleIdx", 0)) && |  | 74969 | pyopencv_to_safe(pyobj_sampleIdx, sampleIdx, ArgInfo("sampleIdx", 0)) &&
| 75018 | pyopencv_to_safe(pyobj_sampleWeights, sampleWeights, ArgInfo("sampleWeights", 0)) && |  | 74970 | pyopencv_to_safe(pyobj_sampleWeights, sampleWeights, ArgInfo("sampleWeights", 0)) &&
| 75019 | pyopencv_to_safe(pyobj_varType, varType, ArgInfo("varType", 0)) ) |  | 74971 | pyopencv_to_safe(pyobj_varType, varType, ArgInfo("varType", 0)) )
| 75020 | { |  | 74972 | {
| 75021 | ERRWRAP2(retval = cv::ml::TrainData::create(samples, layout, responses, varIdx, sampleIdx, sampleWeights, varType)); |  | 74973 | ERRWRAP2(retval = cv::ml::TrainData::create(samples, layout, responses, varIdx, sampleIdx, sampleWeights, varType));
| 75022 | return pyopencv_from(retval); |  | 74974 | return pyopencv_from(retval);
| 75023 | } |  | 74975 | }
| 75024 |  |  | 74976 |
| 75025 |  |  | 74977 |
| 75026 | pyPopulateArgumentConversionErrors(); |  | 74978 | pyPopulateArgumentConversionErrors();
| 75027 | } |  | 74979 | }
| 75028 | pyRaiseCVOverloadException("create"); |  | 74980 | pyRaiseCVOverloadException("create");
| 75029 |  |  | 74981 |
| 75030 | return NULL; |  | 74982 | return NULL;
| 75031 | } |  | 74983 | }
| 75032 |  |  | 74984 |
| 75033 | static PyObject* pyopencv_cv_ml_ml_TrainData_getCatCount(PyObject* self, PyObject* py_args, PyObject* kw) |  | 74985 | static PyObject* pyopencv_cv_ml_ml_TrainData_getCatCount(PyObject* self, PyObject* py_args, PyObject* kw)
| 75034 | { |  | 74986 | {
| 75035 | using namespace cv::ml; |  | 74987 | using namespace cv::ml;
| 75036 |  |  | 74988 |
| 75037 |  |  | 74989 |
| 75038 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 74990 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75039 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 74991 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75040 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 74992 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75041 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 74993 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75042 | PyObject* pyobj_vi = NULL; |  | 74994 | PyObject* pyobj_vi = NULL;
| 75043 | int vi=0; |  | 74995 | int vi=0;
| 75044 | int retval; |  | 74996 | int retval;
| 75045 |  |  | 74997 |
| 75046 | const char* keywords[] = { "vi", NULL }; |  | 74998 | const char* keywords[] = { "vi", NULL };
| 75047 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_TrainData.getCatCount", (char**)keywords, &pyobj_vi) && |  | 74999 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_TrainData.getCatCount", (char**)keywords, &pyobj_vi) &&
| 75048 | pyopencv_to_safe(pyobj_vi, vi, ArgInfo("vi", 0)) ) |  | 75000 | pyopencv_to_safe(pyobj_vi, vi, ArgInfo("vi", 0)) )
| 75049 | { |  | 75001 | {
| 75050 | ERRWRAP2(retval = _self_->getCatCount(vi)); |  | 75002 | ERRWRAP2(retval = _self_->getCatCount(vi));
| 75051 | return pyopencv_from(retval); |  | 75003 | return pyopencv_from(retval);
| 75052 | } |  | 75004 | }
| 75053 |  |  | 75005 |
| 75054 | return NULL; |  | 75006 | return NULL;
| 75055 | } |  | 75007 | }
| 75056 |  |  | 75008 |
| 75057 | static PyObject* pyopencv_cv_ml_ml_TrainData_getCatMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75009 | static PyObject* pyopencv_cv_ml_ml_TrainData_getCatMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 75058 | { |  | 75010 | {
| 75059 | using namespace cv::ml; |  | 75011 | using namespace cv::ml;
| 75060 |  |  | 75012 |
| 75061 |  |  | 75013 |
| 75062 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75014 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75063 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75015 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75064 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75016 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75065 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75017 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75066 | Mat retval; |  | 75018 | Mat retval;
| 75067 |  |  | 75019 |
| 75068 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75020 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75069 | { |  | 75021 | {
| 75070 | ERRWRAP2(retval = _self_->getCatMap()); |  | 75022 | ERRWRAP2(retval = _self_->getCatMap());
| 75071 | return pyopencv_from(retval); |  | 75023 | return pyopencv_from(retval);
| 75072 | } |  | 75024 | }
| 75073 |  |  | 75025 |
| 75074 | return NULL; |  | 75026 | return NULL;
| 75075 | } |  | 75027 | }
| 75076 |  |  | 75028 |
| 75077 | static PyObject* pyopencv_cv_ml_ml_TrainData_getCatOfs(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75029 | static PyObject* pyopencv_cv_ml_ml_TrainData_getCatOfs(PyObject* self, PyObject* py_args, PyObject* kw)
| 75078 | { |  | 75030 | {
| 75079 | using namespace cv::ml; |  | 75031 | using namespace cv::ml;
| 75080 |  |  | 75032 |
| 75081 |  |  | 75033 |
| 75082 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75034 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75083 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75035 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75084 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75036 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75085 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75037 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75086 | Mat retval; |  | 75038 | Mat retval;
| 75087 |  |  | 75039 |
| 75088 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75040 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75089 | { |  | 75041 | {
| 75090 | ERRWRAP2(retval = _self_->getCatOfs()); |  | 75042 | ERRWRAP2(retval = _self_->getCatOfs());
| 75091 | return pyopencv_from(retval); |  | 75043 | return pyopencv_from(retval);
| 75092 | } |  | 75044 | }
| 75093 |  |  | 75045 |
| 75094 | return NULL; |  | 75046 | return NULL;
| 75095 | } |  | 75047 | }
| 75096 |  |  | 75048 |
| 75097 | static PyObject* pyopencv_cv_ml_ml_TrainData_getClassLabels(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75049 | static PyObject* pyopencv_cv_ml_ml_TrainData_getClassLabels(PyObject* self, PyObject* py_args, PyObject* kw)
| 75098 | { |  | 75050 | {
| 75099 | using namespace cv::ml; |  | 75051 | using namespace cv::ml;
| 75100 |  |  | 75052 |
| 75101 |  |  | 75053 |
| 75102 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75054 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75103 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75055 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75104 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75056 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75105 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75057 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75106 | Mat retval; |  | 75058 | Mat retval;
| 75107 |  |  | 75059 |
| 75108 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75060 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75109 | { |  | 75061 | {
| 75110 | ERRWRAP2(retval = _self_->getClassLabels()); |  | 75062 | ERRWRAP2(retval = _self_->getClassLabels());
| 75111 | return pyopencv_from(retval); |  | 75063 | return pyopencv_from(retval);
| 75112 | } |  | 75064 | }
| 75113 |  |  | 75065 |
| 75114 | return NULL; |  | 75066 | return NULL;
| 75115 | } |  | 75067 | }
| 75116 |  |  | 75068 |
| 75117 | static PyObject* pyopencv_cv_ml_ml_TrainData_getDefaultSubstValues(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75069 | static PyObject* pyopencv_cv_ml_ml_TrainData_getDefaultSubstValues(PyObject* self, PyObject* py_args, PyObject* kw)
| 75118 | { |  | 75070 | {
| 75119 | using namespace cv::ml; |  | 75071 | using namespace cv::ml;
| 75120 |  |  | 75072 |
| 75121 |  |  | 75073 |
| 75122 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75074 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75123 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75075 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75124 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75076 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75125 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75077 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75126 | Mat retval; |  | 75078 | Mat retval;
| 75127 |  |  | 75079 |
| 75128 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75080 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75129 | { |  | 75081 | {
| 75130 | ERRWRAP2(retval = _self_->getDefaultSubstValues()); |  | 75082 | ERRWRAP2(retval = _self_->getDefaultSubstValues());
| 75131 | return pyopencv_from(retval); |  | 75083 | return pyopencv_from(retval);
| 75132 | } |  | 75084 | }
| 75133 |  |  | 75085 |
| 75134 | return NULL; |  | 75086 | return NULL;
| 75135 | } |  | 75087 | }
| 75136 |  |  | 75088 |
| 75137 | static PyObject* pyopencv_cv_ml_ml_TrainData_getLayout(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75089 | static PyObject* pyopencv_cv_ml_ml_TrainData_getLayout(PyObject* self, PyObject* py_args, PyObject* kw)
| 75138 | { |  | 75090 | {
| 75139 | using namespace cv::ml; |  | 75091 | using namespace cv::ml;
| 75140 |  |  | 75092 |
| 75141 |  |  | 75093 |
| 75142 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75094 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75143 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75095 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75144 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75096 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75145 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75097 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75146 | int retval; |  | 75098 | int retval;
| 75147 |  |  | 75099 |
| 75148 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75100 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75149 | { |  | 75101 | {
| 75150 | ERRWRAP2(retval = _self_->getLayout()); |  | 75102 | ERRWRAP2(retval = _self_->getLayout());
| 75151 | return pyopencv_from(retval); |  | 75103 | return pyopencv_from(retval);
| 75152 | } |  | 75104 | }
| 75153 |  |  | 75105 |
| 75154 | return NULL; |  | 75106 | return NULL;
| 75155 | } |  | 75107 | }
| 75156 |  |  | 75108 |
| 75157 | static PyObject* pyopencv_cv_ml_ml_TrainData_getMissing(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75109 | static PyObject* pyopencv_cv_ml_ml_TrainData_getMissing(PyObject* self, PyObject* py_args, PyObject* kw)
| 75158 | { |  | 75110 | {
| 75159 | using namespace cv::ml; |  | 75111 | using namespace cv::ml;
| 75160 |  |  | 75112 |
| 75161 |  |  | 75113 |
| 75162 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75114 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75163 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75115 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75164 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75116 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75165 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75117 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75166 | Mat retval; |  | 75118 | Mat retval;
| 75167 |  |  | 75119 |
| 75168 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75120 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75169 | { |  | 75121 | {
| 75170 | ERRWRAP2(retval = _self_->getMissing()); |  | 75122 | ERRWRAP2(retval = _self_->getMissing());
| 75171 | return pyopencv_from(retval); |  | 75123 | return pyopencv_from(retval);
| 75172 | } |  | 75124 | }
| 75173 |  |  | 75125 |
| 75174 | return NULL; |  | 75126 | return NULL;
| 75175 | } |  | 75127 | }
| 75176 |  |  | 75128 |
| 75177 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNAllVars(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75129 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNAllVars(PyObject* self, PyObject* py_args, PyObject* kw)
| 75178 | { |  | 75130 | {
| 75179 | using namespace cv::ml; |  | 75131 | using namespace cv::ml;
| 75180 |  |  | 75132 |
| 75181 |  |  | 75133 |
| 75182 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75134 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75183 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75135 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75184 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75136 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75185 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75137 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75186 | int retval; |  | 75138 | int retval;
| 75187 |  |  | 75139 |
| 75188 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75140 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75189 | { |  | 75141 | {
| 75190 | ERRWRAP2(retval = _self_->getNAllVars()); |  | 75142 | ERRWRAP2(retval = _self_->getNAllVars());
| 75191 | return pyopencv_from(retval); |  | 75143 | return pyopencv_from(retval);
| 75192 | } |  | 75144 | }
| 75193 |  |  | 75145 |
| 75194 | return NULL; |  | 75146 | return NULL;
| 75195 | } |  | 75147 | }
| 75196 |  |  | 75148 |
| 75197 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75149 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 75198 | { |  | 75150 | {
| 75199 | using namespace cv::ml; |  | 75151 | using namespace cv::ml;
| 75200 |  |  | 75152 |
| 75201 |  |  | 75153 |
| 75202 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75154 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75203 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75155 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75204 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75156 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75205 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75157 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75206 | int retval; |  | 75158 | int retval;
| 75207 |  |  | 75159 |
| 75208 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75160 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75209 | { |  | 75161 | {
| 75210 | ERRWRAP2(retval = _self_->getNSamples()); |  | 75162 | ERRWRAP2(retval = _self_->getNSamples());
| 75211 | return pyopencv_from(retval); |  | 75163 | return pyopencv_from(retval);
| 75212 | } |  | 75164 | }
| 75213 |  |  | 75165 |
| 75214 | return NULL; |  | 75166 | return NULL;
| 75215 | } |  | 75167 | }
| 75216 |  |  | 75168 |
| 75217 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNTestSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75169 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNTestSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 75218 | { |  | 75170 | {
| 75219 | using namespace cv::ml; |  | 75171 | using namespace cv::ml;
| 75220 |  |  | 75172 |
| 75221 |  |  | 75173 |
| 75222 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75174 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75223 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75175 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75224 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75176 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75225 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75177 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75226 | int retval; |  | 75178 | int retval;
| 75227 |  |  | 75179 |
| 75228 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75180 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75229 | { |  | 75181 | {
| 75230 | ERRWRAP2(retval = _self_->getNTestSamples()); |  | 75182 | ERRWRAP2(retval = _self_->getNTestSamples());
| 75231 | return pyopencv_from(retval); |  | 75183 | return pyopencv_from(retval);
| 75232 | } |  | 75184 | }
| 75233 |  |  | 75185 |
| 75234 | return NULL; |  | 75186 | return NULL;
| 75235 | } |  | 75187 | }
| 75236 |  |  | 75188 |
| 75237 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNTrainSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75189 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNTrainSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 75238 | { |  | 75190 | {
| 75239 | using namespace cv::ml; |  | 75191 | using namespace cv::ml;
| 75240 |  |  | 75192 |
| 75241 |  |  | 75193 |
| 75242 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75194 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75243 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75195 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75244 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75196 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75245 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75197 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75246 | int retval; |  | 75198 | int retval;
| 75247 |  |  | 75199 |
| 75248 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75200 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75249 | { |  | 75201 | {
| 75250 | ERRWRAP2(retval = _self_->getNTrainSamples()); |  | 75202 | ERRWRAP2(retval = _self_->getNTrainSamples());
| 75251 | return pyopencv_from(retval); |  | 75203 | return pyopencv_from(retval);
| 75252 | } |  | 75204 | }
| 75253 |  |  | 75205 |
| 75254 | return NULL; |  | 75206 | return NULL;
| 75255 | } |  | 75207 | }
| 75256 |  |  | 75208 |
| 75257 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNVars(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75209 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNVars(PyObject* self, PyObject* py_args, PyObject* kw)
| 75258 | { |  | 75210 | {
| 75259 | using namespace cv::ml; |  | 75211 | using namespace cv::ml;
| 75260 |  |  | 75212 |
| 75261 |  |  | 75213 |
| 75262 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75214 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75263 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75215 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75264 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75216 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75265 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75217 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75266 | int retval; |  | 75218 | int retval;
| 75267 |  |  | 75219 |
| 75268 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75220 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75269 | { |  | 75221 | {
| 75270 | ERRWRAP2(retval = _self_->getNVars()); |  | 75222 | ERRWRAP2(retval = _self_->getNVars());
| 75271 | return pyopencv_from(retval); |  | 75223 | return pyopencv_from(retval);
| 75272 | } |  | 75224 | }
| 75273 |  |  | 75225 |
| 75274 | return NULL; |  | 75226 | return NULL;
| 75275 | } |  | 75227 | }
| 75276 |  |  | 75228 |
| 75277 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNames(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75229 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNames(PyObject* self, PyObject* py_args, PyObject* kw)
| 75278 | { |  | 75230 | {
| 75279 | using namespace cv::ml; |  | 75231 | using namespace cv::ml;
| 75280 |  |  | 75232 |
| 75281 |  |  | 75233 |
| 75282 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75234 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75283 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75235 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75284 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75236 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75285 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75237 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75286 | PyObject* pyobj_names = NULL; |  | 75238 | PyObject* pyobj_names = NULL;
| 75287 | vector_String names; |  | 75239 | vector_String names;
| 75288 |  |  | 75240 |
| 75289 | const char* keywords[] = { "names", NULL }; |  | 75241 | const char* keywords[] = { "names", NULL };
| 75290 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_TrainData.getNames", (char**)keywords, &pyobj_names) && |  | 75242 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ml_TrainData.getNames", (char**)keywords, &pyobj_names) &&
| 75291 | pyopencv_to_safe(pyobj_names, names, ArgInfo("names", 0)) ) |  | 75243 | pyopencv_to_safe(pyobj_names, names, ArgInfo("names", 0)) )
| 75292 | { |  | 75244 | {
| 75293 | ERRWRAP2(_self_->getNames(names)); |  | 75245 | ERRWRAP2(_self_->getNames(names));
| 75294 | Py_RETURN_NONE; |  | 75246 | Py_RETURN_NONE;
| 75295 | } |  | 75247 | }
| 75296 |  |  | 75248 |
| 75297 | return NULL; |  | 75249 | return NULL;
| 75298 | } |  | 75250 | }
| 75299 |  |  | 75251 |
| 75300 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNormCatResponses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75252 | static PyObject* pyopencv_cv_ml_ml_TrainData_getNormCatResponses(PyObject* self, PyObject* py_args, PyObject* kw)
| 75301 | { |  | 75253 | {
| 75302 | using namespace cv::ml; |  | 75254 | using namespace cv::ml;
| 75303 |  |  | 75255 |
| 75304 |  |  | 75256 |
| 75305 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75257 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75306 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75258 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75307 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75259 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75308 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75260 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75309 | Mat retval; |  | 75261 | Mat retval;
| 75310 |  |  | 75262 |
| 75311 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75263 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75312 | { |  | 75264 | {
| 75313 | ERRWRAP2(retval = _self_->getNormCatResponses()); |  | 75265 | ERRWRAP2(retval = _self_->getNormCatResponses());
| 75314 | return pyopencv_from(retval); |  | 75266 | return pyopencv_from(retval);
| 75315 | } |  | 75267 | }
| 75316 |  |  | 75268 |
| 75317 | return NULL; |  | 75269 | return NULL;
| 75318 | } |  | 75270 | }
| 75319 |  |  | 75271 |
| 75320 | static PyObject* pyopencv_cv_ml_ml_TrainData_getResponseType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75272 | static PyObject* pyopencv_cv_ml_ml_TrainData_getResponseType(PyObject* self, PyObject* py_args, PyObject* kw)
| 75321 | { |  | 75273 | {
| 75322 | using namespace cv::ml; |  | 75274 | using namespace cv::ml;
| 75323 |  |  | 75275 |
| 75324 |  |  | 75276 |
| 75325 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75277 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75326 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75278 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75327 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75279 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75328 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75280 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75329 | int retval; |  | 75281 | int retval;
| 75330 |  |  | 75282 |
| 75331 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75283 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75332 | { |  | 75284 | {
| 75333 | ERRWRAP2(retval = _self_->getResponseType()); |  | 75285 | ERRWRAP2(retval = _self_->getResponseType());
| 75334 | return pyopencv_from(retval); |  | 75286 | return pyopencv_from(retval);
| 75335 | } |  | 75287 | }
| 75336 |  |  | 75288 |
| 75337 | return NULL; |  | 75289 | return NULL;
| 75338 | } |  | 75290 | }
| 75339 |  |  | 75291 |
| 75340 | static PyObject* pyopencv_cv_ml_ml_TrainData_getResponses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75292 | static PyObject* pyopencv_cv_ml_ml_TrainData_getResponses(PyObject* self, PyObject* py_args, PyObject* kw)
| 75341 | { |  | 75293 | {
| 75342 | using namespace cv::ml; |  | 75294 | using namespace cv::ml;
| 75343 |  |  | 75295 |
| 75344 |  |  | 75296 |
| 75345 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75297 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75346 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75298 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75347 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75299 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75348 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75300 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75349 | Mat retval; |  | 75301 | Mat retval;
| 75350 |  |  | 75302 |
| 75351 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75303 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75352 | { |  | 75304 | {
| 75353 | ERRWRAP2(retval = _self_->getResponses()); |  | 75305 | ERRWRAP2(retval = _self_->getResponses());
| 75354 | return pyopencv_from(retval); |  | 75306 | return pyopencv_from(retval);
| 75355 | } |  | 75307 | }
| 75356 |  |  | 75308 |
| 75357 | return NULL; |  | 75309 | return NULL;
| 75358 | } |  | 75310 | }
| 75359 |  |  | 75311 |
| 75360 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSample(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75312 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSample(PyObject* self, PyObject* py_args, PyObject* kw)
| 75361 | { |  | 75313 | {
| 75362 | using namespace cv::ml; |  | 75314 | using namespace cv::ml;
| 75363 |  |  | 75315 |
| 75364 |  |  | 75316 |
| 75365 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75317 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75366 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75318 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75367 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75319 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75368 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75320 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75369 | pyPrepareArgumentConversionErrorsStorage(2); |  | 75321 | pyPrepareArgumentConversionErrorsStorage(2);
| 75370 |  |  | 75322 |
| 75371 | { |  | 75323 | {
| 75372 | PyObject* pyobj_varIdx = NULL; |  | 75324 | PyObject* pyobj_varIdx = NULL;
| 75373 | Mat varIdx; |  | 75325 | Mat varIdx;
| 75374 | PyObject* pyobj_sidx = NULL; |  | 75326 | PyObject* pyobj_sidx = NULL;
| 75375 | int sidx=0; |  | 75327 | int sidx=0;
| 75376 | PyObject* pyobj_buf = NULL; |  | 75328 | PyObject* pyobj_buf = NULL;
| 75377 | float buf=0.f; |  | 75329 | float buf=0.f;
| 75378 |  |  | 75330 |
| 75379 | const char* keywords[] = { "varIdx", "sidx", "buf", NULL }; |  | 75331 | const char* keywords[] = { "varIdx", "sidx", "buf", NULL };
| 75380 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getSample", (char**)keywords, &pyobj_varIdx, &pyobj_sidx, &pyobj_buf) && |  | 75332 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getSample", (char**)keywords, &pyobj_varIdx, &pyobj_sidx, &pyobj_buf) &&
| 75381 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) && |  | 75333 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) &&
| 75382 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) && |  | 75334 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) &&
| 75383 | pyopencv_to_safe(pyobj_buf, buf, ArgInfo("buf", 0)) ) |  | 75335 | pyopencv_to_safe(pyobj_buf, buf, ArgInfo("buf", 0)) )
| 75384 | { |  | 75336 | {
| 75385 | ERRWRAP2(_self_->getSample(varIdx, sidx, &buf)); |  | 75337 | ERRWRAP2(_self_->getSample(varIdx, sidx, &buf));
| 75386 | Py_RETURN_NONE; |  | 75338 | Py_RETURN_NONE;
| 75387 | } |  | 75339 | }
| 75388 |  |  | 75340 |
| 75389 |  |  | 75341 |
| 75390 | pyPopulateArgumentConversionErrors(); |  | 75342 | pyPopulateArgumentConversionErrors();
| 75391 | } |  | 75343 | }
| 75392 |  |  | 75344 |
| 75393 |  |  | 75345 |
| 75394 | { |  | 75346 | {
| 75395 | PyObject* pyobj_varIdx = NULL; |  | 75347 | PyObject* pyobj_varIdx = NULL;
| 75396 | UMat varIdx; |  | 75348 | UMat varIdx;
| 75397 | PyObject* pyobj_sidx = NULL; |  | 75349 | PyObject* pyobj_sidx = NULL;
| 75398 | int sidx=0; |  | 75350 | int sidx=0;
| 75399 | PyObject* pyobj_buf = NULL; |  | 75351 | PyObject* pyobj_buf = NULL;
| 75400 | float buf=0.f; |  | 75352 | float buf=0.f;
| 75401 |  |  | 75353 |
| 75402 | const char* keywords[] = { "varIdx", "sidx", "buf", NULL }; |  | 75354 | const char* keywords[] = { "varIdx", "sidx", "buf", NULL };
| 75403 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getSample", (char**)keywords, &pyobj_varIdx, &pyobj_sidx, &pyobj_buf) && |  | 75355 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getSample", (char**)keywords, &pyobj_varIdx, &pyobj_sidx, &pyobj_buf) &&
| 75404 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) && |  | 75356 | pyopencv_to_safe(pyobj_varIdx, varIdx, ArgInfo("varIdx", 0)) &&
| 75405 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) && |  | 75357 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) &&
| 75406 | pyopencv_to_safe(pyobj_buf, buf, ArgInfo("buf", 0)) ) |  | 75358 | pyopencv_to_safe(pyobj_buf, buf, ArgInfo("buf", 0)) )
| 75407 | { |  | 75359 | {
| 75408 | ERRWRAP2(_self_->getSample(varIdx, sidx, &buf)); |  | 75360 | ERRWRAP2(_self_->getSample(varIdx, sidx, &buf));
| 75409 | Py_RETURN_NONE; |  | 75361 | Py_RETURN_NONE;
| 75410 | } |  | 75362 | }
| 75411 |  |  | 75363 |
| 75412 |  |  | 75364 |
| 75413 | pyPopulateArgumentConversionErrors(); |  | 75365 | pyPopulateArgumentConversionErrors();
| 75414 | } |  | 75366 | }
| 75415 | pyRaiseCVOverloadException("getSample"); |  | 75367 | pyRaiseCVOverloadException("getSample");
| 75416 |  |  | 75368 |
| 75417 | return NULL; |  | 75369 | return NULL;
| 75418 | } |  | 75370 | }
| 75419 |  |  | 75371 |
| 75420 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSampleWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75372 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSampleWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 75421 | { |  | 75373 | {
| 75422 | using namespace cv::ml; |  | 75374 | using namespace cv::ml;
| 75423 |  |  | 75375 |
| 75424 |  |  | 75376 |
| 75425 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75377 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75426 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75378 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75427 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75379 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75428 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75380 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75429 | Mat retval; |  | 75381 | Mat retval;
| 75430 |  |  | 75382 |
| 75431 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75383 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75432 | { |  | 75384 | {
| 75433 | ERRWRAP2(retval = _self_->getSampleWeights()); |  | 75385 | ERRWRAP2(retval = _self_->getSampleWeights());
| 75434 | return pyopencv_from(retval); |  | 75386 | return pyopencv_from(retval);
| 75435 | } |  | 75387 | }
| 75436 |  |  | 75388 |
| 75437 | return NULL; |  | 75389 | return NULL;
| 75438 | } |  | 75390 | }
| 75439 |  |  | 75391 |
| 75440 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75392 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 75441 | { |  | 75393 | {
| 75442 | using namespace cv::ml; |  | 75394 | using namespace cv::ml;
| 75443 |  |  | 75395 |
| 75444 |  |  | 75396 |
| 75445 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75397 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75446 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75398 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75447 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75399 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75448 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75400 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75449 | Mat retval; |  | 75401 | Mat retval;
| 75450 |  |  | 75402 |
| 75451 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75403 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75452 | { |  | 75404 | {
| 75453 | ERRWRAP2(retval = _self_->getSamples()); |  | 75405 | ERRWRAP2(retval = _self_->getSamples());
| 75454 | return pyopencv_from(retval); |  | 75406 | return pyopencv_from(retval);
| 75455 | } |  | 75407 | }
| 75456 |  |  | 75408 |
| 75457 | return NULL; |  | 75409 | return NULL;
| 75458 | } |  | 75410 | }
| 75459 |  |  | 75411 |
| 75460 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSubMatrix_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75412 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSubMatrix_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 75461 | { |  | 75413 | {
| 75462 | using namespace cv::ml; |  | 75414 | using namespace cv::ml;
| 75463 |  |  | 75415 |
| 75464 | PyObject* pyobj_matrix = NULL; |  | 75416 | PyObject* pyobj_matrix = NULL;
| 75465 | Mat matrix; |  | 75417 | Mat matrix;
| 75466 | PyObject* pyobj_idx = NULL; |  | 75418 | PyObject* pyobj_idx = NULL;
| 75467 | Mat idx; |  | 75419 | Mat idx;
| 75468 | PyObject* pyobj_layout = NULL; |  | 75420 | PyObject* pyobj_layout = NULL;
| 75469 | int layout=0; |  | 75421 | int layout=0;
| 75470 | Mat retval; |  | 75422 | Mat retval;
| 75471 |  |  | 75423 |
| 75472 | const char* keywords[] = { "matrix", "idx", "layout", NULL }; |  | 75424 | const char* keywords[] = { "matrix", "idx", "layout", NULL };
| 75473 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getSubMatrix", (char**)keywords, &pyobj_matrix, &pyobj_idx, &pyobj_layout) && |  | 75425 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getSubMatrix", (char**)keywords, &pyobj_matrix, &pyobj_idx, &pyobj_layout) &&
| 75474 | pyopencv_to_safe(pyobj_matrix, matrix, ArgInfo("matrix", 0)) && |  | 75426 | pyopencv_to_safe(pyobj_matrix, matrix, ArgInfo("matrix", 0)) &&
| 75475 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) && |  | 75427 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) &&
| 75476 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) ) |  | 75428 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) )
| 75477 | { |  | 75429 | {
| 75478 | ERRWRAP2(retval = cv::ml::TrainData::getSubMatrix(matrix, idx, layout)); |  | 75430 | ERRWRAP2(retval = cv::ml::TrainData::getSubMatrix(matrix, idx, layout));
| 75479 | return pyopencv_from(retval); |  | 75431 | return pyopencv_from(retval);
| 75480 | } |  | 75432 | }
| 75481 |  |  | 75433 |
| 75482 | return NULL; |  | 75434 | return NULL;
| 75483 | } |  | 75435 | }
| 75484 |  |  | 75436 |
| 75485 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSubVector_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75437 | static PyObject* pyopencv_cv_ml_ml_TrainData_getSubVector_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 75486 | { |  | 75438 | {
| 75487 | using namespace cv::ml; |  | 75439 | using namespace cv::ml;
| 75488 |  |  | 75440 |
| 75489 | PyObject* pyobj_vec = NULL; |  | 75441 | PyObject* pyobj_vec = NULL;
| 75490 | Mat vec; |  | 75442 | Mat vec;
| 75491 | PyObject* pyobj_idx = NULL; |  | 75443 | PyObject* pyobj_idx = NULL;
| 75492 | Mat idx; |  | 75444 | Mat idx;
| 75493 | Mat retval; |  | 75445 | Mat retval;
| 75494 |  |  | 75446 |
| 75495 | const char* keywords[] = { "vec", "idx", NULL }; |  | 75447 | const char* keywords[] = { "vec", "idx", NULL };
| 75496 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ml_TrainData.getSubVector", (char**)keywords, &pyobj_vec, &pyobj_idx) && |  | 75448 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ml_TrainData.getSubVector", (char**)keywords, &pyobj_vec, &pyobj_idx) &&
| 75497 | pyopencv_to_safe(pyobj_vec, vec, ArgInfo("vec", 0)) && |  | 75449 | pyopencv_to_safe(pyobj_vec, vec, ArgInfo("vec", 0)) &&
| 75498 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) ) |  | 75450 | pyopencv_to_safe(pyobj_idx, idx, ArgInfo("idx", 0)) )
| 75499 | { |  | 75451 | {
| 75500 | ERRWRAP2(retval = cv::ml::TrainData::getSubVector(vec, idx)); |  | 75452 | ERRWRAP2(retval = cv::ml::TrainData::getSubVector(vec, idx));
| 75501 | return pyopencv_from(retval); |  | 75453 | return pyopencv_from(retval);
| 75502 | } |  | 75454 | }
| 75503 |  |  | 75455 |
| 75504 | return NULL; |  | 75456 | return NULL;
| 75505 | } |  | 75457 | }
| 75506 |  |  | 75458 |
| 75507 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestNormCatResponses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75459 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestNormCatResponses(PyObject* self, PyObject* py_args, PyObject* kw)
| 75508 | { |  | 75460 | {
| 75509 | using namespace cv::ml; |  | 75461 | using namespace cv::ml;
| 75510 |  |  | 75462 |
| 75511 |  |  | 75463 |
| 75512 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75464 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75513 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75465 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75514 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75466 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75515 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75467 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75516 | Mat retval; |  | 75468 | Mat retval;
| 75517 |  |  | 75469 |
| 75518 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75470 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75519 | { |  | 75471 | {
| 75520 | ERRWRAP2(retval = _self_->getTestNormCatResponses()); |  | 75472 | ERRWRAP2(retval = _self_->getTestNormCatResponses());
| 75521 | return pyopencv_from(retval); |  | 75473 | return pyopencv_from(retval);
| 75522 | } |  | 75474 | }
| 75523 |  |  | 75475 |
| 75524 | return NULL; |  | 75476 | return NULL;
| 75525 | } |  | 75477 | }
| 75526 |  |  | 75478 |
| 75527 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestResponses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75479 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestResponses(PyObject* self, PyObject* py_args, PyObject* kw)
| 75528 | { |  | 75480 | {
| 75529 | using namespace cv::ml; |  | 75481 | using namespace cv::ml;
| 75530 |  |  | 75482 |
| 75531 |  |  | 75483 |
| 75532 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75484 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75533 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75485 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75534 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75486 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75535 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75487 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75536 | Mat retval; |  | 75488 | Mat retval;
| 75537 |  |  | 75489 |
| 75538 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75490 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75539 | { |  | 75491 | {
| 75540 | ERRWRAP2(retval = _self_->getTestResponses()); |  | 75492 | ERRWRAP2(retval = _self_->getTestResponses());
| 75541 | return pyopencv_from(retval); |  | 75493 | return pyopencv_from(retval);
| 75542 | } |  | 75494 | }
| 75543 |  |  | 75495 |
| 75544 | return NULL; |  | 75496 | return NULL;
| 75545 | } |  | 75497 | }
| 75546 |  |  | 75498 |
| 75547 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestSampleIdx(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75499 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestSampleIdx(PyObject* self, PyObject* py_args, PyObject* kw)
| 75548 | { |  | 75500 | {
| 75549 | using namespace cv::ml; |  | 75501 | using namespace cv::ml;
| 75550 |  |  | 75502 |
| 75551 |  |  | 75503 |
| 75552 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75504 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75553 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75505 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75554 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75506 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75555 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75507 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75556 | Mat retval; |  | 75508 | Mat retval;
| 75557 |  |  | 75509 |
| 75558 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75510 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75559 | { |  | 75511 | {
| 75560 | ERRWRAP2(retval = _self_->getTestSampleIdx()); |  | 75512 | ERRWRAP2(retval = _self_->getTestSampleIdx());
| 75561 | return pyopencv_from(retval); |  | 75513 | return pyopencv_from(retval);
| 75562 | } |  | 75514 | }
| 75563 |  |  | 75515 |
| 75564 | return NULL; |  | 75516 | return NULL;
| 75565 | } |  | 75517 | }
| 75566 |  |  | 75518 |
| 75567 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestSampleWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75519 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestSampleWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 75568 | { |  | 75520 | {
| 75569 | using namespace cv::ml; |  | 75521 | using namespace cv::ml;
| 75570 |  |  | 75522 |
| 75571 |  |  | 75523 |
| 75572 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75524 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75573 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75525 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75574 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75526 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75575 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75527 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75576 | Mat retval; |  | 75528 | Mat retval;
| 75577 |  |  | 75529 |
| 75578 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75530 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75579 | { |  | 75531 | {
| 75580 | ERRWRAP2(retval = _self_->getTestSampleWeights()); |  | 75532 | ERRWRAP2(retval = _self_->getTestSampleWeights());
| 75581 | return pyopencv_from(retval); |  | 75533 | return pyopencv_from(retval);
| 75582 | } |  | 75534 | }
| 75583 |  |  | 75535 |
| 75584 | return NULL; |  | 75536 | return NULL;
| 75585 | } |  | 75537 | }
| 75586 |  |  | 75538 |
| 75587 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75539 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTestSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 75588 | { |  | 75540 | {
| 75589 | using namespace cv::ml; |  | 75541 | using namespace cv::ml;
| 75590 |  |  | 75542 |
| 75591 |  |  | 75543 |
| 75592 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75544 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75593 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75545 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75594 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75546 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75595 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75547 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75596 | Mat retval; |  | 75548 | Mat retval;
| 75597 |  |  | 75549 |
| 75598 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75550 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75599 | { |  | 75551 | {
| 75600 | ERRWRAP2(retval = _self_->getTestSamples()); |  | 75552 | ERRWRAP2(retval = _self_->getTestSamples());
| 75601 | return pyopencv_from(retval); |  | 75553 | return pyopencv_from(retval);
| 75602 | } |  | 75554 | }
| 75603 |  |  | 75555 |
| 75604 | return NULL; |  | 75556 | return NULL;
| 75605 | } |  | 75557 | }
| 75606 |  |  | 75558 |
| 75607 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainNormCatResponses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75559 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainNormCatResponses(PyObject* self, PyObject* py_args, PyObject* kw)
| 75608 | { |  | 75560 | {
| 75609 | using namespace cv::ml; |  | 75561 | using namespace cv::ml;
| 75610 |  |  | 75562 |
| 75611 |  |  | 75563 |
| 75612 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75564 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75613 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75565 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75614 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75566 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75615 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75567 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75616 | Mat retval; |  | 75568 | Mat retval;
| 75617 |  |  | 75569 |
| 75618 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75570 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75619 | { |  | 75571 | {
| 75620 | ERRWRAP2(retval = _self_->getTrainNormCatResponses()); |  | 75572 | ERRWRAP2(retval = _self_->getTrainNormCatResponses());
| 75621 | return pyopencv_from(retval); |  | 75573 | return pyopencv_from(retval);
| 75622 | } |  | 75574 | }
| 75623 |  |  | 75575 |
| 75624 | return NULL; |  | 75576 | return NULL;
| 75625 | } |  | 75577 | }
| 75626 |  |  | 75578 |
| 75627 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainResponses(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75579 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainResponses(PyObject* self, PyObject* py_args, PyObject* kw)
| 75628 | { |  | 75580 | {
| 75629 | using namespace cv::ml; |  | 75581 | using namespace cv::ml;
| 75630 |  |  | 75582 |
| 75631 |  |  | 75583 |
| 75632 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75584 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75633 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75585 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75634 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75586 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75635 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75587 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75636 | Mat retval; |  | 75588 | Mat retval;
| 75637 |  |  | 75589 |
| 75638 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75590 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75639 | { |  | 75591 | {
| 75640 | ERRWRAP2(retval = _self_->getTrainResponses()); |  | 75592 | ERRWRAP2(retval = _self_->getTrainResponses());
| 75641 | return pyopencv_from(retval); |  | 75593 | return pyopencv_from(retval);
| 75642 | } |  | 75594 | }
| 75643 |  |  | 75595 |
| 75644 | return NULL; |  | 75596 | return NULL;
| 75645 | } |  | 75597 | }
| 75646 |  |  | 75598 |
| 75647 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainSampleIdx(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75599 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainSampleIdx(PyObject* self, PyObject* py_args, PyObject* kw)
| 75648 | { |  | 75600 | {
| 75649 | using namespace cv::ml; |  | 75601 | using namespace cv::ml;
| 75650 |  |  | 75602 |
| 75651 |  |  | 75603 |
| 75652 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75604 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75653 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75605 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75654 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75606 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75655 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75607 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75656 | Mat retval; |  | 75608 | Mat retval;
| 75657 |  |  | 75609 |
| 75658 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75610 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75659 | { |  | 75611 | {
| 75660 | ERRWRAP2(retval = _self_->getTrainSampleIdx()); |  | 75612 | ERRWRAP2(retval = _self_->getTrainSampleIdx());
| 75661 | return pyopencv_from(retval); |  | 75613 | return pyopencv_from(retval);
| 75662 | } |  | 75614 | }
| 75663 |  |  | 75615 |
| 75664 | return NULL; |  | 75616 | return NULL;
| 75665 | } |  | 75617 | }
| 75666 |  |  | 75618 |
| 75667 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainSampleWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75619 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainSampleWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 75668 | { |  | 75620 | {
| 75669 | using namespace cv::ml; |  | 75621 | using namespace cv::ml;
| 75670 |  |  | 75622 |
| 75671 |  |  | 75623 |
| 75672 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75624 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75673 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75625 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75674 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75626 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75675 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75627 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75676 | Mat retval; |  | 75628 | Mat retval;
| 75677 |  |  | 75629 |
| 75678 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75630 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75679 | { |  | 75631 | {
| 75680 | ERRWRAP2(retval = _self_->getTrainSampleWeights()); |  | 75632 | ERRWRAP2(retval = _self_->getTrainSampleWeights());
| 75681 | return pyopencv_from(retval); |  | 75633 | return pyopencv_from(retval);
| 75682 | } |  | 75634 | }
| 75683 |  |  | 75635 |
| 75684 | return NULL; |  | 75636 | return NULL;
| 75685 | } |  | 75637 | }
| 75686 |  |  | 75638 |
| 75687 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainSamples(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75639 | static PyObject* pyopencv_cv_ml_ml_TrainData_getTrainSamples(PyObject* self, PyObject* py_args, PyObject* kw)
| 75688 | { |  | 75640 | {
| 75689 | using namespace cv::ml; |  | 75641 | using namespace cv::ml;
| 75690 |  |  | 75642 |
| 75691 |  |  | 75643 |
| 75692 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75644 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75693 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75645 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75694 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75646 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75695 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75647 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75696 | PyObject* pyobj_layout = NULL; |  | 75648 | PyObject* pyobj_layout = NULL;
| 75697 | int layout=ROW_SAMPLE; |  | 75649 | int layout=ROW_SAMPLE;
| 75698 | PyObject* pyobj_compressSamples = NULL; |  | 75650 | PyObject* pyobj_compressSamples = NULL;
| 75699 | bool compressSamples=true; |  | 75651 | bool compressSamples=true;
| 75700 | PyObject* pyobj_compressVars = NULL; |  | 75652 | PyObject* pyobj_compressVars = NULL;
| 75701 | bool compressVars=true; |  | 75653 | bool compressVars=true;
| 75702 | Mat retval; |  | 75654 | Mat retval;
| 75703 |  |  | 75655 |
| 75704 | const char* keywords[] = { "layout", "compressSamples", "compressVars", NULL }; |  | 75656 | const char* keywords[] = { "layout", "compressSamples", "compressVars", NULL };
| 75705 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:ml_TrainData.getTrainSamples", (char**)keywords, &pyobj_layout, &pyobj_compressSamples, &pyobj_compressVars) && |  | 75657 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOO:ml_TrainData.getTrainSamples", (char**)keywords, &pyobj_layout, &pyobj_compressSamples, &pyobj_compressVars) &&
| 75706 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) && |  | 75658 | pyopencv_to_safe(pyobj_layout, layout, ArgInfo("layout", 0)) &&
| 75707 | pyopencv_to_safe(pyobj_compressSamples, compressSamples, ArgInfo("compressSamples", 0)) && |  | 75659 | pyopencv_to_safe(pyobj_compressSamples, compressSamples, ArgInfo("compressSamples", 0)) &&
| 75708 | pyopencv_to_safe(pyobj_compressVars, compressVars, ArgInfo("compressVars", 0)) ) |  | 75660 | pyopencv_to_safe(pyobj_compressVars, compressVars, ArgInfo("compressVars", 0)) )
| 75709 | { |  | 75661 | {
| 75710 | ERRWRAP2(retval = _self_->getTrainSamples(layout, compressSamples, compressVars)); |  | 75662 | ERRWRAP2(retval = _self_->getTrainSamples(layout, compressSamples, compressVars));
| 75711 | return pyopencv_from(retval); |  | 75663 | return pyopencv_from(retval);
| 75712 | } |  | 75664 | }
| 75713 |  |  | 75665 |
| 75714 | return NULL; |  | 75666 | return NULL;
| 75715 | } |  | 75667 | }
| 75716 |  |  | 75668 |
| 75717 | static PyObject* pyopencv_cv_ml_ml_TrainData_getValues(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75669 | static PyObject* pyopencv_cv_ml_ml_TrainData_getValues(PyObject* self, PyObject* py_args, PyObject* kw)
| 75718 | { |  | 75670 | {
| 75719 | using namespace cv::ml; |  | 75671 | using namespace cv::ml;
| 75720 |  |  | 75672 |
| 75721 |  |  | 75673 |
| 75722 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75674 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75723 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75675 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75724 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75676 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75725 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75677 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75726 | pyPrepareArgumentConversionErrorsStorage(2); |  | 75678 | pyPrepareArgumentConversionErrorsStorage(2);
| 75727 |  |  | 75679 |
| 75728 | { |  | 75680 | {
| 75729 | PyObject* pyobj_vi = NULL; |  | 75681 | PyObject* pyobj_vi = NULL;
| 75730 | int vi=0; |  | 75682 | int vi=0;
| 75731 | PyObject* pyobj_sidx = NULL; |  | 75683 | PyObject* pyobj_sidx = NULL;
| 75732 | Mat sidx; |  | 75684 | Mat sidx;
| 75733 | PyObject* pyobj_values = NULL; |  | 75685 | PyObject* pyobj_values = NULL;
| 75734 | float values=0.f; |  | 75686 | float values=0.f;
| 75735 |  |  | 75687 |
| 75736 | const char* keywords[] = { "vi", "sidx", "values", NULL }; |  | 75688 | const char* keywords[] = { "vi", "sidx", "values", NULL };
| 75737 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getValues", (char**)keywords, &pyobj_vi, &pyobj_sidx, &pyobj_values) && |  | 75689 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getValues", (char**)keywords, &pyobj_vi, &pyobj_sidx, &pyobj_values) &&
| 75738 | pyopencv_to_safe(pyobj_vi, vi, ArgInfo("vi", 0)) && |  | 75690 | pyopencv_to_safe(pyobj_vi, vi, ArgInfo("vi", 0)) &&
| 75739 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) && |  | 75691 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) &&
| 75740 | pyopencv_to_safe(pyobj_values, values, ArgInfo("values", 0)) ) |  | 75692 | pyopencv_to_safe(pyobj_values, values, ArgInfo("values", 0)) )
| 75741 | { |  | 75693 | {
| 75742 | ERRWRAP2(_self_->getValues(vi, sidx, &values)); |  | 75694 | ERRWRAP2(_self_->getValues(vi, sidx, &values));
| 75743 | Py_RETURN_NONE; |  | 75695 | Py_RETURN_NONE;
| 75744 | } |  | 75696 | }
| 75745 |  |  | 75697 |
| 75746 |  |  | 75698 |
| 75747 | pyPopulateArgumentConversionErrors(); |  | 75699 | pyPopulateArgumentConversionErrors();
| 75748 | } |  | 75700 | }
| 75749 |  |  | 75701 |
| 75750 |  |  | 75702 |
| 75751 | { |  | 75703 | {
| 75752 | PyObject* pyobj_vi = NULL; |  | 75704 | PyObject* pyobj_vi = NULL;
| 75753 | int vi=0; |  | 75705 | int vi=0;
| 75754 | PyObject* pyobj_sidx = NULL; |  | 75706 | PyObject* pyobj_sidx = NULL;
| 75755 | UMat sidx; |  | 75707 | UMat sidx;
| 75756 | PyObject* pyobj_values = NULL; |  | 75708 | PyObject* pyobj_values = NULL;
| 75757 | float values=0.f; |  | 75709 | float values=0.f;
| 75758 |  |  | 75710 |
| 75759 | const char* keywords[] = { "vi", "sidx", "values", NULL }; |  | 75711 | const char* keywords[] = { "vi", "sidx", "values", NULL };
| 75760 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getValues", (char**)keywords, &pyobj_vi, &pyobj_sidx, &pyobj_values) && |  | 75712 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ml_TrainData.getValues", (char**)keywords, &pyobj_vi, &pyobj_sidx, &pyobj_values) &&
| 75761 | pyopencv_to_safe(pyobj_vi, vi, ArgInfo("vi", 0)) && |  | 75713 | pyopencv_to_safe(pyobj_vi, vi, ArgInfo("vi", 0)) &&
| 75762 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) && |  | 75714 | pyopencv_to_safe(pyobj_sidx, sidx, ArgInfo("sidx", 0)) &&
| 75763 | pyopencv_to_safe(pyobj_values, values, ArgInfo("values", 0)) ) |  | 75715 | pyopencv_to_safe(pyobj_values, values, ArgInfo("values", 0)) )
| 75764 | { |  | 75716 | {
| 75765 | ERRWRAP2(_self_->getValues(vi, sidx, &values)); |  | 75717 | ERRWRAP2(_self_->getValues(vi, sidx, &values));
| 75766 | Py_RETURN_NONE; |  | 75718 | Py_RETURN_NONE;
| 75767 | } |  | 75719 | }
| 75768 |  |  | 75720 |
| 75769 |  |  | 75721 |
| 75770 | pyPopulateArgumentConversionErrors(); |  | 75722 | pyPopulateArgumentConversionErrors();
| 75771 | } |  | 75723 | }
| 75772 | pyRaiseCVOverloadException("getValues"); |  | 75724 | pyRaiseCVOverloadException("getValues");
| 75773 |  |  | 75725 |
| 75774 | return NULL; |  | 75726 | return NULL;
| 75775 | } |  | 75727 | }
| 75776 |  |  | 75728 |
| 75777 | static PyObject* pyopencv_cv_ml_ml_TrainData_getVarIdx(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75729 | static PyObject* pyopencv_cv_ml_ml_TrainData_getVarIdx(PyObject* self, PyObject* py_args, PyObject* kw)
| 75778 | { |  | 75730 | {
| 75779 | using namespace cv::ml; |  | 75731 | using namespace cv::ml;
| 75780 |  |  | 75732 |
| 75781 |  |  | 75733 |
| 75782 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75734 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75783 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75735 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75784 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75736 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75785 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75737 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75786 | Mat retval; |  | 75738 | Mat retval;
| 75787 |  |  | 75739 |
| 75788 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75740 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75789 | { |  | 75741 | {
| 75790 | ERRWRAP2(retval = _self_->getVarIdx()); |  | 75742 | ERRWRAP2(retval = _self_->getVarIdx());
| 75791 | return pyopencv_from(retval); |  | 75743 | return pyopencv_from(retval);
| 75792 | } |  | 75744 | }
| 75793 |  |  | 75745 |
| 75794 | return NULL; |  | 75746 | return NULL;
| 75795 | } |  | 75747 | }
| 75796 |  |  | 75748 |
| 75797 | static PyObject* pyopencv_cv_ml_ml_TrainData_getVarSymbolFlags(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75749 | static PyObject* pyopencv_cv_ml_ml_TrainData_getVarSymbolFlags(PyObject* self, PyObject* py_args, PyObject* kw)
| 75798 | { |  | 75750 | {
| 75799 | using namespace cv::ml; |  | 75751 | using namespace cv::ml;
| 75800 |  |  | 75752 |
| 75801 |  |  | 75753 |
| 75802 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75754 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75803 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75755 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75804 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75756 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75805 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75757 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75806 | Mat retval; |  | 75758 | Mat retval;
| 75807 |  |  | 75759 |
| 75808 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75760 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75809 | { |  | 75761 | {
| 75810 | ERRWRAP2(retval = _self_->getVarSymbolFlags()); |  | 75762 | ERRWRAP2(retval = _self_->getVarSymbolFlags());
| 75811 | return pyopencv_from(retval); |  | 75763 | return pyopencv_from(retval);
| 75812 | } |  | 75764 | }
| 75813 |  |  | 75765 |
| 75814 | return NULL; |  | 75766 | return NULL;
| 75815 | } |  | 75767 | }
| 75816 |  |  | 75768 |
| 75817 | static PyObject* pyopencv_cv_ml_ml_TrainData_getVarType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75769 | static PyObject* pyopencv_cv_ml_ml_TrainData_getVarType(PyObject* self, PyObject* py_args, PyObject* kw)
| 75818 | { |  | 75770 | {
| 75819 | using namespace cv::ml; |  | 75771 | using namespace cv::ml;
| 75820 |  |  | 75772 |
| 75821 |  |  | 75773 |
| 75822 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75774 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75823 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75775 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75824 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75776 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75825 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75777 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75826 | Mat retval; |  | 75778 | Mat retval;
| 75827 |  |  | 75779 |
| 75828 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75780 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75829 | { |  | 75781 | {
| 75830 | ERRWRAP2(retval = _self_->getVarType()); |  | 75782 | ERRWRAP2(retval = _self_->getVarType());
| 75831 | return pyopencv_from(retval); |  | 75783 | return pyopencv_from(retval);
| 75832 | } |  | 75784 | }
| 75833 |  |  | 75785 |
| 75834 | return NULL; |  | 75786 | return NULL;
| 75835 | } |  | 75787 | }
| 75836 |  |  | 75788 |
| 75837 | static PyObject* pyopencv_cv_ml_ml_TrainData_setTrainTestSplit(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75789 | static PyObject* pyopencv_cv_ml_ml_TrainData_setTrainTestSplit(PyObject* self, PyObject* py_args, PyObject* kw)
| 75838 | { |  | 75790 | {
| 75839 | using namespace cv::ml; |  | 75791 | using namespace cv::ml;
| 75840 |  |  | 75792 |
| 75841 |  |  | 75793 |
| 75842 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75794 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75843 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75795 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75844 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75796 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75845 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75797 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75846 | PyObject* pyobj_count = NULL; |  | 75798 | PyObject* pyobj_count = NULL;
| 75847 | int count=0; |  | 75799 | int count=0;
| 75848 | PyObject* pyobj_shuffle = NULL; |  | 75800 | PyObject* pyobj_shuffle = NULL;
| 75849 | bool shuffle=true; |  | 75801 | bool shuffle=true;
| 75850 |  |  | 75802 |
| 75851 | const char* keywords[] = { "count", "shuffle", NULL }; |  | 75803 | const char* keywords[] = { "count", "shuffle", NULL };
| 75852 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_TrainData.setTrainTestSplit", (char**)keywords, &pyobj_count, &pyobj_shuffle) && |  | 75804 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_TrainData.setTrainTestSplit", (char**)keywords, &pyobj_count, &pyobj_shuffle) &&
| 75853 | pyopencv_to_safe(pyobj_count, count, ArgInfo("count", 0)) && |  | 75805 | pyopencv_to_safe(pyobj_count, count, ArgInfo("count", 0)) &&
| 75854 | pyopencv_to_safe(pyobj_shuffle, shuffle, ArgInfo("shuffle", 0)) ) |  | 75806 | pyopencv_to_safe(pyobj_shuffle, shuffle, ArgInfo("shuffle", 0)) )
| 75855 | { |  | 75807 | {
| 75856 | ERRWRAP2(_self_->setTrainTestSplit(count, shuffle)); |  | 75808 | ERRWRAP2(_self_->setTrainTestSplit(count, shuffle));
| 75857 | Py_RETURN_NONE; |  | 75809 | Py_RETURN_NONE;
| 75858 | } |  | 75810 | }
| 75859 |  |  | 75811 |
| 75860 | return NULL; |  | 75812 | return NULL;
| 75861 | } |  | 75813 | }
| 75862 |  |  | 75814 |
| 75863 | static PyObject* pyopencv_cv_ml_ml_TrainData_setTrainTestSplitRatio(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75815 | static PyObject* pyopencv_cv_ml_ml_TrainData_setTrainTestSplitRatio(PyObject* self, PyObject* py_args, PyObject* kw)
| 75864 | { |  | 75816 | {
| 75865 | using namespace cv::ml; |  | 75817 | using namespace cv::ml;
| 75866 |  |  | 75818 |
| 75867 |  |  | 75819 |
| 75868 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75820 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75869 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75821 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75870 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75822 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75871 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75823 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75872 | PyObject* pyobj_ratio = NULL; |  | 75824 | PyObject* pyobj_ratio = NULL;
| 75873 | double ratio=0; |  | 75825 | double ratio=0;
| 75874 | PyObject* pyobj_shuffle = NULL; |  | 75826 | PyObject* pyobj_shuffle = NULL;
| 75875 | bool shuffle=true; |  | 75827 | bool shuffle=true;
| 75876 |  |  | 75828 |
| 75877 | const char* keywords[] = { "ratio", "shuffle", NULL }; |  | 75829 | const char* keywords[] = { "ratio", "shuffle", NULL };
| 75878 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_TrainData.setTrainTestSplitRatio", (char**)keywords, &pyobj_ratio, &pyobj_shuffle) && |  | 75830 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:ml_TrainData.setTrainTestSplitRatio", (char**)keywords, &pyobj_ratio, &pyobj_shuffle) &&
| 75879 | pyopencv_to_safe(pyobj_ratio, ratio, ArgInfo("ratio", 0)) && |  | 75831 | pyopencv_to_safe(pyobj_ratio, ratio, ArgInfo("ratio", 0)) &&
| 75880 | pyopencv_to_safe(pyobj_shuffle, shuffle, ArgInfo("shuffle", 0)) ) |  | 75832 | pyopencv_to_safe(pyobj_shuffle, shuffle, ArgInfo("shuffle", 0)) )
| 75881 | { |  | 75833 | {
| 75882 | ERRWRAP2(_self_->setTrainTestSplitRatio(ratio, shuffle)); |  | 75834 | ERRWRAP2(_self_->setTrainTestSplitRatio(ratio, shuffle));
| 75883 | Py_RETURN_NONE; |  | 75835 | Py_RETURN_NONE;
| 75884 | } |  | 75836 | }
| 75885 |  |  | 75837 |
| 75886 | return NULL; |  | 75838 | return NULL;
| 75887 | } |  | 75839 | }
| 75888 |  |  | 75840 |
| 75889 | static PyObject* pyopencv_cv_ml_ml_TrainData_shuffleTrainTest(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75841 | static PyObject* pyopencv_cv_ml_ml_TrainData_shuffleTrainTest(PyObject* self, PyObject* py_args, PyObject* kw)
| 75890 | { |  | 75842 | {
| 75891 | using namespace cv::ml; |  | 75843 | using namespace cv::ml;
| 75892 |  |  | 75844 |
| 75893 |  |  | 75845 |
| 75894 | Ptr<cv::ml::TrainData> * self1 = 0; |  | 75846 | Ptr<cv::ml::TrainData> * self1 = 0;
| 75895 | if (!pyopencv_ml_TrainData_getp(self, self1)) |  | 75847 | if (!pyopencv_ml_TrainData_getp(self, self1))
| 75896 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)"); |  | 75848 | return failmsgp("Incorrect type of self (must be 'ml_TrainData' or its derivative)");
| 75897 | Ptr<cv::ml::TrainData> _self_ = *(self1); |  | 75849 | Ptr<cv::ml::TrainData> _self_ = *(self1);
| 75898 |  |  | 75850 |
| 75899 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75851 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 75900 | { |  | 75852 | {
| 75901 | ERRWRAP2(_self_->shuffleTrainTest()); |  | 75853 | ERRWRAP2(_self_->shuffleTrainTest());
| 75902 | Py_RETURN_NONE; |  | 75854 | Py_RETURN_NONE;
| 75903 | } |  | 75855 | }
| 75904 |  |  | 75856 |
| 75905 | return NULL; |  | 75857 | return NULL;
| 75906 | } |  | 75858 | }
| 75907 |  |  | 75859 |
| 75908 |  |  | 75860 |
| 75909 |  |  | 75861 |
| 75910 | // Tables (ml_TrainData) |  | 75862 | // Tables (ml_TrainData)
| 75911 |  |  | 75863 |
| 75912 | static PyGetSetDef pyopencv_ml_TrainData_getseters[] = |  | 75864 | static PyGetSetDef pyopencv_ml_TrainData_getseters[] =
| 75913 | { |  | 75865 | {
| 75914 | {NULL} /* Sentinel */ |  | 75866 | {NULL} /* Sentinel */
| 75915 | }; |  | 75867 | };
| 75916 |  |  | 75868 |
| 75917 | static PyMethodDef pyopencv_ml_TrainData_methods[] = |  | 75869 | static PyMethodDef pyopencv_ml_TrainData_methods[] =
| 75918 | { |  | 75870 | {
| 75919 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_create_static, METH_STATIC), "create(samples, layout, responses[, varIdx[, sampleIdx[, sampleWeights[, varType]]]]) -> retval\n. @brief Creates training data from in-memory arrays.\n. \n. @param samples matrix of samples. It should have CV_32F type.\n. @param layout see ml::SampleTypes.\n. @param responses matrix of responses. If the responses are scalar, they should be stored as a\n. single row or as a single column. The matrix should have type CV_32F or CV_32S (in the\n. former case the responses are considered as ordered by default; in the latter case - as\n. categorical)\n. @param varIdx vector specifying which variables to use for training. It can be an integer vector\n. (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of\n. active variables.\n. @param sampleIdx vector specifying which samples to use for training. It can be an integer\n. vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask\n. of training samples.\n. @param sampleWeights optional vector with weights for each sample. It should have CV_32F type.\n. @param varType optional vector of type CV_8U and size `<number_of_variables_in_samples> +\n. <number_of_variables_in_responses>`, containing types of each input and output variable. See\n. ml::VariableTypes."}, |  | 75871 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_create_static, METH_STATIC), "create(samples, layout, responses[, varIdx[, sampleIdx[, sampleWeights[, varType]]]]) -> retval\n. @brief Creates training data from in-memory arrays.\n. \n. @param samples matrix of samples. It should have CV_32F type.\n. @param layout see ml::SampleTypes.\n. @param responses matrix of responses. If the responses are scalar, they should be stored as a\n. single row or as a single column. The matrix should have type CV_32F or CV_32S (in the\n. former case the responses are considered as ordered by default; in the latter case - as\n. categorical)\n. @param varIdx vector specifying which variables to use for training. It can be an integer vector\n. (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of\n. active variables.\n. @param sampleIdx vector specifying which samples to use for training. It can be an integer\n. vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask\n. of training samples.\n. @param sampleWeights optional vector with weights for each sample. It should have CV_32F type.\n. @param varType optional vector of type CV_8U and size `<number_of_variables_in_samples> +\n. <number_of_variables_in_responses>`, containing types of each input and output variable. See\n. ml::VariableTypes."},
| 75920 | {"getCatCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getCatCount, 0), "getCatCount(vi) -> retval\n."}, |  | 75872 | {"getCatCount", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getCatCount, 0), "getCatCount(vi) -> retval\n."},
| 75921 | {"getCatMap", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getCatMap, 0), "getCatMap() -> retval\n."}, |  | 75873 | {"getCatMap", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getCatMap, 0), "getCatMap() -> retval\n."},
| 75922 | {"getCatOfs", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getCatOfs, 0), "getCatOfs() -> retval\n."}, |  | 75874 | {"getCatOfs", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getCatOfs, 0), "getCatOfs() -> retval\n."},
| 75923 | {"getClassLabels", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getClassLabels, 0), "getClassLabels() -> retval\n. @brief Returns the vector of class labels\n. \n. The function returns vector of unique labels occurred in the responses."}, |  | 75875 | {"getClassLabels", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getClassLabels, 0), "getClassLabels() -> retval\n. @brief Returns the vector of class labels\n. \n. The function returns vector of unique labels occurred in the responses."},
| 75924 | {"getDefaultSubstValues", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getDefaultSubstValues, 0), "getDefaultSubstValues() -> retval\n."}, |  | 75876 | {"getDefaultSubstValues", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getDefaultSubstValues, 0), "getDefaultSubstValues() -> retval\n."},
| 75925 | {"getLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getLayout, 0), "getLayout() -> retval\n."}, |  | 75877 | {"getLayout", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getLayout, 0), "getLayout() -> retval\n."},
| 75926 | {"getMissing", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getMissing, 0), "getMissing() -> retval\n."}, |  | 75878 | {"getMissing", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getMissing, 0), "getMissing() -> retval\n."},
| 75927 | {"getNAllVars", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNAllVars, 0), "getNAllVars() -> retval\n."}, |  | 75879 | {"getNAllVars", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNAllVars, 0), "getNAllVars() -> retval\n."},
| 75928 | {"getNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNSamples, 0), "getNSamples() -> retval\n."}, |  | 75880 | {"getNSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNSamples, 0), "getNSamples() -> retval\n."},
| 75929 | {"getNTestSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNTestSamples, 0), "getNTestSamples() -> retval\n."}, |  | 75881 | {"getNTestSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNTestSamples, 0), "getNTestSamples() -> retval\n."},
| 75930 | {"getNTrainSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNTrainSamples, 0), "getNTrainSamples() -> retval\n."}, |  | 75882 | {"getNTrainSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNTrainSamples, 0), "getNTrainSamples() -> retval\n."},
| 75931 | {"getNVars", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNVars, 0), "getNVars() -> retval\n."}, |  | 75883 | {"getNVars", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNVars, 0), "getNVars() -> retval\n."},
| 75932 | {"getNames", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNames, 0), "getNames(names) -> None\n. @brief Returns vector of symbolic names captured in loadFromCSV()"}, |  | 75884 | {"getNames", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNames, 0), "getNames(names) -> None\n. @brief Returns vector of symbolic names captured in loadFromCSV()"},
| 75933 | {"getNormCatResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNormCatResponses, 0), "getNormCatResponses() -> retval\n."}, |  | 75885 | {"getNormCatResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getNormCatResponses, 0), "getNormCatResponses() -> retval\n."},
| 75934 | {"getResponseType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getResponseType, 0), "getResponseType() -> retval\n."}, |  | 75886 | {"getResponseType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getResponseType, 0), "getResponseType() -> retval\n."},
| 75935 | {"getResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getResponses, 0), "getResponses() -> retval\n."}, |  | 75887 | {"getResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getResponses, 0), "getResponses() -> retval\n."},
| 75936 | {"getSample", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSample, 0), "getSample(varIdx, sidx, buf) -> None\n."}, |  | 75888 | {"getSample", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSample, 0), "getSample(varIdx, sidx, buf) -> None\n."},
| 75937 | {"getSampleWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSampleWeights, 0), "getSampleWeights() -> retval\n."}, |  | 75889 | {"getSampleWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSampleWeights, 0), "getSampleWeights() -> retval\n."},
| 75938 | {"getSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSamples, 0), "getSamples() -> retval\n."}, |  | 75890 | {"getSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSamples, 0), "getSamples() -> retval\n."},
| 75939 | {"getSubMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSubMatrix_static, METH_STATIC), "getSubMatrix(matrix, idx, layout) -> retval\n. @brief Extract from matrix rows/cols specified by passed indexes.\n. @param matrix input matrix (supported types: CV_32S, CV_32F, CV_64F)\n. @param idx 1D index vector\n. @param layout specifies to extract rows (cv::ml::ROW_SAMPLES) or to extract columns (cv::ml::COL_SAMPLES)"}, |  | 75891 | {"getSubMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSubMatrix_static, METH_STATIC), "getSubMatrix(matrix, idx, layout) -> retval\n. @brief Extract from matrix rows/cols specified by passed indexes.\n. @param matrix input matrix (supported types: CV_32S, CV_32F, CV_64F)\n. @param idx 1D index vector\n. @param layout specifies to extract rows (cv::ml::ROW_SAMPLES) or to extract columns (cv::ml::COL_SAMPLES)"},
| 75940 | {"getSubVector", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSubVector_static, METH_STATIC), "getSubVector(vec, idx) -> retval\n. @brief Extract from 1D vector elements specified by passed indexes.\n. @param vec input vector (supported types: CV_32S, CV_32F, CV_64F)\n. @param idx 1D index vector"}, |  | 75892 | {"getSubVector", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getSubVector_static, METH_STATIC), "getSubVector(vec, idx) -> retval\n. @brief Extract from 1D vector elements specified by passed indexes.\n. @param vec input vector (supported types: CV_32S, CV_32F, CV_64F)\n. @param idx 1D index vector"},
| 75941 | {"getTestNormCatResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestNormCatResponses, 0), "getTestNormCatResponses() -> retval\n."}, |  | 75893 | {"getTestNormCatResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestNormCatResponses, 0), "getTestNormCatResponses() -> retval\n."},
| 75942 | {"getTestResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestResponses, 0), "getTestResponses() -> retval\n."}, |  | 75894 | {"getTestResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestResponses, 0), "getTestResponses() -> retval\n."},
| 75943 | {"getTestSampleIdx", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestSampleIdx, 0), "getTestSampleIdx() -> retval\n."}, |  | 75895 | {"getTestSampleIdx", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestSampleIdx, 0), "getTestSampleIdx() -> retval\n."},
| 75944 | {"getTestSampleWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestSampleWeights, 0), "getTestSampleWeights() -> retval\n."}, |  | 75896 | {"getTestSampleWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestSampleWeights, 0), "getTestSampleWeights() -> retval\n."},
| 75945 | {"getTestSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestSamples, 0), "getTestSamples() -> retval\n. @brief Returns matrix of test samples"}, |  | 75897 | {"getTestSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTestSamples, 0), "getTestSamples() -> retval\n. @brief Returns matrix of test samples"},
| 75946 | {"getTrainNormCatResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainNormCatResponses, 0), "getTrainNormCatResponses() -> retval\n. @brief Returns the vector of normalized categorical responses\n. \n. The function returns vector of responses. Each response is integer from `0` to `<number of\n. classes>-1`. The actual label value can be retrieved then from the class label vector, see\n. TrainData::getClassLabels."}, |  | 75898 | {"getTrainNormCatResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainNormCatResponses, 0), "getTrainNormCatResponses() -> retval\n. @brief Returns the vector of normalized categorical responses\n. \n. The function returns vector of responses. Each response is integer from `0` to `<number of\n. classes>-1`. The actual label value can be retrieved then from the class label vector, see\n. TrainData::getClassLabels."},
| 75947 | {"getTrainResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainResponses, 0), "getTrainResponses() -> retval\n. @brief Returns the vector of responses\n. \n. The function returns ordered or the original categorical responses. Usually it's used in\n. regression algorithms."}, |  | 75899 | {"getTrainResponses", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainResponses, 0), "getTrainResponses() -> retval\n. @brief Returns the vector of responses\n. \n. The function returns ordered or the original categorical responses. Usually it's used in\n. regression algorithms."},
| 75948 | {"getTrainSampleIdx", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainSampleIdx, 0), "getTrainSampleIdx() -> retval\n."}, |  | 75900 | {"getTrainSampleIdx", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainSampleIdx, 0), "getTrainSampleIdx() -> retval\n."},
| 75949 | {"getTrainSampleWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainSampleWeights, 0), "getTrainSampleWeights() -> retval\n."}, |  | 75901 | {"getTrainSampleWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainSampleWeights, 0), "getTrainSampleWeights() -> retval\n."},
| 75950 | {"getTrainSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainSamples, 0), "getTrainSamples([, layout[, compressSamples[, compressVars]]]) -> retval\n. @brief Returns matrix of train samples\n. \n. @param layout The requested layout. If it's different from the initial one, the matrix is\n. transposed. See ml::SampleTypes.\n. @param compressSamples if true, the function returns only the training samples (specified by\n. sampleIdx)\n. @param compressVars if true, the function returns the shorter training samples, containing only\n. the active variables.\n. \n. In current implementation the function tries to avoid physical data copying and returns the\n. matrix stored inside TrainData (unless the transposition or compression is needed)."}, |  | 75902 | {"getTrainSamples", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getTrainSamples, 0), "getTrainSamples([, layout[, compressSamples[, compressVars]]]) -> retval\n. @brief Returns matrix of train samples\n. \n. @param layout The requested layout. If it's different from the initial one, the matrix is\n. transposed. See ml::SampleTypes.\n. @param compressSamples if true, the function returns only the training samples (specified by\n. sampleIdx)\n. @param compressVars if true, the function returns the shorter training samples, containing only\n. the active variables.\n. \n. In current implementation the function tries to avoid physical data copying and returns the\n. matrix stored inside TrainData (unless the transposition or compression is needed)."},
| 75951 | {"getValues", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getValues, 0), "getValues(vi, sidx, values) -> None\n."}, |  | 75903 | {"getValues", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getValues, 0), "getValues(vi, sidx, values) -> None\n."},
| 75952 | {"getVarIdx", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getVarIdx, 0), "getVarIdx() -> retval\n."}, |  | 75904 | {"getVarIdx", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getVarIdx, 0), "getVarIdx() -> retval\n."},
| 75953 | {"getVarSymbolFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getVarSymbolFlags, 0), "getVarSymbolFlags() -> retval\n."}, |  | 75905 | {"getVarSymbolFlags", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getVarSymbolFlags, 0), "getVarSymbolFlags() -> retval\n."},
| 75954 | {"getVarType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getVarType, 0), "getVarType() -> retval\n."}, |  | 75906 | {"getVarType", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_getVarType, 0), "getVarType() -> retval\n."},
| 75955 | {"setTrainTestSplit", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_setTrainTestSplit, 0), "setTrainTestSplit(count[, shuffle]) -> None\n. @brief Splits the training data into the training and test parts\n. @sa TrainData::setTrainTestSplitRatio"}, |  | 75907 | {"setTrainTestSplit", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_setTrainTestSplit, 0), "setTrainTestSplit(count[, shuffle]) -> None\n. @brief Splits the training data into the training and test parts\n. @sa TrainData::setTrainTestSplitRatio"},
| 75956 | {"setTrainTestSplitRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_setTrainTestSplitRatio, 0), "setTrainTestSplitRatio(ratio[, shuffle]) -> None\n. @brief Splits the training data into the training and test parts\n. \n. The function selects a subset of specified relative size and then returns it as the training\n. set. If the function is not called, all the data is used for training. Please, note that for\n. each of TrainData::getTrain\\* there is corresponding TrainData::getTest\\*, so that the test\n. subset can be retrieved and processed as well.\n. @sa TrainData::setTrainTestSplit"}, |  | 75908 | {"setTrainTestSplitRatio", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_setTrainTestSplitRatio, 0), "setTrainTestSplitRatio(ratio[, shuffle]) -> None\n. @brief Splits the training data into the training and test parts\n. \n. The function selects a subset of specified relative size and then returns it as the training\n. set. If the function is not called, all the data is used for training. Please, note that for\n. each of TrainData::getTrain\\* there is corresponding TrainData::getTest\\*, so that the test\n. subset can be retrieved and processed as well.\n. @sa TrainData::setTrainTestSplit"},
| 75957 | {"shuffleTrainTest", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_shuffleTrainTest, 0), "shuffleTrainTest() -> None\n."}, |  | 75909 | {"shuffleTrainTest", CV_PY_FN_WITH_KW_(pyopencv_cv_ml_ml_TrainData_shuffleTrainTest, 0), "shuffleTrainTest() -> None\n."},
| 75958 |  |  | 75910 |
| 75959 | {NULL, NULL} |  | 75911 | {NULL, NULL}
| 75960 | }; |  | 75912 | };
| 75961 |  |  | 75913 |
| 75962 | // Converter (ml_TrainData) |  | 75914 | // Converter (ml_TrainData)
| 75963 |  |  | 75915 |
| 75964 | template<> |  | 75916 | template<>
| 75965 | struct PyOpenCV_Converter< Ptr<cv::ml::TrainData> > |  | 75917 | struct PyOpenCV_Converter< Ptr<cv::ml::TrainData> >
| 75966 | { |  | 75918 | {
| 75967 | static PyObject* from(const Ptr<cv::ml::TrainData>& r) |  | 75919 | static PyObject* from(const Ptr<cv::ml::TrainData>& r)
| 75968 | { |  | 75920 | {
| 75969 | return pyopencv_ml_TrainData_Instance(r); |  | 75921 | return pyopencv_ml_TrainData_Instance(r);
| 75970 | } |  | 75922 | }
| 75971 | static bool to(PyObject* src, Ptr<cv::ml::TrainData>& dst, const ArgInfo& info) |  | 75923 | static bool to(PyObject* src, Ptr<cv::ml::TrainData>& dst, const ArgInfo& info)
| 75972 | { |  | 75924 | {
| 75973 | if(!src || src == Py_None) |  | 75925 | if(!src || src == Py_None)
| 75974 | return true; |  | 75926 | return true;
| 75975 | Ptr<cv::ml::TrainData> * dst_; |  | 75927 | Ptr<cv::ml::TrainData> * dst_;
| 75976 | if (pyopencv_ml_TrainData_getp(src, dst_)) |  | 75928 | if (pyopencv_ml_TrainData_getp(src, dst_))
| 75977 | { |  | 75929 | {
| 75978 | dst = *dst_; |  | 75930 | dst = *dst_;
| 75979 | return true; |  | 75931 | return true;
| 75980 | } |  | 75932 | }
| 75981 |  |  | 75933 |
| 75982 | failmsg("Expected Ptr<cv::ml::TrainData> for argument '%s'", info.name); |  | 75934 | failmsg("Expected Ptr<cv::ml::TrainData> for argument '%s'", info.name);
| 75983 | return false; |  | 75935 | return false;
| 75984 | } |  | 75936 | }
| 75985 | }; |  | 75937 | };
| 75986 |  |  | 75938 |
| 75987 | //================================================================================ |  | 75939 | //================================================================================
| 75988 | // ocl_Device (Generic) |  | 75940 | // ocl_Device (Generic)
| 75989 | //================================================================================ |  | 75941 | //================================================================================
| 75990 |  |  | 75942 |
| 75991 | // GetSet (ocl_Device) |  | 75943 | // GetSet (ocl_Device)
| 75992 |  |  | 75944 |
| 75993 |  |  | 75945 |
| 75994 |  |  | 75946 |
| 75995 | // Methods (ocl_Device) |  | 75947 | // Methods (ocl_Device)
| 75996 |  |  | 75948 |
| 75997 | static int pyopencv_cv_ocl_ocl_Device_Device(pyopencv_ocl_Device_t* self, PyObject* py_args, PyObject* kw) |  | 75949 | static int pyopencv_cv_ocl_ocl_Device_Device(pyopencv_ocl_Device_t* self, PyObject* py_args, PyObject* kw)
| 75998 | { |  | 75950 | {
| 75999 | using namespace cv::ocl; |  | 75951 | using namespace cv::ocl;
| 76000 |  |  | 75952 |
| 76001 |  |  | 75953 |
| 76002 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75954 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76003 | { |  | 75955 | {
| 76004 | if(self) ERRWRAP2(new (&(self->v)) cv::ocl::Device()); |  | 75956 | if(self) ERRWRAP2(new (&(self->v)) cv::ocl::Device());
| 76005 | return 0; |  | 75957 | return 0;
| 76006 | } |  | 75958 | }
| 76007 |  |  | 75959 |
| 76008 | return -1; |  | 75960 | return -1;
| 76009 | } |  | 75961 | }
| 76010 |  |  | 75962 |
| 76011 | static PyObject* pyopencv_cv_ocl_ocl_Device_OpenCLVersion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75963 | static PyObject* pyopencv_cv_ocl_ocl_Device_OpenCLVersion(PyObject* self, PyObject* py_args, PyObject* kw)
| 76012 | { |  | 75964 | {
| 76013 | using namespace cv::ocl; |  | 75965 | using namespace cv::ocl;
| 76014 |  |  | 75966 |
| 76015 |  |  | 75967 |
| 76016 | cv::ocl::Device * self1 = 0; |  | 75968 | cv::ocl::Device * self1 = 0;
| 76017 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 75969 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76018 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 75970 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76019 | cv::ocl::Device* _self_ = (self1); |  | 75971 | cv::ocl::Device* _self_ = (self1);
| 76020 | String retval; |  | 75972 | String retval;
| 76021 |  |  | 75973 |
| 76022 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75974 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76023 | { |  | 75975 | {
| 76024 | ERRWRAP2(retval = _self_->OpenCLVersion()); |  | 75976 | ERRWRAP2(retval = _self_->OpenCLVersion());
| 76025 | return pyopencv_from(retval); |  | 75977 | return pyopencv_from(retval);
| 76026 | } |  | 75978 | }
| 76027 |  |  | 75979 |
| 76028 | return NULL; |  | 75980 | return NULL;
| 76029 | } |  | 75981 | }
| 76030 |  |  | 75982 |
| 76031 | static PyObject* pyopencv_cv_ocl_ocl_Device_OpenCL_C_Version(PyObject* self, PyObject* py_args, PyObject* kw) |  | 75983 | static PyObject* pyopencv_cv_ocl_ocl_Device_OpenCL_C_Version(PyObject* self, PyObject* py_args, PyObject* kw)
| 76032 | { |  | 75984 | {
| 76033 | using namespace cv::ocl; |  | 75985 | using namespace cv::ocl;
| 76034 |  |  | 75986 |
| 76035 |  |  | 75987 |
| 76036 | cv::ocl::Device * self1 = 0; |  | 75988 | cv::ocl::Device * self1 = 0;
| 76037 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 75989 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76038 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 75990 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76039 | cv::ocl::Device* _self_ = (self1); |  | 75991 | cv::ocl::Device* _self_ = (self1);
| 76040 | String retval; |  | 75992 | String retval;
| 76041 |  |  | 75993 |
| 76042 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 75994 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76043 | { |  | 75995 | {
| 76044 | ERRWRAP2(retval = _self_->OpenCL_C_Version()); |  | 75996 | ERRWRAP2(retval = _self_->OpenCL_C_Version());
| 76045 | return pyopencv_from(retval); |  | 75997 | return pyopencv_from(retval);
| 76046 | } |  | 75998 | }
| 76047 |  |  | 75999 |
| 76048 | return NULL; |  | 76000 | return NULL;
| 76049 | } |  | 76001 | }
| 76050 |  |  | 76002 |
| 76051 | static PyObject* pyopencv_cv_ocl_ocl_Device_addressBits(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76003 | static PyObject* pyopencv_cv_ocl_ocl_Device_addressBits(PyObject* self, PyObject* py_args, PyObject* kw)
| 76052 | { |  | 76004 | {
| 76053 | using namespace cv::ocl; |  | 76005 | using namespace cv::ocl;
| 76054 |  |  | 76006 |
| 76055 |  |  | 76007 |
| 76056 | cv::ocl::Device * self1 = 0; |  | 76008 | cv::ocl::Device * self1 = 0;
| 76057 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76009 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76058 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76010 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76059 | cv::ocl::Device* _self_ = (self1); |  | 76011 | cv::ocl::Device* _self_ = (self1);
| 76060 | int retval; |  | 76012 | int retval;
| 76061 |  |  | 76013 |
| 76062 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76014 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76063 | { |  | 76015 | {
| 76064 | ERRWRAP2(retval = _self_->addressBits()); |  | 76016 | ERRWRAP2(retval = _self_->addressBits());
| 76065 | return pyopencv_from(retval); |  | 76017 | return pyopencv_from(retval);
| 76066 | } |  | 76018 | }
| 76067 |  |  | 76019 |
| 76068 | return NULL; |  | 76020 | return NULL;
| 76069 | } |  | 76021 | }
| 76070 |  |  | 76022 |
| 76071 | static PyObject* pyopencv_cv_ocl_ocl_Device_available(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76023 | static PyObject* pyopencv_cv_ocl_ocl_Device_available(PyObject* self, PyObject* py_args, PyObject* kw)
| 76072 | { |  | 76024 | {
| 76073 | using namespace cv::ocl; |  | 76025 | using namespace cv::ocl;
| 76074 |  |  | 76026 |
| 76075 |  |  | 76027 |
| 76076 | cv::ocl::Device * self1 = 0; |  | 76028 | cv::ocl::Device * self1 = 0;
| 76077 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76029 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76078 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76030 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76079 | cv::ocl::Device* _self_ = (self1); |  | 76031 | cv::ocl::Device* _self_ = (self1);
| 76080 | bool retval; |  | 76032 | bool retval;
| 76081 |  |  | 76033 |
| 76082 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76034 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76083 | { |  | 76035 | {
| 76084 | ERRWRAP2(retval = _self_->available()); |  | 76036 | ERRWRAP2(retval = _self_->available());
| 76085 | return pyopencv_from(retval); |  | 76037 | return pyopencv_from(retval);
| 76086 | } |  | 76038 | }
| 76087 |  |  | 76039 |
| 76088 | return NULL; |  | 76040 | return NULL;
| 76089 | } |  | 76041 | }
| 76090 |  |  | 76042 |
| 76091 | static PyObject* pyopencv_cv_ocl_ocl_Device_compilerAvailable(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76043 | static PyObject* pyopencv_cv_ocl_ocl_Device_compilerAvailable(PyObject* self, PyObject* py_args, PyObject* kw)
| 76092 | { |  | 76044 | {
| 76093 | using namespace cv::ocl; |  | 76045 | using namespace cv::ocl;
| 76094 |  |  | 76046 |
| 76095 |  |  | 76047 |
| 76096 | cv::ocl::Device * self1 = 0; |  | 76048 | cv::ocl::Device * self1 = 0;
| 76097 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76049 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76098 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76050 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76099 | cv::ocl::Device* _self_ = (self1); |  | 76051 | cv::ocl::Device* _self_ = (self1);
| 76100 | bool retval; |  | 76052 | bool retval;
| 76101 |  |  | 76053 |
| 76102 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76054 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76103 | { |  | 76055 | {
| 76104 | ERRWRAP2(retval = _self_->compilerAvailable()); |  | 76056 | ERRWRAP2(retval = _self_->compilerAvailable());
| 76105 | return pyopencv_from(retval); |  | 76057 | return pyopencv_from(retval);
| 76106 | } |  | 76058 | }
| 76107 |  |  | 76059 |
| 76108 | return NULL; |  | 76060 | return NULL;
| 76109 | } |  | 76061 | }
| 76110 |  |  | 76062 |
| 76111 | static PyObject* pyopencv_cv_ocl_ocl_Device_deviceVersionMajor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76063 | static PyObject* pyopencv_cv_ocl_ocl_Device_deviceVersionMajor(PyObject* self, PyObject* py_args, PyObject* kw)
| 76112 | { |  | 76064 | {
| 76113 | using namespace cv::ocl; |  | 76065 | using namespace cv::ocl;
| 76114 |  |  | 76066 |
| 76115 |  |  | 76067 |
| 76116 | cv::ocl::Device * self1 = 0; |  | 76068 | cv::ocl::Device * self1 = 0;
| 76117 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76069 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76118 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76070 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76119 | cv::ocl::Device* _self_ = (self1); |  | 76071 | cv::ocl::Device* _self_ = (self1);
| 76120 | int retval; |  | 76072 | int retval;
| 76121 |  |  | 76073 |
| 76122 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76074 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76123 | { |  | 76075 | {
| 76124 | ERRWRAP2(retval = _self_->deviceVersionMajor()); |  | 76076 | ERRWRAP2(retval = _self_->deviceVersionMajor());
| 76125 | return pyopencv_from(retval); |  | 76077 | return pyopencv_from(retval);
| 76126 | } |  | 76078 | }
| 76127 |  |  | 76079 |
| 76128 | return NULL; |  | 76080 | return NULL;
| 76129 | } |  | 76081 | }
| 76130 |  |  | 76082 |
| 76131 | static PyObject* pyopencv_cv_ocl_ocl_Device_deviceVersionMinor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76083 | static PyObject* pyopencv_cv_ocl_ocl_Device_deviceVersionMinor(PyObject* self, PyObject* py_args, PyObject* kw)
| 76132 | { |  | 76084 | {
| 76133 | using namespace cv::ocl; |  | 76085 | using namespace cv::ocl;
| 76134 |  |  | 76086 |
| 76135 |  |  | 76087 |
| 76136 | cv::ocl::Device * self1 = 0; |  | 76088 | cv::ocl::Device * self1 = 0;
| 76137 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76089 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76138 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76090 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76139 | cv::ocl::Device* _self_ = (self1); |  | 76091 | cv::ocl::Device* _self_ = (self1);
| 76140 | int retval; |  | 76092 | int retval;
| 76141 |  |  | 76093 |
| 76142 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76094 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76143 | { |  | 76095 | {
| 76144 | ERRWRAP2(retval = _self_->deviceVersionMinor()); |  | 76096 | ERRWRAP2(retval = _self_->deviceVersionMinor());
| 76145 | return pyopencv_from(retval); |  | 76097 | return pyopencv_from(retval);
| 76146 | } |  | 76098 | }
| 76147 |  |  | 76099 |
| 76148 | return NULL; |  | 76100 | return NULL;
| 76149 | } |  | 76101 | }
| 76150 |  |  | 76102 |
| 76151 | static PyObject* pyopencv_cv_ocl_ocl_Device_doubleFPConfig(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76103 | static PyObject* pyopencv_cv_ocl_ocl_Device_doubleFPConfig(PyObject* self, PyObject* py_args, PyObject* kw)
| 76152 | { |  | 76104 | {
| 76153 | using namespace cv::ocl; |  | 76105 | using namespace cv::ocl;
| 76154 |  |  | 76106 |
| 76155 |  |  | 76107 |
| 76156 | cv::ocl::Device * self1 = 0; |  | 76108 | cv::ocl::Device * self1 = 0;
| 76157 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76109 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76158 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76110 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76159 | cv::ocl::Device* _self_ = (self1); |  | 76111 | cv::ocl::Device* _self_ = (self1);
| 76160 | int retval; |  | 76112 | int retval;
| 76161 |  |  | 76113 |
| 76162 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76114 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76163 | { |  | 76115 | {
| 76164 | ERRWRAP2(retval = _self_->doubleFPConfig()); |  | 76116 | ERRWRAP2(retval = _self_->doubleFPConfig());
| 76165 | return pyopencv_from(retval); |  | 76117 | return pyopencv_from(retval);
| 76166 | } |  | 76118 | }
| 76167 |  |  | 76119 |
| 76168 | return NULL; |  | 76120 | return NULL;
| 76169 | } |  | 76121 | }
| 76170 |  |  | 76122 |
| 76171 | static PyObject* pyopencv_cv_ocl_ocl_Device_driverVersion(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76123 | static PyObject* pyopencv_cv_ocl_ocl_Device_driverVersion(PyObject* self, PyObject* py_args, PyObject* kw)
| 76172 | { |  | 76124 | {
| 76173 | using namespace cv::ocl; |  | 76125 | using namespace cv::ocl;
| 76174 |  |  | 76126 |
| 76175 |  |  | 76127 |
| 76176 | cv::ocl::Device * self1 = 0; |  | 76128 | cv::ocl::Device * self1 = 0;
| 76177 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76129 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76178 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76130 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76179 | cv::ocl::Device* _self_ = (self1); |  | 76131 | cv::ocl::Device* _self_ = (self1);
| 76180 | String retval; |  | 76132 | String retval;
| 76181 |  |  | 76133 |
| 76182 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76134 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76183 | { |  | 76135 | {
| 76184 | ERRWRAP2(retval = _self_->driverVersion()); |  | 76136 | ERRWRAP2(retval = _self_->driverVersion());
| 76185 | return pyopencv_from(retval); |  | 76137 | return pyopencv_from(retval);
| 76186 | } |  | 76138 | }
| 76187 |  |  | 76139 |
| 76188 | return NULL; |  | 76140 | return NULL;
| 76189 | } |  | 76141 | }
| 76190 |  |  | 76142 |
| 76191 | static PyObject* pyopencv_cv_ocl_ocl_Device_endianLittle(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76143 | static PyObject* pyopencv_cv_ocl_ocl_Device_endianLittle(PyObject* self, PyObject* py_args, PyObject* kw)
| 76192 | { |  | 76144 | {
| 76193 | using namespace cv::ocl; |  | 76145 | using namespace cv::ocl;
| 76194 |  |  | 76146 |
| 76195 |  |  | 76147 |
| 76196 | cv::ocl::Device * self1 = 0; |  | 76148 | cv::ocl::Device * self1 = 0;
| 76197 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76149 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76198 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76150 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76199 | cv::ocl::Device* _self_ = (self1); |  | 76151 | cv::ocl::Device* _self_ = (self1);
| 76200 | bool retval; |  | 76152 | bool retval;
| 76201 |  |  | 76153 |
| 76202 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76154 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76203 | { |  | 76155 | {
| 76204 | ERRWRAP2(retval = _self_->endianLittle()); |  | 76156 | ERRWRAP2(retval = _self_->endianLittle());
| 76205 | return pyopencv_from(retval); |  | 76157 | return pyopencv_from(retval);
| 76206 | } |  | 76158 | }
| 76207 |  |  | 76159 |
| 76208 | return NULL; |  | 76160 | return NULL;
| 76209 | } |  | 76161 | }
| 76210 |  |  | 76162 |
| 76211 | static PyObject* pyopencv_cv_ocl_ocl_Device_errorCorrectionSupport(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76163 | static PyObject* pyopencv_cv_ocl_ocl_Device_errorCorrectionSupport(PyObject* self, PyObject* py_args, PyObject* kw)
| 76212 | { |  | 76164 | {
| 76213 | using namespace cv::ocl; |  | 76165 | using namespace cv::ocl;
| 76214 |  |  | 76166 |
| 76215 |  |  | 76167 |
| 76216 | cv::ocl::Device * self1 = 0; |  | 76168 | cv::ocl::Device * self1 = 0;
| 76217 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76169 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76218 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76170 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76219 | cv::ocl::Device* _self_ = (self1); |  | 76171 | cv::ocl::Device* _self_ = (self1);
| 76220 | bool retval; |  | 76172 | bool retval;
| 76221 |  |  | 76173 |
| 76222 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76174 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76223 | { |  | 76175 | {
| 76224 | ERRWRAP2(retval = _self_->errorCorrectionSupport()); |  | 76176 | ERRWRAP2(retval = _self_->errorCorrectionSupport());
| 76225 | return pyopencv_from(retval); |  | 76177 | return pyopencv_from(retval);
| 76226 | } |  | 76178 | }
| 76227 |  |  | 76179 |
| 76228 | return NULL; |  | 76180 | return NULL;
| 76229 | } |  | 76181 | }
| 76230 |  |  | 76182 |
| 76231 | static PyObject* pyopencv_cv_ocl_ocl_Device_executionCapabilities(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76183 | static PyObject* pyopencv_cv_ocl_ocl_Device_executionCapabilities(PyObject* self, PyObject* py_args, PyObject* kw)
| 76232 | { |  | 76184 | {
| 76233 | using namespace cv::ocl; |  | 76185 | using namespace cv::ocl;
| 76234 |  |  | 76186 |
| 76235 |  |  | 76187 |
| 76236 | cv::ocl::Device * self1 = 0; |  | 76188 | cv::ocl::Device * self1 = 0;
| 76237 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76189 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76238 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76190 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76239 | cv::ocl::Device* _self_ = (self1); |  | 76191 | cv::ocl::Device* _self_ = (self1);
| 76240 | int retval; |  | 76192 | int retval;
| 76241 |  |  | 76193 |
| 76242 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76194 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76243 | { |  | 76195 | {
| 76244 | ERRWRAP2(retval = _self_->executionCapabilities()); |  | 76196 | ERRWRAP2(retval = _self_->executionCapabilities());
| 76245 | return pyopencv_from(retval); |  | 76197 | return pyopencv_from(retval);
| 76246 | } |  | 76198 | }
| 76247 |  |  | 76199 |
| 76248 | return NULL; |  | 76200 | return NULL;
| 76249 | } |  | 76201 | }
| 76250 |  |  | 76202 |
| 76251 | static PyObject* pyopencv_cv_ocl_ocl_Device_extensions(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76203 | static PyObject* pyopencv_cv_ocl_ocl_Device_extensions(PyObject* self, PyObject* py_args, PyObject* kw)
| 76252 | { |  | 76204 | {
| 76253 | using namespace cv::ocl; |  | 76205 | using namespace cv::ocl;
| 76254 |  |  | 76206 |
| 76255 |  |  | 76207 |
| 76256 | cv::ocl::Device * self1 = 0; |  | 76208 | cv::ocl::Device * self1 = 0;
| 76257 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76209 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76258 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76210 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76259 | cv::ocl::Device* _self_ = (self1); |  | 76211 | cv::ocl::Device* _self_ = (self1);
| 76260 | String retval; |  | 76212 | String retval;
| 76261 |  |  | 76213 |
| 76262 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76214 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76263 | { |  | 76215 | {
| 76264 | ERRWRAP2(retval = _self_->extensions()); |  | 76216 | ERRWRAP2(retval = _self_->extensions());
| 76265 | return pyopencv_from(retval); |  | 76217 | return pyopencv_from(retval);
| 76266 | } |  | 76218 | }
| 76267 |  |  | 76219 |
| 76268 | return NULL; |  | 76220 | return NULL;
| 76269 | } |  | 76221 | }
| 76270 |  |  | 76222 |
| 76271 | static PyObject* pyopencv_cv_ocl_ocl_Device_getDefault_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76223 | static PyObject* pyopencv_cv_ocl_ocl_Device_getDefault_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 76272 | { |  | 76224 | {
| 76273 | using namespace cv::ocl; |  | 76225 | using namespace cv::ocl;
| 76274 |  |  | 76226 |
| 76275 | Device retval; |  | 76227 | Device retval;
| 76276 |  |  | 76228 |
| 76277 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76229 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76278 | { |  | 76230 | {
| 76279 | ERRWRAP2(retval = cv::ocl::Device::getDefault()); |  | 76231 | ERRWRAP2(retval = cv::ocl::Device::getDefault());
| 76280 | return pyopencv_from(retval); |  | 76232 | return pyopencv_from(retval);
| 76281 | } |  | 76233 | }
| 76282 |  |  | 76234 |
| 76283 | return NULL; |  | 76235 | return NULL;
| 76284 | } |  | 76236 | }
| 76285 |  |  | 76237 |
| 76286 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemCacheLineSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76238 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemCacheLineSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76287 | { |  | 76239 | {
| 76288 | using namespace cv::ocl; |  | 76240 | using namespace cv::ocl;
| 76289 |  |  | 76241 |
| 76290 |  |  | 76242 |
| 76291 | cv::ocl::Device * self1 = 0; |  | 76243 | cv::ocl::Device * self1 = 0;
| 76292 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76244 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76293 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76245 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76294 | cv::ocl::Device* _self_ = (self1); |  | 76246 | cv::ocl::Device* _self_ = (self1);
| 76295 | int retval; |  | 76247 | int retval;
| 76296 |  |  | 76248 |
| 76297 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76249 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76298 | { |  | 76250 | {
| 76299 | ERRWRAP2(retval = _self_->globalMemCacheLineSize()); |  | 76251 | ERRWRAP2(retval = _self_->globalMemCacheLineSize());
| 76300 | return pyopencv_from(retval); |  | 76252 | return pyopencv_from(retval);
| 76301 | } |  | 76253 | }
| 76302 |  |  | 76254 |
| 76303 | return NULL; |  | 76255 | return NULL;
| 76304 | } |  | 76256 | }
| 76305 |  |  | 76257 |
| 76306 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemCacheSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76258 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemCacheSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76307 | { |  | 76259 | {
| 76308 | using namespace cv::ocl; |  | 76260 | using namespace cv::ocl;
| 76309 |  |  | 76261 |
| 76310 |  |  | 76262 |
| 76311 | cv::ocl::Device * self1 = 0; |  | 76263 | cv::ocl::Device * self1 = 0;
| 76312 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76264 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76313 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76265 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76314 | cv::ocl::Device* _self_ = (self1); |  | 76266 | cv::ocl::Device* _self_ = (self1);
| 76315 | size_t retval; |  | 76267 | size_t retval;
| 76316 |  |  | 76268 |
| 76317 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76269 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76318 | { |  | 76270 | {
| 76319 | ERRWRAP2(retval = _self_->globalMemCacheSize()); |  | 76271 | ERRWRAP2(retval = _self_->globalMemCacheSize());
| 76320 | return pyopencv_from(retval); |  | 76272 | return pyopencv_from(retval);
| 76321 | } |  | 76273 | }
| 76322 |  |  | 76274 |
| 76323 | return NULL; |  | 76275 | return NULL;
| 76324 | } |  | 76276 | }
| 76325 |  |  | 76277 |
| 76326 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemCacheType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76278 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemCacheType(PyObject* self, PyObject* py_args, PyObject* kw)
| 76327 | { |  | 76279 | {
| 76328 | using namespace cv::ocl; |  | 76280 | using namespace cv::ocl;
| 76329 |  |  | 76281 |
| 76330 |  |  | 76282 |
| 76331 | cv::ocl::Device * self1 = 0; |  | 76283 | cv::ocl::Device * self1 = 0;
| 76332 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76284 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76333 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76285 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76334 | cv::ocl::Device* _self_ = (self1); |  | 76286 | cv::ocl::Device* _self_ = (self1);
| 76335 | int retval; |  | 76287 | int retval;
| 76336 |  |  | 76288 |
| 76337 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76289 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76338 | { |  | 76290 | {
| 76339 | ERRWRAP2(retval = _self_->globalMemCacheType()); |  | 76291 | ERRWRAP2(retval = _self_->globalMemCacheType());
| 76340 | return pyopencv_from(retval); |  | 76292 | return pyopencv_from(retval);
| 76341 | } |  | 76293 | }
| 76342 |  |  | 76294 |
| 76343 | return NULL; |  | 76295 | return NULL;
| 76344 | } |  | 76296 | }
| 76345 |  |  | 76297 |
| 76346 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76298 | static PyObject* pyopencv_cv_ocl_ocl_Device_globalMemSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76347 | { |  | 76299 | {
| 76348 | using namespace cv::ocl; |  | 76300 | using namespace cv::ocl;
| 76349 |  |  | 76301 |
| 76350 |  |  | 76302 |
| 76351 | cv::ocl::Device * self1 = 0; |  | 76303 | cv::ocl::Device * self1 = 0;
| 76352 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76304 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76353 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76305 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76354 | cv::ocl::Device* _self_ = (self1); |  | 76306 | cv::ocl::Device* _self_ = (self1);
| 76355 | size_t retval; |  | 76307 | size_t retval;
| 76356 |  |  | 76308 |
| 76357 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76309 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76358 | { |  | 76310 | {
| 76359 | ERRWRAP2(retval = _self_->globalMemSize()); |  | 76311 | ERRWRAP2(retval = _self_->globalMemSize());
| 76360 | return pyopencv_from(retval); |  | 76312 | return pyopencv_from(retval);
| 76361 | } |  | 76313 | }
| 76362 |  |  | 76314 |
| 76363 | return NULL; |  | 76315 | return NULL;
| 76364 | } |  | 76316 | }
| 76365 |  |  | 76317 |
| 76366 | static PyObject* pyopencv_cv_ocl_ocl_Device_halfFPConfig(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76318 | static PyObject* pyopencv_cv_ocl_ocl_Device_halfFPConfig(PyObject* self, PyObject* py_args, PyObject* kw)
| 76367 | { |  | 76319 | {
| 76368 | using namespace cv::ocl; |  | 76320 | using namespace cv::ocl;
| 76369 |  |  | 76321 |
| 76370 |  |  | 76322 |
| 76371 | cv::ocl::Device * self1 = 0; |  | 76323 | cv::ocl::Device * self1 = 0;
| 76372 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76324 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76373 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76325 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76374 | cv::ocl::Device* _self_ = (self1); |  | 76326 | cv::ocl::Device* _self_ = (self1);
| 76375 | int retval; |  | 76327 | int retval;
| 76376 |  |  | 76328 |
| 76377 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76329 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76378 | { |  | 76330 | {
| 76379 | ERRWRAP2(retval = _self_->halfFPConfig()); |  | 76331 | ERRWRAP2(retval = _self_->halfFPConfig());
| 76380 | return pyopencv_from(retval); |  | 76332 | return pyopencv_from(retval);
| 76381 | } |  | 76333 | }
| 76382 |  |  | 76334 |
| 76383 | return NULL; |  | 76335 | return NULL;
| 76384 | } |  | 76336 | }
| 76385 |  |  | 76337 |
| 76386 | static PyObject* pyopencv_cv_ocl_ocl_Device_hasFP16(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76338 | static PyObject* pyopencv_cv_ocl_ocl_Device_hasFP16(PyObject* self, PyObject* py_args, PyObject* kw)
| 76387 | { |  | 76339 | {
| 76388 | using namespace cv::ocl; |  | 76340 | using namespace cv::ocl;
| 76389 |  |  | 76341 |
| 76390 |  |  | 76342 |
| 76391 | cv::ocl::Device * self1 = 0; |  | 76343 | cv::ocl::Device * self1 = 0;
| 76392 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76344 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76393 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76345 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76394 | cv::ocl::Device* _self_ = (self1); |  | 76346 | cv::ocl::Device* _self_ = (self1);
| 76395 | bool retval; |  | 76347 | bool retval;
| 76396 |  |  | 76348 |
| 76397 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76349 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76398 | { |  | 76350 | {
| 76399 | ERRWRAP2(retval = _self_->hasFP16()); |  | 76351 | ERRWRAP2(retval = _self_->hasFP16());
| 76400 | return pyopencv_from(retval); |  | 76352 | return pyopencv_from(retval);
| 76401 | } |  | 76353 | }
| 76402 |  |  | 76354 |
| 76403 | return NULL; |  | 76355 | return NULL;
| 76404 | } |  | 76356 | }
| 76405 |  |  | 76357 |
| 76406 | static PyObject* pyopencv_cv_ocl_ocl_Device_hasFP64(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76358 | static PyObject* pyopencv_cv_ocl_ocl_Device_hasFP64(PyObject* self, PyObject* py_args, PyObject* kw)
| 76407 | { |  | 76359 | {
| 76408 | using namespace cv::ocl; |  | 76360 | using namespace cv::ocl;
| 76409 |  |  | 76361 |
| 76410 |  |  | 76362 |
| 76411 | cv::ocl::Device * self1 = 0; |  | 76363 | cv::ocl::Device * self1 = 0;
| 76412 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76364 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76413 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76365 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76414 | cv::ocl::Device* _self_ = (self1); |  | 76366 | cv::ocl::Device* _self_ = (self1);
| 76415 | bool retval; |  | 76367 | bool retval;
| 76416 |  |  | 76368 |
| 76417 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76369 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76418 | { |  | 76370 | {
| 76419 | ERRWRAP2(retval = _self_->hasFP64()); |  | 76371 | ERRWRAP2(retval = _self_->hasFP64());
| 76420 | return pyopencv_from(retval); |  | 76372 | return pyopencv_from(retval);
| 76421 | } |  | 76373 | }
| 76422 |  |  | 76374 |
| 76423 | return NULL; |  | 76375 | return NULL;
| 76424 | } |  | 76376 | }
| 76425 |  |  | 76377 |
| 76426 | static PyObject* pyopencv_cv_ocl_ocl_Device_hostUnifiedMemory(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76378 | static PyObject* pyopencv_cv_ocl_ocl_Device_hostUnifiedMemory(PyObject* self, PyObject* py_args, PyObject* kw)
| 76427 | { |  | 76379 | {
| 76428 | using namespace cv::ocl; |  | 76380 | using namespace cv::ocl;
| 76429 |  |  | 76381 |
| 76430 |  |  | 76382 |
| 76431 | cv::ocl::Device * self1 = 0; |  | 76383 | cv::ocl::Device * self1 = 0;
| 76432 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76384 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76433 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76385 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76434 | cv::ocl::Device* _self_ = (self1); |  | 76386 | cv::ocl::Device* _self_ = (self1);
| 76435 | bool retval; |  | 76387 | bool retval;
| 76436 |  |  | 76388 |
| 76437 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76389 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76438 | { |  | 76390 | {
| 76439 | ERRWRAP2(retval = _self_->hostUnifiedMemory()); |  | 76391 | ERRWRAP2(retval = _self_->hostUnifiedMemory());
| 76440 | return pyopencv_from(retval); |  | 76392 | return pyopencv_from(retval);
| 76441 | } |  | 76393 | }
| 76442 |  |  | 76394 |
| 76443 | return NULL; |  | 76395 | return NULL;
| 76444 | } |  | 76396 | }
| 76445 |  |  | 76397 |
| 76446 | static PyObject* pyopencv_cv_ocl_ocl_Device_image2DMaxHeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76398 | static PyObject* pyopencv_cv_ocl_ocl_Device_image2DMaxHeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 76447 | { |  | 76399 | {
| 76448 | using namespace cv::ocl; |  | 76400 | using namespace cv::ocl;
| 76449 |  |  | 76401 |
| 76450 |  |  | 76402 |
| 76451 | cv::ocl::Device * self1 = 0; |  | 76403 | cv::ocl::Device * self1 = 0;
| 76452 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76404 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76453 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76405 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76454 | cv::ocl::Device* _self_ = (self1); |  | 76406 | cv::ocl::Device* _self_ = (self1);
| 76455 | size_t retval; |  | 76407 | size_t retval;
| 76456 |  |  | 76408 |
| 76457 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76409 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76458 | { |  | 76410 | {
| 76459 | ERRWRAP2(retval = _self_->image2DMaxHeight()); |  | 76411 | ERRWRAP2(retval = _self_->image2DMaxHeight());
| 76460 | return pyopencv_from(retval); |  | 76412 | return pyopencv_from(retval);
| 76461 | } |  | 76413 | }
| 76462 |  |  | 76414 |
| 76463 | return NULL; |  | 76415 | return NULL;
| 76464 | } |  | 76416 | }
| 76465 |  |  | 76417 |
| 76466 | static PyObject* pyopencv_cv_ocl_ocl_Device_image2DMaxWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76418 | static PyObject* pyopencv_cv_ocl_ocl_Device_image2DMaxWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 76467 | { |  | 76419 | {
| 76468 | using namespace cv::ocl; |  | 76420 | using namespace cv::ocl;
| 76469 |  |  | 76421 |
| 76470 |  |  | 76422 |
| 76471 | cv::ocl::Device * self1 = 0; |  | 76423 | cv::ocl::Device * self1 = 0;
| 76472 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76424 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76473 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76425 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76474 | cv::ocl::Device* _self_ = (self1); |  | 76426 | cv::ocl::Device* _self_ = (self1);
| 76475 | size_t retval; |  | 76427 | size_t retval;
| 76476 |  |  | 76428 |
| 76477 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76429 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76478 | { |  | 76430 | {
| 76479 | ERRWRAP2(retval = _self_->image2DMaxWidth()); |  | 76431 | ERRWRAP2(retval = _self_->image2DMaxWidth());
| 76480 | return pyopencv_from(retval); |  | 76432 | return pyopencv_from(retval);
| 76481 | } |  | 76433 | }
| 76482 |  |  | 76434 |
| 76483 | return NULL; |  | 76435 | return NULL;
| 76484 | } |  | 76436 | }
| 76485 |  |  | 76437 |
| 76486 | static PyObject* pyopencv_cv_ocl_ocl_Device_image3DMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76438 | static PyObject* pyopencv_cv_ocl_ocl_Device_image3DMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 76487 | { |  | 76439 | {
| 76488 | using namespace cv::ocl; |  | 76440 | using namespace cv::ocl;
| 76489 |  |  | 76441 |
| 76490 |  |  | 76442 |
| 76491 | cv::ocl::Device * self1 = 0; |  | 76443 | cv::ocl::Device * self1 = 0;
| 76492 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76444 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76493 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76445 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76494 | cv::ocl::Device* _self_ = (self1); |  | 76446 | cv::ocl::Device* _self_ = (self1);
| 76495 | size_t retval; |  | 76447 | size_t retval;
| 76496 |  |  | 76448 |
| 76497 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76449 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76498 | { |  | 76450 | {
| 76499 | ERRWRAP2(retval = _self_->image3DMaxDepth()); |  | 76451 | ERRWRAP2(retval = _self_->image3DMaxDepth());
| 76500 | return pyopencv_from(retval); |  | 76452 | return pyopencv_from(retval);
| 76501 | } |  | 76453 | }
| 76502 |  |  | 76454 |
| 76503 | return NULL; |  | 76455 | return NULL;
| 76504 | } |  | 76456 | }
| 76505 |  |  | 76457 |
| 76506 | static PyObject* pyopencv_cv_ocl_ocl_Device_image3DMaxHeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76458 | static PyObject* pyopencv_cv_ocl_ocl_Device_image3DMaxHeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 76507 | { |  | 76459 | {
| 76508 | using namespace cv::ocl; |  | 76460 | using namespace cv::ocl;
| 76509 |  |  | 76461 |
| 76510 |  |  | 76462 |
| 76511 | cv::ocl::Device * self1 = 0; |  | 76463 | cv::ocl::Device * self1 = 0;
| 76512 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76464 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76513 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76465 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76514 | cv::ocl::Device* _self_ = (self1); |  | 76466 | cv::ocl::Device* _self_ = (self1);
| 76515 | size_t retval; |  | 76467 | size_t retval;
| 76516 |  |  | 76468 |
| 76517 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76469 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76518 | { |  | 76470 | {
| 76519 | ERRWRAP2(retval = _self_->image3DMaxHeight()); |  | 76471 | ERRWRAP2(retval = _self_->image3DMaxHeight());
| 76520 | return pyopencv_from(retval); |  | 76472 | return pyopencv_from(retval);
| 76521 | } |  | 76473 | }
| 76522 |  |  | 76474 |
| 76523 | return NULL; |  | 76475 | return NULL;
| 76524 | } |  | 76476 | }
| 76525 |  |  | 76477 |
| 76526 | static PyObject* pyopencv_cv_ocl_ocl_Device_image3DMaxWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76478 | static PyObject* pyopencv_cv_ocl_ocl_Device_image3DMaxWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 76527 | { |  | 76479 | {
| 76528 | using namespace cv::ocl; |  | 76480 | using namespace cv::ocl;
| 76529 |  |  | 76481 |
| 76530 |  |  | 76482 |
| 76531 | cv::ocl::Device * self1 = 0; |  | 76483 | cv::ocl::Device * self1 = 0;
| 76532 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76484 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76533 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76485 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76534 | cv::ocl::Device* _self_ = (self1); |  | 76486 | cv::ocl::Device* _self_ = (self1);
| 76535 | size_t retval; |  | 76487 | size_t retval;
| 76536 |  |  | 76488 |
| 76537 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76489 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76538 | { |  | 76490 | {
| 76539 | ERRWRAP2(retval = _self_->image3DMaxWidth()); |  | 76491 | ERRWRAP2(retval = _self_->image3DMaxWidth());
| 76540 | return pyopencv_from(retval); |  | 76492 | return pyopencv_from(retval);
| 76541 | } |  | 76493 | }
| 76542 |  |  | 76494 |
| 76543 | return NULL; |  | 76495 | return NULL;
| 76544 | } |  | 76496 | }
| 76545 |  |  | 76497 |
| 76546 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageFromBufferSupport(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76498 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageFromBufferSupport(PyObject* self, PyObject* py_args, PyObject* kw)
| 76547 | { |  | 76499 | {
| 76548 | using namespace cv::ocl; |  | 76500 | using namespace cv::ocl;
| 76549 |  |  | 76501 |
| 76550 |  |  | 76502 |
| 76551 | cv::ocl::Device * self1 = 0; |  | 76503 | cv::ocl::Device * self1 = 0;
| 76552 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76504 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76553 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76505 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76554 | cv::ocl::Device* _self_ = (self1); |  | 76506 | cv::ocl::Device* _self_ = (self1);
| 76555 | bool retval; |  | 76507 | bool retval;
| 76556 |  |  | 76508 |
| 76557 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76509 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76558 | { |  | 76510 | {
| 76559 | ERRWRAP2(retval = _self_->imageFromBufferSupport()); |  | 76511 | ERRWRAP2(retval = _self_->imageFromBufferSupport());
| 76560 | return pyopencv_from(retval); |  | 76512 | return pyopencv_from(retval);
| 76561 | } |  | 76513 | }
| 76562 |  |  | 76514 |
| 76563 | return NULL; |  | 76515 | return NULL;
| 76564 | } |  | 76516 | }
| 76565 |  |  | 76517 |
| 76566 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageMaxArraySize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76518 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageMaxArraySize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76567 | { |  | 76519 | {
| 76568 | using namespace cv::ocl; |  | 76520 | using namespace cv::ocl;
| 76569 |  |  | 76521 |
| 76570 |  |  | 76522 |
| 76571 | cv::ocl::Device * self1 = 0; |  | 76523 | cv::ocl::Device * self1 = 0;
| 76572 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76524 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76573 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76525 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76574 | cv::ocl::Device* _self_ = (self1); |  | 76526 | cv::ocl::Device* _self_ = (self1);
| 76575 | size_t retval; |  | 76527 | size_t retval;
| 76576 |  |  | 76528 |
| 76577 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76529 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76578 | { |  | 76530 | {
| 76579 | ERRWRAP2(retval = _self_->imageMaxArraySize()); |  | 76531 | ERRWRAP2(retval = _self_->imageMaxArraySize());
| 76580 | return pyopencv_from(retval); |  | 76532 | return pyopencv_from(retval);
| 76581 | } |  | 76533 | }
| 76582 |  |  | 76534 |
| 76583 | return NULL; |  | 76535 | return NULL;
| 76584 | } |  | 76536 | }
| 76585 |  |  | 76537 |
| 76586 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageMaxBufferSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76538 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageMaxBufferSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76587 | { |  | 76539 | {
| 76588 | using namespace cv::ocl; |  | 76540 | using namespace cv::ocl;
| 76589 |  |  | 76541 |
| 76590 |  |  | 76542 |
| 76591 | cv::ocl::Device * self1 = 0; |  | 76543 | cv::ocl::Device * self1 = 0;
| 76592 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76544 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76593 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76545 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76594 | cv::ocl::Device* _self_ = (self1); |  | 76546 | cv::ocl::Device* _self_ = (self1);
| 76595 | size_t retval; |  | 76547 | size_t retval;
| 76596 |  |  | 76548 |
| 76597 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76549 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76598 | { |  | 76550 | {
| 76599 | ERRWRAP2(retval = _self_->imageMaxBufferSize()); |  | 76551 | ERRWRAP2(retval = _self_->imageMaxBufferSize());
| 76600 | return pyopencv_from(retval); |  | 76552 | return pyopencv_from(retval);
| 76601 | } |  | 76553 | }
| 76602 |  |  | 76554 |
| 76603 | return NULL; |  | 76555 | return NULL;
| 76604 | } |  | 76556 | }
| 76605 |  |  | 76557 |
| 76606 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageSupport(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76558 | static PyObject* pyopencv_cv_ocl_ocl_Device_imageSupport(PyObject* self, PyObject* py_args, PyObject* kw)
| 76607 | { |  | 76559 | {
| 76608 | using namespace cv::ocl; |  | 76560 | using namespace cv::ocl;
| 76609 |  |  | 76561 |
| 76610 |  |  | 76562 |
| 76611 | cv::ocl::Device * self1 = 0; |  | 76563 | cv::ocl::Device * self1 = 0;
| 76612 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76564 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76613 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76565 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76614 | cv::ocl::Device* _self_ = (self1); |  | 76566 | cv::ocl::Device* _self_ = (self1);
| 76615 | bool retval; |  | 76567 | bool retval;
| 76616 |  |  | 76568 |
| 76617 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76569 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76618 | { |  | 76570 | {
| 76619 | ERRWRAP2(retval = _self_->imageSupport()); |  | 76571 | ERRWRAP2(retval = _self_->imageSupport());
| 76620 | return pyopencv_from(retval); |  | 76572 | return pyopencv_from(retval);
| 76621 | } |  | 76573 | }
| 76622 |  |  | 76574 |
| 76623 | return NULL; |  | 76575 | return NULL;
| 76624 | } |  | 76576 | }
| 76625 |  |  | 76577 |
| 76626 | static PyObject* pyopencv_cv_ocl_ocl_Device_intelSubgroupsSupport(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76578 | static PyObject* pyopencv_cv_ocl_ocl_Device_intelSubgroupsSupport(PyObject* self, PyObject* py_args, PyObject* kw)
| 76627 | { |  | 76579 | {
| 76628 | using namespace cv::ocl; |  | 76580 | using namespace cv::ocl;
| 76629 |  |  | 76581 |
| 76630 |  |  | 76582 |
| 76631 | cv::ocl::Device * self1 = 0; |  | 76583 | cv::ocl::Device * self1 = 0;
| 76632 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76584 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76633 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76585 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76634 | cv::ocl::Device* _self_ = (self1); |  | 76586 | cv::ocl::Device* _self_ = (self1);
| 76635 | bool retval; |  | 76587 | bool retval;
| 76636 |  |  | 76588 |
| 76637 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76589 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76638 | { |  | 76590 | {
| 76639 | ERRWRAP2(retval = _self_->intelSubgroupsSupport()); |  | 76591 | ERRWRAP2(retval = _self_->intelSubgroupsSupport());
| 76640 | return pyopencv_from(retval); |  | 76592 | return pyopencv_from(retval);
| 76641 | } |  | 76593 | }
| 76642 |  |  | 76594 |
| 76643 | return NULL; |  | 76595 | return NULL;
| 76644 | } |  | 76596 | }
| 76645 |  |  | 76597 |
| 76646 | static PyObject* pyopencv_cv_ocl_ocl_Device_isAMD(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76598 | static PyObject* pyopencv_cv_ocl_ocl_Device_isAMD(PyObject* self, PyObject* py_args, PyObject* kw)
| 76647 | { |  | 76599 | {
| 76648 | using namespace cv::ocl; |  | 76600 | using namespace cv::ocl;
| 76649 |  |  | 76601 |
| 76650 |  |  | 76602 |
| 76651 | cv::ocl::Device * self1 = 0; |  | 76603 | cv::ocl::Device * self1 = 0;
| 76652 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76604 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76653 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76605 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76654 | cv::ocl::Device* _self_ = (self1); |  | 76606 | cv::ocl::Device* _self_ = (self1);
| 76655 | bool retval; |  | 76607 | bool retval;
| 76656 |  |  | 76608 |
| 76657 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76609 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76658 | { |  | 76610 | {
| 76659 | ERRWRAP2(retval = _self_->isAMD()); |  | 76611 | ERRWRAP2(retval = _self_->isAMD());
| 76660 | return pyopencv_from(retval); |  | 76612 | return pyopencv_from(retval);
| 76661 | } |  | 76613 | }
| 76662 |  |  | 76614 |
| 76663 | return NULL; |  | 76615 | return NULL;
| 76664 | } |  | 76616 | }
| 76665 |  |  | 76617 |
| 76666 | static PyObject* pyopencv_cv_ocl_ocl_Device_isExtensionSupported(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76618 | static PyObject* pyopencv_cv_ocl_ocl_Device_isExtensionSupported(PyObject* self, PyObject* py_args, PyObject* kw)
| 76667 | { |  | 76619 | {
| 76668 | using namespace cv::ocl; |  | 76620 | using namespace cv::ocl;
| 76669 |  |  | 76621 |
| 76670 |  |  | 76622 |
| 76671 | cv::ocl::Device * self1 = 0; |  | 76623 | cv::ocl::Device * self1 = 0;
| 76672 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76624 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76673 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76625 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76674 | cv::ocl::Device* _self_ = (self1); |  | 76626 | cv::ocl::Device* _self_ = (self1);
| 76675 | PyObject* pyobj_extensionName = NULL; |  | 76627 | PyObject* pyobj_extensionName = NULL;
| 76676 | String extensionName; |  | 76628 | String extensionName;
| 76677 | bool retval; |  | 76629 | bool retval;
| 76678 |  |  | 76630 |
| 76679 | const char* keywords[] = { "extensionName", NULL }; |  | 76631 | const char* keywords[] = { "extensionName", NULL };
| 76680 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ocl_Device.isExtensionSupported", (char**)keywords, &pyobj_extensionName) && |  | 76632 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ocl_Device.isExtensionSupported", (char**)keywords, &pyobj_extensionName) &&
| 76681 | pyopencv_to_safe(pyobj_extensionName, extensionName, ArgInfo("extensionName", 0)) ) |  | 76633 | pyopencv_to_safe(pyobj_extensionName, extensionName, ArgInfo("extensionName", 0)) )
| 76682 | { |  | 76634 | {
| 76683 | ERRWRAP2(retval = _self_->isExtensionSupported(extensionName)); |  | 76635 | ERRWRAP2(retval = _self_->isExtensionSupported(extensionName));
| 76684 | return pyopencv_from(retval); |  | 76636 | return pyopencv_from(retval);
| 76685 | } |  | 76637 | }
| 76686 |  |  | 76638 |
| 76687 | return NULL; |  | 76639 | return NULL;
| 76688 | } |  | 76640 | }
| 76689 |  |  | 76641 |
| 76690 | static PyObject* pyopencv_cv_ocl_ocl_Device_isIntel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76642 | static PyObject* pyopencv_cv_ocl_ocl_Device_isIntel(PyObject* self, PyObject* py_args, PyObject* kw)
| 76691 | { |  | 76643 | {
| 76692 | using namespace cv::ocl; |  | 76644 | using namespace cv::ocl;
| 76693 |  |  | 76645 |
| 76694 |  |  | 76646 |
| 76695 | cv::ocl::Device * self1 = 0; |  | 76647 | cv::ocl::Device * self1 = 0;
| 76696 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76648 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76697 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76649 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76698 | cv::ocl::Device* _self_ = (self1); |  | 76650 | cv::ocl::Device* _self_ = (self1);
| 76699 | bool retval; |  | 76651 | bool retval;
| 76700 |  |  | 76652 |
| 76701 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76653 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76702 | { |  | 76654 | {
| 76703 | ERRWRAP2(retval = _self_->isIntel()); |  | 76655 | ERRWRAP2(retval = _self_->isIntel());
| 76704 | return pyopencv_from(retval); |  | 76656 | return pyopencv_from(retval);
| 76705 | } |  | 76657 | }
| 76706 |  |  | 76658 |
| 76707 | return NULL; |  | 76659 | return NULL;
| 76708 | } |  | 76660 | }
| 76709 |  |  | 76661 |
| 76710 | static PyObject* pyopencv_cv_ocl_ocl_Device_isNVidia(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76662 | static PyObject* pyopencv_cv_ocl_ocl_Device_isNVidia(PyObject* self, PyObject* py_args, PyObject* kw)
| 76711 | { |  | 76663 | {
| 76712 | using namespace cv::ocl; |  | 76664 | using namespace cv::ocl;
| 76713 |  |  | 76665 |
| 76714 |  |  | 76666 |
| 76715 | cv::ocl::Device * self1 = 0; |  | 76667 | cv::ocl::Device * self1 = 0;
| 76716 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76668 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76717 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76669 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76718 | cv::ocl::Device* _self_ = (self1); |  | 76670 | cv::ocl::Device* _self_ = (self1);
| 76719 | bool retval; |  | 76671 | bool retval;
| 76720 |  |  | 76672 |
| 76721 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76673 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76722 | { |  | 76674 | {
| 76723 | ERRWRAP2(retval = _self_->isNVidia()); |  | 76675 | ERRWRAP2(retval = _self_->isNVidia());
| 76724 | return pyopencv_from(retval); |  | 76676 | return pyopencv_from(retval);
| 76725 | } |  | 76677 | }
| 76726 |  |  | 76678 |
| 76727 | return NULL; |  | 76679 | return NULL;
| 76728 | } |  | 76680 | }
| 76729 |  |  | 76681 |
| 76730 | static PyObject* pyopencv_cv_ocl_ocl_Device_linkerAvailable(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76682 | static PyObject* pyopencv_cv_ocl_ocl_Device_linkerAvailable(PyObject* self, PyObject* py_args, PyObject* kw)
| 76731 | { |  | 76683 | {
| 76732 | using namespace cv::ocl; |  | 76684 | using namespace cv::ocl;
| 76733 |  |  | 76685 |
| 76734 |  |  | 76686 |
| 76735 | cv::ocl::Device * self1 = 0; |  | 76687 | cv::ocl::Device * self1 = 0;
| 76736 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76688 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76737 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76689 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76738 | cv::ocl::Device* _self_ = (self1); |  | 76690 | cv::ocl::Device* _self_ = (self1);
| 76739 | bool retval; |  | 76691 | bool retval;
| 76740 |  |  | 76692 |
| 76741 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76693 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76742 | { |  | 76694 | {
| 76743 | ERRWRAP2(retval = _self_->linkerAvailable()); |  | 76695 | ERRWRAP2(retval = _self_->linkerAvailable());
| 76744 | return pyopencv_from(retval); |  | 76696 | return pyopencv_from(retval);
| 76745 | } |  | 76697 | }
| 76746 |  |  | 76698 |
| 76747 | return NULL; |  | 76699 | return NULL;
| 76748 | } |  | 76700 | }
| 76749 |  |  | 76701 |
| 76750 | static PyObject* pyopencv_cv_ocl_ocl_Device_localMemSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76702 | static PyObject* pyopencv_cv_ocl_ocl_Device_localMemSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76751 | { |  | 76703 | {
| 76752 | using namespace cv::ocl; |  | 76704 | using namespace cv::ocl;
| 76753 |  |  | 76705 |
| 76754 |  |  | 76706 |
| 76755 | cv::ocl::Device * self1 = 0; |  | 76707 | cv::ocl::Device * self1 = 0;
| 76756 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76708 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76757 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76709 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76758 | cv::ocl::Device* _self_ = (self1); |  | 76710 | cv::ocl::Device* _self_ = (self1);
| 76759 | size_t retval; |  | 76711 | size_t retval;
| 76760 |  |  | 76712 |
| 76761 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76713 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76762 | { |  | 76714 | {
| 76763 | ERRWRAP2(retval = _self_->localMemSize()); |  | 76715 | ERRWRAP2(retval = _self_->localMemSize());
| 76764 | return pyopencv_from(retval); |  | 76716 | return pyopencv_from(retval);
| 76765 | } |  | 76717 | }
| 76766 |  |  | 76718 |
| 76767 | return NULL; |  | 76719 | return NULL;
| 76768 | } |  | 76720 | }
| 76769 |  |  | 76721 |
| 76770 | static PyObject* pyopencv_cv_ocl_ocl_Device_localMemType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76722 | static PyObject* pyopencv_cv_ocl_ocl_Device_localMemType(PyObject* self, PyObject* py_args, PyObject* kw)
| 76771 | { |  | 76723 | {
| 76772 | using namespace cv::ocl; |  | 76724 | using namespace cv::ocl;
| 76773 |  |  | 76725 |
| 76774 |  |  | 76726 |
| 76775 | cv::ocl::Device * self1 = 0; |  | 76727 | cv::ocl::Device * self1 = 0;
| 76776 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76728 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76777 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76729 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76778 | cv::ocl::Device* _self_ = (self1); |  | 76730 | cv::ocl::Device* _self_ = (self1);
| 76779 | int retval; |  | 76731 | int retval;
| 76780 |  |  | 76732 |
| 76781 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76733 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76782 | { |  | 76734 | {
| 76783 | ERRWRAP2(retval = _self_->localMemType()); |  | 76735 | ERRWRAP2(retval = _self_->localMemType());
| 76784 | return pyopencv_from(retval); |  | 76736 | return pyopencv_from(retval);
| 76785 | } |  | 76737 | }
| 76786 |  |  | 76738 |
| 76787 | return NULL; |  | 76739 | return NULL;
| 76788 | } |  | 76740 | }
| 76789 |  |  | 76741 |
| 76790 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxClockFrequency(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76742 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxClockFrequency(PyObject* self, PyObject* py_args, PyObject* kw)
| 76791 | { |  | 76743 | {
| 76792 | using namespace cv::ocl; |  | 76744 | using namespace cv::ocl;
| 76793 |  |  | 76745 |
| 76794 |  |  | 76746 |
| 76795 | cv::ocl::Device * self1 = 0; |  | 76747 | cv::ocl::Device * self1 = 0;
| 76796 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76748 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76797 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76749 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76798 | cv::ocl::Device* _self_ = (self1); |  | 76750 | cv::ocl::Device* _self_ = (self1);
| 76799 | int retval; |  | 76751 | int retval;
| 76800 |  |  | 76752 |
| 76801 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76753 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76802 | { |  | 76754 | {
| 76803 | ERRWRAP2(retval = _self_->maxClockFrequency()); |  | 76755 | ERRWRAP2(retval = _self_->maxClockFrequency());
| 76804 | return pyopencv_from(retval); |  | 76756 | return pyopencv_from(retval);
| 76805 | } |  | 76757 | }
| 76806 |  |  | 76758 |
| 76807 | return NULL; |  | 76759 | return NULL;
| 76808 | } |  | 76760 | }
| 76809 |  |  | 76761 |
| 76810 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxComputeUnits(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76762 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxComputeUnits(PyObject* self, PyObject* py_args, PyObject* kw)
| 76811 | { |  | 76763 | {
| 76812 | using namespace cv::ocl; |  | 76764 | using namespace cv::ocl;
| 76813 |  |  | 76765 |
| 76814 |  |  | 76766 |
| 76815 | cv::ocl::Device * self1 = 0; |  | 76767 | cv::ocl::Device * self1 = 0;
| 76816 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76768 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76817 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76769 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76818 | cv::ocl::Device* _self_ = (self1); |  | 76770 | cv::ocl::Device* _self_ = (self1);
| 76819 | int retval; |  | 76771 | int retval;
| 76820 |  |  | 76772 |
| 76821 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76773 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76822 | { |  | 76774 | {
| 76823 | ERRWRAP2(retval = _self_->maxComputeUnits()); |  | 76775 | ERRWRAP2(retval = _self_->maxComputeUnits());
| 76824 | return pyopencv_from(retval); |  | 76776 | return pyopencv_from(retval);
| 76825 | } |  | 76777 | }
| 76826 |  |  | 76778 |
| 76827 | return NULL; |  | 76779 | return NULL;
| 76828 | } |  | 76780 | }
| 76829 |  |  | 76781 |
| 76830 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxConstantArgs(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76782 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxConstantArgs(PyObject* self, PyObject* py_args, PyObject* kw)
| 76831 | { |  | 76783 | {
| 76832 | using namespace cv::ocl; |  | 76784 | using namespace cv::ocl;
| 76833 |  |  | 76785 |
| 76834 |  |  | 76786 |
| 76835 | cv::ocl::Device * self1 = 0; |  | 76787 | cv::ocl::Device * self1 = 0;
| 76836 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76788 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76837 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76789 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76838 | cv::ocl::Device* _self_ = (self1); |  | 76790 | cv::ocl::Device* _self_ = (self1);
| 76839 | int retval; |  | 76791 | int retval;
| 76840 |  |  | 76792 |
| 76841 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76793 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76842 | { |  | 76794 | {
| 76843 | ERRWRAP2(retval = _self_->maxConstantArgs()); |  | 76795 | ERRWRAP2(retval = _self_->maxConstantArgs());
| 76844 | return pyopencv_from(retval); |  | 76796 | return pyopencv_from(retval);
| 76845 | } |  | 76797 | }
| 76846 |  |  | 76798 |
| 76847 | return NULL; |  | 76799 | return NULL;
| 76848 | } |  | 76800 | }
| 76849 |  |  | 76801 |
| 76850 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxConstantBufferSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76802 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxConstantBufferSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76851 | { |  | 76803 | {
| 76852 | using namespace cv::ocl; |  | 76804 | using namespace cv::ocl;
| 76853 |  |  | 76805 |
| 76854 |  |  | 76806 |
| 76855 | cv::ocl::Device * self1 = 0; |  | 76807 | cv::ocl::Device * self1 = 0;
| 76856 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76808 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76857 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76809 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76858 | cv::ocl::Device* _self_ = (self1); |  | 76810 | cv::ocl::Device* _self_ = (self1);
| 76859 | size_t retval; |  | 76811 | size_t retval;
| 76860 |  |  | 76812 |
| 76861 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76813 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76862 | { |  | 76814 | {
| 76863 | ERRWRAP2(retval = _self_->maxConstantBufferSize()); |  | 76815 | ERRWRAP2(retval = _self_->maxConstantBufferSize());
| 76864 | return pyopencv_from(retval); |  | 76816 | return pyopencv_from(retval);
| 76865 | } |  | 76817 | }
| 76866 |  |  | 76818 |
| 76867 | return NULL; |  | 76819 | return NULL;
| 76868 | } |  | 76820 | }
| 76869 |  |  | 76821 |
| 76870 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxMemAllocSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76822 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxMemAllocSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76871 | { |  | 76823 | {
| 76872 | using namespace cv::ocl; |  | 76824 | using namespace cv::ocl;
| 76873 |  |  | 76825 |
| 76874 |  |  | 76826 |
| 76875 | cv::ocl::Device * self1 = 0; |  | 76827 | cv::ocl::Device * self1 = 0;
| 76876 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76828 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76877 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76829 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76878 | cv::ocl::Device* _self_ = (self1); |  | 76830 | cv::ocl::Device* _self_ = (self1);
| 76879 | size_t retval; |  | 76831 | size_t retval;
| 76880 |  |  | 76832 |
| 76881 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76833 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76882 | { |  | 76834 | {
| 76883 | ERRWRAP2(retval = _self_->maxMemAllocSize()); |  | 76835 | ERRWRAP2(retval = _self_->maxMemAllocSize());
| 76884 | return pyopencv_from(retval); |  | 76836 | return pyopencv_from(retval);
| 76885 | } |  | 76837 | }
| 76886 |  |  | 76838 |
| 76887 | return NULL; |  | 76839 | return NULL;
| 76888 | } |  | 76840 | }
| 76889 |  |  | 76841 |
| 76890 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxParameterSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76842 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxParameterSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76891 | { |  | 76843 | {
| 76892 | using namespace cv::ocl; |  | 76844 | using namespace cv::ocl;
| 76893 |  |  | 76845 |
| 76894 |  |  | 76846 |
| 76895 | cv::ocl::Device * self1 = 0; |  | 76847 | cv::ocl::Device * self1 = 0;
| 76896 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76848 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76897 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76849 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76898 | cv::ocl::Device* _self_ = (self1); |  | 76850 | cv::ocl::Device* _self_ = (self1);
| 76899 | size_t retval; |  | 76851 | size_t retval;
| 76900 |  |  | 76852 |
| 76901 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76853 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76902 | { |  | 76854 | {
| 76903 | ERRWRAP2(retval = _self_->maxParameterSize()); |  | 76855 | ERRWRAP2(retval = _self_->maxParameterSize());
| 76904 | return pyopencv_from(retval); |  | 76856 | return pyopencv_from(retval);
| 76905 | } |  | 76857 | }
| 76906 |  |  | 76858 |
| 76907 | return NULL; |  | 76859 | return NULL;
| 76908 | } |  | 76860 | }
| 76909 |  |  | 76861 |
| 76910 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxReadImageArgs(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76862 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxReadImageArgs(PyObject* self, PyObject* py_args, PyObject* kw)
| 76911 | { |  | 76863 | {
| 76912 | using namespace cv::ocl; |  | 76864 | using namespace cv::ocl;
| 76913 |  |  | 76865 |
| 76914 |  |  | 76866 |
| 76915 | cv::ocl::Device * self1 = 0; |  | 76867 | cv::ocl::Device * self1 = 0;
| 76916 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76868 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76917 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76869 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76918 | cv::ocl::Device* _self_ = (self1); |  | 76870 | cv::ocl::Device* _self_ = (self1);
| 76919 | int retval; |  | 76871 | int retval;
| 76920 |  |  | 76872 |
| 76921 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76873 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76922 | { |  | 76874 | {
| 76923 | ERRWRAP2(retval = _self_->maxReadImageArgs()); |  | 76875 | ERRWRAP2(retval = _self_->maxReadImageArgs());
| 76924 | return pyopencv_from(retval); |  | 76876 | return pyopencv_from(retval);
| 76925 | } |  | 76877 | }
| 76926 |  |  | 76878 |
| 76927 | return NULL; |  | 76879 | return NULL;
| 76928 | } |  | 76880 | }
| 76929 |  |  | 76881 |
| 76930 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxSamplers(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76882 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxSamplers(PyObject* self, PyObject* py_args, PyObject* kw)
| 76931 | { |  | 76883 | {
| 76932 | using namespace cv::ocl; |  | 76884 | using namespace cv::ocl;
| 76933 |  |  | 76885 |
| 76934 |  |  | 76886 |
| 76935 | cv::ocl::Device * self1 = 0; |  | 76887 | cv::ocl::Device * self1 = 0;
| 76936 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76888 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76937 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76889 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76938 | cv::ocl::Device* _self_ = (self1); |  | 76890 | cv::ocl::Device* _self_ = (self1);
| 76939 | int retval; |  | 76891 | int retval;
| 76940 |  |  | 76892 |
| 76941 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76893 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76942 | { |  | 76894 | {
| 76943 | ERRWRAP2(retval = _self_->maxSamplers()); |  | 76895 | ERRWRAP2(retval = _self_->maxSamplers());
| 76944 | return pyopencv_from(retval); |  | 76896 | return pyopencv_from(retval);
| 76945 | } |  | 76897 | }
| 76946 |  |  | 76898 |
| 76947 | return NULL; |  | 76899 | return NULL;
| 76948 | } |  | 76900 | }
| 76949 |  |  | 76901 |
| 76950 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxWorkGroupSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76902 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxWorkGroupSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 76951 | { |  | 76903 | {
| 76952 | using namespace cv::ocl; |  | 76904 | using namespace cv::ocl;
| 76953 |  |  | 76905 |
| 76954 |  |  | 76906 |
| 76955 | cv::ocl::Device * self1 = 0; |  | 76907 | cv::ocl::Device * self1 = 0;
| 76956 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76908 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76957 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76909 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76958 | cv::ocl::Device* _self_ = (self1); |  | 76910 | cv::ocl::Device* _self_ = (self1);
| 76959 | size_t retval; |  | 76911 | size_t retval;
| 76960 |  |  | 76912 |
| 76961 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76913 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76962 | { |  | 76914 | {
| 76963 | ERRWRAP2(retval = _self_->maxWorkGroupSize()); |  | 76915 | ERRWRAP2(retval = _self_->maxWorkGroupSize());
| 76964 | return pyopencv_from(retval); |  | 76916 | return pyopencv_from(retval);
| 76965 | } |  | 76917 | }
| 76966 |  |  | 76918 |
| 76967 | return NULL; |  | 76919 | return NULL;
| 76968 | } |  | 76920 | }
| 76969 |  |  | 76921 |
| 76970 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxWorkItemDims(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76922 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxWorkItemDims(PyObject* self, PyObject* py_args, PyObject* kw)
| 76971 | { |  | 76923 | {
| 76972 | using namespace cv::ocl; |  | 76924 | using namespace cv::ocl;
| 76973 |  |  | 76925 |
| 76974 |  |  | 76926 |
| 76975 | cv::ocl::Device * self1 = 0; |  | 76927 | cv::ocl::Device * self1 = 0;
| 76976 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76928 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76977 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76929 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76978 | cv::ocl::Device* _self_ = (self1); |  | 76930 | cv::ocl::Device* _self_ = (self1);
| 76979 | int retval; |  | 76931 | int retval;
| 76980 |  |  | 76932 |
| 76981 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76933 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 76982 | { |  | 76934 | {
| 76983 | ERRWRAP2(retval = _self_->maxWorkItemDims()); |  | 76935 | ERRWRAP2(retval = _self_->maxWorkItemDims());
| 76984 | return pyopencv_from(retval); |  | 76936 | return pyopencv_from(retval);
| 76985 | } |  | 76937 | }
| 76986 |  |  | 76938 |
| 76987 | return NULL; |  | 76939 | return NULL;
| 76988 | } |  | 76940 | }
| 76989 |  |  | 76941 |
| 76990 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxWriteImageArgs(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76942 | static PyObject* pyopencv_cv_ocl_ocl_Device_maxWriteImageArgs(PyObject* self, PyObject* py_args, PyObject* kw)
| 76991 | { |  | 76943 | {
| 76992 | using namespace cv::ocl; |  | 76944 | using namespace cv::ocl;
| 76993 |  |  | 76945 |
| 76994 |  |  | 76946 |
| 76995 | cv::ocl::Device * self1 = 0; |  | 76947 | cv::ocl::Device * self1 = 0;
| 76996 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76948 | if (!pyopencv_ocl_Device_getp(self, self1))
| 76997 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76949 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 76998 | cv::ocl::Device* _self_ = (self1); |  | 76950 | cv::ocl::Device* _self_ = (self1);
| 76999 | int retval; |  | 76951 | int retval;
| 77000 |  |  | 76952 |
| 77001 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76953 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77002 | { |  | 76954 | {
| 77003 | ERRWRAP2(retval = _self_->maxWriteImageArgs()); |  | 76955 | ERRWRAP2(retval = _self_->maxWriteImageArgs());
| 77004 | return pyopencv_from(retval); |  | 76956 | return pyopencv_from(retval);
| 77005 | } |  | 76957 | }
| 77006 |  |  | 76958 |
| 77007 | return NULL; |  | 76959 | return NULL;
| 77008 | } |  | 76960 | }
| 77009 |  |  | 76961 |
| 77010 | static PyObject* pyopencv_cv_ocl_ocl_Device_memBaseAddrAlign(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76962 | static PyObject* pyopencv_cv_ocl_ocl_Device_memBaseAddrAlign(PyObject* self, PyObject* py_args, PyObject* kw)
| 77011 | { |  | 76963 | {
| 77012 | using namespace cv::ocl; |  | 76964 | using namespace cv::ocl;
| 77013 |  |  | 76965 |
| 77014 |  |  | 76966 |
| 77015 | cv::ocl::Device * self1 = 0; |  | 76967 | cv::ocl::Device * self1 = 0;
| 77016 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76968 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77017 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76969 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77018 | cv::ocl::Device* _self_ = (self1); |  | 76970 | cv::ocl::Device* _self_ = (self1);
| 77019 | int retval; |  | 76971 | int retval;
| 77020 |  |  | 76972 |
| 77021 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76973 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77022 | { |  | 76974 | {
| 77023 | ERRWRAP2(retval = _self_->memBaseAddrAlign()); |  | 76975 | ERRWRAP2(retval = _self_->memBaseAddrAlign());
| 77024 | return pyopencv_from(retval); |  | 76976 | return pyopencv_from(retval);
| 77025 | } |  | 76977 | }
| 77026 |  |  | 76978 |
| 77027 | return NULL; |  | 76979 | return NULL;
| 77028 | } |  | 76980 | }
| 77029 |  |  | 76981 |
| 77030 | static PyObject* pyopencv_cv_ocl_ocl_Device_name(PyObject* self, PyObject* py_args, PyObject* kw) |  | 76982 | static PyObject* pyopencv_cv_ocl_ocl_Device_name(PyObject* self, PyObject* py_args, PyObject* kw)
| 77031 | { |  | 76983 | {
| 77032 | using namespace cv::ocl; |  | 76984 | using namespace cv::ocl;
| 77033 |  |  | 76985 |
| 77034 |  |  | 76986 |
| 77035 | cv::ocl::Device * self1 = 0; |  | 76987 | cv::ocl::Device * self1 = 0;
| 77036 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 76988 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77037 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 76989 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77038 | cv::ocl::Device* _self_ = (self1); |  | 76990 | cv::ocl::Device* _self_ = (self1);
| 77039 | String retval; |  | 76991 | String retval;
| 77040 |  |  | 76992 |
| 77041 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 76993 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77042 | { |  | 76994 | {
| 77043 | ERRWRAP2(retval = _self_->name()); |  | 76995 | ERRWRAP2(retval = _self_->name());
| 77044 | return pyopencv_from(retval); |  | 76996 | return pyopencv_from(retval);
| 77045 | } |  | 76997 | }
| 77046 |  |  | 76998 |
| 77047 | return NULL; |  | 76999 | return NULL;
| 77048 | } |  | 77000 | }
| 77049 |  |  | 77001 |
| 77050 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthChar(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77002 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthChar(PyObject* self, PyObject* py_args, PyObject* kw)
| 77051 | { |  | 77003 | {
| 77052 | using namespace cv::ocl; |  | 77004 | using namespace cv::ocl;
| 77053 |  |  | 77005 |
| 77054 |  |  | 77006 |
| 77055 | cv::ocl::Device * self1 = 0; |  | 77007 | cv::ocl::Device * self1 = 0;
| 77056 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77008 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77057 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77009 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77058 | cv::ocl::Device* _self_ = (self1); |  | 77010 | cv::ocl::Device* _self_ = (self1);
| 77059 | int retval; |  | 77011 | int retval;
| 77060 |  |  | 77012 |
| 77061 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77013 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77062 | { |  | 77014 | {
| 77063 | ERRWRAP2(retval = _self_->nativeVectorWidthChar()); |  | 77015 | ERRWRAP2(retval = _self_->nativeVectorWidthChar());
| 77064 | return pyopencv_from(retval); |  | 77016 | return pyopencv_from(retval);
| 77065 | } |  | 77017 | }
| 77066 |  |  | 77018 |
| 77067 | return NULL; |  | 77019 | return NULL;
| 77068 | } |  | 77020 | }
| 77069 |  |  | 77021 |
| 77070 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthDouble(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77022 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthDouble(PyObject* self, PyObject* py_args, PyObject* kw)
| 77071 | { |  | 77023 | {
| 77072 | using namespace cv::ocl; |  | 77024 | using namespace cv::ocl;
| 77073 |  |  | 77025 |
| 77074 |  |  | 77026 |
| 77075 | cv::ocl::Device * self1 = 0; |  | 77027 | cv::ocl::Device * self1 = 0;
| 77076 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77028 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77077 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77029 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77078 | cv::ocl::Device* _self_ = (self1); |  | 77030 | cv::ocl::Device* _self_ = (self1);
| 77079 | int retval; |  | 77031 | int retval;
| 77080 |  |  | 77032 |
| 77081 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77033 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77082 | { |  | 77034 | {
| 77083 | ERRWRAP2(retval = _self_->nativeVectorWidthDouble()); |  | 77035 | ERRWRAP2(retval = _self_->nativeVectorWidthDouble());
| 77084 | return pyopencv_from(retval); |  | 77036 | return pyopencv_from(retval);
| 77085 | } |  | 77037 | }
| 77086 |  |  | 77038 |
| 77087 | return NULL; |  | 77039 | return NULL;
| 77088 | } |  | 77040 | }
| 77089 |  |  | 77041 |
| 77090 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthFloat(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77042 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthFloat(PyObject* self, PyObject* py_args, PyObject* kw)
| 77091 | { |  | 77043 | {
| 77092 | using namespace cv::ocl; |  | 77044 | using namespace cv::ocl;
| 77093 |  |  | 77045 |
| 77094 |  |  | 77046 |
| 77095 | cv::ocl::Device * self1 = 0; |  | 77047 | cv::ocl::Device * self1 = 0;
| 77096 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77048 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77097 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77049 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77098 | cv::ocl::Device* _self_ = (self1); |  | 77050 | cv::ocl::Device* _self_ = (self1);
| 77099 | int retval; |  | 77051 | int retval;
| 77100 |  |  | 77052 |
| 77101 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77053 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77102 | { |  | 77054 | {
| 77103 | ERRWRAP2(retval = _self_->nativeVectorWidthFloat()); |  | 77055 | ERRWRAP2(retval = _self_->nativeVectorWidthFloat());
| 77104 | return pyopencv_from(retval); |  | 77056 | return pyopencv_from(retval);
| 77105 | } |  | 77057 | }
| 77106 |  |  | 77058 |
| 77107 | return NULL; |  | 77059 | return NULL;
| 77108 | } |  | 77060 | }
| 77109 |  |  | 77061 |
| 77110 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthHalf(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77062 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthHalf(PyObject* self, PyObject* py_args, PyObject* kw)
| 77111 | { |  | 77063 | {
| 77112 | using namespace cv::ocl; |  | 77064 | using namespace cv::ocl;
| 77113 |  |  | 77065 |
| 77114 |  |  | 77066 |
| 77115 | cv::ocl::Device * self1 = 0; |  | 77067 | cv::ocl::Device * self1 = 0;
| 77116 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77068 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77117 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77069 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77118 | cv::ocl::Device* _self_ = (self1); |  | 77070 | cv::ocl::Device* _self_ = (self1);
| 77119 | int retval; |  | 77071 | int retval;
| 77120 |  |  | 77072 |
| 77121 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77073 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77122 | { |  | 77074 | {
| 77123 | ERRWRAP2(retval = _self_->nativeVectorWidthHalf()); |  | 77075 | ERRWRAP2(retval = _self_->nativeVectorWidthHalf());
| 77124 | return pyopencv_from(retval); |  | 77076 | return pyopencv_from(retval);
| 77125 | } |  | 77077 | }
| 77126 |  |  | 77078 |
| 77127 | return NULL; |  | 77079 | return NULL;
| 77128 | } |  | 77080 | }
| 77129 |  |  | 77081 |
| 77130 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthInt(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77082 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthInt(PyObject* self, PyObject* py_args, PyObject* kw)
| 77131 | { |  | 77083 | {
| 77132 | using namespace cv::ocl; |  | 77084 | using namespace cv::ocl;
| 77133 |  |  | 77085 |
| 77134 |  |  | 77086 |
| 77135 | cv::ocl::Device * self1 = 0; |  | 77087 | cv::ocl::Device * self1 = 0;
| 77136 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77088 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77137 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77089 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77138 | cv::ocl::Device* _self_ = (self1); |  | 77090 | cv::ocl::Device* _self_ = (self1);
| 77139 | int retval; |  | 77091 | int retval;
| 77140 |  |  | 77092 |
| 77141 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77093 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77142 | { |  | 77094 | {
| 77143 | ERRWRAP2(retval = _self_->nativeVectorWidthInt()); |  | 77095 | ERRWRAP2(retval = _self_->nativeVectorWidthInt());
| 77144 | return pyopencv_from(retval); |  | 77096 | return pyopencv_from(retval);
| 77145 | } |  | 77097 | }
| 77146 |  |  | 77098 |
| 77147 | return NULL; |  | 77099 | return NULL;
| 77148 | } |  | 77100 | }
| 77149 |  |  | 77101 |
| 77150 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthLong(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77102 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthLong(PyObject* self, PyObject* py_args, PyObject* kw)
| 77151 | { |  | 77103 | {
| 77152 | using namespace cv::ocl; |  | 77104 | using namespace cv::ocl;
| 77153 |  |  | 77105 |
| 77154 |  |  | 77106 |
| 77155 | cv::ocl::Device * self1 = 0; |  | 77107 | cv::ocl::Device * self1 = 0;
| 77156 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77108 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77157 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77109 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77158 | cv::ocl::Device* _self_ = (self1); |  | 77110 | cv::ocl::Device* _self_ = (self1);
| 77159 | int retval; |  | 77111 | int retval;
| 77160 |  |  | 77112 |
| 77161 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77113 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77162 | { |  | 77114 | {
| 77163 | ERRWRAP2(retval = _self_->nativeVectorWidthLong()); |  | 77115 | ERRWRAP2(retval = _self_->nativeVectorWidthLong());
| 77164 | return pyopencv_from(retval); |  | 77116 | return pyopencv_from(retval);
| 77165 | } |  | 77117 | }
| 77166 |  |  | 77118 |
| 77167 | return NULL; |  | 77119 | return NULL;
| 77168 | } |  | 77120 | }
| 77169 |  |  | 77121 |
| 77170 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthShort(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77122 | static PyObject* pyopencv_cv_ocl_ocl_Device_nativeVectorWidthShort(PyObject* self, PyObject* py_args, PyObject* kw)
| 77171 | { |  | 77123 | {
| 77172 | using namespace cv::ocl; |  | 77124 | using namespace cv::ocl;
| 77173 |  |  | 77125 |
| 77174 |  |  | 77126 |
| 77175 | cv::ocl::Device * self1 = 0; |  | 77127 | cv::ocl::Device * self1 = 0;
| 77176 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77128 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77177 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77129 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77178 | cv::ocl::Device* _self_ = (self1); |  | 77130 | cv::ocl::Device* _self_ = (self1);
| 77179 | int retval; |  | 77131 | int retval;
| 77180 |  |  | 77132 |
| 77181 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77133 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77182 | { |  | 77134 | {
| 77183 | ERRWRAP2(retval = _self_->nativeVectorWidthShort()); |  | 77135 | ERRWRAP2(retval = _self_->nativeVectorWidthShort());
| 77184 | return pyopencv_from(retval); |  | 77136 | return pyopencv_from(retval);
| 77185 | } |  | 77137 | }
| 77186 |  |  | 77138 |
| 77187 | return NULL; |  | 77139 | return NULL;
| 77188 | } |  | 77140 | }
| 77189 |  |  | 77141 |
| 77190 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthChar(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77142 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthChar(PyObject* self, PyObject* py_args, PyObject* kw)
| 77191 | { |  | 77143 | {
| 77192 | using namespace cv::ocl; |  | 77144 | using namespace cv::ocl;
| 77193 |  |  | 77145 |
| 77194 |  |  | 77146 |
| 77195 | cv::ocl::Device * self1 = 0; |  | 77147 | cv::ocl::Device * self1 = 0;
| 77196 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77148 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77197 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77149 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77198 | cv::ocl::Device* _self_ = (self1); |  | 77150 | cv::ocl::Device* _self_ = (self1);
| 77199 | int retval; |  | 77151 | int retval;
| 77200 |  |  | 77152 |
| 77201 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77153 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77202 | { |  | 77154 | {
| 77203 | ERRWRAP2(retval = _self_->preferredVectorWidthChar()); |  | 77155 | ERRWRAP2(retval = _self_->preferredVectorWidthChar());
| 77204 | return pyopencv_from(retval); |  | 77156 | return pyopencv_from(retval);
| 77205 | } |  | 77157 | }
| 77206 |  |  | 77158 |
| 77207 | return NULL; |  | 77159 | return NULL;
| 77208 | } |  | 77160 | }
| 77209 |  |  | 77161 |
| 77210 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthDouble(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77162 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthDouble(PyObject* self, PyObject* py_args, PyObject* kw)
| 77211 | { |  | 77163 | {
| 77212 | using namespace cv::ocl; |  | 77164 | using namespace cv::ocl;
| 77213 |  |  | 77165 |
| 77214 |  |  | 77166 |
| 77215 | cv::ocl::Device * self1 = 0; |  | 77167 | cv::ocl::Device * self1 = 0;
| 77216 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77168 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77217 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77169 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77218 | cv::ocl::Device* _self_ = (self1); |  | 77170 | cv::ocl::Device* _self_ = (self1);
| 77219 | int retval; |  | 77171 | int retval;
| 77220 |  |  | 77172 |
| 77221 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77173 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77222 | { |  | 77174 | {
| 77223 | ERRWRAP2(retval = _self_->preferredVectorWidthDouble()); |  | 77175 | ERRWRAP2(retval = _self_->preferredVectorWidthDouble());
| 77224 | return pyopencv_from(retval); |  | 77176 | return pyopencv_from(retval);
| 77225 | } |  | 77177 | }
| 77226 |  |  | 77178 |
| 77227 | return NULL; |  | 77179 | return NULL;
| 77228 | } |  | 77180 | }
| 77229 |  |  | 77181 |
| 77230 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthFloat(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77182 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthFloat(PyObject* self, PyObject* py_args, PyObject* kw)
| 77231 | { |  | 77183 | {
| 77232 | using namespace cv::ocl; |  | 77184 | using namespace cv::ocl;
| 77233 |  |  | 77185 |
| 77234 |  |  | 77186 |
| 77235 | cv::ocl::Device * self1 = 0; |  | 77187 | cv::ocl::Device * self1 = 0;
| 77236 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77188 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77237 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77189 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77238 | cv::ocl::Device* _self_ = (self1); |  | 77190 | cv::ocl::Device* _self_ = (self1);
| 77239 | int retval; |  | 77191 | int retval;
| 77240 |  |  | 77192 |
| 77241 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77193 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77242 | { |  | 77194 | {
| 77243 | ERRWRAP2(retval = _self_->preferredVectorWidthFloat()); |  | 77195 | ERRWRAP2(retval = _self_->preferredVectorWidthFloat());
| 77244 | return pyopencv_from(retval); |  | 77196 | return pyopencv_from(retval);
| 77245 | } |  | 77197 | }
| 77246 |  |  | 77198 |
| 77247 | return NULL; |  | 77199 | return NULL;
| 77248 | } |  | 77200 | }
| 77249 |  |  | 77201 |
| 77250 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthHalf(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77202 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthHalf(PyObject* self, PyObject* py_args, PyObject* kw)
| 77251 | { |  | 77203 | {
| 77252 | using namespace cv::ocl; |  | 77204 | using namespace cv::ocl;
| 77253 |  |  | 77205 |
| 77254 |  |  | 77206 |
| 77255 | cv::ocl::Device * self1 = 0; |  | 77207 | cv::ocl::Device * self1 = 0;
| 77256 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77208 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77257 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77209 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77258 | cv::ocl::Device* _self_ = (self1); |  | 77210 | cv::ocl::Device* _self_ = (self1);
| 77259 | int retval; |  | 77211 | int retval;
| 77260 |  |  | 77212 |
| 77261 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77213 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77262 | { |  | 77214 | {
| 77263 | ERRWRAP2(retval = _self_->preferredVectorWidthHalf()); |  | 77215 | ERRWRAP2(retval = _self_->preferredVectorWidthHalf());
| 77264 | return pyopencv_from(retval); |  | 77216 | return pyopencv_from(retval);
| 77265 | } |  | 77217 | }
| 77266 |  |  | 77218 |
| 77267 | return NULL; |  | 77219 | return NULL;
| 77268 | } |  | 77220 | }
| 77269 |  |  | 77221 |
| 77270 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthInt(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77222 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthInt(PyObject* self, PyObject* py_args, PyObject* kw)
| 77271 | { |  | 77223 | {
| 77272 | using namespace cv::ocl; |  | 77224 | using namespace cv::ocl;
| 77273 |  |  | 77225 |
| 77274 |  |  | 77226 |
| 77275 | cv::ocl::Device * self1 = 0; |  | 77227 | cv::ocl::Device * self1 = 0;
| 77276 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77228 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77277 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77229 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77278 | cv::ocl::Device* _self_ = (self1); |  | 77230 | cv::ocl::Device* _self_ = (self1);
| 77279 | int retval; |  | 77231 | int retval;
| 77280 |  |  | 77232 |
| 77281 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77233 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77282 | { |  | 77234 | {
| 77283 | ERRWRAP2(retval = _self_->preferredVectorWidthInt()); |  | 77235 | ERRWRAP2(retval = _self_->preferredVectorWidthInt());
| 77284 | return pyopencv_from(retval); |  | 77236 | return pyopencv_from(retval);
| 77285 | } |  | 77237 | }
| 77286 |  |  | 77238 |
| 77287 | return NULL; |  | 77239 | return NULL;
| 77288 | } |  | 77240 | }
| 77289 |  |  | 77241 |
| 77290 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthLong(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77242 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthLong(PyObject* self, PyObject* py_args, PyObject* kw)
| 77291 | { |  | 77243 | {
| 77292 | using namespace cv::ocl; |  | 77244 | using namespace cv::ocl;
| 77293 |  |  | 77245 |
| 77294 |  |  | 77246 |
| 77295 | cv::ocl::Device * self1 = 0; |  | 77247 | cv::ocl::Device * self1 = 0;
| 77296 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77248 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77297 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77249 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77298 | cv::ocl::Device* _self_ = (self1); |  | 77250 | cv::ocl::Device* _self_ = (self1);
| 77299 | int retval; |  | 77251 | int retval;
| 77300 |  |  | 77252 |
| 77301 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77253 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77302 | { |  | 77254 | {
| 77303 | ERRWRAP2(retval = _self_->preferredVectorWidthLong()); |  | 77255 | ERRWRAP2(retval = _self_->preferredVectorWidthLong());
| 77304 | return pyopencv_from(retval); |  | 77256 | return pyopencv_from(retval);
| 77305 | } |  | 77257 | }
| 77306 |  |  | 77258 |
| 77307 | return NULL; |  | 77259 | return NULL;
| 77308 | } |  | 77260 | }
| 77309 |  |  | 77261 |
| 77310 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthShort(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77262 | static PyObject* pyopencv_cv_ocl_ocl_Device_preferredVectorWidthShort(PyObject* self, PyObject* py_args, PyObject* kw)
| 77311 | { |  | 77263 | {
| 77312 | using namespace cv::ocl; |  | 77264 | using namespace cv::ocl;
| 77313 |  |  | 77265 |
| 77314 |  |  | 77266 |
| 77315 | cv::ocl::Device * self1 = 0; |  | 77267 | cv::ocl::Device * self1 = 0;
| 77316 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77268 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77317 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77269 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77318 | cv::ocl::Device* _self_ = (self1); |  | 77270 | cv::ocl::Device* _self_ = (self1);
| 77319 | int retval; |  | 77271 | int retval;
| 77320 |  |  | 77272 |
| 77321 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77273 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77322 | { |  | 77274 | {
| 77323 | ERRWRAP2(retval = _self_->preferredVectorWidthShort()); |  | 77275 | ERRWRAP2(retval = _self_->preferredVectorWidthShort());
| 77324 | return pyopencv_from(retval); |  | 77276 | return pyopencv_from(retval);
| 77325 | } |  | 77277 | }
| 77326 |  |  | 77278 |
| 77327 | return NULL; |  | 77279 | return NULL;
| 77328 | } |  | 77280 | }
| 77329 |  |  | 77281 |
| 77330 | static PyObject* pyopencv_cv_ocl_ocl_Device_printfBufferSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77282 | static PyObject* pyopencv_cv_ocl_ocl_Device_printfBufferSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 77331 | { |  | 77283 | {
| 77332 | using namespace cv::ocl; |  | 77284 | using namespace cv::ocl;
| 77333 |  |  | 77285 |
| 77334 |  |  | 77286 |
| 77335 | cv::ocl::Device * self1 = 0; |  | 77287 | cv::ocl::Device * self1 = 0;
| 77336 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77288 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77337 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77289 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77338 | cv::ocl::Device* _self_ = (self1); |  | 77290 | cv::ocl::Device* _self_ = (self1);
| 77339 | size_t retval; |  | 77291 | size_t retval;
| 77340 |  |  | 77292 |
| 77341 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77293 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77342 | { |  | 77294 | {
| 77343 | ERRWRAP2(retval = _self_->printfBufferSize()); |  | 77295 | ERRWRAP2(retval = _self_->printfBufferSize());
| 77344 | return pyopencv_from(retval); |  | 77296 | return pyopencv_from(retval);
| 77345 | } |  | 77297 | }
| 77346 |  |  | 77298 |
| 77347 | return NULL; |  | 77299 | return NULL;
| 77348 | } |  | 77300 | }
| 77349 |  |  | 77301 |
| 77350 | static PyObject* pyopencv_cv_ocl_ocl_Device_profilingTimerResolution(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77302 | static PyObject* pyopencv_cv_ocl_ocl_Device_profilingTimerResolution(PyObject* self, PyObject* py_args, PyObject* kw)
| 77351 | { |  | 77303 | {
| 77352 | using namespace cv::ocl; |  | 77304 | using namespace cv::ocl;
| 77353 |  |  | 77305 |
| 77354 |  |  | 77306 |
| 77355 | cv::ocl::Device * self1 = 0; |  | 77307 | cv::ocl::Device * self1 = 0;
| 77356 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77308 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77357 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77309 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77358 | cv::ocl::Device* _self_ = (self1); |  | 77310 | cv::ocl::Device* _self_ = (self1);
| 77359 | size_t retval; |  | 77311 | size_t retval;
| 77360 |  |  | 77312 |
| 77361 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77313 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77362 | { |  | 77314 | {
| 77363 | ERRWRAP2(retval = _self_->profilingTimerResolution()); |  | 77315 | ERRWRAP2(retval = _self_->profilingTimerResolution());
| 77364 | return pyopencv_from(retval); |  | 77316 | return pyopencv_from(retval);
| 77365 | } |  | 77317 | }
| 77366 |  |  | 77318 |
| 77367 | return NULL; |  | 77319 | return NULL;
| 77368 | } |  | 77320 | }
| 77369 |  |  | 77321 |
| 77370 | static PyObject* pyopencv_cv_ocl_ocl_Device_singleFPConfig(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77322 | static PyObject* pyopencv_cv_ocl_ocl_Device_singleFPConfig(PyObject* self, PyObject* py_args, PyObject* kw)
| 77371 | { |  | 77323 | {
| 77372 | using namespace cv::ocl; |  | 77324 | using namespace cv::ocl;
| 77373 |  |  | 77325 |
| 77374 |  |  | 77326 |
| 77375 | cv::ocl::Device * self1 = 0; |  | 77327 | cv::ocl::Device * self1 = 0;
| 77376 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77328 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77377 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77329 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77378 | cv::ocl::Device* _self_ = (self1); |  | 77330 | cv::ocl::Device* _self_ = (self1);
| 77379 | int retval; |  | 77331 | int retval;
| 77380 |  |  | 77332 |
| 77381 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77333 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77382 | { |  | 77334 | {
| 77383 | ERRWRAP2(retval = _self_->singleFPConfig()); |  | 77335 | ERRWRAP2(retval = _self_->singleFPConfig());
| 77384 | return pyopencv_from(retval); |  | 77336 | return pyopencv_from(retval);
| 77385 | } |  | 77337 | }
| 77386 |  |  | 77338 |
| 77387 | return NULL; |  | 77339 | return NULL;
| 77388 | } |  | 77340 | }
| 77389 |  |  | 77341 |
| 77390 | static PyObject* pyopencv_cv_ocl_ocl_Device_type(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77342 | static PyObject* pyopencv_cv_ocl_ocl_Device_type(PyObject* self, PyObject* py_args, PyObject* kw)
| 77391 | { |  | 77343 | {
| 77392 | using namespace cv::ocl; |  | 77344 | using namespace cv::ocl;
| 77393 |  |  | 77345 |
| 77394 |  |  | 77346 |
| 77395 | cv::ocl::Device * self1 = 0; |  | 77347 | cv::ocl::Device * self1 = 0;
| 77396 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77348 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77397 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77349 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77398 | cv::ocl::Device* _self_ = (self1); |  | 77350 | cv::ocl::Device* _self_ = (self1);
| 77399 | int retval; |  | 77351 | int retval;
| 77400 |  |  | 77352 |
| 77401 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77353 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77402 | { |  | 77354 | {
| 77403 | ERRWRAP2(retval = _self_->type()); |  | 77355 | ERRWRAP2(retval = _self_->type());
| 77404 | return pyopencv_from(retval); |  | 77356 | return pyopencv_from(retval);
| 77405 | } |  | 77357 | }
| 77406 |  |  | 77358 |
| 77407 | return NULL; |  | 77359 | return NULL;
| 77408 | } |  | 77360 | }
| 77409 |  |  | 77361 |
| 77410 | static PyObject* pyopencv_cv_ocl_ocl_Device_vendorID(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77362 | static PyObject* pyopencv_cv_ocl_ocl_Device_vendorID(PyObject* self, PyObject* py_args, PyObject* kw)
| 77411 | { |  | 77363 | {
| 77412 | using namespace cv::ocl; |  | 77364 | using namespace cv::ocl;
| 77413 |  |  | 77365 |
| 77414 |  |  | 77366 |
| 77415 | cv::ocl::Device * self1 = 0; |  | 77367 | cv::ocl::Device * self1 = 0;
| 77416 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77368 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77417 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77369 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77418 | cv::ocl::Device* _self_ = (self1); |  | 77370 | cv::ocl::Device* _self_ = (self1);
| 77419 | int retval; |  | 77371 | int retval;
| 77420 |  |  | 77372 |
| 77421 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77373 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77422 | { |  | 77374 | {
| 77423 | ERRWRAP2(retval = _self_->vendorID()); |  | 77375 | ERRWRAP2(retval = _self_->vendorID());
| 77424 | return pyopencv_from(retval); |  | 77376 | return pyopencv_from(retval);
| 77425 | } |  | 77377 | }
| 77426 |  |  | 77378 |
| 77427 | return NULL; |  | 77379 | return NULL;
| 77428 | } |  | 77380 | }
| 77429 |  |  | 77381 |
| 77430 | static PyObject* pyopencv_cv_ocl_ocl_Device_vendorName(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77382 | static PyObject* pyopencv_cv_ocl_ocl_Device_vendorName(PyObject* self, PyObject* py_args, PyObject* kw)
| 77431 | { |  | 77383 | {
| 77432 | using namespace cv::ocl; |  | 77384 | using namespace cv::ocl;
| 77433 |  |  | 77385 |
| 77434 |  |  | 77386 |
| 77435 | cv::ocl::Device * self1 = 0; |  | 77387 | cv::ocl::Device * self1 = 0;
| 77436 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77388 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77437 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77389 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77438 | cv::ocl::Device* _self_ = (self1); |  | 77390 | cv::ocl::Device* _self_ = (self1);
| 77439 | String retval; |  | 77391 | String retval;
| 77440 |  |  | 77392 |
| 77441 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77393 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77442 | { |  | 77394 | {
| 77443 | ERRWRAP2(retval = _self_->vendorName()); |  | 77395 | ERRWRAP2(retval = _self_->vendorName());
| 77444 | return pyopencv_from(retval); |  | 77396 | return pyopencv_from(retval);
| 77445 | } |  | 77397 | }
| 77446 |  |  | 77398 |
| 77447 | return NULL; |  | 77399 | return NULL;
| 77448 | } |  | 77400 | }
| 77449 |  |  | 77401 |
| 77450 | static PyObject* pyopencv_cv_ocl_ocl_Device_version(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77402 | static PyObject* pyopencv_cv_ocl_ocl_Device_version(PyObject* self, PyObject* py_args, PyObject* kw)
| 77451 | { |  | 77403 | {
| 77452 | using namespace cv::ocl; |  | 77404 | using namespace cv::ocl;
| 77453 |  |  | 77405 |
| 77454 |  |  | 77406 |
| 77455 | cv::ocl::Device * self1 = 0; |  | 77407 | cv::ocl::Device * self1 = 0;
| 77456 | if (!pyopencv_ocl_Device_getp(self, self1)) |  | 77408 | if (!pyopencv_ocl_Device_getp(self, self1))
| 77457 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)"); |  | 77409 | return failmsgp("Incorrect type of self (must be 'ocl_Device' or its derivative)");
| 77458 | cv::ocl::Device* _self_ = (self1); |  | 77410 | cv::ocl::Device* _self_ = (self1);
| 77459 | String retval; |  | 77411 | String retval;
| 77460 |  |  | 77412 |
| 77461 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77413 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77462 | { |  | 77414 | {
| 77463 | ERRWRAP2(retval = _self_->version()); |  | 77415 | ERRWRAP2(retval = _self_->version());
| 77464 | return pyopencv_from(retval); |  | 77416 | return pyopencv_from(retval);
| 77465 | } |  | 77417 | }
| 77466 |  |  | 77418 |
| 77467 | return NULL; |  | 77419 | return NULL;
| 77468 | } |  | 77420 | }
| 77469 |  |  | 77421 |
| 77470 |  |  | 77422 |
| 77471 |  |  | 77423 |
| 77472 | // Tables (ocl_Device) |  | 77424 | // Tables (ocl_Device)
| 77473 |  |  | 77425 |
| 77474 | static PyGetSetDef pyopencv_ocl_Device_getseters[] = |  | 77426 | static PyGetSetDef pyopencv_ocl_Device_getseters[] =
| 77475 | { |  | 77427 | {
| 77476 | {NULL} /* Sentinel */ |  | 77428 | {NULL} /* Sentinel */
| 77477 | }; |  | 77429 | };
| 77478 |  |  | 77430 |
| 77479 | static PyMethodDef pyopencv_ocl_Device_methods[] = |  | 77431 | static PyMethodDef pyopencv_ocl_Device_methods[] =
| 77480 | { |  | 77432 | {
| 77481 | {"OpenCLVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_OpenCLVersion, 0), "OpenCLVersion() -> retval\n."}, |  | 77433 | {"OpenCLVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_OpenCLVersion, 0), "OpenCLVersion() -> retval\n."},
| 77482 | {"OpenCL_C_Version", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_OpenCL_C_Version, 0), "OpenCL_C_Version() -> retval\n."}, |  | 77434 | {"OpenCL_C_Version", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_OpenCL_C_Version, 0), "OpenCL_C_Version() -> retval\n."},
| 77483 | {"addressBits", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_addressBits, 0), "addressBits() -> retval\n."}, |  | 77435 | {"addressBits", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_addressBits, 0), "addressBits() -> retval\n."},
| 77484 | {"available", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_available, 0), "available() -> retval\n."}, |  | 77436 | {"available", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_available, 0), "available() -> retval\n."},
| 77485 | {"compilerAvailable", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_compilerAvailable, 0), "compilerAvailable() -> retval\n."}, |  | 77437 | {"compilerAvailable", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_compilerAvailable, 0), "compilerAvailable() -> retval\n."},
| 77486 | {"deviceVersionMajor", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_deviceVersionMajor, 0), "deviceVersionMajor() -> retval\n."}, |  | 77438 | {"deviceVersionMajor", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_deviceVersionMajor, 0), "deviceVersionMajor() -> retval\n."},
| 77487 | {"deviceVersionMinor", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_deviceVersionMinor, 0), "deviceVersionMinor() -> retval\n."}, |  | 77439 | {"deviceVersionMinor", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_deviceVersionMinor, 0), "deviceVersionMinor() -> retval\n."},
| 77488 | {"doubleFPConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_doubleFPConfig, 0), "doubleFPConfig() -> retval\n."}, |  | 77440 | {"doubleFPConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_doubleFPConfig, 0), "doubleFPConfig() -> retval\n."},
| 77489 | {"driverVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_driverVersion, 0), "driverVersion() -> retval\n."}, |  | 77441 | {"driverVersion", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_driverVersion, 0), "driverVersion() -> retval\n."},
| 77490 | {"endianLittle", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_endianLittle, 0), "endianLittle() -> retval\n."}, |  | 77442 | {"endianLittle", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_endianLittle, 0), "endianLittle() -> retval\n."},
| 77491 | {"errorCorrectionSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_errorCorrectionSupport, 0), "errorCorrectionSupport() -> retval\n."}, |  | 77443 | {"errorCorrectionSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_errorCorrectionSupport, 0), "errorCorrectionSupport() -> retval\n."},
| 77492 | {"executionCapabilities", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_executionCapabilities, 0), "executionCapabilities() -> retval\n."}, |  | 77444 | {"executionCapabilities", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_executionCapabilities, 0), "executionCapabilities() -> retval\n."},
| 77493 | {"extensions", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_extensions, 0), "extensions() -> retval\n."}, |  | 77445 | {"extensions", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_extensions, 0), "extensions() -> retval\n."},
| 77494 | {"getDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_getDefault_static, METH_STATIC), "getDefault() -> retval\n."}, |  | 77446 | {"getDefault", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_getDefault_static, METH_STATIC), "getDefault() -> retval\n."},
| 77495 | {"globalMemCacheLineSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemCacheLineSize, 0), "globalMemCacheLineSize() -> retval\n."}, |  | 77447 | {"globalMemCacheLineSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemCacheLineSize, 0), "globalMemCacheLineSize() -> retval\n."},
| 77496 | {"globalMemCacheSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemCacheSize, 0), "globalMemCacheSize() -> retval\n."}, |  | 77448 | {"globalMemCacheSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemCacheSize, 0), "globalMemCacheSize() -> retval\n."},
| 77497 | {"globalMemCacheType", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemCacheType, 0), "globalMemCacheType() -> retval\n."}, |  | 77449 | {"globalMemCacheType", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemCacheType, 0), "globalMemCacheType() -> retval\n."},
| 77498 | {"globalMemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemSize, 0), "globalMemSize() -> retval\n."}, |  | 77450 | {"globalMemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_globalMemSize, 0), "globalMemSize() -> retval\n."},
| 77499 | {"halfFPConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_halfFPConfig, 0), "halfFPConfig() -> retval\n."}, |  | 77451 | {"halfFPConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_halfFPConfig, 0), "halfFPConfig() -> retval\n."},
| 77500 | {"hasFP16", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_hasFP16, 0), "hasFP16() -> retval\n."}, |  | 77452 | {"hasFP16", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_hasFP16, 0), "hasFP16() -> retval\n."},
| 77501 | {"hasFP64", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_hasFP64, 0), "hasFP64() -> retval\n."}, |  | 77453 | {"hasFP64", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_hasFP64, 0), "hasFP64() -> retval\n."},
| 77502 | {"hostUnifiedMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_hostUnifiedMemory, 0), "hostUnifiedMemory() -> retval\n."}, |  | 77454 | {"hostUnifiedMemory", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_hostUnifiedMemory, 0), "hostUnifiedMemory() -> retval\n."},
| 77503 | {"image2DMaxHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image2DMaxHeight, 0), "image2DMaxHeight() -> retval\n."}, |  | 77455 | {"image2DMaxHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image2DMaxHeight, 0), "image2DMaxHeight() -> retval\n."},
| 77504 | {"image2DMaxWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image2DMaxWidth, 0), "image2DMaxWidth() -> retval\n."}, |  | 77456 | {"image2DMaxWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image2DMaxWidth, 0), "image2DMaxWidth() -> retval\n."},
| 77505 | {"image3DMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image3DMaxDepth, 0), "image3DMaxDepth() -> retval\n."}, |  | 77457 | {"image3DMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image3DMaxDepth, 0), "image3DMaxDepth() -> retval\n."},
| 77506 | {"image3DMaxHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image3DMaxHeight, 0), "image3DMaxHeight() -> retval\n."}, |  | 77458 | {"image3DMaxHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image3DMaxHeight, 0), "image3DMaxHeight() -> retval\n."},
| 77507 | {"image3DMaxWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image3DMaxWidth, 0), "image3DMaxWidth() -> retval\n."}, |  | 77459 | {"image3DMaxWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_image3DMaxWidth, 0), "image3DMaxWidth() -> retval\n."},
| 77508 | {"imageFromBufferSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageFromBufferSupport, 0), "imageFromBufferSupport() -> retval\n."}, |  | 77460 | {"imageFromBufferSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageFromBufferSupport, 0), "imageFromBufferSupport() -> retval\n."},
| 77509 | {"imageMaxArraySize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageMaxArraySize, 0), "imageMaxArraySize() -> retval\n."}, |  | 77461 | {"imageMaxArraySize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageMaxArraySize, 0), "imageMaxArraySize() -> retval\n."},
| 77510 | {"imageMaxBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageMaxBufferSize, 0), "imageMaxBufferSize() -> retval\n."}, |  | 77462 | {"imageMaxBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageMaxBufferSize, 0), "imageMaxBufferSize() -> retval\n."},
| 77511 | {"imageSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageSupport, 0), "imageSupport() -> retval\n."}, |  | 77463 | {"imageSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_imageSupport, 0), "imageSupport() -> retval\n."},
| 77512 | {"intelSubgroupsSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_intelSubgroupsSupport, 0), "intelSubgroupsSupport() -> retval\n."}, |  | 77464 | {"intelSubgroupsSupport", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_intelSubgroupsSupport, 0), "intelSubgroupsSupport() -> retval\n."},
| 77513 | {"isAMD", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isAMD, 0), "isAMD() -> retval\n."}, |  | 77465 | {"isAMD", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isAMD, 0), "isAMD() -> retval\n."},
| 77514 | {"isExtensionSupported", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isExtensionSupported, 0), "isExtensionSupported(extensionName) -> retval\n."}, |  | 77466 | {"isExtensionSupported", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isExtensionSupported, 0), "isExtensionSupported(extensionName) -> retval\n."},
| 77515 | {"isIntel", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isIntel, 0), "isIntel() -> retval\n."}, |  | 77467 | {"isIntel", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isIntel, 0), "isIntel() -> retval\n."},
| 77516 | {"isNVidia", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isNVidia, 0), "isNVidia() -> retval\n."}, |  | 77468 | {"isNVidia", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_isNVidia, 0), "isNVidia() -> retval\n."},
| 77517 | {"linkerAvailable", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_linkerAvailable, 0), "linkerAvailable() -> retval\n."}, |  | 77469 | {"linkerAvailable", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_linkerAvailable, 0), "linkerAvailable() -> retval\n."},
| 77518 | {"localMemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_localMemSize, 0), "localMemSize() -> retval\n."}, |  | 77470 | {"localMemSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_localMemSize, 0), "localMemSize() -> retval\n."},
| 77519 | {"localMemType", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_localMemType, 0), "localMemType() -> retval\n."}, |  | 77471 | {"localMemType", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_localMemType, 0), "localMemType() -> retval\n."},
| 77520 | {"maxClockFrequency", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxClockFrequency, 0), "maxClockFrequency() -> retval\n."}, |  | 77472 | {"maxClockFrequency", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxClockFrequency, 0), "maxClockFrequency() -> retval\n."},
| 77521 | {"maxComputeUnits", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxComputeUnits, 0), "maxComputeUnits() -> retval\n."}, |  | 77473 | {"maxComputeUnits", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxComputeUnits, 0), "maxComputeUnits() -> retval\n."},
| 77522 | {"maxConstantArgs", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxConstantArgs, 0), "maxConstantArgs() -> retval\n."}, |  | 77474 | {"maxConstantArgs", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxConstantArgs, 0), "maxConstantArgs() -> retval\n."},
| 77523 | {"maxConstantBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxConstantBufferSize, 0), "maxConstantBufferSize() -> retval\n."}, |  | 77475 | {"maxConstantBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxConstantBufferSize, 0), "maxConstantBufferSize() -> retval\n."},
| 77524 | {"maxMemAllocSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxMemAllocSize, 0), "maxMemAllocSize() -> retval\n."}, |  | 77476 | {"maxMemAllocSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxMemAllocSize, 0), "maxMemAllocSize() -> retval\n."},
| 77525 | {"maxParameterSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxParameterSize, 0), "maxParameterSize() -> retval\n."}, |  | 77477 | {"maxParameterSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxParameterSize, 0), "maxParameterSize() -> retval\n."},
| 77526 | {"maxReadImageArgs", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxReadImageArgs, 0), "maxReadImageArgs() -> retval\n."}, |  | 77478 | {"maxReadImageArgs", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxReadImageArgs, 0), "maxReadImageArgs() -> retval\n."},
| 77527 | {"maxSamplers", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxSamplers, 0), "maxSamplers() -> retval\n."}, |  | 77479 | {"maxSamplers", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxSamplers, 0), "maxSamplers() -> retval\n."},
| 77528 | {"maxWorkGroupSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxWorkGroupSize, 0), "maxWorkGroupSize() -> retval\n."}, |  | 77480 | {"maxWorkGroupSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxWorkGroupSize, 0), "maxWorkGroupSize() -> retval\n."},
| 77529 | {"maxWorkItemDims", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxWorkItemDims, 0), "maxWorkItemDims() -> retval\n."}, |  | 77481 | {"maxWorkItemDims", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxWorkItemDims, 0), "maxWorkItemDims() -> retval\n."},
| 77530 | {"maxWriteImageArgs", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxWriteImageArgs, 0), "maxWriteImageArgs() -> retval\n."}, |  | 77482 | {"maxWriteImageArgs", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_maxWriteImageArgs, 0), "maxWriteImageArgs() -> retval\n."},
| 77531 | {"memBaseAddrAlign", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_memBaseAddrAlign, 0), "memBaseAddrAlign() -> retval\n."}, |  | 77483 | {"memBaseAddrAlign", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_memBaseAddrAlign, 0), "memBaseAddrAlign() -> retval\n."},
| 77532 | {"name", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_name, 0), "name() -> retval\n."}, |  | 77484 | {"name", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_name, 0), "name() -> retval\n."},
| 77533 | {"nativeVectorWidthChar", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthChar, 0), "nativeVectorWidthChar() -> retval\n."}, |  | 77485 | {"nativeVectorWidthChar", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthChar, 0), "nativeVectorWidthChar() -> retval\n."},
| 77534 | {"nativeVectorWidthDouble", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthDouble, 0), "nativeVectorWidthDouble() -> retval\n."}, |  | 77486 | {"nativeVectorWidthDouble", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthDouble, 0), "nativeVectorWidthDouble() -> retval\n."},
| 77535 | {"nativeVectorWidthFloat", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthFloat, 0), "nativeVectorWidthFloat() -> retval\n."}, |  | 77487 | {"nativeVectorWidthFloat", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthFloat, 0), "nativeVectorWidthFloat() -> retval\n."},
| 77536 | {"nativeVectorWidthHalf", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthHalf, 0), "nativeVectorWidthHalf() -> retval\n."}, |  | 77488 | {"nativeVectorWidthHalf", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthHalf, 0), "nativeVectorWidthHalf() -> retval\n."},
| 77537 | {"nativeVectorWidthInt", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthInt, 0), "nativeVectorWidthInt() -> retval\n."}, |  | 77489 | {"nativeVectorWidthInt", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthInt, 0), "nativeVectorWidthInt() -> retval\n."},
| 77538 | {"nativeVectorWidthLong", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthLong, 0), "nativeVectorWidthLong() -> retval\n."}, |  | 77490 | {"nativeVectorWidthLong", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthLong, 0), "nativeVectorWidthLong() -> retval\n."},
| 77539 | {"nativeVectorWidthShort", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthShort, 0), "nativeVectorWidthShort() -> retval\n."}, |  | 77491 | {"nativeVectorWidthShort", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_nativeVectorWidthShort, 0), "nativeVectorWidthShort() -> retval\n."},
| 77540 | {"preferredVectorWidthChar", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthChar, 0), "preferredVectorWidthChar() -> retval\n."}, |  | 77492 | {"preferredVectorWidthChar", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthChar, 0), "preferredVectorWidthChar() -> retval\n."},
| 77541 | {"preferredVectorWidthDouble", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthDouble, 0), "preferredVectorWidthDouble() -> retval\n."}, |  | 77493 | {"preferredVectorWidthDouble", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthDouble, 0), "preferredVectorWidthDouble() -> retval\n."},
| 77542 | {"preferredVectorWidthFloat", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthFloat, 0), "preferredVectorWidthFloat() -> retval\n."}, |  | 77494 | {"preferredVectorWidthFloat", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthFloat, 0), "preferredVectorWidthFloat() -> retval\n."},
| 77543 | {"preferredVectorWidthHalf", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthHalf, 0), "preferredVectorWidthHalf() -> retval\n."}, |  | 77495 | {"preferredVectorWidthHalf", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthHalf, 0), "preferredVectorWidthHalf() -> retval\n."},
| 77544 | {"preferredVectorWidthInt", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthInt, 0), "preferredVectorWidthInt() -> retval\n."}, |  | 77496 | {"preferredVectorWidthInt", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthInt, 0), "preferredVectorWidthInt() -> retval\n."},
| 77545 | {"preferredVectorWidthLong", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthLong, 0), "preferredVectorWidthLong() -> retval\n."}, |  | 77497 | {"preferredVectorWidthLong", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthLong, 0), "preferredVectorWidthLong() -> retval\n."},
| 77546 | {"preferredVectorWidthShort", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthShort, 0), "preferredVectorWidthShort() -> retval\n."}, |  | 77498 | {"preferredVectorWidthShort", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_preferredVectorWidthShort, 0), "preferredVectorWidthShort() -> retval\n."},
| 77547 | {"printfBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_printfBufferSize, 0), "printfBufferSize() -> retval\n."}, |  | 77499 | {"printfBufferSize", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_printfBufferSize, 0), "printfBufferSize() -> retval\n."},
| 77548 | {"profilingTimerResolution", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_profilingTimerResolution, 0), "profilingTimerResolution() -> retval\n."}, |  | 77500 | {"profilingTimerResolution", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_profilingTimerResolution, 0), "profilingTimerResolution() -> retval\n."},
| 77549 | {"singleFPConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_singleFPConfig, 0), "singleFPConfig() -> retval\n."}, |  | 77501 | {"singleFPConfig", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_singleFPConfig, 0), "singleFPConfig() -> retval\n."},
| 77550 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_type, 0), "type() -> retval\n."}, |  | 77502 | {"type", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_type, 0), "type() -> retval\n."},
| 77551 | {"vendorID", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_vendorID, 0), "vendorID() -> retval\n."}, |  | 77503 | {"vendorID", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_vendorID, 0), "vendorID() -> retval\n."},
| 77552 | {"vendorName", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_vendorName, 0), "vendorName() -> retval\n."}, |  | 77504 | {"vendorName", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_vendorName, 0), "vendorName() -> retval\n."},
| 77553 | {"version", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_version, 0), "version() -> retval\n."}, |  | 77505 | {"version", CV_PY_FN_WITH_KW_(pyopencv_cv_ocl_ocl_Device_version, 0), "version() -> retval\n."},
| 77554 |  |  | 77506 |
| 77555 | {NULL, NULL} |  | 77507 | {NULL, NULL}
| 77556 | }; |  | 77508 | };
| 77557 |  |  | 77509 |
| 77558 | // Converter (ocl_Device) |  | 77510 | // Converter (ocl_Device)
| 77559 |  |  | 77511 |
| 77560 | template<> |  | 77512 | template<>
| 77561 | struct PyOpenCV_Converter< cv::ocl::Device > |  | 77513 | struct PyOpenCV_Converter< cv::ocl::Device >
| 77562 | { |  | 77514 | {
| 77563 | static PyObject* from(const cv::ocl::Device& r) |  | 77515 | static PyObject* from(const cv::ocl::Device& r)
| 77564 | { |  | 77516 | {
| 77565 | return pyopencv_ocl_Device_Instance(r); |  | 77517 | return pyopencv_ocl_Device_Instance(r);
| 77566 | } |  | 77518 | }
| 77567 | static bool to(PyObject* src, cv::ocl::Device& dst, const ArgInfo& info) |  | 77519 | static bool to(PyObject* src, cv::ocl::Device& dst, const ArgInfo& info)
| 77568 | { |  | 77520 | {
| 77569 | if(!src || src == Py_None) |  | 77521 | if(!src || src == Py_None)
| 77570 | return true; |  | 77522 | return true;
| 77571 | cv::ocl::Device * dst_; |  | 77523 | cv::ocl::Device * dst_;
| 77572 | if (pyopencv_ocl_Device_getp(src, dst_)) |  | 77524 | if (pyopencv_ocl_Device_getp(src, dst_))
| 77573 | { |  | 77525 | {
| 77574 | dst = *dst_; |  | 77526 | dst = *dst_;
| 77575 | return true; |  | 77527 | return true;
| 77576 | } |  | 77528 | }
| 77577 |  |  | 77529 |
| 77578 | failmsg("Expected cv::ocl::Device for argument '%s'", info.name); |  | 77530 | failmsg("Expected cv::ocl::Device for argument '%s'", info.name);
| 77579 | return false; |  | 77531 | return false;
| 77580 | } |  | 77532 | }
| 77581 | }; |  | 77533 | };
| 77582 |  |  | 77534 |
| 77583 | //================================================================================ |  | 77535 | //================================================================================
| 77584 | // ocl_OpenCLExecutionContext (Generic) |  | 77536 | // ocl_OpenCLExecutionContext (Generic)
| 77585 | //================================================================================ |  | 77537 | //================================================================================
| 77586 |  |  | 77538 |
| 77587 | // GetSet (ocl_OpenCLExecutionContext) |  | 77539 | // GetSet (ocl_OpenCLExecutionContext)
| 77588 |  |  | 77540 |
| 77589 |  |  | 77541 |
| 77590 |  |  | 77542 |
| 77591 | // Methods (ocl_OpenCLExecutionContext) |  | 77543 | // Methods (ocl_OpenCLExecutionContext)
| 77592 |  |  | 77544 |
| 77593 |  |  | 77545 |
| 77594 |  |  | 77546 |
| 77595 | // Tables (ocl_OpenCLExecutionContext) |  | 77547 | // Tables (ocl_OpenCLExecutionContext)
| 77596 |  |  | 77548 |
| 77597 | static PyGetSetDef pyopencv_ocl_OpenCLExecutionContext_getseters[] = |  | 77549 | static PyGetSetDef pyopencv_ocl_OpenCLExecutionContext_getseters[] =
| 77598 | { |  | 77550 | {
| 77599 | {NULL} /* Sentinel */ |  | 77551 | {NULL} /* Sentinel */
| 77600 | }; |  | 77552 | };
| 77601 |  |  | 77553 |
| 77602 | static PyMethodDef pyopencv_ocl_OpenCLExecutionContext_methods[] = |  | 77554 | static PyMethodDef pyopencv_ocl_OpenCLExecutionContext_methods[] =
| 77603 | { |  | 77555 | {
| 77604 |  |  | 77556 |
| 77605 | {NULL, NULL} |  | 77557 | {NULL, NULL}
| 77606 | }; |  | 77558 | };
| 77607 |  |  | 77559 |
| 77608 | // Converter (ocl_OpenCLExecutionContext) |  | 77560 | // Converter (ocl_OpenCLExecutionContext)
| 77609 |  |  | 77561 |
| 77610 | template<> |  | 77562 | template<>
| 77611 | struct PyOpenCV_Converter< Ptr<cv::ocl::OpenCLExecutionContext> > |  | 77563 | struct PyOpenCV_Converter< Ptr<cv::ocl::OpenCLExecutionContext> >
| 77612 | { |  | 77564 | {
| 77613 | static PyObject* from(const Ptr<cv::ocl::OpenCLExecutionContext>& r) |  | 77565 | static PyObject* from(const Ptr<cv::ocl::OpenCLExecutionContext>& r)
| 77614 | { |  | 77566 | {
| 77615 | return pyopencv_ocl_OpenCLExecutionContext_Instance(r); |  | 77567 | return pyopencv_ocl_OpenCLExecutionContext_Instance(r);
| 77616 | } |  | 77568 | }
| 77617 | static bool to(PyObject* src, Ptr<cv::ocl::OpenCLExecutionContext>& dst, const ArgInfo& info) |  | 77569 | static bool to(PyObject* src, Ptr<cv::ocl::OpenCLExecutionContext>& dst, const ArgInfo& info)
| 77618 | { |  | 77570 | {
| 77619 | if(!src || src == Py_None) |  | 77571 | if(!src || src == Py_None)
| 77620 | return true; |  | 77572 | return true;
| 77621 | Ptr<cv::ocl::OpenCLExecutionContext> * dst_; |  | 77573 | Ptr<cv::ocl::OpenCLExecutionContext> * dst_;
| 77622 | if (pyopencv_ocl_OpenCLExecutionContext_getp(src, dst_)) |  | 77574 | if (pyopencv_ocl_OpenCLExecutionContext_getp(src, dst_))
| 77623 | { |  | 77575 | {
| 77624 | dst = *dst_; |  | 77576 | dst = *dst_;
| 77625 | return true; |  | 77577 | return true;
| 77626 | } |  | 77578 | }
| 77627 |  |  | 77579 |
| 77628 | failmsg("Expected Ptr<cv::ocl::OpenCLExecutionContext> for argument '%s'", info.name); |  | 77580 | failmsg("Expected Ptr<cv::ocl::OpenCLExecutionContext> for argument '%s'", info.name);
| 77629 | return false; |  | 77581 | return false;
| 77630 | } |  | 77582 | }
| 77631 | }; |  | 77583 | };
| 77632 |  |  | 77584 |
| 77633 | //================================================================================ |  | 77585 | //================================================================================
| 77634 | // optflow_DenseRLOFOpticalFlow (Generic) |  | 77586 | // optflow_DenseRLOFOpticalFlow (Generic)
| 77635 | //================================================================================ |  | 77587 | //================================================================================
| 77636 |  |  | 77588 |
| 77637 | // GetSet (optflow_DenseRLOFOpticalFlow) |  | 77589 | // GetSet (optflow_DenseRLOFOpticalFlow)
| 77638 |  |  | 77590 |
| 77639 |  |  | 77591 |
| 77640 |  |  | 77592 |
| 77641 | // Methods (optflow_DenseRLOFOpticalFlow) |  | 77593 | // Methods (optflow_DenseRLOFOpticalFlow)
| 77642 |  |  | 77594 |
| 77643 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77595 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 77644 | { |  | 77596 | {
| 77645 | using namespace cv::optflow; |  | 77597 | using namespace cv::optflow;
| 77646 |  |  | 77598 |
| 77647 | PyObject* pyobj_rlofParam = NULL; |  | 77599 | PyObject* pyobj_rlofParam = NULL;
| 77648 | Ptr<RLOFOpticalFlowParameter> rlofParam; |  | 77600 | Ptr<RLOFOpticalFlowParameter> rlofParam;
| 77649 | PyObject* pyobj_forwardBackwardThreshold = NULL; |  | 77601 | PyObject* pyobj_forwardBackwardThreshold = NULL;
| 77650 | float forwardBackwardThreshold=1.f; |  | 77602 | float forwardBackwardThreshold=1.f;
| 77651 | PyObject* pyobj_gridStep = NULL; |  | 77603 | PyObject* pyobj_gridStep = NULL;
| 77652 | Size gridStep=Size(6, 6); |  | 77604 | Size gridStep=Size(6, 6);
| 77653 | PyObject* pyobj_interp_type = NULL; |  | 77605 | PyObject* pyobj_interp_type = NULL;
| 77654 | InterpolationType interp_type=InterpolationType::INTERP_EPIC; |  | 77606 | InterpolationType interp_type=InterpolationType::INTERP_EPIC;
| 77655 | PyObject* pyobj_epicK = NULL; |  | 77607 | PyObject* pyobj_epicK = NULL;
| 77656 | int epicK=128; |  | 77608 | int epicK=128;
| 77657 | PyObject* pyobj_epicSigma = NULL; |  | 77609 | PyObject* pyobj_epicSigma = NULL;
| 77658 | float epicSigma=0.05f; |  | 77610 | float epicSigma=0.05f;
| 77659 | PyObject* pyobj_epicLambda = NULL; |  | 77611 | PyObject* pyobj_epicLambda = NULL;
| 77660 | float epicLambda=999.0f; |  | 77612 | float epicLambda=999.0f;
| 77661 | PyObject* pyobj_ricSPSize = NULL; |  | 77613 | PyObject* pyobj_ricSPSize = NULL;
| 77662 | int ricSPSize=15; |  | 77614 | int ricSPSize=15;
| 77663 | PyObject* pyobj_ricSLICType = NULL; |  | 77615 | PyObject* pyobj_ricSLICType = NULL;
| 77664 | int ricSLICType=100; |  | 77616 | int ricSLICType=100;
| 77665 | PyObject* pyobj_use_post_proc = NULL; |  | 77617 | PyObject* pyobj_use_post_proc = NULL;
| 77666 | bool use_post_proc=true; |  | 77618 | bool use_post_proc=true;
| 77667 | PyObject* pyobj_fgsLambda = NULL; |  | 77619 | PyObject* pyobj_fgsLambda = NULL;
| 77668 | float fgsLambda=500.0f; |  | 77620 | float fgsLambda=500.0f;
| 77669 | PyObject* pyobj_fgsSigma = NULL; |  | 77621 | PyObject* pyobj_fgsSigma = NULL;
| 77670 | float fgsSigma=1.5f; |  | 77622 | float fgsSigma=1.5f;
| 77671 | PyObject* pyobj_use_variational_refinement = NULL; |  | 77623 | PyObject* pyobj_use_variational_refinement = NULL;
| 77672 | bool use_variational_refinement=false; |  | 77624 | bool use_variational_refinement=false;
| 77673 | Ptr<DenseRLOFOpticalFlow> retval; |  | 77625 | Ptr<DenseRLOFOpticalFlow> retval;
| 77674 |  |  | 77626 |
| 77675 | const char* keywords[] = { "rlofParam", "forwardBackwardThreshold", "gridStep", "interp_type", "epicK", "epicSigma", "epicLambda", "ricSPSize", "ricSLICType", "use_post_proc", "fgsLambda", "fgsSigma", "use_variational_refinement", NULL }; |  | 77627 | const char* keywords[] = { "rlofParam", "forwardBackwardThreshold", "gridStep", "interp_type", "epicK", "epicSigma", "epicLambda", "ricSPSize", "ricSLICType", "use_post_proc", "fgsLambda", "fgsSigma", "use_variational_refinement", NULL };
| 77676 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOOOOOO:optflow_DenseRLOFOpticalFlow.create", (char**)keywords, &pyobj_rlofParam, &pyobj_forwardBackwardThreshold, &pyobj_gridStep, &pyobj_interp_type, &pyobj_epicK, &pyobj_epicSigma, &pyobj_epicLambda, &pyobj_ricSPSize, &pyobj_ricSLICType, &pyobj_use_post_proc, &pyobj_fgsLambda, &pyobj_fgsSigma, &pyobj_use_variational_refinement) && |  | 77628 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOOOOOO:optflow_DenseRLOFOpticalFlow.create", (char**)keywords, &pyobj_rlofParam, &pyobj_forwardBackwardThreshold, &pyobj_gridStep, &pyobj_interp_type, &pyobj_epicK, &pyobj_epicSigma, &pyobj_epicLambda, &pyobj_ricSPSize, &pyobj_ricSLICType, &pyobj_use_post_proc, &pyobj_fgsLambda, &pyobj_fgsSigma, &pyobj_use_variational_refinement) &&
| 77677 | pyopencv_to_safe(pyobj_rlofParam, rlofParam, ArgInfo("rlofParam", 0)) && |  | 77629 | pyopencv_to_safe(pyobj_rlofParam, rlofParam, ArgInfo("rlofParam", 0)) &&
| 77678 | pyopencv_to_safe(pyobj_forwardBackwardThreshold, forwardBackwardThreshold, ArgInfo("forwardBackwardThreshold", 0)) && |  | 77630 | pyopencv_to_safe(pyobj_forwardBackwardThreshold, forwardBackwardThreshold, ArgInfo("forwardBackwardThreshold", 0)) &&
| 77679 | pyopencv_to_safe(pyobj_gridStep, gridStep, ArgInfo("gridStep", 0)) && |  | 77631 | pyopencv_to_safe(pyobj_gridStep, gridStep, ArgInfo("gridStep", 0)) &&
| 77680 | pyopencv_to_safe(pyobj_interp_type, interp_type, ArgInfo("interp_type", 0)) && |  | 77632 | pyopencv_to_safe(pyobj_interp_type, interp_type, ArgInfo("interp_type", 0)) &&
| 77681 | pyopencv_to_safe(pyobj_epicK, epicK, ArgInfo("epicK", 0)) && |  | 77633 | pyopencv_to_safe(pyobj_epicK, epicK, ArgInfo("epicK", 0)) &&
| 77682 | pyopencv_to_safe(pyobj_epicSigma, epicSigma, ArgInfo("epicSigma", 0)) && |  | 77634 | pyopencv_to_safe(pyobj_epicSigma, epicSigma, ArgInfo("epicSigma", 0)) &&
| 77683 | pyopencv_to_safe(pyobj_epicLambda, epicLambda, ArgInfo("epicLambda", 0)) && |  | 77635 | pyopencv_to_safe(pyobj_epicLambda, epicLambda, ArgInfo("epicLambda", 0)) &&
| 77684 | pyopencv_to_safe(pyobj_ricSPSize, ricSPSize, ArgInfo("ricSPSize", 0)) && |  | 77636 | pyopencv_to_safe(pyobj_ricSPSize, ricSPSize, ArgInfo("ricSPSize", 0)) &&
| 77685 | pyopencv_to_safe(pyobj_ricSLICType, ricSLICType, ArgInfo("ricSLICType", 0)) && |  | 77637 | pyopencv_to_safe(pyobj_ricSLICType, ricSLICType, ArgInfo("ricSLICType", 0)) &&
| 77686 | pyopencv_to_safe(pyobj_use_post_proc, use_post_proc, ArgInfo("use_post_proc", 0)) && |  | 77638 | pyopencv_to_safe(pyobj_use_post_proc, use_post_proc, ArgInfo("use_post_proc", 0)) &&
| 77687 | pyopencv_to_safe(pyobj_fgsLambda, fgsLambda, ArgInfo("fgsLambda", 0)) && |  | 77639 | pyopencv_to_safe(pyobj_fgsLambda, fgsLambda, ArgInfo("fgsLambda", 0)) &&
| 77688 | pyopencv_to_safe(pyobj_fgsSigma, fgsSigma, ArgInfo("fgsSigma", 0)) && |  | 77640 | pyopencv_to_safe(pyobj_fgsSigma, fgsSigma, ArgInfo("fgsSigma", 0)) &&
| 77689 | pyopencv_to_safe(pyobj_use_variational_refinement, use_variational_refinement, ArgInfo("use_variational_refinement", 0)) ) |  | 77641 | pyopencv_to_safe(pyobj_use_variational_refinement, use_variational_refinement, ArgInfo("use_variational_refinement", 0)) )
| 77690 | { |  | 77642 | {
| 77691 | ERRWRAP2(retval = cv::optflow::DenseRLOFOpticalFlow::create(rlofParam, forwardBackwardThreshold, gridStep, interp_type, epicK, epicSigma, epicLambda, ricSPSize, ricSLICType, use_post_proc, fgsLambda, fgsSigma, use_variational_refinement)); |  | 77643 | ERRWRAP2(retval = cv::optflow::DenseRLOFOpticalFlow::create(rlofParam, forwardBackwardThreshold, gridStep, interp_type, epicK, epicSigma, epicLambda, ricSPSize, ricSLICType, use_post_proc, fgsLambda, fgsSigma, use_variational_refinement));
| 77692 | return pyopencv_from(retval); |  | 77644 | return pyopencv_from(retval);
| 77693 | } |  | 77645 | }
| 77694 |  |  | 77646 |
| 77695 | return NULL; |  | 77647 | return NULL;
| 77696 | } |  | 77648 | }
| 77697 |  |  | 77649 |
| 77698 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77650 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICK(PyObject* self, PyObject* py_args, PyObject* kw)
| 77699 | { |  | 77651 | {
| 77700 | using namespace cv::optflow; |  | 77652 | using namespace cv::optflow;
| 77701 |  |  | 77653 |
| 77702 |  |  | 77654 |
| 77703 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77655 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77704 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77656 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77705 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77657 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77706 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77658 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77707 | int retval; |  | 77659 | int retval;
| 77708 |  |  | 77660 |
| 77709 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77661 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77710 | { |  | 77662 | {
| 77711 | ERRWRAP2(retval = _self_->getEPICK()); |  | 77663 | ERRWRAP2(retval = _self_->getEPICK());
| 77712 | return pyopencv_from(retval); |  | 77664 | return pyopencv_from(retval);
| 77713 | } |  | 77665 | }
| 77714 |  |  | 77666 |
| 77715 | return NULL; |  | 77667 | return NULL;
| 77716 | } |  | 77668 | }
| 77717 |  |  | 77669 |
| 77718 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77670 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 77719 | { |  | 77671 | {
| 77720 | using namespace cv::optflow; |  | 77672 | using namespace cv::optflow;
| 77721 |  |  | 77673 |
| 77722 |  |  | 77674 |
| 77723 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77675 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77724 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77676 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77725 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77677 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77726 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77678 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77727 | float retval; |  | 77679 | float retval;
| 77728 |  |  | 77680 |
| 77729 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77681 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77730 | { |  | 77682 | {
| 77731 | ERRWRAP2(retval = _self_->getEPICLambda()); |  | 77683 | ERRWRAP2(retval = _self_->getEPICLambda());
| 77732 | return pyopencv_from(retval); |  | 77684 | return pyopencv_from(retval);
| 77733 | } |  | 77685 | }
| 77734 |  |  | 77686 |
| 77735 | return NULL; |  | 77687 | return NULL;
| 77736 | } |  | 77688 | }
| 77737 |  |  | 77689 |
| 77738 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77690 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 77739 | { |  | 77691 | {
| 77740 | using namespace cv::optflow; |  | 77692 | using namespace cv::optflow;
| 77741 |  |  | 77693 |
| 77742 |  |  | 77694 |
| 77743 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77695 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77744 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77696 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77745 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77697 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77746 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77698 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77747 | float retval; |  | 77699 | float retval;
| 77748 |  |  | 77700 |
| 77749 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77701 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77750 | { |  | 77702 | {
| 77751 | ERRWRAP2(retval = _self_->getEPICSigma()); |  | 77703 | ERRWRAP2(retval = _self_->getEPICSigma());
| 77752 | return pyopencv_from(retval); |  | 77704 | return pyopencv_from(retval);
| 77753 | } |  | 77705 | }
| 77754 |  |  | 77706 |
| 77755 | return NULL; |  | 77707 | return NULL;
| 77756 | } |  | 77708 | }
| 77757 |  |  | 77709 |
| 77758 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77710 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 77759 | { |  | 77711 | {
| 77760 | using namespace cv::optflow; |  | 77712 | using namespace cv::optflow;
| 77761 |  |  | 77713 |
| 77762 |  |  | 77714 |
| 77763 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77715 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77764 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77716 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77765 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77717 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77766 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77718 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77767 | float retval; |  | 77719 | float retval;
| 77768 |  |  | 77720 |
| 77769 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77721 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77770 | { |  | 77722 | {
| 77771 | ERRWRAP2(retval = _self_->getFgsLambda()); |  | 77723 | ERRWRAP2(retval = _self_->getFgsLambda());
| 77772 | return pyopencv_from(retval); |  | 77724 | return pyopencv_from(retval);
| 77773 | } |  | 77725 | }
| 77774 |  |  | 77726 |
| 77775 | return NULL; |  | 77727 | return NULL;
| 77776 | } |  | 77728 | }
| 77777 |  |  | 77729 |
| 77778 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77730 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 77779 | { |  | 77731 | {
| 77780 | using namespace cv::optflow; |  | 77732 | using namespace cv::optflow;
| 77781 |  |  | 77733 |
| 77782 |  |  | 77734 |
| 77783 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77735 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77784 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77736 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77785 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77737 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77786 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77738 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77787 | float retval; |  | 77739 | float retval;
| 77788 |  |  | 77740 |
| 77789 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77741 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77790 | { |  | 77742 | {
| 77791 | ERRWRAP2(retval = _self_->getFgsSigma()); |  | 77743 | ERRWRAP2(retval = _self_->getFgsSigma());
| 77792 | return pyopencv_from(retval); |  | 77744 | return pyopencv_from(retval);
| 77793 | } |  | 77745 | }
| 77794 |  |  | 77746 |
| 77795 | return NULL; |  | 77747 | return NULL;
| 77796 | } |  | 77748 | }
| 77797 |  |  | 77749 |
| 77798 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77750 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw)
| 77799 | { |  | 77751 | {
| 77800 | using namespace cv::optflow; |  | 77752 | using namespace cv::optflow;
| 77801 |  |  | 77753 |
| 77802 |  |  | 77754 |
| 77803 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77755 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77804 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77756 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77805 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77757 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77806 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77758 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77807 | float retval; |  | 77759 | float retval;
| 77808 |  |  | 77760 |
| 77809 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77761 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77810 | { |  | 77762 | {
| 77811 | ERRWRAP2(retval = _self_->getForwardBackward()); |  | 77763 | ERRWRAP2(retval = _self_->getForwardBackward());
| 77812 | return pyopencv_from(retval); |  | 77764 | return pyopencv_from(retval);
| 77813 | } |  | 77765 | }
| 77814 |  |  | 77766 |
| 77815 | return NULL; |  | 77767 | return NULL;
| 77816 | } |  | 77768 | }
| 77817 |  |  | 77769 |
| 77818 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getGridStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77770 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getGridStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 77819 | { |  | 77771 | {
| 77820 | using namespace cv::optflow; |  | 77772 | using namespace cv::optflow;
| 77821 |  |  | 77773 |
| 77822 |  |  | 77774 |
| 77823 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77775 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77824 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77776 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77825 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77777 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77826 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77778 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77827 | Size retval; |  | 77779 | Size retval;
| 77828 |  |  | 77780 |
| 77829 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77781 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77830 | { |  | 77782 | {
| 77831 | ERRWRAP2(retval = _self_->getGridStep()); |  | 77783 | ERRWRAP2(retval = _self_->getGridStep());
| 77832 | return pyopencv_from(retval); |  | 77784 | return pyopencv_from(retval);
| 77833 | } |  | 77785 | }
| 77834 |  |  | 77786 |
| 77835 | return NULL; |  | 77787 | return NULL;
| 77836 | } |  | 77788 | }
| 77837 |  |  | 77789 |
| 77838 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getInterpolation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77790 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getInterpolation(PyObject* self, PyObject* py_args, PyObject* kw)
| 77839 | { |  | 77791 | {
| 77840 | using namespace cv::optflow; |  | 77792 | using namespace cv::optflow;
| 77841 |  |  | 77793 |
| 77842 |  |  | 77794 |
| 77843 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77795 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77844 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77796 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77845 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77797 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77846 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77798 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77847 | InterpolationType retval; |  | 77799 | InterpolationType retval;
| 77848 |  |  | 77800 |
| 77849 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77801 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77850 | { |  | 77802 | {
| 77851 | ERRWRAP2(retval = _self_->getInterpolation()); |  | 77803 | ERRWRAP2(retval = _self_->getInterpolation());
| 77852 | return pyopencv_from(retval); |  | 77804 | return pyopencv_from(retval);
| 77853 | } |  | 77805 | }
| 77854 |  |  | 77806 |
| 77855 | return NULL; |  | 77807 | return NULL;
| 77856 | } |  | 77808 | }
| 77857 |  |  | 77809 |
| 77858 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSLICType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77810 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSLICType(PyObject* self, PyObject* py_args, PyObject* kw)
| 77859 | { |  | 77811 | {
| 77860 | using namespace cv::optflow; |  | 77812 | using namespace cv::optflow;
| 77861 |  |  | 77813 |
| 77862 |  |  | 77814 |
| 77863 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77815 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77864 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77816 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77865 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77817 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77866 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77818 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77867 | int retval; |  | 77819 | int retval;
| 77868 |  |  | 77820 |
| 77869 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77821 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77870 | { |  | 77822 | {
| 77871 | ERRWRAP2(retval = _self_->getRICSLICType()); |  | 77823 | ERRWRAP2(retval = _self_->getRICSLICType());
| 77872 | return pyopencv_from(retval); |  | 77824 | return pyopencv_from(retval);
| 77873 | } |  | 77825 | }
| 77874 |  |  | 77826 |
| 77875 | return NULL; |  | 77827 | return NULL;
| 77876 | } |  | 77828 | }
| 77877 |  |  | 77829 |
| 77878 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSPSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77830 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSPSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 77879 | { |  | 77831 | {
| 77880 | using namespace cv::optflow; |  | 77832 | using namespace cv::optflow;
| 77881 |  |  | 77833 |
| 77882 |  |  | 77834 |
| 77883 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77835 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77884 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77836 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77885 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77837 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77886 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77838 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77887 | int retval; |  | 77839 | int retval;
| 77888 |  |  | 77840 |
| 77889 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77841 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77890 | { |  | 77842 | {
| 77891 | ERRWRAP2(retval = _self_->getRICSPSize()); |  | 77843 | ERRWRAP2(retval = _self_->getRICSPSize());
| 77892 | return pyopencv_from(retval); |  | 77844 | return pyopencv_from(retval);
| 77893 | } |  | 77845 | }
| 77894 |  |  | 77846 |
| 77895 | return NULL; |  | 77847 | return NULL;
| 77896 | } |  | 77848 | }
| 77897 |  |  | 77849 |
| 77898 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77850 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw)
| 77899 | { |  | 77851 | {
| 77900 | using namespace cv::optflow; |  | 77852 | using namespace cv::optflow;
| 77901 |  |  | 77853 |
| 77902 |  |  | 77854 |
| 77903 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77855 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77904 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77856 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77905 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77857 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77906 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77858 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77907 | Ptr<RLOFOpticalFlowParameter> retval; |  | 77859 | Ptr<RLOFOpticalFlowParameter> retval;
| 77908 |  |  | 77860 |
| 77909 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77861 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77910 | { |  | 77862 | {
| 77911 | ERRWRAP2(retval = _self_->getRLOFOpticalFlowParameter()); |  | 77863 | ERRWRAP2(retval = _self_->getRLOFOpticalFlowParameter());
| 77912 | return pyopencv_from(retval); |  | 77864 | return pyopencv_from(retval);
| 77913 | } |  | 77865 | }
| 77914 |  |  | 77866 |
| 77915 | return NULL; |  | 77867 | return NULL;
| 77916 | } |  | 77868 | }
| 77917 |  |  | 77869 |
| 77918 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUsePostProc(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77870 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUsePostProc(PyObject* self, PyObject* py_args, PyObject* kw)
| 77919 | { |  | 77871 | {
| 77920 | using namespace cv::optflow; |  | 77872 | using namespace cv::optflow;
| 77921 |  |  | 77873 |
| 77922 |  |  | 77874 |
| 77923 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77875 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77924 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77876 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77925 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77877 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77926 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77878 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77927 | bool retval; |  | 77879 | bool retval;
| 77928 |  |  | 77880 |
| 77929 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77881 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77930 | { |  | 77882 | {
| 77931 | ERRWRAP2(retval = _self_->getUsePostProc()); |  | 77883 | ERRWRAP2(retval = _self_->getUsePostProc());
| 77932 | return pyopencv_from(retval); |  | 77884 | return pyopencv_from(retval);
| 77933 | } |  | 77885 | }
| 77934 |  |  | 77886 |
| 77935 | return NULL; |  | 77887 | return NULL;
| 77936 | } |  | 77888 | }
| 77937 |  |  | 77889 |
| 77938 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUseVariationalRefinement(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77890 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUseVariationalRefinement(PyObject* self, PyObject* py_args, PyObject* kw)
| 77939 | { |  | 77891 | {
| 77940 | using namespace cv::optflow; |  | 77892 | using namespace cv::optflow;
| 77941 |  |  | 77893 |
| 77942 |  |  | 77894 |
| 77943 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77895 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77944 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77896 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77945 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77897 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77946 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77898 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77947 | bool retval; |  | 77899 | bool retval;
| 77948 |  |  | 77900 |
| 77949 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 77901 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 77950 | { |  | 77902 | {
| 77951 | ERRWRAP2(retval = _self_->getUseVariationalRefinement()); |  | 77903 | ERRWRAP2(retval = _self_->getUseVariationalRefinement());
| 77952 | return pyopencv_from(retval); |  | 77904 | return pyopencv_from(retval);
| 77953 | } |  | 77905 | }
| 77954 |  |  | 77906 |
| 77955 | return NULL; |  | 77907 | return NULL;
| 77956 | } |  | 77908 | }
| 77957 |  |  | 77909 |
| 77958 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77910 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICK(PyObject* self, PyObject* py_args, PyObject* kw)
| 77959 | { |  | 77911 | {
| 77960 | using namespace cv::optflow; |  | 77912 | using namespace cv::optflow;
| 77961 |  |  | 77913 |
| 77962 |  |  | 77914 |
| 77963 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77915 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77964 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77916 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77965 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77917 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77966 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77918 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77967 | PyObject* pyobj_val = NULL; |  | 77919 | PyObject* pyobj_val = NULL;
| 77968 | int val=0; |  | 77920 | int val=0;
| 77969 |  |  | 77921 |
| 77970 | const char* keywords[] = { "val", NULL }; |  | 77922 | const char* keywords[] = { "val", NULL };
| 77971 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setEPICK", (char**)keywords, &pyobj_val) && |  | 77923 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setEPICK", (char**)keywords, &pyobj_val) &&
| 77972 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 77924 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 77973 | { |  | 77925 | {
| 77974 | ERRWRAP2(_self_->setEPICK(val)); |  | 77926 | ERRWRAP2(_self_->setEPICK(val));
| 77975 | Py_RETURN_NONE; |  | 77927 | Py_RETURN_NONE;
| 77976 | } |  | 77928 | }
| 77977 |  |  | 77929 |
| 77978 | return NULL; |  | 77930 | return NULL;
| 77979 | } |  | 77931 | }
| 77980 |  |  | 77932 |
| 77981 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77933 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 77982 | { |  | 77934 | {
| 77983 | using namespace cv::optflow; |  | 77935 | using namespace cv::optflow;
| 77984 |  |  | 77936 |
| 77985 |  |  | 77937 |
| 77986 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77938 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 77987 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77939 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 77988 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77940 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 77989 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77941 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 77990 | PyObject* pyobj_val = NULL; |  | 77942 | PyObject* pyobj_val = NULL;
| 77991 | float val=0.f; |  | 77943 | float val=0.f;
| 77992 |  |  | 77944 |
| 77993 | const char* keywords[] = { "val", NULL }; |  | 77945 | const char* keywords[] = { "val", NULL };
| 77994 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setEPICLambda", (char**)keywords, &pyobj_val) && |  | 77946 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setEPICLambda", (char**)keywords, &pyobj_val) &&
| 77995 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 77947 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 77996 | { |  | 77948 | {
| 77997 | ERRWRAP2(_self_->setEPICLambda(val)); |  | 77949 | ERRWRAP2(_self_->setEPICLambda(val));
| 77998 | Py_RETURN_NONE; |  | 77950 | Py_RETURN_NONE;
| 77999 | } |  | 77951 | }
| 78000 |  |  | 77952 |
| 78001 | return NULL; |  | 77953 | return NULL;
| 78002 | } |  | 77954 | }
| 78003 |  |  | 77955 |
| 78004 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77956 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 78005 | { |  | 77957 | {
| 78006 | using namespace cv::optflow; |  | 77958 | using namespace cv::optflow;
| 78007 |  |  | 77959 |
| 78008 |  |  | 77960 |
| 78009 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77961 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78010 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77962 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78011 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77963 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78012 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77964 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78013 | PyObject* pyobj_val = NULL; |  | 77965 | PyObject* pyobj_val = NULL;
| 78014 | float val=0.f; |  | 77966 | float val=0.f;
| 78015 |  |  | 77967 |
| 78016 | const char* keywords[] = { "val", NULL }; |  | 77968 | const char* keywords[] = { "val", NULL };
| 78017 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setEPICSigma", (char**)keywords, &pyobj_val) && |  | 77969 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setEPICSigma", (char**)keywords, &pyobj_val) &&
| 78018 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 77970 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78019 | { |  | 77971 | {
| 78020 | ERRWRAP2(_self_->setEPICSigma(val)); |  | 77972 | ERRWRAP2(_self_->setEPICSigma(val));
| 78021 | Py_RETURN_NONE; |  | 77973 | Py_RETURN_NONE;
| 78022 | } |  | 77974 | }
| 78023 |  |  | 77975 |
| 78024 | return NULL; |  | 77976 | return NULL;
| 78025 | } |  | 77977 | }
| 78026 |  |  | 77978 |
| 78027 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 77979 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 78028 | { |  | 77980 | {
| 78029 | using namespace cv::optflow; |  | 77981 | using namespace cv::optflow;
| 78030 |  |  | 77982 |
| 78031 |  |  | 77983 |
| 78032 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 77984 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78033 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 77985 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78034 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 77986 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78035 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 77987 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78036 | PyObject* pyobj_val = NULL; |  | 77988 | PyObject* pyobj_val = NULL;
| 78037 | float val=0.f; |  | 77989 | float val=0.f;
| 78038 |  |  | 77990 |
| 78039 | const char* keywords[] = { "val", NULL }; |  | 77991 | const char* keywords[] = { "val", NULL };
| 78040 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setFgsLambda", (char**)keywords, &pyobj_val) && |  | 77992 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setFgsLambda", (char**)keywords, &pyobj_val) &&
| 78041 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 77993 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78042 | { |  | 77994 | {
| 78043 | ERRWRAP2(_self_->setFgsLambda(val)); |  | 77995 | ERRWRAP2(_self_->setFgsLambda(val));
| 78044 | Py_RETURN_NONE; |  | 77996 | Py_RETURN_NONE;
| 78045 | } |  | 77997 | }
| 78046 |  |  | 77998 |
| 78047 | return NULL; |  | 77999 | return NULL;
| 78048 | } |  | 78000 | }
| 78049 |  |  | 78001 |
| 78050 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsSigma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78002 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsSigma(PyObject* self, PyObject* py_args, PyObject* kw)
| 78051 | { |  | 78003 | {
| 78052 | using namespace cv::optflow; |  | 78004 | using namespace cv::optflow;
| 78053 |  |  | 78005 |
| 78054 |  |  | 78006 |
| 78055 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78007 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78056 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78008 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78057 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78009 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78058 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78010 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78059 | PyObject* pyobj_val = NULL; |  | 78011 | PyObject* pyobj_val = NULL;
| 78060 | float val=0.f; |  | 78012 | float val=0.f;
| 78061 |  |  | 78013 |
| 78062 | const char* keywords[] = { "val", NULL }; |  | 78014 | const char* keywords[] = { "val", NULL };
| 78063 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setFgsSigma", (char**)keywords, &pyobj_val) && |  | 78015 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setFgsSigma", (char**)keywords, &pyobj_val) &&
| 78064 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78016 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78065 | { |  | 78017 | {
| 78066 | ERRWRAP2(_self_->setFgsSigma(val)); |  | 78018 | ERRWRAP2(_self_->setFgsSigma(val));
| 78067 | Py_RETURN_NONE; |  | 78019 | Py_RETURN_NONE;
| 78068 | } |  | 78020 | }
| 78069 |  |  | 78021 |
| 78070 | return NULL; |  | 78022 | return NULL;
| 78071 | } |  | 78023 | }
| 78072 |  |  | 78024 |
| 78073 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78025 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw)
| 78074 | { |  | 78026 | {
| 78075 | using namespace cv::optflow; |  | 78027 | using namespace cv::optflow;
| 78076 |  |  | 78028 |
| 78077 |  |  | 78029 |
| 78078 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78030 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78079 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78031 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78080 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78032 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78081 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78033 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78082 | PyObject* pyobj_val = NULL; |  | 78034 | PyObject* pyobj_val = NULL;
| 78083 | float val=0.f; |  | 78035 | float val=0.f;
| 78084 |  |  | 78036 |
| 78085 | const char* keywords[] = { "val", NULL }; |  | 78037 | const char* keywords[] = { "val", NULL };
| 78086 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setForwardBackward", (char**)keywords, &pyobj_val) && |  | 78038 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setForwardBackward", (char**)keywords, &pyobj_val) &&
| 78087 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78039 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78088 | { |  | 78040 | {
| 78089 | ERRWRAP2(_self_->setForwardBackward(val)); |  | 78041 | ERRWRAP2(_self_->setForwardBackward(val));
| 78090 | Py_RETURN_NONE; |  | 78042 | Py_RETURN_NONE;
| 78091 | } |  | 78043 | }
| 78092 |  |  | 78044 |
| 78093 | return NULL; |  | 78045 | return NULL;
| 78094 | } |  | 78046 | }
| 78095 |  |  | 78047 |
| 78096 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setGridStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78048 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setGridStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 78097 | { |  | 78049 | {
| 78098 | using namespace cv::optflow; |  | 78050 | using namespace cv::optflow;
| 78099 |  |  | 78051 |
| 78100 |  |  | 78052 |
| 78101 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78053 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78102 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78054 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78103 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78055 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78104 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78056 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78105 | PyObject* pyobj_val = NULL; |  | 78057 | PyObject* pyobj_val = NULL;
| 78106 | Size val; |  | 78058 | Size val;
| 78107 |  |  | 78059 |
| 78108 | const char* keywords[] = { "val", NULL }; |  | 78060 | const char* keywords[] = { "val", NULL };
| 78109 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setGridStep", (char**)keywords, &pyobj_val) && |  | 78061 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setGridStep", (char**)keywords, &pyobj_val) &&
| 78110 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78062 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78111 | { |  | 78063 | {
| 78112 | ERRWRAP2(_self_->setGridStep(val)); |  | 78064 | ERRWRAP2(_self_->setGridStep(val));
| 78113 | Py_RETURN_NONE; |  | 78065 | Py_RETURN_NONE;
| 78114 | } |  | 78066 | }
| 78115 |  |  | 78067 |
| 78116 | return NULL; |  | 78068 | return NULL;
| 78117 | } |  | 78069 | }
| 78118 |  |  | 78070 |
| 78119 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setInterpolation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78071 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setInterpolation(PyObject* self, PyObject* py_args, PyObject* kw)
| 78120 | { |  | 78072 | {
| 78121 | using namespace cv::optflow; |  | 78073 | using namespace cv::optflow;
| 78122 |  |  | 78074 |
| 78123 |  |  | 78075 |
| 78124 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78076 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78125 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78077 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78126 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78078 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78127 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78079 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78128 | PyObject* pyobj_val = NULL; |  | 78080 | PyObject* pyobj_val = NULL;
| 78129 | InterpolationType val=static_cast<InterpolationType>(0); |  | 78081 | InterpolationType val=static_cast<InterpolationType>(0);
| 78130 |  |  | 78082 |
| 78131 | const char* keywords[] = { "val", NULL }; |  | 78083 | const char* keywords[] = { "val", NULL };
| 78132 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setInterpolation", (char**)keywords, &pyobj_val) && |  | 78084 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setInterpolation", (char**)keywords, &pyobj_val) &&
| 78133 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78085 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78134 | { |  | 78086 | {
| 78135 | ERRWRAP2(_self_->setInterpolation(val)); |  | 78087 | ERRWRAP2(_self_->setInterpolation(val));
| 78136 | Py_RETURN_NONE; |  | 78088 | Py_RETURN_NONE;
| 78137 | } |  | 78089 | }
| 78138 |  |  | 78090 |
| 78139 | return NULL; |  | 78091 | return NULL;
| 78140 | } |  | 78092 | }
| 78141 |  |  | 78093 |
| 78142 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSLICType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78094 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSLICType(PyObject* self, PyObject* py_args, PyObject* kw)
| 78143 | { |  | 78095 | {
| 78144 | using namespace cv::optflow; |  | 78096 | using namespace cv::optflow;
| 78145 |  |  | 78097 |
| 78146 |  |  | 78098 |
| 78147 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78099 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78148 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78100 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78149 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78101 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78150 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78102 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78151 | PyObject* pyobj_val = NULL; |  | 78103 | PyObject* pyobj_val = NULL;
| 78152 | int val=0; |  | 78104 | int val=0;
| 78153 |  |  | 78105 |
| 78154 | const char* keywords[] = { "val", NULL }; |  | 78106 | const char* keywords[] = { "val", NULL };
| 78155 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setRICSLICType", (char**)keywords, &pyobj_val) && |  | 78107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setRICSLICType", (char**)keywords, &pyobj_val) &&
| 78156 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78108 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78157 | { |  | 78109 | {
| 78158 | ERRWRAP2(_self_->setRICSLICType(val)); |  | 78110 | ERRWRAP2(_self_->setRICSLICType(val));
| 78159 | Py_RETURN_NONE; |  | 78111 | Py_RETURN_NONE;
| 78160 | } |  | 78112 | }
| 78161 |  |  | 78113 |
| 78162 | return NULL; |  | 78114 | return NULL;
| 78163 | } |  | 78115 | }
| 78164 |  |  | 78116 |
| 78165 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSPSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78117 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSPSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 78166 | { |  | 78118 | {
| 78167 | using namespace cv::optflow; |  | 78119 | using namespace cv::optflow;
| 78168 |  |  | 78120 |
| 78169 |  |  | 78121 |
| 78170 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78122 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78171 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78123 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78172 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78124 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78173 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78125 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78174 | PyObject* pyobj_val = NULL; |  | 78126 | PyObject* pyobj_val = NULL;
| 78175 | int val=0; |  | 78127 | int val=0;
| 78176 |  |  | 78128 |
| 78177 | const char* keywords[] = { "val", NULL }; |  | 78129 | const char* keywords[] = { "val", NULL };
| 78178 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setRICSPSize", (char**)keywords, &pyobj_val) && |  | 78130 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setRICSPSize", (char**)keywords, &pyobj_val) &&
| 78179 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78131 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78180 | { |  | 78132 | {
| 78181 | ERRWRAP2(_self_->setRICSPSize(val)); |  | 78133 | ERRWRAP2(_self_->setRICSPSize(val));
| 78182 | Py_RETURN_NONE; |  | 78134 | Py_RETURN_NONE;
| 78183 | } |  | 78135 | }
| 78184 |  |  | 78136 |
| 78185 | return NULL; |  | 78137 | return NULL;
| 78186 | } |  | 78138 | }
| 78187 |  |  | 78139 |
| 78188 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78140 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw)
| 78189 | { |  | 78141 | {
| 78190 | using namespace cv::optflow; |  | 78142 | using namespace cv::optflow;
| 78191 |  |  | 78143 |
| 78192 |  |  | 78144 |
| 78193 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78145 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78194 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78146 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78195 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78147 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78196 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78148 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78197 | PyObject* pyobj_val = NULL; |  | 78149 | PyObject* pyobj_val = NULL;
| 78198 | Ptr<RLOFOpticalFlowParameter> val; |  | 78150 | Ptr<RLOFOpticalFlowParameter> val;
| 78199 |  |  | 78151 |
| 78200 | const char* keywords[] = { "val", NULL }; |  | 78152 | const char* keywords[] = { "val", NULL };
| 78201 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setRLOFOpticalFlowParameter", (char**)keywords, &pyobj_val) && |  | 78153 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setRLOFOpticalFlowParameter", (char**)keywords, &pyobj_val) &&
| 78202 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78154 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78203 | { |  | 78155 | {
| 78204 | ERRWRAP2(_self_->setRLOFOpticalFlowParameter(val)); |  | 78156 | ERRWRAP2(_self_->setRLOFOpticalFlowParameter(val));
| 78205 | Py_RETURN_NONE; |  | 78157 | Py_RETURN_NONE;
| 78206 | } |  | 78158 | }
| 78207 |  |  | 78159 |
| 78208 | return NULL; |  | 78160 | return NULL;
| 78209 | } |  | 78161 | }
| 78210 |  |  | 78162 |
| 78211 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUsePostProc(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78163 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUsePostProc(PyObject* self, PyObject* py_args, PyObject* kw)
| 78212 | { |  | 78164 | {
| 78213 | using namespace cv::optflow; |  | 78165 | using namespace cv::optflow;
| 78214 |  |  | 78166 |
| 78215 |  |  | 78167 |
| 78216 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78168 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78217 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78169 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78218 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78170 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78219 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78171 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78220 | PyObject* pyobj_val = NULL; |  | 78172 | PyObject* pyobj_val = NULL;
| 78221 | bool val=0; |  | 78173 | bool val=0;
| 78222 |  |  | 78174 |
| 78223 | const char* keywords[] = { "val", NULL }; |  | 78175 | const char* keywords[] = { "val", NULL };
| 78224 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setUsePostProc", (char**)keywords, &pyobj_val) && |  | 78176 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setUsePostProc", (char**)keywords, &pyobj_val) &&
| 78225 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78177 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78226 | { |  | 78178 | {
| 78227 | ERRWRAP2(_self_->setUsePostProc(val)); |  | 78179 | ERRWRAP2(_self_->setUsePostProc(val));
| 78228 | Py_RETURN_NONE; |  | 78180 | Py_RETURN_NONE;
| 78229 | } |  | 78181 | }
| 78230 |  |  | 78182 |
| 78231 | return NULL; |  | 78183 | return NULL;
| 78232 | } |  | 78184 | }
| 78233 |  |  | 78185 |
| 78234 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUseVariationalRefinement(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78186 | static PyObject* pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUseVariationalRefinement(PyObject* self, PyObject* py_args, PyObject* kw)
| 78235 | { |  | 78187 | {
| 78236 | using namespace cv::optflow; |  | 78188 | using namespace cv::optflow;
| 78237 |  |  | 78189 |
| 78238 |  |  | 78190 |
| 78239 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0; |  | 78191 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * self1 = 0;
| 78240 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1)) |  | 78192 | if (!pyopencv_optflow_DenseRLOFOpticalFlow_getp(self, self1))
| 78241 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)"); |  | 78193 | return failmsgp("Incorrect type of self (must be 'optflow_DenseRLOFOpticalFlow' or its derivative)");
| 78242 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1); |  | 78194 | Ptr<cv::optflow::DenseRLOFOpticalFlow> _self_ = *(self1);
| 78243 | PyObject* pyobj_val = NULL; |  | 78195 | PyObject* pyobj_val = NULL;
| 78244 | bool val=0; |  | 78196 | bool val=0;
| 78245 |  |  | 78197 |
| 78246 | const char* keywords[] = { "val", NULL }; |  | 78198 | const char* keywords[] = { "val", NULL };
| 78247 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setUseVariationalRefinement", (char**)keywords, &pyobj_val) && |  | 78199 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DenseRLOFOpticalFlow.setUseVariationalRefinement", (char**)keywords, &pyobj_val) &&
| 78248 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78200 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78249 | { |  | 78201 | {
| 78250 | ERRWRAP2(_self_->setUseVariationalRefinement(val)); |  | 78202 | ERRWRAP2(_self_->setUseVariationalRefinement(val));
| 78251 | Py_RETURN_NONE; |  | 78203 | Py_RETURN_NONE;
| 78252 | } |  | 78204 | }
| 78253 |  |  | 78205 |
| 78254 | return NULL; |  | 78206 | return NULL;
| 78255 | } |  | 78207 | }
| 78256 |  |  | 78208 |
| 78257 |  |  | 78209 |
| 78258 |  |  | 78210 |
| 78259 | // Tables (optflow_DenseRLOFOpticalFlow) |  | 78211 | // Tables (optflow_DenseRLOFOpticalFlow)
| 78260 |  |  | 78212 |
| 78261 | static PyGetSetDef pyopencv_optflow_DenseRLOFOpticalFlow_getseters[] = |  | 78213 | static PyGetSetDef pyopencv_optflow_DenseRLOFOpticalFlow_getseters[] =
| 78262 | { |  | 78214 | {
| 78263 | {NULL} /* Sentinel */ |  | 78215 | {NULL} /* Sentinel */
| 78264 | }; |  | 78216 | };
| 78265 |  |  | 78217 |
| 78266 | static PyMethodDef pyopencv_optflow_DenseRLOFOpticalFlow_methods[] = |  | 78218 | static PyMethodDef pyopencv_optflow_DenseRLOFOpticalFlow_methods[] =
| 78267 | { |  | 78219 | {
| 78268 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_create_static, METH_STATIC), "create([, rlofParam[, forwardBackwardThreshold[, gridStep[, interp_type[, epicK[, epicSigma[, epicLambda[, ricSPSize[, ricSLICType[, use_post_proc[, fgsLambda[, fgsSigma[, use_variational_refinement]]]]]]]]]]]]]) -> retval\n. * @param rlofParam see optflow::RLOFOpticalFlowParameter\n. * @param forwardBackwardThreshold see setForwardBackward\n. * @param gridStep see setGridStep\n. * @param interp_type see setInterpolation\n. * @param epicK see setEPICK\n. * @param epicSigma see setEPICSigma\n. * @param epicLambda see setEPICLambda\n. * @param ricSPSize see setRICSPSize\n. * @param ricSLICType see setRICSLICType\n. * @param use_post_proc see setUsePostProc\n. * @param fgsLambda see setFgsLambda\n. * @param fgsSigma see setFgsSigma\n. * @param use_variational_refinement see setUseVariationalRefinement"}, |  | 78220 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_create_static, METH_STATIC), "create([, rlofParam[, forwardBackwardThreshold[, gridStep[, interp_type[, epicK[, epicSigma[, epicLambda[, ricSPSize[, ricSLICType[, use_post_proc[, fgsLambda[, fgsSigma[, use_variational_refinement]]]]]]]]]]]]]) -> retval\n. * @param rlofParam see optflow::RLOFOpticalFlowParameter\n. * @param forwardBackwardThreshold see setForwardBackward\n. * @param gridStep see setGridStep\n. * @param interp_type see setInterpolation\n. * @param epicK see setEPICK\n. * @param epicSigma see setEPICSigma\n. * @param epicLambda see setEPICLambda\n. * @param ricSPSize see setRICSPSize\n. * @param ricSLICType see setRICSLICType\n. * @param use_post_proc see setUsePostProc\n. * @param fgsLambda see setFgsLambda\n. * @param fgsSigma see setFgsSigma\n. * @param use_variational_refinement see setUseVariationalRefinement"},
| 78269 | {"getEPICK", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICK, 0), "getEPICK() -> retval\n. K is a number of nearest-neighbor matches considered, when fitting a locally affine\n. * model. Usually it should be around 128. However, lower values would make the interpolation noticeably faster.\n. * @see ximgproc::EdgeAwareInterpolator, setEPICK"}, |  | 78221 | {"getEPICK", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICK, 0), "getEPICK() -> retval\n. K is a number of nearest-neighbor matches considered, when fitting a locally affine\n. * model. Usually it should be around 128. However, lower values would make the interpolation noticeably faster.\n. * @see ximgproc::EdgeAwareInterpolator, setEPICK"},
| 78270 | {"getEPICLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICLambda, 0), "getEPICLambda() -> retval\n. Lambda is a parameter defining the weight of the edge-aware term in geodesic distance,\n. * should be in the range of 0 to 1000.\n. * @see ximgproc::EdgeAwareInterpolator, setEPICSigma"}, |  | 78222 | {"getEPICLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICLambda, 0), "getEPICLambda() -> retval\n. Lambda is a parameter defining the weight of the edge-aware term in geodesic distance,\n. * should be in the range of 0 to 1000.\n. * @see ximgproc::EdgeAwareInterpolator, setEPICSigma"},
| 78271 | {"getEPICSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICSigma, 0), "getEPICSigma() -> retval\n. Sigma is a parameter defining how fast the weights decrease in the locally-weighted affine\n. * fitting. Higher values can help preserve fine details, lower values can help to get rid of noise in the\n. * output flow.\n. * @see ximgproc::EdgeAwareInterpolator, setEPICSigma"}, |  | 78223 | {"getEPICSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getEPICSigma, 0), "getEPICSigma() -> retval\n. Sigma is a parameter defining how fast the weights decrease in the locally-weighted affine\n. * fitting. Higher values can help preserve fine details, lower values can help to get rid of noise in the\n. * output flow.\n. * @see ximgproc::EdgeAwareInterpolator, setEPICSigma"},
| 78272 | {"getFgsLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsLambda, 0), "getFgsLambda() -> retval\n. Sets the respective fastGlobalSmootherFilter() parameter.\n. * @see ximgproc::EdgeAwareInterpolator, setFgsLambda"}, |  | 78224 | {"getFgsLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsLambda, 0), "getFgsLambda() -> retval\n. Sets the respective fastGlobalSmootherFilter() parameter.\n. * @see ximgproc::EdgeAwareInterpolator, setFgsLambda"},
| 78273 | {"getFgsSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsSigma, 0), "getFgsSigma() -> retval\n. Sets the respective fastGlobalSmootherFilter() parameter.\n. * @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, setFgsSigma"}, |  | 78225 | {"getFgsSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getFgsSigma, 0), "getFgsSigma() -> retval\n. Sets the respective fastGlobalSmootherFilter() parameter.\n. * @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, setFgsSigma"},
| 78274 | {"getForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getForwardBackward, 0), "getForwardBackward() -> retval\n. @copybrief setForwardBackward\n. @see setForwardBackward"}, |  | 78226 | {"getForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getForwardBackward, 0), "getForwardBackward() -> retval\n. @copybrief setForwardBackward\n. @see setForwardBackward"},
| 78275 | {"getGridStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getGridStep, 0), "getGridStep() -> retval\n. For each grid point a motion vector is computed. Some motion vectors will be removed due to the forwatd backward\n. * threshold (if set >0). The rest will be the base of the vector field interpolation.\n. * @see getForwardBackward, setGridStep"}, |  | 78227 | {"getGridStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getGridStep, 0), "getGridStep() -> retval\n. For each grid point a motion vector is computed. Some motion vectors will be removed due to the forwatd backward\n. * threshold (if set >0). The rest will be the base of the vector field interpolation.\n. * @see getForwardBackward, setGridStep"},
| 78276 | {"getInterpolation", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getInterpolation, 0), "getInterpolation() -> retval\n. @copybrief setInterpolation\n. * @see ximgproc::EdgeAwareInterpolator, setInterpolation"}, |  | 78228 | {"getInterpolation", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getInterpolation, 0), "getInterpolation() -> retval\n. @copybrief setInterpolation\n. * @see ximgproc::EdgeAwareInterpolator, setInterpolation"},
| 78277 | {"getRICSLICType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSLICType, 0), "getRICSLICType() -> retval\n. @copybrief setRICSLICType\n. * @see setRICSLICType"}, |  | 78229 | {"getRICSLICType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSLICType, 0), "getRICSLICType() -> retval\n. @copybrief setRICSLICType\n. * @see setRICSLICType"},
| 78278 | {"getRICSPSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSPSize, 0), "getRICSPSize() -> retval\n. @copybrief setRICSPSize\n. * @see setRICSPSize"}, |  | 78230 | {"getRICSPSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRICSPSize, 0), "getRICSPSize() -> retval\n. @copybrief setRICSPSize\n. * @see setRICSPSize"},
| 78279 | {"getRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRLOFOpticalFlowParameter, 0), "getRLOFOpticalFlowParameter() -> retval\n. @copybrief setRLOFOpticalFlowParameter\n. @see optflow::RLOFOpticalFlowParameter, setRLOFOpticalFlowParameter"}, |  | 78231 | {"getRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getRLOFOpticalFlowParameter, 0), "getRLOFOpticalFlowParameter() -> retval\n. @copybrief setRLOFOpticalFlowParameter\n. @see optflow::RLOFOpticalFlowParameter, setRLOFOpticalFlowParameter"},
| 78280 | {"getUsePostProc", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUsePostProc, 0), "getUsePostProc() -> retval\n. @copybrief setUsePostProc\n. * @see ximgproc::fastGlobalSmootherFilter, setUsePostProc"}, |  | 78232 | {"getUsePostProc", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUsePostProc, 0), "getUsePostProc() -> retval\n. @copybrief setUsePostProc\n. * @see ximgproc::fastGlobalSmootherFilter, setUsePostProc"},
| 78281 | {"getUseVariationalRefinement", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUseVariationalRefinement, 0), "getUseVariationalRefinement() -> retval\n. @copybrief setUseVariationalRefinement\n. * @see ximgproc::fastGlobalSmootherFilter, setUsePostProc"}, |  | 78233 | {"getUseVariationalRefinement", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_getUseVariationalRefinement, 0), "getUseVariationalRefinement() -> retval\n. @copybrief setUseVariationalRefinement\n. * @see ximgproc::fastGlobalSmootherFilter, setUsePostProc"},
| 78282 | {"setEPICK", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICK, 0), "setEPICK(val) -> None\n. @copybrief getEPICK\n. * @see ximgproc::EdgeAwareInterpolator, getEPICK"}, |  | 78234 | {"setEPICK", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICK, 0), "setEPICK(val) -> None\n. @copybrief getEPICK\n. * @see ximgproc::EdgeAwareInterpolator, getEPICK"},
| 78283 | {"setEPICLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICLambda, 0), "setEPICLambda(val) -> None\n. @copybrief getEPICLambda\n. * @see ximgproc::EdgeAwareInterpolator, getEPICLambda"}, |  | 78235 | {"setEPICLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICLambda, 0), "setEPICLambda(val) -> None\n. @copybrief getEPICLambda\n. * @see ximgproc::EdgeAwareInterpolator, getEPICLambda"},
| 78284 | {"setEPICSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICSigma, 0), "setEPICSigma(val) -> None\n. @copybrief getEPICSigma\n. * @see ximgproc::EdgeAwareInterpolator, getEPICSigma"}, |  | 78236 | {"setEPICSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setEPICSigma, 0), "setEPICSigma(val) -> None\n. @copybrief getEPICSigma\n. * @see ximgproc::EdgeAwareInterpolator, getEPICSigma"},
| 78285 | {"setFgsLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsLambda, 0), "setFgsLambda(val) -> None\n. @copybrief getFgsLambda\n. * @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, getFgsLambda"}, |  | 78237 | {"setFgsLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsLambda, 0), "setFgsLambda(val) -> None\n. @copybrief getFgsLambda\n. * @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, getFgsLambda"},
| 78286 | {"setFgsSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsSigma, 0), "setFgsSigma(val) -> None\n. @copybrief getFgsSigma\n. * @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, getFgsSigma"}, |  | 78238 | {"setFgsSigma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setFgsSigma, 0), "setFgsSigma(val) -> None\n. @copybrief getFgsSigma\n. * @see ximgproc::EdgeAwareInterpolator, ximgproc::fastGlobalSmootherFilter, getFgsSigma"},
| 78287 | {"setForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setForwardBackward, 0), "setForwardBackward(val) -> None\n. For each grid point \\f$ \\mathbf{x} \\f$ a motion vector \\f$ d_{I0,I1}(\\mathbf{x}) \\f$ is computed.\n. * If the forward backward error \\f[ EP_{FB} = || d_{I0,I1} + d_{I1,I0} || \\f]\n. * is larger than threshold given by this function then the motion vector will not be used by the following\n. * vector field interpolation. \\f$ d_{I1,I0} \\f$ denotes the backward flow. Note, the forward backward test\n. * will only be applied if the threshold > 0. This may results into a doubled runtime for the motion estimation.\n. * @see getForwardBackward, setGridStep"}, |  | 78239 | {"setForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setForwardBackward, 0), "setForwardBackward(val) -> None\n. For each grid point \\f$ \\mathbf{x} \\f$ a motion vector \\f$ d_{I0,I1}(\\mathbf{x}) \\f$ is computed.\n. * If the forward backward error \\f[ EP_{FB} = || d_{I0,I1} + d_{I1,I0} || \\f]\n. * is larger than threshold given by this function then the motion vector will not be used by the following\n. * vector field interpolation. \\f$ d_{I1,I0} \\f$ denotes the backward flow. Note, the forward backward test\n. * will only be applied if the threshold > 0. This may results into a doubled runtime for the motion estimation.\n. * @see getForwardBackward, setGridStep"},
| 78288 | {"setGridStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setGridStep, 0), "setGridStep(val) -> None\n. @copybrief getGridStep\n. * @see getGridStep"}, |  | 78240 | {"setGridStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setGridStep, 0), "setGridStep(val) -> None\n. @copybrief getGridStep\n. * @see getGridStep"},
| 78289 | {"setInterpolation", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setInterpolation, 0), "setInterpolation(val) -> None\n. Two interpolation algorithms are supported\n. * - **INTERP_GEO** applies the fast geodesic interpolation, see @cite Geistert2016.\n. * - **INTERP_EPIC_RESIDUAL** applies the edge-preserving interpolation, see @cite Revaud2015,Geistert2016.\n. * @see ximgproc::EdgeAwareInterpolator, getInterpolation"}, |  | 78241 | {"setInterpolation", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setInterpolation, 0), "setInterpolation(val) -> None\n. Two interpolation algorithms are supported\n. * - **INTERP_GEO** applies the fast geodesic interpolation, see @cite Geistert2016.\n. * - **INTERP_EPIC_RESIDUAL** applies the edge-preserving interpolation, see @cite Revaud2015,Geistert2016.\n. * @see ximgproc::EdgeAwareInterpolator, getInterpolation"},
| 78290 | {"setRICSLICType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSLICType, 0), "setRICSLICType(val) -> None\n. @brief Parameter to choose superpixel algorithm variant to use:\n. * - cv::ximgproc::SLICType SLIC segments image using a desired region_size (value: 100)\n. * - cv::ximgproc::SLICType SLICO will optimize using adaptive compactness factor (value: 101)\n. * - cv::ximgproc::SLICType MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels (value: 102).\n. * @see cv::ximgproc::createSuperpixelSLIC, cv::ximgproc::RICInterpolator"}, |  | 78242 | {"setRICSLICType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSLICType, 0), "setRICSLICType(val) -> None\n. @brief Parameter to choose superpixel algorithm variant to use:\n. * - cv::ximgproc::SLICType SLIC segments image using a desired region_size (value: 100)\n. * - cv::ximgproc::SLICType SLICO will optimize using adaptive compactness factor (value: 101)\n. * - cv::ximgproc::SLICType MSLIC will optimize using manifold methods resulting in more content-sensitive superpixels (value: 102).\n. * @see cv::ximgproc::createSuperpixelSLIC, cv::ximgproc::RICInterpolator"},
| 78291 | {"setRICSPSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSPSize, 0), "setRICSPSize(val) -> None\n. * @see cv::ximgproc::createSuperpixelSLIC, cv::ximgproc::RICInterpolator"}, |  | 78243 | {"setRICSPSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRICSPSize, 0), "setRICSPSize(val) -> None\n. * @see cv::ximgproc::createSuperpixelSLIC, cv::ximgproc::RICInterpolator"},
| 78292 | {"setRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRLOFOpticalFlowParameter, 0), "setRLOFOpticalFlowParameter(val) -> None\n. @see optflow::RLOFOpticalFlowParameter, getRLOFOpticalFlowParameter"}, |  | 78244 | {"setRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setRLOFOpticalFlowParameter, 0), "setRLOFOpticalFlowParameter(val) -> None\n. @see optflow::RLOFOpticalFlowParameter, getRLOFOpticalFlowParameter"},
| 78293 | {"setUsePostProc", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUsePostProc, 0), "setUsePostProc(val) -> None\n. * @see getUsePostProc"}, |  | 78245 | {"setUsePostProc", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUsePostProc, 0), "setUsePostProc(val) -> None\n. * @see getUsePostProc"},
| 78294 | {"setUseVariationalRefinement", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUseVariationalRefinement, 0), "setUseVariationalRefinement(val) -> None\n. * @see getUseVariationalRefinement"}, |  | 78246 | {"setUseVariationalRefinement", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DenseRLOFOpticalFlow_setUseVariationalRefinement, 0), "setUseVariationalRefinement(val) -> None\n. * @see getUseVariationalRefinement"},
| 78295 |  |  | 78247 |
| 78296 | {NULL, NULL} |  | 78248 | {NULL, NULL}
| 78297 | }; |  | 78249 | };
| 78298 |  |  | 78250 |
| 78299 | // Converter (optflow_DenseRLOFOpticalFlow) |  | 78251 | // Converter (optflow_DenseRLOFOpticalFlow)
| 78300 |  |  | 78252 |
| 78301 | template<> |  | 78253 | template<>
| 78302 | struct PyOpenCV_Converter< Ptr<cv::optflow::DenseRLOFOpticalFlow> > |  | 78254 | struct PyOpenCV_Converter< Ptr<cv::optflow::DenseRLOFOpticalFlow> >
| 78303 | { |  | 78255 | {
| 78304 | static PyObject* from(const Ptr<cv::optflow::DenseRLOFOpticalFlow>& r) |  | 78256 | static PyObject* from(const Ptr<cv::optflow::DenseRLOFOpticalFlow>& r)
| 78305 | { |  | 78257 | {
| 78306 | return pyopencv_optflow_DenseRLOFOpticalFlow_Instance(r); |  | 78258 | return pyopencv_optflow_DenseRLOFOpticalFlow_Instance(r);
| 78307 | } |  | 78259 | }
| 78308 | static bool to(PyObject* src, Ptr<cv::optflow::DenseRLOFOpticalFlow>& dst, const ArgInfo& info) |  | 78260 | static bool to(PyObject* src, Ptr<cv::optflow::DenseRLOFOpticalFlow>& dst, const ArgInfo& info)
| 78309 | { |  | 78261 | {
| 78310 | if(!src || src == Py_None) |  | 78262 | if(!src || src == Py_None)
| 78311 | return true; |  | 78263 | return true;
| 78312 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * dst_; |  | 78264 | Ptr<cv::optflow::DenseRLOFOpticalFlow> * dst_;
| 78313 | if (pyopencv_optflow_DenseRLOFOpticalFlow_getp(src, dst_)) |  | 78265 | if (pyopencv_optflow_DenseRLOFOpticalFlow_getp(src, dst_))
| 78314 | { |  | 78266 | {
| 78315 | dst = *dst_; |  | 78267 | dst = *dst_;
| 78316 | return true; |  | 78268 | return true;
| 78317 | } |  | 78269 | }
| 78318 |  |  | 78270 |
| 78319 | failmsg("Expected Ptr<cv::optflow::DenseRLOFOpticalFlow> for argument '%s'", info.name); |  | 78271 | failmsg("Expected Ptr<cv::optflow::DenseRLOFOpticalFlow> for argument '%s'", info.name);
| 78320 | return false; |  | 78272 | return false;
| 78321 | } |  | 78273 | }
| 78322 | }; |  | 78274 | };
| 78323 |  |  | 78275 |
| 78324 | //================================================================================ |  | 78276 | //================================================================================
| 78325 | // optflow_DualTVL1OpticalFlow (Generic) |  | 78277 | // optflow_DualTVL1OpticalFlow (Generic)
| 78326 | //================================================================================ |  | 78278 | //================================================================================
| 78327 |  |  | 78279 |
| 78328 | // GetSet (optflow_DualTVL1OpticalFlow) |  | 78280 | // GetSet (optflow_DualTVL1OpticalFlow)
| 78329 |  |  | 78281 |
| 78330 |  |  | 78282 |
| 78331 |  |  | 78283 |
| 78332 | // Methods (optflow_DualTVL1OpticalFlow) |  | 78284 | // Methods (optflow_DualTVL1OpticalFlow)
| 78333 |  |  | 78285 |
| 78334 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78286 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 78335 | { |  | 78287 | {
| 78336 | using namespace cv::optflow; |  | 78288 | using namespace cv::optflow;
| 78337 |  |  | 78289 |
| 78338 | PyObject* pyobj_tau = NULL; |  | 78290 | PyObject* pyobj_tau = NULL;
| 78339 | double tau=0.25; |  | 78291 | double tau=0.25;
| 78340 | PyObject* pyobj_lambda = NULL; |  | 78292 | PyObject* pyobj_lambda = NULL;
| 78341 | double lambda=0.15; |  | 78293 | double lambda=0.15;
| 78342 | PyObject* pyobj_theta = NULL; |  | 78294 | PyObject* pyobj_theta = NULL;
| 78343 | double theta=0.3; |  | 78295 | double theta=0.3;
| 78344 | PyObject* pyobj_nscales = NULL; |  | 78296 | PyObject* pyobj_nscales = NULL;
| 78345 | int nscales=5; |  | 78297 | int nscales=5;
| 78346 | PyObject* pyobj_warps = NULL; |  | 78298 | PyObject* pyobj_warps = NULL;
| 78347 | int warps=5; |  | 78299 | int warps=5;
| 78348 | PyObject* pyobj_epsilon = NULL; |  | 78300 | PyObject* pyobj_epsilon = NULL;
| 78349 | double epsilon=0.01; |  | 78301 | double epsilon=0.01;
| 78350 | PyObject* pyobj_innnerIterations = NULL; |  | 78302 | PyObject* pyobj_innnerIterations = NULL;
| 78351 | int innnerIterations=30; |  | 78303 | int innnerIterations=30;
| 78352 | PyObject* pyobj_outerIterations = NULL; |  | 78304 | PyObject* pyobj_outerIterations = NULL;
| 78353 | int outerIterations=10; |  | 78305 | int outerIterations=10;
| 78354 | PyObject* pyobj_scaleStep = NULL; |  | 78306 | PyObject* pyobj_scaleStep = NULL;
| 78355 | double scaleStep=0.8; |  | 78307 | double scaleStep=0.8;
| 78356 | PyObject* pyobj_gamma = NULL; |  | 78308 | PyObject* pyobj_gamma = NULL;
| 78357 | double gamma=0.0; |  | 78309 | double gamma=0.0;
| 78358 | PyObject* pyobj_medianFiltering = NULL; |  | 78310 | PyObject* pyobj_medianFiltering = NULL;
| 78359 | int medianFiltering=5; |  | 78311 | int medianFiltering=5;
| 78360 | PyObject* pyobj_useInitialFlow = NULL; |  | 78312 | PyObject* pyobj_useInitialFlow = NULL;
| 78361 | bool useInitialFlow=false; |  | 78313 | bool useInitialFlow=false;
| 78362 | Ptr<DualTVL1OpticalFlow> retval; |  | 78314 | Ptr<DualTVL1OpticalFlow> retval;
| 78363 |  |  | 78315 |
| 78364 | const char* keywords[] = { "tau", "lambda_", "theta", "nscales", "warps", "epsilon", "innnerIterations", "outerIterations", "scaleStep", "gamma", "medianFiltering", "useInitialFlow", NULL }; |  | 78316 | const char* keywords[] = { "tau", "lambda_", "theta", "nscales", "warps", "epsilon", "innnerIterations", "outerIterations", "scaleStep", "gamma", "medianFiltering", "useInitialFlow", NULL };
| 78365 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOOOOO:optflow_DualTVL1OpticalFlow.create", (char**)keywords, &pyobj_tau, &pyobj_lambda, &pyobj_theta, &pyobj_nscales, &pyobj_warps, &pyobj_epsilon, &pyobj_innnerIterations, &pyobj_outerIterations, &pyobj_scaleStep, &pyobj_gamma, &pyobj_medianFiltering, &pyobj_useInitialFlow) && |  | 78317 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOOOOOO:optflow_DualTVL1OpticalFlow.create", (char**)keywords, &pyobj_tau, &pyobj_lambda, &pyobj_theta, &pyobj_nscales, &pyobj_warps, &pyobj_epsilon, &pyobj_innnerIterations, &pyobj_outerIterations, &pyobj_scaleStep, &pyobj_gamma, &pyobj_medianFiltering, &pyobj_useInitialFlow) &&
| 78366 | pyopencv_to_safe(pyobj_tau, tau, ArgInfo("tau", 0)) && |  | 78318 | pyopencv_to_safe(pyobj_tau, tau, ArgInfo("tau", 0)) &&
| 78367 | pyopencv_to_safe(pyobj_lambda, lambda, ArgInfo("lambda", 0)) && |  | 78319 | pyopencv_to_safe(pyobj_lambda, lambda, ArgInfo("lambda", 0)) &&
| 78368 | pyopencv_to_safe(pyobj_theta, theta, ArgInfo("theta", 0)) && |  | 78320 | pyopencv_to_safe(pyobj_theta, theta, ArgInfo("theta", 0)) &&
| 78369 | pyopencv_to_safe(pyobj_nscales, nscales, ArgInfo("nscales", 0)) && |  | 78321 | pyopencv_to_safe(pyobj_nscales, nscales, ArgInfo("nscales", 0)) &&
| 78370 | pyopencv_to_safe(pyobj_warps, warps, ArgInfo("warps", 0)) && |  | 78322 | pyopencv_to_safe(pyobj_warps, warps, ArgInfo("warps", 0)) &&
| 78371 | pyopencv_to_safe(pyobj_epsilon, epsilon, ArgInfo("epsilon", 0)) && |  | 78323 | pyopencv_to_safe(pyobj_epsilon, epsilon, ArgInfo("epsilon", 0)) &&
| 78372 | pyopencv_to_safe(pyobj_innnerIterations, innnerIterations, ArgInfo("innnerIterations", 0)) && |  | 78324 | pyopencv_to_safe(pyobj_innnerIterations, innnerIterations, ArgInfo("innnerIterations", 0)) &&
| 78373 | pyopencv_to_safe(pyobj_outerIterations, outerIterations, ArgInfo("outerIterations", 0)) && |  | 78325 | pyopencv_to_safe(pyobj_outerIterations, outerIterations, ArgInfo("outerIterations", 0)) &&
| 78374 | pyopencv_to_safe(pyobj_scaleStep, scaleStep, ArgInfo("scaleStep", 0)) && |  | 78326 | pyopencv_to_safe(pyobj_scaleStep, scaleStep, ArgInfo("scaleStep", 0)) &&
| 78375 | pyopencv_to_safe(pyobj_gamma, gamma, ArgInfo("gamma", 0)) && |  | 78327 | pyopencv_to_safe(pyobj_gamma, gamma, ArgInfo("gamma", 0)) &&
| 78376 | pyopencv_to_safe(pyobj_medianFiltering, medianFiltering, ArgInfo("medianFiltering", 0)) && |  | 78328 | pyopencv_to_safe(pyobj_medianFiltering, medianFiltering, ArgInfo("medianFiltering", 0)) &&
| 78377 | pyopencv_to_safe(pyobj_useInitialFlow, useInitialFlow, ArgInfo("useInitialFlow", 0)) ) |  | 78329 | pyopencv_to_safe(pyobj_useInitialFlow, useInitialFlow, ArgInfo("useInitialFlow", 0)) )
| 78378 | { |  | 78330 | {
| 78379 | ERRWRAP2(retval = cv::optflow::DualTVL1OpticalFlow::create(tau, lambda, theta, nscales, warps, epsilon, innnerIterations, outerIterations, scaleStep, gamma, medianFiltering, useInitialFlow)); |  | 78331 | ERRWRAP2(retval = cv::optflow::DualTVL1OpticalFlow::create(tau, lambda, theta, nscales, warps, epsilon, innnerIterations, outerIterations, scaleStep, gamma, medianFiltering, useInitialFlow));
| 78380 | return pyopencv_from(retval); |  | 78332 | return pyopencv_from(retval);
| 78381 | } |  | 78333 | }
| 78382 |  |  | 78334 |
| 78383 | return NULL; |  | 78335 | return NULL;
| 78384 | } |  | 78336 | }
| 78385 |  |  | 78337 |
| 78386 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78338 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 78387 | { |  | 78339 | {
| 78388 | using namespace cv::optflow; |  | 78340 | using namespace cv::optflow;
| 78389 |  |  | 78341 |
| 78390 |  |  | 78342 |
| 78391 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78343 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78392 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78344 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78393 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78345 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78394 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78346 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78395 | double retval; |  | 78347 | double retval;
| 78396 |  |  | 78348 |
| 78397 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78349 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78398 | { |  | 78350 | {
| 78399 | ERRWRAP2(retval = _self_->getEpsilon()); |  | 78351 | ERRWRAP2(retval = _self_->getEpsilon());
| 78400 | return pyopencv_from(retval); |  | 78352 | return pyopencv_from(retval);
| 78401 | } |  | 78353 | }
| 78402 |  |  | 78354 |
| 78403 | return NULL; |  | 78355 | return NULL;
| 78404 | } |  | 78356 | }
| 78405 |  |  | 78357 |
| 78406 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78358 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 78407 | { |  | 78359 | {
| 78408 | using namespace cv::optflow; |  | 78360 | using namespace cv::optflow;
| 78409 |  |  | 78361 |
| 78410 |  |  | 78362 |
| 78411 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78363 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78412 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78364 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78413 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78365 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78414 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78366 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78415 | double retval; |  | 78367 | double retval;
| 78416 |  |  | 78368 |
| 78417 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78369 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78418 | { |  | 78370 | {
| 78419 | ERRWRAP2(retval = _self_->getGamma()); |  | 78371 | ERRWRAP2(retval = _self_->getGamma());
| 78420 | return pyopencv_from(retval); |  | 78372 | return pyopencv_from(retval);
| 78421 | } |  | 78373 | }
| 78422 |  |  | 78374 |
| 78423 | return NULL; |  | 78375 | return NULL;
| 78424 | } |  | 78376 | }
| 78425 |  |  | 78377 |
| 78426 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getInnerIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78378 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getInnerIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 78427 | { |  | 78379 | {
| 78428 | using namespace cv::optflow; |  | 78380 | using namespace cv::optflow;
| 78429 |  |  | 78381 |
| 78430 |  |  | 78382 |
| 78431 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78383 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78432 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78384 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78433 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78385 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78434 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78386 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78435 | int retval; |  | 78387 | int retval;
| 78436 |  |  | 78388 |
| 78437 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78389 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78438 | { |  | 78390 | {
| 78439 | ERRWRAP2(retval = _self_->getInnerIterations()); |  | 78391 | ERRWRAP2(retval = _self_->getInnerIterations());
| 78440 | return pyopencv_from(retval); |  | 78392 | return pyopencv_from(retval);
| 78441 | } |  | 78393 | }
| 78442 |  |  | 78394 |
| 78443 | return NULL; |  | 78395 | return NULL;
| 78444 | } |  | 78396 | }
| 78445 |  |  | 78397 |
| 78446 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78398 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 78447 | { |  | 78399 | {
| 78448 | using namespace cv::optflow; |  | 78400 | using namespace cv::optflow;
| 78449 |  |  | 78401 |
| 78450 |  |  | 78402 |
| 78451 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78403 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78452 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78404 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78453 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78405 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78454 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78406 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78455 | double retval; |  | 78407 | double retval;
| 78456 |  |  | 78408 |
| 78457 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78409 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78458 | { |  | 78410 | {
| 78459 | ERRWRAP2(retval = _self_->getLambda()); |  | 78411 | ERRWRAP2(retval = _self_->getLambda());
| 78460 | return pyopencv_from(retval); |  | 78412 | return pyopencv_from(retval);
| 78461 | } |  | 78413 | }
| 78462 |  |  | 78414 |
| 78463 | return NULL; |  | 78415 | return NULL;
| 78464 | } |  | 78416 | }
| 78465 |  |  | 78417 |
| 78466 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getMedianFiltering(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78418 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getMedianFiltering(PyObject* self, PyObject* py_args, PyObject* kw)
| 78467 | { |  | 78419 | {
| 78468 | using namespace cv::optflow; |  | 78420 | using namespace cv::optflow;
| 78469 |  |  | 78421 |
| 78470 |  |  | 78422 |
| 78471 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78423 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78472 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78424 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78473 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78425 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78474 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78426 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78475 | int retval; |  | 78427 | int retval;
| 78476 |  |  | 78428 |
| 78477 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78429 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78478 | { |  | 78430 | {
| 78479 | ERRWRAP2(retval = _self_->getMedianFiltering()); |  | 78431 | ERRWRAP2(retval = _self_->getMedianFiltering());
| 78480 | return pyopencv_from(retval); |  | 78432 | return pyopencv_from(retval);
| 78481 | } |  | 78433 | }
| 78482 |  |  | 78434 |
| 78483 | return NULL; |  | 78435 | return NULL;
| 78484 | } |  | 78436 | }
| 78485 |  |  | 78437 |
| 78486 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getOuterIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78438 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getOuterIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 78487 | { |  | 78439 | {
| 78488 | using namespace cv::optflow; |  | 78440 | using namespace cv::optflow;
| 78489 |  |  | 78441 |
| 78490 |  |  | 78442 |
| 78491 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78443 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78492 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78444 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78493 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78445 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78494 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78446 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78495 | int retval; |  | 78447 | int retval;
| 78496 |  |  | 78448 |
| 78497 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78449 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78498 | { |  | 78450 | {
| 78499 | ERRWRAP2(retval = _self_->getOuterIterations()); |  | 78451 | ERRWRAP2(retval = _self_->getOuterIterations());
| 78500 | return pyopencv_from(retval); |  | 78452 | return pyopencv_from(retval);
| 78501 | } |  | 78453 | }
| 78502 |  |  | 78454 |
| 78503 | return NULL; |  | 78455 | return NULL;
| 78504 | } |  | 78456 | }
| 78505 |  |  | 78457 |
| 78506 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScaleStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78458 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScaleStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 78507 | { |  | 78459 | {
| 78508 | using namespace cv::optflow; |  | 78460 | using namespace cv::optflow;
| 78509 |  |  | 78461 |
| 78510 |  |  | 78462 |
| 78511 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78463 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78512 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78464 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78513 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78465 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78514 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78466 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78515 | double retval; |  | 78467 | double retval;
| 78516 |  |  | 78468 |
| 78517 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78469 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78518 | { |  | 78470 | {
| 78519 | ERRWRAP2(retval = _self_->getScaleStep()); |  | 78471 | ERRWRAP2(retval = _self_->getScaleStep());
| 78520 | return pyopencv_from(retval); |  | 78472 | return pyopencv_from(retval);
| 78521 | } |  | 78473 | }
| 78522 |  |  | 78474 |
| 78523 | return NULL; |  | 78475 | return NULL;
| 78524 | } |  | 78476 | }
| 78525 |  |  | 78477 |
| 78526 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScalesNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78478 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScalesNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 78527 | { |  | 78479 | {
| 78528 | using namespace cv::optflow; |  | 78480 | using namespace cv::optflow;
| 78529 |  |  | 78481 |
| 78530 |  |  | 78482 |
| 78531 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78483 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78532 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78484 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78533 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78485 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78534 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78486 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78535 | int retval; |  | 78487 | int retval;
| 78536 |  |  | 78488 |
| 78537 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78489 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78538 | { |  | 78490 | {
| 78539 | ERRWRAP2(retval = _self_->getScalesNumber()); |  | 78491 | ERRWRAP2(retval = _self_->getScalesNumber());
| 78540 | return pyopencv_from(retval); |  | 78492 | return pyopencv_from(retval);
| 78541 | } |  | 78493 | }
| 78542 |  |  | 78494 |
| 78543 | return NULL; |  | 78495 | return NULL;
| 78544 | } |  | 78496 | }
| 78545 |  |  | 78497 |
| 78546 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTau(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78498 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTau(PyObject* self, PyObject* py_args, PyObject* kw)
| 78547 | { |  | 78499 | {
| 78548 | using namespace cv::optflow; |  | 78500 | using namespace cv::optflow;
| 78549 |  |  | 78501 |
| 78550 |  |  | 78502 |
| 78551 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78503 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78552 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78504 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78553 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78505 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78554 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78506 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78555 | double retval; |  | 78507 | double retval;
| 78556 |  |  | 78508 |
| 78557 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78509 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78558 | { |  | 78510 | {
| 78559 | ERRWRAP2(retval = _self_->getTau()); |  | 78511 | ERRWRAP2(retval = _self_->getTau());
| 78560 | return pyopencv_from(retval); |  | 78512 | return pyopencv_from(retval);
| 78561 | } |  | 78513 | }
| 78562 |  |  | 78514 |
| 78563 | return NULL; |  | 78515 | return NULL;
| 78564 | } |  | 78516 | }
| 78565 |  |  | 78517 |
| 78566 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTheta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78518 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTheta(PyObject* self, PyObject* py_args, PyObject* kw)
| 78567 | { |  | 78519 | {
| 78568 | using namespace cv::optflow; |  | 78520 | using namespace cv::optflow;
| 78569 |  |  | 78521 |
| 78570 |  |  | 78522 |
| 78571 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78523 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78572 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78524 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78573 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78525 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78574 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78526 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78575 | double retval; |  | 78527 | double retval;
| 78576 |  |  | 78528 |
| 78577 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78529 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78578 | { |  | 78530 | {
| 78579 | ERRWRAP2(retval = _self_->getTheta()); |  | 78531 | ERRWRAP2(retval = _self_->getTheta());
| 78580 | return pyopencv_from(retval); |  | 78532 | return pyopencv_from(retval);
| 78581 | } |  | 78533 | }
| 78582 |  |  | 78534 |
| 78583 | return NULL; |  | 78535 | return NULL;
| 78584 | } |  | 78536 | }
| 78585 |  |  | 78537 |
| 78586 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78538 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw)
| 78587 | { |  | 78539 | {
| 78588 | using namespace cv::optflow; |  | 78540 | using namespace cv::optflow;
| 78589 |  |  | 78541 |
| 78590 |  |  | 78542 |
| 78591 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78543 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78592 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78544 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78593 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78545 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78594 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78546 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78595 | bool retval; |  | 78547 | bool retval;
| 78596 |  |  | 78548 |
| 78597 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78549 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78598 | { |  | 78550 | {
| 78599 | ERRWRAP2(retval = _self_->getUseInitialFlow()); |  | 78551 | ERRWRAP2(retval = _self_->getUseInitialFlow());
| 78600 | return pyopencv_from(retval); |  | 78552 | return pyopencv_from(retval);
| 78601 | } |  | 78553 | }
| 78602 |  |  | 78554 |
| 78603 | return NULL; |  | 78555 | return NULL;
| 78604 | } |  | 78556 | }
| 78605 |  |  | 78557 |
| 78606 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getWarpingsNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78558 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getWarpingsNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 78607 | { |  | 78559 | {
| 78608 | using namespace cv::optflow; |  | 78560 | using namespace cv::optflow;
| 78609 |  |  | 78561 |
| 78610 |  |  | 78562 |
| 78611 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78563 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78612 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78564 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78613 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78565 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78614 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78566 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78615 | int retval; |  | 78567 | int retval;
| 78616 |  |  | 78568 |
| 78617 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 78569 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 78618 | { |  | 78570 | {
| 78619 | ERRWRAP2(retval = _self_->getWarpingsNumber()); |  | 78571 | ERRWRAP2(retval = _self_->getWarpingsNumber());
| 78620 | return pyopencv_from(retval); |  | 78572 | return pyopencv_from(retval);
| 78621 | } |  | 78573 | }
| 78622 |  |  | 78574 |
| 78623 | return NULL; |  | 78575 | return NULL;
| 78624 | } |  | 78576 | }
| 78625 |  |  | 78577 |
| 78626 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setEpsilon(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78578 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setEpsilon(PyObject* self, PyObject* py_args, PyObject* kw)
| 78627 | { |  | 78579 | {
| 78628 | using namespace cv::optflow; |  | 78580 | using namespace cv::optflow;
| 78629 |  |  | 78581 |
| 78630 |  |  | 78582 |
| 78631 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78583 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78632 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78584 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78633 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78585 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78634 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78586 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78635 | PyObject* pyobj_val = NULL; |  | 78587 | PyObject* pyobj_val = NULL;
| 78636 | double val=0; |  | 78588 | double val=0;
| 78637 |  |  | 78589 |
| 78638 | const char* keywords[] = { "val", NULL }; |  | 78590 | const char* keywords[] = { "val", NULL };
| 78639 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setEpsilon", (char**)keywords, &pyobj_val) && |  | 78591 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setEpsilon", (char**)keywords, &pyobj_val) &&
| 78640 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78592 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78641 | { |  | 78593 | {
| 78642 | ERRWRAP2(_self_->setEpsilon(val)); |  | 78594 | ERRWRAP2(_self_->setEpsilon(val));
| 78643 | Py_RETURN_NONE; |  | 78595 | Py_RETURN_NONE;
| 78644 | } |  | 78596 | }
| 78645 |  |  | 78597 |
| 78646 | return NULL; |  | 78598 | return NULL;
| 78647 | } |  | 78599 | }
| 78648 |  |  | 78600 |
| 78649 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setGamma(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78601 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setGamma(PyObject* self, PyObject* py_args, PyObject* kw)
| 78650 | { |  | 78602 | {
| 78651 | using namespace cv::optflow; |  | 78603 | using namespace cv::optflow;
| 78652 |  |  | 78604 |
| 78653 |  |  | 78605 |
| 78654 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78606 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78655 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78607 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78656 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78608 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78657 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78609 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78658 | PyObject* pyobj_val = NULL; |  | 78610 | PyObject* pyobj_val = NULL;
| 78659 | double val=0; |  | 78611 | double val=0;
| 78660 |  |  | 78612 |
| 78661 | const char* keywords[] = { "val", NULL }; |  | 78613 | const char* keywords[] = { "val", NULL };
| 78662 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setGamma", (char**)keywords, &pyobj_val) && |  | 78614 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setGamma", (char**)keywords, &pyobj_val) &&
| 78663 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78615 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78664 | { |  | 78616 | {
| 78665 | ERRWRAP2(_self_->setGamma(val)); |  | 78617 | ERRWRAP2(_self_->setGamma(val));
| 78666 | Py_RETURN_NONE; |  | 78618 | Py_RETURN_NONE;
| 78667 | } |  | 78619 | }
| 78668 |  |  | 78620 |
| 78669 | return NULL; |  | 78621 | return NULL;
| 78670 | } |  | 78622 | }
| 78671 |  |  | 78623 |
| 78672 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setInnerIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78624 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setInnerIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 78673 | { |  | 78625 | {
| 78674 | using namespace cv::optflow; |  | 78626 | using namespace cv::optflow;
| 78675 |  |  | 78627 |
| 78676 |  |  | 78628 |
| 78677 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78629 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78678 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78630 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78679 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78631 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78680 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78632 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78681 | PyObject* pyobj_val = NULL; |  | 78633 | PyObject* pyobj_val = NULL;
| 78682 | int val=0; |  | 78634 | int val=0;
| 78683 |  |  | 78635 |
| 78684 | const char* keywords[] = { "val", NULL }; |  | 78636 | const char* keywords[] = { "val", NULL };
| 78685 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setInnerIterations", (char**)keywords, &pyobj_val) && |  | 78637 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setInnerIterations", (char**)keywords, &pyobj_val) &&
| 78686 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78638 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78687 | { |  | 78639 | {
| 78688 | ERRWRAP2(_self_->setInnerIterations(val)); |  | 78640 | ERRWRAP2(_self_->setInnerIterations(val));
| 78689 | Py_RETURN_NONE; |  | 78641 | Py_RETURN_NONE;
| 78690 | } |  | 78642 | }
| 78691 |  |  | 78643 |
| 78692 | return NULL; |  | 78644 | return NULL;
| 78693 | } |  | 78645 | }
| 78694 |  |  | 78646 |
| 78695 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setLambda(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78647 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setLambda(PyObject* self, PyObject* py_args, PyObject* kw)
| 78696 | { |  | 78648 | {
| 78697 | using namespace cv::optflow; |  | 78649 | using namespace cv::optflow;
| 78698 |  |  | 78650 |
| 78699 |  |  | 78651 |
| 78700 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78652 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78701 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78653 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78702 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78654 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78703 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78655 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78704 | PyObject* pyobj_val = NULL; |  | 78656 | PyObject* pyobj_val = NULL;
| 78705 | double val=0; |  | 78657 | double val=0;
| 78706 |  |  | 78658 |
| 78707 | const char* keywords[] = { "val", NULL }; |  | 78659 | const char* keywords[] = { "val", NULL };
| 78708 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setLambda", (char**)keywords, &pyobj_val) && |  | 78660 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setLambda", (char**)keywords, &pyobj_val) &&
| 78709 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78661 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78710 | { |  | 78662 | {
| 78711 | ERRWRAP2(_self_->setLambda(val)); |  | 78663 | ERRWRAP2(_self_->setLambda(val));
| 78712 | Py_RETURN_NONE; |  | 78664 | Py_RETURN_NONE;
| 78713 | } |  | 78665 | }
| 78714 |  |  | 78666 |
| 78715 | return NULL; |  | 78667 | return NULL;
| 78716 | } |  | 78668 | }
| 78717 |  |  | 78669 |
| 78718 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setMedianFiltering(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78670 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setMedianFiltering(PyObject* self, PyObject* py_args, PyObject* kw)
| 78719 | { |  | 78671 | {
| 78720 | using namespace cv::optflow; |  | 78672 | using namespace cv::optflow;
| 78721 |  |  | 78673 |
| 78722 |  |  | 78674 |
| 78723 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78675 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78724 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78676 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78725 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78677 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78726 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78678 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78727 | PyObject* pyobj_val = NULL; |  | 78679 | PyObject* pyobj_val = NULL;
| 78728 | int val=0; |  | 78680 | int val=0;
| 78729 |  |  | 78681 |
| 78730 | const char* keywords[] = { "val", NULL }; |  | 78682 | const char* keywords[] = { "val", NULL };
| 78731 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setMedianFiltering", (char**)keywords, &pyobj_val) && |  | 78683 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setMedianFiltering", (char**)keywords, &pyobj_val) &&
| 78732 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78684 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78733 | { |  | 78685 | {
| 78734 | ERRWRAP2(_self_->setMedianFiltering(val)); |  | 78686 | ERRWRAP2(_self_->setMedianFiltering(val));
| 78735 | Py_RETURN_NONE; |  | 78687 | Py_RETURN_NONE;
| 78736 | } |  | 78688 | }
| 78737 |  |  | 78689 |
| 78738 | return NULL; |  | 78690 | return NULL;
| 78739 | } |  | 78691 | }
| 78740 |  |  | 78692 |
| 78741 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setOuterIterations(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78693 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setOuterIterations(PyObject* self, PyObject* py_args, PyObject* kw)
| 78742 | { |  | 78694 | {
| 78743 | using namespace cv::optflow; |  | 78695 | using namespace cv::optflow;
| 78744 |  |  | 78696 |
| 78745 |  |  | 78697 |
| 78746 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78698 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78747 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78699 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78748 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78700 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78749 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78701 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78750 | PyObject* pyobj_val = NULL; |  | 78702 | PyObject* pyobj_val = NULL;
| 78751 | int val=0; |  | 78703 | int val=0;
| 78752 |  |  | 78704 |
| 78753 | const char* keywords[] = { "val", NULL }; |  | 78705 | const char* keywords[] = { "val", NULL };
| 78754 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setOuterIterations", (char**)keywords, &pyobj_val) && |  | 78706 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setOuterIterations", (char**)keywords, &pyobj_val) &&
| 78755 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78707 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78756 | { |  | 78708 | {
| 78757 | ERRWRAP2(_self_->setOuterIterations(val)); |  | 78709 | ERRWRAP2(_self_->setOuterIterations(val));
| 78758 | Py_RETURN_NONE; |  | 78710 | Py_RETURN_NONE;
| 78759 | } |  | 78711 | }
| 78760 |  |  | 78712 |
| 78761 | return NULL; |  | 78713 | return NULL;
| 78762 | } |  | 78714 | }
| 78763 |  |  | 78715 |
| 78764 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScaleStep(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78716 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScaleStep(PyObject* self, PyObject* py_args, PyObject* kw)
| 78765 | { |  | 78717 | {
| 78766 | using namespace cv::optflow; |  | 78718 | using namespace cv::optflow;
| 78767 |  |  | 78719 |
| 78768 |  |  | 78720 |
| 78769 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78721 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78770 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78722 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78771 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78723 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78772 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78724 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78773 | PyObject* pyobj_val = NULL; |  | 78725 | PyObject* pyobj_val = NULL;
| 78774 | double val=0; |  | 78726 | double val=0;
| 78775 |  |  | 78727 |
| 78776 | const char* keywords[] = { "val", NULL }; |  | 78728 | const char* keywords[] = { "val", NULL };
| 78777 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setScaleStep", (char**)keywords, &pyobj_val) && |  | 78729 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setScaleStep", (char**)keywords, &pyobj_val) &&
| 78778 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78730 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78779 | { |  | 78731 | {
| 78780 | ERRWRAP2(_self_->setScaleStep(val)); |  | 78732 | ERRWRAP2(_self_->setScaleStep(val));
| 78781 | Py_RETURN_NONE; |  | 78733 | Py_RETURN_NONE;
| 78782 | } |  | 78734 | }
| 78783 |  |  | 78735 |
| 78784 | return NULL; |  | 78736 | return NULL;
| 78785 | } |  | 78737 | }
| 78786 |  |  | 78738 |
| 78787 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScalesNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78739 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScalesNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 78788 | { |  | 78740 | {
| 78789 | using namespace cv::optflow; |  | 78741 | using namespace cv::optflow;
| 78790 |  |  | 78742 |
| 78791 |  |  | 78743 |
| 78792 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78744 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78793 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78745 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78794 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78746 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78795 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78747 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78796 | PyObject* pyobj_val = NULL; |  | 78748 | PyObject* pyobj_val = NULL;
| 78797 | int val=0; |  | 78749 | int val=0;
| 78798 |  |  | 78750 |
| 78799 | const char* keywords[] = { "val", NULL }; |  | 78751 | const char* keywords[] = { "val", NULL };
| 78800 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setScalesNumber", (char**)keywords, &pyobj_val) && |  | 78752 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setScalesNumber", (char**)keywords, &pyobj_val) &&
| 78801 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78753 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78802 | { |  | 78754 | {
| 78803 | ERRWRAP2(_self_->setScalesNumber(val)); |  | 78755 | ERRWRAP2(_self_->setScalesNumber(val));
| 78804 | Py_RETURN_NONE; |  | 78756 | Py_RETURN_NONE;
| 78805 | } |  | 78757 | }
| 78806 |  |  | 78758 |
| 78807 | return NULL; |  | 78759 | return NULL;
| 78808 | } |  | 78760 | }
| 78809 |  |  | 78761 |
| 78810 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTau(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78762 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTau(PyObject* self, PyObject* py_args, PyObject* kw)
| 78811 | { |  | 78763 | {
| 78812 | using namespace cv::optflow; |  | 78764 | using namespace cv::optflow;
| 78813 |  |  | 78765 |
| 78814 |  |  | 78766 |
| 78815 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78767 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78816 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78768 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78817 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78769 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78818 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78770 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78819 | PyObject* pyobj_val = NULL; |  | 78771 | PyObject* pyobj_val = NULL;
| 78820 | double val=0; |  | 78772 | double val=0;
| 78821 |  |  | 78773 |
| 78822 | const char* keywords[] = { "val", NULL }; |  | 78774 | const char* keywords[] = { "val", NULL };
| 78823 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setTau", (char**)keywords, &pyobj_val) && |  | 78775 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setTau", (char**)keywords, &pyobj_val) &&
| 78824 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78776 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78825 | { |  | 78777 | {
| 78826 | ERRWRAP2(_self_->setTau(val)); |  | 78778 | ERRWRAP2(_self_->setTau(val));
| 78827 | Py_RETURN_NONE; |  | 78779 | Py_RETURN_NONE;
| 78828 | } |  | 78780 | }
| 78829 |  |  | 78781 |
| 78830 | return NULL; |  | 78782 | return NULL;
| 78831 | } |  | 78783 | }
| 78832 |  |  | 78784 |
| 78833 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTheta(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78785 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTheta(PyObject* self, PyObject* py_args, PyObject* kw)
| 78834 | { |  | 78786 | {
| 78835 | using namespace cv::optflow; |  | 78787 | using namespace cv::optflow;
| 78836 |  |  | 78788 |
| 78837 |  |  | 78789 |
| 78838 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78790 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78839 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78791 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78840 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78792 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78841 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78793 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78842 | PyObject* pyobj_val = NULL; |  | 78794 | PyObject* pyobj_val = NULL;
| 78843 | double val=0; |  | 78795 | double val=0;
| 78844 |  |  | 78796 |
| 78845 | const char* keywords[] = { "val", NULL }; |  | 78797 | const char* keywords[] = { "val", NULL };
| 78846 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setTheta", (char**)keywords, &pyobj_val) && |  | 78798 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setTheta", (char**)keywords, &pyobj_val) &&
| 78847 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78799 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78848 | { |  | 78800 | {
| 78849 | ERRWRAP2(_self_->setTheta(val)); |  | 78801 | ERRWRAP2(_self_->setTheta(val));
| 78850 | Py_RETURN_NONE; |  | 78802 | Py_RETURN_NONE;
| 78851 | } |  | 78803 | }
| 78852 |  |  | 78804 |
| 78853 | return NULL; |  | 78805 | return NULL;
| 78854 | } |  | 78806 | }
| 78855 |  |  | 78807 |
| 78856 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78808 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw)
| 78857 | { |  | 78809 | {
| 78858 | using namespace cv::optflow; |  | 78810 | using namespace cv::optflow;
| 78859 |  |  | 78811 |
| 78860 |  |  | 78812 |
| 78861 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78813 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78862 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78814 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78863 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78815 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78864 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78816 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78865 | PyObject* pyobj_val = NULL; |  | 78817 | PyObject* pyobj_val = NULL;
| 78866 | bool val=0; |  | 78818 | bool val=0;
| 78867 |  |  | 78819 |
| 78868 | const char* keywords[] = { "val", NULL }; |  | 78820 | const char* keywords[] = { "val", NULL };
| 78869 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setUseInitialFlow", (char**)keywords, &pyobj_val) && |  | 78821 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setUseInitialFlow", (char**)keywords, &pyobj_val) &&
| 78870 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78822 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78871 | { |  | 78823 | {
| 78872 | ERRWRAP2(_self_->setUseInitialFlow(val)); |  | 78824 | ERRWRAP2(_self_->setUseInitialFlow(val));
| 78873 | Py_RETURN_NONE; |  | 78825 | Py_RETURN_NONE;
| 78874 | } |  | 78826 | }
| 78875 |  |  | 78827 |
| 78876 | return NULL; |  | 78828 | return NULL;
| 78877 | } |  | 78829 | }
| 78878 |  |  | 78830 |
| 78879 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setWarpingsNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 78831 | static PyObject* pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setWarpingsNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 78880 | { |  | 78832 | {
| 78881 | using namespace cv::optflow; |  | 78833 | using namespace cv::optflow;
| 78882 |  |  | 78834 |
| 78883 |  |  | 78835 |
| 78884 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0; |  | 78836 | Ptr<cv::optflow::DualTVL1OpticalFlow> * self1 = 0;
| 78885 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1)) |  | 78837 | if (!pyopencv_optflow_DualTVL1OpticalFlow_getp(self, self1))
| 78886 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)"); |  | 78838 | return failmsgp("Incorrect type of self (must be 'optflow_DualTVL1OpticalFlow' or its derivative)");
| 78887 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1); |  | 78839 | Ptr<cv::optflow::DualTVL1OpticalFlow> _self_ = *(self1);
| 78888 | PyObject* pyobj_val = NULL; |  | 78840 | PyObject* pyobj_val = NULL;
| 78889 | int val=0; |  | 78841 | int val=0;
| 78890 |  |  | 78842 |
| 78891 | const char* keywords[] = { "val", NULL }; |  | 78843 | const char* keywords[] = { "val", NULL };
| 78892 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setWarpingsNumber", (char**)keywords, &pyobj_val) && |  | 78844 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_DualTVL1OpticalFlow.setWarpingsNumber", (char**)keywords, &pyobj_val) &&
| 78893 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 78845 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 78894 | { |  | 78846 | {
| 78895 | ERRWRAP2(_self_->setWarpingsNumber(val)); |  | 78847 | ERRWRAP2(_self_->setWarpingsNumber(val));
| 78896 | Py_RETURN_NONE; |  | 78848 | Py_RETURN_NONE;
| 78897 | } |  | 78849 | }
| 78898 |  |  | 78850 |
| 78899 | return NULL; |  | 78851 | return NULL;
| 78900 | } |  | 78852 | }
| 78901 |  |  | 78853 |
| 78902 |  |  | 78854 |
| 78903 |  |  | 78855 |
| 78904 | // Tables (optflow_DualTVL1OpticalFlow) |  | 78856 | // Tables (optflow_DualTVL1OpticalFlow)
| 78905 |  |  | 78857 |
| 78906 | static PyGetSetDef pyopencv_optflow_DualTVL1OpticalFlow_getseters[] = |  | 78858 | static PyGetSetDef pyopencv_optflow_DualTVL1OpticalFlow_getseters[] =
| 78907 | { |  | 78859 | {
| 78908 | {NULL} /* Sentinel */ |  | 78860 | {NULL} /* Sentinel */
| 78909 | }; |  | 78861 | };
| 78910 |  |  | 78862 |
| 78911 | static PyMethodDef pyopencv_optflow_DualTVL1OpticalFlow_methods[] = |  | 78863 | static PyMethodDef pyopencv_optflow_DualTVL1OpticalFlow_methods[] =
| 78912 | { |  | 78864 | {
| 78913 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_create_static, METH_STATIC), "create([, tau[, lambda_[, theta[, nscales[, warps[, epsilon[, innnerIterations[, outerIterations[, scaleStep[, gamma[, medianFiltering[, useInitialFlow]]]]]]]]]]]]) -> retval\n. @brief Creates instance of cv::DualTVL1OpticalFlow"}, |  | 78865 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_create_static, METH_STATIC), "create([, tau[, lambda_[, theta[, nscales[, warps[, epsilon[, innnerIterations[, outerIterations[, scaleStep[, gamma[, medianFiltering[, useInitialFlow]]]]]]]]]]]]) -> retval\n. @brief Creates instance of cv::DualTVL1OpticalFlow"},
| 78914 | {"getEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getEpsilon, 0), "getEpsilon() -> retval\n. @see setEpsilon"}, |  | 78866 | {"getEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getEpsilon, 0), "getEpsilon() -> retval\n. @see setEpsilon"},
| 78915 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getGamma, 0), "getGamma() -> retval\n. @see setGamma"}, |  | 78867 | {"getGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getGamma, 0), "getGamma() -> retval\n. @see setGamma"},
| 78916 | {"getInnerIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getInnerIterations, 0), "getInnerIterations() -> retval\n. @see setInnerIterations"}, |  | 78868 | {"getInnerIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getInnerIterations, 0), "getInnerIterations() -> retval\n. @see setInnerIterations"},
| 78917 | {"getLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getLambda, 0), "getLambda() -> retval\n. @see setLambda"}, |  | 78869 | {"getLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getLambda, 0), "getLambda() -> retval\n. @see setLambda"},
| 78918 | {"getMedianFiltering", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getMedianFiltering, 0), "getMedianFiltering() -> retval\n. @see setMedianFiltering"}, |  | 78870 | {"getMedianFiltering", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getMedianFiltering, 0), "getMedianFiltering() -> retval\n. @see setMedianFiltering"},
| 78919 | {"getOuterIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getOuterIterations, 0), "getOuterIterations() -> retval\n. @see setOuterIterations"}, |  | 78871 | {"getOuterIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getOuterIterations, 0), "getOuterIterations() -> retval\n. @see setOuterIterations"},
| 78920 | {"getScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScaleStep, 0), "getScaleStep() -> retval\n. @see setScaleStep"}, |  | 78872 | {"getScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScaleStep, 0), "getScaleStep() -> retval\n. @see setScaleStep"},
| 78921 | {"getScalesNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScalesNumber, 0), "getScalesNumber() -> retval\n. @see setScalesNumber"}, |  | 78873 | {"getScalesNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getScalesNumber, 0), "getScalesNumber() -> retval\n. @see setScalesNumber"},
| 78922 | {"getTau", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTau, 0), "getTau() -> retval\n. @see setTau"}, |  | 78874 | {"getTau", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTau, 0), "getTau() -> retval\n. @see setTau"},
| 78923 | {"getTheta", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTheta, 0), "getTheta() -> retval\n. @see setTheta"}, |  | 78875 | {"getTheta", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getTheta, 0), "getTheta() -> retval\n. @see setTheta"},
| 78924 | {"getUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getUseInitialFlow, 0), "getUseInitialFlow() -> retval\n. @see setUseInitialFlow"}, |  | 78876 | {"getUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getUseInitialFlow, 0), "getUseInitialFlow() -> retval\n. @see setUseInitialFlow"},
| 78925 | {"getWarpingsNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getWarpingsNumber, 0), "getWarpingsNumber() -> retval\n. @see setWarpingsNumber"}, |  | 78877 | {"getWarpingsNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_getWarpingsNumber, 0), "getWarpingsNumber() -> retval\n. @see setWarpingsNumber"},
| 78926 | {"setEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setEpsilon, 0), "setEpsilon(val) -> None\n. @copybrief getEpsilon @see getEpsilon"}, |  | 78878 | {"setEpsilon", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setEpsilon, 0), "setEpsilon(val) -> None\n. @copybrief getEpsilon @see getEpsilon"},
| 78927 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setGamma, 0), "setGamma(val) -> None\n. @copybrief getGamma @see getGamma"}, |  | 78879 | {"setGamma", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setGamma, 0), "setGamma(val) -> None\n. @copybrief getGamma @see getGamma"},
| 78928 | {"setInnerIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setInnerIterations, 0), "setInnerIterations(val) -> None\n. @copybrief getInnerIterations @see getInnerIterations"}, |  | 78880 | {"setInnerIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setInnerIterations, 0), "setInnerIterations(val) -> None\n. @copybrief getInnerIterations @see getInnerIterations"},
| 78929 | {"setLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setLambda, 0), "setLambda(val) -> None\n. @copybrief getLambda @see getLambda"}, |  | 78881 | {"setLambda", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setLambda, 0), "setLambda(val) -> None\n. @copybrief getLambda @see getLambda"},
| 78930 | {"setMedianFiltering", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setMedianFiltering, 0), "setMedianFiltering(val) -> None\n. @copybrief getMedianFiltering @see getMedianFiltering"}, |  | 78882 | {"setMedianFiltering", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setMedianFiltering, 0), "setMedianFiltering(val) -> None\n. @copybrief getMedianFiltering @see getMedianFiltering"},
| 78931 | {"setOuterIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setOuterIterations, 0), "setOuterIterations(val) -> None\n. @copybrief getOuterIterations @see getOuterIterations"}, |  | 78883 | {"setOuterIterations", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setOuterIterations, 0), "setOuterIterations(val) -> None\n. @copybrief getOuterIterations @see getOuterIterations"},
| 78932 | {"setScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScaleStep, 0), "setScaleStep(val) -> None\n. @copybrief getScaleStep @see getScaleStep"}, |  | 78884 | {"setScaleStep", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScaleStep, 0), "setScaleStep(val) -> None\n. @copybrief getScaleStep @see getScaleStep"},
| 78933 | {"setScalesNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScalesNumber, 0), "setScalesNumber(val) -> None\n. @copybrief getScalesNumber @see getScalesNumber"}, |  | 78885 | {"setScalesNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setScalesNumber, 0), "setScalesNumber(val) -> None\n. @copybrief getScalesNumber @see getScalesNumber"},
| 78934 | {"setTau", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTau, 0), "setTau(val) -> None\n. @copybrief getTau @see getTau"}, |  | 78886 | {"setTau", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTau, 0), "setTau(val) -> None\n. @copybrief getTau @see getTau"},
| 78935 | {"setTheta", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTheta, 0), "setTheta(val) -> None\n. @copybrief getTheta @see getTheta"}, |  | 78887 | {"setTheta", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setTheta, 0), "setTheta(val) -> None\n. @copybrief getTheta @see getTheta"},
| 78936 | {"setUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setUseInitialFlow, 0), "setUseInitialFlow(val) -> None\n. @copybrief getUseInitialFlow @see getUseInitialFlow"}, |  | 78888 | {"setUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setUseInitialFlow, 0), "setUseInitialFlow(val) -> None\n. @copybrief getUseInitialFlow @see getUseInitialFlow"},
| 78937 | {"setWarpingsNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setWarpingsNumber, 0), "setWarpingsNumber(val) -> None\n. @copybrief getWarpingsNumber @see getWarpingsNumber"}, |  | 78889 | {"setWarpingsNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_DualTVL1OpticalFlow_setWarpingsNumber, 0), "setWarpingsNumber(val) -> None\n. @copybrief getWarpingsNumber @see getWarpingsNumber"},
| 78938 |  |  | 78890 |
| 78939 | {NULL, NULL} |  | 78891 | {NULL, NULL}
| 78940 | }; |  | 78892 | };
| 78941 |  |  | 78893 |
| 78942 | // Converter (optflow_DualTVL1OpticalFlow) |  | 78894 | // Converter (optflow_DualTVL1OpticalFlow)
| 78943 |  |  | 78895 |
| 78944 | template<> |  | 78896 | template<>
| 78945 | struct PyOpenCV_Converter< Ptr<cv::optflow::DualTVL1OpticalFlow> > |  | 78897 | struct PyOpenCV_Converter< Ptr<cv::optflow::DualTVL1OpticalFlow> >
| 78946 | { |  | 78898 | {
| 78947 | static PyObject* from(const Ptr<cv::optflow::DualTVL1OpticalFlow>& r) |  | 78899 | static PyObject* from(const Ptr<cv::optflow::DualTVL1OpticalFlow>& r)
| 78948 | { |  | 78900 | {
| 78949 | return pyopencv_optflow_DualTVL1OpticalFlow_Instance(r); |  | 78901 | return pyopencv_optflow_DualTVL1OpticalFlow_Instance(r);
| 78950 | } |  | 78902 | }
| 78951 | static bool to(PyObject* src, Ptr<cv::optflow::DualTVL1OpticalFlow>& dst, const ArgInfo& info) |  | 78903 | static bool to(PyObject* src, Ptr<cv::optflow::DualTVL1OpticalFlow>& dst, const ArgInfo& info)
| 78952 | { |  | 78904 | {
| 78953 | if(!src || src == Py_None) |  | 78905 | if(!src || src == Py_None)
| 78954 | return true; |  | 78906 | return true;
| 78955 | Ptr<cv::optflow::DualTVL1OpticalFlow> * dst_; |  | 78907 | Ptr<cv::optflow::DualTVL1OpticalFlow> * dst_;
| 78956 | if (pyopencv_optflow_DualTVL1OpticalFlow_getp(src, dst_)) |  | 78908 | if (pyopencv_optflow_DualTVL1OpticalFlow_getp(src, dst_))
| 78957 | { |  | 78909 | {
| 78958 | dst = *dst_; |  | 78910 | dst = *dst_;
| 78959 | return true; |  | 78911 | return true;
| 78960 | } |  | 78912 | }
| 78961 |  |  | 78913 |
| 78962 | failmsg("Expected Ptr<cv::optflow::DualTVL1OpticalFlow> for argument '%s'", info.name); |  | 78914 | failmsg("Expected Ptr<cv::optflow::DualTVL1OpticalFlow> for argument '%s'", info.name);
| 78963 | return false; |  | 78915 | return false;
| 78964 | } |  | 78916 | }
| 78965 | }; |  | 78917 | };
| 78966 |  |  | 78918 |
| 78967 | //================================================================================ |  | 78919 | //================================================================================
| 78968 | // optflow_GPCDetails (Generic) |  | 78920 | // optflow_GPCDetails (Generic)
| 78969 | //================================================================================ |  | 78921 | //================================================================================
| 78970 |  |  | 78922 |
| 78971 | // GetSet (optflow_GPCDetails) |  | 78923 | // GetSet (optflow_GPCDetails)
| 78972 |  |  | 78924 |
| 78973 |  |  | 78925 |
| 78974 |  |  | 78926 |
| 78975 | // Methods (optflow_GPCDetails) |  | 78927 | // Methods (optflow_GPCDetails)
| 78976 |  |  | 78928 |
| 78977 |  |  | 78929 |
| 78978 |  |  | 78930 |
| 78979 | // Tables (optflow_GPCDetails) |  | 78931 | // Tables (optflow_GPCDetails)
| 78980 |  |  | 78932 |
| 78981 | static PyGetSetDef pyopencv_optflow_GPCDetails_getseters[] = |  | 78933 | static PyGetSetDef pyopencv_optflow_GPCDetails_getseters[] =
| 78982 | { |  | 78934 | {
| 78983 | {NULL} /* Sentinel */ |  | 78935 | {NULL} /* Sentinel */
| 78984 | }; |  | 78936 | };
| 78985 |  |  | 78937 |
| 78986 | static PyMethodDef pyopencv_optflow_GPCDetails_methods[] = |  | 78938 | static PyMethodDef pyopencv_optflow_GPCDetails_methods[] =
| 78987 | { |  | 78939 | {
| 78988 |  |  | 78940 |
| 78989 | {NULL, NULL} |  | 78941 | {NULL, NULL}
| 78990 | }; |  | 78942 | };
| 78991 |  |  | 78943 |
| 78992 | // Converter (optflow_GPCDetails) |  | 78944 | // Converter (optflow_GPCDetails)
| 78993 |  |  | 78945 |
| 78994 | template<> |  | 78946 | template<>
| 78995 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCDetails> > |  | 78947 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCDetails> >
| 78996 | { |  | 78948 | {
| 78997 | static PyObject* from(const Ptr<cv::optflow::GPCDetails>& r) |  | 78949 | static PyObject* from(const Ptr<cv::optflow::GPCDetails>& r)
| 78998 | { |  | 78950 | {
| 78999 | return pyopencv_optflow_GPCDetails_Instance(r); |  | 78951 | return pyopencv_optflow_GPCDetails_Instance(r);
| 79000 | } |  | 78952 | }
| 79001 | static bool to(PyObject* src, Ptr<cv::optflow::GPCDetails>& dst, const ArgInfo& info) |  | 78953 | static bool to(PyObject* src, Ptr<cv::optflow::GPCDetails>& dst, const ArgInfo& info)
| 79002 | { |  | 78954 | {
| 79003 | if(!src || src == Py_None) |  | 78955 | if(!src || src == Py_None)
| 79004 | return true; |  | 78956 | return true;
| 79005 | Ptr<cv::optflow::GPCDetails> * dst_; |  | 78957 | Ptr<cv::optflow::GPCDetails> * dst_;
| 79006 | if (pyopencv_optflow_GPCDetails_getp(src, dst_)) |  | 78958 | if (pyopencv_optflow_GPCDetails_getp(src, dst_))
| 79007 | { |  | 78959 | {
| 79008 | dst = *dst_; |  | 78960 | dst = *dst_;
| 79009 | return true; |  | 78961 | return true;
| 79010 | } |  | 78962 | }
| 79011 |  |  | 78963 |
| 79012 | failmsg("Expected Ptr<cv::optflow::GPCDetails> for argument '%s'", info.name); |  | 78964 | failmsg("Expected Ptr<cv::optflow::GPCDetails> for argument '%s'", info.name);
| 79013 | return false; |  | 78965 | return false;
| 79014 | } |  | 78966 | }
| 79015 | }; |  | 78967 | };
| 79016 |  |  | 78968 |
| 79017 | //================================================================================ |  | 78969 | //================================================================================
| 79018 | // optflow_GPCPatchDescriptor (Generic) |  | 78970 | // optflow_GPCPatchDescriptor (Generic)
| 79019 | //================================================================================ |  | 78971 | //================================================================================
| 79020 |  |  | 78972 |
| 79021 | // GetSet (optflow_GPCPatchDescriptor) |  | 78973 | // GetSet (optflow_GPCPatchDescriptor)
| 79022 |  |  | 78974 |
| 79023 |  |  | 78975 |
| 79024 |  |  | 78976 |
| 79025 | // Methods (optflow_GPCPatchDescriptor) |  | 78977 | // Methods (optflow_GPCPatchDescriptor)
| 79026 |  |  | 78978 |
| 79027 |  |  | 78979 |
| 79028 |  |  | 78980 |
| 79029 | // Tables (optflow_GPCPatchDescriptor) |  | 78981 | // Tables (optflow_GPCPatchDescriptor)
| 79030 |  |  | 78982 |
| 79031 | static PyGetSetDef pyopencv_optflow_GPCPatchDescriptor_getseters[] = |  | 78983 | static PyGetSetDef pyopencv_optflow_GPCPatchDescriptor_getseters[] =
| 79032 | { |  | 78984 | {
| 79033 | {NULL} /* Sentinel */ |  | 78985 | {NULL} /* Sentinel */
| 79034 | }; |  | 78986 | };
| 79035 |  |  | 78987 |
| 79036 | static PyMethodDef pyopencv_optflow_GPCPatchDescriptor_methods[] = |  | 78988 | static PyMethodDef pyopencv_optflow_GPCPatchDescriptor_methods[] =
| 79037 | { |  | 78989 | {
| 79038 |  |  | 78990 |
| 79039 | {NULL, NULL} |  | 78991 | {NULL, NULL}
| 79040 | }; |  | 78992 | };
| 79041 |  |  | 78993 |
| 79042 | // Converter (optflow_GPCPatchDescriptor) |  | 78994 | // Converter (optflow_GPCPatchDescriptor)
| 79043 |  |  | 78995 |
| 79044 | template<> |  | 78996 | template<>
| 79045 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCPatchDescriptor> > |  | 78997 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCPatchDescriptor> >
| 79046 | { |  | 78998 | {
| 79047 | static PyObject* from(const Ptr<cv::optflow::GPCPatchDescriptor>& r) |  | 78999 | static PyObject* from(const Ptr<cv::optflow::GPCPatchDescriptor>& r)
| 79048 | { |  | 79000 | {
| 79049 | return pyopencv_optflow_GPCPatchDescriptor_Instance(r); |  | 79001 | return pyopencv_optflow_GPCPatchDescriptor_Instance(r);
| 79050 | } |  | 79002 | }
| 79051 | static bool to(PyObject* src, Ptr<cv::optflow::GPCPatchDescriptor>& dst, const ArgInfo& info) |  | 79003 | static bool to(PyObject* src, Ptr<cv::optflow::GPCPatchDescriptor>& dst, const ArgInfo& info)
| 79052 | { |  | 79004 | {
| 79053 | if(!src || src == Py_None) |  | 79005 | if(!src || src == Py_None)
| 79054 | return true; |  | 79006 | return true;
| 79055 | Ptr<cv::optflow::GPCPatchDescriptor> * dst_; |  | 79007 | Ptr<cv::optflow::GPCPatchDescriptor> * dst_;
| 79056 | if (pyopencv_optflow_GPCPatchDescriptor_getp(src, dst_)) |  | 79008 | if (pyopencv_optflow_GPCPatchDescriptor_getp(src, dst_))
| 79057 | { |  | 79009 | {
| 79058 | dst = *dst_; |  | 79010 | dst = *dst_;
| 79059 | return true; |  | 79011 | return true;
| 79060 | } |  | 79012 | }
| 79061 |  |  | 79013 |
| 79062 | failmsg("Expected Ptr<cv::optflow::GPCPatchDescriptor> for argument '%s'", info.name); |  | 79014 | failmsg("Expected Ptr<cv::optflow::GPCPatchDescriptor> for argument '%s'", info.name);
| 79063 | return false; |  | 79015 | return false;
| 79064 | } |  | 79016 | }
| 79065 | }; |  | 79017 | };
| 79066 |  |  | 79018 |
| 79067 | //================================================================================ |  | 79019 | //================================================================================
| 79068 | // optflow_GPCPatchSample (Generic) |  | 79020 | // optflow_GPCPatchSample (Generic)
| 79069 | //================================================================================ |  | 79021 | //================================================================================
| 79070 |  |  | 79022 |
| 79071 | // GetSet (optflow_GPCPatchSample) |  | 79023 | // GetSet (optflow_GPCPatchSample)
| 79072 |  |  | 79024 |
| 79073 |  |  | 79025 |
| 79074 |  |  | 79026 |
| 79075 | // Methods (optflow_GPCPatchSample) |  | 79027 | // Methods (optflow_GPCPatchSample)
| 79076 |  |  | 79028 |
| 79077 |  |  | 79029 |
| 79078 |  |  | 79030 |
| 79079 | // Tables (optflow_GPCPatchSample) |  | 79031 | // Tables (optflow_GPCPatchSample)
| 79080 |  |  | 79032 |
| 79081 | static PyGetSetDef pyopencv_optflow_GPCPatchSample_getseters[] = |  | 79033 | static PyGetSetDef pyopencv_optflow_GPCPatchSample_getseters[] =
| 79082 | { |  | 79034 | {
| 79083 | {NULL} /* Sentinel */ |  | 79035 | {NULL} /* Sentinel */
| 79084 | }; |  | 79036 | };
| 79085 |  |  | 79037 |
| 79086 | static PyMethodDef pyopencv_optflow_GPCPatchSample_methods[] = |  | 79038 | static PyMethodDef pyopencv_optflow_GPCPatchSample_methods[] =
| 79087 | { |  | 79039 | {
| 79088 |  |  | 79040 |
| 79089 | {NULL, NULL} |  | 79041 | {NULL, NULL}
| 79090 | }; |  | 79042 | };
| 79091 |  |  | 79043 |
| 79092 | // Converter (optflow_GPCPatchSample) |  | 79044 | // Converter (optflow_GPCPatchSample)
| 79093 |  |  | 79045 |
| 79094 | template<> |  | 79046 | template<>
| 79095 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCPatchSample> > |  | 79047 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCPatchSample> >
| 79096 | { |  | 79048 | {
| 79097 | static PyObject* from(const Ptr<cv::optflow::GPCPatchSample>& r) |  | 79049 | static PyObject* from(const Ptr<cv::optflow::GPCPatchSample>& r)
| 79098 | { |  | 79050 | {
| 79099 | return pyopencv_optflow_GPCPatchSample_Instance(r); |  | 79051 | return pyopencv_optflow_GPCPatchSample_Instance(r);
| 79100 | } |  | 79052 | }
| 79101 | static bool to(PyObject* src, Ptr<cv::optflow::GPCPatchSample>& dst, const ArgInfo& info) |  | 79053 | static bool to(PyObject* src, Ptr<cv::optflow::GPCPatchSample>& dst, const ArgInfo& info)
| 79102 | { |  | 79054 | {
| 79103 | if(!src || src == Py_None) |  | 79055 | if(!src || src == Py_None)
| 79104 | return true; |  | 79056 | return true;
| 79105 | Ptr<cv::optflow::GPCPatchSample> * dst_; |  | 79057 | Ptr<cv::optflow::GPCPatchSample> * dst_;
| 79106 | if (pyopencv_optflow_GPCPatchSample_getp(src, dst_)) |  | 79058 | if (pyopencv_optflow_GPCPatchSample_getp(src, dst_))
| 79107 | { |  | 79059 | {
| 79108 | dst = *dst_; |  | 79060 | dst = *dst_;
| 79109 | return true; |  | 79061 | return true;
| 79110 | } |  | 79062 | }
| 79111 |  |  | 79063 |
| 79112 | failmsg("Expected Ptr<cv::optflow::GPCPatchSample> for argument '%s'", info.name); |  | 79064 | failmsg("Expected Ptr<cv::optflow::GPCPatchSample> for argument '%s'", info.name);
| 79113 | return false; |  | 79065 | return false;
| 79114 | } |  | 79066 | }
| 79115 | }; |  | 79067 | };
| 79116 |  |  | 79068 |
| 79117 | //================================================================================ |  | 79069 | //================================================================================
| 79118 | // optflow_GPCTrainingSamples (Generic) |  | 79070 | // optflow_GPCTrainingSamples (Generic)
| 79119 | //================================================================================ |  | 79071 | //================================================================================
| 79120 |  |  | 79072 |
| 79121 | // GetSet (optflow_GPCTrainingSamples) |  | 79073 | // GetSet (optflow_GPCTrainingSamples)
| 79122 |  |  | 79074 |
| 79123 |  |  | 79075 |
| 79124 |  |  | 79076 |
| 79125 | // Methods (optflow_GPCTrainingSamples) |  | 79077 | // Methods (optflow_GPCTrainingSamples)
| 79126 |  |  | 79078 |
| 79127 |  |  | 79079 |
| 79128 |  |  | 79080 |
| 79129 | // Tables (optflow_GPCTrainingSamples) |  | 79081 | // Tables (optflow_GPCTrainingSamples)
| 79130 |  |  | 79082 |
| 79131 | static PyGetSetDef pyopencv_optflow_GPCTrainingSamples_getseters[] = |  | 79083 | static PyGetSetDef pyopencv_optflow_GPCTrainingSamples_getseters[] =
| 79132 | { |  | 79084 | {
| 79133 | {NULL} /* Sentinel */ |  | 79085 | {NULL} /* Sentinel */
| 79134 | }; |  | 79086 | };
| 79135 |  |  | 79087 |
| 79136 | static PyMethodDef pyopencv_optflow_GPCTrainingSamples_methods[] = |  | 79088 | static PyMethodDef pyopencv_optflow_GPCTrainingSamples_methods[] =
| 79137 | { |  | 79089 | {
| 79138 |  |  | 79090 |
| 79139 | {NULL, NULL} |  | 79091 | {NULL, NULL}
| 79140 | }; |  | 79092 | };
| 79141 |  |  | 79093 |
| 79142 | // Converter (optflow_GPCTrainingSamples) |  | 79094 | // Converter (optflow_GPCTrainingSamples)
| 79143 |  |  | 79095 |
| 79144 | template<> |  | 79096 | template<>
| 79145 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCTrainingSamples> > |  | 79097 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCTrainingSamples> >
| 79146 | { |  | 79098 | {
| 79147 | static PyObject* from(const Ptr<cv::optflow::GPCTrainingSamples>& r) |  | 79099 | static PyObject* from(const Ptr<cv::optflow::GPCTrainingSamples>& r)
| 79148 | { |  | 79100 | {
| 79149 | return pyopencv_optflow_GPCTrainingSamples_Instance(r); |  | 79101 | return pyopencv_optflow_GPCTrainingSamples_Instance(r);
| 79150 | } |  | 79102 | }
| 79151 | static bool to(PyObject* src, Ptr<cv::optflow::GPCTrainingSamples>& dst, const ArgInfo& info) |  | 79103 | static bool to(PyObject* src, Ptr<cv::optflow::GPCTrainingSamples>& dst, const ArgInfo& info)
| 79152 | { |  | 79104 | {
| 79153 | if(!src || src == Py_None) |  | 79105 | if(!src || src == Py_None)
| 79154 | return true; |  | 79106 | return true;
| 79155 | Ptr<cv::optflow::GPCTrainingSamples> * dst_; |  | 79107 | Ptr<cv::optflow::GPCTrainingSamples> * dst_;
| 79156 | if (pyopencv_optflow_GPCTrainingSamples_getp(src, dst_)) |  | 79108 | if (pyopencv_optflow_GPCTrainingSamples_getp(src, dst_))
| 79157 | { |  | 79109 | {
| 79158 | dst = *dst_; |  | 79110 | dst = *dst_;
| 79159 | return true; |  | 79111 | return true;
| 79160 | } |  | 79112 | }
| 79161 |  |  | 79113 |
| 79162 | failmsg("Expected Ptr<cv::optflow::GPCTrainingSamples> for argument '%s'", info.name); |  | 79114 | failmsg("Expected Ptr<cv::optflow::GPCTrainingSamples> for argument '%s'", info.name);
| 79163 | return false; |  | 79115 | return false;
| 79164 | } |  | 79116 | }
| 79165 | }; |  | 79117 | };
| 79166 |  |  | 79118 |
| 79167 | //================================================================================ |  | 79119 | //================================================================================
| 79168 | // optflow_GPCTree (Generic) |  | 79120 | // optflow_GPCTree (Generic)
| 79169 | //================================================================================ |  | 79121 | //================================================================================
| 79170 |  |  | 79122 |
| 79171 | // GetSet (optflow_GPCTree) |  | 79123 | // GetSet (optflow_GPCTree)
| 79172 |  |  | 79124 |
| 79173 |  |  | 79125 |
| 79174 |  |  | 79126 |
| 79175 | // Methods (optflow_GPCTree) |  | 79127 | // Methods (optflow_GPCTree)
| 79176 |  |  | 79128 |
| 79177 |  |  | 79129 |
| 79178 |  |  | 79130 |
| 79179 | // Tables (optflow_GPCTree) |  | 79131 | // Tables (optflow_GPCTree)
| 79180 |  |  | 79132 |
| 79181 | static PyGetSetDef pyopencv_optflow_GPCTree_getseters[] = |  | 79133 | static PyGetSetDef pyopencv_optflow_GPCTree_getseters[] =
| 79182 | { |  | 79134 | {
| 79183 | {NULL} /* Sentinel */ |  | 79135 | {NULL} /* Sentinel */
| 79184 | }; |  | 79136 | };
| 79185 |  |  | 79137 |
| 79186 | static PyMethodDef pyopencv_optflow_GPCTree_methods[] = |  | 79138 | static PyMethodDef pyopencv_optflow_GPCTree_methods[] =
| 79187 | { |  | 79139 | {
| 79188 |  |  | 79140 |
| 79189 | {NULL, NULL} |  | 79141 | {NULL, NULL}
| 79190 | }; |  | 79142 | };
| 79191 |  |  | 79143 |
| 79192 | // Converter (optflow_GPCTree) |  | 79144 | // Converter (optflow_GPCTree)
| 79193 |  |  | 79145 |
| 79194 | template<> |  | 79146 | template<>
| 79195 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCTree> > |  | 79147 | struct PyOpenCV_Converter< Ptr<cv::optflow::GPCTree> >
| 79196 | { |  | 79148 | {
| 79197 | static PyObject* from(const Ptr<cv::optflow::GPCTree>& r) |  | 79149 | static PyObject* from(const Ptr<cv::optflow::GPCTree>& r)
| 79198 | { |  | 79150 | {
| 79199 | return pyopencv_optflow_GPCTree_Instance(r); |  | 79151 | return pyopencv_optflow_GPCTree_Instance(r);
| 79200 | } |  | 79152 | }
| 79201 | static bool to(PyObject* src, Ptr<cv::optflow::GPCTree>& dst, const ArgInfo& info) |  | 79153 | static bool to(PyObject* src, Ptr<cv::optflow::GPCTree>& dst, const ArgInfo& info)
| 79202 | { |  | 79154 | {
| 79203 | if(!src || src == Py_None) |  | 79155 | if(!src || src == Py_None)
| 79204 | return true; |  | 79156 | return true;
| 79205 | Ptr<cv::optflow::GPCTree> * dst_; |  | 79157 | Ptr<cv::optflow::GPCTree> * dst_;
| 79206 | if (pyopencv_optflow_GPCTree_getp(src, dst_)) |  | 79158 | if (pyopencv_optflow_GPCTree_getp(src, dst_))
| 79207 | { |  | 79159 | {
| 79208 | dst = *dst_; |  | 79160 | dst = *dst_;
| 79209 | return true; |  | 79161 | return true;
| 79210 | } |  | 79162 | }
| 79211 |  |  | 79163 |
| 79212 | failmsg("Expected Ptr<cv::optflow::GPCTree> for argument '%s'", info.name); |  | 79164 | failmsg("Expected Ptr<cv::optflow::GPCTree> for argument '%s'", info.name);
| 79213 | return false; |  | 79165 | return false;
| 79214 | } |  | 79166 | }
| 79215 | }; |  | 79167 | };
| 79216 |  |  | 79168 |
| 79217 | //================================================================================ |  | 79169 | //================================================================================
| 79218 | // optflow_OpticalFlowPCAFlow (Generic) |  | 79170 | // optflow_OpticalFlowPCAFlow (Generic)
| 79219 | //================================================================================ |  | 79171 | //================================================================================
| 79220 |  |  | 79172 |
| 79221 | // GetSet (optflow_OpticalFlowPCAFlow) |  | 79173 | // GetSet (optflow_OpticalFlowPCAFlow)
| 79222 |  |  | 79174 |
| 79223 |  |  | 79175 |
| 79224 |  |  | 79176 |
| 79225 | // Methods (optflow_OpticalFlowPCAFlow) |  | 79177 | // Methods (optflow_OpticalFlowPCAFlow)
| 79226 |  |  | 79178 |
| 79227 |  |  | 79179 |
| 79228 |  |  | 79180 |
| 79229 | // Tables (optflow_OpticalFlowPCAFlow) |  | 79181 | // Tables (optflow_OpticalFlowPCAFlow)
| 79230 |  |  | 79182 |
| 79231 | static PyGetSetDef pyopencv_optflow_OpticalFlowPCAFlow_getseters[] = |  | 79183 | static PyGetSetDef pyopencv_optflow_OpticalFlowPCAFlow_getseters[] =
| 79232 | { |  | 79184 | {
| 79233 | {NULL} /* Sentinel */ |  | 79185 | {NULL} /* Sentinel */
| 79234 | }; |  | 79186 | };
| 79235 |  |  | 79187 |
| 79236 | static PyMethodDef pyopencv_optflow_OpticalFlowPCAFlow_methods[] = |  | 79188 | static PyMethodDef pyopencv_optflow_OpticalFlowPCAFlow_methods[] =
| 79237 | { |  | 79189 | {
| 79238 |  |  | 79190 |
| 79239 | {NULL, NULL} |  | 79191 | {NULL, NULL}
| 79240 | }; |  | 79192 | };
| 79241 |  |  | 79193 |
| 79242 | // Converter (optflow_OpticalFlowPCAFlow) |  | 79194 | // Converter (optflow_OpticalFlowPCAFlow)
| 79243 |  |  | 79195 |
| 79244 | template<> |  | 79196 | template<>
| 79245 | struct PyOpenCV_Converter< Ptr<cv::optflow::OpticalFlowPCAFlow> > |  | 79197 | struct PyOpenCV_Converter< Ptr<cv::optflow::OpticalFlowPCAFlow> >
| 79246 | { |  | 79198 | {
| 79247 | static PyObject* from(const Ptr<cv::optflow::OpticalFlowPCAFlow>& r) |  | 79199 | static PyObject* from(const Ptr<cv::optflow::OpticalFlowPCAFlow>& r)
| 79248 | { |  | 79200 | {
| 79249 | return pyopencv_optflow_OpticalFlowPCAFlow_Instance(r); |  | 79201 | return pyopencv_optflow_OpticalFlowPCAFlow_Instance(r);
| 79250 | } |  | 79202 | }
| 79251 | static bool to(PyObject* src, Ptr<cv::optflow::OpticalFlowPCAFlow>& dst, const ArgInfo& info) |  | 79203 | static bool to(PyObject* src, Ptr<cv::optflow::OpticalFlowPCAFlow>& dst, const ArgInfo& info)
| 79252 | { |  | 79204 | {
| 79253 | if(!src || src == Py_None) |  | 79205 | if(!src || src == Py_None)
| 79254 | return true; |  | 79206 | return true;
| 79255 | Ptr<cv::optflow::OpticalFlowPCAFlow> * dst_; |  | 79207 | Ptr<cv::optflow::OpticalFlowPCAFlow> * dst_;
| 79256 | if (pyopencv_optflow_OpticalFlowPCAFlow_getp(src, dst_)) |  | 79208 | if (pyopencv_optflow_OpticalFlowPCAFlow_getp(src, dst_))
| 79257 | { |  | 79209 | {
| 79258 | dst = *dst_; |  | 79210 | dst = *dst_;
| 79259 | return true; |  | 79211 | return true;
| 79260 | } |  | 79212 | }
| 79261 |  |  | 79213 |
| 79262 | failmsg("Expected Ptr<cv::optflow::OpticalFlowPCAFlow> for argument '%s'", info.name); |  | 79214 | failmsg("Expected Ptr<cv::optflow::OpticalFlowPCAFlow> for argument '%s'", info.name);
| 79263 | return false; |  | 79215 | return false;
| 79264 | } |  | 79216 | }
| 79265 | }; |  | 79217 | };
| 79266 |  |  | 79218 |
| 79267 | //================================================================================ |  | 79219 | //================================================================================
| 79268 | // optflow_PCAPrior (Generic) |  | 79220 | // optflow_PCAPrior (Generic)
| 79269 | //================================================================================ |  | 79221 | //================================================================================
| 79270 |  |  | 79222 |
| 79271 | // GetSet (optflow_PCAPrior) |  | 79223 | // GetSet (optflow_PCAPrior)
| 79272 |  |  | 79224 |
| 79273 |  |  | 79225 |
| 79274 |  |  | 79226 |
| 79275 | // Methods (optflow_PCAPrior) |  | 79227 | // Methods (optflow_PCAPrior)
| 79276 |  |  | 79228 |
| 79277 |  |  | 79229 |
| 79278 |  |  | 79230 |
| 79279 | // Tables (optflow_PCAPrior) |  | 79231 | // Tables (optflow_PCAPrior)
| 79280 |  |  | 79232 |
| 79281 | static PyGetSetDef pyopencv_optflow_PCAPrior_getseters[] = |  | 79233 | static PyGetSetDef pyopencv_optflow_PCAPrior_getseters[] =
| 79282 | { |  | 79234 | {
| 79283 | {NULL} /* Sentinel */ |  | 79235 | {NULL} /* Sentinel */
| 79284 | }; |  | 79236 | };
| 79285 |  |  | 79237 |
| 79286 | static PyMethodDef pyopencv_optflow_PCAPrior_methods[] = |  | 79238 | static PyMethodDef pyopencv_optflow_PCAPrior_methods[] =
| 79287 | { |  | 79239 | {
| 79288 |  |  | 79240 |
| 79289 | {NULL, NULL} |  | 79241 | {NULL, NULL}
| 79290 | }; |  | 79242 | };
| 79291 |  |  | 79243 |
| 79292 | // Converter (optflow_PCAPrior) |  | 79244 | // Converter (optflow_PCAPrior)
| 79293 |  |  | 79245 |
| 79294 | template<> |  | 79246 | template<>
| 79295 | struct PyOpenCV_Converter< Ptr<cv::optflow::PCAPrior> > |  | 79247 | struct PyOpenCV_Converter< Ptr<cv::optflow::PCAPrior> >
| 79296 | { |  | 79248 | {
| 79297 | static PyObject* from(const Ptr<cv::optflow::PCAPrior>& r) |  | 79249 | static PyObject* from(const Ptr<cv::optflow::PCAPrior>& r)
| 79298 | { |  | 79250 | {
| 79299 | return pyopencv_optflow_PCAPrior_Instance(r); |  | 79251 | return pyopencv_optflow_PCAPrior_Instance(r);
| 79300 | } |  | 79252 | }
| 79301 | static bool to(PyObject* src, Ptr<cv::optflow::PCAPrior>& dst, const ArgInfo& info) |  | 79253 | static bool to(PyObject* src, Ptr<cv::optflow::PCAPrior>& dst, const ArgInfo& info)
| 79302 | { |  | 79254 | {
| 79303 | if(!src || src == Py_None) |  | 79255 | if(!src || src == Py_None)
| 79304 | return true; |  | 79256 | return true;
| 79305 | Ptr<cv::optflow::PCAPrior> * dst_; |  | 79257 | Ptr<cv::optflow::PCAPrior> * dst_;
| 79306 | if (pyopencv_optflow_PCAPrior_getp(src, dst_)) |  | 79258 | if (pyopencv_optflow_PCAPrior_getp(src, dst_))
| 79307 | { |  | 79259 | {
| 79308 | dst = *dst_; |  | 79260 | dst = *dst_;
| 79309 | return true; |  | 79261 | return true;
| 79310 | } |  | 79262 | }
| 79311 |  |  | 79263 |
| 79312 | failmsg("Expected Ptr<cv::optflow::PCAPrior> for argument '%s'", info.name); |  | 79264 | failmsg("Expected Ptr<cv::optflow::PCAPrior> for argument '%s'", info.name);
| 79313 | return false; |  | 79265 | return false;
| 79314 | } |  | 79266 | }
| 79315 | }; |  | 79267 | };
| 79316 |  |  | 79268 |
| 79317 | //================================================================================ |  | 79269 | //================================================================================
| 79318 | // optflow_RLOFOpticalFlowParameter (Generic) |  | 79270 | // optflow_RLOFOpticalFlowParameter (Generic)
| 79319 | //================================================================================ |  | 79271 | //================================================================================
| 79320 |  |  | 79272 |
| 79321 | // GetSet (optflow_RLOFOpticalFlowParameter) |  | 79273 | // GetSet (optflow_RLOFOpticalFlowParameter)
| 79322 |  |  | 79274 |
| 79323 |  |  | 79275 |
| 79324 |  |  | 79276 |
| 79325 | // Methods (optflow_RLOFOpticalFlowParameter) |  | 79277 | // Methods (optflow_RLOFOpticalFlowParameter)
| 79326 |  |  | 79278 |
| 79327 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79279 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 79328 | { |  | 79280 | {
| 79329 | using namespace cv::optflow; |  | 79281 | using namespace cv::optflow;
| 79330 |  |  | 79282 |
| 79331 | Ptr<RLOFOpticalFlowParameter> retval; |  | 79283 | Ptr<RLOFOpticalFlowParameter> retval;
| 79332 |  |  | 79284 |
| 79333 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79285 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79334 | { |  | 79286 | {
| 79335 | ERRWRAP2(retval = cv::optflow::RLOFOpticalFlowParameter::create()); |  | 79287 | ERRWRAP2(retval = cv::optflow::RLOFOpticalFlowParameter::create());
| 79336 | return pyopencv_from(retval); |  | 79288 | return pyopencv_from(retval);
| 79337 | } |  | 79289 | }
| 79338 |  |  | 79290 |
| 79339 | return NULL; |  | 79291 | return NULL;
| 79340 | } |  | 79292 | }
| 79341 |  |  | 79293 |
| 79342 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getCrossSegmentationThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79294 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getCrossSegmentationThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 79343 | { |  | 79295 | {
| 79344 | using namespace cv::optflow; |  | 79296 | using namespace cv::optflow;
| 79345 |  |  | 79297 |
| 79346 |  |  | 79298 |
| 79347 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79299 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79348 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79300 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79349 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79301 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79350 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79302 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79351 | int retval; |  | 79303 | int retval;
| 79352 |  |  | 79304 |
| 79353 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79305 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79354 | { |  | 79306 | {
| 79355 | ERRWRAP2(retval = _self_->getCrossSegmentationThreshold()); |  | 79307 | ERRWRAP2(retval = _self_->getCrossSegmentationThreshold());
| 79356 | return pyopencv_from(retval); |  | 79308 | return pyopencv_from(retval);
| 79357 | } |  | 79309 | }
| 79358 |  |  | 79310 |
| 79359 | return NULL; |  | 79311 | return NULL;
| 79360 | } |  | 79312 | }
| 79361 |  |  | 79313 |
| 79362 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getGlobalMotionRansacThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79314 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getGlobalMotionRansacThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 79363 | { |  | 79315 | {
| 79364 | using namespace cv::optflow; |  | 79316 | using namespace cv::optflow;
| 79365 |  |  | 79317 |
| 79366 |  |  | 79318 |
| 79367 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79319 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79368 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79320 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79369 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79321 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79370 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79322 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79371 | float retval; |  | 79323 | float retval;
| 79372 |  |  | 79324 |
| 79373 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79374 | { |  | 79326 | {
| 79375 | ERRWRAP2(retval = _self_->getGlobalMotionRansacThreshold()); |  | 79327 | ERRWRAP2(retval = _self_->getGlobalMotionRansacThreshold());
| 79376 | return pyopencv_from(retval); |  | 79328 | return pyopencv_from(retval);
| 79377 | } |  | 79329 | }
| 79378 |  |  | 79330 |
| 79379 | return NULL; |  | 79331 | return NULL;
| 79380 | } |  | 79332 | }
| 79381 |  |  | 79333 |
| 79382 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getLargeWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79334 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getLargeWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 79383 | { |  | 79335 | {
| 79384 | using namespace cv::optflow; |  | 79336 | using namespace cv::optflow;
| 79385 |  |  | 79337 |
| 79386 |  |  | 79338 |
| 79387 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79339 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79388 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79340 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79389 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79341 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79390 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79342 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79391 | int retval; |  | 79343 | int retval;
| 79392 |  |  | 79344 |
| 79393 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79345 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79394 | { |  | 79346 | {
| 79395 | ERRWRAP2(retval = _self_->getLargeWinSize()); |  | 79347 | ERRWRAP2(retval = _self_->getLargeWinSize());
| 79396 | return pyopencv_from(retval); |  | 79348 | return pyopencv_from(retval);
| 79397 | } |  | 79349 | }
| 79398 |  |  | 79350 |
| 79399 | return NULL; |  | 79351 | return NULL;
| 79400 | } |  | 79352 | }
| 79401 |  |  | 79353 |
| 79402 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxIteration(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79354 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxIteration(PyObject* self, PyObject* py_args, PyObject* kw)
| 79403 | { |  | 79355 | {
| 79404 | using namespace cv::optflow; |  | 79356 | using namespace cv::optflow;
| 79405 |  |  | 79357 |
| 79406 |  |  | 79358 |
| 79407 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79359 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79408 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79360 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79409 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79361 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79410 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79362 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79411 | int retval; |  | 79363 | int retval;
| 79412 |  |  | 79364 |
| 79413 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79365 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79414 | { |  | 79366 | {
| 79415 | ERRWRAP2(retval = _self_->getMaxIteration()); |  | 79367 | ERRWRAP2(retval = _self_->getMaxIteration());
| 79416 | return pyopencv_from(retval); |  | 79368 | return pyopencv_from(retval);
| 79417 | } |  | 79369 | }
| 79418 |  |  | 79370 |
| 79419 | return NULL; |  | 79371 | return NULL;
| 79420 | } |  | 79372 | }
| 79421 |  |  | 79373 |
| 79422 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79374 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 79423 | { |  | 79375 | {
| 79424 | using namespace cv::optflow; |  | 79376 | using namespace cv::optflow;
| 79425 |  |  | 79377 |
| 79426 |  |  | 79378 |
| 79427 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79379 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79428 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79380 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79429 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79381 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79430 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79382 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79431 | int retval; |  | 79383 | int retval;
| 79432 |  |  | 79384 |
| 79433 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79385 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79434 | { |  | 79386 | {
| 79435 | ERRWRAP2(retval = _self_->getMaxLevel()); |  | 79387 | ERRWRAP2(retval = _self_->getMaxLevel());
| 79436 | return pyopencv_from(retval); |  | 79388 | return pyopencv_from(retval);
| 79437 | } |  | 79389 | }
| 79438 |  |  | 79390 |
| 79439 | return NULL; |  | 79391 | return NULL;
| 79440 | } |  | 79392 | }
| 79441 |  |  | 79393 |
| 79442 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMinEigenValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79394 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMinEigenValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 79443 | { |  | 79395 | {
| 79444 | using namespace cv::optflow; |  | 79396 | using namespace cv::optflow;
| 79445 |  |  | 79397 |
| 79446 |  |  | 79398 |
| 79447 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79399 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79448 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79400 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79449 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79401 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79450 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79402 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79451 | float retval; |  | 79403 | float retval;
| 79452 |  |  | 79404 |
| 79453 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79405 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79454 | { |  | 79406 | {
| 79455 | ERRWRAP2(retval = _self_->getMinEigenValue()); |  | 79407 | ERRWRAP2(retval = _self_->getMinEigenValue());
| 79456 | return pyopencv_from(retval); |  | 79408 | return pyopencv_from(retval);
| 79457 | } |  | 79409 | }
| 79458 |  |  | 79410 |
| 79459 | return NULL; |  | 79411 | return NULL;
| 79460 | } |  | 79412 | }
| 79461 |  |  | 79413 |
| 79462 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma0(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79414 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma0(PyObject* self, PyObject* py_args, PyObject* kw)
| 79463 | { |  | 79415 | {
| 79464 | using namespace cv::optflow; |  | 79416 | using namespace cv::optflow;
| 79465 |  |  | 79417 |
| 79466 |  |  | 79418 |
| 79467 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79419 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79468 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79420 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79469 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79421 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79470 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79422 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79471 | float retval; |  | 79423 | float retval;
| 79472 |  |  | 79424 |
| 79473 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79425 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79474 | { |  | 79426 | {
| 79475 | ERRWRAP2(retval = _self_->getNormSigma0()); |  | 79427 | ERRWRAP2(retval = _self_->getNormSigma0());
| 79476 | return pyopencv_from(retval); |  | 79428 | return pyopencv_from(retval);
| 79477 | } |  | 79429 | }
| 79478 |  |  | 79430 |
| 79479 | return NULL; |  | 79431 | return NULL;
| 79480 | } |  | 79432 | }
| 79481 |  |  | 79433 |
| 79482 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79434 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma1(PyObject* self, PyObject* py_args, PyObject* kw)
| 79483 | { |  | 79435 | {
| 79484 | using namespace cv::optflow; |  | 79436 | using namespace cv::optflow;
| 79485 |  |  | 79437 |
| 79486 |  |  | 79438 |
| 79487 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79439 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79488 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79440 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79489 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79441 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79490 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79442 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79491 | float retval; |  | 79443 | float retval;
| 79492 |  |  | 79444 |
| 79493 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79445 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79494 | { |  | 79446 | {
| 79495 | ERRWRAP2(retval = _self_->getNormSigma1()); |  | 79447 | ERRWRAP2(retval = _self_->getNormSigma1());
| 79496 | return pyopencv_from(retval); |  | 79448 | return pyopencv_from(retval);
| 79497 | } |  | 79449 | }
| 79498 |  |  | 79450 |
| 79499 | return NULL; |  | 79451 | return NULL;
| 79500 | } |  | 79452 | }
| 79501 |  |  | 79453 |
| 79502 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSmallWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79454 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSmallWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 79503 | { |  | 79455 | {
| 79504 | using namespace cv::optflow; |  | 79456 | using namespace cv::optflow;
| 79505 |  |  | 79457 |
| 79506 |  |  | 79458 |
| 79507 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79459 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79508 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79460 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79509 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79461 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79510 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79462 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79511 | int retval; |  | 79463 | int retval;
| 79512 |  |  | 79464 |
| 79513 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79465 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79514 | { |  | 79466 | {
| 79515 | ERRWRAP2(retval = _self_->getSmallWinSize()); |  | 79467 | ERRWRAP2(retval = _self_->getSmallWinSize());
| 79516 | return pyopencv_from(retval); |  | 79468 | return pyopencv_from(retval);
| 79517 | } |  | 79469 | }
| 79518 |  |  | 79470 |
| 79519 | return NULL; |  | 79471 | return NULL;
| 79520 | } |  | 79472 | }
| 79521 |  |  | 79473 |
| 79522 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSolverType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79474 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSolverType(PyObject* self, PyObject* py_args, PyObject* kw)
| 79523 | { |  | 79475 | {
| 79524 | using namespace cv::optflow; |  | 79476 | using namespace cv::optflow;
| 79525 |  |  | 79477 |
| 79526 |  |  | 79478 |
| 79527 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79479 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79528 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79480 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79529 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79481 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79530 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79482 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79531 | SolverType retval; |  | 79483 | SolverType retval;
| 79532 |  |  | 79484 |
| 79533 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79485 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79534 | { |  | 79486 | {
| 79535 | ERRWRAP2(retval = _self_->getSolverType()); |  | 79487 | ERRWRAP2(retval = _self_->getSolverType());
| 79536 | return pyopencv_from(retval); |  | 79488 | return pyopencv_from(retval);
| 79537 | } |  | 79489 | }
| 79538 |  |  | 79490 |
| 79539 | return NULL; |  | 79491 | return NULL;
| 79540 | } |  | 79492 | }
| 79541 |  |  | 79493 |
| 79542 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSupportRegionType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79494 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSupportRegionType(PyObject* self, PyObject* py_args, PyObject* kw)
| 79543 | { |  | 79495 | {
| 79544 | using namespace cv::optflow; |  | 79496 | using namespace cv::optflow;
| 79545 |  |  | 79497 |
| 79546 |  |  | 79498 |
| 79547 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79499 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79548 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79500 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79549 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79501 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79550 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79502 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79551 | SupportRegionType retval; |  | 79503 | SupportRegionType retval;
| 79552 |  |  | 79504 |
| 79553 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79505 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79554 | { |  | 79506 | {
| 79555 | ERRWRAP2(retval = _self_->getSupportRegionType()); |  | 79507 | ERRWRAP2(retval = _self_->getSupportRegionType());
| 79556 | return pyopencv_from(retval); |  | 79508 | return pyopencv_from(retval);
| 79557 | } |  | 79509 | }
| 79558 |  |  | 79510 |
| 79559 | return NULL; |  | 79511 | return NULL;
| 79560 | } |  | 79512 | }
| 79561 |  |  | 79513 |
| 79562 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseGlobalMotionPrior(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79514 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseGlobalMotionPrior(PyObject* self, PyObject* py_args, PyObject* kw)
| 79563 | { |  | 79515 | {
| 79564 | using namespace cv::optflow; |  | 79516 | using namespace cv::optflow;
| 79565 |  |  | 79517 |
| 79566 |  |  | 79518 |
| 79567 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79519 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79568 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79520 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79569 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79521 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79570 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79522 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79571 | bool retval; |  | 79523 | bool retval;
| 79572 |  |  | 79524 |
| 79573 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79525 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79574 | { |  | 79526 | {
| 79575 | ERRWRAP2(retval = _self_->getUseGlobalMotionPrior()); |  | 79527 | ERRWRAP2(retval = _self_->getUseGlobalMotionPrior());
| 79576 | return pyopencv_from(retval); |  | 79528 | return pyopencv_from(retval);
| 79577 | } |  | 79529 | }
| 79578 |  |  | 79530 |
| 79579 | return NULL; |  | 79531 | return NULL;
| 79580 | } |  | 79532 | }
| 79581 |  |  | 79533 |
| 79582 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseIlluminationModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79534 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseIlluminationModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 79583 | { |  | 79535 | {
| 79584 | using namespace cv::optflow; |  | 79536 | using namespace cv::optflow;
| 79585 |  |  | 79537 |
| 79586 |  |  | 79538 |
| 79587 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79539 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79588 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79540 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79589 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79541 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79590 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79542 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79591 | bool retval; |  | 79543 | bool retval;
| 79592 |  |  | 79544 |
| 79593 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79545 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79594 | { |  | 79546 | {
| 79595 | ERRWRAP2(retval = _self_->getUseIlluminationModel()); |  | 79547 | ERRWRAP2(retval = _self_->getUseIlluminationModel());
| 79596 | return pyopencv_from(retval); |  | 79548 | return pyopencv_from(retval);
| 79597 | } |  | 79549 | }
| 79598 |  |  | 79550 |
| 79599 | return NULL; |  | 79551 | return NULL;
| 79600 | } |  | 79552 | }
| 79601 |  |  | 79553 |
| 79602 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79554 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw)
| 79603 | { |  | 79555 | {
| 79604 | using namespace cv::optflow; |  | 79556 | using namespace cv::optflow;
| 79605 |  |  | 79557 |
| 79606 |  |  | 79558 |
| 79607 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79559 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79608 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79560 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79609 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79561 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79610 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79562 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79611 | bool retval; |  | 79563 | bool retval;
| 79612 |  |  | 79564 |
| 79613 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 79565 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 79614 | { |  | 79566 | {
| 79615 | ERRWRAP2(retval = _self_->getUseInitialFlow()); |  | 79567 | ERRWRAP2(retval = _self_->getUseInitialFlow());
| 79616 | return pyopencv_from(retval); |  | 79568 | return pyopencv_from(retval);
| 79617 | } |  | 79569 | }
| 79618 |  |  | 79570 |
| 79619 | return NULL; |  | 79571 | return NULL;
| 79620 | } |  | 79572 | }
| 79621 |  |  | 79573 |
| 79622 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setCrossSegmentationThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79574 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setCrossSegmentationThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 79623 | { |  | 79575 | {
| 79624 | using namespace cv::optflow; |  | 79576 | using namespace cv::optflow;
| 79625 |  |  | 79577 |
| 79626 |  |  | 79578 |
| 79627 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79579 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79628 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79580 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79629 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79581 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79630 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79582 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79631 | PyObject* pyobj_val = NULL; |  | 79583 | PyObject* pyobj_val = NULL;
| 79632 | int val=0; |  | 79584 | int val=0;
| 79633 |  |  | 79585 |
| 79634 | const char* keywords[] = { "val", NULL }; |  | 79586 | const char* keywords[] = { "val", NULL };
| 79635 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setCrossSegmentationThreshold", (char**)keywords, &pyobj_val) && |  | 79587 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setCrossSegmentationThreshold", (char**)keywords, &pyobj_val) &&
| 79636 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79588 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79637 | { |  | 79589 | {
| 79638 | ERRWRAP2(_self_->setCrossSegmentationThreshold(val)); |  | 79590 | ERRWRAP2(_self_->setCrossSegmentationThreshold(val));
| 79639 | Py_RETURN_NONE; |  | 79591 | Py_RETURN_NONE;
| 79640 | } |  | 79592 | }
| 79641 |  |  | 79593 |
| 79642 | return NULL; |  | 79594 | return NULL;
| 79643 | } |  | 79595 | }
| 79644 |  |  | 79596 |
| 79645 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setGlobalMotionRansacThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79597 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setGlobalMotionRansacThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 79646 | { |  | 79598 | {
| 79647 | using namespace cv::optflow; |  | 79599 | using namespace cv::optflow;
| 79648 |  |  | 79600 |
| 79649 |  |  | 79601 |
| 79650 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79602 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79651 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79603 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79652 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79604 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79653 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79605 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79654 | PyObject* pyobj_val = NULL; |  | 79606 | PyObject* pyobj_val = NULL;
| 79655 | float val=0.f; |  | 79607 | float val=0.f;
| 79656 |  |  | 79608 |
| 79657 | const char* keywords[] = { "val", NULL }; |  | 79609 | const char* keywords[] = { "val", NULL };
| 79658 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setGlobalMotionRansacThreshold", (char**)keywords, &pyobj_val) && |  | 79610 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setGlobalMotionRansacThreshold", (char**)keywords, &pyobj_val) &&
| 79659 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79611 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79660 | { |  | 79612 | {
| 79661 | ERRWRAP2(_self_->setGlobalMotionRansacThreshold(val)); |  | 79613 | ERRWRAP2(_self_->setGlobalMotionRansacThreshold(val));
| 79662 | Py_RETURN_NONE; |  | 79614 | Py_RETURN_NONE;
| 79663 | } |  | 79615 | }
| 79664 |  |  | 79616 |
| 79665 | return NULL; |  | 79617 | return NULL;
| 79666 | } |  | 79618 | }
| 79667 |  |  | 79619 |
| 79668 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setLargeWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79620 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setLargeWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 79669 | { |  | 79621 | {
| 79670 | using namespace cv::optflow; |  | 79622 | using namespace cv::optflow;
| 79671 |  |  | 79623 |
| 79672 |  |  | 79624 |
| 79673 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79625 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79674 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79626 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79675 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79627 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79676 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79628 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79677 | PyObject* pyobj_val = NULL; |  | 79629 | PyObject* pyobj_val = NULL;
| 79678 | int val=0; |  | 79630 | int val=0;
| 79679 |  |  | 79631 |
| 79680 | const char* keywords[] = { "val", NULL }; |  | 79632 | const char* keywords[] = { "val", NULL };
| 79681 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setLargeWinSize", (char**)keywords, &pyobj_val) && |  | 79633 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setLargeWinSize", (char**)keywords, &pyobj_val) &&
| 79682 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79634 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79683 | { |  | 79635 | {
| 79684 | ERRWRAP2(_self_->setLargeWinSize(val)); |  | 79636 | ERRWRAP2(_self_->setLargeWinSize(val));
| 79685 | Py_RETURN_NONE; |  | 79637 | Py_RETURN_NONE;
| 79686 | } |  | 79638 | }
| 79687 |  |  | 79639 |
| 79688 | return NULL; |  | 79640 | return NULL;
| 79689 | } |  | 79641 | }
| 79690 |  |  | 79642 |
| 79691 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxIteration(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79643 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxIteration(PyObject* self, PyObject* py_args, PyObject* kw)
| 79692 | { |  | 79644 | {
| 79693 | using namespace cv::optflow; |  | 79645 | using namespace cv::optflow;
| 79694 |  |  | 79646 |
| 79695 |  |  | 79647 |
| 79696 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79648 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79697 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79649 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79698 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79650 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79699 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79651 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79700 | PyObject* pyobj_val = NULL; |  | 79652 | PyObject* pyobj_val = NULL;
| 79701 | int val=0; |  | 79653 | int val=0;
| 79702 |  |  | 79654 |
| 79703 | const char* keywords[] = { "val", NULL }; |  | 79655 | const char* keywords[] = { "val", NULL };
| 79704 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setMaxIteration", (char**)keywords, &pyobj_val) && |  | 79656 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setMaxIteration", (char**)keywords, &pyobj_val) &&
| 79705 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79657 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79706 | { |  | 79658 | {
| 79707 | ERRWRAP2(_self_->setMaxIteration(val)); |  | 79659 | ERRWRAP2(_self_->setMaxIteration(val));
| 79708 | Py_RETURN_NONE; |  | 79660 | Py_RETURN_NONE;
| 79709 | } |  | 79661 | }
| 79710 |  |  | 79662 |
| 79711 | return NULL; |  | 79663 | return NULL;
| 79712 | } |  | 79664 | }
| 79713 |  |  | 79665 |
| 79714 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79666 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxLevel(PyObject* self, PyObject* py_args, PyObject* kw)
| 79715 | { |  | 79667 | {
| 79716 | using namespace cv::optflow; |  | 79668 | using namespace cv::optflow;
| 79717 |  |  | 79669 |
| 79718 |  |  | 79670 |
| 79719 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79671 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79720 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79672 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79721 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79673 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79722 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79674 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79723 | PyObject* pyobj_val = NULL; |  | 79675 | PyObject* pyobj_val = NULL;
| 79724 | int val=0; |  | 79676 | int val=0;
| 79725 |  |  | 79677 |
| 79726 | const char* keywords[] = { "val", NULL }; |  | 79678 | const char* keywords[] = { "val", NULL };
| 79727 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setMaxLevel", (char**)keywords, &pyobj_val) && |  | 79679 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setMaxLevel", (char**)keywords, &pyobj_val) &&
| 79728 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79680 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79729 | { |  | 79681 | {
| 79730 | ERRWRAP2(_self_->setMaxLevel(val)); |  | 79682 | ERRWRAP2(_self_->setMaxLevel(val));
| 79731 | Py_RETURN_NONE; |  | 79683 | Py_RETURN_NONE;
| 79732 | } |  | 79684 | }
| 79733 |  |  | 79685 |
| 79734 | return NULL; |  | 79686 | return NULL;
| 79735 | } |  | 79687 | }
| 79736 |  |  | 79688 |
| 79737 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMinEigenValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79689 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMinEigenValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 79738 | { |  | 79690 | {
| 79739 | using namespace cv::optflow; |  | 79691 | using namespace cv::optflow;
| 79740 |  |  | 79692 |
| 79741 |  |  | 79693 |
| 79742 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79694 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79743 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79695 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79744 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79696 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79745 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79697 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79746 | PyObject* pyobj_val = NULL; |  | 79698 | PyObject* pyobj_val = NULL;
| 79747 | float val=0.f; |  | 79699 | float val=0.f;
| 79748 |  |  | 79700 |
| 79749 | const char* keywords[] = { "val", NULL }; |  | 79701 | const char* keywords[] = { "val", NULL };
| 79750 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setMinEigenValue", (char**)keywords, &pyobj_val) && |  | 79702 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setMinEigenValue", (char**)keywords, &pyobj_val) &&
| 79751 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79703 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79752 | { |  | 79704 | {
| 79753 | ERRWRAP2(_self_->setMinEigenValue(val)); |  | 79705 | ERRWRAP2(_self_->setMinEigenValue(val));
| 79754 | Py_RETURN_NONE; |  | 79706 | Py_RETURN_NONE;
| 79755 | } |  | 79707 | }
| 79756 |  |  | 79708 |
| 79757 | return NULL; |  | 79709 | return NULL;
| 79758 | } |  | 79710 | }
| 79759 |  |  | 79711 |
| 79760 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma0(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79712 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma0(PyObject* self, PyObject* py_args, PyObject* kw)
| 79761 | { |  | 79713 | {
| 79762 | using namespace cv::optflow; |  | 79714 | using namespace cv::optflow;
| 79763 |  |  | 79715 |
| 79764 |  |  | 79716 |
| 79765 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79717 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79766 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79718 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79767 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79719 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79768 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79720 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79769 | PyObject* pyobj_val = NULL; |  | 79721 | PyObject* pyobj_val = NULL;
| 79770 | float val=0.f; |  | 79722 | float val=0.f;
| 79771 |  |  | 79723 |
| 79772 | const char* keywords[] = { "val", NULL }; |  | 79724 | const char* keywords[] = { "val", NULL };
| 79773 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setNormSigma0", (char**)keywords, &pyobj_val) && |  | 79725 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setNormSigma0", (char**)keywords, &pyobj_val) &&
| 79774 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79726 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79775 | { |  | 79727 | {
| 79776 | ERRWRAP2(_self_->setNormSigma0(val)); |  | 79728 | ERRWRAP2(_self_->setNormSigma0(val));
| 79777 | Py_RETURN_NONE; |  | 79729 | Py_RETURN_NONE;
| 79778 | } |  | 79730 | }
| 79779 |  |  | 79731 |
| 79780 | return NULL; |  | 79732 | return NULL;
| 79781 | } |  | 79733 | }
| 79782 |  |  | 79734 |
| 79783 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma1(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79735 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma1(PyObject* self, PyObject* py_args, PyObject* kw)
| 79784 | { |  | 79736 | {
| 79785 | using namespace cv::optflow; |  | 79737 | using namespace cv::optflow;
| 79786 |  |  | 79738 |
| 79787 |  |  | 79739 |
| 79788 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79740 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79789 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79741 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79790 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79742 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79791 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79743 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79792 | PyObject* pyobj_val = NULL; |  | 79744 | PyObject* pyobj_val = NULL;
| 79793 | float val=0.f; |  | 79745 | float val=0.f;
| 79794 |  |  | 79746 |
| 79795 | const char* keywords[] = { "val", NULL }; |  | 79747 | const char* keywords[] = { "val", NULL };
| 79796 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setNormSigma1", (char**)keywords, &pyobj_val) && |  | 79748 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setNormSigma1", (char**)keywords, &pyobj_val) &&
| 79797 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79749 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79798 | { |  | 79750 | {
| 79799 | ERRWRAP2(_self_->setNormSigma1(val)); |  | 79751 | ERRWRAP2(_self_->setNormSigma1(val));
| 79800 | Py_RETURN_NONE; |  | 79752 | Py_RETURN_NONE;
| 79801 | } |  | 79753 | }
| 79802 |  |  | 79754 |
| 79803 | return NULL; |  | 79755 | return NULL;
| 79804 | } |  | 79756 | }
| 79805 |  |  | 79757 |
| 79806 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSmallWinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79758 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSmallWinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 79807 | { |  | 79759 | {
| 79808 | using namespace cv::optflow; |  | 79760 | using namespace cv::optflow;
| 79809 |  |  | 79761 |
| 79810 |  |  | 79762 |
| 79811 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79763 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79812 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79764 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79813 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79765 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79814 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79766 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79815 | PyObject* pyobj_val = NULL; |  | 79767 | PyObject* pyobj_val = NULL;
| 79816 | int val=0; |  | 79768 | int val=0;
| 79817 |  |  | 79769 |
| 79818 | const char* keywords[] = { "val", NULL }; |  | 79770 | const char* keywords[] = { "val", NULL };
| 79819 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setSmallWinSize", (char**)keywords, &pyobj_val) && |  | 79771 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setSmallWinSize", (char**)keywords, &pyobj_val) &&
| 79820 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79772 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79821 | { |  | 79773 | {
| 79822 | ERRWRAP2(_self_->setSmallWinSize(val)); |  | 79774 | ERRWRAP2(_self_->setSmallWinSize(val));
| 79823 | Py_RETURN_NONE; |  | 79775 | Py_RETURN_NONE;
| 79824 | } |  | 79776 | }
| 79825 |  |  | 79777 |
| 79826 | return NULL; |  | 79778 | return NULL;
| 79827 | } |  | 79779 | }
| 79828 |  |  | 79780 |
| 79829 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSolverType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79781 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSolverType(PyObject* self, PyObject* py_args, PyObject* kw)
| 79830 | { |  | 79782 | {
| 79831 | using namespace cv::optflow; |  | 79783 | using namespace cv::optflow;
| 79832 |  |  | 79784 |
| 79833 |  |  | 79785 |
| 79834 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79786 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79835 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79787 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79836 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79788 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79837 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79789 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79838 | PyObject* pyobj_val = NULL; |  | 79790 | PyObject* pyobj_val = NULL;
| 79839 | SolverType val=static_cast<SolverType>(0); |  | 79791 | SolverType val=static_cast<SolverType>(0);
| 79840 |  |  | 79792 |
| 79841 | const char* keywords[] = { "val", NULL }; |  | 79793 | const char* keywords[] = { "val", NULL };
| 79842 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setSolverType", (char**)keywords, &pyobj_val) && |  | 79794 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setSolverType", (char**)keywords, &pyobj_val) &&
| 79843 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79795 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79844 | { |  | 79796 | {
| 79845 | ERRWRAP2(_self_->setSolverType(val)); |  | 79797 | ERRWRAP2(_self_->setSolverType(val));
| 79846 | Py_RETURN_NONE; |  | 79798 | Py_RETURN_NONE;
| 79847 | } |  | 79799 | }
| 79848 |  |  | 79800 |
| 79849 | return NULL; |  | 79801 | return NULL;
| 79850 | } |  | 79802 | }
| 79851 |  |  | 79803 |
| 79852 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSupportRegionType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79804 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSupportRegionType(PyObject* self, PyObject* py_args, PyObject* kw)
| 79853 | { |  | 79805 | {
| 79854 | using namespace cv::optflow; |  | 79806 | using namespace cv::optflow;
| 79855 |  |  | 79807 |
| 79856 |  |  | 79808 |
| 79857 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79809 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79858 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79810 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79859 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79811 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79860 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79812 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79861 | PyObject* pyobj_val = NULL; |  | 79813 | PyObject* pyobj_val = NULL;
| 79862 | SupportRegionType val=static_cast<SupportRegionType>(0); |  | 79814 | SupportRegionType val=static_cast<SupportRegionType>(0);
| 79863 |  |  | 79815 |
| 79864 | const char* keywords[] = { "val", NULL }; |  | 79816 | const char* keywords[] = { "val", NULL };
| 79865 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setSupportRegionType", (char**)keywords, &pyobj_val) && |  | 79817 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setSupportRegionType", (char**)keywords, &pyobj_val) &&
| 79866 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79818 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79867 | { |  | 79819 | {
| 79868 | ERRWRAP2(_self_->setSupportRegionType(val)); |  | 79820 | ERRWRAP2(_self_->setSupportRegionType(val));
| 79869 | Py_RETURN_NONE; |  | 79821 | Py_RETURN_NONE;
| 79870 | } |  | 79822 | }
| 79871 |  |  | 79823 |
| 79872 | return NULL; |  | 79824 | return NULL;
| 79873 | } |  | 79825 | }
| 79874 |  |  | 79826 |
| 79875 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseGlobalMotionPrior(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79827 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseGlobalMotionPrior(PyObject* self, PyObject* py_args, PyObject* kw)
| 79876 | { |  | 79828 | {
| 79877 | using namespace cv::optflow; |  | 79829 | using namespace cv::optflow;
| 79878 |  |  | 79830 |
| 79879 |  |  | 79831 |
| 79880 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79832 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79881 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79833 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79882 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79834 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79883 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79835 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79884 | PyObject* pyobj_val = NULL; |  | 79836 | PyObject* pyobj_val = NULL;
| 79885 | bool val=0; |  | 79837 | bool val=0;
| 79886 |  |  | 79838 |
| 79887 | const char* keywords[] = { "val", NULL }; |  | 79839 | const char* keywords[] = { "val", NULL };
| 79888 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseGlobalMotionPrior", (char**)keywords, &pyobj_val) && |  | 79840 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseGlobalMotionPrior", (char**)keywords, &pyobj_val) &&
| 79889 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79841 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79890 | { |  | 79842 | {
| 79891 | ERRWRAP2(_self_->setUseGlobalMotionPrior(val)); |  | 79843 | ERRWRAP2(_self_->setUseGlobalMotionPrior(val));
| 79892 | Py_RETURN_NONE; |  | 79844 | Py_RETURN_NONE;
| 79893 | } |  | 79845 | }
| 79894 |  |  | 79846 |
| 79895 | return NULL; |  | 79847 | return NULL;
| 79896 | } |  | 79848 | }
| 79897 |  |  | 79849 |
| 79898 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseIlluminationModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79850 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseIlluminationModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 79899 | { |  | 79851 | {
| 79900 | using namespace cv::optflow; |  | 79852 | using namespace cv::optflow;
| 79901 |  |  | 79853 |
| 79902 |  |  | 79854 |
| 79903 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79855 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79904 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79856 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79905 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79857 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79906 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79858 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79907 | PyObject* pyobj_val = NULL; |  | 79859 | PyObject* pyobj_val = NULL;
| 79908 | bool val=0; |  | 79860 | bool val=0;
| 79909 |  |  | 79861 |
| 79910 | const char* keywords[] = { "val", NULL }; |  | 79862 | const char* keywords[] = { "val", NULL };
| 79911 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseIlluminationModel", (char**)keywords, &pyobj_val) && |  | 79863 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseIlluminationModel", (char**)keywords, &pyobj_val) &&
| 79912 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79864 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79913 | { |  | 79865 | {
| 79914 | ERRWRAP2(_self_->setUseIlluminationModel(val)); |  | 79866 | ERRWRAP2(_self_->setUseIlluminationModel(val));
| 79915 | Py_RETURN_NONE; |  | 79867 | Py_RETURN_NONE;
| 79916 | } |  | 79868 | }
| 79917 |  |  | 79869 |
| 79918 | return NULL; |  | 79870 | return NULL;
| 79919 | } |  | 79871 | }
| 79920 |  |  | 79872 |
| 79921 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79873 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseInitialFlow(PyObject* self, PyObject* py_args, PyObject* kw)
| 79922 | { |  | 79874 | {
| 79923 | using namespace cv::optflow; |  | 79875 | using namespace cv::optflow;
| 79924 |  |  | 79876 |
| 79925 |  |  | 79877 |
| 79926 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79878 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79927 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79879 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79928 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79880 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79929 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79881 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79930 | PyObject* pyobj_val = NULL; |  | 79882 | PyObject* pyobj_val = NULL;
| 79931 | bool val=0; |  | 79883 | bool val=0;
| 79932 |  |  | 79884 |
| 79933 | const char* keywords[] = { "val", NULL }; |  | 79885 | const char* keywords[] = { "val", NULL };
| 79934 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseInitialFlow", (char**)keywords, &pyobj_val) && |  | 79886 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseInitialFlow", (char**)keywords, &pyobj_val) &&
| 79935 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79887 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79936 | { |  | 79888 | {
| 79937 | ERRWRAP2(_self_->setUseInitialFlow(val)); |  | 79889 | ERRWRAP2(_self_->setUseInitialFlow(val));
| 79938 | Py_RETURN_NONE; |  | 79890 | Py_RETURN_NONE;
| 79939 | } |  | 79891 | }
| 79940 |  |  | 79892 |
| 79941 | return NULL; |  | 79893 | return NULL;
| 79942 | } |  | 79894 | }
| 79943 |  |  | 79895 |
| 79944 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseMEstimator(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79896 | static PyObject* pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseMEstimator(PyObject* self, PyObject* py_args, PyObject* kw)
| 79945 | { |  | 79897 | {
| 79946 | using namespace cv::optflow; |  | 79898 | using namespace cv::optflow;
| 79947 |  |  | 79899 |
| 79948 |  |  | 79900 |
| 79949 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0; |  | 79901 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * self1 = 0;
| 79950 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1)) |  | 79902 | if (!pyopencv_optflow_RLOFOpticalFlowParameter_getp(self, self1))
| 79951 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)"); |  | 79903 | return failmsgp("Incorrect type of self (must be 'optflow_RLOFOpticalFlowParameter' or its derivative)");
| 79952 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1); |  | 79904 | Ptr<cv::optflow::RLOFOpticalFlowParameter> _self_ = *(self1);
| 79953 | PyObject* pyobj_val = NULL; |  | 79905 | PyObject* pyobj_val = NULL;
| 79954 | bool val=0; |  | 79906 | bool val=0;
| 79955 |  |  | 79907 |
| 79956 | const char* keywords[] = { "val", NULL }; |  | 79908 | const char* keywords[] = { "val", NULL };
| 79957 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseMEstimator", (char**)keywords, &pyobj_val) && |  | 79909 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_RLOFOpticalFlowParameter.setUseMEstimator", (char**)keywords, &pyobj_val) &&
| 79958 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 79910 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 79959 | { |  | 79911 | {
| 79960 | ERRWRAP2(_self_->setUseMEstimator(val)); |  | 79912 | ERRWRAP2(_self_->setUseMEstimator(val));
| 79961 | Py_RETURN_NONE; |  | 79913 | Py_RETURN_NONE;
| 79962 | } |  | 79914 | }
| 79963 |  |  | 79915 |
| 79964 | return NULL; |  | 79916 | return NULL;
| 79965 | } |  | 79917 | }
| 79966 |  |  | 79918 |
| 79967 |  |  | 79919 |
| 79968 |  |  | 79920 |
| 79969 | // Tables (optflow_RLOFOpticalFlowParameter) |  | 79921 | // Tables (optflow_RLOFOpticalFlowParameter)
| 79970 |  |  | 79922 |
| 79971 | static PyGetSetDef pyopencv_optflow_RLOFOpticalFlowParameter_getseters[] = |  | 79923 | static PyGetSetDef pyopencv_optflow_RLOFOpticalFlowParameter_getseters[] =
| 79972 | { |  | 79924 | {
| 79973 | {NULL} /* Sentinel */ |  | 79925 | {NULL} /* Sentinel */
| 79974 | }; |  | 79926 | };
| 79975 |  |  | 79927 |
| 79976 | static PyMethodDef pyopencv_optflow_RLOFOpticalFlowParameter_methods[] = |  | 79928 | static PyMethodDef pyopencv_optflow_RLOFOpticalFlowParameter_methods[] =
| 79977 | { |  | 79929 | {
| 79978 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_create_static, METH_STATIC), "create() -> retval\n."}, |  | 79930 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_create_static, METH_STATIC), "create() -> retval\n."},
| 79979 | {"getCrossSegmentationThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getCrossSegmentationThreshold, 0), "getCrossSegmentationThreshold() -> retval\n."}, |  | 79931 | {"getCrossSegmentationThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getCrossSegmentationThreshold, 0), "getCrossSegmentationThreshold() -> retval\n."},
| 79980 | {"getGlobalMotionRansacThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getGlobalMotionRansacThreshold, 0), "getGlobalMotionRansacThreshold() -> retval\n."}, |  | 79932 | {"getGlobalMotionRansacThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getGlobalMotionRansacThreshold, 0), "getGlobalMotionRansacThreshold() -> retval\n."},
| 79981 | {"getLargeWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getLargeWinSize, 0), "getLargeWinSize() -> retval\n."}, |  | 79933 | {"getLargeWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getLargeWinSize, 0), "getLargeWinSize() -> retval\n."},
| 79982 | {"getMaxIteration", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxIteration, 0), "getMaxIteration() -> retval\n."}, |  | 79934 | {"getMaxIteration", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxIteration, 0), "getMaxIteration() -> retval\n."},
| 79983 | {"getMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxLevel, 0), "getMaxLevel() -> retval\n."}, |  | 79935 | {"getMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMaxLevel, 0), "getMaxLevel() -> retval\n."},
| 79984 | {"getMinEigenValue", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMinEigenValue, 0), "getMinEigenValue() -> retval\n."}, |  | 79936 | {"getMinEigenValue", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getMinEigenValue, 0), "getMinEigenValue() -> retval\n."},
| 79985 | {"getNormSigma0", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma0, 0), "getNormSigma0() -> retval\n."}, |  | 79937 | {"getNormSigma0", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma0, 0), "getNormSigma0() -> retval\n."},
| 79986 | {"getNormSigma1", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma1, 0), "getNormSigma1() -> retval\n."}, |  | 79938 | {"getNormSigma1", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getNormSigma1, 0), "getNormSigma1() -> retval\n."},
| 79987 | {"getSmallWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSmallWinSize, 0), "getSmallWinSize() -> retval\n."}, |  | 79939 | {"getSmallWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSmallWinSize, 0), "getSmallWinSize() -> retval\n."},
| 79988 | {"getSolverType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSolverType, 0), "getSolverType() -> retval\n."}, |  | 79940 | {"getSolverType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSolverType, 0), "getSolverType() -> retval\n."},
| 79989 | {"getSupportRegionType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSupportRegionType, 0), "getSupportRegionType() -> retval\n."}, |  | 79941 | {"getSupportRegionType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getSupportRegionType, 0), "getSupportRegionType() -> retval\n."},
| 79990 | {"getUseGlobalMotionPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseGlobalMotionPrior, 0), "getUseGlobalMotionPrior() -> retval\n."}, |  | 79942 | {"getUseGlobalMotionPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseGlobalMotionPrior, 0), "getUseGlobalMotionPrior() -> retval\n."},
| 79991 | {"getUseIlluminationModel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseIlluminationModel, 0), "getUseIlluminationModel() -> retval\n."}, |  | 79943 | {"getUseIlluminationModel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseIlluminationModel, 0), "getUseIlluminationModel() -> retval\n."},
| 79992 | {"getUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseInitialFlow, 0), "getUseInitialFlow() -> retval\n."}, |  | 79944 | {"getUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_getUseInitialFlow, 0), "getUseInitialFlow() -> retval\n."},
| 79993 | {"setCrossSegmentationThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setCrossSegmentationThreshold, 0), "setCrossSegmentationThreshold(val) -> None\n."}, |  | 79945 | {"setCrossSegmentationThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setCrossSegmentationThreshold, 0), "setCrossSegmentationThreshold(val) -> None\n."},
| 79994 | {"setGlobalMotionRansacThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setGlobalMotionRansacThreshold, 0), "setGlobalMotionRansacThreshold(val) -> None\n."}, |  | 79946 | {"setGlobalMotionRansacThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setGlobalMotionRansacThreshold, 0), "setGlobalMotionRansacThreshold(val) -> None\n."},
| 79995 | {"setLargeWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setLargeWinSize, 0), "setLargeWinSize(val) -> None\n."}, |  | 79947 | {"setLargeWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setLargeWinSize, 0), "setLargeWinSize(val) -> None\n."},
| 79996 | {"setMaxIteration", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxIteration, 0), "setMaxIteration(val) -> None\n."}, |  | 79948 | {"setMaxIteration", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxIteration, 0), "setMaxIteration(val) -> None\n."},
| 79997 | {"setMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxLevel, 0), "setMaxLevel(val) -> None\n."}, |  | 79949 | {"setMaxLevel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMaxLevel, 0), "setMaxLevel(val) -> None\n."},
| 79998 | {"setMinEigenValue", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMinEigenValue, 0), "setMinEigenValue(val) -> None\n."}, |  | 79950 | {"setMinEigenValue", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setMinEigenValue, 0), "setMinEigenValue(val) -> None\n."},
| 79999 | {"setNormSigma0", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma0, 0), "setNormSigma0(val) -> None\n."}, |  | 79951 | {"setNormSigma0", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma0, 0), "setNormSigma0(val) -> None\n."},
| 80000 | {"setNormSigma1", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma1, 0), "setNormSigma1(val) -> None\n."}, |  | 79952 | {"setNormSigma1", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setNormSigma1, 0), "setNormSigma1(val) -> None\n."},
| 80001 | {"setSmallWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSmallWinSize, 0), "setSmallWinSize(val) -> None\n."}, |  | 79953 | {"setSmallWinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSmallWinSize, 0), "setSmallWinSize(val) -> None\n."},
| 80002 | {"setSolverType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSolverType, 0), "setSolverType(val) -> None\n."}, |  | 79954 | {"setSolverType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSolverType, 0), "setSolverType(val) -> None\n."},
| 80003 | {"setSupportRegionType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSupportRegionType, 0), "setSupportRegionType(val) -> None\n."}, |  | 79955 | {"setSupportRegionType", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setSupportRegionType, 0), "setSupportRegionType(val) -> None\n."},
| 80004 | {"setUseGlobalMotionPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseGlobalMotionPrior, 0), "setUseGlobalMotionPrior(val) -> None\n."}, |  | 79956 | {"setUseGlobalMotionPrior", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseGlobalMotionPrior, 0), "setUseGlobalMotionPrior(val) -> None\n."},
| 80005 | {"setUseIlluminationModel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseIlluminationModel, 0), "setUseIlluminationModel(val) -> None\n."}, |  | 79957 | {"setUseIlluminationModel", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseIlluminationModel, 0), "setUseIlluminationModel(val) -> None\n."},
| 80006 | {"setUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseInitialFlow, 0), "setUseInitialFlow(val) -> None\n."}, |  | 79958 | {"setUseInitialFlow", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseInitialFlow, 0), "setUseInitialFlow(val) -> None\n."},
| 80007 | {"setUseMEstimator", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseMEstimator, 0), "setUseMEstimator(val) -> None\n. Enables M-estimator by setting sigma parameters to (3.2, 7.0). Disabling M-estimator can reduce\n. * runtime, while enabling can improve the accuracy.\n. * @param val If true M-estimator is used. If false least-square estimator is used.\n. * @see setNormSigma0, setNormSigma1"}, |  | 79959 | {"setUseMEstimator", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_RLOFOpticalFlowParameter_setUseMEstimator, 0), "setUseMEstimator(val) -> None\n. Enables M-estimator by setting sigma parameters to (3.2, 7.0). Disabling M-estimator can reduce\n. * runtime, while enabling can improve the accuracy.\n. * @param val If true M-estimator is used. If false least-square estimator is used.\n. * @see setNormSigma0, setNormSigma1"},
| 80008 |  |  | 79960 |
| 80009 | {NULL, NULL} |  | 79961 | {NULL, NULL}
| 80010 | }; |  | 79962 | };
| 80011 |  |  | 79963 |
| 80012 | // Converter (optflow_RLOFOpticalFlowParameter) |  | 79964 | // Converter (optflow_RLOFOpticalFlowParameter)
| 80013 |  |  | 79965 |
| 80014 | template<> |  | 79966 | template<>
| 80015 | struct PyOpenCV_Converter< Ptr<cv::optflow::RLOFOpticalFlowParameter> > |  | 79967 | struct PyOpenCV_Converter< Ptr<cv::optflow::RLOFOpticalFlowParameter> >
| 80016 | { |  | 79968 | {
| 80017 | static PyObject* from(const Ptr<cv::optflow::RLOFOpticalFlowParameter>& r) |  | 79969 | static PyObject* from(const Ptr<cv::optflow::RLOFOpticalFlowParameter>& r)
| 80018 | { |  | 79970 | {
| 80019 | return pyopencv_optflow_RLOFOpticalFlowParameter_Instance(r); |  | 79971 | return pyopencv_optflow_RLOFOpticalFlowParameter_Instance(r);
| 80020 | } |  | 79972 | }
| 80021 | static bool to(PyObject* src, Ptr<cv::optflow::RLOFOpticalFlowParameter>& dst, const ArgInfo& info) |  | 79973 | static bool to(PyObject* src, Ptr<cv::optflow::RLOFOpticalFlowParameter>& dst, const ArgInfo& info)
| 80022 | { |  | 79974 | {
| 80023 | if(!src || src == Py_None) |  | 79975 | if(!src || src == Py_None)
| 80024 | return true; |  | 79976 | return true;
| 80025 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * dst_; |  | 79977 | Ptr<cv::optflow::RLOFOpticalFlowParameter> * dst_;
| 80026 | if (pyopencv_optflow_RLOFOpticalFlowParameter_getp(src, dst_)) |  | 79978 | if (pyopencv_optflow_RLOFOpticalFlowParameter_getp(src, dst_))
| 80027 | { |  | 79979 | {
| 80028 | dst = *dst_; |  | 79980 | dst = *dst_;
| 80029 | return true; |  | 79981 | return true;
| 80030 | } |  | 79982 | }
| 80031 |  |  | 79983 |
| 80032 | failmsg("Expected Ptr<cv::optflow::RLOFOpticalFlowParameter> for argument '%s'", info.name); |  | 79984 | failmsg("Expected Ptr<cv::optflow::RLOFOpticalFlowParameter> for argument '%s'", info.name);
| 80033 | return false; |  | 79985 | return false;
| 80034 | } |  | 79986 | }
| 80035 | }; |  | 79987 | };
| 80036 |  |  | 79988 |
| 80037 | //================================================================================ |  | 79989 | //================================================================================
| 80038 | // optflow_SparseRLOFOpticalFlow (Generic) |  | 79990 | // optflow_SparseRLOFOpticalFlow (Generic)
| 80039 | //================================================================================ |  | 79991 | //================================================================================
| 80040 |  |  | 79992 |
| 80041 | // GetSet (optflow_SparseRLOFOpticalFlow) |  | 79993 | // GetSet (optflow_SparseRLOFOpticalFlow)
| 80042 |  |  | 79994 |
| 80043 |  |  | 79995 |
| 80044 |  |  | 79996 |
| 80045 | // Methods (optflow_SparseRLOFOpticalFlow) |  | 79997 | // Methods (optflow_SparseRLOFOpticalFlow)
| 80046 |  |  | 79998 |
| 80047 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 79999 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 80048 | { |  | 80000 | {
| 80049 | using namespace cv::optflow; |  | 80001 | using namespace cv::optflow;
| 80050 |  |  | 80002 |
| 80051 | PyObject* pyobj_rlofParam = NULL; |  | 80003 | PyObject* pyobj_rlofParam = NULL;
| 80052 | Ptr<RLOFOpticalFlowParameter> rlofParam; |  | 80004 | Ptr<RLOFOpticalFlowParameter> rlofParam;
| 80053 | PyObject* pyobj_forwardBackwardThreshold = NULL; |  | 80005 | PyObject* pyobj_forwardBackwardThreshold = NULL;
| 80054 | float forwardBackwardThreshold=1.f; |  | 80006 | float forwardBackwardThreshold=1.f;
| 80055 | Ptr<SparseRLOFOpticalFlow> retval; |  | 80007 | Ptr<SparseRLOFOpticalFlow> retval;
| 80056 |  |  | 80008 |
| 80057 | const char* keywords[] = { "rlofParam", "forwardBackwardThreshold", NULL }; |  | 80009 | const char* keywords[] = { "rlofParam", "forwardBackwardThreshold", NULL };
| 80058 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:optflow_SparseRLOFOpticalFlow.create", (char**)keywords, &pyobj_rlofParam, &pyobj_forwardBackwardThreshold) && |  | 80010 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OO:optflow_SparseRLOFOpticalFlow.create", (char**)keywords, &pyobj_rlofParam, &pyobj_forwardBackwardThreshold) &&
| 80059 | pyopencv_to_safe(pyobj_rlofParam, rlofParam, ArgInfo("rlofParam", 0)) && |  | 80011 | pyopencv_to_safe(pyobj_rlofParam, rlofParam, ArgInfo("rlofParam", 0)) &&
| 80060 | pyopencv_to_safe(pyobj_forwardBackwardThreshold, forwardBackwardThreshold, ArgInfo("forwardBackwardThreshold", 0)) ) |  | 80012 | pyopencv_to_safe(pyobj_forwardBackwardThreshold, forwardBackwardThreshold, ArgInfo("forwardBackwardThreshold", 0)) )
| 80061 | { |  | 80013 | {
| 80062 | ERRWRAP2(retval = cv::optflow::SparseRLOFOpticalFlow::create(rlofParam, forwardBackwardThreshold)); |  | 80014 | ERRWRAP2(retval = cv::optflow::SparseRLOFOpticalFlow::create(rlofParam, forwardBackwardThreshold));
| 80063 | return pyopencv_from(retval); |  | 80015 | return pyopencv_from(retval);
| 80064 | } |  | 80016 | }
| 80065 |  |  | 80017 |
| 80066 | return NULL; |  | 80018 | return NULL;
| 80067 | } |  | 80019 | }
| 80068 |  |  | 80020 |
| 80069 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80021 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw)
| 80070 | { |  | 80022 | {
| 80071 | using namespace cv::optflow; |  | 80023 | using namespace cv::optflow;
| 80072 |  |  | 80024 |
| 80073 |  |  | 80025 |
| 80074 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0; |  | 80026 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0;
| 80075 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1)) |  | 80027 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1))
| 80076 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)"); |  | 80028 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)");
| 80077 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1); |  | 80029 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1);
| 80078 | float retval; |  | 80030 | float retval;
| 80079 |  |  | 80031 |
| 80080 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 80032 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 80081 | { |  | 80033 | {
| 80082 | ERRWRAP2(retval = _self_->getForwardBackward()); |  | 80034 | ERRWRAP2(retval = _self_->getForwardBackward());
| 80083 | return pyopencv_from(retval); |  | 80035 | return pyopencv_from(retval);
| 80084 | } |  | 80036 | }
| 80085 |  |  | 80037 |
| 80086 | return NULL; |  | 80038 | return NULL;
| 80087 | } |  | 80039 | }
| 80088 |  |  | 80040 |
| 80089 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80041 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw)
| 80090 | { |  | 80042 | {
| 80091 | using namespace cv::optflow; |  | 80043 | using namespace cv::optflow;
| 80092 |  |  | 80044 |
| 80093 |  |  | 80045 |
| 80094 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0; |  | 80046 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0;
| 80095 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1)) |  | 80047 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1))
| 80096 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)"); |  | 80048 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)");
| 80097 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1); |  | 80049 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1);
| 80098 | Ptr<RLOFOpticalFlowParameter> retval; |  | 80050 | Ptr<RLOFOpticalFlowParameter> retval;
| 80099 |  |  | 80051 |
| 80100 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 80052 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 80101 | { |  | 80053 | {
| 80102 | ERRWRAP2(retval = _self_->getRLOFOpticalFlowParameter()); |  | 80054 | ERRWRAP2(retval = _self_->getRLOFOpticalFlowParameter());
| 80103 | return pyopencv_from(retval); |  | 80055 | return pyopencv_from(retval);
| 80104 | } |  | 80056 | }
| 80105 |  |  | 80057 |
| 80106 | return NULL; |  | 80058 | return NULL;
| 80107 | } |  | 80059 | }
| 80108 |  |  | 80060 |
| 80109 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80061 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setForwardBackward(PyObject* self, PyObject* py_args, PyObject* kw)
| 80110 | { |  | 80062 | {
| 80111 | using namespace cv::optflow; |  | 80063 | using namespace cv::optflow;
| 80112 |  |  | 80064 |
| 80113 |  |  | 80065 |
| 80114 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0; |  | 80066 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0;
| 80115 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1)) |  | 80067 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1))
| 80116 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)"); |  | 80068 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)");
| 80117 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1); |  | 80069 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1);
| 80118 | PyObject* pyobj_val = NULL; |  | 80070 | PyObject* pyobj_val = NULL;
| 80119 | float val=0.f; |  | 80071 | float val=0.f;
| 80120 |  |  | 80072 |
| 80121 | const char* keywords[] = { "val", NULL }; |  | 80073 | const char* keywords[] = { "val", NULL };
| 80122 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_SparseRLOFOpticalFlow.setForwardBackward", (char**)keywords, &pyobj_val) && |  | 80074 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_SparseRLOFOpticalFlow.setForwardBackward", (char**)keywords, &pyobj_val) &&
| 80123 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 80075 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 80124 | { |  | 80076 | {
| 80125 | ERRWRAP2(_self_->setForwardBackward(val)); |  | 80077 | ERRWRAP2(_self_->setForwardBackward(val));
| 80126 | Py_RETURN_NONE; |  | 80078 | Py_RETURN_NONE;
| 80127 | } |  | 80079 | }
| 80128 |  |  | 80080 |
| 80129 | return NULL; |  | 80081 | return NULL;
| 80130 | } |  | 80082 | }
| 80131 |  |  | 80083 |
| 80132 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80084 | static PyObject* pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setRLOFOpticalFlowParameter(PyObject* self, PyObject* py_args, PyObject* kw)
| 80133 | { |  | 80085 | {
| 80134 | using namespace cv::optflow; |  | 80086 | using namespace cv::optflow;
| 80135 |  |  | 80087 |
| 80136 |  |  | 80088 |
| 80137 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0; |  | 80089 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * self1 = 0;
| 80138 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1)) |  | 80090 | if (!pyopencv_optflow_SparseRLOFOpticalFlow_getp(self, self1))
| 80139 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)"); |  | 80091 | return failmsgp("Incorrect type of self (must be 'optflow_SparseRLOFOpticalFlow' or its derivative)");
| 80140 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1); |  | 80092 | Ptr<cv::optflow::SparseRLOFOpticalFlow> _self_ = *(self1);
| 80141 | PyObject* pyobj_val = NULL; |  | 80093 | PyObject* pyobj_val = NULL;
| 80142 | Ptr<RLOFOpticalFlowParameter> val; |  | 80094 | Ptr<RLOFOpticalFlowParameter> val;
| 80143 |  |  | 80095 |
| 80144 | const char* keywords[] = { "val", NULL }; |  | 80096 | const char* keywords[] = { "val", NULL };
| 80145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_SparseRLOFOpticalFlow.setRLOFOpticalFlowParameter", (char**)keywords, &pyobj_val) && |  | 80097 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:optflow_SparseRLOFOpticalFlow.setRLOFOpticalFlowParameter", (char**)keywords, &pyobj_val) &&
| 80146 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 80098 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 80147 | { |  | 80099 | {
| 80148 | ERRWRAP2(_self_->setRLOFOpticalFlowParameter(val)); |  | 80100 | ERRWRAP2(_self_->setRLOFOpticalFlowParameter(val));
| 80149 | Py_RETURN_NONE; |  | 80101 | Py_RETURN_NONE;
| 80150 | } |  | 80102 | }
| 80151 |  |  | 80103 |
| 80152 | return NULL; |  | 80104 | return NULL;
| 80153 | } |  | 80105 | }
| 80154 |  |  | 80106 |
| 80155 |  |  | 80107 |
| 80156 |  |  | 80108 |
| 80157 | // Tables (optflow_SparseRLOFOpticalFlow) |  | 80109 | // Tables (optflow_SparseRLOFOpticalFlow)
| 80158 |  |  | 80110 |
| 80159 | static PyGetSetDef pyopencv_optflow_SparseRLOFOpticalFlow_getseters[] = |  | 80111 | static PyGetSetDef pyopencv_optflow_SparseRLOFOpticalFlow_getseters[] =
| 80160 | { |  | 80112 | {
| 80161 | {NULL} /* Sentinel */ |  | 80113 | {NULL} /* Sentinel */
| 80162 | }; |  | 80114 | };
| 80163 |  |  | 80115 |
| 80164 | static PyMethodDef pyopencv_optflow_SparseRLOFOpticalFlow_methods[] = |  | 80116 | static PyMethodDef pyopencv_optflow_SparseRLOFOpticalFlow_methods[] =
| 80165 | { |  | 80117 | {
| 80166 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_create_static, METH_STATIC), "create([, rlofParam[, forwardBackwardThreshold]]) -> retval\n. * @param rlofParam see setRLOFOpticalFlowParameter\n. * @param forwardBackwardThreshold see setForwardBackward"}, |  | 80118 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_create_static, METH_STATIC), "create([, rlofParam[, forwardBackwardThreshold]]) -> retval\n. * @param rlofParam see setRLOFOpticalFlowParameter\n. * @param forwardBackwardThreshold see setForwardBackward"},
| 80167 | {"getForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getForwardBackward, 0), "getForwardBackward() -> retval\n. @copybrief setForwardBackward\n. * @see setForwardBackward"}, |  | 80119 | {"getForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getForwardBackward, 0), "getForwardBackward() -> retval\n. @copybrief setForwardBackward\n. * @see setForwardBackward"},
| 80168 | {"getRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getRLOFOpticalFlowParameter, 0), "getRLOFOpticalFlowParameter() -> retval\n. @copybrief setRLOFOpticalFlowParameter\n. * @see setRLOFOpticalFlowParameter"}, |  | 80120 | {"getRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_getRLOFOpticalFlowParameter, 0), "getRLOFOpticalFlowParameter() -> retval\n. @copybrief setRLOFOpticalFlowParameter\n. * @see setRLOFOpticalFlowParameter"},
| 80169 | {"setForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setForwardBackward, 0), "setForwardBackward(val) -> None\n. For each feature point a motion vector \\f$ d_{I0,I1}(\\mathbf{x}) \\f$ is computed.\n. * If the forward backward error \\f[ EP_{FB} = || d_{I0,I1} + d_{I1,I0} || \\f]\n. * is larger than threshold given by this function then the status will not be used by the following\n. * vector field interpolation. \\f$ d_{I1,I0} \\f$ denotes the backward flow. Note, the forward backward test\n. * will only be applied if the threshold > 0. This may results into a doubled runtime for the motion estimation.\n. * @see setForwardBackward"}, |  | 80121 | {"setForwardBackward", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setForwardBackward, 0), "setForwardBackward(val) -> None\n. For each feature point a motion vector \\f$ d_{I0,I1}(\\mathbf{x}) \\f$ is computed.\n. * If the forward backward error \\f[ EP_{FB} = || d_{I0,I1} + d_{I1,I0} || \\f]\n. * is larger than threshold given by this function then the status will not be used by the following\n. * vector field interpolation. \\f$ d_{I1,I0} \\f$ denotes the backward flow. Note, the forward backward test\n. * will only be applied if the threshold > 0. This may results into a doubled runtime for the motion estimation.\n. * @see setForwardBackward"},
| 80170 | {"setRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setRLOFOpticalFlowParameter, 0), "setRLOFOpticalFlowParameter(val) -> None\n. @copydoc DenseRLOFOpticalFlow::setRLOFOpticalFlowParameter"}, |  | 80122 | {"setRLOFOpticalFlowParameter", CV_PY_FN_WITH_KW_(pyopencv_cv_optflow_optflow_SparseRLOFOpticalFlow_setRLOFOpticalFlowParameter, 0), "setRLOFOpticalFlowParameter(val) -> None\n. @copydoc DenseRLOFOpticalFlow::setRLOFOpticalFlowParameter"},
| 80171 |  |  | 80123 |
| 80172 | {NULL, NULL} |  | 80124 | {NULL, NULL}
| 80173 | }; |  | 80125 | };
| 80174 |  |  | 80126 |
| 80175 | // Converter (optflow_SparseRLOFOpticalFlow) |  | 80127 | // Converter (optflow_SparseRLOFOpticalFlow)
| 80176 |  |  | 80128 |
| 80177 | template<> |  | 80129 | template<>
| 80178 | struct PyOpenCV_Converter< Ptr<cv::optflow::SparseRLOFOpticalFlow> > |  | 80130 | struct PyOpenCV_Converter< Ptr<cv::optflow::SparseRLOFOpticalFlow> >
| 80179 | { |  | 80131 | {
| 80180 | static PyObject* from(const Ptr<cv::optflow::SparseRLOFOpticalFlow>& r) |  | 80132 | static PyObject* from(const Ptr<cv::optflow::SparseRLOFOpticalFlow>& r)
| 80181 | { |  | 80133 | {
| 80182 | return pyopencv_optflow_SparseRLOFOpticalFlow_Instance(r); |  | 80134 | return pyopencv_optflow_SparseRLOFOpticalFlow_Instance(r);
| 80183 | } |  | 80135 | }
| 80184 | static bool to(PyObject* src, Ptr<cv::optflow::SparseRLOFOpticalFlow>& dst, const ArgInfo& info) |  | 80136 | static bool to(PyObject* src, Ptr<cv::optflow::SparseRLOFOpticalFlow>& dst, const ArgInfo& info)
| 80185 | { |  | 80137 | {
| 80186 | if(!src || src == Py_None) |  | 80138 | if(!src || src == Py_None)
| 80187 | return true; |  | 80139 | return true;
| 80188 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * dst_; |  | 80140 | Ptr<cv::optflow::SparseRLOFOpticalFlow> * dst_;
| 80189 | if (pyopencv_optflow_SparseRLOFOpticalFlow_getp(src, dst_)) |  | 80141 | if (pyopencv_optflow_SparseRLOFOpticalFlow_getp(src, dst_))
| 80190 | { |  | 80142 | {
| 80191 | dst = *dst_; |  | 80143 | dst = *dst_;
| 80192 | return true; |  | 80144 | return true;
| 80193 | } |  | 80145 | }
| 80194 |  |  | 80146 |
| 80195 | failmsg("Expected Ptr<cv::optflow::SparseRLOFOpticalFlow> for argument '%s'", info.name); |  | 80147 | failmsg("Expected Ptr<cv::optflow::SparseRLOFOpticalFlow> for argument '%s'", info.name);
| 80196 | return false; |  | 80148 | return false;
| 80197 | } |  | 80149 | }
| 80198 | }; |  | 80150 | };
| 80199 |  |  | 80151 |
| 80200 | //================================================================================ |  | 80152 | //================================================================================
| 80201 | // phase_unwrapping_HistogramPhaseUnwrapping (Generic) |  | 80153 | // phase_unwrapping_HistogramPhaseUnwrapping (Generic)
| 80202 | //================================================================================ |  | 80154 | //================================================================================
| 80203 |  |  | 80155 |
| 80204 | // GetSet (phase_unwrapping_HistogramPhaseUnwrapping) |  | 80156 | // GetSet (phase_unwrapping_HistogramPhaseUnwrapping)
| 80205 |  |  | 80157 |
| 80206 |  |  | 80158 |
| 80207 |  |  | 80159 |
| 80208 | // Methods (phase_unwrapping_HistogramPhaseUnwrapping) |  | 80160 | // Methods (phase_unwrapping_HistogramPhaseUnwrapping)
| 80209 |  |  | 80161 |
| 80210 | static PyObject* pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80162 | static PyObject* pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 80211 | { |  | 80163 | {
| 80212 | using namespace cv::phase_unwrapping; |  | 80164 | using namespace cv::phase_unwrapping;
| 80213 |  |  | 80165 |
| 80214 | PyObject* pyobj_parameters = NULL; |  | 80166 | PyObject* pyobj_parameters = NULL;
| 80215 | HistogramPhaseUnwrapping_Params parameters=HistogramPhaseUnwrapping::Params(); |  | 80167 | HistogramPhaseUnwrapping_Params parameters=HistogramPhaseUnwrapping::Params();
| 80216 | Ptr<HistogramPhaseUnwrapping> retval; |  | 80168 | Ptr<HistogramPhaseUnwrapping> retval;
| 80217 |  |  | 80169 |
| 80218 | const char* keywords[] = { "parameters", NULL }; |  | 80170 | const char* keywords[] = { "parameters", NULL };
| 80219 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:phase_unwrapping_HistogramPhaseUnwrapping.create", (char**)keywords, &pyobj_parameters) && |  | 80171 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:phase_unwrapping_HistogramPhaseUnwrapping.create", (char**)keywords, &pyobj_parameters) &&
| 80220 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) ) |  | 80172 | pyopencv_to_safe(pyobj_parameters, parameters, ArgInfo("parameters", 0)) )
| 80221 | { |  | 80173 | {
| 80222 | ERRWRAP2(retval = cv::phase_unwrapping::HistogramPhaseUnwrapping::create(parameters)); |  | 80174 | ERRWRAP2(retval = cv::phase_unwrapping::HistogramPhaseUnwrapping::create(parameters));
| 80223 | return pyopencv_from(retval); |  | 80175 | return pyopencv_from(retval);
| 80224 | } |  | 80176 | }
| 80225 |  |  | 80177 |
| 80226 | return NULL; |  | 80178 | return NULL;
| 80227 | } |  | 80179 | }
| 80228 |  |  | 80180 |
| 80229 | static PyObject* pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_getInverseReliabilityMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80181 | static PyObject* pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_getInverseReliabilityMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 80230 | { |  | 80182 | {
| 80231 | using namespace cv::phase_unwrapping; |  | 80183 | using namespace cv::phase_unwrapping;
| 80232 |  |  | 80184 |
| 80233 |  |  | 80185 |
| 80234 | Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> * self1 = 0; |  | 80186 | Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> * self1 = 0;
| 80235 | if (!pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_getp(self, self1)) |  | 80187 | if (!pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_getp(self, self1))
| 80236 | return failmsgp("Incorrect type of self (must be 'phase_unwrapping_HistogramPhaseUnwrapping' or its derivative)"); |  | 80188 | return failmsgp("Incorrect type of self (must be 'phase_unwrapping_HistogramPhaseUnwrapping' or its derivative)");
| 80237 | Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> _self_ = *(self1); |  | 80189 | Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> _self_ = *(self1);
| 80238 | pyPrepareArgumentConversionErrorsStorage(2); |  | 80190 | pyPrepareArgumentConversionErrorsStorage(2);
| 80239 |  |  | 80191 |
| 80240 | { |  | 80192 | {
| 80241 | PyObject* pyobj_reliabilityMap = NULL; |  | 80193 | PyObject* pyobj_reliabilityMap = NULL;
| 80242 | Mat reliabilityMap; |  | 80194 | Mat reliabilityMap;
| 80243 |  |  | 80195 |
| 80244 | const char* keywords[] = { "reliabilityMap", NULL }; |  | 80196 | const char* keywords[] = { "reliabilityMap", NULL };
| 80245 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:phase_unwrapping_HistogramPhaseUnwrapping.getInverseReliabilityMap", (char**)keywords, &pyobj_reliabilityMap) && |  | 80197 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:phase_unwrapping_HistogramPhaseUnwrapping.getInverseReliabilityMap", (char**)keywords, &pyobj_reliabilityMap) &&
| 80246 | pyopencv_to_safe(pyobj_reliabilityMap, reliabilityMap, ArgInfo("reliabilityMap", 1)) ) |  | 80198 | pyopencv_to_safe(pyobj_reliabilityMap, reliabilityMap, ArgInfo("reliabilityMap", 1)) )
| 80247 | { |  | 80199 | {
| 80248 | ERRWRAP2(_self_->getInverseReliabilityMap(reliabilityMap)); |  | 80200 | ERRWRAP2(_self_->getInverseReliabilityMap(reliabilityMap));
| 80249 | return pyopencv_from(reliabilityMap); |  | 80201 | return pyopencv_from(reliabilityMap);
| 80250 | } |  | 80202 | }
| 80251 |  |  | 80203 |
| 80252 |  |  | 80204 |
| 80253 | pyPopulateArgumentConversionErrors(); |  | 80205 | pyPopulateArgumentConversionErrors();
| 80254 | } |  | 80206 | }
| 80255 |  |  | 80207 |
| 80256 |  |  | 80208 |
| 80257 | { |  | 80209 | {
| 80258 | PyObject* pyobj_reliabilityMap = NULL; |  | 80210 | PyObject* pyobj_reliabilityMap = NULL;
| 80259 | UMat reliabilityMap; |  | 80211 | UMat reliabilityMap;
| 80260 |  |  | 80212 |
| 80261 | const char* keywords[] = { "reliabilityMap", NULL }; |  | 80213 | const char* keywords[] = { "reliabilityMap", NULL };
| 80262 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:phase_unwrapping_HistogramPhaseUnwrapping.getInverseReliabilityMap", (char**)keywords, &pyobj_reliabilityMap) && |  | 80214 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:phase_unwrapping_HistogramPhaseUnwrapping.getInverseReliabilityMap", (char**)keywords, &pyobj_reliabilityMap) &&
| 80263 | pyopencv_to_safe(pyobj_reliabilityMap, reliabilityMap, ArgInfo("reliabilityMap", 1)) ) |  | 80215 | pyopencv_to_safe(pyobj_reliabilityMap, reliabilityMap, ArgInfo("reliabilityMap", 1)) )
| 80264 | { |  | 80216 | {
| 80265 | ERRWRAP2(_self_->getInverseReliabilityMap(reliabilityMap)); |  | 80217 | ERRWRAP2(_self_->getInverseReliabilityMap(reliabilityMap));
| 80266 | return pyopencv_from(reliabilityMap); |  | 80218 | return pyopencv_from(reliabilityMap);
| 80267 | } |  | 80219 | }
| 80268 |  |  | 80220 |
| 80269 |  |  | 80221 |
| 80270 | pyPopulateArgumentConversionErrors(); |  | 80222 | pyPopulateArgumentConversionErrors();
| 80271 | } |  | 80223 | }
| 80272 | pyRaiseCVOverloadException("getInverseReliabilityMap"); |  | 80224 | pyRaiseCVOverloadException("getInverseReliabilityMap");
| 80273 |  |  | 80225 |
| 80274 | return NULL; |  | 80226 | return NULL;
| 80275 | } |  | 80227 | }
| 80276 |  |  | 80228 |
| 80277 |  |  | 80229 |
| 80278 |  |  | 80230 |
| 80279 | // Tables (phase_unwrapping_HistogramPhaseUnwrapping) |  | 80231 | // Tables (phase_unwrapping_HistogramPhaseUnwrapping)
| 80280 |  |  | 80232 |
| 80281 | static PyGetSetDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_getseters[] = |  | 80233 | static PyGetSetDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_getseters[] =
| 80282 | { |  | 80234 | {
| 80283 | {NULL} /* Sentinel */ |  | 80235 | {NULL} /* Sentinel */
| 80284 | }; |  | 80236 | };
| 80285 |  |  | 80237 |
| 80286 | static PyMethodDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_methods[] = |  | 80238 | static PyMethodDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_methods[] =
| 80287 | { |  | 80239 | {
| 80288 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_create_static, METH_STATIC), "create([, parameters]) -> retval\n. * @brief Constructor\n. \n. * @param parameters HistogramPhaseUnwrapping parameters HistogramPhaseUnwrapping::Params: width,height of the phase map and histogram characteristics."}, |  | 80240 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_create_static, METH_STATIC), "create([, parameters]) -> retval\n. * @brief Constructor\n. \n. * @param parameters HistogramPhaseUnwrapping parameters HistogramPhaseUnwrapping::Params: width,height of the phase map and histogram characteristics."},
| 80289 | {"getInverseReliabilityMap", CV_PY_FN_WITH_KW_(pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_getInverseReliabilityMap, 0), "getInverseReliabilityMap([, reliabilityMap]) -> reliabilityMap\n. * @brief Get the reliability map computed from the wrapped phase map.\n. \n. * @param reliabilityMap Image where the reliability map is stored."}, |  | 80241 | {"getInverseReliabilityMap", CV_PY_FN_WITH_KW_(pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_getInverseReliabilityMap, 0), "getInverseReliabilityMap([, reliabilityMap]) -> reliabilityMap\n. * @brief Get the reliability map computed from the wrapped phase map.\n. \n. * @param reliabilityMap Image where the reliability map is stored."},
| 80290 |  |  | 80242 |
| 80291 | {NULL, NULL} |  | 80243 | {NULL, NULL}
| 80292 | }; |  | 80244 | };
| 80293 |  |  | 80245 |
| 80294 | // Converter (phase_unwrapping_HistogramPhaseUnwrapping) |  | 80246 | // Converter (phase_unwrapping_HistogramPhaseUnwrapping)
| 80295 |  |  | 80247 |
| 80296 | template<> |  | 80248 | template<>
| 80297 | struct PyOpenCV_Converter< Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> > |  | 80249 | struct PyOpenCV_Converter< Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> >
| 80298 | { |  | 80250 | {
| 80299 | static PyObject* from(const Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping>& r) |  | 80251 | static PyObject* from(const Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping>& r)
| 80300 | { |  | 80252 | {
| 80301 | return pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Instance(r); |  | 80253 | return pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Instance(r);
| 80302 | } |  | 80254 | }
| 80303 | static bool to(PyObject* src, Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping>& dst, const ArgInfo& info) |  | 80255 | static bool to(PyObject* src, Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping>& dst, const ArgInfo& info)
| 80304 | { |  | 80256 | {
| 80305 | if(!src || src == Py_None) |  | 80257 | if(!src || src == Py_None)
| 80306 | return true; |  | 80258 | return true;
| 80307 | Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> * dst_; |  | 80259 | Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> * dst_;
| 80308 | if (pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_getp(src, dst_)) |  | 80260 | if (pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_getp(src, dst_))
| 80309 | { |  | 80261 | {
| 80310 | dst = *dst_; |  | 80262 | dst = *dst_;
| 80311 | return true; |  | 80263 | return true;
| 80312 | } |  | 80264 | }
| 80313 |  |  | 80265 |
| 80314 | failmsg("Expected Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> for argument '%s'", info.name); |  | 80266 | failmsg("Expected Ptr<cv::phase_unwrapping::HistogramPhaseUnwrapping> for argument '%s'", info.name);
| 80315 | return false; |  | 80267 | return false;
| 80316 | } |  | 80268 | }
| 80317 | }; |  | 80269 | };
| 80318 |  |  | 80270 |
| 80319 | //================================================================================ |  | 80271 | //================================================================================
| 80320 | // phase_unwrapping_HistogramPhaseUnwrapping_Params (Generic) |  | 80272 | // phase_unwrapping_HistogramPhaseUnwrapping_Params (Generic)
| 80321 | //================================================================================ |  | 80273 | //================================================================================
| 80322 |  |  | 80274 |
| 80323 | // GetSet (phase_unwrapping_HistogramPhaseUnwrapping_Params) |  | 80275 | // GetSet (phase_unwrapping_HistogramPhaseUnwrapping_Params)
| 80324 |  |  | 80276 |
| 80325 |  |  | 80277 |
| 80326 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_height(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure) |  | 80278 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_height(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure)
| 80327 | { |  | 80279 | {
| 80328 | return pyopencv_from(p->v.height); |  | 80280 | return pyopencv_from(p->v.height);
| 80329 | } |  | 80281 | }
| 80330 |  |  | 80282 |
| 80331 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_height(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure) |  | 80283 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_height(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure)
| 80332 | { |  | 80284 | {
| 80333 | if (!value) |  | 80285 | if (!value)
| 80334 | { |  | 80286 | {
| 80335 | PyErr_SetString(PyExc_TypeError, "Cannot delete the height attribute"); |  | 80287 | PyErr_SetString(PyExc_TypeError, "Cannot delete the height attribute");
| 80336 | return -1; |  | 80288 | return -1;
| 80337 | } |  | 80289 | }
| 80338 | return pyopencv_to_safe(value, p->v.height, ArgInfo("value", 0)) ? 0 : -1; |  | 80290 | return pyopencv_to_safe(value, p->v.height, ArgInfo("value", 0)) ? 0 : -1;
| 80339 | } |  | 80291 | }
| 80340 |  |  | 80292 |
| 80341 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_histThresh(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure) |  | 80293 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_histThresh(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure)
| 80342 | { |  | 80294 | {
| 80343 | return pyopencv_from(p->v.histThresh); |  | 80295 | return pyopencv_from(p->v.histThresh);
| 80344 | } |  | 80296 | }
| 80345 |  |  | 80297 |
| 80346 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_histThresh(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure) |  | 80298 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_histThresh(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure)
| 80347 | { |  | 80299 | {
| 80348 | if (!value) |  | 80300 | if (!value)
| 80349 | { |  | 80301 | {
| 80350 | PyErr_SetString(PyExc_TypeError, "Cannot delete the histThresh attribute"); |  | 80302 | PyErr_SetString(PyExc_TypeError, "Cannot delete the histThresh attribute");
| 80351 | return -1; |  | 80303 | return -1;
| 80352 | } |  | 80304 | }
| 80353 | return pyopencv_to_safe(value, p->v.histThresh, ArgInfo("value", 0)) ? 0 : -1; |  | 80305 | return pyopencv_to_safe(value, p->v.histThresh, ArgInfo("value", 0)) ? 0 : -1;
| 80354 | } |  | 80306 | }
| 80355 |  |  | 80307 |
| 80356 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfLargeBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure) |  | 80308 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfLargeBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure)
| 80357 | { |  | 80309 | {
| 80358 | return pyopencv_from(p->v.nbrOfLargeBins); |  | 80310 | return pyopencv_from(p->v.nbrOfLargeBins);
| 80359 | } |  | 80311 | }
| 80360 |  |  | 80312 |
| 80361 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfLargeBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure) |  | 80313 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfLargeBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure)
| 80362 | { |  | 80314 | {
| 80363 | if (!value) |  | 80315 | if (!value)
| 80364 | { |  | 80316 | {
| 80365 | PyErr_SetString(PyExc_TypeError, "Cannot delete the nbrOfLargeBins attribute"); |  | 80317 | PyErr_SetString(PyExc_TypeError, "Cannot delete the nbrOfLargeBins attribute");
| 80366 | return -1; |  | 80318 | return -1;
| 80367 | } |  | 80319 | }
| 80368 | return pyopencv_to_safe(value, p->v.nbrOfLargeBins, ArgInfo("value", 0)) ? 0 : -1; |  | 80320 | return pyopencv_to_safe(value, p->v.nbrOfLargeBins, ArgInfo("value", 0)) ? 0 : -1;
| 80369 | } |  | 80321 | }
| 80370 |  |  | 80322 |
| 80371 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfSmallBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure) |  | 80323 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfSmallBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure)
| 80372 | { |  | 80324 | {
| 80373 | return pyopencv_from(p->v.nbrOfSmallBins); |  | 80325 | return pyopencv_from(p->v.nbrOfSmallBins);
| 80374 | } |  | 80326 | }
| 80375 |  |  | 80327 |
| 80376 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfSmallBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure) |  | 80328 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfSmallBins(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure)
| 80377 | { |  | 80329 | {
| 80378 | if (!value) |  | 80330 | if (!value)
| 80379 | { |  | 80331 | {
| 80380 | PyErr_SetString(PyExc_TypeError, "Cannot delete the nbrOfSmallBins attribute"); |  | 80332 | PyErr_SetString(PyExc_TypeError, "Cannot delete the nbrOfSmallBins attribute");
| 80381 | return -1; |  | 80333 | return -1;
| 80382 | } |  | 80334 | }
| 80383 | return pyopencv_to_safe(value, p->v.nbrOfSmallBins, ArgInfo("value", 0)) ? 0 : -1; |  | 80335 | return pyopencv_to_safe(value, p->v.nbrOfSmallBins, ArgInfo("value", 0)) ? 0 : -1;
| 80384 | } |  | 80336 | }
| 80385 |  |  | 80337 |
| 80386 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_width(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure) |  | 80338 | static PyObject* pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_width(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, void *closure)
| 80387 | { |  | 80339 | {
| 80388 | return pyopencv_from(p->v.width); |  | 80340 | return pyopencv_from(p->v.width);
| 80389 | } |  | 80341 | }
| 80390 |  |  | 80342 |
| 80391 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_width(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure) |  | 80343 | static int pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_width(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* p, PyObject *value, void *closure)
| 80392 | { |  | 80344 | {
| 80393 | if (!value) |  | 80345 | if (!value)
| 80394 | { |  | 80346 | {
| 80395 | PyErr_SetString(PyExc_TypeError, "Cannot delete the width attribute"); |  | 80347 | PyErr_SetString(PyExc_TypeError, "Cannot delete the width attribute");
| 80396 | return -1; |  | 80348 | return -1;
| 80397 | } |  | 80349 | }
| 80398 | return pyopencv_to_safe(value, p->v.width, ArgInfo("value", 0)) ? 0 : -1; |  | 80350 | return pyopencv_to_safe(value, p->v.width, ArgInfo("value", 0)) ? 0 : -1;
| 80399 | } |  | 80351 | }
| 80400 |  |  | 80352 |
| 80401 |  |  | 80353 |
| 80402 | // Methods (phase_unwrapping_HistogramPhaseUnwrapping_Params) |  | 80354 | // Methods (phase_unwrapping_HistogramPhaseUnwrapping_Params)
| 80403 |  |  | 80355 |
| 80404 | static int pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_Params_HistogramPhaseUnwrapping_Params(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* self, PyObject* py_args, PyObject* kw) |  | 80356 | static int pyopencv_cv_phase_unwrapping_phase_unwrapping_HistogramPhaseUnwrapping_Params_HistogramPhaseUnwrapping_Params(pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_t* self, PyObject* py_args, PyObject* kw)
| 80405 | { |  | 80357 | {
| 80406 | using namespace cv::phase_unwrapping; |  | 80358 | using namespace cv::phase_unwrapping;
| 80407 |  |  | 80359 |
| 80408 |  |  | 80360 |
| 80409 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 80361 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 80410 | { |  | 80362 | {
| 80411 | if(self) ERRWRAP2(new (&(self->v)) cv::phase_unwrapping::HistogramPhaseUnwrapping::Params()); |  | 80363 | if(self) ERRWRAP2(new (&(self->v)) cv::phase_unwrapping::HistogramPhaseUnwrapping::Params());
| 80412 | return 0; |  | 80364 | return 0;
| 80413 | } |  | 80365 | }
| 80414 |  |  | 80366 |
| 80415 | return -1; |  | 80367 | return -1;
| 80416 | } |  | 80368 | }
| 80417 |  |  | 80369 |
| 80418 |  |  | 80370 |
| 80419 |  |  | 80371 |
| 80420 | // Tables (phase_unwrapping_HistogramPhaseUnwrapping_Params) |  | 80372 | // Tables (phase_unwrapping_HistogramPhaseUnwrapping_Params)
| 80421 |  |  | 80373 |
| 80422 | static PyGetSetDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_getseters[] = |  | 80374 | static PyGetSetDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_getseters[] =
| 80423 | { |  | 80375 | {
| 80424 | {(char*)"height", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_height, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_height, (char*)"height", NULL}, |  | 80376 | {(char*)"height", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_height, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_height, (char*)"height", NULL},
| 80425 | {(char*)"histThresh", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_histThresh, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_histThresh, (char*)"histThresh", NULL}, |  | 80377 | {(char*)"histThresh", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_histThresh, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_histThresh, (char*)"histThresh", NULL},
| 80426 | {(char*)"nbrOfLargeBins", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfLargeBins, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfLargeBins, (char*)"nbrOfLargeBins", NULL}, |  | 80378 | {(char*)"nbrOfLargeBins", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfLargeBins, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfLargeBins, (char*)"nbrOfLargeBins", NULL},
| 80427 | {(char*)"nbrOfSmallBins", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfSmallBins, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfSmallBins, (char*)"nbrOfSmallBins", NULL}, |  | 80379 | {(char*)"nbrOfSmallBins", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_nbrOfSmallBins, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_nbrOfSmallBins, (char*)"nbrOfSmallBins", NULL},
| 80428 | {(char*)"width", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_width, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_width, (char*)"width", NULL}, |  | 80380 | {(char*)"width", (getter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_get_width, (setter)pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_set_width, (char*)"width", NULL},
| 80429 | {NULL} /* Sentinel */ |  | 80381 | {NULL} /* Sentinel */
| 80430 | }; |  | 80382 | };
| 80431 |  |  | 80383 |
| 80432 | static PyMethodDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_methods[] = |  | 80384 | static PyMethodDef pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_methods[] =
| 80433 | { |  | 80385 | {
| 80434 |  |  | 80386 |
| 80435 | {NULL, NULL} |  | 80387 | {NULL, NULL}
| 80436 | }; |  | 80388 | };
| 80437 |  |  | 80389 |
| 80438 | // Converter (phase_unwrapping_HistogramPhaseUnwrapping_Params) |  | 80390 | // Converter (phase_unwrapping_HistogramPhaseUnwrapping_Params)
| 80439 |  |  | 80391 |
| 80440 | template<> |  | 80392 | template<>
| 80441 | struct PyOpenCV_Converter< cv::phase_unwrapping::HistogramPhaseUnwrapping::Params > |  | 80393 | struct PyOpenCV_Converter< cv::phase_unwrapping::HistogramPhaseUnwrapping::Params >
| 80442 | { |  | 80394 | {
| 80443 | static PyObject* from(const cv::phase_unwrapping::HistogramPhaseUnwrapping::Params& r) |  | 80395 | static PyObject* from(const cv::phase_unwrapping::HistogramPhaseUnwrapping::Params& r)
| 80444 | { |  | 80396 | {
| 80445 | return pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_Instance(r); |  | 80397 | return pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_Instance(r);
| 80446 | } |  | 80398 | }
| 80447 | static bool to(PyObject* src, cv::phase_unwrapping::HistogramPhaseUnwrapping::Params& dst, const ArgInfo& info) |  | 80399 | static bool to(PyObject* src, cv::phase_unwrapping::HistogramPhaseUnwrapping::Params& dst, const ArgInfo& info)
| 80448 | { |  | 80400 | {
| 80449 | if(!src || src == Py_None) |  | 80401 | if(!src || src == Py_None)
| 80450 | return true; |  | 80402 | return true;
| 80451 | cv::phase_unwrapping::HistogramPhaseUnwrapping::Params * dst_; |  | 80403 | cv::phase_unwrapping::HistogramPhaseUnwrapping::Params * dst_;
| 80452 | if (pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_getp(src, dst_)) |  | 80404 | if (pyopencv_phase_unwrapping_HistogramPhaseUnwrapping_Params_getp(src, dst_))
| 80453 | { |  | 80405 | {
| 80454 | dst = *dst_; |  | 80406 | dst = *dst_;
| 80455 | return true; |  | 80407 | return true;
| 80456 | } |  | 80408 | }
| 80457 |  |  | 80409 |
| 80458 | failmsg("Expected cv::phase_unwrapping::HistogramPhaseUnwrapping::Params for argument '%s'", info.name); |  | 80410 | failmsg("Expected cv::phase_unwrapping::HistogramPhaseUnwrapping::Params for argument '%s'", info.name);
| 80459 | return false; |  | 80411 | return false;
| 80460 | } |  | 80412 | }
| 80461 | }; |  | 80413 | };
| 80462 |  |  | 80414 |
| 80463 | //================================================================================ |  | 80415 | //================================================================================
| 80464 | // phase_unwrapping_PhaseUnwrapping (Generic) |  | 80416 | // phase_unwrapping_PhaseUnwrapping (Generic)
| 80465 | //================================================================================ |  | 80417 | //================================================================================
| 80466 |  |  | 80418 |
| 80467 | // GetSet (phase_unwrapping_PhaseUnwrapping) |  | 80419 | // GetSet (phase_unwrapping_PhaseUnwrapping)
| 80468 |  |  | 80420 |
| 80469 |  |  | 80421 |
| 80470 |  |  | 80422 |
| 80471 | // Methods (phase_unwrapping_PhaseUnwrapping) |  | 80423 | // Methods (phase_unwrapping_PhaseUnwrapping)
| 80472 |  |  | 80424 |
| 80473 | static PyObject* pyopencv_cv_phase_unwrapping_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80425 | static PyObject* pyopencv_cv_phase_unwrapping_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 80474 | { |  | 80426 | {
| 80475 | using namespace cv::phase_unwrapping; |  | 80427 | using namespace cv::phase_unwrapping;
| 80476 |  |  | 80428 |
| 80477 |  |  | 80429 |
| 80478 | Ptr<cv::phase_unwrapping::PhaseUnwrapping> * self1 = 0; |  | 80430 | Ptr<cv::phase_unwrapping::PhaseUnwrapping> * self1 = 0;
| 80479 | if (!pyopencv_phase_unwrapping_PhaseUnwrapping_getp(self, self1)) |  | 80431 | if (!pyopencv_phase_unwrapping_PhaseUnwrapping_getp(self, self1))
| 80480 | return failmsgp("Incorrect type of self (must be 'phase_unwrapping_PhaseUnwrapping' or its derivative)"); |  | 80432 | return failmsgp("Incorrect type of self (must be 'phase_unwrapping_PhaseUnwrapping' or its derivative)");
| 80481 | Ptr<cv::phase_unwrapping::PhaseUnwrapping> _self_ = *(self1); |  | 80433 | Ptr<cv::phase_unwrapping::PhaseUnwrapping> _self_ = *(self1);
| 80482 | pyPrepareArgumentConversionErrorsStorage(2); |  | 80434 | pyPrepareArgumentConversionErrorsStorage(2);
| 80483 |  |  | 80435 |
| 80484 | { |  | 80436 | {
| 80485 | PyObject* pyobj_wrappedPhaseMap = NULL; |  | 80437 | PyObject* pyobj_wrappedPhaseMap = NULL;
| 80486 | Mat wrappedPhaseMap; |  | 80438 | Mat wrappedPhaseMap;
| 80487 | PyObject* pyobj_unwrappedPhaseMap = NULL; |  | 80439 | PyObject* pyobj_unwrappedPhaseMap = NULL;
| 80488 | Mat unwrappedPhaseMap; |  | 80440 | Mat unwrappedPhaseMap;
| 80489 | PyObject* pyobj_shadowMask = NULL; |  | 80441 | PyObject* pyobj_shadowMask = NULL;
| 80490 | Mat shadowMask; |  | 80442 | Mat shadowMask;
| 80491 |  |  | 80443 |
| 80492 | const char* keywords[] = { "wrappedPhaseMap", "unwrappedPhaseMap", "shadowMask", NULL }; |  | 80444 | const char* keywords[] = { "wrappedPhaseMap", "unwrappedPhaseMap", "shadowMask", NULL };
| 80493 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:phase_unwrapping_PhaseUnwrapping.unwrapPhaseMap", (char**)keywords, &pyobj_wrappedPhaseMap, &pyobj_unwrappedPhaseMap, &pyobj_shadowMask) && |  | 80445 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:phase_unwrapping_PhaseUnwrapping.unwrapPhaseMap", (char**)keywords, &pyobj_wrappedPhaseMap, &pyobj_unwrappedPhaseMap, &pyobj_shadowMask) &&
| 80494 | pyopencv_to_safe(pyobj_wrappedPhaseMap, wrappedPhaseMap, ArgInfo("wrappedPhaseMap", 0)) && |  | 80446 | pyopencv_to_safe(pyobj_wrappedPhaseMap, wrappedPhaseMap, ArgInfo("wrappedPhaseMap", 0)) &&
| 80495 | pyopencv_to_safe(pyobj_unwrappedPhaseMap, unwrappedPhaseMap, ArgInfo("unwrappedPhaseMap", 1)) && |  | 80447 | pyopencv_to_safe(pyobj_unwrappedPhaseMap, unwrappedPhaseMap, ArgInfo("unwrappedPhaseMap", 1)) &&
| 80496 | pyopencv_to_safe(pyobj_shadowMask, shadowMask, ArgInfo("shadowMask", 0)) ) |  | 80448 | pyopencv_to_safe(pyobj_shadowMask, shadowMask, ArgInfo("shadowMask", 0)) )
| 80497 | { |  | 80449 | {
| 80498 | ERRWRAP2(_self_->unwrapPhaseMap(wrappedPhaseMap, unwrappedPhaseMap, shadowMask)); |  | 80450 | ERRWRAP2(_self_->unwrapPhaseMap(wrappedPhaseMap, unwrappedPhaseMap, shadowMask));
| 80499 | return pyopencv_from(unwrappedPhaseMap); |  | 80451 | return pyopencv_from(unwrappedPhaseMap);
| 80500 | } |  | 80452 | }
| 80501 |  |  | 80453 |
| 80502 |  |  | 80454 |
| 80503 | pyPopulateArgumentConversionErrors(); |  | 80455 | pyPopulateArgumentConversionErrors();
| 80504 | } |  | 80456 | }
| 80505 |  |  | 80457 |
| 80506 |  |  | 80458 |
| 80507 | { |  | 80459 | {
| 80508 | PyObject* pyobj_wrappedPhaseMap = NULL; |  | 80460 | PyObject* pyobj_wrappedPhaseMap = NULL;
| 80509 | UMat wrappedPhaseMap; |  | 80461 | UMat wrappedPhaseMap;
| 80510 | PyObject* pyobj_unwrappedPhaseMap = NULL; |  | 80462 | PyObject* pyobj_unwrappedPhaseMap = NULL;
| 80511 | UMat unwrappedPhaseMap; |  | 80463 | UMat unwrappedPhaseMap;
| 80512 | PyObject* pyobj_shadowMask = NULL; |  | 80464 | PyObject* pyobj_shadowMask = NULL;
| 80513 | UMat shadowMask; |  | 80465 | UMat shadowMask;
| 80514 |  |  | 80466 |
| 80515 | const char* keywords[] = { "wrappedPhaseMap", "unwrappedPhaseMap", "shadowMask", NULL }; |  | 80467 | const char* keywords[] = { "wrappedPhaseMap", "unwrappedPhaseMap", "shadowMask", NULL };
| 80516 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:phase_unwrapping_PhaseUnwrapping.unwrapPhaseMap", (char**)keywords, &pyobj_wrappedPhaseMap, &pyobj_unwrappedPhaseMap, &pyobj_shadowMask) && |  | 80468 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:phase_unwrapping_PhaseUnwrapping.unwrapPhaseMap", (char**)keywords, &pyobj_wrappedPhaseMap, &pyobj_unwrappedPhaseMap, &pyobj_shadowMask) &&
| 80517 | pyopencv_to_safe(pyobj_wrappedPhaseMap, wrappedPhaseMap, ArgInfo("wrappedPhaseMap", 0)) && |  | 80469 | pyopencv_to_safe(pyobj_wrappedPhaseMap, wrappedPhaseMap, ArgInfo("wrappedPhaseMap", 0)) &&
| 80518 | pyopencv_to_safe(pyobj_unwrappedPhaseMap, unwrappedPhaseMap, ArgInfo("unwrappedPhaseMap", 1)) && |  | 80470 | pyopencv_to_safe(pyobj_unwrappedPhaseMap, unwrappedPhaseMap, ArgInfo("unwrappedPhaseMap", 1)) &&
| 80519 | pyopencv_to_safe(pyobj_shadowMask, shadowMask, ArgInfo("shadowMask", 0)) ) |  | 80471 | pyopencv_to_safe(pyobj_shadowMask, shadowMask, ArgInfo("shadowMask", 0)) )
| 80520 | { |  | 80472 | {
| 80521 | ERRWRAP2(_self_->unwrapPhaseMap(wrappedPhaseMap, unwrappedPhaseMap, shadowMask)); |  | 80473 | ERRWRAP2(_self_->unwrapPhaseMap(wrappedPhaseMap, unwrappedPhaseMap, shadowMask));
| 80522 | return pyopencv_from(unwrappedPhaseMap); |  | 80474 | return pyopencv_from(unwrappedPhaseMap);
| 80523 | } |  | 80475 | }
| 80524 |  |  | 80476 |
| 80525 |  |  | 80477 |
| 80526 | pyPopulateArgumentConversionErrors(); |  | 80478 | pyPopulateArgumentConversionErrors();
| 80527 | } |  | 80479 | }
| 80528 | pyRaiseCVOverloadException("unwrapPhaseMap"); |  | 80480 | pyRaiseCVOverloadException("unwrapPhaseMap");
| 80529 |  |  | 80481 |
| 80530 | return NULL; |  | 80482 | return NULL;
| 80531 | } |  | 80483 | }
| 80532 |  |  | 80484 |
| 80533 |  |  | 80485 |
| 80534 |  |  | 80486 |
| 80535 | // Tables (phase_unwrapping_PhaseUnwrapping) |  | 80487 | // Tables (phase_unwrapping_PhaseUnwrapping)
| 80536 |  |  | 80488 |
| 80537 | static PyGetSetDef pyopencv_phase_unwrapping_PhaseUnwrapping_getseters[] = |  | 80489 | static PyGetSetDef pyopencv_phase_unwrapping_PhaseUnwrapping_getseters[] =
| 80538 | { |  | 80490 | {
| 80539 | {NULL} /* Sentinel */ |  | 80491 | {NULL} /* Sentinel */
| 80540 | }; |  | 80492 | };
| 80541 |  |  | 80493 |
| 80542 | static PyMethodDef pyopencv_phase_unwrapping_PhaseUnwrapping_methods[] = |  | 80494 | static PyMethodDef pyopencv_phase_unwrapping_PhaseUnwrapping_methods[] =
| 80543 | { |  | 80495 | {
| 80544 | {"unwrapPhaseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_phase_unwrapping_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap, 0), "unwrapPhaseMap(wrappedPhaseMap[, unwrappedPhaseMap[, shadowMask]]) -> unwrappedPhaseMap\n. * @brief Unwraps a 2D phase map.\n. \n. * @param wrappedPhaseMap The wrapped phase map of type CV_32FC1 that needs to be unwrapped.\n. * @param unwrappedPhaseMap The unwrapped phase map.\n. * @param shadowMask Optional CV_8UC1 mask image used when some pixels do not hold any phase information in the wrapped phase map."}, |  | 80496 | {"unwrapPhaseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_phase_unwrapping_phase_unwrapping_PhaseUnwrapping_unwrapPhaseMap, 0), "unwrapPhaseMap(wrappedPhaseMap[, unwrappedPhaseMap[, shadowMask]]) -> unwrappedPhaseMap\n. * @brief Unwraps a 2D phase map.\n. \n. * @param wrappedPhaseMap The wrapped phase map of type CV_32FC1 that needs to be unwrapped.\n. * @param unwrappedPhaseMap The unwrapped phase map.\n. * @param shadowMask Optional CV_8UC1 mask image used when some pixels do not hold any phase information in the wrapped phase map."},
| 80545 |  |  | 80497 |
| 80546 | {NULL, NULL} |  | 80498 | {NULL, NULL}
| 80547 | }; |  | 80499 | };
| 80548 |  |  | 80500 |
| 80549 | // Converter (phase_unwrapping_PhaseUnwrapping) |  | 80501 | // Converter (phase_unwrapping_PhaseUnwrapping)
| 80550 |  |  | 80502 |
| 80551 | template<> |  | 80503 | template<>
| 80552 | struct PyOpenCV_Converter< Ptr<cv::phase_unwrapping::PhaseUnwrapping> > |  | 80504 | struct PyOpenCV_Converter< Ptr<cv::phase_unwrapping::PhaseUnwrapping> >
| 80553 | { |  | 80505 | {
| 80554 | static PyObject* from(const Ptr<cv::phase_unwrapping::PhaseUnwrapping>& r) |  | 80506 | static PyObject* from(const Ptr<cv::phase_unwrapping::PhaseUnwrapping>& r)
| 80555 | { |  | 80507 | {
| 80556 | return pyopencv_phase_unwrapping_PhaseUnwrapping_Instance(r); |  | 80508 | return pyopencv_phase_unwrapping_PhaseUnwrapping_Instance(r);
| 80557 | } |  | 80509 | }
| 80558 | static bool to(PyObject* src, Ptr<cv::phase_unwrapping::PhaseUnwrapping>& dst, const ArgInfo& info) |  | 80510 | static bool to(PyObject* src, Ptr<cv::phase_unwrapping::PhaseUnwrapping>& dst, const ArgInfo& info)
| 80559 | { |  | 80511 | {
| 80560 | if(!src || src == Py_None) |  | 80512 | if(!src || src == Py_None)
| 80561 | return true; |  | 80513 | return true;
| 80562 | Ptr<cv::phase_unwrapping::PhaseUnwrapping> * dst_; |  | 80514 | Ptr<cv::phase_unwrapping::PhaseUnwrapping> * dst_;
| 80563 | if (pyopencv_phase_unwrapping_PhaseUnwrapping_getp(src, dst_)) |  | 80515 | if (pyopencv_phase_unwrapping_PhaseUnwrapping_getp(src, dst_))
| 80564 | { |  | 80516 | {
| 80565 | dst = *dst_; |  | 80517 | dst = *dst_;
| 80566 | return true; |  | 80518 | return true;
| 80567 | } |  | 80519 | }
| 80568 |  |  | 80520 |
| 80569 | failmsg("Expected Ptr<cv::phase_unwrapping::PhaseUnwrapping> for argument '%s'", info.name); |  | 80521 | failmsg("Expected Ptr<cv::phase_unwrapping::PhaseUnwrapping> for argument '%s'", info.name);
| 80570 | return false; |  | 80522 | return false;
| 80571 | } |  | 80523 | }
| 80572 | }; |  | 80524 | };
| 80573 |  |  | 80525 |
| 80574 | //================================================================================ |  | 80526 | //================================================================================
| 80575 | // plot_Plot2d (Generic) |  | 80527 | // plot_Plot2d (Generic)
| 80576 | //================================================================================ |  | 80528 | //================================================================================
| 80577 |  |  | 80529 |
| 80578 | // GetSet (plot_Plot2d) |  | 80530 | // GetSet (plot_Plot2d)
| 80579 |  |  | 80531 |
| 80580 |  |  | 80532 |
| 80581 |  |  | 80533 |
| 80582 | // Methods (plot_Plot2d) |  | 80534 | // Methods (plot_Plot2d)
| 80583 |  |  | 80535 |
| 80584 | static PyObject* pyopencv_cv_plot_plot_Plot2d_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80536 | static PyObject* pyopencv_cv_plot_plot_Plot2d_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 80585 | { |  | 80537 | {
| 80586 | using namespace cv::plot; |  | 80538 | using namespace cv::plot;
| 80587 |  |  | 80539 |
| 80588 | pyPrepareArgumentConversionErrorsStorage(4); |  | 80540 | pyPrepareArgumentConversionErrorsStorage(4);
| 80589 |  |  | 80541 |
| 80590 | { |  | 80542 | {
| 80591 | PyObject* pyobj_data = NULL; |  | 80543 | PyObject* pyobj_data = NULL;
| 80592 | Mat data; |  | 80544 | Mat data;
| 80593 | Ptr<Plot2d> retval; |  | 80545 | Ptr<Plot2d> retval;
| 80594 |  |  | 80546 |
| 80595 | const char* keywords[] = { "data", NULL }; |  | 80547 | const char* keywords[] = { "data", NULL };
| 80596 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.create", (char**)keywords, &pyobj_data) && |  | 80548 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.create", (char**)keywords, &pyobj_data) &&
| 80597 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) ) |  | 80549 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) )
| 80598 | { |  | 80550 | {
| 80599 | ERRWRAP2(retval = cv::plot::Plot2d::create(data)); |  | 80551 | ERRWRAP2(retval = cv::plot::Plot2d::create(data));
| 80600 | return pyopencv_from(retval); |  | 80552 | return pyopencv_from(retval);
| 80601 | } |  | 80553 | }
| 80602 |  |  | 80554 |
| 80603 |  |  | 80555 |
| 80604 | pyPopulateArgumentConversionErrors(); |  | 80556 | pyPopulateArgumentConversionErrors();
| 80605 | } |  | 80557 | }
| 80606 |  |  | 80558 |
| 80607 |  |  | 80559 |
| 80608 | { |  | 80560 | {
| 80609 | PyObject* pyobj_dataX = NULL; |  | 80561 | PyObject* pyobj_dataX = NULL;
| 80610 | Mat dataX; |  | 80562 | Mat dataX;
| 80611 | PyObject* pyobj_dataY = NULL; |  | 80563 | PyObject* pyobj_dataY = NULL;
| 80612 | Mat dataY; |  | 80564 | Mat dataY;
| 80613 | Ptr<Plot2d> retval; |  | 80565 | Ptr<Plot2d> retval;
| 80614 |  |  | 80566 |
| 80615 | const char* keywords[] = { "dataX", "dataY", NULL }; |  | 80567 | const char* keywords[] = { "dataX", "dataY", NULL };
| 80616 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:plot_Plot2d.create", (char**)keywords, &pyobj_dataX, &pyobj_dataY) && |  | 80568 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:plot_Plot2d.create", (char**)keywords, &pyobj_dataX, &pyobj_dataY) &&
| 80617 | pyopencv_to_safe(pyobj_dataX, dataX, ArgInfo("dataX", 0)) && |  | 80569 | pyopencv_to_safe(pyobj_dataX, dataX, ArgInfo("dataX", 0)) &&
| 80618 | pyopencv_to_safe(pyobj_dataY, dataY, ArgInfo("dataY", 0)) ) |  | 80570 | pyopencv_to_safe(pyobj_dataY, dataY, ArgInfo("dataY", 0)) )
| 80619 | { |  | 80571 | {
| 80620 | ERRWRAP2(retval = cv::plot::Plot2d::create(dataX, dataY)); |  | 80572 | ERRWRAP2(retval = cv::plot::Plot2d::create(dataX, dataY));
| 80621 | return pyopencv_from(retval); |  | 80573 | return pyopencv_from(retval);
| 80622 | } |  | 80574 | }
| 80623 |  |  | 80575 |
| 80624 |  |  | 80576 |
| 80625 | pyPopulateArgumentConversionErrors(); |  | 80577 | pyPopulateArgumentConversionErrors();
| 80626 | } |  | 80578 | }
| 80627 |  |  | 80579 |
| 80628 |  |  | 80580 |
| 80629 | { |  | 80581 | {
| 80630 | PyObject* pyobj_data = NULL; |  | 80582 | PyObject* pyobj_data = NULL;
| 80631 | UMat data; |  | 80583 | UMat data;
| 80632 | Ptr<Plot2d> retval; |  | 80584 | Ptr<Plot2d> retval;
| 80633 |  |  | 80585 |
| 80634 | const char* keywords[] = { "data", NULL }; |  | 80586 | const char* keywords[] = { "data", NULL };
| 80635 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.create", (char**)keywords, &pyobj_data) && |  | 80587 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.create", (char**)keywords, &pyobj_data) &&
| 80636 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) ) |  | 80588 | pyopencv_to_safe(pyobj_data, data, ArgInfo("data", 0)) )
| 80637 | { |  | 80589 | {
| 80638 | ERRWRAP2(retval = cv::plot::Plot2d::create(data)); |  | 80590 | ERRWRAP2(retval = cv::plot::Plot2d::create(data));
| 80639 | return pyopencv_from(retval); |  | 80591 | return pyopencv_from(retval);
| 80640 | } |  | 80592 | }
| 80641 |  |  | 80593 |
| 80642 |  |  | 80594 |
| 80643 | pyPopulateArgumentConversionErrors(); |  | 80595 | pyPopulateArgumentConversionErrors();
| 80644 | } |  | 80596 | }
| 80645 |  |  | 80597 |
| 80646 |  |  | 80598 |
| 80647 | { |  | 80599 | {
| 80648 | PyObject* pyobj_dataX = NULL; |  | 80600 | PyObject* pyobj_dataX = NULL;
| 80649 | UMat dataX; |  | 80601 | UMat dataX;
| 80650 | PyObject* pyobj_dataY = NULL; |  | 80602 | PyObject* pyobj_dataY = NULL;
| 80651 | UMat dataY; |  | 80603 | UMat dataY;
| 80652 | Ptr<Plot2d> retval; |  | 80604 | Ptr<Plot2d> retval;
| 80653 |  |  | 80605 |
| 80654 | const char* keywords[] = { "dataX", "dataY", NULL }; |  | 80606 | const char* keywords[] = { "dataX", "dataY", NULL };
| 80655 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:plot_Plot2d.create", (char**)keywords, &pyobj_dataX, &pyobj_dataY) && |  | 80607 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:plot_Plot2d.create", (char**)keywords, &pyobj_dataX, &pyobj_dataY) &&
| 80656 | pyopencv_to_safe(pyobj_dataX, dataX, ArgInfo("dataX", 0)) && |  | 80608 | pyopencv_to_safe(pyobj_dataX, dataX, ArgInfo("dataX", 0)) &&
| 80657 | pyopencv_to_safe(pyobj_dataY, dataY, ArgInfo("dataY", 0)) ) |  | 80609 | pyopencv_to_safe(pyobj_dataY, dataY, ArgInfo("dataY", 0)) )
| 80658 | { |  | 80610 | {
| 80659 | ERRWRAP2(retval = cv::plot::Plot2d::create(dataX, dataY)); |  | 80611 | ERRWRAP2(retval = cv::plot::Plot2d::create(dataX, dataY));
| 80660 | return pyopencv_from(retval); |  | 80612 | return pyopencv_from(retval);
| 80661 | } |  | 80613 | }
| 80662 |  |  | 80614 |
| 80663 |  |  | 80615 |
| 80664 | pyPopulateArgumentConversionErrors(); |  | 80616 | pyPopulateArgumentConversionErrors();
| 80665 | } |  | 80617 | }
| 80666 | pyRaiseCVOverloadException("create"); |  | 80618 | pyRaiseCVOverloadException("create");
| 80667 |  |  | 80619 |
| 80668 | return NULL; |  | 80620 | return NULL;
| 80669 | } |  | 80621 | }
| 80670 |  |  | 80622 |
| 80671 | static PyObject* pyopencv_cv_plot_plot_Plot2d_render(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80623 | static PyObject* pyopencv_cv_plot_plot_Plot2d_render(PyObject* self, PyObject* py_args, PyObject* kw)
| 80672 | { |  | 80624 | {
| 80673 | using namespace cv::plot; |  | 80625 | using namespace cv::plot;
| 80674 |  |  | 80626 |
| 80675 |  |  | 80627 |
| 80676 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80628 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80677 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80629 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80678 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80630 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80679 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80631 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80680 | pyPrepareArgumentConversionErrorsStorage(2); |  | 80632 | pyPrepareArgumentConversionErrorsStorage(2);
| 80681 |  |  | 80633 |
| 80682 | { |  | 80634 | {
| 80683 | PyObject* pyobj__plotResult = NULL; |  | 80635 | PyObject* pyobj__plotResult = NULL;
| 80684 | Mat _plotResult; |  | 80636 | Mat _plotResult;
| 80685 |  |  | 80637 |
| 80686 | const char* keywords[] = { "_plotResult", NULL }; |  | 80638 | const char* keywords[] = { "_plotResult", NULL };
| 80687 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:plot_Plot2d.render", (char**)keywords, &pyobj__plotResult) && |  | 80639 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:plot_Plot2d.render", (char**)keywords, &pyobj__plotResult) &&
| 80688 | pyopencv_to_safe(pyobj__plotResult, _plotResult, ArgInfo("_plotResult", 1)) ) |  | 80640 | pyopencv_to_safe(pyobj__plotResult, _plotResult, ArgInfo("_plotResult", 1)) )
| 80689 | { |  | 80641 | {
| 80690 | ERRWRAP2(_self_->render(_plotResult)); |  | 80642 | ERRWRAP2(_self_->render(_plotResult));
| 80691 | return pyopencv_from(_plotResult); |  | 80643 | return pyopencv_from(_plotResult);
| 80692 | } |  | 80644 | }
| 80693 |  |  | 80645 |
| 80694 |  |  | 80646 |
| 80695 | pyPopulateArgumentConversionErrors(); |  | 80647 | pyPopulateArgumentConversionErrors();
| 80696 | } |  | 80648 | }
| 80697 |  |  | 80649 |
| 80698 |  |  | 80650 |
| 80699 | { |  | 80651 | {
| 80700 | PyObject* pyobj__plotResult = NULL; |  | 80652 | PyObject* pyobj__plotResult = NULL;
| 80701 | UMat _plotResult; |  | 80653 | UMat _plotResult;
| 80702 |  |  | 80654 |
| 80703 | const char* keywords[] = { "_plotResult", NULL }; |  | 80655 | const char* keywords[] = { "_plotResult", NULL };
| 80704 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:plot_Plot2d.render", (char**)keywords, &pyobj__plotResult) && |  | 80656 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:plot_Plot2d.render", (char**)keywords, &pyobj__plotResult) &&
| 80705 | pyopencv_to_safe(pyobj__plotResult, _plotResult, ArgInfo("_plotResult", 1)) ) |  | 80657 | pyopencv_to_safe(pyobj__plotResult, _plotResult, ArgInfo("_plotResult", 1)) )
| 80706 | { |  | 80658 | {
| 80707 | ERRWRAP2(_self_->render(_plotResult)); |  | 80659 | ERRWRAP2(_self_->render(_plotResult));
| 80708 | return pyopencv_from(_plotResult); |  | 80660 | return pyopencv_from(_plotResult);
| 80709 | } |  | 80661 | }
| 80710 |  |  | 80662 |
| 80711 |  |  | 80663 |
| 80712 | pyPopulateArgumentConversionErrors(); |  | 80664 | pyPopulateArgumentConversionErrors();
| 80713 | } |  | 80665 | }
| 80714 | pyRaiseCVOverloadException("render"); |  | 80666 | pyRaiseCVOverloadException("render");
| 80715 |  |  | 80667 |
| 80716 | return NULL; |  | 80668 | return NULL;
| 80717 | } |  | 80669 | }
| 80718 |  |  | 80670 |
| 80719 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setGridLinesNumber(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80671 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setGridLinesNumber(PyObject* self, PyObject* py_args, PyObject* kw)
| 80720 | { |  | 80672 | {
| 80721 | using namespace cv::plot; |  | 80673 | using namespace cv::plot;
| 80722 |  |  | 80674 |
| 80723 |  |  | 80675 |
| 80724 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80676 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80725 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80677 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80726 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80678 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80727 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80679 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80728 | PyObject* pyobj_gridLinesNumber = NULL; |  | 80680 | PyObject* pyobj_gridLinesNumber = NULL;
| 80729 | int gridLinesNumber=0; |  | 80681 | int gridLinesNumber=0;
| 80730 |  |  | 80682 |
| 80731 | const char* keywords[] = { "gridLinesNumber", NULL }; |  | 80683 | const char* keywords[] = { "gridLinesNumber", NULL };
| 80732 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setGridLinesNumber", (char**)keywords, &pyobj_gridLinesNumber) && |  | 80684 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setGridLinesNumber", (char**)keywords, &pyobj_gridLinesNumber) &&
| 80733 | pyopencv_to_safe(pyobj_gridLinesNumber, gridLinesNumber, ArgInfo("gridLinesNumber", 0)) ) |  | 80685 | pyopencv_to_safe(pyobj_gridLinesNumber, gridLinesNumber, ArgInfo("gridLinesNumber", 0)) )
| 80734 | { |  | 80686 | {
| 80735 | ERRWRAP2(_self_->setGridLinesNumber(gridLinesNumber)); |  | 80687 | ERRWRAP2(_self_->setGridLinesNumber(gridLinesNumber));
| 80736 | Py_RETURN_NONE; |  | 80688 | Py_RETURN_NONE;
| 80737 | } |  | 80689 | }
| 80738 |  |  | 80690 |
| 80739 | return NULL; |  | 80691 | return NULL;
| 80740 | } |  | 80692 | }
| 80741 |  |  | 80693 |
| 80742 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setInvertOrientation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80694 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setInvertOrientation(PyObject* self, PyObject* py_args, PyObject* kw)
| 80743 | { |  | 80695 | {
| 80744 | using namespace cv::plot; |  | 80696 | using namespace cv::plot;
| 80745 |  |  | 80697 |
| 80746 |  |  | 80698 |
| 80747 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80699 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80748 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80700 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80749 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80701 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80750 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80702 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80751 | PyObject* pyobj__invertOrientation = NULL; |  | 80703 | PyObject* pyobj__invertOrientation = NULL;
| 80752 | bool _invertOrientation=0; |  | 80704 | bool _invertOrientation=0;
| 80753 |  |  | 80705 |
| 80754 | const char* keywords[] = { "_invertOrientation", NULL }; |  | 80706 | const char* keywords[] = { "_invertOrientation", NULL };
| 80755 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setInvertOrientation", (char**)keywords, &pyobj__invertOrientation) && |  | 80707 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setInvertOrientation", (char**)keywords, &pyobj__invertOrientation) &&
| 80756 | pyopencv_to_safe(pyobj__invertOrientation, _invertOrientation, ArgInfo("_invertOrientation", 0)) ) |  | 80708 | pyopencv_to_safe(pyobj__invertOrientation, _invertOrientation, ArgInfo("_invertOrientation", 0)) )
| 80757 | { |  | 80709 | {
| 80758 | ERRWRAP2(_self_->setInvertOrientation(_invertOrientation)); |  | 80710 | ERRWRAP2(_self_->setInvertOrientation(_invertOrientation));
| 80759 | Py_RETURN_NONE; |  | 80711 | Py_RETURN_NONE;
| 80760 | } |  | 80712 | }
| 80761 |  |  | 80713 |
| 80762 | return NULL; |  | 80714 | return NULL;
| 80763 | } |  | 80715 | }
| 80764 |  |  | 80716 |
| 80765 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMaxX(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80717 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMaxX(PyObject* self, PyObject* py_args, PyObject* kw)
| 80766 | { |  | 80718 | {
| 80767 | using namespace cv::plot; |  | 80719 | using namespace cv::plot;
| 80768 |  |  | 80720 |
| 80769 |  |  | 80721 |
| 80770 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80722 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80771 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80723 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80772 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80724 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80773 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80725 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80774 | PyObject* pyobj__plotMaxX = NULL; |  | 80726 | PyObject* pyobj__plotMaxX = NULL;
| 80775 | double _plotMaxX=0; |  | 80727 | double _plotMaxX=0;
| 80776 |  |  | 80728 |
| 80777 | const char* keywords[] = { "_plotMaxX", NULL }; |  | 80729 | const char* keywords[] = { "_plotMaxX", NULL };
| 80778 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMaxX", (char**)keywords, &pyobj__plotMaxX) && |  | 80730 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMaxX", (char**)keywords, &pyobj__plotMaxX) &&
| 80779 | pyopencv_to_safe(pyobj__plotMaxX, _plotMaxX, ArgInfo("_plotMaxX", 0)) ) |  | 80731 | pyopencv_to_safe(pyobj__plotMaxX, _plotMaxX, ArgInfo("_plotMaxX", 0)) )
| 80780 | { |  | 80732 | {
| 80781 | ERRWRAP2(_self_->setMaxX(_plotMaxX)); |  | 80733 | ERRWRAP2(_self_->setMaxX(_plotMaxX));
| 80782 | Py_RETURN_NONE; |  | 80734 | Py_RETURN_NONE;
| 80783 | } |  | 80735 | }
| 80784 |  |  | 80736 |
| 80785 | return NULL; |  | 80737 | return NULL;
| 80786 | } |  | 80738 | }
| 80787 |  |  | 80739 |
| 80788 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMaxY(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80740 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMaxY(PyObject* self, PyObject* py_args, PyObject* kw)
| 80789 | { |  | 80741 | {
| 80790 | using namespace cv::plot; |  | 80742 | using namespace cv::plot;
| 80791 |  |  | 80743 |
| 80792 |  |  | 80744 |
| 80793 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80745 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80794 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80746 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80795 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80747 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80796 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80748 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80797 | PyObject* pyobj__plotMaxY = NULL; |  | 80749 | PyObject* pyobj__plotMaxY = NULL;
| 80798 | double _plotMaxY=0; |  | 80750 | double _plotMaxY=0;
| 80799 |  |  | 80751 |
| 80800 | const char* keywords[] = { "_plotMaxY", NULL }; |  | 80752 | const char* keywords[] = { "_plotMaxY", NULL };
| 80801 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMaxY", (char**)keywords, &pyobj__plotMaxY) && |  | 80753 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMaxY", (char**)keywords, &pyobj__plotMaxY) &&
| 80802 | pyopencv_to_safe(pyobj__plotMaxY, _plotMaxY, ArgInfo("_plotMaxY", 0)) ) |  | 80754 | pyopencv_to_safe(pyobj__plotMaxY, _plotMaxY, ArgInfo("_plotMaxY", 0)) )
| 80803 | { |  | 80755 | {
| 80804 | ERRWRAP2(_self_->setMaxY(_plotMaxY)); |  | 80756 | ERRWRAP2(_self_->setMaxY(_plotMaxY));
| 80805 | Py_RETURN_NONE; |  | 80757 | Py_RETURN_NONE;
| 80806 | } |  | 80758 | }
| 80807 |  |  | 80759 |
| 80808 | return NULL; |  | 80760 | return NULL;
| 80809 | } |  | 80761 | }
| 80810 |  |  | 80762 |
| 80811 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMinX(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80763 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMinX(PyObject* self, PyObject* py_args, PyObject* kw)
| 80812 | { |  | 80764 | {
| 80813 | using namespace cv::plot; |  | 80765 | using namespace cv::plot;
| 80814 |  |  | 80766 |
| 80815 |  |  | 80767 |
| 80816 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80768 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80817 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80769 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80818 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80770 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80819 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80771 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80820 | PyObject* pyobj__plotMinX = NULL; |  | 80772 | PyObject* pyobj__plotMinX = NULL;
| 80821 | double _plotMinX=0; |  | 80773 | double _plotMinX=0;
| 80822 |  |  | 80774 |
| 80823 | const char* keywords[] = { "_plotMinX", NULL }; |  | 80775 | const char* keywords[] = { "_plotMinX", NULL };
| 80824 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMinX", (char**)keywords, &pyobj__plotMinX) && |  | 80776 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMinX", (char**)keywords, &pyobj__plotMinX) &&
| 80825 | pyopencv_to_safe(pyobj__plotMinX, _plotMinX, ArgInfo("_plotMinX", 0)) ) |  | 80777 | pyopencv_to_safe(pyobj__plotMinX, _plotMinX, ArgInfo("_plotMinX", 0)) )
| 80826 | { |  | 80778 | {
| 80827 | ERRWRAP2(_self_->setMinX(_plotMinX)); |  | 80779 | ERRWRAP2(_self_->setMinX(_plotMinX));
| 80828 | Py_RETURN_NONE; |  | 80780 | Py_RETURN_NONE;
| 80829 | } |  | 80781 | }
| 80830 |  |  | 80782 |
| 80831 | return NULL; |  | 80783 | return NULL;
| 80832 | } |  | 80784 | }
| 80833 |  |  | 80785 |
| 80834 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMinY(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80786 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setMinY(PyObject* self, PyObject* py_args, PyObject* kw)
| 80835 | { |  | 80787 | {
| 80836 | using namespace cv::plot; |  | 80788 | using namespace cv::plot;
| 80837 |  |  | 80789 |
| 80838 |  |  | 80790 |
| 80839 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80791 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80840 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80792 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80841 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80793 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80842 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80794 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80843 | PyObject* pyobj__plotMinY = NULL; |  | 80795 | PyObject* pyobj__plotMinY = NULL;
| 80844 | double _plotMinY=0; |  | 80796 | double _plotMinY=0;
| 80845 |  |  | 80797 |
| 80846 | const char* keywords[] = { "_plotMinY", NULL }; |  | 80798 | const char* keywords[] = { "_plotMinY", NULL };
| 80847 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMinY", (char**)keywords, &pyobj__plotMinY) && |  | 80799 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setMinY", (char**)keywords, &pyobj__plotMinY) &&
| 80848 | pyopencv_to_safe(pyobj__plotMinY, _plotMinY, ArgInfo("_plotMinY", 0)) ) |  | 80800 | pyopencv_to_safe(pyobj__plotMinY, _plotMinY, ArgInfo("_plotMinY", 0)) )
| 80849 | { |  | 80801 | {
| 80850 | ERRWRAP2(_self_->setMinY(_plotMinY)); |  | 80802 | ERRWRAP2(_self_->setMinY(_plotMinY));
| 80851 | Py_RETURN_NONE; |  | 80803 | Py_RETURN_NONE;
| 80852 | } |  | 80804 | }
| 80853 |  |  | 80805 |
| 80854 | return NULL; |  | 80806 | return NULL;
| 80855 | } |  | 80807 | }
| 80856 |  |  | 80808 |
| 80857 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setNeedPlotLine(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80809 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setNeedPlotLine(PyObject* self, PyObject* py_args, PyObject* kw)
| 80858 | { |  | 80810 | {
| 80859 | using namespace cv::plot; |  | 80811 | using namespace cv::plot;
| 80860 |  |  | 80812 |
| 80861 |  |  | 80813 |
| 80862 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80814 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80863 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80815 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80864 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80816 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80865 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80817 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80866 | PyObject* pyobj__needPlotLine = NULL; |  | 80818 | PyObject* pyobj__needPlotLine = NULL;
| 80867 | bool _needPlotLine=0; |  | 80819 | bool _needPlotLine=0;
| 80868 |  |  | 80820 |
| 80869 | const char* keywords[] = { "_needPlotLine", NULL }; |  | 80821 | const char* keywords[] = { "_needPlotLine", NULL };
| 80870 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setNeedPlotLine", (char**)keywords, &pyobj__needPlotLine) && |  | 80822 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setNeedPlotLine", (char**)keywords, &pyobj__needPlotLine) &&
| 80871 | pyopencv_to_safe(pyobj__needPlotLine, _needPlotLine, ArgInfo("_needPlotLine", 0)) ) |  | 80823 | pyopencv_to_safe(pyobj__needPlotLine, _needPlotLine, ArgInfo("_needPlotLine", 0)) )
| 80872 | { |  | 80824 | {
| 80873 | ERRWRAP2(_self_->setNeedPlotLine(_needPlotLine)); |  | 80825 | ERRWRAP2(_self_->setNeedPlotLine(_needPlotLine));
| 80874 | Py_RETURN_NONE; |  | 80826 | Py_RETURN_NONE;
| 80875 | } |  | 80827 | }
| 80876 |  |  | 80828 |
| 80877 | return NULL; |  | 80829 | return NULL;
| 80878 | } |  | 80830 | }
| 80879 |  |  | 80831 |
| 80880 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotAxisColor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80832 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotAxisColor(PyObject* self, PyObject* py_args, PyObject* kw)
| 80881 | { |  | 80833 | {
| 80882 | using namespace cv::plot; |  | 80834 | using namespace cv::plot;
| 80883 |  |  | 80835 |
| 80884 |  |  | 80836 |
| 80885 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80837 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80886 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80838 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80887 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80839 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80888 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80840 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80889 | PyObject* pyobj__plotAxisColor = NULL; |  | 80841 | PyObject* pyobj__plotAxisColor = NULL;
| 80890 | Scalar _plotAxisColor; |  | 80842 | Scalar _plotAxisColor;
| 80891 |  |  | 80843 |
| 80892 | const char* keywords[] = { "_plotAxisColor", NULL }; |  | 80844 | const char* keywords[] = { "_plotAxisColor", NULL };
| 80893 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotAxisColor", (char**)keywords, &pyobj__plotAxisColor) && |  | 80845 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotAxisColor", (char**)keywords, &pyobj__plotAxisColor) &&
| 80894 | pyopencv_to_safe(pyobj__plotAxisColor, _plotAxisColor, ArgInfo("_plotAxisColor", 0)) ) |  | 80846 | pyopencv_to_safe(pyobj__plotAxisColor, _plotAxisColor, ArgInfo("_plotAxisColor", 0)) )
| 80895 | { |  | 80847 | {
| 80896 | ERRWRAP2(_self_->setPlotAxisColor(_plotAxisColor)); |  | 80848 | ERRWRAP2(_self_->setPlotAxisColor(_plotAxisColor));
| 80897 | Py_RETURN_NONE; |  | 80849 | Py_RETURN_NONE;
| 80898 | } |  | 80850 | }
| 80899 |  |  | 80851 |
| 80900 | return NULL; |  | 80852 | return NULL;
| 80901 | } |  | 80853 | }
| 80902 |  |  | 80854 |
| 80903 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotBackgroundColor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80855 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotBackgroundColor(PyObject* self, PyObject* py_args, PyObject* kw)
| 80904 | { |  | 80856 | {
| 80905 | using namespace cv::plot; |  | 80857 | using namespace cv::plot;
| 80906 |  |  | 80858 |
| 80907 |  |  | 80859 |
| 80908 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80860 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80909 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80861 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80910 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80862 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80911 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80863 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80912 | PyObject* pyobj__plotBackgroundColor = NULL; |  | 80864 | PyObject* pyobj__plotBackgroundColor = NULL;
| 80913 | Scalar _plotBackgroundColor; |  | 80865 | Scalar _plotBackgroundColor;
| 80914 |  |  | 80866 |
| 80915 | const char* keywords[] = { "_plotBackgroundColor", NULL }; |  | 80867 | const char* keywords[] = { "_plotBackgroundColor", NULL };
| 80916 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotBackgroundColor", (char**)keywords, &pyobj__plotBackgroundColor) && |  | 80868 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotBackgroundColor", (char**)keywords, &pyobj__plotBackgroundColor) &&
| 80917 | pyopencv_to_safe(pyobj__plotBackgroundColor, _plotBackgroundColor, ArgInfo("_plotBackgroundColor", 0)) ) |  | 80869 | pyopencv_to_safe(pyobj__plotBackgroundColor, _plotBackgroundColor, ArgInfo("_plotBackgroundColor", 0)) )
| 80918 | { |  | 80870 | {
| 80919 | ERRWRAP2(_self_->setPlotBackgroundColor(_plotBackgroundColor)); |  | 80871 | ERRWRAP2(_self_->setPlotBackgroundColor(_plotBackgroundColor));
| 80920 | Py_RETURN_NONE; |  | 80872 | Py_RETURN_NONE;
| 80921 | } |  | 80873 | }
| 80922 |  |  | 80874 |
| 80923 | return NULL; |  | 80875 | return NULL;
| 80924 | } |  | 80876 | }
| 80925 |  |  | 80877 |
| 80926 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotGridColor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80878 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotGridColor(PyObject* self, PyObject* py_args, PyObject* kw)
| 80927 | { |  | 80879 | {
| 80928 | using namespace cv::plot; |  | 80880 | using namespace cv::plot;
| 80929 |  |  | 80881 |
| 80930 |  |  | 80882 |
| 80931 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80883 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80932 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80884 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80933 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80885 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80934 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80886 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80935 | PyObject* pyobj__plotGridColor = NULL; |  | 80887 | PyObject* pyobj__plotGridColor = NULL;
| 80936 | Scalar _plotGridColor; |  | 80888 | Scalar _plotGridColor;
| 80937 |  |  | 80889 |
| 80938 | const char* keywords[] = { "_plotGridColor", NULL }; |  | 80890 | const char* keywords[] = { "_plotGridColor", NULL };
| 80939 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotGridColor", (char**)keywords, &pyobj__plotGridColor) && |  | 80891 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotGridColor", (char**)keywords, &pyobj__plotGridColor) &&
| 80940 | pyopencv_to_safe(pyobj__plotGridColor, _plotGridColor, ArgInfo("_plotGridColor", 0)) ) |  | 80892 | pyopencv_to_safe(pyobj__plotGridColor, _plotGridColor, ArgInfo("_plotGridColor", 0)) )
| 80941 | { |  | 80893 | {
| 80942 | ERRWRAP2(_self_->setPlotGridColor(_plotGridColor)); |  | 80894 | ERRWRAP2(_self_->setPlotGridColor(_plotGridColor));
| 80943 | Py_RETURN_NONE; |  | 80895 | Py_RETURN_NONE;
| 80944 | } |  | 80896 | }
| 80945 |  |  | 80897 |
| 80946 | return NULL; |  | 80898 | return NULL;
| 80947 | } |  | 80899 | }
| 80948 |  |  | 80900 |
| 80949 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotLineColor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80901 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotLineColor(PyObject* self, PyObject* py_args, PyObject* kw)
| 80950 | { |  | 80902 | {
| 80951 | using namespace cv::plot; |  | 80903 | using namespace cv::plot;
| 80952 |  |  | 80904 |
| 80953 |  |  | 80905 |
| 80954 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80906 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80955 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80907 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80956 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80908 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80957 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80909 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80958 | PyObject* pyobj__plotLineColor = NULL; |  | 80910 | PyObject* pyobj__plotLineColor = NULL;
| 80959 | Scalar _plotLineColor; |  | 80911 | Scalar _plotLineColor;
| 80960 |  |  | 80912 |
| 80961 | const char* keywords[] = { "_plotLineColor", NULL }; |  | 80913 | const char* keywords[] = { "_plotLineColor", NULL };
| 80962 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotLineColor", (char**)keywords, &pyobj__plotLineColor) && |  | 80914 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotLineColor", (char**)keywords, &pyobj__plotLineColor) &&
| 80963 | pyopencv_to_safe(pyobj__plotLineColor, _plotLineColor, ArgInfo("_plotLineColor", 0)) ) |  | 80915 | pyopencv_to_safe(pyobj__plotLineColor, _plotLineColor, ArgInfo("_plotLineColor", 0)) )
| 80964 | { |  | 80916 | {
| 80965 | ERRWRAP2(_self_->setPlotLineColor(_plotLineColor)); |  | 80917 | ERRWRAP2(_self_->setPlotLineColor(_plotLineColor));
| 80966 | Py_RETURN_NONE; |  | 80918 | Py_RETURN_NONE;
| 80967 | } |  | 80919 | }
| 80968 |  |  | 80920 |
| 80969 | return NULL; |  | 80921 | return NULL;
| 80970 | } |  | 80922 | }
| 80971 |  |  | 80923 |
| 80972 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotLineWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80924 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotLineWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 80973 | { |  | 80925 | {
| 80974 | using namespace cv::plot; |  | 80926 | using namespace cv::plot;
| 80975 |  |  | 80927 |
| 80976 |  |  | 80928 |
| 80977 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80929 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 80978 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80930 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 80979 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80931 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 80980 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80932 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 80981 | PyObject* pyobj__plotLineWidth = NULL; |  | 80933 | PyObject* pyobj__plotLineWidth = NULL;
| 80982 | int _plotLineWidth=0; |  | 80934 | int _plotLineWidth=0;
| 80983 |  |  | 80935 |
| 80984 | const char* keywords[] = { "_plotLineWidth", NULL }; |  | 80936 | const char* keywords[] = { "_plotLineWidth", NULL };
| 80985 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotLineWidth", (char**)keywords, &pyobj__plotLineWidth) && |  | 80937 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotLineWidth", (char**)keywords, &pyobj__plotLineWidth) &&
| 80986 | pyopencv_to_safe(pyobj__plotLineWidth, _plotLineWidth, ArgInfo("_plotLineWidth", 0)) ) |  | 80938 | pyopencv_to_safe(pyobj__plotLineWidth, _plotLineWidth, ArgInfo("_plotLineWidth", 0)) )
| 80987 | { |  | 80939 | {
| 80988 | ERRWRAP2(_self_->setPlotLineWidth(_plotLineWidth)); |  | 80940 | ERRWRAP2(_self_->setPlotLineWidth(_plotLineWidth));
| 80989 | Py_RETURN_NONE; |  | 80941 | Py_RETURN_NONE;
| 80990 | } |  | 80942 | }
| 80991 |  |  | 80943 |
| 80992 | return NULL; |  | 80944 | return NULL;
| 80993 | } |  | 80945 | }
| 80994 |  |  | 80946 |
| 80995 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80947 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 80996 | { |  | 80948 | {
| 80997 | using namespace cv::plot; |  | 80949 | using namespace cv::plot;
| 80998 |  |  | 80950 |
| 80999 |  |  | 80951 |
| 81000 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80952 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 81001 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80953 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 81002 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80954 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 81003 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80955 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 81004 | PyObject* pyobj__plotSizeWidth = NULL; |  | 80956 | PyObject* pyobj__plotSizeWidth = NULL;
| 81005 | int _plotSizeWidth=0; |  | 80957 | int _plotSizeWidth=0;
| 81006 | PyObject* pyobj__plotSizeHeight = NULL; |  | 80958 | PyObject* pyobj__plotSizeHeight = NULL;
| 81007 | int _plotSizeHeight=0; |  | 80959 | int _plotSizeHeight=0;
| 81008 |  |  | 80960 |
| 81009 | const char* keywords[] = { "_plotSizeWidth", "_plotSizeHeight", NULL }; |  | 80961 | const char* keywords[] = { "_plotSizeWidth", "_plotSizeHeight", NULL };
| 81010 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:plot_Plot2d.setPlotSize", (char**)keywords, &pyobj__plotSizeWidth, &pyobj__plotSizeHeight) && |  | 80962 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:plot_Plot2d.setPlotSize", (char**)keywords, &pyobj__plotSizeWidth, &pyobj__plotSizeHeight) &&
| 81011 | pyopencv_to_safe(pyobj__plotSizeWidth, _plotSizeWidth, ArgInfo("_plotSizeWidth", 0)) && |  | 80963 | pyopencv_to_safe(pyobj__plotSizeWidth, _plotSizeWidth, ArgInfo("_plotSizeWidth", 0)) &&
| 81012 | pyopencv_to_safe(pyobj__plotSizeHeight, _plotSizeHeight, ArgInfo("_plotSizeHeight", 0)) ) |  | 80964 | pyopencv_to_safe(pyobj__plotSizeHeight, _plotSizeHeight, ArgInfo("_plotSizeHeight", 0)) )
| 81013 | { |  | 80965 | {
| 81014 | ERRWRAP2(_self_->setPlotSize(_plotSizeWidth, _plotSizeHeight)); |  | 80966 | ERRWRAP2(_self_->setPlotSize(_plotSizeWidth, _plotSizeHeight));
| 81015 | Py_RETURN_NONE; |  | 80967 | Py_RETURN_NONE;
| 81016 | } |  | 80968 | }
| 81017 |  |  | 80969 |
| 81018 | return NULL; |  | 80970 | return NULL;
| 81019 | } |  | 80971 | }
| 81020 |  |  | 80972 |
| 81021 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotTextColor(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80973 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPlotTextColor(PyObject* self, PyObject* py_args, PyObject* kw)
| 81022 | { |  | 80974 | {
| 81023 | using namespace cv::plot; |  | 80975 | using namespace cv::plot;
| 81024 |  |  | 80976 |
| 81025 |  |  | 80977 |
| 81026 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 80978 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 81027 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 80979 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 81028 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 80980 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 81029 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 80981 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 81030 | PyObject* pyobj__plotTextColor = NULL; |  | 80982 | PyObject* pyobj__plotTextColor = NULL;
| 81031 | Scalar _plotTextColor; |  | 80983 | Scalar _plotTextColor;
| 81032 |  |  | 80984 |
| 81033 | const char* keywords[] = { "_plotTextColor", NULL }; |  | 80985 | const char* keywords[] = { "_plotTextColor", NULL };
| 81034 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotTextColor", (char**)keywords, &pyobj__plotTextColor) && |  | 80986 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPlotTextColor", (char**)keywords, &pyobj__plotTextColor) &&
| 81035 | pyopencv_to_safe(pyobj__plotTextColor, _plotTextColor, ArgInfo("_plotTextColor", 0)) ) |  | 80987 | pyopencv_to_safe(pyobj__plotTextColor, _plotTextColor, ArgInfo("_plotTextColor", 0)) )
| 81036 | { |  | 80988 | {
| 81037 | ERRWRAP2(_self_->setPlotTextColor(_plotTextColor)); |  | 80989 | ERRWRAP2(_self_->setPlotTextColor(_plotTextColor));
| 81038 | Py_RETURN_NONE; |  | 80990 | Py_RETURN_NONE;
| 81039 | } |  | 80991 | }
| 81040 |  |  | 80992 |
| 81041 | return NULL; |  | 80993 | return NULL;
| 81042 | } |  | 80994 | }
| 81043 |  |  | 80995 |
| 81044 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPointIdxToPrint(PyObject* self, PyObject* py_args, PyObject* kw) |  | 80996 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setPointIdxToPrint(PyObject* self, PyObject* py_args, PyObject* kw)
| 81045 | { |  | 80997 | {
| 81046 | using namespace cv::plot; |  | 80998 | using namespace cv::plot;
| 81047 |  |  | 80999 |
| 81048 |  |  | 81000 |
| 81049 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 81001 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 81050 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 81002 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 81051 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 81003 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 81052 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 81004 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 81053 | PyObject* pyobj_pointIdx = NULL; |  | 81005 | PyObject* pyobj_pointIdx = NULL;
| 81054 | int pointIdx=0; |  | 81006 | int pointIdx=0;
| 81055 |  |  | 81007 |
| 81056 | const char* keywords[] = { "pointIdx", NULL }; |  | 81008 | const char* keywords[] = { "pointIdx", NULL };
| 81057 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPointIdxToPrint", (char**)keywords, &pyobj_pointIdx) && |  | 81009 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setPointIdxToPrint", (char**)keywords, &pyobj_pointIdx) &&
| 81058 | pyopencv_to_safe(pyobj_pointIdx, pointIdx, ArgInfo("pointIdx", 0)) ) |  | 81010 | pyopencv_to_safe(pyobj_pointIdx, pointIdx, ArgInfo("pointIdx", 0)) )
| 81059 | { |  | 81011 | {
| 81060 | ERRWRAP2(_self_->setPointIdxToPrint(pointIdx)); |  | 81012 | ERRWRAP2(_self_->setPointIdxToPrint(pointIdx));
| 81061 | Py_RETURN_NONE; |  | 81013 | Py_RETURN_NONE;
| 81062 | } |  | 81014 | }
| 81063 |  |  | 81015 |
| 81064 | return NULL; |  | 81016 | return NULL;
| 81065 | } |  | 81017 | }
| 81066 |  |  | 81018 |
| 81067 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setShowGrid(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81019 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setShowGrid(PyObject* self, PyObject* py_args, PyObject* kw)
| 81068 | { |  | 81020 | {
| 81069 | using namespace cv::plot; |  | 81021 | using namespace cv::plot;
| 81070 |  |  | 81022 |
| 81071 |  |  | 81023 |
| 81072 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 81024 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 81073 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 81025 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 81074 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 81026 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 81075 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 81027 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 81076 | PyObject* pyobj_needShowGrid = NULL; |  | 81028 | PyObject* pyobj_needShowGrid = NULL;
| 81077 | bool needShowGrid=0; |  | 81029 | bool needShowGrid=0;
| 81078 |  |  | 81030 |
| 81079 | const char* keywords[] = { "needShowGrid", NULL }; |  | 81031 | const char* keywords[] = { "needShowGrid", NULL };
| 81080 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setShowGrid", (char**)keywords, &pyobj_needShowGrid) && |  | 81032 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setShowGrid", (char**)keywords, &pyobj_needShowGrid) &&
| 81081 | pyopencv_to_safe(pyobj_needShowGrid, needShowGrid, ArgInfo("needShowGrid", 0)) ) |  | 81033 | pyopencv_to_safe(pyobj_needShowGrid, needShowGrid, ArgInfo("needShowGrid", 0)) )
| 81082 | { |  | 81034 | {
| 81083 | ERRWRAP2(_self_->setShowGrid(needShowGrid)); |  | 81035 | ERRWRAP2(_self_->setShowGrid(needShowGrid));
| 81084 | Py_RETURN_NONE; |  | 81036 | Py_RETURN_NONE;
| 81085 | } |  | 81037 | }
| 81086 |  |  | 81038 |
| 81087 | return NULL; |  | 81039 | return NULL;
| 81088 | } |  | 81040 | }
| 81089 |  |  | 81041 |
| 81090 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setShowText(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81042 | static PyObject* pyopencv_cv_plot_plot_Plot2d_setShowText(PyObject* self, PyObject* py_args, PyObject* kw)
| 81091 | { |  | 81043 | {
| 81092 | using namespace cv::plot; |  | 81044 | using namespace cv::plot;
| 81093 |  |  | 81045 |
| 81094 |  |  | 81046 |
| 81095 | Ptr<cv::plot::Plot2d> * self1 = 0; |  | 81047 | Ptr<cv::plot::Plot2d> * self1 = 0;
| 81096 | if (!pyopencv_plot_Plot2d_getp(self, self1)) |  | 81048 | if (!pyopencv_plot_Plot2d_getp(self, self1))
| 81097 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)"); |  | 81049 | return failmsgp("Incorrect type of self (must be 'plot_Plot2d' or its derivative)");
| 81098 | Ptr<cv::plot::Plot2d> _self_ = *(self1); |  | 81050 | Ptr<cv::plot::Plot2d> _self_ = *(self1);
| 81099 | PyObject* pyobj_needShowText = NULL; |  | 81051 | PyObject* pyobj_needShowText = NULL;
| 81100 | bool needShowText=0; |  | 81052 | bool needShowText=0;
| 81101 |  |  | 81053 |
| 81102 | const char* keywords[] = { "needShowText", NULL }; |  | 81054 | const char* keywords[] = { "needShowText", NULL };
| 81103 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setShowText", (char**)keywords, &pyobj_needShowText) && |  | 81055 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:plot_Plot2d.setShowText", (char**)keywords, &pyobj_needShowText) &&
| 81104 | pyopencv_to_safe(pyobj_needShowText, needShowText, ArgInfo("needShowText", 0)) ) |  | 81056 | pyopencv_to_safe(pyobj_needShowText, needShowText, ArgInfo("needShowText", 0)) )
| 81105 | { |  | 81057 | {
| 81106 | ERRWRAP2(_self_->setShowText(needShowText)); |  | 81058 | ERRWRAP2(_self_->setShowText(needShowText));
| 81107 | Py_RETURN_NONE; |  | 81059 | Py_RETURN_NONE;
| 81108 | } |  | 81060 | }
| 81109 |  |  | 81061 |
| 81110 | return NULL; |  | 81062 | return NULL;
| 81111 | } |  | 81063 | }
| 81112 |  |  | 81064 |
| 81113 |  |  | 81065 |
| 81114 |  |  | 81066 |
| 81115 | // Tables (plot_Plot2d) |  | 81067 | // Tables (plot_Plot2d)
| 81116 |  |  | 81068 |
| 81117 | static PyGetSetDef pyopencv_plot_Plot2d_getseters[] = |  | 81069 | static PyGetSetDef pyopencv_plot_Plot2d_getseters[] =
| 81118 | { |  | 81070 | {
| 81119 | {NULL} /* Sentinel */ |  | 81071 | {NULL} /* Sentinel */
| 81120 | }; |  | 81072 | };
| 81121 |  |  | 81073 |
| 81122 | static PyMethodDef pyopencv_plot_Plot2d_methods[] = |  | 81074 | static PyMethodDef pyopencv_plot_Plot2d_methods[] =
| 81123 | { |  | 81075 | {
| 81124 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_create_static, METH_STATIC), "create(data) -> retval\n. * @brief Creates Plot2d object\n. *\n. * @param data \\f$1xN\\f$ or \\f$Nx1\\f$ matrix containing \\f$Y\\f$ values of points to plot. \\f$X\\f$ values\n. * will be equal to indexes of correspondind elements in data matrix.\n\n\n\ncreate(dataX, dataY) -> retval\n. * @brief Creates Plot2d object\n. *\n. * @param dataX \\f$1xN\\f$ or \\f$Nx1\\f$ matrix \\f$X\\f$ values of points to plot.\n. * @param dataY \\f$1xN\\f$ or \\f$Nx1\\f$ matrix containing \\f$Y\\f$ values of points to plot."}, |  | 81076 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_create_static, METH_STATIC), "create(data) -> retval\n. * @brief Creates Plot2d object\n. *\n. * @param data \\f$1xN\\f$ or \\f$Nx1\\f$ matrix containing \\f$Y\\f$ values of points to plot. \\f$X\\f$ values\n. * will be equal to indexes of correspondind elements in data matrix.\n\n\n\ncreate(dataX, dataY) -> retval\n. * @brief Creates Plot2d object\n. *\n. * @param dataX \\f$1xN\\f$ or \\f$Nx1\\f$ matrix \\f$X\\f$ values of points to plot.\n. * @param dataY \\f$1xN\\f$ or \\f$Nx1\\f$ matrix containing \\f$Y\\f$ values of points to plot."},
| 81125 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_render, 0), "render([, _plotResult]) -> _plotResult\n."}, |  | 81077 | {"render", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_render, 0), "render([, _plotResult]) -> _plotResult\n."},
| 81126 | {"setGridLinesNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setGridLinesNumber, 0), "setGridLinesNumber(gridLinesNumber) -> None\n."}, |  | 81078 | {"setGridLinesNumber", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setGridLinesNumber, 0), "setGridLinesNumber(gridLinesNumber) -> None\n."},
| 81127 | {"setInvertOrientation", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setInvertOrientation, 0), "setInvertOrientation(_invertOrientation) -> None\n."}, |  | 81079 | {"setInvertOrientation", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setInvertOrientation, 0), "setInvertOrientation(_invertOrientation) -> None\n."},
| 81128 | {"setMaxX", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMaxX, 0), "setMaxX(_plotMaxX) -> None\n."}, |  | 81080 | {"setMaxX", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMaxX, 0), "setMaxX(_plotMaxX) -> None\n."},
| 81129 | {"setMaxY", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMaxY, 0), "setMaxY(_plotMaxY) -> None\n."}, |  | 81081 | {"setMaxY", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMaxY, 0), "setMaxY(_plotMaxY) -> None\n."},
| 81130 | {"setMinX", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMinX, 0), "setMinX(_plotMinX) -> None\n."}, |  | 81082 | {"setMinX", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMinX, 0), "setMinX(_plotMinX) -> None\n."},
| 81131 | {"setMinY", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMinY, 0), "setMinY(_plotMinY) -> None\n."}, |  | 81083 | {"setMinY", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setMinY, 0), "setMinY(_plotMinY) -> None\n."},
| 81132 | {"setNeedPlotLine", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setNeedPlotLine, 0), "setNeedPlotLine(_needPlotLine) -> None\n. * @brief Switches data visualization mode\n. *\n. * @param _needPlotLine if true then neighbour plot points will be connected by lines.\n. * In other case data will be plotted as a set of standalone points."}, |  | 81084 | {"setNeedPlotLine", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setNeedPlotLine, 0), "setNeedPlotLine(_needPlotLine) -> None\n. * @brief Switches data visualization mode\n. *\n. * @param _needPlotLine if true then neighbour plot points will be connected by lines.\n. * In other case data will be plotted as a set of standalone points."},
| 81133 | {"setPlotAxisColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotAxisColor, 0), "setPlotAxisColor(_plotAxisColor) -> None\n."}, |  | 81085 | {"setPlotAxisColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotAxisColor, 0), "setPlotAxisColor(_plotAxisColor) -> None\n."},
| 81134 | {"setPlotBackgroundColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotBackgroundColor, 0), "setPlotBackgroundColor(_plotBackgroundColor) -> None\n."}, |  | 81086 | {"setPlotBackgroundColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotBackgroundColor, 0), "setPlotBackgroundColor(_plotBackgroundColor) -> None\n."},
| 81135 | {"setPlotGridColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotGridColor, 0), "setPlotGridColor(_plotGridColor) -> None\n."}, |  | 81087 | {"setPlotGridColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotGridColor, 0), "setPlotGridColor(_plotGridColor) -> None\n."},
| 81136 | {"setPlotLineColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotLineColor, 0), "setPlotLineColor(_plotLineColor) -> None\n."}, |  | 81088 | {"setPlotLineColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotLineColor, 0), "setPlotLineColor(_plotLineColor) -> None\n."},
| 81137 | {"setPlotLineWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotLineWidth, 0), "setPlotLineWidth(_plotLineWidth) -> None\n."}, |  | 81089 | {"setPlotLineWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotLineWidth, 0), "setPlotLineWidth(_plotLineWidth) -> None\n."},
| 81138 | {"setPlotSize", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotSize, 0), "setPlotSize(_plotSizeWidth, _plotSizeHeight) -> None\n."}, |  | 81090 | {"setPlotSize", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotSize, 0), "setPlotSize(_plotSizeWidth, _plotSizeHeight) -> None\n."},
| 81139 | {"setPlotTextColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotTextColor, 0), "setPlotTextColor(_plotTextColor) -> None\n."}, |  | 81091 | {"setPlotTextColor", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPlotTextColor, 0), "setPlotTextColor(_plotTextColor) -> None\n."},
| 81140 | {"setPointIdxToPrint", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPointIdxToPrint, 0), "setPointIdxToPrint(pointIdx) -> None\n. * @brief Sets the index of a point which coordinates will be printed on the top left corner of the plot (if ShowText flag is true).\n. *\n. * @param pointIdx index of the required point in data array."}, |  | 81092 | {"setPointIdxToPrint", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setPointIdxToPrint, 0), "setPointIdxToPrint(pointIdx) -> None\n. * @brief Sets the index of a point which coordinates will be printed on the top left corner of the plot (if ShowText flag is true).\n. *\n. * @param pointIdx index of the required point in data array."},
| 81141 | {"setShowGrid", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setShowGrid, 0), "setShowGrid(needShowGrid) -> None\n."}, |  | 81093 | {"setShowGrid", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setShowGrid, 0), "setShowGrid(needShowGrid) -> None\n."},
| 81142 | {"setShowText", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setShowText, 0), "setShowText(needShowText) -> None\n."}, |  | 81094 | {"setShowText", CV_PY_FN_WITH_KW_(pyopencv_cv_plot_plot_Plot2d_setShowText, 0), "setShowText(needShowText) -> None\n."},
| 81143 |  |  | 81095 |
| 81144 | {NULL, NULL} |  | 81096 | {NULL, NULL}
| 81145 | }; |  | 81097 | };
| 81146 |  |  | 81098 |
| 81147 | // Converter (plot_Plot2d) |  | 81099 | // Converter (plot_Plot2d)
| 81148 |  |  | 81100 |
| 81149 | template<> |  | 81101 | template<>
| 81150 | struct PyOpenCV_Converter< Ptr<cv::plot::Plot2d> > |  | 81102 | struct PyOpenCV_Converter< Ptr<cv::plot::Plot2d> >
| 81151 | { |  | 81103 | {
| 81152 | static PyObject* from(const Ptr<cv::plot::Plot2d>& r) |  | 81104 | static PyObject* from(const Ptr<cv::plot::Plot2d>& r)
| 81153 | { |  | 81105 | {
| 81154 | return pyopencv_plot_Plot2d_Instance(r); |  | 81106 | return pyopencv_plot_Plot2d_Instance(r);
| 81155 | } |  | 81107 | }
| 81156 | static bool to(PyObject* src, Ptr<cv::plot::Plot2d>& dst, const ArgInfo& info) |  | 81108 | static bool to(PyObject* src, Ptr<cv::plot::Plot2d>& dst, const ArgInfo& info)
| 81157 | { |  | 81109 | {
| 81158 | if(!src || src == Py_None) |  | 81110 | if(!src || src == Py_None)
| 81159 | return true; |  | 81111 | return true;
| 81160 | Ptr<cv::plot::Plot2d> * dst_; |  | 81112 | Ptr<cv::plot::Plot2d> * dst_;
| 81161 | if (pyopencv_plot_Plot2d_getp(src, dst_)) |  | 81113 | if (pyopencv_plot_Plot2d_getp(src, dst_))
| 81162 | { |  | 81114 | {
| 81163 | dst = *dst_; |  | 81115 | dst = *dst_;
| 81164 | return true; |  | 81116 | return true;
| 81165 | } |  | 81117 | }
| 81166 |  |  | 81118 |
| 81167 | failmsg("Expected Ptr<cv::plot::Plot2d> for argument '%s'", info.name); |  | 81119 | failmsg("Expected Ptr<cv::plot::Plot2d> for argument '%s'", info.name);
| 81168 | return false; |  | 81120 | return false;
| 81169 | } |  | 81121 | }
| 81170 | }; |  | 81122 | };
| 81171 |  |  | 81123 |
| 81172 | //================================================================================ |  | 81124 | //================================================================================
| 81173 | // ppf_match_3d_ICP (Generic) |  | 81125 | // ppf_match_3d_ICP (Generic)
| 81174 | //================================================================================ |  | 81126 | //================================================================================
| 81175 |  |  | 81127 |
| 81176 | // GetSet (ppf_match_3d_ICP) |  | 81128 | // GetSet (ppf_match_3d_ICP)
| 81177 |  |  | 81129 |
| 81178 |  |  | 81130 |
| 81179 |  |  | 81131 |
| 81180 | // Methods (ppf_match_3d_ICP) |  | 81132 | // Methods (ppf_match_3d_ICP)
| 81181 |  |  | 81133 |
| 81182 | static int pyopencv_cv_ppf_match_3d_ppf_match_3d_ICP_ICP(pyopencv_ppf_match_3d_ICP_t* self, PyObject* py_args, PyObject* kw) |  | 81134 | static int pyopencv_cv_ppf_match_3d_ppf_match_3d_ICP_ICP(pyopencv_ppf_match_3d_ICP_t* self, PyObject* py_args, PyObject* kw)
| 81183 | { |  | 81135 | {
| 81184 | using namespace cv::ppf_match_3d; |  | 81136 | using namespace cv::ppf_match_3d;
| 81185 |  |  | 81137 |
| 81186 | pyPrepareArgumentConversionErrorsStorage(2); |  | 81138 | pyPrepareArgumentConversionErrorsStorage(2);
| 81187 |  |  | 81139 |
| 81188 | { |  | 81140 | {
| 81189 |  |  | 81141 |
| 81190 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 81142 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 81191 | { |  | 81143 | {
| 81192 | new (&(self->v)) Ptr<cv::ppf_match_3d::ICP>(); // init Ptr with placement new |  | 81144 | new (&(self->v)) Ptr<cv::ppf_match_3d::ICP>(); // init Ptr with placement new
| 81193 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::ICP())); |  | 81145 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::ICP()));
| 81194 | return 0; |  | 81146 | return 0;
| 81195 | } |  | 81147 | }
| 81196 |  |  | 81148 |
| 81197 |  |  | 81149 |
| 81198 | pyPopulateArgumentConversionErrors(); |  | 81150 | pyPopulateArgumentConversionErrors();
| 81199 | } |  | 81151 | }
| 81200 |  |  | 81152 |
| 81201 |  |  | 81153 |
| 81202 | { |  | 81154 | {
| 81203 | PyObject* pyobj_iterations = NULL; |  | 81155 | PyObject* pyobj_iterations = NULL;
| 81204 | int iterations=0; |  | 81156 | int iterations=0;
| 81205 | PyObject* pyobj_tolerence = NULL; |  | 81157 | PyObject* pyobj_tolerence = NULL;
| 81206 | float tolerence=0.05f; |  | 81158 | float tolerence=0.05f;
| 81207 | PyObject* pyobj_rejectionScale = NULL; |  | 81159 | PyObject* pyobj_rejectionScale = NULL;
| 81208 | float rejectionScale=2.5f; |  | 81160 | float rejectionScale=2.5f;
| 81209 | PyObject* pyobj_numLevels = NULL; |  | 81161 | PyObject* pyobj_numLevels = NULL;
| 81210 | int numLevels=6; |  | 81162 | int numLevels=6;
| 81211 | PyObject* pyobj_sampleType = NULL; |  | 81163 | PyObject* pyobj_sampleType = NULL;
| 81212 | int sampleType=ICP::ICP_SAMPLING_TYPE_UNIFORM; |  | 81164 | int sampleType=ICP::ICP_SAMPLING_TYPE_UNIFORM;
| 81213 | PyObject* pyobj_numMaxCorr = NULL; |  | 81165 | PyObject* pyobj_numMaxCorr = NULL;
| 81214 | int numMaxCorr=1; |  | 81166 | int numMaxCorr=1;
| 81215 |  |  | 81167 |
| 81216 | const char* keywords[] = { "iterations", "tolerence", "rejectionScale", "numLevels", "sampleType", "numMaxCorr", NULL }; |  | 81168 | const char* keywords[] = { "iterations", "tolerence", "rejectionScale", "numLevels", "sampleType", "numMaxCorr", NULL };
| 81217 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:ICP", (char**)keywords, &pyobj_iterations, &pyobj_tolerence, &pyobj_rejectionScale, &pyobj_numLevels, &pyobj_sampleType, &pyobj_numMaxCorr) && |  | 81169 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOO:ICP", (char**)keywords, &pyobj_iterations, &pyobj_tolerence, &pyobj_rejectionScale, &pyobj_numLevels, &pyobj_sampleType, &pyobj_numMaxCorr) &&
| 81218 | pyopencv_to_safe(pyobj_iterations, iterations, ArgInfo("iterations", 0)) && |  | 81170 | pyopencv_to_safe(pyobj_iterations, iterations, ArgInfo("iterations", 0)) &&
| 81219 | pyopencv_to_safe(pyobj_tolerence, tolerence, ArgInfo("tolerence", 0)) && |  | 81171 | pyopencv_to_safe(pyobj_tolerence, tolerence, ArgInfo("tolerence", 0)) &&
| 81220 | pyopencv_to_safe(pyobj_rejectionScale, rejectionScale, ArgInfo("rejectionScale", 0)) && |  | 81172 | pyopencv_to_safe(pyobj_rejectionScale, rejectionScale, ArgInfo("rejectionScale", 0)) &&
| 81221 | pyopencv_to_safe(pyobj_numLevels, numLevels, ArgInfo("numLevels", 0)) && |  | 81173 | pyopencv_to_safe(pyobj_numLevels, numLevels, ArgInfo("numLevels", 0)) &&
| 81222 | pyopencv_to_safe(pyobj_sampleType, sampleType, ArgInfo("sampleType", 0)) && |  | 81174 | pyopencv_to_safe(pyobj_sampleType, sampleType, ArgInfo("sampleType", 0)) &&
| 81223 | pyopencv_to_safe(pyobj_numMaxCorr, numMaxCorr, ArgInfo("numMaxCorr", 0)) ) |  | 81175 | pyopencv_to_safe(pyobj_numMaxCorr, numMaxCorr, ArgInfo("numMaxCorr", 0)) )
| 81224 | { |  | 81176 | {
| 81225 | new (&(self->v)) Ptr<cv::ppf_match_3d::ICP>(); // init Ptr with placement new |  | 81177 | new (&(self->v)) Ptr<cv::ppf_match_3d::ICP>(); // init Ptr with placement new
| 81226 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::ICP(iterations, tolerence, rejectionScale, numLevels, sampleType, numMaxCorr))); |  | 81178 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::ICP(iterations, tolerence, rejectionScale, numLevels, sampleType, numMaxCorr)));
| 81227 | return 0; |  | 81179 | return 0;
| 81228 | } |  | 81180 | }
| 81229 |  |  | 81181 |
| 81230 |  |  | 81182 |
| 81231 | pyPopulateArgumentConversionErrors(); |  | 81183 | pyPopulateArgumentConversionErrors();
| 81232 | } |  | 81184 | }
| 81233 | pyRaiseCVOverloadException("ICP"); |  | 81185 | pyRaiseCVOverloadException("ICP");
| 81234 |  |  | 81186 |
| 81235 | return -1; |  | 81187 | return -1;
| 81236 | } |  | 81188 | }
| 81237 |  |  | 81189 |
| 81238 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_ICP_registerModelToScene(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81190 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_ICP_registerModelToScene(PyObject* self, PyObject* py_args, PyObject* kw)
| 81239 | { |  | 81191 | {
| 81240 | using namespace cv::ppf_match_3d; |  | 81192 | using namespace cv::ppf_match_3d;
| 81241 |  |  | 81193 |
| 81242 |  |  | 81194 |
| 81243 | Ptr<cv::ppf_match_3d::ICP> * self1 = 0; |  | 81195 | Ptr<cv::ppf_match_3d::ICP> * self1 = 0;
| 81244 | if (!pyopencv_ppf_match_3d_ICP_getp(self, self1)) |  | 81196 | if (!pyopencv_ppf_match_3d_ICP_getp(self, self1))
| 81245 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_ICP' or its derivative)"); |  | 81197 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_ICP' or its derivative)");
| 81246 | Ptr<cv::ppf_match_3d::ICP> _self_ = *(self1); |  | 81198 | Ptr<cv::ppf_match_3d::ICP> _self_ = *(self1);
| 81247 | pyPrepareArgumentConversionErrorsStorage(2); |  | 81199 | pyPrepareArgumentConversionErrorsStorage(2);
| 81248 |  |  | 81200 |
| 81249 | { |  | 81201 | {
| 81250 | PyObject* pyobj_srcPC = NULL; |  | 81202 | PyObject* pyobj_srcPC = NULL;
| 81251 | Mat srcPC; |  | 81203 | Mat srcPC;
| 81252 | PyObject* pyobj_dstPC = NULL; |  | 81204 | PyObject* pyobj_dstPC = NULL;
| 81253 | Mat dstPC; |  | 81205 | Mat dstPC;
| 81254 | double residual; |  | 81206 | double residual;
| 81255 | Matx44d pose; |  | 81207 | Matx44d pose;
| 81256 | int retval; |  | 81208 | int retval;
| 81257 |  |  | 81209 |
| 81258 | const char* keywords[] = { "srcPC", "dstPC", NULL }; |  | 81210 | const char* keywords[] = { "srcPC", "dstPC", NULL };
| 81259 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ppf_match_3d_ICP.registerModelToScene", (char**)keywords, &pyobj_srcPC, &pyobj_dstPC) && |  | 81211 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ppf_match_3d_ICP.registerModelToScene", (char**)keywords, &pyobj_srcPC, &pyobj_dstPC) &&
| 81260 | pyopencv_to_safe(pyobj_srcPC, srcPC, ArgInfo("srcPC", 0)) && |  | 81212 | pyopencv_to_safe(pyobj_srcPC, srcPC, ArgInfo("srcPC", 0)) &&
| 81261 | pyopencv_to_safe(pyobj_dstPC, dstPC, ArgInfo("dstPC", 0)) ) |  | 81213 | pyopencv_to_safe(pyobj_dstPC, dstPC, ArgInfo("dstPC", 0)) )
| 81262 | { |  | 81214 | {
| 81263 | ERRWRAP2(retval = _self_->registerModelToScene(srcPC, dstPC, residual, pose)); |  | 81215 | ERRWRAP2(retval = _self_->registerModelToScene(srcPC, dstPC, residual, pose));
| 81264 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(residual), pyopencv_from(pose)); |  | 81216 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(residual), pyopencv_from(pose));
| 81265 | } |  | 81217 | }
| 81266 |  |  | 81218 |
| 81267 |  |  | 81219 |
| 81268 | pyPopulateArgumentConversionErrors(); |  | 81220 | pyPopulateArgumentConversionErrors();
| 81269 | } |  | 81221 | }
| 81270 |  |  | 81222 |
| 81271 |  |  | 81223 |
| 81272 | { |  | 81224 | {
| 81273 | PyObject* pyobj_srcPC = NULL; |  | 81225 | PyObject* pyobj_srcPC = NULL;
| 81274 | Mat srcPC; |  | 81226 | Mat srcPC;
| 81275 | PyObject* pyobj_dstPC = NULL; |  | 81227 | PyObject* pyobj_dstPC = NULL;
| 81276 | Mat dstPC; |  | 81228 | Mat dstPC;
| 81277 | PyObject* pyobj_poses = NULL; |  | 81229 | PyObject* pyobj_poses = NULL;
| 81278 | vector_Pose3DPtr poses; |  | 81230 | vector_Pose3DPtr poses;
| 81279 | int retval; |  | 81231 | int retval;
| 81280 |  |  | 81232 |
| 81281 | const char* keywords[] = { "srcPC", "dstPC", "poses", NULL }; |  | 81233 | const char* keywords[] = { "srcPC", "dstPC", "poses", NULL };
| 81282 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ppf_match_3d_ICP.registerModelToScene", (char**)keywords, &pyobj_srcPC, &pyobj_dstPC, &pyobj_poses) && |  | 81234 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:ppf_match_3d_ICP.registerModelToScene", (char**)keywords, &pyobj_srcPC, &pyobj_dstPC, &pyobj_poses) &&
| 81283 | pyopencv_to_safe(pyobj_srcPC, srcPC, ArgInfo("srcPC", 0)) && |  | 81235 | pyopencv_to_safe(pyobj_srcPC, srcPC, ArgInfo("srcPC", 0)) &&
| 81284 | pyopencv_to_safe(pyobj_dstPC, dstPC, ArgInfo("dstPC", 0)) && |  | 81236 | pyopencv_to_safe(pyobj_dstPC, dstPC, ArgInfo("dstPC", 0)) &&
| 81285 | pyopencv_to_safe(pyobj_poses, poses, ArgInfo("poses", 1)) ) |  | 81237 | pyopencv_to_safe(pyobj_poses, poses, ArgInfo("poses", 1)) )
| 81286 | { |  | 81238 | {
| 81287 | ERRWRAP2(retval = _self_->registerModelToScene(srcPC, dstPC, poses)); |  | 81239 | ERRWRAP2(retval = _self_->registerModelToScene(srcPC, dstPC, poses));
| 81288 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(poses)); |  | 81240 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(poses));
| 81289 | } |  | 81241 | }
| 81290 |  |  | 81242 |
| 81291 |  |  | 81243 |
| 81292 | pyPopulateArgumentConversionErrors(); |  | 81244 | pyPopulateArgumentConversionErrors();
| 81293 | } |  | 81245 | }
| 81294 | pyRaiseCVOverloadException("registerModelToScene"); |  | 81246 | pyRaiseCVOverloadException("registerModelToScene");
| 81295 |  |  | 81247 |
| 81296 | return NULL; |  | 81248 | return NULL;
| 81297 | } |  | 81249 | }
| 81298 |  |  | 81250 |
| 81299 |  |  | 81251 |
| 81300 |  |  | 81252 |
| 81301 | // Tables (ppf_match_3d_ICP) |  | 81253 | // Tables (ppf_match_3d_ICP)
| 81302 |  |  | 81254 |
| 81303 | static PyGetSetDef pyopencv_ppf_match_3d_ICP_getseters[] = |  | 81255 | static PyGetSetDef pyopencv_ppf_match_3d_ICP_getseters[] =
| 81304 | { |  | 81256 | {
| 81305 | {NULL} /* Sentinel */ |  | 81257 | {NULL} /* Sentinel */
| 81306 | }; |  | 81258 | };
| 81307 |  |  | 81259 |
| 81308 | static PyMethodDef pyopencv_ppf_match_3d_ICP_methods[] = |  | 81260 | static PyMethodDef pyopencv_ppf_match_3d_ICP_methods[] =
| 81309 | { |  | 81261 | {
| 81310 | {"registerModelToScene", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_ICP_registerModelToScene, 0), "registerModelToScene(srcPC, dstPC) -> retval, residual, pose\n. * \\brief Perform registration\n. *\n. * @param [in] srcPC The input point cloud for the model. Expected to have the normals (Nx6). Currently,\n. * CV_32F is the only supported data type.\n. * @param [in] dstPC The input point cloud for the scene. It is assumed that the model is registered on the scene. Scene remains static. Expected to have the normals (Nx6). Currently, CV_32F is the only supported data type.\n. * @param [out] residual The output registration error.\n. * @param [out] pose Transformation between srcPC and dstPC.\n. * \\return On successful termination, the function returns 0.\n. *\n. * \\details It is assumed that the model is registered on the scene. Scene remains static, while the model transforms. The output poses transform the models onto the scene. Because of the point to plane minimization, the scene is expected to have the normals available. Expected to have the normals (Nx6).\n\n\n\nregisterModelToScene(srcPC, dstPC, poses) -> retval, poses\n. * \\brief Perform registration with multiple initial poses\n. *\n. * @param [in] srcPC The input point cloud for the model. Expected to have the normals (Nx6). Currently,\n. * CV_32F is the only supported data type.\n. * @param [in] dstPC The input point cloud for the scene. Currently, CV_32F is the only supported data type.\n. * @param [in,out] poses Input poses to start with but also list output of poses.\n. * \\return On successful termination, the function returns 0.\n. *\n. * \\details It is assumed that the model is registered on the scene. Scene remains static, while the model transforms. The output poses transform the models onto the scene. Because of the point to plane minimization, the scene is expected to have the normals available. Expected to have the normals (Nx6)."}, |  | 81262 | {"registerModelToScene", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_ICP_registerModelToScene, 0), "registerModelToScene(srcPC, dstPC) -> retval, residual, pose\n. * \\brief Perform registration\n. *\n. * @param [in] srcPC The input point cloud for the model. Expected to have the normals (Nx6). Currently,\n. * CV_32F is the only supported data type.\n. * @param [in] dstPC The input point cloud for the scene. It is assumed that the model is registered on the scene. Scene remains static. Expected to have the normals (Nx6). Currently, CV_32F is the only supported data type.\n. * @param [out] residual The output registration error.\n. * @param [out] pose Transformation between srcPC and dstPC.\n. * \\return On successful termination, the function returns 0.\n. *\n. * \\details It is assumed that the model is registered on the scene. Scene remains static, while the model transforms. The output poses transform the models onto the scene. Because of the point to plane minimization, the scene is expected to have the normals available. Expected to have the normals (Nx6).\n\n\n\nregisterModelToScene(srcPC, dstPC, poses) -> retval, poses\n. * \\brief Perform registration with multiple initial poses\n. *\n. * @param [in] srcPC The input point cloud for the model. Expected to have the normals (Nx6). Currently,\n. * CV_32F is the only supported data type.\n. * @param [in] dstPC The input point cloud for the scene. Currently, CV_32F is the only supported data type.\n. * @param [in,out] poses Input poses to start with but also list output of poses.\n. * \\return On successful termination, the function returns 0.\n. *\n. * \\details It is assumed that the model is registered on the scene. Scene remains static, while the model transforms. The output poses transform the models onto the scene. Because of the point to plane minimization, the scene is expected to have the normals available. Expected to have the normals (Nx6)."},
| 81311 |  |  | 81263 |
| 81312 | {NULL, NULL} |  | 81264 | {NULL, NULL}
| 81313 | }; |  | 81265 | };
| 81314 |  |  | 81266 |
| 81315 | // Converter (ppf_match_3d_ICP) |  | 81267 | // Converter (ppf_match_3d_ICP)
| 81316 |  |  | 81268 |
| 81317 | template<> |  | 81269 | template<>
| 81318 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::ICP> > |  | 81270 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::ICP> >
| 81319 | { |  | 81271 | {
| 81320 | static PyObject* from(const Ptr<cv::ppf_match_3d::ICP>& r) |  | 81272 | static PyObject* from(const Ptr<cv::ppf_match_3d::ICP>& r)
| 81321 | { |  | 81273 | {
| 81322 | return pyopencv_ppf_match_3d_ICP_Instance(r); |  | 81274 | return pyopencv_ppf_match_3d_ICP_Instance(r);
| 81323 | } |  | 81275 | }
| 81324 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::ICP>& dst, const ArgInfo& info) |  | 81276 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::ICP>& dst, const ArgInfo& info)
| 81325 | { |  | 81277 | {
| 81326 | if(!src || src == Py_None) |  | 81278 | if(!src || src == Py_None)
| 81327 | return true; |  | 81279 | return true;
| 81328 | Ptr<cv::ppf_match_3d::ICP> * dst_; |  | 81280 | Ptr<cv::ppf_match_3d::ICP> * dst_;
| 81329 | if (pyopencv_ppf_match_3d_ICP_getp(src, dst_)) |  | 81281 | if (pyopencv_ppf_match_3d_ICP_getp(src, dst_))
| 81330 | { |  | 81282 | {
| 81331 | dst = *dst_; |  | 81283 | dst = *dst_;
| 81332 | return true; |  | 81284 | return true;
| 81333 | } |  | 81285 | }
| 81334 |  |  | 81286 |
| 81335 | failmsg("Expected Ptr<cv::ppf_match_3d::ICP> for argument '%s'", info.name); |  | 81287 | failmsg("Expected Ptr<cv::ppf_match_3d::ICP> for argument '%s'", info.name);
| 81336 | return false; |  | 81288 | return false;
| 81337 | } |  | 81289 | }
| 81338 | }; |  | 81290 | };
| 81339 |  |  | 81291 |
| 81340 | //================================================================================ |  | 81292 | //================================================================================
| 81341 | // ppf_match_3d_PPF3DDetector (Generic) |  | 81293 | // ppf_match_3d_PPF3DDetector (Generic)
| 81342 | //================================================================================ |  | 81294 | //================================================================================
| 81343 |  |  | 81295 |
| 81344 | // GetSet (ppf_match_3d_PPF3DDetector) |  | 81296 | // GetSet (ppf_match_3d_PPF3DDetector)
| 81345 |  |  | 81297 |
| 81346 |  |  | 81298 |
| 81347 |  |  | 81299 |
| 81348 | // Methods (ppf_match_3d_PPF3DDetector) |  | 81300 | // Methods (ppf_match_3d_PPF3DDetector)
| 81349 |  |  | 81301 |
| 81350 | static int pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_PPF3DDetector(pyopencv_ppf_match_3d_PPF3DDetector_t* self, PyObject* py_args, PyObject* kw) |  | 81302 | static int pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_PPF3DDetector(pyopencv_ppf_match_3d_PPF3DDetector_t* self, PyObject* py_args, PyObject* kw)
| 81351 | { |  | 81303 | {
| 81352 | using namespace cv::ppf_match_3d; |  | 81304 | using namespace cv::ppf_match_3d;
| 81353 |  |  | 81305 |
| 81354 | pyPrepareArgumentConversionErrorsStorage(2); |  | 81306 | pyPrepareArgumentConversionErrorsStorage(2);
| 81355 |  |  | 81307 |
| 81356 | { |  | 81308 | {
| 81357 |  |  | 81309 |
| 81358 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 81310 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 81359 | { |  | 81311 | {
| 81360 | new (&(self->v)) Ptr<cv::ppf_match_3d::PPF3DDetector>(); // init Ptr with placement new |  | 81312 | new (&(self->v)) Ptr<cv::ppf_match_3d::PPF3DDetector>(); // init Ptr with placement new
| 81361 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::PPF3DDetector())); |  | 81313 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::PPF3DDetector()));
| 81362 | return 0; |  | 81314 | return 0;
| 81363 | } |  | 81315 | }
| 81364 |  |  | 81316 |
| 81365 |  |  | 81317 |
| 81366 | pyPopulateArgumentConversionErrors(); |  | 81318 | pyPopulateArgumentConversionErrors();
| 81367 | } |  | 81319 | }
| 81368 |  |  | 81320 |
| 81369 |  |  | 81321 |
| 81370 | { |  | 81322 | {
| 81371 | PyObject* pyobj_relativeSamplingStep = NULL; |  | 81323 | PyObject* pyobj_relativeSamplingStep = NULL;
| 81372 | double relativeSamplingStep=0; |  | 81324 | double relativeSamplingStep=0;
| 81373 | PyObject* pyobj_relativeDistanceStep = NULL; |  | 81325 | PyObject* pyobj_relativeDistanceStep = NULL;
| 81374 | double relativeDistanceStep=0.05; |  | 81326 | double relativeDistanceStep=0.05;
| 81375 | PyObject* pyobj_numAngles = NULL; |  | 81327 | PyObject* pyobj_numAngles = NULL;
| 81376 | double numAngles=30; |  | 81328 | double numAngles=30;
| 81377 |  |  | 81329 |
| 81378 | const char* keywords[] = { "relativeSamplingStep", "relativeDistanceStep", "numAngles", NULL }; |  | 81330 | const char* keywords[] = { "relativeSamplingStep", "relativeDistanceStep", "numAngles", NULL };
| 81379 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:PPF3DDetector", (char**)keywords, &pyobj_relativeSamplingStep, &pyobj_relativeDistanceStep, &pyobj_numAngles) && |  | 81331 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:PPF3DDetector", (char**)keywords, &pyobj_relativeSamplingStep, &pyobj_relativeDistanceStep, &pyobj_numAngles) &&
| 81380 | pyopencv_to_safe(pyobj_relativeSamplingStep, relativeSamplingStep, ArgInfo("relativeSamplingStep", 0)) && |  | 81332 | pyopencv_to_safe(pyobj_relativeSamplingStep, relativeSamplingStep, ArgInfo("relativeSamplingStep", 0)) &&
| 81381 | pyopencv_to_safe(pyobj_relativeDistanceStep, relativeDistanceStep, ArgInfo("relativeDistanceStep", 0)) && |  | 81333 | pyopencv_to_safe(pyobj_relativeDistanceStep, relativeDistanceStep, ArgInfo("relativeDistanceStep", 0)) &&
| 81382 | pyopencv_to_safe(pyobj_numAngles, numAngles, ArgInfo("numAngles", 0)) ) |  | 81334 | pyopencv_to_safe(pyobj_numAngles, numAngles, ArgInfo("numAngles", 0)) )
| 81383 | { |  | 81335 | {
| 81384 | new (&(self->v)) Ptr<cv::ppf_match_3d::PPF3DDetector>(); // init Ptr with placement new |  | 81336 | new (&(self->v)) Ptr<cv::ppf_match_3d::PPF3DDetector>(); // init Ptr with placement new
| 81385 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::PPF3DDetector(relativeSamplingStep, relativeDistanceStep, numAngles))); |  | 81337 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::PPF3DDetector(relativeSamplingStep, relativeDistanceStep, numAngles)));
| 81386 | return 0; |  | 81338 | return 0;
| 81387 | } |  | 81339 | }
| 81388 |  |  | 81340 |
| 81389 |  |  | 81341 |
| 81390 | pyPopulateArgumentConversionErrors(); |  | 81342 | pyPopulateArgumentConversionErrors();
| 81391 | } |  | 81343 | }
| 81392 | pyRaiseCVOverloadException("PPF3DDetector"); |  | 81344 | pyRaiseCVOverloadException("PPF3DDetector");
| 81393 |  |  | 81345 |
| 81394 | return -1; |  | 81346 | return -1;
| 81395 | } |  | 81347 | }
| 81396 |  |  | 81348 |
| 81397 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_match(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81349 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_match(PyObject* self, PyObject* py_args, PyObject* kw)
| 81398 | { |  | 81350 | {
| 81399 | using namespace cv::ppf_match_3d; |  | 81351 | using namespace cv::ppf_match_3d;
| 81400 |  |  | 81352 |
| 81401 |  |  | 81353 |
| 81402 | Ptr<cv::ppf_match_3d::PPF3DDetector> * self1 = 0; |  | 81354 | Ptr<cv::ppf_match_3d::PPF3DDetector> * self1 = 0;
| 81403 | if (!pyopencv_ppf_match_3d_PPF3DDetector_getp(self, self1)) |  | 81355 | if (!pyopencv_ppf_match_3d_PPF3DDetector_getp(self, self1))
| 81404 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_PPF3DDetector' or its derivative)"); |  | 81356 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_PPF3DDetector' or its derivative)");
| 81405 | Ptr<cv::ppf_match_3d::PPF3DDetector> _self_ = *(self1); |  | 81357 | Ptr<cv::ppf_match_3d::PPF3DDetector> _self_ = *(self1);
| 81406 | PyObject* pyobj_scene = NULL; |  | 81358 | PyObject* pyobj_scene = NULL;
| 81407 | Mat scene; |  | 81359 | Mat scene;
| 81408 | vector_Pose3DPtr results; |  | 81360 | vector_Pose3DPtr results;
| 81409 | PyObject* pyobj_relativeSceneSampleStep = NULL; |  | 81361 | PyObject* pyobj_relativeSceneSampleStep = NULL;
| 81410 | double relativeSceneSampleStep=1.0/5.0; |  | 81362 | double relativeSceneSampleStep=1.0/5.0;
| 81411 | PyObject* pyobj_relativeSceneDistance = NULL; |  | 81363 | PyObject* pyobj_relativeSceneDistance = NULL;
| 81412 | double relativeSceneDistance=0.03; |  | 81364 | double relativeSceneDistance=0.03;
| 81413 |  |  | 81365 |
| 81414 | const char* keywords[] = { "scene", "relativeSceneSampleStep", "relativeSceneDistance", NULL }; |  | 81366 | const char* keywords[] = { "scene", "relativeSceneSampleStep", "relativeSceneDistance", NULL };
| 81415 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ppf_match_3d_PPF3DDetector.match", (char**)keywords, &pyobj_scene, &pyobj_relativeSceneSampleStep, &pyobj_relativeSceneDistance) && |  | 81367 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:ppf_match_3d_PPF3DDetector.match", (char**)keywords, &pyobj_scene, &pyobj_relativeSceneSampleStep, &pyobj_relativeSceneDistance) &&
| 81416 | pyopencv_to_safe(pyobj_scene, scene, ArgInfo("scene", 0)) && |  | 81368 | pyopencv_to_safe(pyobj_scene, scene, ArgInfo("scene", 0)) &&
| 81417 | pyopencv_to_safe(pyobj_relativeSceneSampleStep, relativeSceneSampleStep, ArgInfo("relativeSceneSampleStep", 0)) && |  | 81369 | pyopencv_to_safe(pyobj_relativeSceneSampleStep, relativeSceneSampleStep, ArgInfo("relativeSceneSampleStep", 0)) &&
| 81418 | pyopencv_to_safe(pyobj_relativeSceneDistance, relativeSceneDistance, ArgInfo("relativeSceneDistance", 0)) ) |  | 81370 | pyopencv_to_safe(pyobj_relativeSceneDistance, relativeSceneDistance, ArgInfo("relativeSceneDistance", 0)) )
| 81419 | { |  | 81371 | {
| 81420 | ERRWRAP2(_self_->match(scene, results, relativeSceneSampleStep, relativeSceneDistance)); |  | 81372 | ERRWRAP2(_self_->match(scene, results, relativeSceneSampleStep, relativeSceneDistance));
| 81421 | return pyopencv_from(results); |  | 81373 | return pyopencv_from(results);
| 81422 | } |  | 81374 | }
| 81423 |  |  | 81375 |
| 81424 | return NULL; |  | 81376 | return NULL;
| 81425 | } |  | 81377 | }
| 81426 |  |  | 81378 |
| 81427 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_trainModel(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81379 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_trainModel(PyObject* self, PyObject* py_args, PyObject* kw)
| 81428 | { |  | 81380 | {
| 81429 | using namespace cv::ppf_match_3d; |  | 81381 | using namespace cv::ppf_match_3d;
| 81430 |  |  | 81382 |
| 81431 |  |  | 81383 |
| 81432 | Ptr<cv::ppf_match_3d::PPF3DDetector> * self1 = 0; |  | 81384 | Ptr<cv::ppf_match_3d::PPF3DDetector> * self1 = 0;
| 81433 | if (!pyopencv_ppf_match_3d_PPF3DDetector_getp(self, self1)) |  | 81385 | if (!pyopencv_ppf_match_3d_PPF3DDetector_getp(self, self1))
| 81434 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_PPF3DDetector' or its derivative)"); |  | 81386 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_PPF3DDetector' or its derivative)");
| 81435 | Ptr<cv::ppf_match_3d::PPF3DDetector> _self_ = *(self1); |  | 81387 | Ptr<cv::ppf_match_3d::PPF3DDetector> _self_ = *(self1);
| 81436 | PyObject* pyobj_Model = NULL; |  | 81388 | PyObject* pyobj_Model = NULL;
| 81437 | Mat Model; |  | 81389 | Mat Model;
| 81438 |  |  | 81390 |
| 81439 | const char* keywords[] = { "Model", NULL }; |  | 81391 | const char* keywords[] = { "Model", NULL };
| 81440 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ppf_match_3d_PPF3DDetector.trainModel", (char**)keywords, &pyobj_Model) && |  | 81392 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ppf_match_3d_PPF3DDetector.trainModel", (char**)keywords, &pyobj_Model) &&
| 81441 | pyopencv_to_safe(pyobj_Model, Model, ArgInfo("Model", 0)) ) |  | 81393 | pyopencv_to_safe(pyobj_Model, Model, ArgInfo("Model", 0)) )
| 81442 | { |  | 81394 | {
| 81443 | ERRWRAP2(_self_->trainModel(Model)); |  | 81395 | ERRWRAP2(_self_->trainModel(Model));
| 81444 | Py_RETURN_NONE; |  | 81396 | Py_RETURN_NONE;
| 81445 | } |  | 81397 | }
| 81446 |  |  | 81398 |
| 81447 | return NULL; |  | 81399 | return NULL;
| 81448 | } |  | 81400 | }
| 81449 |  |  | 81401 |
| 81450 |  |  | 81402 |
| 81451 |  |  | 81403 |
| 81452 | // Tables (ppf_match_3d_PPF3DDetector) |  | 81404 | // Tables (ppf_match_3d_PPF3DDetector)
| 81453 |  |  | 81405 |
| 81454 | static PyGetSetDef pyopencv_ppf_match_3d_PPF3DDetector_getseters[] = |  | 81406 | static PyGetSetDef pyopencv_ppf_match_3d_PPF3DDetector_getseters[] =
| 81455 | { |  | 81407 | {
| 81456 | {NULL} /* Sentinel */ |  | 81408 | {NULL} /* Sentinel */
| 81457 | }; |  | 81409 | };
| 81458 |  |  | 81410 |
| 81459 | static PyMethodDef pyopencv_ppf_match_3d_PPF3DDetector_methods[] = |  | 81411 | static PyMethodDef pyopencv_ppf_match_3d_PPF3DDetector_methods[] =
| 81460 | { |  | 81412 | {
| 81461 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_match, 0), "match(scene[, relativeSceneSampleStep[, relativeSceneDistance]]) -> results\n. * \\brief Matches a trained model across a provided scene.\n. *\n. * @param [in] scene Point cloud for the scene\n. * @param [out] results List of output poses\n. * @param [in] relativeSceneSampleStep The ratio of scene points to be used for the matching after sampling with relativeSceneDistance. For example, if this value is set to 1.0/5.0, every 5th point from the scene is used for pose estimation. This parameter allows an easy trade-off between speed and accuracy of the matching. Increasing the value leads to less points being used and in turn to a faster but less accurate pose computation. Decreasing the value has the inverse effect.\n. * @param [in] relativeSceneDistance Set the distance threshold relative to the diameter of the model. This parameter is equivalent to relativeSamplingStep in the training stage. This parameter acts like a prior sampling with the relativeSceneSampleStep parameter."}, |  | 81413 | {"match", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_match, 0), "match(scene[, relativeSceneSampleStep[, relativeSceneDistance]]) -> results\n. * \\brief Matches a trained model across a provided scene.\n. *\n. * @param [in] scene Point cloud for the scene\n. * @param [out] results List of output poses\n. * @param [in] relativeSceneSampleStep The ratio of scene points to be used for the matching after sampling with relativeSceneDistance. For example, if this value is set to 1.0/5.0, every 5th point from the scene is used for pose estimation. This parameter allows an easy trade-off between speed and accuracy of the matching. Increasing the value leads to less points being used and in turn to a faster but less accurate pose computation. Decreasing the value has the inverse effect.\n. * @param [in] relativeSceneDistance Set the distance threshold relative to the diameter of the model. This parameter is equivalent to relativeSamplingStep in the training stage. This parameter acts like a prior sampling with the relativeSceneSampleStep parameter."},
| 81462 | {"trainModel", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_trainModel, 0), "trainModel(Model) -> None\n. * \\brief Trains a new model.\n. *\n. * @param [in] Model The input point cloud with normals (Nx6)\n. *\n. * \\details Uses the parameters set in the constructor to downsample and learn a new model. When the model is learnt, the instance gets ready for calling \"match\"."}, |  | 81414 | {"trainModel", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_PPF3DDetector_trainModel, 0), "trainModel(Model) -> None\n. * \\brief Trains a new model.\n. *\n. * @param [in] Model The input point cloud with normals (Nx6)\n. *\n. * \\details Uses the parameters set in the constructor to downsample and learn a new model. When the model is learnt, the instance gets ready for calling \"match\"."},
| 81463 |  |  | 81415 |
| 81464 | {NULL, NULL} |  | 81416 | {NULL, NULL}
| 81465 | }; |  | 81417 | };
| 81466 |  |  | 81418 |
| 81467 | // Converter (ppf_match_3d_PPF3DDetector) |  | 81419 | // Converter (ppf_match_3d_PPF3DDetector)
| 81468 |  |  | 81420 |
| 81469 | template<> |  | 81421 | template<>
| 81470 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::PPF3DDetector> > |  | 81422 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::PPF3DDetector> >
| 81471 | { |  | 81423 | {
| 81472 | static PyObject* from(const Ptr<cv::ppf_match_3d::PPF3DDetector>& r) |  | 81424 | static PyObject* from(const Ptr<cv::ppf_match_3d::PPF3DDetector>& r)
| 81473 | { |  | 81425 | {
| 81474 | return pyopencv_ppf_match_3d_PPF3DDetector_Instance(r); |  | 81426 | return pyopencv_ppf_match_3d_PPF3DDetector_Instance(r);
| 81475 | } |  | 81427 | }
| 81476 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::PPF3DDetector>& dst, const ArgInfo& info) |  | 81428 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::PPF3DDetector>& dst, const ArgInfo& info)
| 81477 | { |  | 81429 | {
| 81478 | if(!src || src == Py_None) |  | 81430 | if(!src || src == Py_None)
| 81479 | return true; |  | 81431 | return true;
| 81480 | Ptr<cv::ppf_match_3d::PPF3DDetector> * dst_; |  | 81432 | Ptr<cv::ppf_match_3d::PPF3DDetector> * dst_;
| 81481 | if (pyopencv_ppf_match_3d_PPF3DDetector_getp(src, dst_)) |  | 81433 | if (pyopencv_ppf_match_3d_PPF3DDetector_getp(src, dst_))
| 81482 | { |  | 81434 | {
| 81483 | dst = *dst_; |  | 81435 | dst = *dst_;
| 81484 | return true; |  | 81436 | return true;
| 81485 | } |  | 81437 | }
| 81486 |  |  | 81438 |
| 81487 | failmsg("Expected Ptr<cv::ppf_match_3d::PPF3DDetector> for argument '%s'", info.name); |  | 81439 | failmsg("Expected Ptr<cv::ppf_match_3d::PPF3DDetector> for argument '%s'", info.name);
| 81488 | return false; |  | 81440 | return false;
| 81489 | } |  | 81441 | }
| 81490 | }; |  | 81442 | };
| 81491 |  |  | 81443 |
| 81492 | //================================================================================ |  | 81444 | //================================================================================
| 81493 | // ppf_match_3d_Pose3D (Generic) |  | 81445 | // ppf_match_3d_Pose3D (Generic)
| 81494 | //================================================================================ |  | 81446 | //================================================================================
| 81495 |  |  | 81447 |
| 81496 | // GetSet (ppf_match_3d_Pose3D) |  | 81448 | // GetSet (ppf_match_3d_Pose3D)
| 81497 |  |  | 81449 |
| 81498 |  |  | 81450 |
| 81499 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_alpha(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81451 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_alpha(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81500 | { |  | 81452 | {
| 81501 | return pyopencv_from(p->v->alpha); |  | 81453 | return pyopencv_from(p->v->alpha);
| 81502 | } |  | 81454 | }
| 81503 |  |  | 81455 |
| 81504 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_angle(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81456 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_angle(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81505 | { |  | 81457 | {
| 81506 | return pyopencv_from(p->v->angle); |  | 81458 | return pyopencv_from(p->v->angle);
| 81507 | } |  | 81459 | }
| 81508 |  |  | 81460 |
| 81509 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_modelIndex(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81461 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_modelIndex(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81510 | { |  | 81462 | {
| 81511 | return pyopencv_from(p->v->modelIndex); |  | 81463 | return pyopencv_from(p->v->modelIndex);
| 81512 | } |  | 81464 | }
| 81513 |  |  | 81465 |
| 81514 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_numVotes(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81466 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_numVotes(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81515 | { |  | 81467 | {
| 81516 | return pyopencv_from(p->v->numVotes); |  | 81468 | return pyopencv_from(p->v->numVotes);
| 81517 | } |  | 81469 | }
| 81518 |  |  | 81470 |
| 81519 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_pose(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81471 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_pose(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81520 | { |  | 81472 | {
| 81521 | return pyopencv_from(p->v->pose); |  | 81473 | return pyopencv_from(p->v->pose);
| 81522 | } |  | 81474 | }
| 81523 |  |  | 81475 |
| 81524 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_q(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81476 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_q(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81525 | { |  | 81477 | {
| 81526 | return pyopencv_from(p->v->q); |  | 81478 | return pyopencv_from(p->v->q);
| 81527 | } |  | 81479 | }
| 81528 |  |  | 81480 |
| 81529 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_residual(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81481 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_residual(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81530 | { |  | 81482 | {
| 81531 | return pyopencv_from(p->v->residual); |  | 81483 | return pyopencv_from(p->v->residual);
| 81532 | } |  | 81484 | }
| 81533 |  |  | 81485 |
| 81534 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_t(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure) |  | 81486 | static PyObject* pyopencv_ppf_match_3d_Pose3D_get_t(pyopencv_ppf_match_3d_Pose3D_t* p, void *closure)
| 81535 | { |  | 81487 | {
| 81536 | return pyopencv_from(p->v->t); |  | 81488 | return pyopencv_from(p->v->t);
| 81537 | } |  | 81489 | }
| 81538 |  |  | 81490 |
| 81539 |  |  | 81491 |
| 81540 | // Methods (ppf_match_3d_Pose3D) |  | 81492 | // Methods (ppf_match_3d_Pose3D)
| 81541 |  |  | 81493 |
| 81542 | static int pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_Pose3D(pyopencv_ppf_match_3d_Pose3D_t* self, PyObject* py_args, PyObject* kw) |  | 81494 | static int pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_Pose3D(pyopencv_ppf_match_3d_Pose3D_t* self, PyObject* py_args, PyObject* kw)
| 81543 | { |  | 81495 | {
| 81544 | using namespace cv::ppf_match_3d; |  | 81496 | using namespace cv::ppf_match_3d;
| 81545 |  |  | 81497 |
| 81546 | pyPrepareArgumentConversionErrorsStorage(2); |  | 81498 | pyPrepareArgumentConversionErrorsStorage(2);
| 81547 |  |  | 81499 |
| 81548 | { |  | 81500 | {
| 81549 |  |  | 81501 |
| 81550 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 81502 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 81551 | { |  | 81503 | {
| 81552 | new (&(self->v)) Ptr<cv::ppf_match_3d::Pose3D>(); // init Ptr with placement new |  | 81504 | new (&(self->v)) Ptr<cv::ppf_match_3d::Pose3D>(); // init Ptr with placement new
| 81553 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::Pose3D())); |  | 81505 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::Pose3D()));
| 81554 | return 0; |  | 81506 | return 0;
| 81555 | } |  | 81507 | }
| 81556 |  |  | 81508 |
| 81557 |  |  | 81509 |
| 81558 | pyPopulateArgumentConversionErrors(); |  | 81510 | pyPopulateArgumentConversionErrors();
| 81559 | } |  | 81511 | }
| 81560 |  |  | 81512 |
| 81561 |  |  | 81513 |
| 81562 | { |  | 81514 | {
| 81563 | PyObject* pyobj_Alpha = NULL; |  | 81515 | PyObject* pyobj_Alpha = NULL;
| 81564 | double Alpha=0; |  | 81516 | double Alpha=0;
| 81565 | PyObject* pyobj_ModelIndex = NULL; |  | 81517 | PyObject* pyobj_ModelIndex = NULL;
| 81566 | size_t ModelIndex=0; |  | 81518 | size_t ModelIndex=0;
| 81567 | PyObject* pyobj_NumVotes = NULL; |  | 81519 | PyObject* pyobj_NumVotes = NULL;
| 81568 | size_t NumVotes=0; |  | 81520 | size_t NumVotes=0;
| 81569 |  |  | 81521 |
| 81570 | const char* keywords[] = { "Alpha", "ModelIndex", "NumVotes", NULL }; |  | 81522 | const char* keywords[] = { "Alpha", "ModelIndex", "NumVotes", NULL };
| 81571 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:Pose3D", (char**)keywords, &pyobj_Alpha, &pyobj_ModelIndex, &pyobj_NumVotes) && |  | 81523 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:Pose3D", (char**)keywords, &pyobj_Alpha, &pyobj_ModelIndex, &pyobj_NumVotes) &&
| 81572 | pyopencv_to_safe(pyobj_Alpha, Alpha, ArgInfo("Alpha", 0)) && |  | 81524 | pyopencv_to_safe(pyobj_Alpha, Alpha, ArgInfo("Alpha", 0)) &&
| 81573 | pyopencv_to_safe(pyobj_ModelIndex, ModelIndex, ArgInfo("ModelIndex", 0)) && |  | 81525 | pyopencv_to_safe(pyobj_ModelIndex, ModelIndex, ArgInfo("ModelIndex", 0)) &&
| 81574 | pyopencv_to_safe(pyobj_NumVotes, NumVotes, ArgInfo("NumVotes", 0)) ) |  | 81526 | pyopencv_to_safe(pyobj_NumVotes, NumVotes, ArgInfo("NumVotes", 0)) )
| 81575 | { |  | 81527 | {
| 81576 | new (&(self->v)) Ptr<cv::ppf_match_3d::Pose3D>(); // init Ptr with placement new |  | 81528 | new (&(self->v)) Ptr<cv::ppf_match_3d::Pose3D>(); // init Ptr with placement new
| 81577 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::Pose3D(Alpha, ModelIndex, NumVotes))); |  | 81529 | if(self) ERRWRAP2(self->v.reset(new cv::ppf_match_3d::Pose3D(Alpha, ModelIndex, NumVotes)));
| 81578 | return 0; |  | 81530 | return 0;
| 81579 | } |  | 81531 | }
| 81580 |  |  | 81532 |
| 81581 |  |  | 81533 |
| 81582 | pyPopulateArgumentConversionErrors(); |  | 81534 | pyPopulateArgumentConversionErrors();
| 81583 | } |  | 81535 | }
| 81584 | pyRaiseCVOverloadException("Pose3D"); |  | 81536 | pyRaiseCVOverloadException("Pose3D");
| 81585 |  |  | 81537 |
| 81586 | return -1; |  | 81538 | return -1;
| 81587 | } |  | 81539 | }
| 81588 |  |  | 81540 |
| 81589 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_appendPose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81541 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_appendPose(PyObject* self, PyObject* py_args, PyObject* kw)
| 81590 | { |  | 81542 | {
| 81591 | using namespace cv::ppf_match_3d; |  | 81543 | using namespace cv::ppf_match_3d;
| 81592 |  |  | 81544 |
| 81593 |  |  | 81545 |
| 81594 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0; |  | 81546 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0;
| 81595 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1)) |  | 81547 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1))
| 81596 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)"); |  | 81548 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)");
| 81597 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1); |  | 81549 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1);
| 81598 | PyObject* pyobj_IncrementalPose = NULL; |  | 81550 | PyObject* pyobj_IncrementalPose = NULL;
| 81599 | Matx44d IncrementalPose; |  | 81551 | Matx44d IncrementalPose;
| 81600 |  |  | 81552 |
| 81601 | const char* keywords[] = { "IncrementalPose", NULL }; |  | 81553 | const char* keywords[] = { "IncrementalPose", NULL };
| 81602 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ppf_match_3d_Pose3D.appendPose", (char**)keywords, &pyobj_IncrementalPose) && |  | 81554 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ppf_match_3d_Pose3D.appendPose", (char**)keywords, &pyobj_IncrementalPose) &&
| 81603 | pyopencv_to_safe(pyobj_IncrementalPose, IncrementalPose, ArgInfo("IncrementalPose", 0)) ) |  | 81555 | pyopencv_to_safe(pyobj_IncrementalPose, IncrementalPose, ArgInfo("IncrementalPose", 0)) )
| 81604 | { |  | 81556 | {
| 81605 | ERRWRAP2(_self_->appendPose(IncrementalPose)); |  | 81557 | ERRWRAP2(_self_->appendPose(IncrementalPose));
| 81606 | Py_RETURN_NONE; |  | 81558 | Py_RETURN_NONE;
| 81607 | } |  | 81559 | }
| 81608 |  |  | 81560 |
| 81609 | return NULL; |  | 81561 | return NULL;
| 81610 | } |  | 81562 | }
| 81611 |  |  | 81563 |
| 81612 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_printPose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81564 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_printPose(PyObject* self, PyObject* py_args, PyObject* kw)
| 81613 | { |  | 81565 | {
| 81614 | using namespace cv::ppf_match_3d; |  | 81566 | using namespace cv::ppf_match_3d;
| 81615 |  |  | 81567 |
| 81616 |  |  | 81568 |
| 81617 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0; |  | 81569 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0;
| 81618 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1)) |  | 81570 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1))
| 81619 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)"); |  | 81571 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)");
| 81620 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1); |  | 81572 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1);
| 81621 |  |  | 81573 |
| 81622 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 81574 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 81623 | { |  | 81575 | {
| 81624 | ERRWRAP2(_self_->printPose()); |  | 81576 | ERRWRAP2(_self_->printPose());
| 81625 | Py_RETURN_NONE; |  | 81577 | Py_RETURN_NONE;
| 81626 | } |  | 81578 | }
| 81627 |  |  | 81579 |
| 81628 | return NULL; |  | 81580 | return NULL;
| 81629 | } |  | 81581 | }
| 81630 |  |  | 81582 |
| 81631 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81583 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePose(PyObject* self, PyObject* py_args, PyObject* kw)
| 81632 | { |  | 81584 | {
| 81633 | using namespace cv::ppf_match_3d; |  | 81585 | using namespace cv::ppf_match_3d;
| 81634 |  |  | 81586 |
| 81635 |  |  | 81587 |
| 81636 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0; |  | 81588 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0;
| 81637 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1)) |  | 81589 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1))
| 81638 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)"); |  | 81590 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)");
| 81639 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1); |  | 81591 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1);
| 81640 | pyPrepareArgumentConversionErrorsStorage(2); |  | 81592 | pyPrepareArgumentConversionErrorsStorage(2);
| 81641 |  |  | 81593 |
| 81642 | { |  | 81594 | {
| 81643 | PyObject* pyobj_NewPose = NULL; |  | 81595 | PyObject* pyobj_NewPose = NULL;
| 81644 | Matx44d NewPose; |  | 81596 | Matx44d NewPose;
| 81645 |  |  | 81597 |
| 81646 | const char* keywords[] = { "NewPose", NULL }; |  | 81598 | const char* keywords[] = { "NewPose", NULL };
| 81647 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ppf_match_3d_Pose3D.updatePose", (char**)keywords, &pyobj_NewPose) && |  | 81599 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:ppf_match_3d_Pose3D.updatePose", (char**)keywords, &pyobj_NewPose) &&
| 81648 | pyopencv_to_safe(pyobj_NewPose, NewPose, ArgInfo("NewPose", 0)) ) |  | 81600 | pyopencv_to_safe(pyobj_NewPose, NewPose, ArgInfo("NewPose", 0)) )
| 81649 | { |  | 81601 | {
| 81650 | ERRWRAP2(_self_->updatePose(NewPose)); |  | 81602 | ERRWRAP2(_self_->updatePose(NewPose));
| 81651 | Py_RETURN_NONE; |  | 81603 | Py_RETURN_NONE;
| 81652 | } |  | 81604 | }
| 81653 |  |  | 81605 |
| 81654 |  |  | 81606 |
| 81655 | pyPopulateArgumentConversionErrors(); |  | 81607 | pyPopulateArgumentConversionErrors();
| 81656 | } |  | 81608 | }
| 81657 |  |  | 81609 |
| 81658 |  |  | 81610 |
| 81659 | { |  | 81611 | {
| 81660 | PyObject* pyobj_NewR = NULL; |  | 81612 | PyObject* pyobj_NewR = NULL;
| 81661 | Matx33d NewR; |  | 81613 | Matx33d NewR;
| 81662 | PyObject* pyobj_NewT = NULL; |  | 81614 | PyObject* pyobj_NewT = NULL;
| 81663 | Vec3d NewT; |  | 81615 | Vec3d NewT;
| 81664 |  |  | 81616 |
| 81665 | const char* keywords[] = { "NewR", "NewT", NULL }; |  | 81617 | const char* keywords[] = { "NewR", "NewT", NULL };
| 81666 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ppf_match_3d_Pose3D.updatePose", (char**)keywords, &pyobj_NewR, &pyobj_NewT) && |  | 81618 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ppf_match_3d_Pose3D.updatePose", (char**)keywords, &pyobj_NewR, &pyobj_NewT) &&
| 81667 | pyopencv_to_safe(pyobj_NewR, NewR, ArgInfo("NewR", 0)) && |  | 81619 | pyopencv_to_safe(pyobj_NewR, NewR, ArgInfo("NewR", 0)) &&
| 81668 | pyopencv_to_safe(pyobj_NewT, NewT, ArgInfo("NewT", 0)) ) |  | 81620 | pyopencv_to_safe(pyobj_NewT, NewT, ArgInfo("NewT", 0)) )
| 81669 | { |  | 81621 | {
| 81670 | ERRWRAP2(_self_->updatePose(NewR, NewT)); |  | 81622 | ERRWRAP2(_self_->updatePose(NewR, NewT));
| 81671 | Py_RETURN_NONE; |  | 81623 | Py_RETURN_NONE;
| 81672 | } |  | 81624 | }
| 81673 |  |  | 81625 |
| 81674 |  |  | 81626 |
| 81675 | pyPopulateArgumentConversionErrors(); |  | 81627 | pyPopulateArgumentConversionErrors();
| 81676 | } |  | 81628 | }
| 81677 | pyRaiseCVOverloadException("updatePose"); |  | 81629 | pyRaiseCVOverloadException("updatePose");
| 81678 |  |  | 81630 |
| 81679 | return NULL; |  | 81631 | return NULL;
| 81680 | } |  | 81632 | }
| 81681 |  |  | 81633 |
| 81682 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePoseQuat(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81634 | static PyObject* pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePoseQuat(PyObject* self, PyObject* py_args, PyObject* kw)
| 81683 | { |  | 81635 | {
| 81684 | using namespace cv::ppf_match_3d; |  | 81636 | using namespace cv::ppf_match_3d;
| 81685 |  |  | 81637 |
| 81686 |  |  | 81638 |
| 81687 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0; |  | 81639 | Ptr<cv::ppf_match_3d::Pose3D> * self1 = 0;
| 81688 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1)) |  | 81640 | if (!pyopencv_ppf_match_3d_Pose3D_getp(self, self1))
| 81689 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)"); |  | 81641 | return failmsgp("Incorrect type of self (must be 'ppf_match_3d_Pose3D' or its derivative)");
| 81690 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1); |  | 81642 | Ptr<cv::ppf_match_3d::Pose3D> _self_ = *(self1);
| 81691 | PyObject* pyobj_Q = NULL; |  | 81643 | PyObject* pyobj_Q = NULL;
| 81692 | Vec4d Q; |  | 81644 | Vec4d Q;
| 81693 | PyObject* pyobj_NewT = NULL; |  | 81645 | PyObject* pyobj_NewT = NULL;
| 81694 | Vec3d NewT; |  | 81646 | Vec3d NewT;
| 81695 |  |  | 81647 |
| 81696 | const char* keywords[] = { "Q", "NewT", NULL }; |  | 81648 | const char* keywords[] = { "Q", "NewT", NULL };
| 81697 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ppf_match_3d_Pose3D.updatePoseQuat", (char**)keywords, &pyobj_Q, &pyobj_NewT) && |  | 81649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:ppf_match_3d_Pose3D.updatePoseQuat", (char**)keywords, &pyobj_Q, &pyobj_NewT) &&
| 81698 | pyopencv_to_safe(pyobj_Q, Q, ArgInfo("Q", 0)) && |  | 81650 | pyopencv_to_safe(pyobj_Q, Q, ArgInfo("Q", 0)) &&
| 81699 | pyopencv_to_safe(pyobj_NewT, NewT, ArgInfo("NewT", 0)) ) |  | 81651 | pyopencv_to_safe(pyobj_NewT, NewT, ArgInfo("NewT", 0)) )
| 81700 | { |  | 81652 | {
| 81701 | ERRWRAP2(_self_->updatePoseQuat(Q, NewT)); |  | 81653 | ERRWRAP2(_self_->updatePoseQuat(Q, NewT));
| 81702 | Py_RETURN_NONE; |  | 81654 | Py_RETURN_NONE;
| 81703 | } |  | 81655 | }
| 81704 |  |  | 81656 |
| 81705 | return NULL; |  | 81657 | return NULL;
| 81706 | } |  | 81658 | }
| 81707 |  |  | 81659 |
| 81708 |  |  | 81660 |
| 81709 |  |  | 81661 |
| 81710 | // Tables (ppf_match_3d_Pose3D) |  | 81662 | // Tables (ppf_match_3d_Pose3D)
| 81711 |  |  | 81663 |
| 81712 | static PyGetSetDef pyopencv_ppf_match_3d_Pose3D_getseters[] = |  | 81664 | static PyGetSetDef pyopencv_ppf_match_3d_Pose3D_getseters[] =
| 81713 | { |  | 81665 | {
| 81714 | {(char*)"alpha", (getter)pyopencv_ppf_match_3d_Pose3D_get_alpha, NULL, (char*)"alpha", NULL}, |  | 81666 | {(char*)"alpha", (getter)pyopencv_ppf_match_3d_Pose3D_get_alpha, NULL, (char*)"alpha", NULL},
| 81715 | {(char*)"angle", (getter)pyopencv_ppf_match_3d_Pose3D_get_angle, NULL, (char*)"angle", NULL}, |  | 81667 | {(char*)"angle", (getter)pyopencv_ppf_match_3d_Pose3D_get_angle, NULL, (char*)"angle", NULL},
| 81716 | {(char*)"modelIndex", (getter)pyopencv_ppf_match_3d_Pose3D_get_modelIndex, NULL, (char*)"modelIndex", NULL}, |  | 81668 | {(char*)"modelIndex", (getter)pyopencv_ppf_match_3d_Pose3D_get_modelIndex, NULL, (char*)"modelIndex", NULL},
| 81717 | {(char*)"numVotes", (getter)pyopencv_ppf_match_3d_Pose3D_get_numVotes, NULL, (char*)"numVotes", NULL}, |  | 81669 | {(char*)"numVotes", (getter)pyopencv_ppf_match_3d_Pose3D_get_numVotes, NULL, (char*)"numVotes", NULL},
| 81718 | {(char*)"pose", (getter)pyopencv_ppf_match_3d_Pose3D_get_pose, NULL, (char*)"pose", NULL}, |  | 81670 | {(char*)"pose", (getter)pyopencv_ppf_match_3d_Pose3D_get_pose, NULL, (char*)"pose", NULL},
| 81719 | {(char*)"q", (getter)pyopencv_ppf_match_3d_Pose3D_get_q, NULL, (char*)"q", NULL}, |  | 81671 | {(char*)"q", (getter)pyopencv_ppf_match_3d_Pose3D_get_q, NULL, (char*)"q", NULL},
| 81720 | {(char*)"residual", (getter)pyopencv_ppf_match_3d_Pose3D_get_residual, NULL, (char*)"residual", NULL}, |  | 81672 | {(char*)"residual", (getter)pyopencv_ppf_match_3d_Pose3D_get_residual, NULL, (char*)"residual", NULL},
| 81721 | {(char*)"t", (getter)pyopencv_ppf_match_3d_Pose3D_get_t, NULL, (char*)"t", NULL}, |  | 81673 | {(char*)"t", (getter)pyopencv_ppf_match_3d_Pose3D_get_t, NULL, (char*)"t", NULL},
| 81722 | {NULL} /* Sentinel */ |  | 81674 | {NULL} /* Sentinel */
| 81723 | }; |  | 81675 | };
| 81724 |  |  | 81676 |
| 81725 | static PyMethodDef pyopencv_ppf_match_3d_Pose3D_methods[] = |  | 81677 | static PyMethodDef pyopencv_ppf_match_3d_Pose3D_methods[] =
| 81726 | { |  | 81678 | {
| 81727 | {"appendPose", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_appendPose, 0), "appendPose(IncrementalPose) -> None\n. * \\brief Left multiplies the existing pose in order to update the transformation\n. * \\param [in] IncrementalPose New pose to apply"}, |  | 81679 | {"appendPose", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_appendPose, 0), "appendPose(IncrementalPose) -> None\n. * \\brief Left multiplies the existing pose in order to update the transformation\n. * \\param [in] IncrementalPose New pose to apply"},
| 81728 | {"printPose", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_printPose, 0), "printPose() -> None\n."}, |  | 81680 | {"printPose", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_printPose, 0), "printPose() -> None\n."},
| 81729 | {"updatePose", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePose, 0), "updatePose(NewPose) -> None\n. * \\brief Updates the pose with the new one\n. * \\param [in] NewPose New pose to overwrite\n\n\n\nupdatePose(NewR, NewT) -> None\n. * \\brief Updates the pose with the new one"}, |  | 81681 | {"updatePose", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePose, 0), "updatePose(NewPose) -> None\n. * \\brief Updates the pose with the new one\n. * \\param [in] NewPose New pose to overwrite\n\n\n\nupdatePose(NewR, NewT) -> None\n. * \\brief Updates the pose with the new one"},
| 81730 | {"updatePoseQuat", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePoseQuat, 0), "updatePoseQuat(Q, NewT) -> None\n. * \\brief Updates the pose with the new one, but this time using quaternions to represent rotation"}, |  | 81682 | {"updatePoseQuat", CV_PY_FN_WITH_KW_(pyopencv_cv_ppf_match_3d_ppf_match_3d_Pose3D_updatePoseQuat, 0), "updatePoseQuat(Q, NewT) -> None\n. * \\brief Updates the pose with the new one, but this time using quaternions to represent rotation"},
| 81731 |  |  | 81683 |
| 81732 | {NULL, NULL} |  | 81684 | {NULL, NULL}
| 81733 | }; |  | 81685 | };
| 81734 |  |  | 81686 |
| 81735 | // Converter (ppf_match_3d_Pose3D) |  | 81687 | // Converter (ppf_match_3d_Pose3D)
| 81736 |  |  | 81688 |
| 81737 | template<> |  | 81689 | template<>
| 81738 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::Pose3D> > |  | 81690 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::Pose3D> >
| 81739 | { |  | 81691 | {
| 81740 | static PyObject* from(const Ptr<cv::ppf_match_3d::Pose3D>& r) |  | 81692 | static PyObject* from(const Ptr<cv::ppf_match_3d::Pose3D>& r)
| 81741 | { |  | 81693 | {
| 81742 | return pyopencv_ppf_match_3d_Pose3D_Instance(r); |  | 81694 | return pyopencv_ppf_match_3d_Pose3D_Instance(r);
| 81743 | } |  | 81695 | }
| 81744 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::Pose3D>& dst, const ArgInfo& info) |  | 81696 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::Pose3D>& dst, const ArgInfo& info)
| 81745 | { |  | 81697 | {
| 81746 | if(!src || src == Py_None) |  | 81698 | if(!src || src == Py_None)
| 81747 | return true; |  | 81699 | return true;
| 81748 | Ptr<cv::ppf_match_3d::Pose3D> * dst_; |  | 81700 | Ptr<cv::ppf_match_3d::Pose3D> * dst_;
| 81749 | if (pyopencv_ppf_match_3d_Pose3D_getp(src, dst_)) |  | 81701 | if (pyopencv_ppf_match_3d_Pose3D_getp(src, dst_))
| 81750 | { |  | 81702 | {
| 81751 | dst = *dst_; |  | 81703 | dst = *dst_;
| 81752 | return true; |  | 81704 | return true;
| 81753 | } |  | 81705 | }
| 81754 |  |  | 81706 |
| 81755 | failmsg("Expected Ptr<cv::ppf_match_3d::Pose3D> for argument '%s'", info.name); |  | 81707 | failmsg("Expected Ptr<cv::ppf_match_3d::Pose3D> for argument '%s'", info.name);
| 81756 | return false; |  | 81708 | return false;
| 81757 | } |  | 81709 | }
| 81758 | }; |  | 81710 | };
| 81759 |  |  | 81711 |
| 81760 | //================================================================================ |  | 81712 | //================================================================================
| 81761 | // ppf_match_3d_PoseCluster3D (Generic) |  | 81713 | // ppf_match_3d_PoseCluster3D (Generic)
| 81762 | //================================================================================ |  | 81714 | //================================================================================
| 81763 |  |  | 81715 |
| 81764 | // GetSet (ppf_match_3d_PoseCluster3D) |  | 81716 | // GetSet (ppf_match_3d_PoseCluster3D)
| 81765 |  |  | 81717 |
| 81766 |  |  | 81718 |
| 81767 |  |  | 81719 |
| 81768 | // Methods (ppf_match_3d_PoseCluster3D) |  | 81720 | // Methods (ppf_match_3d_PoseCluster3D)
| 81769 |  |  | 81721 |
| 81770 |  |  | 81722 |
| 81771 |  |  | 81723 |
| 81772 | // Tables (ppf_match_3d_PoseCluster3D) |  | 81724 | // Tables (ppf_match_3d_PoseCluster3D)
| 81773 |  |  | 81725 |
| 81774 | static PyGetSetDef pyopencv_ppf_match_3d_PoseCluster3D_getseters[] = |  | 81726 | static PyGetSetDef pyopencv_ppf_match_3d_PoseCluster3D_getseters[] =
| 81775 | { |  | 81727 | {
| 81776 | {NULL} /* Sentinel */ |  | 81728 | {NULL} /* Sentinel */
| 81777 | }; |  | 81729 | };
| 81778 |  |  | 81730 |
| 81779 | static PyMethodDef pyopencv_ppf_match_3d_PoseCluster3D_methods[] = |  | 81731 | static PyMethodDef pyopencv_ppf_match_3d_PoseCluster3D_methods[] =
| 81780 | { |  | 81732 | {
| 81781 |  |  | 81733 |
| 81782 | {NULL, NULL} |  | 81734 | {NULL, NULL}
| 81783 | }; |  | 81735 | };
| 81784 |  |  | 81736 |
| 81785 | // Converter (ppf_match_3d_PoseCluster3D) |  | 81737 | // Converter (ppf_match_3d_PoseCluster3D)
| 81786 |  |  | 81738 |
| 81787 | template<> |  | 81739 | template<>
| 81788 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::PoseCluster3D> > |  | 81740 | struct PyOpenCV_Converter< Ptr<cv::ppf_match_3d::PoseCluster3D> >
| 81789 | { |  | 81741 | {
| 81790 | static PyObject* from(const Ptr<cv::ppf_match_3d::PoseCluster3D>& r) |  | 81742 | static PyObject* from(const Ptr<cv::ppf_match_3d::PoseCluster3D>& r)
| 81791 | { |  | 81743 | {
| 81792 | return pyopencv_ppf_match_3d_PoseCluster3D_Instance(r); |  | 81744 | return pyopencv_ppf_match_3d_PoseCluster3D_Instance(r);
| 81793 | } |  | 81745 | }
| 81794 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::PoseCluster3D>& dst, const ArgInfo& info) |  | 81746 | static bool to(PyObject* src, Ptr<cv::ppf_match_3d::PoseCluster3D>& dst, const ArgInfo& info)
| 81795 | { |  | 81747 | {
| 81796 | if(!src || src == Py_None) |  | 81748 | if(!src || src == Py_None)
| 81797 | return true; |  | 81749 | return true;
| 81798 | Ptr<cv::ppf_match_3d::PoseCluster3D> * dst_; |  | 81750 | Ptr<cv::ppf_match_3d::PoseCluster3D> * dst_;
| 81799 | if (pyopencv_ppf_match_3d_PoseCluster3D_getp(src, dst_)) |  | 81751 | if (pyopencv_ppf_match_3d_PoseCluster3D_getp(src, dst_))
| 81800 | { |  | 81752 | {
| 81801 | dst = *dst_; |  | 81753 | dst = *dst_;
| 81802 | return true; |  | 81754 | return true;
| 81803 | } |  | 81755 | }
| 81804 |  |  | 81756 |
| 81805 | failmsg("Expected Ptr<cv::ppf_match_3d::PoseCluster3D> for argument '%s'", info.name); |  | 81757 | failmsg("Expected Ptr<cv::ppf_match_3d::PoseCluster3D> for argument '%s'", info.name);
| 81806 | return false; |  | 81758 | return false;
| 81807 | } |  | 81759 | }
| 81808 | }; |  | 81760 | };
| 81809 |  |  | 81761 |
| 81810 | //================================================================================ |  | 81762 | //================================================================================
| 81811 | // quality_QualityBRISQUE (Generic) |  | 81763 | // quality_QualityBRISQUE (Generic)
| 81812 | //================================================================================ |  | 81764 | //================================================================================
| 81813 |  |  | 81765 |
| 81814 | // GetSet (quality_QualityBRISQUE) |  | 81766 | // GetSet (quality_QualityBRISQUE)
| 81815 |  |  | 81767 |
| 81816 |  |  | 81768 |
| 81817 |  |  | 81769 |
| 81818 | // Methods (quality_QualityBRISQUE) |  | 81770 | // Methods (quality_QualityBRISQUE)
| 81819 |  |  | 81771 |
| 81820 | static PyObject* pyopencv_cv_quality_quality_QualityBRISQUE_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81772 | static PyObject* pyopencv_cv_quality_quality_QualityBRISQUE_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 81821 | { |  | 81773 | {
| 81822 | using namespace cv::quality; |  | 81774 | using namespace cv::quality;
| 81823 |  |  | 81775 |
| 81824 |  |  | 81776 |
| 81825 | Ptr<cv::quality::QualityBRISQUE> * self1 = 0; |  | 81777 | Ptr<cv::quality::QualityBRISQUE> * self1 = 0;
| 81826 | if (!pyopencv_quality_QualityBRISQUE_getp(self, self1)) |  | 81778 | if (!pyopencv_quality_QualityBRISQUE_getp(self, self1))
| 81827 | return failmsgp("Incorrect type of self (must be 'quality_QualityBRISQUE' or its derivative)"); |  | 81779 | return failmsgp("Incorrect type of self (must be 'quality_QualityBRISQUE' or its derivative)");
| 81828 | Ptr<cv::quality::QualityBRISQUE> _self_ = *(self1); |  | 81780 | Ptr<cv::quality::QualityBRISQUE> _self_ = *(self1);
| 81829 | pyPrepareArgumentConversionErrorsStorage(4); |  | 81781 | pyPrepareArgumentConversionErrorsStorage(4);
| 81830 |  |  | 81782 |
| 81831 | { |  | 81783 | {
| 81832 | PyObject* pyobj_img = NULL; |  | 81784 | PyObject* pyobj_img = NULL;
| 81833 | Mat img; |  | 81785 | Mat img;
| 81834 | cv::Scalar retval; |  | 81786 | cv::Scalar retval;
| 81835 |  |  | 81787 |
| 81836 | const char* keywords[] = { "img", NULL }; |  | 81788 | const char* keywords[] = { "img", NULL };
| 81837 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img) && |  | 81789 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img) &&
| 81838 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) ) |  | 81790 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) )
| 81839 | { |  | 81791 | {
| 81840 | ERRWRAP2(retval = _self_->compute(img)); |  | 81792 | ERRWRAP2(retval = _self_->compute(img));
| 81841 | return pyopencv_from(retval); |  | 81793 | return pyopencv_from(retval);
| 81842 | } |  | 81794 | }
| 81843 |  |  | 81795 |
| 81844 |  |  | 81796 |
| 81845 | pyPopulateArgumentConversionErrors(); |  | 81797 | pyPopulateArgumentConversionErrors();
| 81846 | } |  | 81798 | }
| 81847 |  |  | 81799 |
| 81848 |  |  | 81800 |
| 81849 | { |  | 81801 | {
| 81850 | PyObject* pyobj_img = NULL; |  | 81802 | PyObject* pyobj_img = NULL;
| 81851 | Mat img; |  | 81803 | Mat img;
| 81852 | PyObject* pyobj_model_file_path = NULL; |  | 81804 | PyObject* pyobj_model_file_path = NULL;
| 81853 | String model_file_path; |  | 81805 | String model_file_path;
| 81854 | PyObject* pyobj_range_file_path = NULL; |  | 81806 | PyObject* pyobj_range_file_path = NULL;
| 81855 | String range_file_path; |  | 81807 | String range_file_path;
| 81856 | cv::Scalar retval; |  | 81808 | cv::Scalar retval;
| 81857 |  |  | 81809 |
| 81858 | const char* keywords[] = { "img", "model_file_path", "range_file_path", NULL }; |  | 81810 | const char* keywords[] = { "img", "model_file_path", "range_file_path", NULL };
| 81859 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img, &pyobj_model_file_path, &pyobj_range_file_path) && |  | 81811 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img, &pyobj_model_file_path, &pyobj_range_file_path) &&
| 81860 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 81812 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 81861 | pyopencv_to_safe(pyobj_model_file_path, model_file_path, ArgInfo("model_file_path", 0)) && |  | 81813 | pyopencv_to_safe(pyobj_model_file_path, model_file_path, ArgInfo("model_file_path", 0)) &&
| 81862 | pyopencv_to_safe(pyobj_range_file_path, range_file_path, ArgInfo("range_file_path", 0)) ) |  | 81814 | pyopencv_to_safe(pyobj_range_file_path, range_file_path, ArgInfo("range_file_path", 0)) )
| 81863 | { |  | 81815 | {
| 81864 | ERRWRAP2(retval = _self_->compute(img, model_file_path, range_file_path)); |  | 81816 | ERRWRAP2(retval = _self_->compute(img, model_file_path, range_file_path));
| 81865 | return pyopencv_from(retval); |  | 81817 | return pyopencv_from(retval);
| 81866 | } |  | 81818 | }
| 81867 |  |  | 81819 |
| 81868 |  |  | 81820 |
| 81869 | pyPopulateArgumentConversionErrors(); |  | 81821 | pyPopulateArgumentConversionErrors();
| 81870 | } |  | 81822 | }
| 81871 |  |  | 81823 |
| 81872 |  |  | 81824 |
| 81873 | { |  | 81825 | {
| 81874 | PyObject* pyobj_img = NULL; |  | 81826 | PyObject* pyobj_img = NULL;
| 81875 | UMat img; |  | 81827 | UMat img;
| 81876 | cv::Scalar retval; |  | 81828 | cv::Scalar retval;
| 81877 |  |  | 81829 |
| 81878 | const char* keywords[] = { "img", NULL }; |  | 81830 | const char* keywords[] = { "img", NULL };
| 81879 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img) && |  | 81831 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img) &&
| 81880 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) ) |  | 81832 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) )
| 81881 | { |  | 81833 | {
| 81882 | ERRWRAP2(retval = _self_->compute(img)); |  | 81834 | ERRWRAP2(retval = _self_->compute(img));
| 81883 | return pyopencv_from(retval); |  | 81835 | return pyopencv_from(retval);
| 81884 | } |  | 81836 | }
| 81885 |  |  | 81837 |
| 81886 |  |  | 81838 |
| 81887 | pyPopulateArgumentConversionErrors(); |  | 81839 | pyPopulateArgumentConversionErrors();
| 81888 | } |  | 81840 | }
| 81889 |  |  | 81841 |
| 81890 |  |  | 81842 |
| 81891 | { |  | 81843 | {
| 81892 | PyObject* pyobj_img = NULL; |  | 81844 | PyObject* pyobj_img = NULL;
| 81893 | UMat img; |  | 81845 | UMat img;
| 81894 | PyObject* pyobj_model_file_path = NULL; |  | 81846 | PyObject* pyobj_model_file_path = NULL;
| 81895 | String model_file_path; |  | 81847 | String model_file_path;
| 81896 | PyObject* pyobj_range_file_path = NULL; |  | 81848 | PyObject* pyobj_range_file_path = NULL;
| 81897 | String range_file_path; |  | 81849 | String range_file_path;
| 81898 | cv::Scalar retval; |  | 81850 | cv::Scalar retval;
| 81899 |  |  | 81851 |
| 81900 | const char* keywords[] = { "img", "model_file_path", "range_file_path", NULL }; |  | 81852 | const char* keywords[] = { "img", "model_file_path", "range_file_path", NULL };
| 81901 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img, &pyobj_model_file_path, &pyobj_range_file_path) && |  | 81853 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:quality_QualityBRISQUE.compute", (char**)keywords, &pyobj_img, &pyobj_model_file_path, &pyobj_range_file_path) &&
| 81902 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 81854 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 81903 | pyopencv_to_safe(pyobj_model_file_path, model_file_path, ArgInfo("model_file_path", 0)) && |  | 81855 | pyopencv_to_safe(pyobj_model_file_path, model_file_path, ArgInfo("model_file_path", 0)) &&
| 81904 | pyopencv_to_safe(pyobj_range_file_path, range_file_path, ArgInfo("range_file_path", 0)) ) |  | 81856 | pyopencv_to_safe(pyobj_range_file_path, range_file_path, ArgInfo("range_file_path", 0)) )
| 81905 | { |  | 81857 | {
| 81906 | ERRWRAP2(retval = _self_->compute(img, model_file_path, range_file_path)); |  | 81858 | ERRWRAP2(retval = _self_->compute(img, model_file_path, range_file_path));
| 81907 | return pyopencv_from(retval); |  | 81859 | return pyopencv_from(retval);
| 81908 | } |  | 81860 | }
| 81909 |  |  | 81861 |
| 81910 |  |  | 81862 |
| 81911 | pyPopulateArgumentConversionErrors(); |  | 81863 | pyPopulateArgumentConversionErrors();
| 81912 | } |  | 81864 | }
| 81913 | pyRaiseCVOverloadException("compute"); |  | 81865 | pyRaiseCVOverloadException("compute");
| 81914 |  |  | 81866 |
| 81915 | return NULL; |  | 81867 | return NULL;
| 81916 | } |  | 81868 | }
| 81917 |  |  | 81869 |
| 81918 | static PyObject* pyopencv_cv_quality_quality_QualityBRISQUE_computeFeatures_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81870 | static PyObject* pyopencv_cv_quality_quality_QualityBRISQUE_computeFeatures_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 81919 | { |  | 81871 | {
| 81920 | using namespace cv::quality; |  | 81872 | using namespace cv::quality;
| 81921 |  |  | 81873 |
| 81922 | pyPrepareArgumentConversionErrorsStorage(2); |  | 81874 | pyPrepareArgumentConversionErrorsStorage(2);
| 81923 |  |  | 81875 |
| 81924 | { |  | 81876 | {
| 81925 | PyObject* pyobj_img = NULL; |  | 81877 | PyObject* pyobj_img = NULL;
| 81926 | Mat img; |  | 81878 | Mat img;
| 81927 | PyObject* pyobj_features = NULL; |  | 81879 | PyObject* pyobj_features = NULL;
| 81928 | Mat features; |  | 81880 | Mat features;
| 81929 |  |  | 81881 |
| 81930 | const char* keywords[] = { "img", "features", NULL }; |  | 81882 | const char* keywords[] = { "img", "features", NULL };
| 81931 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityBRISQUE.computeFeatures", (char**)keywords, &pyobj_img, &pyobj_features) && |  | 81883 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityBRISQUE.computeFeatures", (char**)keywords, &pyobj_img, &pyobj_features) &&
| 81932 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 81884 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 81933 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) ) |  | 81885 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) )
| 81934 | { |  | 81886 | {
| 81935 | ERRWRAP2(cv::quality::QualityBRISQUE::computeFeatures(img, features)); |  | 81887 | ERRWRAP2(cv::quality::QualityBRISQUE::computeFeatures(img, features));
| 81936 | return pyopencv_from(features); |  | 81888 | return pyopencv_from(features);
| 81937 | } |  | 81889 | }
| 81938 |  |  | 81890 |
| 81939 |  |  | 81891 |
| 81940 | pyPopulateArgumentConversionErrors(); |  | 81892 | pyPopulateArgumentConversionErrors();
| 81941 | } |  | 81893 | }
| 81942 |  |  | 81894 |
| 81943 |  |  | 81895 |
| 81944 | { |  | 81896 | {
| 81945 | PyObject* pyobj_img = NULL; |  | 81897 | PyObject* pyobj_img = NULL;
| 81946 | UMat img; |  | 81898 | UMat img;
| 81947 | PyObject* pyobj_features = NULL; |  | 81899 | PyObject* pyobj_features = NULL;
| 81948 | UMat features; |  | 81900 | UMat features;
| 81949 |  |  | 81901 |
| 81950 | const char* keywords[] = { "img", "features", NULL }; |  | 81902 | const char* keywords[] = { "img", "features", NULL };
| 81951 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityBRISQUE.computeFeatures", (char**)keywords, &pyobj_img, &pyobj_features) && |  | 81903 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityBRISQUE.computeFeatures", (char**)keywords, &pyobj_img, &pyobj_features) &&
| 81952 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 81904 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 81953 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) ) |  | 81905 | pyopencv_to_safe(pyobj_features, features, ArgInfo("features", 1)) )
| 81954 | { |  | 81906 | {
| 81955 | ERRWRAP2(cv::quality::QualityBRISQUE::computeFeatures(img, features)); |  | 81907 | ERRWRAP2(cv::quality::QualityBRISQUE::computeFeatures(img, features));
| 81956 | return pyopencv_from(features); |  | 81908 | return pyopencv_from(features);
| 81957 | } |  | 81909 | }
| 81958 |  |  | 81910 |
| 81959 |  |  | 81911 |
| 81960 | pyPopulateArgumentConversionErrors(); |  | 81912 | pyPopulateArgumentConversionErrors();
| 81961 | } |  | 81913 | }
| 81962 | pyRaiseCVOverloadException("computeFeatures"); |  | 81914 | pyRaiseCVOverloadException("computeFeatures");
| 81963 |  |  | 81915 |
| 81964 | return NULL; |  | 81916 | return NULL;
| 81965 | } |  | 81917 | }
| 81966 |  |  | 81918 |
| 81967 | static PyObject* pyopencv_cv_quality_quality_QualityBRISQUE_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 81919 | static PyObject* pyopencv_cv_quality_quality_QualityBRISQUE_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 81968 | { |  | 81920 | {
| 81969 | using namespace cv::quality; |  | 81921 | using namespace cv::quality;
| 81970 |  |  | 81922 |
| 81971 | pyPrepareArgumentConversionErrorsStorage(2); |  | 81923 | pyPrepareArgumentConversionErrorsStorage(2);
| 81972 |  |  | 81924 |
| 81973 | { |  | 81925 | {
| 81974 | PyObject* pyobj_model_file_path = NULL; |  | 81926 | PyObject* pyobj_model_file_path = NULL;
| 81975 | String model_file_path; |  | 81927 | String model_file_path;
| 81976 | PyObject* pyobj_range_file_path = NULL; |  | 81928 | PyObject* pyobj_range_file_path = NULL;
| 81977 | String range_file_path; |  | 81929 | String range_file_path;
| 81978 | Ptr<QualityBRISQUE> retval; |  | 81930 | Ptr<QualityBRISQUE> retval;
| 81979 |  |  | 81931 |
| 81980 | const char* keywords[] = { "model_file_path", "range_file_path", NULL }; |  | 81932 | const char* keywords[] = { "model_file_path", "range_file_path", NULL };
| 81981 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:quality_QualityBRISQUE.create", (char**)keywords, &pyobj_model_file_path, &pyobj_range_file_path) && |  | 81933 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:quality_QualityBRISQUE.create", (char**)keywords, &pyobj_model_file_path, &pyobj_range_file_path) &&
| 81982 | pyopencv_to_safe(pyobj_model_file_path, model_file_path, ArgInfo("model_file_path", 0)) && |  | 81934 | pyopencv_to_safe(pyobj_model_file_path, model_file_path, ArgInfo("model_file_path", 0)) &&
| 81983 | pyopencv_to_safe(pyobj_range_file_path, range_file_path, ArgInfo("range_file_path", 0)) ) |  | 81935 | pyopencv_to_safe(pyobj_range_file_path, range_file_path, ArgInfo("range_file_path", 0)) )
| 81984 | { |  | 81936 | {
| 81985 | ERRWRAP2(retval = cv::quality::QualityBRISQUE::create(model_file_path, range_file_path)); |  | 81937 | ERRWRAP2(retval = cv::quality::QualityBRISQUE::create(model_file_path, range_file_path));
| 81986 | return pyopencv_from(retval); |  | 81938 | return pyopencv_from(retval);
| 81987 | } |  | 81939 | }
| 81988 |  |  | 81940 |
| 81989 |  |  | 81941 |
| 81990 | pyPopulateArgumentConversionErrors(); |  | 81942 | pyPopulateArgumentConversionErrors();
| 81991 | } |  | 81943 | }
| 81992 |  |  | 81944 |
| 81993 |  |  | 81945 |
| 81994 | { |  | 81946 | {
| 81995 | PyObject* pyobj_model = NULL; |  | 81947 | PyObject* pyobj_model = NULL;
| 81996 | Ptr<ml::SVM> model; |  | 81948 | Ptr<ml::SVM> model;
| 81997 | PyObject* pyobj_range = NULL; |  | 81949 | PyObject* pyobj_range = NULL;
| 81998 | Mat range; |  | 81950 | Mat range;
| 81999 | Ptr<QualityBRISQUE> retval; |  | 81951 | Ptr<QualityBRISQUE> retval;
| 82000 |  |  | 81952 |
| 82001 | const char* keywords[] = { "model", "range", NULL }; |  | 81953 | const char* keywords[] = { "model", "range", NULL };
| 82002 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:quality_QualityBRISQUE.create", (char**)keywords, &pyobj_model, &pyobj_range) && |  | 81954 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:quality_QualityBRISQUE.create", (char**)keywords, &pyobj_model, &pyobj_range) &&
| 82003 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) && |  | 81955 | pyopencv_to_safe(pyobj_model, model, ArgInfo("model", 0)) &&
| 82004 | pyopencv_to_safe(pyobj_range, range, ArgInfo("range", 0)) ) |  | 81956 | pyopencv_to_safe(pyobj_range, range, ArgInfo("range", 0)) )
| 82005 | { |  | 81957 | {
| 82006 | ERRWRAP2(retval = cv::quality::QualityBRISQUE::create(model, range)); |  | 81958 | ERRWRAP2(retval = cv::quality::QualityBRISQUE::create(model, range));
| 82007 | return pyopencv_from(retval); |  | 81959 | return pyopencv_from(retval);
| 82008 | } |  | 81960 | }
| 82009 |  |  | 81961 |
| 82010 |  |  | 81962 |
| 82011 | pyPopulateArgumentConversionErrors(); |  | 81963 | pyPopulateArgumentConversionErrors();
| 82012 | } |  | 81964 | }
| 82013 | pyRaiseCVOverloadException("create"); |  | 81965 | pyRaiseCVOverloadException("create");
| 82014 |  |  | 81966 |
| 82015 | return NULL; |  | 81967 | return NULL;
| 82016 | } |  | 81968 | }
| 82017 |  |  | 81969 |
| 82018 |  |  | 81970 |
| 82019 |  |  | 81971 |
| 82020 | // Tables (quality_QualityBRISQUE) |  | 81972 | // Tables (quality_QualityBRISQUE)
| 82021 |  |  | 81973 |
| 82022 | static PyGetSetDef pyopencv_quality_QualityBRISQUE_getseters[] = |  | 81974 | static PyGetSetDef pyopencv_quality_QualityBRISQUE_getseters[] =
| 82023 | { |  | 81975 | {
| 82024 | {NULL} /* Sentinel */ |  | 81976 | {NULL} /* Sentinel */
| 82025 | }; |  | 81977 | };
| 82026 |  |  | 81978 |
| 82027 | static PyMethodDef pyopencv_quality_QualityBRISQUE_methods[] = |  | 81979 | static PyMethodDef pyopencv_quality_QualityBRISQUE_methods[] =
| 82028 | { |  | 81980 | {
| 82029 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBRISQUE_compute, 0), "compute(img) -> retval\n. @brief Computes BRISQUE quality score for input image\n. @param img Image for which to compute quality\n. @returns cv::Scalar with the score in the first element. The score ranges from 0 (best quality) to 100 (worst quality)\n\n\n\ncompute(img, model_file_path, range_file_path) -> retval\n. @brief static method for computing quality\n. @param img image for which to compute quality\n. @param model_file_path cv::String which contains a path to the BRISQUE model data, eg. /path/to/brisque_model_live.yml\n. @param range_file_path cv::String which contains a path to the BRISQUE range data, eg. /path/to/brisque_range_live.yml\n. @returns cv::Scalar with the score in the first element. The score ranges from 0 (best quality) to 100 (worst quality)"}, |  | 81981 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBRISQUE_compute, 0), "compute(img) -> retval\n. @brief Computes BRISQUE quality score for input image\n. @param img Image for which to compute quality\n. @returns cv::Scalar with the score in the first element. The score ranges from 0 (best quality) to 100 (worst quality)\n\n\n\ncompute(img, model_file_path, range_file_path) -> retval\n. @brief static method for computing quality\n. @param img image for which to compute quality\n. @param model_file_path cv::String which contains a path to the BRISQUE model data, eg. /path/to/brisque_model_live.yml\n. @param range_file_path cv::String which contains a path to the BRISQUE range data, eg. /path/to/brisque_range_live.yml\n. @returns cv::Scalar with the score in the first element. The score ranges from 0 (best quality) to 100 (worst quality)"},
| 82030 | {"computeFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBRISQUE_computeFeatures_static, METH_STATIC), "computeFeatures(img[, features]) -> features\n. @brief static method for computing image features used by the BRISQUE algorithm\n. @param img image (BGR(A) or grayscale) for which to compute features\n. @param features output row vector of features to cv::Mat or cv::UMat"}, |  | 81982 | {"computeFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBRISQUE_computeFeatures_static, METH_STATIC), "computeFeatures(img[, features]) -> features\n. @brief static method for computing image features used by the BRISQUE algorithm\n. @param img image (BGR(A) or grayscale) for which to compute features\n. @param features output row vector of features to cv::Mat or cv::UMat"},
| 82031 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBRISQUE_create_static, METH_STATIC), "create(model_file_path, range_file_path) -> retval\n. @brief Create an object which calculates quality\n. @param model_file_path cv::String which contains a path to the BRISQUE model data, eg. /path/to/brisque_model_live.yml\n. @param range_file_path cv::String which contains a path to the BRISQUE range data, eg. /path/to/brisque_range_live.yml\n\n\n\ncreate(model, range) -> retval\n. @brief Create an object which calculates quality\n. @param model cv::Ptr<cv::ml::SVM> which contains a loaded BRISQUE model\n. @param range cv::Mat which contains BRISQUE range data"}, |  | 81983 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBRISQUE_create_static, METH_STATIC), "create(model_file_path, range_file_path) -> retval\n. @brief Create an object which calculates quality\n. @param model_file_path cv::String which contains a path to the BRISQUE model data, eg. /path/to/brisque_model_live.yml\n. @param range_file_path cv::String which contains a path to the BRISQUE range data, eg. /path/to/brisque_range_live.yml\n\n\n\ncreate(model, range) -> retval\n. @brief Create an object which calculates quality\n. @param model cv::Ptr<cv::ml::SVM> which contains a loaded BRISQUE model\n. @param range cv::Mat which contains BRISQUE range data"},
| 82032 |  |  | 81984 |
| 82033 | {NULL, NULL} |  | 81985 | {NULL, NULL}
| 82034 | }; |  | 81986 | };
| 82035 |  |  | 81987 |
| 82036 | // Converter (quality_QualityBRISQUE) |  | 81988 | // Converter (quality_QualityBRISQUE)
| 82037 |  |  | 81989 |
| 82038 | template<> |  | 81990 | template<>
| 82039 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityBRISQUE> > |  | 81991 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityBRISQUE> >
| 82040 | { |  | 81992 | {
| 82041 | static PyObject* from(const Ptr<cv::quality::QualityBRISQUE>& r) |  | 81993 | static PyObject* from(const Ptr<cv::quality::QualityBRISQUE>& r)
| 82042 | { |  | 81994 | {
| 82043 | return pyopencv_quality_QualityBRISQUE_Instance(r); |  | 81995 | return pyopencv_quality_QualityBRISQUE_Instance(r);
| 82044 | } |  | 81996 | }
| 82045 | static bool to(PyObject* src, Ptr<cv::quality::QualityBRISQUE>& dst, const ArgInfo& info) |  | 81997 | static bool to(PyObject* src, Ptr<cv::quality::QualityBRISQUE>& dst, const ArgInfo& info)
| 82046 | { |  | 81998 | {
| 82047 | if(!src || src == Py_None) |  | 81999 | if(!src || src == Py_None)
| 82048 | return true; |  | 82000 | return true;
| 82049 | Ptr<cv::quality::QualityBRISQUE> * dst_; |  | 82001 | Ptr<cv::quality::QualityBRISQUE> * dst_;
| 82050 | if (pyopencv_quality_QualityBRISQUE_getp(src, dst_)) |  | 82002 | if (pyopencv_quality_QualityBRISQUE_getp(src, dst_))
| 82051 | { |  | 82003 | {
| 82052 | dst = *dst_; |  | 82004 | dst = *dst_;
| 82053 | return true; |  | 82005 | return true;
| 82054 | } |  | 82006 | }
| 82055 |  |  | 82007 |
| 82056 | failmsg("Expected Ptr<cv::quality::QualityBRISQUE> for argument '%s'", info.name); |  | 82008 | failmsg("Expected Ptr<cv::quality::QualityBRISQUE> for argument '%s'", info.name);
| 82057 | return false; |  | 82009 | return false;
| 82058 | } |  | 82010 | }
| 82059 | }; |  | 82011 | };
| 82060 |  |  | 82012 |
| 82061 | //================================================================================ |  | 82013 | //================================================================================
| 82062 | // quality_QualityBase (Generic) |  | 82014 | // quality_QualityBase (Generic)
| 82063 | //================================================================================ |  | 82015 | //================================================================================
| 82064 |  |  | 82016 |
| 82065 | // GetSet (quality_QualityBase) |  | 82017 | // GetSet (quality_QualityBase)
| 82066 |  |  | 82018 |
| 82067 |  |  | 82019 |
| 82068 |  |  | 82020 |
| 82069 | // Methods (quality_QualityBase) |  | 82021 | // Methods (quality_QualityBase)
| 82070 |  |  | 82022 |
| 82071 | static PyObject* pyopencv_cv_quality_quality_QualityBase_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82023 | static PyObject* pyopencv_cv_quality_quality_QualityBase_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 82072 | { |  | 82024 | {
| 82073 | using namespace cv::quality; |  | 82025 | using namespace cv::quality;
| 82074 |  |  | 82026 |
| 82075 |  |  | 82027 |
| 82076 | Ptr<cv::quality::QualityBase> * self1 = 0; |  | 82028 | Ptr<cv::quality::QualityBase> * self1 = 0;
| 82077 | if (!pyopencv_quality_QualityBase_getp(self, self1)) |  | 82029 | if (!pyopencv_quality_QualityBase_getp(self, self1))
| 82078 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)"); |  | 82030 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)");
| 82079 | Ptr<cv::quality::QualityBase> _self_ = *(self1); |  | 82031 | Ptr<cv::quality::QualityBase> _self_ = *(self1);
| 82080 |  |  | 82032 |
| 82081 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82033 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82082 | { |  | 82034 | {
| 82083 | ERRWRAP2(_self_->clear()); |  | 82035 | ERRWRAP2(_self_->clear());
| 82084 | Py_RETURN_NONE; |  | 82036 | Py_RETURN_NONE;
| 82085 | } |  | 82037 | }
| 82086 |  |  | 82038 |
| 82087 | return NULL; |  | 82039 | return NULL;
| 82088 | } |  | 82040 | }
| 82089 |  |  | 82041 |
| 82090 | static PyObject* pyopencv_cv_quality_quality_QualityBase_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82042 | static PyObject* pyopencv_cv_quality_quality_QualityBase_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 82091 | { |  | 82043 | {
| 82092 | using namespace cv::quality; |  | 82044 | using namespace cv::quality;
| 82093 |  |  | 82045 |
| 82094 |  |  | 82046 |
| 82095 | Ptr<cv::quality::QualityBase> * self1 = 0; |  | 82047 | Ptr<cv::quality::QualityBase> * self1 = 0;
| 82096 | if (!pyopencv_quality_QualityBase_getp(self, self1)) |  | 82048 | if (!pyopencv_quality_QualityBase_getp(self, self1))
| 82097 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)"); |  | 82049 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)");
| 82098 | Ptr<cv::quality::QualityBase> _self_ = *(self1); |  | 82050 | Ptr<cv::quality::QualityBase> _self_ = *(self1);
| 82099 | pyPrepareArgumentConversionErrorsStorage(2); |  | 82051 | pyPrepareArgumentConversionErrorsStorage(2);
| 82100 |  |  | 82052 |
| 82101 | { |  | 82053 | {
| 82102 | PyObject* pyobj_img = NULL; |  | 82054 | PyObject* pyobj_img = NULL;
| 82103 | Mat img; |  | 82055 | Mat img;
| 82104 | cv::Scalar retval; |  | 82056 | cv::Scalar retval;
| 82105 |  |  | 82057 |
| 82106 | const char* keywords[] = { "img", NULL }; |  | 82058 | const char* keywords[] = { "img", NULL };
| 82107 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBase.compute", (char**)keywords, &pyobj_img) && |  | 82059 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBase.compute", (char**)keywords, &pyobj_img) &&
| 82108 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) ) |  | 82060 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) )
| 82109 | { |  | 82061 | {
| 82110 | ERRWRAP2(retval = _self_->compute(img)); |  | 82062 | ERRWRAP2(retval = _self_->compute(img));
| 82111 | return pyopencv_from(retval); |  | 82063 | return pyopencv_from(retval);
| 82112 | } |  | 82064 | }
| 82113 |  |  | 82065 |
| 82114 |  |  | 82066 |
| 82115 | pyPopulateArgumentConversionErrors(); |  | 82067 | pyPopulateArgumentConversionErrors();
| 82116 | } |  | 82068 | }
| 82117 |  |  | 82069 |
| 82118 |  |  | 82070 |
| 82119 | { |  | 82071 | {
| 82120 | PyObject* pyobj_img = NULL; |  | 82072 | PyObject* pyobj_img = NULL;
| 82121 | UMat img; |  | 82073 | UMat img;
| 82122 | cv::Scalar retval; |  | 82074 | cv::Scalar retval;
| 82123 |  |  | 82075 |
| 82124 | const char* keywords[] = { "img", NULL }; |  | 82076 | const char* keywords[] = { "img", NULL };
| 82125 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBase.compute", (char**)keywords, &pyobj_img) && |  | 82077 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityBase.compute", (char**)keywords, &pyobj_img) &&
| 82126 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) ) |  | 82078 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) )
| 82127 | { |  | 82079 | {
| 82128 | ERRWRAP2(retval = _self_->compute(img)); |  | 82080 | ERRWRAP2(retval = _self_->compute(img));
| 82129 | return pyopencv_from(retval); |  | 82081 | return pyopencv_from(retval);
| 82130 | } |  | 82082 | }
| 82131 |  |  | 82083 |
| 82132 |  |  | 82084 |
| 82133 | pyPopulateArgumentConversionErrors(); |  | 82085 | pyPopulateArgumentConversionErrors();
| 82134 | } |  | 82086 | }
| 82135 | pyRaiseCVOverloadException("compute"); |  | 82087 | pyRaiseCVOverloadException("compute");
| 82136 |  |  | 82088 |
| 82137 | return NULL; |  | 82089 | return NULL;
| 82138 | } |  | 82090 | }
| 82139 |  |  | 82091 |
| 82140 | static PyObject* pyopencv_cv_quality_quality_QualityBase_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82092 | static PyObject* pyopencv_cv_quality_quality_QualityBase_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 82141 | { |  | 82093 | {
| 82142 | using namespace cv::quality; |  | 82094 | using namespace cv::quality;
| 82143 |  |  | 82095 |
| 82144 |  |  | 82096 |
| 82145 | Ptr<cv::quality::QualityBase> * self1 = 0; |  | 82097 | Ptr<cv::quality::QualityBase> * self1 = 0;
| 82146 | if (!pyopencv_quality_QualityBase_getp(self, self1)) |  | 82098 | if (!pyopencv_quality_QualityBase_getp(self, self1))
| 82147 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)"); |  | 82099 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)");
| 82148 | Ptr<cv::quality::QualityBase> _self_ = *(self1); |  | 82100 | Ptr<cv::quality::QualityBase> _self_ = *(self1);
| 82149 | bool retval; |  | 82101 | bool retval;
| 82150 |  |  | 82102 |
| 82151 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82103 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82152 | { |  | 82104 | {
| 82153 | ERRWRAP2(retval = _self_->empty()); |  | 82105 | ERRWRAP2(retval = _self_->empty());
| 82154 | return pyopencv_from(retval); |  | 82106 | return pyopencv_from(retval);
| 82155 | } |  | 82107 | }
| 82156 |  |  | 82108 |
| 82157 | return NULL; |  | 82109 | return NULL;
| 82158 | } |  | 82110 | }
| 82159 |  |  | 82111 |
| 82160 | static PyObject* pyopencv_cv_quality_quality_QualityBase_getQualityMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82112 | static PyObject* pyopencv_cv_quality_quality_QualityBase_getQualityMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 82161 | { |  | 82113 | {
| 82162 | using namespace cv::quality; |  | 82114 | using namespace cv::quality;
| 82163 |  |  | 82115 |
| 82164 |  |  | 82116 |
| 82165 | Ptr<cv::quality::QualityBase> * self1 = 0; |  | 82117 | Ptr<cv::quality::QualityBase> * self1 = 0;
| 82166 | if (!pyopencv_quality_QualityBase_getp(self, self1)) |  | 82118 | if (!pyopencv_quality_QualityBase_getp(self, self1))
| 82167 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)"); |  | 82119 | return failmsgp("Incorrect type of self (must be 'quality_QualityBase' or its derivative)");
| 82168 | Ptr<cv::quality::QualityBase> _self_ = *(self1); |  | 82120 | Ptr<cv::quality::QualityBase> _self_ = *(self1);
| 82169 | pyPrepareArgumentConversionErrorsStorage(2); |  | 82121 | pyPrepareArgumentConversionErrorsStorage(2);
| 82170 |  |  | 82122 |
| 82171 | { |  | 82123 | {
| 82172 | PyObject* pyobj_dst = NULL; |  | 82124 | PyObject* pyobj_dst = NULL;
| 82173 | Mat dst; |  | 82125 | Mat dst;
| 82174 |  |  | 82126 |
| 82175 | const char* keywords[] = { "dst", NULL }; |  | 82127 | const char* keywords[] = { "dst", NULL };
| 82176 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:quality_QualityBase.getQualityMap", (char**)keywords, &pyobj_dst) && |  | 82128 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:quality_QualityBase.getQualityMap", (char**)keywords, &pyobj_dst) &&
| 82177 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 82129 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 82178 | { |  | 82130 | {
| 82179 | ERRWRAP2(_self_->getQualityMap(dst)); |  | 82131 | ERRWRAP2(_self_->getQualityMap(dst));
| 82180 | return pyopencv_from(dst); |  | 82132 | return pyopencv_from(dst);
| 82181 | } |  | 82133 | }
| 82182 |  |  | 82134 |
| 82183 |  |  | 82135 |
| 82184 | pyPopulateArgumentConversionErrors(); |  | 82136 | pyPopulateArgumentConversionErrors();
| 82185 | } |  | 82137 | }
| 82186 |  |  | 82138 |
| 82187 |  |  | 82139 |
| 82188 | { |  | 82140 | {
| 82189 | PyObject* pyobj_dst = NULL; |  | 82141 | PyObject* pyobj_dst = NULL;
| 82190 | UMat dst; |  | 82142 | UMat dst;
| 82191 |  |  | 82143 |
| 82192 | const char* keywords[] = { "dst", NULL }; |  | 82144 | const char* keywords[] = { "dst", NULL };
| 82193 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:quality_QualityBase.getQualityMap", (char**)keywords, &pyobj_dst) && |  | 82145 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:quality_QualityBase.getQualityMap", (char**)keywords, &pyobj_dst) &&
| 82194 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) ) |  | 82146 | pyopencv_to_safe(pyobj_dst, dst, ArgInfo("dst", 1)) )
| 82195 | { |  | 82147 | {
| 82196 | ERRWRAP2(_self_->getQualityMap(dst)); |  | 82148 | ERRWRAP2(_self_->getQualityMap(dst));
| 82197 | return pyopencv_from(dst); |  | 82149 | return pyopencv_from(dst);
| 82198 | } |  | 82150 | }
| 82199 |  |  | 82151 |
| 82200 |  |  | 82152 |
| 82201 | pyPopulateArgumentConversionErrors(); |  | 82153 | pyPopulateArgumentConversionErrors();
| 82202 | } |  | 82154 | }
| 82203 | pyRaiseCVOverloadException("getQualityMap"); |  | 82155 | pyRaiseCVOverloadException("getQualityMap");
| 82204 |  |  | 82156 |
| 82205 | return NULL; |  | 82157 | return NULL;
| 82206 | } |  | 82158 | }
| 82207 |  |  | 82159 |
| 82208 |  |  | 82160 |
| 82209 |  |  | 82161 |
| 82210 | // Tables (quality_QualityBase) |  | 82162 | // Tables (quality_QualityBase)
| 82211 |  |  | 82163 |
| 82212 | static PyGetSetDef pyopencv_quality_QualityBase_getseters[] = |  | 82164 | static PyGetSetDef pyopencv_quality_QualityBase_getseters[] =
| 82213 | { |  | 82165 | {
| 82214 | {NULL} /* Sentinel */ |  | 82166 | {NULL} /* Sentinel */
| 82215 | }; |  | 82167 | };
| 82216 |  |  | 82168 |
| 82217 | static PyMethodDef pyopencv_quality_QualityBase_methods[] = |  | 82169 | static PyMethodDef pyopencv_quality_QualityBase_methods[] =
| 82218 | { |  | 82170 | {
| 82219 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"}, |  | 82171 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"},
| 82220 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_compute, 0), "compute(img) -> retval\n. @brief Compute quality score per channel with the per-channel score in each element of the resulting cv::Scalar. See specific algorithm for interpreting result scores\n. @param img comparison image, or image to evalute for no-reference quality algorithms"}, |  | 82172 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_compute, 0), "compute(img) -> retval\n. @brief Compute quality score per channel with the per-channel score in each element of the resulting cv::Scalar. See specific algorithm for interpreting result scores\n. @param img comparison image, or image to evalute for no-reference quality algorithms"},
| 82221 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"}, |  | 82173 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"},
| 82222 | {"getQualityMap", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_getQualityMap, 0), "getQualityMap([, dst]) -> dst\n. @brief Returns output quality map that was generated during computation, if supported by the algorithm"}, |  | 82174 | {"getQualityMap", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityBase_getQualityMap, 0), "getQualityMap([, dst]) -> dst\n. @brief Returns output quality map that was generated during computation, if supported by the algorithm"},
| 82223 |  |  | 82175 |
| 82224 | {NULL, NULL} |  | 82176 | {NULL, NULL}
| 82225 | }; |  | 82177 | };
| 82226 |  |  | 82178 |
| 82227 | // Converter (quality_QualityBase) |  | 82179 | // Converter (quality_QualityBase)
| 82228 |  |  | 82180 |
| 82229 | template<> |  | 82181 | template<>
| 82230 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityBase> > |  | 82182 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityBase> >
| 82231 | { |  | 82183 | {
| 82232 | static PyObject* from(const Ptr<cv::quality::QualityBase>& r) |  | 82184 | static PyObject* from(const Ptr<cv::quality::QualityBase>& r)
| 82233 | { |  | 82185 | {
| 82234 | return pyopencv_quality_QualityBase_Instance(r); |  | 82186 | return pyopencv_quality_QualityBase_Instance(r);
| 82235 | } |  | 82187 | }
| 82236 | static bool to(PyObject* src, Ptr<cv::quality::QualityBase>& dst, const ArgInfo& info) |  | 82188 | static bool to(PyObject* src, Ptr<cv::quality::QualityBase>& dst, const ArgInfo& info)
| 82237 | { |  | 82189 | {
| 82238 | if(!src || src == Py_None) |  | 82190 | if(!src || src == Py_None)
| 82239 | return true; |  | 82191 | return true;
| 82240 | Ptr<cv::quality::QualityBase> * dst_; |  | 82192 | Ptr<cv::quality::QualityBase> * dst_;
| 82241 | if (pyopencv_quality_QualityBase_getp(src, dst_)) |  | 82193 | if (pyopencv_quality_QualityBase_getp(src, dst_))
| 82242 | { |  | 82194 | {
| 82243 | dst = *dst_; |  | 82195 | dst = *dst_;
| 82244 | return true; |  | 82196 | return true;
| 82245 | } |  | 82197 | }
| 82246 |  |  | 82198 |
| 82247 | failmsg("Expected Ptr<cv::quality::QualityBase> for argument '%s'", info.name); |  | 82199 | failmsg("Expected Ptr<cv::quality::QualityBase> for argument '%s'", info.name);
| 82248 | return false; |  | 82200 | return false;
| 82249 | } |  | 82201 | }
| 82250 | }; |  | 82202 | };
| 82251 |  |  | 82203 |
| 82252 | //================================================================================ |  | 82204 | //================================================================================
| 82253 | // quality_QualityGMSD (Generic) |  | 82205 | // quality_QualityGMSD (Generic)
| 82254 | //================================================================================ |  | 82206 | //================================================================================
| 82255 |  |  | 82207 |
| 82256 | // GetSet (quality_QualityGMSD) |  | 82208 | // GetSet (quality_QualityGMSD)
| 82257 |  |  | 82209 |
| 82258 |  |  | 82210 |
| 82259 |  |  | 82211 |
| 82260 | // Methods (quality_QualityGMSD) |  | 82212 | // Methods (quality_QualityGMSD)
| 82261 |  |  | 82213 |
| 82262 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82214 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 82263 | { |  | 82215 | {
| 82264 | using namespace cv::quality; |  | 82216 | using namespace cv::quality;
| 82265 |  |  | 82217 |
| 82266 |  |  | 82218 |
| 82267 | Ptr<cv::quality::QualityGMSD> * self1 = 0; |  | 82219 | Ptr<cv::quality::QualityGMSD> * self1 = 0;
| 82268 | if (!pyopencv_quality_QualityGMSD_getp(self, self1)) |  | 82220 | if (!pyopencv_quality_QualityGMSD_getp(self, self1))
| 82269 | return failmsgp("Incorrect type of self (must be 'quality_QualityGMSD' or its derivative)"); |  | 82221 | return failmsgp("Incorrect type of self (must be 'quality_QualityGMSD' or its derivative)");
| 82270 | Ptr<cv::quality::QualityGMSD> _self_ = *(self1); |  | 82222 | Ptr<cv::quality::QualityGMSD> _self_ = *(self1);
| 82271 |  |  | 82223 |
| 82272 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82224 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82273 | { |  | 82225 | {
| 82274 | ERRWRAP2(_self_->clear()); |  | 82226 | ERRWRAP2(_self_->clear());
| 82275 | Py_RETURN_NONE; |  | 82227 | Py_RETURN_NONE;
| 82276 | } |  | 82228 | }
| 82277 |  |  | 82229 |
| 82278 | return NULL; |  | 82230 | return NULL;
| 82279 | } |  | 82231 | }
| 82280 |  |  | 82232 |
| 82281 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82233 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 82282 | { |  | 82234 | {
| 82283 | using namespace cv::quality; |  | 82235 | using namespace cv::quality;
| 82284 |  |  | 82236 |
| 82285 |  |  | 82237 |
| 82286 | Ptr<cv::quality::QualityGMSD> * self1 = 0; |  | 82238 | Ptr<cv::quality::QualityGMSD> * self1 = 0;
| 82287 | if (!pyopencv_quality_QualityGMSD_getp(self, self1)) |  | 82239 | if (!pyopencv_quality_QualityGMSD_getp(self, self1))
| 82288 | return failmsgp("Incorrect type of self (must be 'quality_QualityGMSD' or its derivative)"); |  | 82240 | return failmsgp("Incorrect type of self (must be 'quality_QualityGMSD' or its derivative)");
| 82289 | Ptr<cv::quality::QualityGMSD> _self_ = *(self1); |  | 82241 | Ptr<cv::quality::QualityGMSD> _self_ = *(self1);
| 82290 | pyPrepareArgumentConversionErrorsStorage(4); |  | 82242 | pyPrepareArgumentConversionErrorsStorage(4);
| 82291 |  |  | 82243 |
| 82292 | { |  | 82244 | {
| 82293 | PyObject* pyobj_cmp = NULL; |  | 82245 | PyObject* pyobj_cmp = NULL;
| 82294 | Mat cmp; |  | 82246 | Mat cmp;
| 82295 | cv::Scalar retval; |  | 82247 | cv::Scalar retval;
| 82296 |  |  | 82248 |
| 82297 | const char* keywords[] = { "cmp", NULL }; |  | 82249 | const char* keywords[] = { "cmp", NULL };
| 82298 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_cmp) && |  | 82250 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_cmp) &&
| 82299 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) ) |  | 82251 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) )
| 82300 | { |  | 82252 | {
| 82301 | ERRWRAP2(retval = _self_->compute(cmp)); |  | 82253 | ERRWRAP2(retval = _self_->compute(cmp));
| 82302 | return pyopencv_from(retval); |  | 82254 | return pyopencv_from(retval);
| 82303 | } |  | 82255 | }
| 82304 |  |  | 82256 |
| 82305 |  |  | 82257 |
| 82306 | pyPopulateArgumentConversionErrors(); |  | 82258 | pyPopulateArgumentConversionErrors();
| 82307 | } |  | 82259 | }
| 82308 |  |  | 82260 |
| 82309 |  |  | 82261 |
| 82310 | { |  | 82262 | {
| 82311 | PyObject* pyobj_ref = NULL; |  | 82263 | PyObject* pyobj_ref = NULL;
| 82312 | Mat ref; |  | 82264 | Mat ref;
| 82313 | PyObject* pyobj_cmp = NULL; |  | 82265 | PyObject* pyobj_cmp = NULL;
| 82314 | Mat cmp; |  | 82266 | Mat cmp;
| 82315 | PyObject* pyobj_qualityMap = NULL; |  | 82267 | PyObject* pyobj_qualityMap = NULL;
| 82316 | Mat qualityMap; |  | 82268 | Mat qualityMap;
| 82317 | cv::Scalar retval; |  | 82269 | cv::Scalar retval;
| 82318 |  |  | 82270 |
| 82319 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL }; |  | 82271 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL };
| 82320 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) && |  | 82272 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) &&
| 82321 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82273 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82322 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 82274 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 82323 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) ) |  | 82275 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) )
| 82324 | { |  | 82276 | {
| 82325 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap)); |  | 82277 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap));
| 82326 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 82278 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 82327 | } |  | 82279 | }
| 82328 |  |  | 82280 |
| 82329 |  |  | 82281 |
| 82330 | pyPopulateArgumentConversionErrors(); |  | 82282 | pyPopulateArgumentConversionErrors();
| 82331 | } |  | 82283 | }
| 82332 |  |  | 82284 |
| 82333 |  |  | 82285 |
| 82334 | { |  | 82286 | {
| 82335 | PyObject* pyobj_cmp = NULL; |  | 82287 | PyObject* pyobj_cmp = NULL;
| 82336 | UMat cmp; |  | 82288 | UMat cmp;
| 82337 | cv::Scalar retval; |  | 82289 | cv::Scalar retval;
| 82338 |  |  | 82290 |
| 82339 | const char* keywords[] = { "cmp", NULL }; |  | 82291 | const char* keywords[] = { "cmp", NULL };
| 82340 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_cmp) && |  | 82292 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_cmp) &&
| 82341 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) ) |  | 82293 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) )
| 82342 | { |  | 82294 | {
| 82343 | ERRWRAP2(retval = _self_->compute(cmp)); |  | 82295 | ERRWRAP2(retval = _self_->compute(cmp));
| 82344 | return pyopencv_from(retval); |  | 82296 | return pyopencv_from(retval);
| 82345 | } |  | 82297 | }
| 82346 |  |  | 82298 |
| 82347 |  |  | 82299 |
| 82348 | pyPopulateArgumentConversionErrors(); |  | 82300 | pyPopulateArgumentConversionErrors();
| 82349 | } |  | 82301 | }
| 82350 |  |  | 82302 |
| 82351 |  |  | 82303 |
| 82352 | { |  | 82304 | {
| 82353 | PyObject* pyobj_ref = NULL; |  | 82305 | PyObject* pyobj_ref = NULL;
| 82354 | UMat ref; |  | 82306 | UMat ref;
| 82355 | PyObject* pyobj_cmp = NULL; |  | 82307 | PyObject* pyobj_cmp = NULL;
| 82356 | UMat cmp; |  | 82308 | UMat cmp;
| 82357 | PyObject* pyobj_qualityMap = NULL; |  | 82309 | PyObject* pyobj_qualityMap = NULL;
| 82358 | UMat qualityMap; |  | 82310 | UMat qualityMap;
| 82359 | cv::Scalar retval; |  | 82311 | cv::Scalar retval;
| 82360 |  |  | 82312 |
| 82361 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL }; |  | 82313 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL };
| 82362 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) && |  | 82314 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityGMSD.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) &&
| 82363 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82315 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82364 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 82316 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 82365 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) ) |  | 82317 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) )
| 82366 | { |  | 82318 | {
| 82367 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap)); |  | 82319 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap));
| 82368 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 82320 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 82369 | } |  | 82321 | }
| 82370 |  |  | 82322 |
| 82371 |  |  | 82323 |
| 82372 | pyPopulateArgumentConversionErrors(); |  | 82324 | pyPopulateArgumentConversionErrors();
| 82373 | } |  | 82325 | }
| 82374 | pyRaiseCVOverloadException("compute"); |  | 82326 | pyRaiseCVOverloadException("compute");
| 82375 |  |  | 82327 |
| 82376 | return NULL; |  | 82328 | return NULL;
| 82377 | } |  | 82329 | }
| 82378 |  |  | 82330 |
| 82379 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82331 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 82380 | { |  | 82332 | {
| 82381 | using namespace cv::quality; |  | 82333 | using namespace cv::quality;
| 82382 |  |  | 82334 |
| 82383 | pyPrepareArgumentConversionErrorsStorage(2); |  | 82335 | pyPrepareArgumentConversionErrorsStorage(2);
| 82384 |  |  | 82336 |
| 82385 | { |  | 82337 | {
| 82386 | PyObject* pyobj_ref = NULL; |  | 82338 | PyObject* pyobj_ref = NULL;
| 82387 | Mat ref; |  | 82339 | Mat ref;
| 82388 | Ptr<QualityGMSD> retval; |  | 82340 | Ptr<QualityGMSD> retval;
| 82389 |  |  | 82341 |
| 82390 | const char* keywords[] = { "ref", NULL }; |  | 82342 | const char* keywords[] = { "ref", NULL };
| 82391 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.create", (char**)keywords, &pyobj_ref) && |  | 82343 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.create", (char**)keywords, &pyobj_ref) &&
| 82392 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) ) |  | 82344 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) )
| 82393 | { |  | 82345 | {
| 82394 | ERRWRAP2(retval = cv::quality::QualityGMSD::create(ref)); |  | 82346 | ERRWRAP2(retval = cv::quality::QualityGMSD::create(ref));
| 82395 | return pyopencv_from(retval); |  | 82347 | return pyopencv_from(retval);
| 82396 | } |  | 82348 | }
| 82397 |  |  | 82349 |
| 82398 |  |  | 82350 |
| 82399 | pyPopulateArgumentConversionErrors(); |  | 82351 | pyPopulateArgumentConversionErrors();
| 82400 | } |  | 82352 | }
| 82401 |  |  | 82353 |
| 82402 |  |  | 82354 |
| 82403 | { |  | 82355 | {
| 82404 | PyObject* pyobj_ref = NULL; |  | 82356 | PyObject* pyobj_ref = NULL;
| 82405 | UMat ref; |  | 82357 | UMat ref;
| 82406 | Ptr<QualityGMSD> retval; |  | 82358 | Ptr<QualityGMSD> retval;
| 82407 |  |  | 82359 |
| 82408 | const char* keywords[] = { "ref", NULL }; |  | 82360 | const char* keywords[] = { "ref", NULL };
| 82409 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.create", (char**)keywords, &pyobj_ref) && |  | 82361 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityGMSD.create", (char**)keywords, &pyobj_ref) &&
| 82410 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) ) |  | 82362 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) )
| 82411 | { |  | 82363 | {
| 82412 | ERRWRAP2(retval = cv::quality::QualityGMSD::create(ref)); |  | 82364 | ERRWRAP2(retval = cv::quality::QualityGMSD::create(ref));
| 82413 | return pyopencv_from(retval); |  | 82365 | return pyopencv_from(retval);
| 82414 | } |  | 82366 | }
| 82415 |  |  | 82367 |
| 82416 |  |  | 82368 |
| 82417 | pyPopulateArgumentConversionErrors(); |  | 82369 | pyPopulateArgumentConversionErrors();
| 82418 | } |  | 82370 | }
| 82419 | pyRaiseCVOverloadException("create"); |  | 82371 | pyRaiseCVOverloadException("create");
| 82420 |  |  | 82372 |
| 82421 | return NULL; |  | 82373 | return NULL;
| 82422 | } |  | 82374 | }
| 82423 |  |  | 82375 |
| 82424 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82376 | static PyObject* pyopencv_cv_quality_quality_QualityGMSD_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 82425 | { |  | 82377 | {
| 82426 | using namespace cv::quality; |  | 82378 | using namespace cv::quality;
| 82427 |  |  | 82379 |
| 82428 |  |  | 82380 |
| 82429 | Ptr<cv::quality::QualityGMSD> * self1 = 0; |  | 82381 | Ptr<cv::quality::QualityGMSD> * self1 = 0;
| 82430 | if (!pyopencv_quality_QualityGMSD_getp(self, self1)) |  | 82382 | if (!pyopencv_quality_QualityGMSD_getp(self, self1))
| 82431 | return failmsgp("Incorrect type of self (must be 'quality_QualityGMSD' or its derivative)"); |  | 82383 | return failmsgp("Incorrect type of self (must be 'quality_QualityGMSD' or its derivative)");
| 82432 | Ptr<cv::quality::QualityGMSD> _self_ = *(self1); |  | 82384 | Ptr<cv::quality::QualityGMSD> _self_ = *(self1);
| 82433 | bool retval; |  | 82385 | bool retval;
| 82434 |  |  | 82386 |
| 82435 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82387 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82436 | { |  | 82388 | {
| 82437 | ERRWRAP2(retval = _self_->empty()); |  | 82389 | ERRWRAP2(retval = _self_->empty());
| 82438 | return pyopencv_from(retval); |  | 82390 | return pyopencv_from(retval);
| 82439 | } |  | 82391 | }
| 82440 |  |  | 82392 |
| 82441 | return NULL; |  | 82393 | return NULL;
| 82442 | } |  | 82394 | }
| 82443 |  |  | 82395 |
| 82444 |  |  | 82396 |
| 82445 |  |  | 82397 |
| 82446 | // Tables (quality_QualityGMSD) |  | 82398 | // Tables (quality_QualityGMSD)
| 82447 |  |  | 82399 |
| 82448 | static PyGetSetDef pyopencv_quality_QualityGMSD_getseters[] = |  | 82400 | static PyGetSetDef pyopencv_quality_QualityGMSD_getseters[] =
| 82449 | { |  | 82401 | {
| 82450 | {NULL} /* Sentinel */ |  | 82402 | {NULL} /* Sentinel */
| 82451 | }; |  | 82403 | };
| 82452 |  |  | 82404 |
| 82453 | static PyMethodDef pyopencv_quality_QualityGMSD_methods[] = |  | 82405 | static PyMethodDef pyopencv_quality_QualityGMSD_methods[] =
| 82454 | { |  | 82406 | {
| 82455 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"}, |  | 82407 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"},
| 82456 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_compute, 0), "compute(cmp) -> retval\n. @brief Compute GMSD\n. @param cmp comparison image\n. @returns cv::Scalar with per-channel quality value. Values range from 0 (worst) to 1 (best)\n\n\n\ncompute(ref, cmp[, qualityMap]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image\n. @param qualityMap output quality map, or cv::noArray()\n. @returns cv::Scalar with per-channel quality value. Values range from 0 (worst) to 1 (best)"}, |  | 82408 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_compute, 0), "compute(cmp) -> retval\n. @brief Compute GMSD\n. @param cmp comparison image\n. @returns cv::Scalar with per-channel quality value. Values range from 0 (worst) to 1 (best)\n\n\n\ncompute(ref, cmp[, qualityMap]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image\n. @param qualityMap output quality map, or cv::noArray()\n. @returns cv::Scalar with per-channel quality value. Values range from 0 (worst) to 1 (best)"},
| 82457 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_create_static, METH_STATIC), "create(ref) -> retval\n. @brief Create an object which calculates image quality\n. @param ref reference image"}, |  | 82409 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_create_static, METH_STATIC), "create(ref) -> retval\n. @brief Create an object which calculates image quality\n. @param ref reference image"},
| 82458 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"}, |  | 82410 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityGMSD_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"},
| 82459 |  |  | 82411 |
| 82460 | {NULL, NULL} |  | 82412 | {NULL, NULL}
| 82461 | }; |  | 82413 | };
| 82462 |  |  | 82414 |
| 82463 | // Converter (quality_QualityGMSD) |  | 82415 | // Converter (quality_QualityGMSD)
| 82464 |  |  | 82416 |
| 82465 | template<> |  | 82417 | template<>
| 82466 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityGMSD> > |  | 82418 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityGMSD> >
| 82467 | { |  | 82419 | {
| 82468 | static PyObject* from(const Ptr<cv::quality::QualityGMSD>& r) |  | 82420 | static PyObject* from(const Ptr<cv::quality::QualityGMSD>& r)
| 82469 | { |  | 82421 | {
| 82470 | return pyopencv_quality_QualityGMSD_Instance(r); |  | 82422 | return pyopencv_quality_QualityGMSD_Instance(r);
| 82471 | } |  | 82423 | }
| 82472 | static bool to(PyObject* src, Ptr<cv::quality::QualityGMSD>& dst, const ArgInfo& info) |  | 82424 | static bool to(PyObject* src, Ptr<cv::quality::QualityGMSD>& dst, const ArgInfo& info)
| 82473 | { |  | 82425 | {
| 82474 | if(!src || src == Py_None) |  | 82426 | if(!src || src == Py_None)
| 82475 | return true; |  | 82427 | return true;
| 82476 | Ptr<cv::quality::QualityGMSD> * dst_; |  | 82428 | Ptr<cv::quality::QualityGMSD> * dst_;
| 82477 | if (pyopencv_quality_QualityGMSD_getp(src, dst_)) |  | 82429 | if (pyopencv_quality_QualityGMSD_getp(src, dst_))
| 82478 | { |  | 82430 | {
| 82479 | dst = *dst_; |  | 82431 | dst = *dst_;
| 82480 | return true; |  | 82432 | return true;
| 82481 | } |  | 82433 | }
| 82482 |  |  | 82434 |
| 82483 | failmsg("Expected Ptr<cv::quality::QualityGMSD> for argument '%s'", info.name); |  | 82435 | failmsg("Expected Ptr<cv::quality::QualityGMSD> for argument '%s'", info.name);
| 82484 | return false; |  | 82436 | return false;
| 82485 | } |  | 82437 | }
| 82486 | }; |  | 82438 | };
| 82487 |  |  | 82439 |
| 82488 | //================================================================================ |  | 82440 | //================================================================================
| 82489 | // quality_QualityMSE (Generic) |  | 82441 | // quality_QualityMSE (Generic)
| 82490 | //================================================================================ |  | 82442 | //================================================================================
| 82491 |  |  | 82443 |
| 82492 | // GetSet (quality_QualityMSE) |  | 82444 | // GetSet (quality_QualityMSE)
| 82493 |  |  | 82445 |
| 82494 |  |  | 82446 |
| 82495 |  |  | 82447 |
| 82496 | // Methods (quality_QualityMSE) |  | 82448 | // Methods (quality_QualityMSE)
| 82497 |  |  | 82449 |
| 82498 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82450 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 82499 | { |  | 82451 | {
| 82500 | using namespace cv::quality; |  | 82452 | using namespace cv::quality;
| 82501 |  |  | 82453 |
| 82502 |  |  | 82454 |
| 82503 | Ptr<cv::quality::QualityMSE> * self1 = 0; |  | 82455 | Ptr<cv::quality::QualityMSE> * self1 = 0;
| 82504 | if (!pyopencv_quality_QualityMSE_getp(self, self1)) |  | 82456 | if (!pyopencv_quality_QualityMSE_getp(self, self1))
| 82505 | return failmsgp("Incorrect type of self (must be 'quality_QualityMSE' or its derivative)"); |  | 82457 | return failmsgp("Incorrect type of self (must be 'quality_QualityMSE' or its derivative)");
| 82506 | Ptr<cv::quality::QualityMSE> _self_ = *(self1); |  | 82458 | Ptr<cv::quality::QualityMSE> _self_ = *(self1);
| 82507 |  |  | 82459 |
| 82508 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82460 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82509 | { |  | 82461 | {
| 82510 | ERRWRAP2(_self_->clear()); |  | 82462 | ERRWRAP2(_self_->clear());
| 82511 | Py_RETURN_NONE; |  | 82463 | Py_RETURN_NONE;
| 82512 | } |  | 82464 | }
| 82513 |  |  | 82465 |
| 82514 | return NULL; |  | 82466 | return NULL;
| 82515 | } |  | 82467 | }
| 82516 |  |  | 82468 |
| 82517 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82469 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 82518 | { |  | 82470 | {
| 82519 | using namespace cv::quality; |  | 82471 | using namespace cv::quality;
| 82520 |  |  | 82472 |
| 82521 |  |  | 82473 |
| 82522 | Ptr<cv::quality::QualityMSE> * self1 = 0; |  | 82474 | Ptr<cv::quality::QualityMSE> * self1 = 0;
| 82523 | if (!pyopencv_quality_QualityMSE_getp(self, self1)) |  | 82475 | if (!pyopencv_quality_QualityMSE_getp(self, self1))
| 82524 | return failmsgp("Incorrect type of self (must be 'quality_QualityMSE' or its derivative)"); |  | 82476 | return failmsgp("Incorrect type of self (must be 'quality_QualityMSE' or its derivative)");
| 82525 | Ptr<cv::quality::QualityMSE> _self_ = *(self1); |  | 82477 | Ptr<cv::quality::QualityMSE> _self_ = *(self1);
| 82526 | pyPrepareArgumentConversionErrorsStorage(4); |  | 82478 | pyPrepareArgumentConversionErrorsStorage(4);
| 82527 |  |  | 82479 |
| 82528 | { |  | 82480 | {
| 82529 | PyObject* pyobj_cmpImgs = NULL; |  | 82481 | PyObject* pyobj_cmpImgs = NULL;
| 82530 | vector_Mat cmpImgs; |  | 82482 | vector_Mat cmpImgs;
| 82531 | cv::Scalar retval; |  | 82483 | cv::Scalar retval;
| 82532 |  |  | 82484 |
| 82533 | const char* keywords[] = { "cmpImgs", NULL }; |  | 82485 | const char* keywords[] = { "cmpImgs", NULL };
| 82534 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.compute", (char**)keywords, &pyobj_cmpImgs) && |  | 82486 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.compute", (char**)keywords, &pyobj_cmpImgs) &&
| 82535 | pyopencv_to_safe(pyobj_cmpImgs, cmpImgs, ArgInfo("cmpImgs", 0)) ) |  | 82487 | pyopencv_to_safe(pyobj_cmpImgs, cmpImgs, ArgInfo("cmpImgs", 0)) )
| 82536 | { |  | 82488 | {
| 82537 | ERRWRAP2(retval = _self_->compute(cmpImgs)); |  | 82489 | ERRWRAP2(retval = _self_->compute(cmpImgs));
| 82538 | return pyopencv_from(retval); |  | 82490 | return pyopencv_from(retval);
| 82539 | } |  | 82491 | }
| 82540 |  |  | 82492 |
| 82541 |  |  | 82493 |
| 82542 | pyPopulateArgumentConversionErrors(); |  | 82494 | pyPopulateArgumentConversionErrors();
| 82543 | } |  | 82495 | }
| 82544 |  |  | 82496 |
| 82545 |  |  | 82497 |
| 82546 | { |  | 82498 | {
| 82547 | PyObject* pyobj_ref = NULL; |  | 82499 | PyObject* pyobj_ref = NULL;
| 82548 | Mat ref; |  | 82500 | Mat ref;
| 82549 | PyObject* pyobj_cmp = NULL; |  | 82501 | PyObject* pyobj_cmp = NULL;
| 82550 | Mat cmp; |  | 82502 | Mat cmp;
| 82551 | PyObject* pyobj_qualityMap = NULL; |  | 82503 | PyObject* pyobj_qualityMap = NULL;
| 82552 | Mat qualityMap; |  | 82504 | Mat qualityMap;
| 82553 | cv::Scalar retval; |  | 82505 | cv::Scalar retval;
| 82554 |  |  | 82506 |
| 82555 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL }; |  | 82507 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL };
| 82556 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityMSE.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) && |  | 82508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityMSE.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) &&
| 82557 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82509 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82558 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 82510 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 82559 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) ) |  | 82511 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) )
| 82560 | { |  | 82512 | {
| 82561 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap)); |  | 82513 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap));
| 82562 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 82514 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 82563 | } |  | 82515 | }
| 82564 |  |  | 82516 |
| 82565 |  |  | 82517 |
| 82566 | pyPopulateArgumentConversionErrors(); |  | 82518 | pyPopulateArgumentConversionErrors();
| 82567 | } |  | 82519 | }
| 82568 |  |  | 82520 |
| 82569 |  |  | 82521 |
| 82570 | { |  | 82522 | {
| 82571 | PyObject* pyobj_cmpImgs = NULL; |  | 82523 | PyObject* pyobj_cmpImgs = NULL;
| 82572 | vector_UMat cmpImgs; |  | 82524 | vector_UMat cmpImgs;
| 82573 | cv::Scalar retval; |  | 82525 | cv::Scalar retval;
| 82574 |  |  | 82526 |
| 82575 | const char* keywords[] = { "cmpImgs", NULL }; |  | 82527 | const char* keywords[] = { "cmpImgs", NULL };
| 82576 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.compute", (char**)keywords, &pyobj_cmpImgs) && |  | 82528 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.compute", (char**)keywords, &pyobj_cmpImgs) &&
| 82577 | pyopencv_to_safe(pyobj_cmpImgs, cmpImgs, ArgInfo("cmpImgs", 0)) ) |  | 82529 | pyopencv_to_safe(pyobj_cmpImgs, cmpImgs, ArgInfo("cmpImgs", 0)) )
| 82578 | { |  | 82530 | {
| 82579 | ERRWRAP2(retval = _self_->compute(cmpImgs)); |  | 82531 | ERRWRAP2(retval = _self_->compute(cmpImgs));
| 82580 | return pyopencv_from(retval); |  | 82532 | return pyopencv_from(retval);
| 82581 | } |  | 82533 | }
| 82582 |  |  | 82534 |
| 82583 |  |  | 82535 |
| 82584 | pyPopulateArgumentConversionErrors(); |  | 82536 | pyPopulateArgumentConversionErrors();
| 82585 | } |  | 82537 | }
| 82586 |  |  | 82538 |
| 82587 |  |  | 82539 |
| 82588 | { |  | 82540 | {
| 82589 | PyObject* pyobj_ref = NULL; |  | 82541 | PyObject* pyobj_ref = NULL;
| 82590 | UMat ref; |  | 82542 | UMat ref;
| 82591 | PyObject* pyobj_cmp = NULL; |  | 82543 | PyObject* pyobj_cmp = NULL;
| 82592 | UMat cmp; |  | 82544 | UMat cmp;
| 82593 | PyObject* pyobj_qualityMap = NULL; |  | 82545 | PyObject* pyobj_qualityMap = NULL;
| 82594 | UMat qualityMap; |  | 82546 | UMat qualityMap;
| 82595 | cv::Scalar retval; |  | 82547 | cv::Scalar retval;
| 82596 |  |  | 82548 |
| 82597 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL }; |  | 82549 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL };
| 82598 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityMSE.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) && |  | 82550 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualityMSE.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) &&
| 82599 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82551 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82600 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 82552 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 82601 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) ) |  | 82553 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) )
| 82602 | { |  | 82554 | {
| 82603 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap)); |  | 82555 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap));
| 82604 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 82556 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 82605 | } |  | 82557 | }
| 82606 |  |  | 82558 |
| 82607 |  |  | 82559 |
| 82608 | pyPopulateArgumentConversionErrors(); |  | 82560 | pyPopulateArgumentConversionErrors();
| 82609 | } |  | 82561 | }
| 82610 | pyRaiseCVOverloadException("compute"); |  | 82562 | pyRaiseCVOverloadException("compute");
| 82611 |  |  | 82563 |
| 82612 | return NULL; |  | 82564 | return NULL;
| 82613 | } |  | 82565 | }
| 82614 |  |  | 82566 |
| 82615 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82567 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 82616 | { |  | 82568 | {
| 82617 | using namespace cv::quality; |  | 82569 | using namespace cv::quality;
| 82618 |  |  | 82570 |
| 82619 | pyPrepareArgumentConversionErrorsStorage(2); |  | 82571 | pyPrepareArgumentConversionErrorsStorage(2);
| 82620 |  |  | 82572 |
| 82621 | { |  | 82573 | {
| 82622 | PyObject* pyobj_ref = NULL; |  | 82574 | PyObject* pyobj_ref = NULL;
| 82623 | Mat ref; |  | 82575 | Mat ref;
| 82624 | Ptr<QualityMSE> retval; |  | 82576 | Ptr<QualityMSE> retval;
| 82625 |  |  | 82577 |
| 82626 | const char* keywords[] = { "ref", NULL }; |  | 82578 | const char* keywords[] = { "ref", NULL };
| 82627 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.create", (char**)keywords, &pyobj_ref) && |  | 82579 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.create", (char**)keywords, &pyobj_ref) &&
| 82628 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) ) |  | 82580 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) )
| 82629 | { |  | 82581 | {
| 82630 | ERRWRAP2(retval = cv::quality::QualityMSE::create(ref)); |  | 82582 | ERRWRAP2(retval = cv::quality::QualityMSE::create(ref));
| 82631 | return pyopencv_from(retval); |  | 82583 | return pyopencv_from(retval);
| 82632 | } |  | 82584 | }
| 82633 |  |  | 82585 |
| 82634 |  |  | 82586 |
| 82635 | pyPopulateArgumentConversionErrors(); |  | 82587 | pyPopulateArgumentConversionErrors();
| 82636 | } |  | 82588 | }
| 82637 |  |  | 82589 |
| 82638 |  |  | 82590 |
| 82639 | { |  | 82591 | {
| 82640 | PyObject* pyobj_ref = NULL; |  | 82592 | PyObject* pyobj_ref = NULL;
| 82641 | UMat ref; |  | 82593 | UMat ref;
| 82642 | Ptr<QualityMSE> retval; |  | 82594 | Ptr<QualityMSE> retval;
| 82643 |  |  | 82595 |
| 82644 | const char* keywords[] = { "ref", NULL }; |  | 82596 | const char* keywords[] = { "ref", NULL };
| 82645 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.create", (char**)keywords, &pyobj_ref) && |  | 82597 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityMSE.create", (char**)keywords, &pyobj_ref) &&
| 82646 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) ) |  | 82598 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) )
| 82647 | { |  | 82599 | {
| 82648 | ERRWRAP2(retval = cv::quality::QualityMSE::create(ref)); |  | 82600 | ERRWRAP2(retval = cv::quality::QualityMSE::create(ref));
| 82649 | return pyopencv_from(retval); |  | 82601 | return pyopencv_from(retval);
| 82650 | } |  | 82602 | }
| 82651 |  |  | 82603 |
| 82652 |  |  | 82604 |
| 82653 | pyPopulateArgumentConversionErrors(); |  | 82605 | pyPopulateArgumentConversionErrors();
| 82654 | } |  | 82606 | }
| 82655 | pyRaiseCVOverloadException("create"); |  | 82607 | pyRaiseCVOverloadException("create");
| 82656 |  |  | 82608 |
| 82657 | return NULL; |  | 82609 | return NULL;
| 82658 | } |  | 82610 | }
| 82659 |  |  | 82611 |
| 82660 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82612 | static PyObject* pyopencv_cv_quality_quality_QualityMSE_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 82661 | { |  | 82613 | {
| 82662 | using namespace cv::quality; |  | 82614 | using namespace cv::quality;
| 82663 |  |  | 82615 |
| 82664 |  |  | 82616 |
| 82665 | Ptr<cv::quality::QualityMSE> * self1 = 0; |  | 82617 | Ptr<cv::quality::QualityMSE> * self1 = 0;
| 82666 | if (!pyopencv_quality_QualityMSE_getp(self, self1)) |  | 82618 | if (!pyopencv_quality_QualityMSE_getp(self, self1))
| 82667 | return failmsgp("Incorrect type of self (must be 'quality_QualityMSE' or its derivative)"); |  | 82619 | return failmsgp("Incorrect type of self (must be 'quality_QualityMSE' or its derivative)");
| 82668 | Ptr<cv::quality::QualityMSE> _self_ = *(self1); |  | 82620 | Ptr<cv::quality::QualityMSE> _self_ = *(self1);
| 82669 | bool retval; |  | 82621 | bool retval;
| 82670 |  |  | 82622 |
| 82671 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82623 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82672 | { |  | 82624 | {
| 82673 | ERRWRAP2(retval = _self_->empty()); |  | 82625 | ERRWRAP2(retval = _self_->empty());
| 82674 | return pyopencv_from(retval); |  | 82626 | return pyopencv_from(retval);
| 82675 | } |  | 82627 | }
| 82676 |  |  | 82628 |
| 82677 | return NULL; |  | 82629 | return NULL;
| 82678 | } |  | 82630 | }
| 82679 |  |  | 82631 |
| 82680 |  |  | 82632 |
| 82681 |  |  | 82633 |
| 82682 | // Tables (quality_QualityMSE) |  | 82634 | // Tables (quality_QualityMSE)
| 82683 |  |  | 82635 |
| 82684 | static PyGetSetDef pyopencv_quality_QualityMSE_getseters[] = |  | 82636 | static PyGetSetDef pyopencv_quality_QualityMSE_getseters[] =
| 82685 | { |  | 82637 | {
| 82686 | {NULL} /* Sentinel */ |  | 82638 | {NULL} /* Sentinel */
| 82687 | }; |  | 82639 | };
| 82688 |  |  | 82640 |
| 82689 | static PyMethodDef pyopencv_quality_QualityMSE_methods[] = |  | 82641 | static PyMethodDef pyopencv_quality_QualityMSE_methods[] =
| 82690 | { |  | 82642 | {
| 82691 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"}, |  | 82643 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"},
| 82692 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_compute, 0), "compute(cmpImgs) -> retval\n. @brief Computes MSE for reference images supplied in class constructor and provided comparison images\n. @param cmpImgs Comparison image(s)\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (best) to potentially max float (worst)\n\n\n\ncompute(ref, cmp[, qualityMap]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image=\n. @param qualityMap output quality map, or cv::noArray()\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (best) to max float (worst)"}, |  | 82644 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_compute, 0), "compute(cmpImgs) -> retval\n. @brief Computes MSE for reference images supplied in class constructor and provided comparison images\n. @param cmpImgs Comparison image(s)\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (best) to potentially max float (worst)\n\n\n\ncompute(ref, cmp[, qualityMap]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image=\n. @param qualityMap output quality map, or cv::noArray()\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (best) to max float (worst)"},
| 82693 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_create_static, METH_STATIC), "create(ref) -> retval\n. @brief Create an object which calculates quality\n. @param ref input image to use as the reference for comparison"}, |  | 82645 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_create_static, METH_STATIC), "create(ref) -> retval\n. @brief Create an object which calculates quality\n. @param ref input image to use as the reference for comparison"},
| 82694 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"}, |  | 82646 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityMSE_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"},
| 82695 |  |  | 82647 |
| 82696 | {NULL, NULL} |  | 82648 | {NULL, NULL}
| 82697 | }; |  | 82649 | };
| 82698 |  |  | 82650 |
| 82699 | // Converter (quality_QualityMSE) |  | 82651 | // Converter (quality_QualityMSE)
| 82700 |  |  | 82652 |
| 82701 | template<> |  | 82653 | template<>
| 82702 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityMSE> > |  | 82654 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityMSE> >
| 82703 | { |  | 82655 | {
| 82704 | static PyObject* from(const Ptr<cv::quality::QualityMSE>& r) |  | 82656 | static PyObject* from(const Ptr<cv::quality::QualityMSE>& r)
| 82705 | { |  | 82657 | {
| 82706 | return pyopencv_quality_QualityMSE_Instance(r); |  | 82658 | return pyopencv_quality_QualityMSE_Instance(r);
| 82707 | } |  | 82659 | }
| 82708 | static bool to(PyObject* src, Ptr<cv::quality::QualityMSE>& dst, const ArgInfo& info) |  | 82660 | static bool to(PyObject* src, Ptr<cv::quality::QualityMSE>& dst, const ArgInfo& info)
| 82709 | { |  | 82661 | {
| 82710 | if(!src || src == Py_None) |  | 82662 | if(!src || src == Py_None)
| 82711 | return true; |  | 82663 | return true;
| 82712 | Ptr<cv::quality::QualityMSE> * dst_; |  | 82664 | Ptr<cv::quality::QualityMSE> * dst_;
| 82713 | if (pyopencv_quality_QualityMSE_getp(src, dst_)) |  | 82665 | if (pyopencv_quality_QualityMSE_getp(src, dst_))
| 82714 | { |  | 82666 | {
| 82715 | dst = *dst_; |  | 82667 | dst = *dst_;
| 82716 | return true; |  | 82668 | return true;
| 82717 | } |  | 82669 | }
| 82718 |  |  | 82670 |
| 82719 | failmsg("Expected Ptr<cv::quality::QualityMSE> for argument '%s'", info.name); |  | 82671 | failmsg("Expected Ptr<cv::quality::QualityMSE> for argument '%s'", info.name);
| 82720 | return false; |  | 82672 | return false;
| 82721 | } |  | 82673 | }
| 82722 | }; |  | 82674 | };
| 82723 |  |  | 82675 |
| 82724 | //================================================================================ |  | 82676 | //================================================================================
| 82725 | // quality_QualityPSNR (Generic) |  | 82677 | // quality_QualityPSNR (Generic)
| 82726 | //================================================================================ |  | 82678 | //================================================================================
| 82727 |  |  | 82679 |
| 82728 | // GetSet (quality_QualityPSNR) |  | 82680 | // GetSet (quality_QualityPSNR)
| 82729 |  |  | 82681 |
| 82730 |  |  | 82682 |
| 82731 |  |  | 82683 |
| 82732 | // Methods (quality_QualityPSNR) |  | 82684 | // Methods (quality_QualityPSNR)
| 82733 |  |  | 82685 |
| 82734 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82686 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 82735 | { |  | 82687 | {
| 82736 | using namespace cv::quality; |  | 82688 | using namespace cv::quality;
| 82737 |  |  | 82689 |
| 82738 |  |  | 82690 |
| 82739 | Ptr<cv::quality::QualityPSNR> * self1 = 0; |  | 82691 | Ptr<cv::quality::QualityPSNR> * self1 = 0;
| 82740 | if (!pyopencv_quality_QualityPSNR_getp(self, self1)) |  | 82692 | if (!pyopencv_quality_QualityPSNR_getp(self, self1))
| 82741 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)"); |  | 82693 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)");
| 82742 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1); |  | 82694 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1);
| 82743 |  |  | 82695 |
| 82744 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82696 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82745 | { |  | 82697 | {
| 82746 | ERRWRAP2(_self_->clear()); |  | 82698 | ERRWRAP2(_self_->clear());
| 82747 | Py_RETURN_NONE; |  | 82699 | Py_RETURN_NONE;
| 82748 | } |  | 82700 | }
| 82749 |  |  | 82701 |
| 82750 | return NULL; |  | 82702 | return NULL;
| 82751 | } |  | 82703 | }
| 82752 |  |  | 82704 |
| 82753 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82705 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 82754 | { |  | 82706 | {
| 82755 | using namespace cv::quality; |  | 82707 | using namespace cv::quality;
| 82756 |  |  | 82708 |
| 82757 |  |  | 82709 |
| 82758 | Ptr<cv::quality::QualityPSNR> * self1 = 0; |  | 82710 | Ptr<cv::quality::QualityPSNR> * self1 = 0;
| 82759 | if (!pyopencv_quality_QualityPSNR_getp(self, self1)) |  | 82711 | if (!pyopencv_quality_QualityPSNR_getp(self, self1))
| 82760 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)"); |  | 82712 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)");
| 82761 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1); |  | 82713 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1);
| 82762 | pyPrepareArgumentConversionErrorsStorage(4); |  | 82714 | pyPrepareArgumentConversionErrorsStorage(4);
| 82763 |  |  | 82715 |
| 82764 | { |  | 82716 | {
| 82765 | PyObject* pyobj_cmp = NULL; |  | 82717 | PyObject* pyobj_cmp = NULL;
| 82766 | Mat cmp; |  | 82718 | Mat cmp;
| 82767 | cv::Scalar retval; |  | 82719 | cv::Scalar retval;
| 82768 |  |  | 82720 |
| 82769 | const char* keywords[] = { "cmp", NULL }; |  | 82721 | const char* keywords[] = { "cmp", NULL };
| 82770 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityPSNR.compute", (char**)keywords, &pyobj_cmp) && |  | 82722 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityPSNR.compute", (char**)keywords, &pyobj_cmp) &&
| 82771 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) ) |  | 82723 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) )
| 82772 | { |  | 82724 | {
| 82773 | ERRWRAP2(retval = _self_->compute(cmp)); |  | 82725 | ERRWRAP2(retval = _self_->compute(cmp));
| 82774 | return pyopencv_from(retval); |  | 82726 | return pyopencv_from(retval);
| 82775 | } |  | 82727 | }
| 82776 |  |  | 82728 |
| 82777 |  |  | 82729 |
| 82778 | pyPopulateArgumentConversionErrors(); |  | 82730 | pyPopulateArgumentConversionErrors();
| 82779 | } |  | 82731 | }
| 82780 |  |  | 82732 |
| 82781 |  |  | 82733 |
| 82782 | { |  | 82734 | {
| 82783 | PyObject* pyobj_ref = NULL; |  | 82735 | PyObject* pyobj_ref = NULL;
| 82784 | Mat ref; |  | 82736 | Mat ref;
| 82785 | PyObject* pyobj_cmp = NULL; |  | 82737 | PyObject* pyobj_cmp = NULL;
| 82786 | Mat cmp; |  | 82738 | Mat cmp;
| 82787 | PyObject* pyobj_qualityMap = NULL; |  | 82739 | PyObject* pyobj_qualityMap = NULL;
| 82788 | Mat qualityMap; |  | 82740 | Mat qualityMap;
| 82789 | PyObject* pyobj_maxPixelValue = NULL; |  | 82741 | PyObject* pyobj_maxPixelValue = NULL;
| 82790 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT; |  | 82742 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT;
| 82791 | cv::Scalar retval; |  | 82743 | cv::Scalar retval;
| 82792 |  |  | 82744 |
| 82793 | const char* keywords[] = { "ref", "cmp", "qualityMap", "maxPixelValue", NULL }; |  | 82745 | const char* keywords[] = { "ref", "cmp", "qualityMap", "maxPixelValue", NULL };
| 82794 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:quality_QualityPSNR.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap, &pyobj_maxPixelValue) && |  | 82746 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:quality_QualityPSNR.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap, &pyobj_maxPixelValue) &&
| 82795 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82747 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82796 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 82748 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 82797 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) && |  | 82749 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) &&
| 82798 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) ) |  | 82750 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) )
| 82799 | { |  | 82751 | {
| 82800 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap, maxPixelValue)); |  | 82752 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap, maxPixelValue));
| 82801 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 82753 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 82802 | } |  | 82754 | }
| 82803 |  |  | 82755 |
| 82804 |  |  | 82756 |
| 82805 | pyPopulateArgumentConversionErrors(); |  | 82757 | pyPopulateArgumentConversionErrors();
| 82806 | } |  | 82758 | }
| 82807 |  |  | 82759 |
| 82808 |  |  | 82760 |
| 82809 | { |  | 82761 | {
| 82810 | PyObject* pyobj_cmp = NULL; |  | 82762 | PyObject* pyobj_cmp = NULL;
| 82811 | UMat cmp; |  | 82763 | UMat cmp;
| 82812 | cv::Scalar retval; |  | 82764 | cv::Scalar retval;
| 82813 |  |  | 82765 |
| 82814 | const char* keywords[] = { "cmp", NULL }; |  | 82766 | const char* keywords[] = { "cmp", NULL };
| 82815 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityPSNR.compute", (char**)keywords, &pyobj_cmp) && |  | 82767 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityPSNR.compute", (char**)keywords, &pyobj_cmp) &&
| 82816 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) ) |  | 82768 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) )
| 82817 | { |  | 82769 | {
| 82818 | ERRWRAP2(retval = _self_->compute(cmp)); |  | 82770 | ERRWRAP2(retval = _self_->compute(cmp));
| 82819 | return pyopencv_from(retval); |  | 82771 | return pyopencv_from(retval);
| 82820 | } |  | 82772 | }
| 82821 |  |  | 82773 |
| 82822 |  |  | 82774 |
| 82823 | pyPopulateArgumentConversionErrors(); |  | 82775 | pyPopulateArgumentConversionErrors();
| 82824 | } |  | 82776 | }
| 82825 |  |  | 82777 |
| 82826 |  |  | 82778 |
| 82827 | { |  | 82779 | {
| 82828 | PyObject* pyobj_ref = NULL; |  | 82780 | PyObject* pyobj_ref = NULL;
| 82829 | UMat ref; |  | 82781 | UMat ref;
| 82830 | PyObject* pyobj_cmp = NULL; |  | 82782 | PyObject* pyobj_cmp = NULL;
| 82831 | UMat cmp; |  | 82783 | UMat cmp;
| 82832 | PyObject* pyobj_qualityMap = NULL; |  | 82784 | PyObject* pyobj_qualityMap = NULL;
| 82833 | UMat qualityMap; |  | 82785 | UMat qualityMap;
| 82834 | PyObject* pyobj_maxPixelValue = NULL; |  | 82786 | PyObject* pyobj_maxPixelValue = NULL;
| 82835 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT; |  | 82787 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT;
| 82836 | cv::Scalar retval; |  | 82788 | cv::Scalar retval;
| 82837 |  |  | 82789 |
| 82838 | const char* keywords[] = { "ref", "cmp", "qualityMap", "maxPixelValue", NULL }; |  | 82790 | const char* keywords[] = { "ref", "cmp", "qualityMap", "maxPixelValue", NULL };
| 82839 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:quality_QualityPSNR.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap, &pyobj_maxPixelValue) && |  | 82791 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:quality_QualityPSNR.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap, &pyobj_maxPixelValue) &&
| 82840 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82792 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82841 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 82793 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 82842 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) && |  | 82794 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) &&
| 82843 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) ) |  | 82795 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) )
| 82844 | { |  | 82796 | {
| 82845 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap, maxPixelValue)); |  | 82797 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap, maxPixelValue));
| 82846 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 82798 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 82847 | } |  | 82799 | }
| 82848 |  |  | 82800 |
| 82849 |  |  | 82801 |
| 82850 | pyPopulateArgumentConversionErrors(); |  | 82802 | pyPopulateArgumentConversionErrors();
| 82851 | } |  | 82803 | }
| 82852 | pyRaiseCVOverloadException("compute"); |  | 82804 | pyRaiseCVOverloadException("compute");
| 82853 |  |  | 82805 |
| 82854 | return NULL; |  | 82806 | return NULL;
| 82855 | } |  | 82807 | }
| 82856 |  |  | 82808 |
| 82857 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82809 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 82858 | { |  | 82810 | {
| 82859 | using namespace cv::quality; |  | 82811 | using namespace cv::quality;
| 82860 |  |  | 82812 |
| 82861 | pyPrepareArgumentConversionErrorsStorage(2); |  | 82813 | pyPrepareArgumentConversionErrorsStorage(2);
| 82862 |  |  | 82814 |
| 82863 | { |  | 82815 | {
| 82864 | PyObject* pyobj_ref = NULL; |  | 82816 | PyObject* pyobj_ref = NULL;
| 82865 | Mat ref; |  | 82817 | Mat ref;
| 82866 | PyObject* pyobj_maxPixelValue = NULL; |  | 82818 | PyObject* pyobj_maxPixelValue = NULL;
| 82867 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT; |  | 82819 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT;
| 82868 | Ptr<QualityPSNR> retval; |  | 82820 | Ptr<QualityPSNR> retval;
| 82869 |  |  | 82821 |
| 82870 | const char* keywords[] = { "ref", "maxPixelValue", NULL }; |  | 82822 | const char* keywords[] = { "ref", "maxPixelValue", NULL };
| 82871 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityPSNR.create", (char**)keywords, &pyobj_ref, &pyobj_maxPixelValue) && |  | 82823 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityPSNR.create", (char**)keywords, &pyobj_ref, &pyobj_maxPixelValue) &&
| 82872 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82824 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82873 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) ) |  | 82825 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) )
| 82874 | { |  | 82826 | {
| 82875 | ERRWRAP2(retval = cv::quality::QualityPSNR::create(ref, maxPixelValue)); |  | 82827 | ERRWRAP2(retval = cv::quality::QualityPSNR::create(ref, maxPixelValue));
| 82876 | return pyopencv_from(retval); |  | 82828 | return pyopencv_from(retval);
| 82877 | } |  | 82829 | }
| 82878 |  |  | 82830 |
| 82879 |  |  | 82831 |
| 82880 | pyPopulateArgumentConversionErrors(); |  | 82832 | pyPopulateArgumentConversionErrors();
| 82881 | } |  | 82833 | }
| 82882 |  |  | 82834 |
| 82883 |  |  | 82835 |
| 82884 | { |  | 82836 | {
| 82885 | PyObject* pyobj_ref = NULL; |  | 82837 | PyObject* pyobj_ref = NULL;
| 82886 | UMat ref; |  | 82838 | UMat ref;
| 82887 | PyObject* pyobj_maxPixelValue = NULL; |  | 82839 | PyObject* pyobj_maxPixelValue = NULL;
| 82888 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT; |  | 82840 | double maxPixelValue=QualityPSNR::MAX_PIXEL_VALUE_DEFAULT;
| 82889 | Ptr<QualityPSNR> retval; |  | 82841 | Ptr<QualityPSNR> retval;
| 82890 |  |  | 82842 |
| 82891 | const char* keywords[] = { "ref", "maxPixelValue", NULL }; |  | 82843 | const char* keywords[] = { "ref", "maxPixelValue", NULL };
| 82892 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityPSNR.create", (char**)keywords, &pyobj_ref, &pyobj_maxPixelValue) && |  | 82844 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:quality_QualityPSNR.create", (char**)keywords, &pyobj_ref, &pyobj_maxPixelValue) &&
| 82893 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 82845 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 82894 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) ) |  | 82846 | pyopencv_to_safe(pyobj_maxPixelValue, maxPixelValue, ArgInfo("maxPixelValue", 0)) )
| 82895 | { |  | 82847 | {
| 82896 | ERRWRAP2(retval = cv::quality::QualityPSNR::create(ref, maxPixelValue)); |  | 82848 | ERRWRAP2(retval = cv::quality::QualityPSNR::create(ref, maxPixelValue));
| 82897 | return pyopencv_from(retval); |  | 82849 | return pyopencv_from(retval);
| 82898 | } |  | 82850 | }
| 82899 |  |  | 82851 |
| 82900 |  |  | 82852 |
| 82901 | pyPopulateArgumentConversionErrors(); |  | 82853 | pyPopulateArgumentConversionErrors();
| 82902 | } |  | 82854 | }
| 82903 | pyRaiseCVOverloadException("create"); |  | 82855 | pyRaiseCVOverloadException("create");
| 82904 |  |  | 82856 |
| 82905 | return NULL; |  | 82857 | return NULL;
| 82906 | } |  | 82858 | }
| 82907 |  |  | 82859 |
| 82908 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82860 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 82909 | { |  | 82861 | {
| 82910 | using namespace cv::quality; |  | 82862 | using namespace cv::quality;
| 82911 |  |  | 82863 |
| 82912 |  |  | 82864 |
| 82913 | Ptr<cv::quality::QualityPSNR> * self1 = 0; |  | 82865 | Ptr<cv::quality::QualityPSNR> * self1 = 0;
| 82914 | if (!pyopencv_quality_QualityPSNR_getp(self, self1)) |  | 82866 | if (!pyopencv_quality_QualityPSNR_getp(self, self1))
| 82915 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)"); |  | 82867 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)");
| 82916 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1); |  | 82868 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1);
| 82917 | bool retval; |  | 82869 | bool retval;
| 82918 |  |  | 82870 |
| 82919 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82871 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82920 | { |  | 82872 | {
| 82921 | ERRWRAP2(retval = _self_->empty()); |  | 82873 | ERRWRAP2(retval = _self_->empty());
| 82922 | return pyopencv_from(retval); |  | 82874 | return pyopencv_from(retval);
| 82923 | } |  | 82875 | }
| 82924 |  |  | 82876 |
| 82925 | return NULL; |  | 82877 | return NULL;
| 82926 | } |  | 82878 | }
| 82927 |  |  | 82879 |
| 82928 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_getMaxPixelValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82880 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_getMaxPixelValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 82929 | { |  | 82881 | {
| 82930 | using namespace cv::quality; |  | 82882 | using namespace cv::quality;
| 82931 |  |  | 82883 |
| 82932 |  |  | 82884 |
| 82933 | Ptr<cv::quality::QualityPSNR> * self1 = 0; |  | 82885 | Ptr<cv::quality::QualityPSNR> * self1 = 0;
| 82934 | if (!pyopencv_quality_QualityPSNR_getp(self, self1)) |  | 82886 | if (!pyopencv_quality_QualityPSNR_getp(self, self1))
| 82935 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)"); |  | 82887 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)");
| 82936 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1); |  | 82888 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1);
| 82937 | double retval; |  | 82889 | double retval;
| 82938 |  |  | 82890 |
| 82939 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82891 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 82940 | { |  | 82892 | {
| 82941 | ERRWRAP2(retval = _self_->getMaxPixelValue()); |  | 82893 | ERRWRAP2(retval = _self_->getMaxPixelValue());
| 82942 | return pyopencv_from(retval); |  | 82894 | return pyopencv_from(retval);
| 82943 | } |  | 82895 | }
| 82944 |  |  | 82896 |
| 82945 | return NULL; |  | 82897 | return NULL;
| 82946 | } |  | 82898 | }
| 82947 |  |  | 82899 |
| 82948 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_setMaxPixelValue(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82900 | static PyObject* pyopencv_cv_quality_quality_QualityPSNR_setMaxPixelValue(PyObject* self, PyObject* py_args, PyObject* kw)
| 82949 | { |  | 82901 | {
| 82950 | using namespace cv::quality; |  | 82902 | using namespace cv::quality;
| 82951 |  |  | 82903 |
| 82952 |  |  | 82904 |
| 82953 | Ptr<cv::quality::QualityPSNR> * self1 = 0; |  | 82905 | Ptr<cv::quality::QualityPSNR> * self1 = 0;
| 82954 | if (!pyopencv_quality_QualityPSNR_getp(self, self1)) |  | 82906 | if (!pyopencv_quality_QualityPSNR_getp(self, self1))
| 82955 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)"); |  | 82907 | return failmsgp("Incorrect type of self (must be 'quality_QualityPSNR' or its derivative)");
| 82956 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1); |  | 82908 | Ptr<cv::quality::QualityPSNR> _self_ = *(self1);
| 82957 | PyObject* pyobj_val = NULL; |  | 82909 | PyObject* pyobj_val = NULL;
| 82958 | double val=0; |  | 82910 | double val=0;
| 82959 |  |  | 82911 |
| 82960 | const char* keywords[] = { "val", NULL }; |  | 82912 | const char* keywords[] = { "val", NULL };
| 82961 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityPSNR.setMaxPixelValue", (char**)keywords, &pyobj_val) && |  | 82913 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualityPSNR.setMaxPixelValue", (char**)keywords, &pyobj_val) &&
| 82962 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 82914 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 82963 | { |  | 82915 | {
| 82964 | ERRWRAP2(_self_->setMaxPixelValue(val)); |  | 82916 | ERRWRAP2(_self_->setMaxPixelValue(val));
| 82965 | Py_RETURN_NONE; |  | 82917 | Py_RETURN_NONE;
| 82966 | } |  | 82918 | }
| 82967 |  |  | 82919 |
| 82968 | return NULL; |  | 82920 | return NULL;
| 82969 | } |  | 82921 | }
| 82970 |  |  | 82922 |
| 82971 |  |  | 82923 |
| 82972 |  |  | 82924 |
| 82973 | // Tables (quality_QualityPSNR) |  | 82925 | // Tables (quality_QualityPSNR)
| 82974 |  |  | 82926 |
| 82975 | static PyGetSetDef pyopencv_quality_QualityPSNR_getseters[] = |  | 82927 | static PyGetSetDef pyopencv_quality_QualityPSNR_getseters[] =
| 82976 | { |  | 82928 | {
| 82977 | {NULL} /* Sentinel */ |  | 82929 | {NULL} /* Sentinel */
| 82978 | }; |  | 82930 | };
| 82979 |  |  | 82931 |
| 82980 | static PyMethodDef pyopencv_quality_QualityPSNR_methods[] = |  | 82932 | static PyMethodDef pyopencv_quality_QualityPSNR_methods[] =
| 82981 | { |  | 82933 | {
| 82982 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"}, |  | 82934 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"},
| 82983 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_compute, 0), "compute(cmp) -> retval\n. @brief Compute the PSNR\n. @param cmp Comparison image\n. @returns Per-channel PSNR value, or std::numeric_limits<double>::infinity() if the MSE between the two images == 0\n\n\n\ncompute(ref, cmp[, qualityMap[, maxPixelValue]]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image\n. @param qualityMap output quality map, or cv::noArray()\n. @param maxPixelValue maximum per-channel value for any individual pixel; eg 255 for uint8 image\n. @returns PSNR value, or std::numeric_limits<double>::infinity() if the MSE between the two images == 0"}, |  | 82935 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_compute, 0), "compute(cmp) -> retval\n. @brief Compute the PSNR\n. @param cmp Comparison image\n. @returns Per-channel PSNR value, or std::numeric_limits<double>::infinity() if the MSE between the two images == 0\n\n\n\ncompute(ref, cmp[, qualityMap[, maxPixelValue]]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image\n. @param qualityMap output quality map, or cv::noArray()\n. @param maxPixelValue maximum per-channel value for any individual pixel; eg 255 for uint8 image\n. @returns PSNR value, or std::numeric_limits<double>::infinity() if the MSE between the two images == 0"},
| 82984 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_create_static, METH_STATIC), "create(ref[, maxPixelValue]) -> retval\n. @brief Create an object which calculates quality\n. @param ref input image to use as the source for comparison\n. @param maxPixelValue maximum per-channel value for any individual pixel; eg 255 for uint8 image"}, |  | 82936 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_create_static, METH_STATIC), "create(ref[, maxPixelValue]) -> retval\n. @brief Create an object which calculates quality\n. @param ref input image to use as the source for comparison\n. @param maxPixelValue maximum per-channel value for any individual pixel; eg 255 for uint8 image"},
| 82985 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"}, |  | 82937 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"},
| 82986 | {"getMaxPixelValue", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_getMaxPixelValue, 0), "getMaxPixelValue() -> retval\n. @brief return the maximum pixel value used for PSNR computation"}, |  | 82938 | {"getMaxPixelValue", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_getMaxPixelValue, 0), "getMaxPixelValue() -> retval\n. @brief return the maximum pixel value used for PSNR computation"},
| 82987 | {"setMaxPixelValue", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_setMaxPixelValue, 0), "setMaxPixelValue(val) -> None\n. @brief sets the maximum pixel value used for PSNR computation\n. @param val Maximum pixel value"}, |  | 82939 | {"setMaxPixelValue", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualityPSNR_setMaxPixelValue, 0), "setMaxPixelValue(val) -> None\n. @brief sets the maximum pixel value used for PSNR computation\n. @param val Maximum pixel value"},
| 82988 |  |  | 82940 |
| 82989 | {NULL, NULL} |  | 82941 | {NULL, NULL}
| 82990 | }; |  | 82942 | };
| 82991 |  |  | 82943 |
| 82992 | // Converter (quality_QualityPSNR) |  | 82944 | // Converter (quality_QualityPSNR)
| 82993 |  |  | 82945 |
| 82994 | template<> |  | 82946 | template<>
| 82995 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityPSNR> > |  | 82947 | struct PyOpenCV_Converter< Ptr<cv::quality::QualityPSNR> >
| 82996 | { |  | 82948 | {
| 82997 | static PyObject* from(const Ptr<cv::quality::QualityPSNR>& r) |  | 82949 | static PyObject* from(const Ptr<cv::quality::QualityPSNR>& r)
| 82998 | { |  | 82950 | {
| 82999 | return pyopencv_quality_QualityPSNR_Instance(r); |  | 82951 | return pyopencv_quality_QualityPSNR_Instance(r);
| 83000 | } |  | 82952 | }
| 83001 | static bool to(PyObject* src, Ptr<cv::quality::QualityPSNR>& dst, const ArgInfo& info) |  | 82953 | static bool to(PyObject* src, Ptr<cv::quality::QualityPSNR>& dst, const ArgInfo& info)
| 83002 | { |  | 82954 | {
| 83003 | if(!src || src == Py_None) |  | 82955 | if(!src || src == Py_None)
| 83004 | return true; |  | 82956 | return true;
| 83005 | Ptr<cv::quality::QualityPSNR> * dst_; |  | 82957 | Ptr<cv::quality::QualityPSNR> * dst_;
| 83006 | if (pyopencv_quality_QualityPSNR_getp(src, dst_)) |  | 82958 | if (pyopencv_quality_QualityPSNR_getp(src, dst_))
| 83007 | { |  | 82959 | {
| 83008 | dst = *dst_; |  | 82960 | dst = *dst_;
| 83009 | return true; |  | 82961 | return true;
| 83010 | } |  | 82962 | }
| 83011 |  |  | 82963 |
| 83012 | failmsg("Expected Ptr<cv::quality::QualityPSNR> for argument '%s'", info.name); |  | 82964 | failmsg("Expected Ptr<cv::quality::QualityPSNR> for argument '%s'", info.name);
| 83013 | return false; |  | 82965 | return false;
| 83014 | } |  | 82966 | }
| 83015 | }; |  | 82967 | };
| 83016 |  |  | 82968 |
| 83017 | //================================================================================ |  | 82969 | //================================================================================
| 83018 | // quality_QualitySSIM (Generic) |  | 82970 | // quality_QualitySSIM (Generic)
| 83019 | //================================================================================ |  | 82971 | //================================================================================
| 83020 |  |  | 82972 |
| 83021 | // GetSet (quality_QualitySSIM) |  | 82973 | // GetSet (quality_QualitySSIM)
| 83022 |  |  | 82974 |
| 83023 |  |  | 82975 |
| 83024 |  |  | 82976 |
| 83025 | // Methods (quality_QualitySSIM) |  | 82977 | // Methods (quality_QualitySSIM)
| 83026 |  |  | 82978 |
| 83027 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_clear(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82979 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_clear(PyObject* self, PyObject* py_args, PyObject* kw)
| 83028 | { |  | 82980 | {
| 83029 | using namespace cv::quality; |  | 82981 | using namespace cv::quality;
| 83030 |  |  | 82982 |
| 83031 |  |  | 82983 |
| 83032 | Ptr<cv::quality::QualitySSIM> * self1 = 0; |  | 82984 | Ptr<cv::quality::QualitySSIM> * self1 = 0;
| 83033 | if (!pyopencv_quality_QualitySSIM_getp(self, self1)) |  | 82985 | if (!pyopencv_quality_QualitySSIM_getp(self, self1))
| 83034 | return failmsgp("Incorrect type of self (must be 'quality_QualitySSIM' or its derivative)"); |  | 82986 | return failmsgp("Incorrect type of self (must be 'quality_QualitySSIM' or its derivative)");
| 83035 | Ptr<cv::quality::QualitySSIM> _self_ = *(self1); |  | 82987 | Ptr<cv::quality::QualitySSIM> _self_ = *(self1);
| 83036 |  |  | 82988 |
| 83037 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 82989 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 83038 | { |  | 82990 | {
| 83039 | ERRWRAP2(_self_->clear()); |  | 82991 | ERRWRAP2(_self_->clear());
| 83040 | Py_RETURN_NONE; |  | 82992 | Py_RETURN_NONE;
| 83041 | } |  | 82993 | }
| 83042 |  |  | 82994 |
| 83043 | return NULL; |  | 82995 | return NULL;
| 83044 | } |  | 82996 | }
| 83045 |  |  | 82997 |
| 83046 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 82998 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 83047 | { |  | 82999 | {
| 83048 | using namespace cv::quality; |  | 83000 | using namespace cv::quality;
| 83049 |  |  | 83001 |
| 83050 |  |  | 83002 |
| 83051 | Ptr<cv::quality::QualitySSIM> * self1 = 0; |  | 83003 | Ptr<cv::quality::QualitySSIM> * self1 = 0;
| 83052 | if (!pyopencv_quality_QualitySSIM_getp(self, self1)) |  | 83004 | if (!pyopencv_quality_QualitySSIM_getp(self, self1))
| 83053 | return failmsgp("Incorrect type of self (must be 'quality_QualitySSIM' or its derivative)"); |  | 83005 | return failmsgp("Incorrect type of self (must be 'quality_QualitySSIM' or its derivative)");
| 83054 | Ptr<cv::quality::QualitySSIM> _self_ = *(self1); |  | 83006 | Ptr<cv::quality::QualitySSIM> _self_ = *(self1);
| 83055 | pyPrepareArgumentConversionErrorsStorage(4); |  | 83007 | pyPrepareArgumentConversionErrorsStorage(4);
| 83056 |  |  | 83008 |
| 83057 | { |  | 83009 | {
| 83058 | PyObject* pyobj_cmp = NULL; |  | 83010 | PyObject* pyobj_cmp = NULL;
| 83059 | Mat cmp; |  | 83011 | Mat cmp;
| 83060 | cv::Scalar retval; |  | 83012 | cv::Scalar retval;
| 83061 |  |  | 83013 |
| 83062 | const char* keywords[] = { "cmp", NULL }; |  | 83014 | const char* keywords[] = { "cmp", NULL };
| 83063 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_cmp) && |  | 83015 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_cmp) &&
| 83064 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) ) |  | 83016 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) )
| 83065 | { |  | 83017 | {
| 83066 | ERRWRAP2(retval = _self_->compute(cmp)); |  | 83018 | ERRWRAP2(retval = _self_->compute(cmp));
| 83067 | return pyopencv_from(retval); |  | 83019 | return pyopencv_from(retval);
| 83068 | } |  | 83020 | }
| 83069 |  |  | 83021 |
| 83070 |  |  | 83022 |
| 83071 | pyPopulateArgumentConversionErrors(); |  | 83023 | pyPopulateArgumentConversionErrors();
| 83072 | } |  | 83024 | }
| 83073 |  |  | 83025 |
| 83074 |  |  | 83026 |
| 83075 | { |  | 83027 | {
| 83076 | PyObject* pyobj_ref = NULL; |  | 83028 | PyObject* pyobj_ref = NULL;
| 83077 | Mat ref; |  | 83029 | Mat ref;
| 83078 | PyObject* pyobj_cmp = NULL; |  | 83030 | PyObject* pyobj_cmp = NULL;
| 83079 | Mat cmp; |  | 83031 | Mat cmp;
| 83080 | PyObject* pyobj_qualityMap = NULL; |  | 83032 | PyObject* pyobj_qualityMap = NULL;
| 83081 | Mat qualityMap; |  | 83033 | Mat qualityMap;
| 83082 | cv::Scalar retval; |  | 83034 | cv::Scalar retval;
| 83083 |  |  | 83035 |
| 83084 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL }; |  | 83036 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL };
| 83085 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) && |  | 83037 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) &&
| 83086 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 83038 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 83087 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 83039 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 83088 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) ) |  | 83040 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) )
| 83089 | { |  | 83041 | {
| 83090 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap)); |  | 83042 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap));
| 83091 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 83043 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 83092 | } |  | 83044 | }
| 83093 |  |  | 83045 |
| 83094 |  |  | 83046 |
| 83095 | pyPopulateArgumentConversionErrors(); |  | 83047 | pyPopulateArgumentConversionErrors();
| 83096 | } |  | 83048 | }
| 83097 |  |  | 83049 |
| 83098 |  |  | 83050 |
| 83099 | { |  | 83051 | {
| 83100 | PyObject* pyobj_cmp = NULL; |  | 83052 | PyObject* pyobj_cmp = NULL;
| 83101 | UMat cmp; |  | 83053 | UMat cmp;
| 83102 | cv::Scalar retval; |  | 83054 | cv::Scalar retval;
| 83103 |  |  | 83055 |
| 83104 | const char* keywords[] = { "cmp", NULL }; |  | 83056 | const char* keywords[] = { "cmp", NULL };
| 83105 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_cmp) && |  | 83057 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_cmp) &&
| 83106 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) ) |  | 83058 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) )
| 83107 | { |  | 83059 | {
| 83108 | ERRWRAP2(retval = _self_->compute(cmp)); |  | 83060 | ERRWRAP2(retval = _self_->compute(cmp));
| 83109 | return pyopencv_from(retval); |  | 83061 | return pyopencv_from(retval);
| 83110 | } |  | 83062 | }
| 83111 |  |  | 83063 |
| 83112 |  |  | 83064 |
| 83113 | pyPopulateArgumentConversionErrors(); |  | 83065 | pyPopulateArgumentConversionErrors();
| 83114 | } |  | 83066 | }
| 83115 |  |  | 83067 |
| 83116 |  |  | 83068 |
| 83117 | { |  | 83069 | {
| 83118 | PyObject* pyobj_ref = NULL; |  | 83070 | PyObject* pyobj_ref = NULL;
| 83119 | UMat ref; |  | 83071 | UMat ref;
| 83120 | PyObject* pyobj_cmp = NULL; |  | 83072 | PyObject* pyobj_cmp = NULL;
| 83121 | UMat cmp; |  | 83073 | UMat cmp;
| 83122 | PyObject* pyobj_qualityMap = NULL; |  | 83074 | PyObject* pyobj_qualityMap = NULL;
| 83123 | UMat qualityMap; |  | 83075 | UMat qualityMap;
| 83124 | cv::Scalar retval; |  | 83076 | cv::Scalar retval;
| 83125 |  |  | 83077 |
| 83126 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL }; |  | 83078 | const char* keywords[] = { "ref", "cmp", "qualityMap", NULL };
| 83127 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) && |  | 83079 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:quality_QualitySSIM.compute", (char**)keywords, &pyobj_ref, &pyobj_cmp, &pyobj_qualityMap) &&
| 83128 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) && |  | 83080 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) &&
| 83129 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) && |  | 83081 | pyopencv_to_safe(pyobj_cmp, cmp, ArgInfo("cmp", 0)) &&
| 83130 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) ) |  | 83082 | pyopencv_to_safe(pyobj_qualityMap, qualityMap, ArgInfo("qualityMap", 1)) )
| 83131 | { |  | 83083 | {
| 83132 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap)); |  | 83084 | ERRWRAP2(retval = _self_->compute(ref, cmp, qualityMap));
| 83133 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap)); |  | 83085 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(qualityMap));
| 83134 | } |  | 83086 | }
| 83135 |  |  | 83087 |
| 83136 |  |  | 83088 |
| 83137 | pyPopulateArgumentConversionErrors(); |  | 83089 | pyPopulateArgumentConversionErrors();
| 83138 | } |  | 83090 | }
| 83139 | pyRaiseCVOverloadException("compute"); |  | 83091 | pyRaiseCVOverloadException("compute");
| 83140 |  |  | 83092 |
| 83141 | return NULL; |  | 83093 | return NULL;
| 83142 | } |  | 83094 | }
| 83143 |  |  | 83095 |
| 83144 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83096 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 83145 | { |  | 83097 | {
| 83146 | using namespace cv::quality; |  | 83098 | using namespace cv::quality;
| 83147 |  |  | 83099 |
| 83148 | pyPrepareArgumentConversionErrorsStorage(2); |  | 83100 | pyPrepareArgumentConversionErrorsStorage(2);
| 83149 |  |  | 83101 |
| 83150 | { |  | 83102 | {
| 83151 | PyObject* pyobj_ref = NULL; |  | 83103 | PyObject* pyobj_ref = NULL;
| 83152 | Mat ref; |  | 83104 | Mat ref;
| 83153 | Ptr<QualitySSIM> retval; |  | 83105 | Ptr<QualitySSIM> retval;
| 83154 |  |  | 83106 |
| 83155 | const char* keywords[] = { "ref", NULL }; |  | 83107 | const char* keywords[] = { "ref", NULL };
| 83156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.create", (char**)keywords, &pyobj_ref) && |  | 83108 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.create", (char**)keywords, &pyobj_ref) &&
| 83157 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) ) |  | 83109 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) )
| 83158 | { |  | 83110 | {
| 83159 | ERRWRAP2(retval = cv::quality::QualitySSIM::create(ref)); |  | 83111 | ERRWRAP2(retval = cv::quality::QualitySSIM::create(ref));
| 83160 | return pyopencv_from(retval); |  | 83112 | return pyopencv_from(retval);
| 83161 | } |  | 83113 | }
| 83162 |  |  | 83114 |
| 83163 |  |  | 83115 |
| 83164 | pyPopulateArgumentConversionErrors(); |  | 83116 | pyPopulateArgumentConversionErrors();
| 83165 | } |  | 83117 | }
| 83166 |  |  | 83118 |
| 83167 |  |  | 83119 |
| 83168 | { |  | 83120 | {
| 83169 | PyObject* pyobj_ref = NULL; |  | 83121 | PyObject* pyobj_ref = NULL;
| 83170 | UMat ref; |  | 83122 | UMat ref;
| 83171 | Ptr<QualitySSIM> retval; |  | 83123 | Ptr<QualitySSIM> retval;
| 83172 |  |  | 83124 |
| 83173 | const char* keywords[] = { "ref", NULL }; |  | 83125 | const char* keywords[] = { "ref", NULL };
| 83174 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.create", (char**)keywords, &pyobj_ref) && |  | 83126 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:quality_QualitySSIM.create", (char**)keywords, &pyobj_ref) &&
| 83175 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) ) |  | 83127 | pyopencv_to_safe(pyobj_ref, ref, ArgInfo("ref", 0)) )
| 83176 | { |  | 83128 | {
| 83177 | ERRWRAP2(retval = cv::quality::QualitySSIM::create(ref)); |  | 83129 | ERRWRAP2(retval = cv::quality::QualitySSIM::create(ref));
| 83178 | return pyopencv_from(retval); |  | 83130 | return pyopencv_from(retval);
| 83179 | } |  | 83131 | }
| 83180 |  |  | 83132 |
| 83181 |  |  | 83133 |
| 83182 | pyPopulateArgumentConversionErrors(); |  | 83134 | pyPopulateArgumentConversionErrors();
| 83183 | } |  | 83135 | }
| 83184 | pyRaiseCVOverloadException("create"); |  | 83136 | pyRaiseCVOverloadException("create");
| 83185 |  |  | 83137 |
| 83186 | return NULL; |  | 83138 | return NULL;
| 83187 | } |  | 83139 | }
| 83188 |  |  | 83140 |
| 83189 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_empty(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83141 | static PyObject* pyopencv_cv_quality_quality_QualitySSIM_empty(PyObject* self, PyObject* py_args, PyObject* kw)
| 83190 | { |  | 83142 | {
| 83191 | using namespace cv::quality; |  | 83143 | using namespace cv::quality;
| 83192 |  |  | 83144 |
| 83193 |  |  | 83145 |
| 83194 | Ptr<cv::quality::QualitySSIM> * self1 = 0; |  | 83146 | Ptr<cv::quality::QualitySSIM> * self1 = 0;
| 83195 | if (!pyopencv_quality_QualitySSIM_getp(self, self1)) |  | 83147 | if (!pyopencv_quality_QualitySSIM_getp(self, self1))
| 83196 | return failmsgp("Incorrect type of self (must be 'quality_QualitySSIM' or its derivative)"); |  | 83148 | return failmsgp("Incorrect type of self (must be 'quality_QualitySSIM' or its derivative)");
| 83197 | Ptr<cv::quality::QualitySSIM> _self_ = *(self1); |  | 83149 | Ptr<cv::quality::QualitySSIM> _self_ = *(self1);
| 83198 | bool retval; |  | 83150 | bool retval;
| 83199 |  |  | 83151 |
| 83200 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 83152 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 83201 | { |  | 83153 | {
| 83202 | ERRWRAP2(retval = _self_->empty()); |  | 83154 | ERRWRAP2(retval = _self_->empty());
| 83203 | return pyopencv_from(retval); |  | 83155 | return pyopencv_from(retval);
| 83204 | } |  | 83156 | }
| 83205 |  |  | 83157 |
| 83206 | return NULL; |  | 83158 | return NULL;
| 83207 | } |  | 83159 | }
| 83208 |  |  | 83160 |
| 83209 |  |  | 83161 |
| 83210 |  |  | 83162 |
| 83211 | // Tables (quality_QualitySSIM) |  | 83163 | // Tables (quality_QualitySSIM)
| 83212 |  |  | 83164 |
| 83213 | static PyGetSetDef pyopencv_quality_QualitySSIM_getseters[] = |  | 83165 | static PyGetSetDef pyopencv_quality_QualitySSIM_getseters[] =
| 83214 | { |  | 83166 | {
| 83215 | {NULL} /* Sentinel */ |  | 83167 | {NULL} /* Sentinel */
| 83216 | }; |  | 83168 | };
| 83217 |  |  | 83169 |
| 83218 | static PyMethodDef pyopencv_quality_QualitySSIM_methods[] = |  | 83170 | static PyMethodDef pyopencv_quality_QualitySSIM_methods[] =
| 83219 | { |  | 83171 | {
| 83220 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"}, |  | 83172 | {"clear", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_clear, 0), "clear() -> None\n. @brief Implements Algorithm::clear()"},
| 83221 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_compute, 0), "compute(cmp) -> retval\n. @brief Computes SSIM\n. @param cmp Comparison image\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (worst) to 1 (best)\n\n\n\ncompute(ref, cmp[, qualityMap]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image\n. @param qualityMap output quality map, or cv::noArray()\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (worst) to 1 (best)"}, |  | 83173 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_compute, 0), "compute(cmp) -> retval\n. @brief Computes SSIM\n. @param cmp Comparison image\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (worst) to 1 (best)\n\n\n\ncompute(ref, cmp[, qualityMap]) -> retval, qualityMap\n. @brief static method for computing quality\n. @param ref reference image\n. @param cmp comparison image\n. @param qualityMap output quality map, or cv::noArray()\n. @returns cv::Scalar with per-channel quality values. Values range from 0 (worst) to 1 (best)"},
| 83222 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_create_static, METH_STATIC), "create(ref) -> retval\n. @brief Create an object which calculates quality\n. @param ref input image to use as the reference image for comparison"}, |  | 83174 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_create_static, METH_STATIC), "create(ref) -> retval\n. @brief Create an object which calculates quality\n. @param ref input image to use as the reference image for comparison"},
| 83223 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"}, |  | 83175 | {"empty", CV_PY_FN_WITH_KW_(pyopencv_cv_quality_quality_QualitySSIM_empty, 0), "empty() -> retval\n. @brief Implements Algorithm::empty()"},
| 83224 |  |  | 83176 |
| 83225 | {NULL, NULL} |  | 83177 | {NULL, NULL}
| 83226 | }; |  | 83178 | };
| 83227 |  |  | 83179 |
| 83228 | // Converter (quality_QualitySSIM) |  | 83180 | // Converter (quality_QualitySSIM)
| 83229 |  |  | 83181 |
| 83230 | template<> |  | 83182 | template<>
| 83231 | struct PyOpenCV_Converter< Ptr<cv::quality::QualitySSIM> > |  | 83183 | struct PyOpenCV_Converter< Ptr<cv::quality::QualitySSIM> >
| 83232 | { |  | 83184 | {
| 83233 | static PyObject* from(const Ptr<cv::quality::QualitySSIM>& r) |  | 83185 | static PyObject* from(const Ptr<cv::quality::QualitySSIM>& r)
| 83234 | { |  | 83186 | {
| 83235 | return pyopencv_quality_QualitySSIM_Instance(r); |  | 83187 | return pyopencv_quality_QualitySSIM_Instance(r);
| 83236 | } |  | 83188 | }
| 83237 | static bool to(PyObject* src, Ptr<cv::quality::QualitySSIM>& dst, const ArgInfo& info) |  | 83189 | static bool to(PyObject* src, Ptr<cv::quality::QualitySSIM>& dst, const ArgInfo& info)
| 83238 | { |  | 83190 | {
| 83239 | if(!src || src == Py_None) |  | 83191 | if(!src || src == Py_None)
| 83240 | return true; |  | 83192 | return true;
| 83241 | Ptr<cv::quality::QualitySSIM> * dst_; |  | 83193 | Ptr<cv::quality::QualitySSIM> * dst_;
| 83242 | if (pyopencv_quality_QualitySSIM_getp(src, dst_)) |  | 83194 | if (pyopencv_quality_QualitySSIM_getp(src, dst_))
| 83243 | { |  | 83195 | {
| 83244 | dst = *dst_; |  | 83196 | dst = *dst_;
| 83245 | return true; |  | 83197 | return true;
| 83246 | } |  | 83198 | }
| 83247 |  |  | 83199 |
| 83248 | failmsg("Expected Ptr<cv::quality::QualitySSIM> for argument '%s'", info.name); |  | 83200 | failmsg("Expected Ptr<cv::quality::QualitySSIM> for argument '%s'", info.name);
| 83249 | return false; |  | 83201 | return false;
| 83250 | } |  | 83202 | }
| 83251 | }; |  | 83203 | };
| 83252 |  |  | 83204 |
| 83253 | //================================================================================ |  | 83205 | //================================================================================
| 83254 | // rapid_GOSTracker (Generic) |  | 83206 | // rapid_GOSTracker (Generic)
| 83255 | //================================================================================ |  | 83207 | //================================================================================
| 83256 |  |  | 83208 |
| 83257 | // GetSet (rapid_GOSTracker) |  | 83209 | // GetSet (rapid_GOSTracker)
| 83258 |  |  | 83210 |
| 83259 |  |  | 83211 |
| 83260 |  |  | 83212 |
| 83261 | // Methods (rapid_GOSTracker) |  | 83213 | // Methods (rapid_GOSTracker)
| 83262 |  |  | 83214 |
| 83263 | static PyObject* pyopencv_cv_rapid_rapid_GOSTracker_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83215 | static PyObject* pyopencv_cv_rapid_rapid_GOSTracker_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 83264 | { |  | 83216 | {
| 83265 | using namespace cv::rapid; |  | 83217 | using namespace cv::rapid;
| 83266 |  |  | 83218 |
| 83267 | pyPrepareArgumentConversionErrorsStorage(2); |  | 83219 | pyPrepareArgumentConversionErrorsStorage(2);
| 83268 |  |  | 83220 |
| 83269 | { |  | 83221 | {
| 83270 | PyObject* pyobj_pts3d = NULL; |  | 83222 | PyObject* pyobj_pts3d = NULL;
| 83271 | Mat pts3d; |  | 83223 | Mat pts3d;
| 83272 | PyObject* pyobj_tris = NULL; |  | 83224 | PyObject* pyobj_tris = NULL;
| 83273 | Mat tris; |  | 83225 | Mat tris;
| 83274 | PyObject* pyobj_histBins = NULL; |  | 83226 | PyObject* pyobj_histBins = NULL;
| 83275 | int histBins=4; |  | 83227 | int histBins=4;
| 83276 | PyObject* pyobj_sobelThesh = NULL; |  | 83228 | PyObject* pyobj_sobelThesh = NULL;
| 83277 | uchar sobelThesh=10; |  | 83229 | uchar sobelThesh=10;
| 83278 | Ptr<OLSTracker> retval; |  | 83230 | Ptr<OLSTracker> retval;
| 83279 |  |  | 83231 |
| 83280 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL }; |  | 83232 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL };
| 83281 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_GOSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) && |  | 83233 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_GOSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) &&
| 83282 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) && |  | 83234 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) &&
| 83283 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) && |  | 83235 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) &&
| 83284 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) && |  | 83236 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) &&
| 83285 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) ) |  | 83237 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) )
| 83286 | { |  | 83238 | {
| 83287 | ERRWRAP2(retval = cv::rapid::GOSTracker::create(pts3d, tris, histBins, sobelThesh)); |  | 83239 | ERRWRAP2(retval = cv::rapid::GOSTracker::create(pts3d, tris, histBins, sobelThesh));
| 83288 | return pyopencv_from(retval); |  | 83240 | return pyopencv_from(retval);
| 83289 | } |  | 83241 | }
| 83290 |  |  | 83242 |
| 83291 |  |  | 83243 |
| 83292 | pyPopulateArgumentConversionErrors(); |  | 83244 | pyPopulateArgumentConversionErrors();
| 83293 | } |  | 83245 | }
| 83294 |  |  | 83246 |
| 83295 |  |  | 83247 |
| 83296 | { |  | 83248 | {
| 83297 | PyObject* pyobj_pts3d = NULL; |  | 83249 | PyObject* pyobj_pts3d = NULL;
| 83298 | UMat pts3d; |  | 83250 | UMat pts3d;
| 83299 | PyObject* pyobj_tris = NULL; |  | 83251 | PyObject* pyobj_tris = NULL;
| 83300 | UMat tris; |  | 83252 | UMat tris;
| 83301 | PyObject* pyobj_histBins = NULL; |  | 83253 | PyObject* pyobj_histBins = NULL;
| 83302 | int histBins=4; |  | 83254 | int histBins=4;
| 83303 | PyObject* pyobj_sobelThesh = NULL; |  | 83255 | PyObject* pyobj_sobelThesh = NULL;
| 83304 | uchar sobelThesh=10; |  | 83256 | uchar sobelThesh=10;
| 83305 | Ptr<OLSTracker> retval; |  | 83257 | Ptr<OLSTracker> retval;
| 83306 |  |  | 83258 |
| 83307 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL }; |  | 83259 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL };
| 83308 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_GOSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) && |  | 83260 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_GOSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) &&
| 83309 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) && |  | 83261 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) &&
| 83310 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) && |  | 83262 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) &&
| 83311 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) && |  | 83263 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) &&
| 83312 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) ) |  | 83264 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) )
| 83313 | { |  | 83265 | {
| 83314 | ERRWRAP2(retval = cv::rapid::GOSTracker::create(pts3d, tris, histBins, sobelThesh)); |  | 83266 | ERRWRAP2(retval = cv::rapid::GOSTracker::create(pts3d, tris, histBins, sobelThesh));
| 83315 | return pyopencv_from(retval); |  | 83267 | return pyopencv_from(retval);
| 83316 | } |  | 83268 | }
| 83317 |  |  | 83269 |
| 83318 |  |  | 83270 |
| 83319 | pyPopulateArgumentConversionErrors(); |  | 83271 | pyPopulateArgumentConversionErrors();
| 83320 | } |  | 83272 | }
| 83321 | pyRaiseCVOverloadException("create"); |  | 83273 | pyRaiseCVOverloadException("create");
| 83322 |  |  | 83274 |
| 83323 | return NULL; |  | 83275 | return NULL;
| 83324 | } |  | 83276 | }
| 83325 |  |  | 83277 |
| 83326 |  |  | 83278 |
| 83327 |  |  | 83279 |
| 83328 | // Tables (rapid_GOSTracker) |  | 83280 | // Tables (rapid_GOSTracker)
| 83329 |  |  | 83281 |
| 83330 | static PyGetSetDef pyopencv_rapid_GOSTracker_getseters[] = |  | 83282 | static PyGetSetDef pyopencv_rapid_GOSTracker_getseters[] =
| 83331 | { |  | 83283 | {
| 83332 | {NULL} /* Sentinel */ |  | 83284 | {NULL} /* Sentinel */
| 83333 | }; |  | 83285 | };
| 83334 |  |  | 83286 |
| 83335 | static PyMethodDef pyopencv_rapid_GOSTracker_methods[] = |  | 83287 | static PyMethodDef pyopencv_rapid_GOSTracker_methods[] =
| 83336 | { |  | 83288 | {
| 83337 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_GOSTracker_create_static, METH_STATIC), "create(pts3d, tris[, histBins[, sobelThesh]]) -> retval\n."}, |  | 83289 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_GOSTracker_create_static, METH_STATIC), "create(pts3d, tris[, histBins[, sobelThesh]]) -> retval\n."},
| 83338 |  |  | 83290 |
| 83339 | {NULL, NULL} |  | 83291 | {NULL, NULL}
| 83340 | }; |  | 83292 | };
| 83341 |  |  | 83293 |
| 83342 | // Converter (rapid_GOSTracker) |  | 83294 | // Converter (rapid_GOSTracker)
| 83343 |  |  | 83295 |
| 83344 | template<> |  | 83296 | template<>
| 83345 | struct PyOpenCV_Converter< Ptr<cv::rapid::GOSTracker> > |  | 83297 | struct PyOpenCV_Converter< Ptr<cv::rapid::GOSTracker> >
| 83346 | { |  | 83298 | {
| 83347 | static PyObject* from(const Ptr<cv::rapid::GOSTracker>& r) |  | 83299 | static PyObject* from(const Ptr<cv::rapid::GOSTracker>& r)
| 83348 | { |  | 83300 | {
| 83349 | return pyopencv_rapid_GOSTracker_Instance(r); |  | 83301 | return pyopencv_rapid_GOSTracker_Instance(r);
| 83350 | } |  | 83302 | }
| 83351 | static bool to(PyObject* src, Ptr<cv::rapid::GOSTracker>& dst, const ArgInfo& info) |  | 83303 | static bool to(PyObject* src, Ptr<cv::rapid::GOSTracker>& dst, const ArgInfo& info)
| 83352 | { |  | 83304 | {
| 83353 | if(!src || src == Py_None) |  | 83305 | if(!src || src == Py_None)
| 83354 | return true; |  | 83306 | return true;
| 83355 | Ptr<cv::rapid::GOSTracker> * dst_; |  | 83307 | Ptr<cv::rapid::GOSTracker> * dst_;
| 83356 | if (pyopencv_rapid_GOSTracker_getp(src, dst_)) |  | 83308 | if (pyopencv_rapid_GOSTracker_getp(src, dst_))
| 83357 | { |  | 83309 | {
| 83358 | dst = *dst_; |  | 83310 | dst = *dst_;
| 83359 | return true; |  | 83311 | return true;
| 83360 | } |  | 83312 | }
| 83361 |  |  | 83313 |
| 83362 | failmsg("Expected Ptr<cv::rapid::GOSTracker> for argument '%s'", info.name); |  | 83314 | failmsg("Expected Ptr<cv::rapid::GOSTracker> for argument '%s'", info.name);
| 83363 | return false; |  | 83315 | return false;
| 83364 | } |  | 83316 | }
| 83365 | }; |  | 83317 | };
| 83366 |  |  | 83318 |
| 83367 | //================================================================================ |  | 83319 | //================================================================================
| 83368 | // rapid_OLSTracker (Generic) |  | 83320 | // rapid_OLSTracker (Generic)
| 83369 | //================================================================================ |  | 83321 | //================================================================================
| 83370 |  |  | 83322 |
| 83371 | // GetSet (rapid_OLSTracker) |  | 83323 | // GetSet (rapid_OLSTracker)
| 83372 |  |  | 83324 |
| 83373 |  |  | 83325 |
| 83374 |  |  | 83326 |
| 83375 | // Methods (rapid_OLSTracker) |  | 83327 | // Methods (rapid_OLSTracker)
| 83376 |  |  | 83328 |
| 83377 | static PyObject* pyopencv_cv_rapid_rapid_OLSTracker_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83329 | static PyObject* pyopencv_cv_rapid_rapid_OLSTracker_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 83378 | { |  | 83330 | {
| 83379 | using namespace cv::rapid; |  | 83331 | using namespace cv::rapid;
| 83380 |  |  | 83332 |
| 83381 | pyPrepareArgumentConversionErrorsStorage(2); |  | 83333 | pyPrepareArgumentConversionErrorsStorage(2);
| 83382 |  |  | 83334 |
| 83383 | { |  | 83335 | {
| 83384 | PyObject* pyobj_pts3d = NULL; |  | 83336 | PyObject* pyobj_pts3d = NULL;
| 83385 | Mat pts3d; |  | 83337 | Mat pts3d;
| 83386 | PyObject* pyobj_tris = NULL; |  | 83338 | PyObject* pyobj_tris = NULL;
| 83387 | Mat tris; |  | 83339 | Mat tris;
| 83388 | PyObject* pyobj_histBins = NULL; |  | 83340 | PyObject* pyobj_histBins = NULL;
| 83389 | int histBins=8; |  | 83341 | int histBins=8;
| 83390 | PyObject* pyobj_sobelThesh = NULL; |  | 83342 | PyObject* pyobj_sobelThesh = NULL;
| 83391 | uchar sobelThesh=10; |  | 83343 | uchar sobelThesh=10;
| 83392 | Ptr<OLSTracker> retval; |  | 83344 | Ptr<OLSTracker> retval;
| 83393 |  |  | 83345 |
| 83394 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL }; |  | 83346 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL };
| 83395 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_OLSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) && |  | 83347 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_OLSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) &&
| 83396 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) && |  | 83348 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) &&
| 83397 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) && |  | 83349 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) &&
| 83398 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) && |  | 83350 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) &&
| 83399 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) ) |  | 83351 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) )
| 83400 | { |  | 83352 | {
| 83401 | ERRWRAP2(retval = cv::rapid::OLSTracker::create(pts3d, tris, histBins, sobelThesh)); |  | 83353 | ERRWRAP2(retval = cv::rapid::OLSTracker::create(pts3d, tris, histBins, sobelThesh));
| 83402 | return pyopencv_from(retval); |  | 83354 | return pyopencv_from(retval);
| 83403 | } |  | 83355 | }
| 83404 |  |  | 83356 |
| 83405 |  |  | 83357 |
| 83406 | pyPopulateArgumentConversionErrors(); |  | 83358 | pyPopulateArgumentConversionErrors();
| 83407 | } |  | 83359 | }
| 83408 |  |  | 83360 |
| 83409 |  |  | 83361 |
| 83410 | { |  | 83362 | {
| 83411 | PyObject* pyobj_pts3d = NULL; |  | 83363 | PyObject* pyobj_pts3d = NULL;
| 83412 | UMat pts3d; |  | 83364 | UMat pts3d;
| 83413 | PyObject* pyobj_tris = NULL; |  | 83365 | PyObject* pyobj_tris = NULL;
| 83414 | UMat tris; |  | 83366 | UMat tris;
| 83415 | PyObject* pyobj_histBins = NULL; |  | 83367 | PyObject* pyobj_histBins = NULL;
| 83416 | int histBins=8; |  | 83368 | int histBins=8;
| 83417 | PyObject* pyobj_sobelThesh = NULL; |  | 83369 | PyObject* pyobj_sobelThesh = NULL;
| 83418 | uchar sobelThesh=10; |  | 83370 | uchar sobelThesh=10;
| 83419 | Ptr<OLSTracker> retval; |  | 83371 | Ptr<OLSTracker> retval;
| 83420 |  |  | 83372 |
| 83421 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL }; |  | 83373 | const char* keywords[] = { "pts3d", "tris", "histBins", "sobelThesh", NULL };
| 83422 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_OLSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) && |  | 83374 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rapid_OLSTracker.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris, &pyobj_histBins, &pyobj_sobelThesh) &&
| 83423 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) && |  | 83375 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) &&
| 83424 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) && |  | 83376 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) &&
| 83425 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) && |  | 83377 | pyopencv_to_safe(pyobj_histBins, histBins, ArgInfo("histBins", 0)) &&
| 83426 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) ) |  | 83378 | pyopencv_to_safe(pyobj_sobelThesh, sobelThesh, ArgInfo("sobelThesh", 0)) )
| 83427 | { |  | 83379 | {
| 83428 | ERRWRAP2(retval = cv::rapid::OLSTracker::create(pts3d, tris, histBins, sobelThesh)); |  | 83380 | ERRWRAP2(retval = cv::rapid::OLSTracker::create(pts3d, tris, histBins, sobelThesh));
| 83429 | return pyopencv_from(retval); |  | 83381 | return pyopencv_from(retval);
| 83430 | } |  | 83382 | }
| 83431 |  |  | 83383 |
| 83432 |  |  | 83384 |
| 83433 | pyPopulateArgumentConversionErrors(); |  | 83385 | pyPopulateArgumentConversionErrors();
| 83434 | } |  | 83386 | }
| 83435 | pyRaiseCVOverloadException("create"); |  | 83387 | pyRaiseCVOverloadException("create");
| 83436 |  |  | 83388 |
| 83437 | return NULL; |  | 83389 | return NULL;
| 83438 | } |  | 83390 | }
| 83439 |  |  | 83391 |
| 83440 |  |  | 83392 |
| 83441 |  |  | 83393 |
| 83442 | // Tables (rapid_OLSTracker) |  | 83394 | // Tables (rapid_OLSTracker)
| 83443 |  |  | 83395 |
| 83444 | static PyGetSetDef pyopencv_rapid_OLSTracker_getseters[] = |  | 83396 | static PyGetSetDef pyopencv_rapid_OLSTracker_getseters[] =
| 83445 | { |  | 83397 | {
| 83446 | {NULL} /* Sentinel */ |  | 83398 | {NULL} /* Sentinel */
| 83447 | }; |  | 83399 | };
| 83448 |  |  | 83400 |
| 83449 | static PyMethodDef pyopencv_rapid_OLSTracker_methods[] = |  | 83401 | static PyMethodDef pyopencv_rapid_OLSTracker_methods[] =
| 83450 | { |  | 83402 | {
| 83451 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_OLSTracker_create_static, METH_STATIC), "create(pts3d, tris[, histBins[, sobelThesh]]) -> retval\n."}, |  | 83403 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_OLSTracker_create_static, METH_STATIC), "create(pts3d, tris[, histBins[, sobelThesh]]) -> retval\n."},
| 83452 |  |  | 83404 |
| 83453 | {NULL, NULL} |  | 83405 | {NULL, NULL}
| 83454 | }; |  | 83406 | };
| 83455 |  |  | 83407 |
| 83456 | // Converter (rapid_OLSTracker) |  | 83408 | // Converter (rapid_OLSTracker)
| 83457 |  |  | 83409 |
| 83458 | template<> |  | 83410 | template<>
| 83459 | struct PyOpenCV_Converter< Ptr<cv::rapid::OLSTracker> > |  | 83411 | struct PyOpenCV_Converter< Ptr<cv::rapid::OLSTracker> >
| 83460 | { |  | 83412 | {
| 83461 | static PyObject* from(const Ptr<cv::rapid::OLSTracker>& r) |  | 83413 | static PyObject* from(const Ptr<cv::rapid::OLSTracker>& r)
| 83462 | { |  | 83414 | {
| 83463 | return pyopencv_rapid_OLSTracker_Instance(r); |  | 83415 | return pyopencv_rapid_OLSTracker_Instance(r);
| 83464 | } |  | 83416 | }
| 83465 | static bool to(PyObject* src, Ptr<cv::rapid::OLSTracker>& dst, const ArgInfo& info) |  | 83417 | static bool to(PyObject* src, Ptr<cv::rapid::OLSTracker>& dst, const ArgInfo& info)
| 83466 | { |  | 83418 | {
| 83467 | if(!src || src == Py_None) |  | 83419 | if(!src || src == Py_None)
| 83468 | return true; |  | 83420 | return true;
| 83469 | Ptr<cv::rapid::OLSTracker> * dst_; |  | 83421 | Ptr<cv::rapid::OLSTracker> * dst_;
| 83470 | if (pyopencv_rapid_OLSTracker_getp(src, dst_)) |  | 83422 | if (pyopencv_rapid_OLSTracker_getp(src, dst_))
| 83471 | { |  | 83423 | {
| 83472 | dst = *dst_; |  | 83424 | dst = *dst_;
| 83473 | return true; |  | 83425 | return true;
| 83474 | } |  | 83426 | }
| 83475 |  |  | 83427 |
| 83476 | failmsg("Expected Ptr<cv::rapid::OLSTracker> for argument '%s'", info.name); |  | 83428 | failmsg("Expected Ptr<cv::rapid::OLSTracker> for argument '%s'", info.name);
| 83477 | return false; |  | 83429 | return false;
| 83478 | } |  | 83430 | }
| 83479 | }; |  | 83431 | };
| 83480 |  |  | 83432 |
| 83481 | //================================================================================ |  | 83433 | //================================================================================
| 83482 | // rapid_Rapid (Generic) |  | 83434 | // rapid_Rapid (Generic)
| 83483 | //================================================================================ |  | 83435 | //================================================================================
| 83484 |  |  | 83436 |
| 83485 | // GetSet (rapid_Rapid) |  | 83437 | // GetSet (rapid_Rapid)
| 83486 |  |  | 83438 |
| 83487 |  |  | 83439 |
| 83488 |  |  | 83440 |
| 83489 | // Methods (rapid_Rapid) |  | 83441 | // Methods (rapid_Rapid)
| 83490 |  |  | 83442 |
| 83491 | static PyObject* pyopencv_cv_rapid_rapid_Rapid_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83443 | static PyObject* pyopencv_cv_rapid_rapid_Rapid_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 83492 | { |  | 83444 | {
| 83493 | using namespace cv::rapid; |  | 83445 | using namespace cv::rapid;
| 83494 |  |  | 83446 |
| 83495 | pyPrepareArgumentConversionErrorsStorage(2); |  | 83447 | pyPrepareArgumentConversionErrorsStorage(2);
| 83496 |  |  | 83448 |
| 83497 | { |  | 83449 | {
| 83498 | PyObject* pyobj_pts3d = NULL; |  | 83450 | PyObject* pyobj_pts3d = NULL;
| 83499 | Mat pts3d; |  | 83451 | Mat pts3d;
| 83500 | PyObject* pyobj_tris = NULL; |  | 83452 | PyObject* pyobj_tris = NULL;
| 83501 | Mat tris; |  | 83453 | Mat tris;
| 83502 | Ptr<Rapid> retval; |  | 83454 | Ptr<Rapid> retval;
| 83503 |  |  | 83455 |
| 83504 | const char* keywords[] = { "pts3d", "tris", NULL }; |  | 83456 | const char* keywords[] = { "pts3d", "tris", NULL };
| 83505 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rapid_Rapid.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris) && |  | 83457 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rapid_Rapid.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris) &&
| 83506 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) && |  | 83458 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) &&
| 83507 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) ) |  | 83459 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) )
| 83508 | { |  | 83460 | {
| 83509 | ERRWRAP2(retval = cv::rapid::Rapid::create(pts3d, tris)); |  | 83461 | ERRWRAP2(retval = cv::rapid::Rapid::create(pts3d, tris));
| 83510 | return pyopencv_from(retval); |  | 83462 | return pyopencv_from(retval);
| 83511 | } |  | 83463 | }
| 83512 |  |  | 83464 |
| 83513 |  |  | 83465 |
| 83514 | pyPopulateArgumentConversionErrors(); |  | 83466 | pyPopulateArgumentConversionErrors();
| 83515 | } |  | 83467 | }
| 83516 |  |  | 83468 |
| 83517 |  |  | 83469 |
| 83518 | { |  | 83470 | {
| 83519 | PyObject* pyobj_pts3d = NULL; |  | 83471 | PyObject* pyobj_pts3d = NULL;
| 83520 | UMat pts3d; |  | 83472 | UMat pts3d;
| 83521 | PyObject* pyobj_tris = NULL; |  | 83473 | PyObject* pyobj_tris = NULL;
| 83522 | UMat tris; |  | 83474 | UMat tris;
| 83523 | Ptr<Rapid> retval; |  | 83475 | Ptr<Rapid> retval;
| 83524 |  |  | 83476 |
| 83525 | const char* keywords[] = { "pts3d", "tris", NULL }; |  | 83477 | const char* keywords[] = { "pts3d", "tris", NULL };
| 83526 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rapid_Rapid.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris) && |  | 83478 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rapid_Rapid.create", (char**)keywords, &pyobj_pts3d, &pyobj_tris) &&
| 83527 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) && |  | 83479 | pyopencv_to_safe(pyobj_pts3d, pts3d, ArgInfo("pts3d", 0)) &&
| 83528 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) ) |  | 83480 | pyopencv_to_safe(pyobj_tris, tris, ArgInfo("tris", 0)) )
| 83529 | { |  | 83481 | {
| 83530 | ERRWRAP2(retval = cv::rapid::Rapid::create(pts3d, tris)); |  | 83482 | ERRWRAP2(retval = cv::rapid::Rapid::create(pts3d, tris));
| 83531 | return pyopencv_from(retval); |  | 83483 | return pyopencv_from(retval);
| 83532 | } |  | 83484 | }
| 83533 |  |  | 83485 |
| 83534 |  |  | 83486 |
| 83535 | pyPopulateArgumentConversionErrors(); |  | 83487 | pyPopulateArgumentConversionErrors();
| 83536 | } |  | 83488 | }
| 83537 | pyRaiseCVOverloadException("create"); |  | 83489 | pyRaiseCVOverloadException("create");
| 83538 |  |  | 83490 |
| 83539 | return NULL; |  | 83491 | return NULL;
| 83540 | } |  | 83492 | }
| 83541 |  |  | 83493 |
| 83542 |  |  | 83494 |
| 83543 |  |  | 83495 |
| 83544 | // Tables (rapid_Rapid) |  | 83496 | // Tables (rapid_Rapid)
| 83545 |  |  | 83497 |
| 83546 | static PyGetSetDef pyopencv_rapid_Rapid_getseters[] = |  | 83498 | static PyGetSetDef pyopencv_rapid_Rapid_getseters[] =
| 83547 | { |  | 83499 | {
| 83548 | {NULL} /* Sentinel */ |  | 83500 | {NULL} /* Sentinel */
| 83549 | }; |  | 83501 | };
| 83550 |  |  | 83502 |
| 83551 | static PyMethodDef pyopencv_rapid_Rapid_methods[] = |  | 83503 | static PyMethodDef pyopencv_rapid_Rapid_methods[] =
| 83552 | { |  | 83504 | {
| 83553 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_Rapid_create_static, METH_STATIC), "create(pts3d, tris) -> retval\n."}, |  | 83505 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_Rapid_create_static, METH_STATIC), "create(pts3d, tris) -> retval\n."},
| 83554 |  |  | 83506 |
| 83555 | {NULL, NULL} |  | 83507 | {NULL, NULL}
| 83556 | }; |  | 83508 | };
| 83557 |  |  | 83509 |
| 83558 | // Converter (rapid_Rapid) |  | 83510 | // Converter (rapid_Rapid)
| 83559 |  |  | 83511 |
| 83560 | template<> |  | 83512 | template<>
| 83561 | struct PyOpenCV_Converter< Ptr<cv::rapid::Rapid> > |  | 83513 | struct PyOpenCV_Converter< Ptr<cv::rapid::Rapid> >
| 83562 | { |  | 83514 | {
| 83563 | static PyObject* from(const Ptr<cv::rapid::Rapid>& r) |  | 83515 | static PyObject* from(const Ptr<cv::rapid::Rapid>& r)
| 83564 | { |  | 83516 | {
| 83565 | return pyopencv_rapid_Rapid_Instance(r); |  | 83517 | return pyopencv_rapid_Rapid_Instance(r);
| 83566 | } |  | 83518 | }
| 83567 | static bool to(PyObject* src, Ptr<cv::rapid::Rapid>& dst, const ArgInfo& info) |  | 83519 | static bool to(PyObject* src, Ptr<cv::rapid::Rapid>& dst, const ArgInfo& info)
| 83568 | { |  | 83520 | {
| 83569 | if(!src || src == Py_None) |  | 83521 | if(!src || src == Py_None)
| 83570 | return true; |  | 83522 | return true;
| 83571 | Ptr<cv::rapid::Rapid> * dst_; |  | 83523 | Ptr<cv::rapid::Rapid> * dst_;
| 83572 | if (pyopencv_rapid_Rapid_getp(src, dst_)) |  | 83524 | if (pyopencv_rapid_Rapid_getp(src, dst_))
| 83573 | { |  | 83525 | {
| 83574 | dst = *dst_; |  | 83526 | dst = *dst_;
| 83575 | return true; |  | 83527 | return true;
| 83576 | } |  | 83528 | }
| 83577 |  |  | 83529 |
| 83578 | failmsg("Expected Ptr<cv::rapid::Rapid> for argument '%s'", info.name); |  | 83530 | failmsg("Expected Ptr<cv::rapid::Rapid> for argument '%s'", info.name);
| 83579 | return false; |  | 83531 | return false;
| 83580 | } |  | 83532 | }
| 83581 | }; |  | 83533 | };
| 83582 |  |  | 83534 |
| 83583 | //================================================================================ |  | 83535 | //================================================================================
| 83584 | // rapid_Tracker (Generic) |  | 83536 | // rapid_Tracker (Generic)
| 83585 | //================================================================================ |  | 83537 | //================================================================================
| 83586 |  |  | 83538 |
| 83587 | // GetSet (rapid_Tracker) |  | 83539 | // GetSet (rapid_Tracker)
| 83588 |  |  | 83540 |
| 83589 |  |  | 83541 |
| 83590 |  |  | 83542 |
| 83591 | // Methods (rapid_Tracker) |  | 83543 | // Methods (rapid_Tracker)
| 83592 |  |  | 83544 |
| 83593 | static PyObject* pyopencv_cv_rapid_rapid_Tracker_clearState(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83545 | static PyObject* pyopencv_cv_rapid_rapid_Tracker_clearState(PyObject* self, PyObject* py_args, PyObject* kw)
| 83594 | { |  | 83546 | {
| 83595 | using namespace cv::rapid; |  | 83547 | using namespace cv::rapid;
| 83596 |  |  | 83548 |
| 83597 |  |  | 83549 |
| 83598 | Ptr<cv::rapid::Tracker> * self1 = 0; |  | 83550 | Ptr<cv::rapid::Tracker> * self1 = 0;
| 83599 | if (!pyopencv_rapid_Tracker_getp(self, self1)) |  | 83551 | if (!pyopencv_rapid_Tracker_getp(self, self1))
| 83600 | return failmsgp("Incorrect type of self (must be 'rapid_Tracker' or its derivative)"); |  | 83552 | return failmsgp("Incorrect type of self (must be 'rapid_Tracker' or its derivative)");
| 83601 | Ptr<cv::rapid::Tracker> _self_ = *(self1); |  | 83553 | Ptr<cv::rapid::Tracker> _self_ = *(self1);
| 83602 |  |  | 83554 |
| 83603 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 83555 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 83604 | { |  | 83556 | {
| 83605 | ERRWRAP2(_self_->clearState()); |  | 83557 | ERRWRAP2(_self_->clearState());
| 83606 | Py_RETURN_NONE; |  | 83558 | Py_RETURN_NONE;
| 83607 | } |  | 83559 | }
| 83608 |  |  | 83560 |
| 83609 | return NULL; |  | 83561 | return NULL;
| 83610 | } |  | 83562 | }
| 83611 |  |  | 83563 |
| 83612 | static PyObject* pyopencv_cv_rapid_rapid_Tracker_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83564 | static PyObject* pyopencv_cv_rapid_rapid_Tracker_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 83613 | { |  | 83565 | {
| 83614 | using namespace cv::rapid; |  | 83566 | using namespace cv::rapid;
| 83615 |  |  | 83567 |
| 83616 |  |  | 83568 |
| 83617 | Ptr<cv::rapid::Tracker> * self1 = 0; |  | 83569 | Ptr<cv::rapid::Tracker> * self1 = 0;
| 83618 | if (!pyopencv_rapid_Tracker_getp(self, self1)) |  | 83570 | if (!pyopencv_rapid_Tracker_getp(self, self1))
| 83619 | return failmsgp("Incorrect type of self (must be 'rapid_Tracker' or its derivative)"); |  | 83571 | return failmsgp("Incorrect type of self (must be 'rapid_Tracker' or its derivative)");
| 83620 | Ptr<cv::rapid::Tracker> _self_ = *(self1); |  | 83572 | Ptr<cv::rapid::Tracker> _self_ = *(self1);
| 83621 | pyPrepareArgumentConversionErrorsStorage(2); |  | 83573 | pyPrepareArgumentConversionErrorsStorage(2);
| 83622 |  |  | 83574 |
| 83623 | { |  | 83575 | {
| 83624 | PyObject* pyobj_img = NULL; |  | 83576 | PyObject* pyobj_img = NULL;
| 83625 | Mat img; |  | 83577 | Mat img;
| 83626 | PyObject* pyobj_num = NULL; |  | 83578 | PyObject* pyobj_num = NULL;
| 83627 | int num=0; |  | 83579 | int num=0;
| 83628 | PyObject* pyobj_len = NULL; |  | 83580 | PyObject* pyobj_len = NULL;
| 83629 | int len=0; |  | 83581 | int len=0;
| 83630 | PyObject* pyobj_K = NULL; |  | 83582 | PyObject* pyobj_K = NULL;
| 83631 | Mat K; |  | 83583 | Mat K;
| 83632 | PyObject* pyobj_rvec = NULL; |  | 83584 | PyObject* pyobj_rvec = NULL;
| 83633 | Mat rvec; |  | 83585 | Mat rvec;
| 83634 | PyObject* pyobj_tvec = NULL; |  | 83586 | PyObject* pyobj_tvec = NULL;
| 83635 | Mat tvec; |  | 83587 | Mat tvec;
| 83636 | PyObject* pyobj_termcrit = NULL; |  | 83588 | PyObject* pyobj_termcrit = NULL;
| 83637 | TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS, 5, 1.5); |  | 83589 | TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS, 5, 1.5);
| 83638 | float retval; |  | 83590 | float retval;
| 83639 |  |  | 83591 |
| 83640 | const char* keywords[] = { "img", "num", "len", "K", "rvec", "tvec", "termcrit", NULL }; |  | 83592 | const char* keywords[] = { "img", "num", "len", "K", "rvec", "tvec", "termcrit", NULL };
| 83641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:rapid_Tracker.compute", (char**)keywords, &pyobj_img, &pyobj_num, &pyobj_len, &pyobj_K, &pyobj_rvec, &pyobj_tvec, &pyobj_termcrit) && |  | 83593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:rapid_Tracker.compute", (char**)keywords, &pyobj_img, &pyobj_num, &pyobj_len, &pyobj_K, &pyobj_rvec, &pyobj_tvec, &pyobj_termcrit) &&
| 83642 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 83594 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 83643 | pyopencv_to_safe(pyobj_num, num, ArgInfo("num", 0)) && |  | 83595 | pyopencv_to_safe(pyobj_num, num, ArgInfo("num", 0)) &&
| 83644 | pyopencv_to_safe(pyobj_len, len, ArgInfo("len", 0)) && |  | 83596 | pyopencv_to_safe(pyobj_len, len, ArgInfo("len", 0)) &&
| 83645 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 83597 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 83646 | pyopencv_to_safe(pyobj_rvec, rvec, ArgInfo("rvec", 1)) && |  | 83598 | pyopencv_to_safe(pyobj_rvec, rvec, ArgInfo("rvec", 1)) &&
| 83647 | pyopencv_to_safe(pyobj_tvec, tvec, ArgInfo("tvec", 1)) && |  | 83599 | pyopencv_to_safe(pyobj_tvec, tvec, ArgInfo("tvec", 1)) &&
| 83648 | pyopencv_to_safe(pyobj_termcrit, termcrit, ArgInfo("termcrit", 0)) ) |  | 83600 | pyopencv_to_safe(pyobj_termcrit, termcrit, ArgInfo("termcrit", 0)) )
| 83649 | { |  | 83601 | {
| 83650 | ERRWRAP2(retval = _self_->compute(img, num, len, K, rvec, tvec, termcrit)); |  | 83602 | ERRWRAP2(retval = _self_->compute(img, num, len, K, rvec, tvec, termcrit));
| 83651 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(rvec), pyopencv_from(tvec)); |  | 83603 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(rvec), pyopencv_from(tvec));
| 83652 | } |  | 83604 | }
| 83653 |  |  | 83605 |
| 83654 |  |  | 83606 |
| 83655 | pyPopulateArgumentConversionErrors(); |  | 83607 | pyPopulateArgumentConversionErrors();
| 83656 | } |  | 83608 | }
| 83657 |  |  | 83609 |
| 83658 |  |  | 83610 |
| 83659 | { |  | 83611 | {
| 83660 | PyObject* pyobj_img = NULL; |  | 83612 | PyObject* pyobj_img = NULL;
| 83661 | UMat img; |  | 83613 | UMat img;
| 83662 | PyObject* pyobj_num = NULL; |  | 83614 | PyObject* pyobj_num = NULL;
| 83663 | int num=0; |  | 83615 | int num=0;
| 83664 | PyObject* pyobj_len = NULL; |  | 83616 | PyObject* pyobj_len = NULL;
| 83665 | int len=0; |  | 83617 | int len=0;
| 83666 | PyObject* pyobj_K = NULL; |  | 83618 | PyObject* pyobj_K = NULL;
| 83667 | UMat K; |  | 83619 | UMat K;
| 83668 | PyObject* pyobj_rvec = NULL; |  | 83620 | PyObject* pyobj_rvec = NULL;
| 83669 | UMat rvec; |  | 83621 | UMat rvec;
| 83670 | PyObject* pyobj_tvec = NULL; |  | 83622 | PyObject* pyobj_tvec = NULL;
| 83671 | UMat tvec; |  | 83623 | UMat tvec;
| 83672 | PyObject* pyobj_termcrit = NULL; |  | 83624 | PyObject* pyobj_termcrit = NULL;
| 83673 | TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS, 5, 1.5); |  | 83625 | TermCriteria termcrit=TermCriteria(TermCriteria::MAX_ITER | TermCriteria::EPS, 5, 1.5);
| 83674 | float retval; |  | 83626 | float retval;
| 83675 |  |  | 83627 |
| 83676 | const char* keywords[] = { "img", "num", "len", "K", "rvec", "tvec", "termcrit", NULL }; |  | 83628 | const char* keywords[] = { "img", "num", "len", "K", "rvec", "tvec", "termcrit", NULL };
| 83677 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:rapid_Tracker.compute", (char**)keywords, &pyobj_img, &pyobj_num, &pyobj_len, &pyobj_K, &pyobj_rvec, &pyobj_tvec, &pyobj_termcrit) && |  | 83629 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|O:rapid_Tracker.compute", (char**)keywords, &pyobj_img, &pyobj_num, &pyobj_len, &pyobj_K, &pyobj_rvec, &pyobj_tvec, &pyobj_termcrit) &&
| 83678 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) && |  | 83630 | pyopencv_to_safe(pyobj_img, img, ArgInfo("img", 0)) &&
| 83679 | pyopencv_to_safe(pyobj_num, num, ArgInfo("num", 0)) && |  | 83631 | pyopencv_to_safe(pyobj_num, num, ArgInfo("num", 0)) &&
| 83680 | pyopencv_to_safe(pyobj_len, len, ArgInfo("len", 0)) && |  | 83632 | pyopencv_to_safe(pyobj_len, len, ArgInfo("len", 0)) &&
| 83681 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 83633 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 83682 | pyopencv_to_safe(pyobj_rvec, rvec, ArgInfo("rvec", 1)) && |  | 83634 | pyopencv_to_safe(pyobj_rvec, rvec, ArgInfo("rvec", 1)) &&
| 83683 | pyopencv_to_safe(pyobj_tvec, tvec, ArgInfo("tvec", 1)) && |  | 83635 | pyopencv_to_safe(pyobj_tvec, tvec, ArgInfo("tvec", 1)) &&
| 83684 | pyopencv_to_safe(pyobj_termcrit, termcrit, ArgInfo("termcrit", 0)) ) |  | 83636 | pyopencv_to_safe(pyobj_termcrit, termcrit, ArgInfo("termcrit", 0)) )
| 83685 | { |  | 83637 | {
| 83686 | ERRWRAP2(retval = _self_->compute(img, num, len, K, rvec, tvec, termcrit)); |  | 83638 | ERRWRAP2(retval = _self_->compute(img, num, len, K, rvec, tvec, termcrit));
| 83687 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(rvec), pyopencv_from(tvec)); |  | 83639 | return Py_BuildValue("(NNN)", pyopencv_from(retval), pyopencv_from(rvec), pyopencv_from(tvec));
| 83688 | } |  | 83640 | }
| 83689 |  |  | 83641 |
| 83690 |  |  | 83642 |
| 83691 | pyPopulateArgumentConversionErrors(); |  | 83643 | pyPopulateArgumentConversionErrors();
| 83692 | } |  | 83644 | }
| 83693 | pyRaiseCVOverloadException("compute"); |  | 83645 | pyRaiseCVOverloadException("compute");
| 83694 |  |  | 83646 |
| 83695 | return NULL; |  | 83647 | return NULL;
| 83696 | } |  | 83648 | }
| 83697 |  |  | 83649 |
| 83698 |  |  | 83650 |
| 83699 |  |  | 83651 |
| 83700 | // Tables (rapid_Tracker) |  | 83652 | // Tables (rapid_Tracker)
| 83701 |  |  | 83653 |
| 83702 | static PyGetSetDef pyopencv_rapid_Tracker_getseters[] = |  | 83654 | static PyGetSetDef pyopencv_rapid_Tracker_getseters[] =
| 83703 | { |  | 83655 | {
| 83704 | {NULL} /* Sentinel */ |  | 83656 | {NULL} /* Sentinel */
| 83705 | }; |  | 83657 | };
| 83706 |  |  | 83658 |
| 83707 | static PyMethodDef pyopencv_rapid_Tracker_methods[] = |  | 83659 | static PyMethodDef pyopencv_rapid_Tracker_methods[] =
| 83708 | { |  | 83660 | {
| 83709 | {"clearState", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_Tracker_clearState, 0), "clearState() -> None\n."}, |  | 83661 | {"clearState", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_Tracker_clearState, 0), "clearState() -> None\n."},
| 83710 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_Tracker_compute, 0), "compute(img, num, len, K, rvec, tvec[, termcrit]) -> retval, rvec, tvec\n."}, |  | 83662 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_rapid_rapid_Tracker_compute, 0), "compute(img, num, len, K, rvec, tvec[, termcrit]) -> retval, rvec, tvec\n."},
| 83711 |  |  | 83663 |
| 83712 | {NULL, NULL} |  | 83664 | {NULL, NULL}
| 83713 | }; |  | 83665 | };
| 83714 |  |  | 83666 |
| 83715 | // Converter (rapid_Tracker) |  | 83667 | // Converter (rapid_Tracker)
| 83716 |  |  | 83668 |
| 83717 | template<> |  | 83669 | template<>
| 83718 | struct PyOpenCV_Converter< Ptr<cv::rapid::Tracker> > |  | 83670 | struct PyOpenCV_Converter< Ptr<cv::rapid::Tracker> >
| 83719 | { |  | 83671 | {
| 83720 | static PyObject* from(const Ptr<cv::rapid::Tracker>& r) |  | 83672 | static PyObject* from(const Ptr<cv::rapid::Tracker>& r)
| 83721 | { |  | 83673 | {
| 83722 | return pyopencv_rapid_Tracker_Instance(r); |  | 83674 | return pyopencv_rapid_Tracker_Instance(r);
| 83723 | } |  | 83675 | }
| 83724 | static bool to(PyObject* src, Ptr<cv::rapid::Tracker>& dst, const ArgInfo& info) |  | 83676 | static bool to(PyObject* src, Ptr<cv::rapid::Tracker>& dst, const ArgInfo& info)
| 83725 | { |  | 83677 | {
| 83726 | if(!src || src == Py_None) |  | 83678 | if(!src || src == Py_None)
| 83727 | return true; |  | 83679 | return true;
| 83728 | Ptr<cv::rapid::Tracker> * dst_; |  | 83680 | Ptr<cv::rapid::Tracker> * dst_;
| 83729 | if (pyopencv_rapid_Tracker_getp(src, dst_)) |  | 83681 | if (pyopencv_rapid_Tracker_getp(src, dst_))
| 83730 | { |  | 83682 | {
| 83731 | dst = *dst_; |  | 83683 | dst = *dst_;
| 83732 | return true; |  | 83684 | return true;
| 83733 | } |  | 83685 | }
| 83734 |  |  | 83686 |
| 83735 | failmsg("Expected Ptr<cv::rapid::Tracker> for argument '%s'", info.name); |  | 83687 | failmsg("Expected Ptr<cv::rapid::Tracker> for argument '%s'", info.name);
| 83736 | return false; |  | 83688 | return false;
| 83737 | } |  | 83689 | }
| 83738 | }; |  | 83690 | };
| 83739 |  |  | 83691 |
| 83740 | //================================================================================ |  | 83692 | //================================================================================
| 83741 | // reg_Map (Generic) |  | 83693 | // reg_Map (Generic)
| 83742 | //================================================================================ |  | 83694 | //================================================================================
| 83743 |  |  | 83695 |
| 83744 | // GetSet (reg_Map) |  | 83696 | // GetSet (reg_Map)
| 83745 |  |  | 83697 |
| 83746 |  |  | 83698 |
| 83747 |  |  | 83699 |
| 83748 | // Methods (reg_Map) |  | 83700 | // Methods (reg_Map)
| 83749 |  |  | 83701 |
| 83750 | static PyObject* pyopencv_cv_reg_reg_Map_compose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83702 | static PyObject* pyopencv_cv_reg_reg_Map_compose(PyObject* self, PyObject* py_args, PyObject* kw)
| 83751 | { |  | 83703 | {
| 83752 | using namespace cv::reg; |  | 83704 | using namespace cv::reg;
| 83753 |  |  | 83705 |
| 83754 |  |  | 83706 |
| 83755 | Ptr<cv::reg::Map> * self1 = 0; |  | 83707 | Ptr<cv::reg::Map> * self1 = 0;
| 83756 | if (!pyopencv_reg_Map_getp(self, self1)) |  | 83708 | if (!pyopencv_reg_Map_getp(self, self1))
| 83757 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)"); |  | 83709 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)");
| 83758 | Ptr<cv::reg::Map> _self_ = *(self1); |  | 83710 | Ptr<cv::reg::Map> _self_ = *(self1);
| 83759 | PyObject* pyobj_map = NULL; |  | 83711 | PyObject* pyobj_map = NULL;
| 83760 | Ptr<Map> map; |  | 83712 | Ptr<Map> map;
| 83761 |  |  | 83713 |
| 83762 | const char* keywords[] = { "map", NULL }; |  | 83714 | const char* keywords[] = { "map", NULL };
| 83763 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_Map.compose", (char**)keywords, &pyobj_map) && |  | 83715 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_Map.compose", (char**)keywords, &pyobj_map) &&
| 83764 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) ) |  | 83716 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) )
| 83765 | { |  | 83717 | {
| 83766 | ERRWRAP2(_self_->compose(map)); |  | 83718 | ERRWRAP2(_self_->compose(map));
| 83767 | Py_RETURN_NONE; |  | 83719 | Py_RETURN_NONE;
| 83768 | } |  | 83720 | }
| 83769 |  |  | 83721 |
| 83770 | return NULL; |  | 83722 | return NULL;
| 83771 | } |  | 83723 | }
| 83772 |  |  | 83724 |
| 83773 | static PyObject* pyopencv_cv_reg_reg_Map_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83725 | static PyObject* pyopencv_cv_reg_reg_Map_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 83774 | { |  | 83726 | {
| 83775 | using namespace cv::reg; |  | 83727 | using namespace cv::reg;
| 83776 |  |  | 83728 |
| 83777 |  |  | 83729 |
| 83778 | Ptr<cv::reg::Map> * self1 = 0; |  | 83730 | Ptr<cv::reg::Map> * self1 = 0;
| 83779 | if (!pyopencv_reg_Map_getp(self, self1)) |  | 83731 | if (!pyopencv_reg_Map_getp(self, self1))
| 83780 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)"); |  | 83732 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)");
| 83781 | Ptr<cv::reg::Map> _self_ = *(self1); |  | 83733 | Ptr<cv::reg::Map> _self_ = *(self1);
| 83782 | cv::Ptr<Map> retval; |  | 83734 | cv::Ptr<Map> retval;
| 83783 |  |  | 83735 |
| 83784 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 83736 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 83785 | { |  | 83737 | {
| 83786 | ERRWRAP2(retval = _self_->inverseMap()); |  | 83738 | ERRWRAP2(retval = _self_->inverseMap());
| 83787 | return pyopencv_from(retval); |  | 83739 | return pyopencv_from(retval);
| 83788 | } |  | 83740 | }
| 83789 |  |  | 83741 |
| 83790 | return NULL; |  | 83742 | return NULL;
| 83791 | } |  | 83743 | }
| 83792 |  |  | 83744 |
| 83793 | static PyObject* pyopencv_cv_reg_reg_Map_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83745 | static PyObject* pyopencv_cv_reg_reg_Map_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw)
| 83794 | { |  | 83746 | {
| 83795 | using namespace cv::reg; |  | 83747 | using namespace cv::reg;
| 83796 |  |  | 83748 |
| 83797 |  |  | 83749 |
| 83798 | Ptr<cv::reg::Map> * self1 = 0; |  | 83750 | Ptr<cv::reg::Map> * self1 = 0;
| 83799 | if (!pyopencv_reg_Map_getp(self, self1)) |  | 83751 | if (!pyopencv_reg_Map_getp(self, self1))
| 83800 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)"); |  | 83752 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)");
| 83801 | Ptr<cv::reg::Map> _self_ = *(self1); |  | 83753 | Ptr<cv::reg::Map> _self_ = *(self1);
| 83802 | pyPrepareArgumentConversionErrorsStorage(2); |  | 83754 | pyPrepareArgumentConversionErrorsStorage(2);
| 83803 |  |  | 83755 |
| 83804 | { |  | 83756 | {
| 83805 | PyObject* pyobj_img1 = NULL; |  | 83757 | PyObject* pyobj_img1 = NULL;
| 83806 | Mat img1; |  | 83758 | Mat img1;
| 83807 | PyObject* pyobj_img2 = NULL; |  | 83759 | PyObject* pyobj_img2 = NULL;
| 83808 | Mat img2; |  | 83760 | Mat img2;
| 83809 |  |  | 83761 |
| 83810 | const char* keywords[] = { "img1", "img2", NULL }; |  | 83762 | const char* keywords[] = { "img1", "img2", NULL };
| 83811 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 83763 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 83812 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 83764 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 83813 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 83765 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 83814 | { |  | 83766 | {
| 83815 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 83767 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 83816 | return pyopencv_from(img2); |  | 83768 | return pyopencv_from(img2);
| 83817 | } |  | 83769 | }
| 83818 |  |  | 83770 |
| 83819 |  |  | 83771 |
| 83820 | pyPopulateArgumentConversionErrors(); |  | 83772 | pyPopulateArgumentConversionErrors();
| 83821 | } |  | 83773 | }
| 83822 |  |  | 83774 |
| 83823 |  |  | 83775 |
| 83824 | { |  | 83776 | {
| 83825 | PyObject* pyobj_img1 = NULL; |  | 83777 | PyObject* pyobj_img1 = NULL;
| 83826 | UMat img1; |  | 83778 | UMat img1;
| 83827 | PyObject* pyobj_img2 = NULL; |  | 83779 | PyObject* pyobj_img2 = NULL;
| 83828 | UMat img2; |  | 83780 | UMat img2;
| 83829 |  |  | 83781 |
| 83830 | const char* keywords[] = { "img1", "img2", NULL }; |  | 83782 | const char* keywords[] = { "img1", "img2", NULL };
| 83831 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 83783 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 83832 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 83784 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 83833 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 83785 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 83834 | { |  | 83786 | {
| 83835 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 83787 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 83836 | return pyopencv_from(img2); |  | 83788 | return pyopencv_from(img2);
| 83837 | } |  | 83789 | }
| 83838 |  |  | 83790 |
| 83839 |  |  | 83791 |
| 83840 | pyPopulateArgumentConversionErrors(); |  | 83792 | pyPopulateArgumentConversionErrors();
| 83841 | } |  | 83793 | }
| 83842 | pyRaiseCVOverloadException("inverseWarp"); |  | 83794 | pyRaiseCVOverloadException("inverseWarp");
| 83843 |  |  | 83795 |
| 83844 | return NULL; |  | 83796 | return NULL;
| 83845 | } |  | 83797 | }
| 83846 |  |  | 83798 |
| 83847 | static PyObject* pyopencv_cv_reg_reg_Map_scale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83799 | static PyObject* pyopencv_cv_reg_reg_Map_scale(PyObject* self, PyObject* py_args, PyObject* kw)
| 83848 | { |  | 83800 | {
| 83849 | using namespace cv::reg; |  | 83801 | using namespace cv::reg;
| 83850 |  |  | 83802 |
| 83851 |  |  | 83803 |
| 83852 | Ptr<cv::reg::Map> * self1 = 0; |  | 83804 | Ptr<cv::reg::Map> * self1 = 0;
| 83853 | if (!pyopencv_reg_Map_getp(self, self1)) |  | 83805 | if (!pyopencv_reg_Map_getp(self, self1))
| 83854 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)"); |  | 83806 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)");
| 83855 | Ptr<cv::reg::Map> _self_ = *(self1); |  | 83807 | Ptr<cv::reg::Map> _self_ = *(self1);
| 83856 | PyObject* pyobj_factor = NULL; |  | 83808 | PyObject* pyobj_factor = NULL;
| 83857 | double factor=0; |  | 83809 | double factor=0;
| 83858 |  |  | 83810 |
| 83859 | const char* keywords[] = { "factor", NULL }; |  | 83811 | const char* keywords[] = { "factor", NULL };
| 83860 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_Map.scale", (char**)keywords, &pyobj_factor) && |  | 83812 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_Map.scale", (char**)keywords, &pyobj_factor) &&
| 83861 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) ) |  | 83813 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) )
| 83862 | { |  | 83814 | {
| 83863 | ERRWRAP2(_self_->scale(factor)); |  | 83815 | ERRWRAP2(_self_->scale(factor));
| 83864 | Py_RETURN_NONE; |  | 83816 | Py_RETURN_NONE;
| 83865 | } |  | 83817 | }
| 83866 |  |  | 83818 |
| 83867 | return NULL; |  | 83819 | return NULL;
| 83868 | } |  | 83820 | }
| 83869 |  |  | 83821 |
| 83870 | static PyObject* pyopencv_cv_reg_reg_Map_warp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83822 | static PyObject* pyopencv_cv_reg_reg_Map_warp(PyObject* self, PyObject* py_args, PyObject* kw)
| 83871 | { |  | 83823 | {
| 83872 | using namespace cv::reg; |  | 83824 | using namespace cv::reg;
| 83873 |  |  | 83825 |
| 83874 |  |  | 83826 |
| 83875 | Ptr<cv::reg::Map> * self1 = 0; |  | 83827 | Ptr<cv::reg::Map> * self1 = 0;
| 83876 | if (!pyopencv_reg_Map_getp(self, self1)) |  | 83828 | if (!pyopencv_reg_Map_getp(self, self1))
| 83877 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)"); |  | 83829 | return failmsgp("Incorrect type of self (must be 'reg_Map' or its derivative)");
| 83878 | Ptr<cv::reg::Map> _self_ = *(self1); |  | 83830 | Ptr<cv::reg::Map> _self_ = *(self1);
| 83879 | pyPrepareArgumentConversionErrorsStorage(2); |  | 83831 | pyPrepareArgumentConversionErrorsStorage(2);
| 83880 |  |  | 83832 |
| 83881 | { |  | 83833 | {
| 83882 | PyObject* pyobj_img1 = NULL; |  | 83834 | PyObject* pyobj_img1 = NULL;
| 83883 | Mat img1; |  | 83835 | Mat img1;
| 83884 | PyObject* pyobj_img2 = NULL; |  | 83836 | PyObject* pyobj_img2 = NULL;
| 83885 | Mat img2; |  | 83837 | Mat img2;
| 83886 |  |  | 83838 |
| 83887 | const char* keywords[] = { "img1", "img2", NULL }; |  | 83839 | const char* keywords[] = { "img1", "img2", NULL };
| 83888 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.warp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 83840 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.warp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 83889 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 83841 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 83890 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 83842 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 83891 | { |  | 83843 | {
| 83892 | ERRWRAP2(_self_->warp(img1, img2)); |  | 83844 | ERRWRAP2(_self_->warp(img1, img2));
| 83893 | return pyopencv_from(img2); |  | 83845 | return pyopencv_from(img2);
| 83894 | } |  | 83846 | }
| 83895 |  |  | 83847 |
| 83896 |  |  | 83848 |
| 83897 | pyPopulateArgumentConversionErrors(); |  | 83849 | pyPopulateArgumentConversionErrors();
| 83898 | } |  | 83850 | }
| 83899 |  |  | 83851 |
| 83900 |  |  | 83852 |
| 83901 | { |  | 83853 | {
| 83902 | PyObject* pyobj_img1 = NULL; |  | 83854 | PyObject* pyobj_img1 = NULL;
| 83903 | UMat img1; |  | 83855 | UMat img1;
| 83904 | PyObject* pyobj_img2 = NULL; |  | 83856 | PyObject* pyobj_img2 = NULL;
| 83905 | UMat img2; |  | 83857 | UMat img2;
| 83906 |  |  | 83858 |
| 83907 | const char* keywords[] = { "img1", "img2", NULL }; |  | 83859 | const char* keywords[] = { "img1", "img2", NULL };
| 83908 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.warp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 83860 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_Map.warp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 83909 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 83861 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 83910 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 83862 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 83911 | { |  | 83863 | {
| 83912 | ERRWRAP2(_self_->warp(img1, img2)); |  | 83864 | ERRWRAP2(_self_->warp(img1, img2));
| 83913 | return pyopencv_from(img2); |  | 83865 | return pyopencv_from(img2);
| 83914 | } |  | 83866 | }
| 83915 |  |  | 83867 |
| 83916 |  |  | 83868 |
| 83917 | pyPopulateArgumentConversionErrors(); |  | 83869 | pyPopulateArgumentConversionErrors();
| 83918 | } |  | 83870 | }
| 83919 | pyRaiseCVOverloadException("warp"); |  | 83871 | pyRaiseCVOverloadException("warp");
| 83920 |  |  | 83872 |
| 83921 | return NULL; |  | 83873 | return NULL;
| 83922 | } |  | 83874 | }
| 83923 |  |  | 83875 |
| 83924 |  |  | 83876 |
| 83925 |  |  | 83877 |
| 83926 | // Tables (reg_Map) |  | 83878 | // Tables (reg_Map)
| 83927 |  |  | 83879 |
| 83928 | static PyGetSetDef pyopencv_reg_Map_getseters[] = |  | 83880 | static PyGetSetDef pyopencv_reg_Map_getseters[] =
| 83929 | { |  | 83881 | {
| 83930 | {NULL} /* Sentinel */ |  | 83882 | {NULL} /* Sentinel */
| 83931 | }; |  | 83883 | };
| 83932 |  |  | 83884 |
| 83933 | static PyMethodDef pyopencv_reg_Map_methods[] = |  | 83885 | static PyMethodDef pyopencv_reg_Map_methods[] =
| 83934 | { |  | 83886 | {
| 83935 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_compose, 0), "compose(map) -> None\n."}, |  | 83887 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_compose, 0), "compose(map) -> None\n."},
| 83936 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_inverseMap, 0), "inverseMap() -> retval\n."}, |  | 83888 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_inverseMap, 0), "inverseMap() -> retval\n."},
| 83937 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."}, |  | 83889 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."},
| 83938 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_scale, 0), "scale(factor) -> None\n."}, |  | 83890 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_scale, 0), "scale(factor) -> None\n."},
| 83939 | {"warp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_warp, 0), "warp(img1[, img2]) -> img2\n."}, |  | 83891 | {"warp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Map_warp, 0), "warp(img1[, img2]) -> img2\n."},
| 83940 |  |  | 83892 |
| 83941 | {NULL, NULL} |  | 83893 | {NULL, NULL}
| 83942 | }; |  | 83894 | };
| 83943 |  |  | 83895 |
| 83944 | // Converter (reg_Map) |  | 83896 | // Converter (reg_Map)
| 83945 |  |  | 83897 |
| 83946 | template<> |  | 83898 | template<>
| 83947 | struct PyOpenCV_Converter< Ptr<cv::reg::Map> > |  | 83899 | struct PyOpenCV_Converter< Ptr<cv::reg::Map> >
| 83948 | { |  | 83900 | {
| 83949 | static PyObject* from(const Ptr<cv::reg::Map>& r) |  | 83901 | static PyObject* from(const Ptr<cv::reg::Map>& r)
| 83950 | { |  | 83902 | {
| 83951 | return pyopencv_reg_Map_Instance(r); |  | 83903 | return pyopencv_reg_Map_Instance(r);
| 83952 | } |  | 83904 | }
| 83953 | static bool to(PyObject* src, Ptr<cv::reg::Map>& dst, const ArgInfo& info) |  | 83905 | static bool to(PyObject* src, Ptr<cv::reg::Map>& dst, const ArgInfo& info)
| 83954 | { |  | 83906 | {
| 83955 | if(!src || src == Py_None) |  | 83907 | if(!src || src == Py_None)
| 83956 | return true; |  | 83908 | return true;
| 83957 | Ptr<cv::reg::Map> * dst_; |  | 83909 | Ptr<cv::reg::Map> * dst_;
| 83958 | if (pyopencv_reg_Map_getp(src, dst_)) |  | 83910 | if (pyopencv_reg_Map_getp(src, dst_))
| 83959 | { |  | 83911 | {
| 83960 | dst = *dst_; |  | 83912 | dst = *dst_;
| 83961 | return true; |  | 83913 | return true;
| 83962 | } |  | 83914 | }
| 83963 |  |  | 83915 |
| 83964 | failmsg("Expected Ptr<cv::reg::Map> for argument '%s'", info.name); |  | 83916 | failmsg("Expected Ptr<cv::reg::Map> for argument '%s'", info.name);
| 83965 | return false; |  | 83917 | return false;
| 83966 | } |  | 83918 | }
| 83967 | }; |  | 83919 | };
| 83968 |  |  | 83920 |
| 83969 | //================================================================================ |  | 83921 | //================================================================================
| 83970 | // reg_MapAffine (Generic) |  | 83922 | // reg_MapAffine (Generic)
| 83971 | //================================================================================ |  | 83923 | //================================================================================
| 83972 |  |  | 83924 |
| 83973 | // GetSet (reg_MapAffine) |  | 83925 | // GetSet (reg_MapAffine)
| 83974 |  |  | 83926 |
| 83975 |  |  | 83927 |
| 83976 |  |  | 83928 |
| 83977 | // Methods (reg_MapAffine) |  | 83929 | // Methods (reg_MapAffine)
| 83978 |  |  | 83930 |
| 83979 | static int pyopencv_cv_reg_reg_MapAffine_MapAffine(pyopencv_reg_MapAffine_t* self, PyObject* py_args, PyObject* kw) |  | 83931 | static int pyopencv_cv_reg_reg_MapAffine_MapAffine(pyopencv_reg_MapAffine_t* self, PyObject* py_args, PyObject* kw)
| 83980 | { |  | 83932 | {
| 83981 | using namespace cv::reg; |  | 83933 | using namespace cv::reg;
| 83982 |  |  | 83934 |
| 83983 | pyPrepareArgumentConversionErrorsStorage(3); |  | 83935 | pyPrepareArgumentConversionErrorsStorage(3);
| 83984 |  |  | 83936 |
| 83985 | { |  | 83937 | {
| 83986 |  |  | 83938 |
| 83987 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 83939 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 83988 | { |  | 83940 | {
| 83989 | new (&(self->v)) Ptr<cv::reg::MapAffine>(); // init Ptr with placement new |  | 83941 | new (&(self->v)) Ptr<cv::reg::MapAffine>(); // init Ptr with placement new
| 83990 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapAffine())); |  | 83942 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapAffine()));
| 83991 | return 0; |  | 83943 | return 0;
| 83992 | } |  | 83944 | }
| 83993 |  |  | 83945 |
| 83994 |  |  | 83946 |
| 83995 | pyPopulateArgumentConversionErrors(); |  | 83947 | pyPopulateArgumentConversionErrors();
| 83996 | } |  | 83948 | }
| 83997 |  |  | 83949 |
| 83998 |  |  | 83950 |
| 83999 | { |  | 83951 | {
| 84000 | PyObject* pyobj_linTr = NULL; |  | 83952 | PyObject* pyobj_linTr = NULL;
| 84001 | Mat linTr; |  | 83953 | Mat linTr;
| 84002 | PyObject* pyobj_shift = NULL; |  | 83954 | PyObject* pyobj_shift = NULL;
| 84003 | Mat shift; |  | 83955 | Mat shift;
| 84004 |  |  | 83956 |
| 84005 | const char* keywords[] = { "linTr", "shift", NULL }; |  | 83957 | const char* keywords[] = { "linTr", "shift", NULL };
| 84006 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:MapAffine", (char**)keywords, &pyobj_linTr, &pyobj_shift) && |  | 83958 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:MapAffine", (char**)keywords, &pyobj_linTr, &pyobj_shift) &&
| 84007 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 0)) && |  | 83959 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 0)) &&
| 84008 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) ) |  | 83960 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) )
| 84009 | { |  | 83961 | {
| 84010 | new (&(self->v)) Ptr<cv::reg::MapAffine>(); // init Ptr with placement new |  | 83962 | new (&(self->v)) Ptr<cv::reg::MapAffine>(); // init Ptr with placement new
| 84011 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapAffine(linTr, shift))); |  | 83963 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapAffine(linTr, shift)));
| 84012 | return 0; |  | 83964 | return 0;
| 84013 | } |  | 83965 | }
| 84014 |  |  | 83966 |
| 84015 |  |  | 83967 |
| 84016 | pyPopulateArgumentConversionErrors(); |  | 83968 | pyPopulateArgumentConversionErrors();
| 84017 | } |  | 83969 | }
| 84018 |  |  | 83970 |
| 84019 |  |  | 83971 |
| 84020 | { |  | 83972 | {
| 84021 | PyObject* pyobj_linTr = NULL; |  | 83973 | PyObject* pyobj_linTr = NULL;
| 84022 | UMat linTr; |  | 83974 | UMat linTr;
| 84023 | PyObject* pyobj_shift = NULL; |  | 83975 | PyObject* pyobj_shift = NULL;
| 84024 | UMat shift; |  | 83976 | UMat shift;
| 84025 |  |  | 83977 |
| 84026 | const char* keywords[] = { "linTr", "shift", NULL }; |  | 83978 | const char* keywords[] = { "linTr", "shift", NULL };
| 84027 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:MapAffine", (char**)keywords, &pyobj_linTr, &pyobj_shift) && |  | 83979 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:MapAffine", (char**)keywords, &pyobj_linTr, &pyobj_shift) &&
| 84028 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 0)) && |  | 83980 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 0)) &&
| 84029 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) ) |  | 83981 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) )
| 84030 | { |  | 83982 | {
| 84031 | new (&(self->v)) Ptr<cv::reg::MapAffine>(); // init Ptr with placement new |  | 83983 | new (&(self->v)) Ptr<cv::reg::MapAffine>(); // init Ptr with placement new
| 84032 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapAffine(linTr, shift))); |  | 83984 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapAffine(linTr, shift)));
| 84033 | return 0; |  | 83985 | return 0;
| 84034 | } |  | 83986 | }
| 84035 |  |  | 83987 |
| 84036 |  |  | 83988 |
| 84037 | pyPopulateArgumentConversionErrors(); |  | 83989 | pyPopulateArgumentConversionErrors();
| 84038 | } |  | 83990 | }
| 84039 | pyRaiseCVOverloadException("MapAffine"); |  | 83991 | pyRaiseCVOverloadException("MapAffine");
| 84040 |  |  | 83992 |
| 84041 | return -1; |  | 83993 | return -1;
| 84042 | } |  | 83994 | }
| 84043 |  |  | 83995 |
| 84044 | static PyObject* pyopencv_cv_reg_reg_MapAffine_compose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 83996 | static PyObject* pyopencv_cv_reg_reg_MapAffine_compose(PyObject* self, PyObject* py_args, PyObject* kw)
| 84045 | { |  | 83997 | {
| 84046 | using namespace cv::reg; |  | 83998 | using namespace cv::reg;
| 84047 |  |  | 83999 |
| 84048 |  |  | 84000 |
| 84049 | Ptr<cv::reg::MapAffine> * self1 = 0; |  | 84001 | Ptr<cv::reg::MapAffine> * self1 = 0;
| 84050 | if (!pyopencv_reg_MapAffine_getp(self, self1)) |  | 84002 | if (!pyopencv_reg_MapAffine_getp(self, self1))
| 84051 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)"); |  | 84003 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)");
| 84052 | Ptr<cv::reg::MapAffine> _self_ = *(self1); |  | 84004 | Ptr<cv::reg::MapAffine> _self_ = *(self1);
| 84053 | PyObject* pyobj_map = NULL; |  | 84005 | PyObject* pyobj_map = NULL;
| 84054 | Ptr<Map> map; |  | 84006 | Ptr<Map> map;
| 84055 |  |  | 84007 |
| 84056 | const char* keywords[] = { "map", NULL }; |  | 84008 | const char* keywords[] = { "map", NULL };
| 84057 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapAffine.compose", (char**)keywords, &pyobj_map) && |  | 84009 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapAffine.compose", (char**)keywords, &pyobj_map) &&
| 84058 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) ) |  | 84010 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) )
| 84059 | { |  | 84011 | {
| 84060 | ERRWRAP2(_self_->compose(map)); |  | 84012 | ERRWRAP2(_self_->compose(map));
| 84061 | Py_RETURN_NONE; |  | 84013 | Py_RETURN_NONE;
| 84062 | } |  | 84014 | }
| 84063 |  |  | 84015 |
| 84064 | return NULL; |  | 84016 | return NULL;
| 84065 | } |  | 84017 | }
| 84066 |  |  | 84018 |
| 84067 | static PyObject* pyopencv_cv_reg_reg_MapAffine_getLinTr(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84019 | static PyObject* pyopencv_cv_reg_reg_MapAffine_getLinTr(PyObject* self, PyObject* py_args, PyObject* kw)
| 84068 | { |  | 84020 | {
| 84069 | using namespace cv::reg; |  | 84021 | using namespace cv::reg;
| 84070 |  |  | 84022 |
| 84071 |  |  | 84023 |
| 84072 | Ptr<cv::reg::MapAffine> * self1 = 0; |  | 84024 | Ptr<cv::reg::MapAffine> * self1 = 0;
| 84073 | if (!pyopencv_reg_MapAffine_getp(self, self1)) |  | 84025 | if (!pyopencv_reg_MapAffine_getp(self, self1))
| 84074 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)"); |  | 84026 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)");
| 84075 | Ptr<cv::reg::MapAffine> _self_ = *(self1); |  | 84027 | Ptr<cv::reg::MapAffine> _self_ = *(self1);
| 84076 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84028 | pyPrepareArgumentConversionErrorsStorage(2);
| 84077 |  |  | 84029 |
| 84078 | { |  | 84030 | {
| 84079 | PyObject* pyobj_linTr = NULL; |  | 84031 | PyObject* pyobj_linTr = NULL;
| 84080 | Mat linTr; |  | 84032 | Mat linTr;
| 84081 |  |  | 84033 |
| 84082 | const char* keywords[] = { "linTr", NULL }; |  | 84034 | const char* keywords[] = { "linTr", NULL };
| 84083 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getLinTr", (char**)keywords, &pyobj_linTr) && |  | 84035 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getLinTr", (char**)keywords, &pyobj_linTr) &&
| 84084 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 1)) ) |  | 84036 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 1)) )
| 84085 | { |  | 84037 | {
| 84086 | ERRWRAP2(_self_->getLinTr(linTr)); |  | 84038 | ERRWRAP2(_self_->getLinTr(linTr));
| 84087 | return pyopencv_from(linTr); |  | 84039 | return pyopencv_from(linTr);
| 84088 | } |  | 84040 | }
| 84089 |  |  | 84041 |
| 84090 |  |  | 84042 |
| 84091 | pyPopulateArgumentConversionErrors(); |  | 84043 | pyPopulateArgumentConversionErrors();
| 84092 | } |  | 84044 | }
| 84093 |  |  | 84045 |
| 84094 |  |  | 84046 |
| 84095 | { |  | 84047 | {
| 84096 | PyObject* pyobj_linTr = NULL; |  | 84048 | PyObject* pyobj_linTr = NULL;
| 84097 | UMat linTr; |  | 84049 | UMat linTr;
| 84098 |  |  | 84050 |
| 84099 | const char* keywords[] = { "linTr", NULL }; |  | 84051 | const char* keywords[] = { "linTr", NULL };
| 84100 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getLinTr", (char**)keywords, &pyobj_linTr) && |  | 84052 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getLinTr", (char**)keywords, &pyobj_linTr) &&
| 84101 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 1)) ) |  | 84053 | pyopencv_to_safe(pyobj_linTr, linTr, ArgInfo("linTr", 1)) )
| 84102 | { |  | 84054 | {
| 84103 | ERRWRAP2(_self_->getLinTr(linTr)); |  | 84055 | ERRWRAP2(_self_->getLinTr(linTr));
| 84104 | return pyopencv_from(linTr); |  | 84056 | return pyopencv_from(linTr);
| 84105 | } |  | 84057 | }
| 84106 |  |  | 84058 |
| 84107 |  |  | 84059 |
| 84108 | pyPopulateArgumentConversionErrors(); |  | 84060 | pyPopulateArgumentConversionErrors();
| 84109 | } |  | 84061 | }
| 84110 | pyRaiseCVOverloadException("getLinTr"); |  | 84062 | pyRaiseCVOverloadException("getLinTr");
| 84111 |  |  | 84063 |
| 84112 | return NULL; |  | 84064 | return NULL;
| 84113 | } |  | 84065 | }
| 84114 |  |  | 84066 |
| 84115 | static PyObject* pyopencv_cv_reg_reg_MapAffine_getShift(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84067 | static PyObject* pyopencv_cv_reg_reg_MapAffine_getShift(PyObject* self, PyObject* py_args, PyObject* kw)
| 84116 | { |  | 84068 | {
| 84117 | using namespace cv::reg; |  | 84069 | using namespace cv::reg;
| 84118 |  |  | 84070 |
| 84119 |  |  | 84071 |
| 84120 | Ptr<cv::reg::MapAffine> * self1 = 0; |  | 84072 | Ptr<cv::reg::MapAffine> * self1 = 0;
| 84121 | if (!pyopencv_reg_MapAffine_getp(self, self1)) |  | 84073 | if (!pyopencv_reg_MapAffine_getp(self, self1))
| 84122 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)"); |  | 84074 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)");
| 84123 | Ptr<cv::reg::MapAffine> _self_ = *(self1); |  | 84075 | Ptr<cv::reg::MapAffine> _self_ = *(self1);
| 84124 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84076 | pyPrepareArgumentConversionErrorsStorage(2);
| 84125 |  |  | 84077 |
| 84126 | { |  | 84078 | {
| 84127 | PyObject* pyobj_shift = NULL; |  | 84079 | PyObject* pyobj_shift = NULL;
| 84128 | Mat shift; |  | 84080 | Mat shift;
| 84129 |  |  | 84081 |
| 84130 | const char* keywords[] = { "shift", NULL }; |  | 84082 | const char* keywords[] = { "shift", NULL };
| 84131 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getShift", (char**)keywords, &pyobj_shift) && |  | 84083 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getShift", (char**)keywords, &pyobj_shift) &&
| 84132 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) ) |  | 84084 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) )
| 84133 | { |  | 84085 | {
| 84134 | ERRWRAP2(_self_->getShift(shift)); |  | 84086 | ERRWRAP2(_self_->getShift(shift));
| 84135 | return pyopencv_from(shift); |  | 84087 | return pyopencv_from(shift);
| 84136 | } |  | 84088 | }
| 84137 |  |  | 84089 |
| 84138 |  |  | 84090 |
| 84139 | pyPopulateArgumentConversionErrors(); |  | 84091 | pyPopulateArgumentConversionErrors();
| 84140 | } |  | 84092 | }
| 84141 |  |  | 84093 |
| 84142 |  |  | 84094 |
| 84143 | { |  | 84095 | {
| 84144 | PyObject* pyobj_shift = NULL; |  | 84096 | PyObject* pyobj_shift = NULL;
| 84145 | UMat shift; |  | 84097 | UMat shift;
| 84146 |  |  | 84098 |
| 84147 | const char* keywords[] = { "shift", NULL }; |  | 84099 | const char* keywords[] = { "shift", NULL };
| 84148 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getShift", (char**)keywords, &pyobj_shift) && |  | 84100 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapAffine.getShift", (char**)keywords, &pyobj_shift) &&
| 84149 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) ) |  | 84101 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) )
| 84150 | { |  | 84102 | {
| 84151 | ERRWRAP2(_self_->getShift(shift)); |  | 84103 | ERRWRAP2(_self_->getShift(shift));
| 84152 | return pyopencv_from(shift); |  | 84104 | return pyopencv_from(shift);
| 84153 | } |  | 84105 | }
| 84154 |  |  | 84106 |
| 84155 |  |  | 84107 |
| 84156 | pyPopulateArgumentConversionErrors(); |  | 84108 | pyPopulateArgumentConversionErrors();
| 84157 | } |  | 84109 | }
| 84158 | pyRaiseCVOverloadException("getShift"); |  | 84110 | pyRaiseCVOverloadException("getShift");
| 84159 |  |  | 84111 |
| 84160 | return NULL; |  | 84112 | return NULL;
| 84161 | } |  | 84113 | }
| 84162 |  |  | 84114 |
| 84163 | static PyObject* pyopencv_cv_reg_reg_MapAffine_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84115 | static PyObject* pyopencv_cv_reg_reg_MapAffine_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 84164 | { |  | 84116 | {
| 84165 | using namespace cv::reg; |  | 84117 | using namespace cv::reg;
| 84166 |  |  | 84118 |
| 84167 |  |  | 84119 |
| 84168 | Ptr<cv::reg::MapAffine> * self1 = 0; |  | 84120 | Ptr<cv::reg::MapAffine> * self1 = 0;
| 84169 | if (!pyopencv_reg_MapAffine_getp(self, self1)) |  | 84121 | if (!pyopencv_reg_MapAffine_getp(self, self1))
| 84170 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)"); |  | 84122 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)");
| 84171 | Ptr<cv::reg::MapAffine> _self_ = *(self1); |  | 84123 | Ptr<cv::reg::MapAffine> _self_ = *(self1);
| 84172 | cv::Ptr<Map> retval; |  | 84124 | cv::Ptr<Map> retval;
| 84173 |  |  | 84125 |
| 84174 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 84126 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 84175 | { |  | 84127 | {
| 84176 | ERRWRAP2(retval = _self_->inverseMap()); |  | 84128 | ERRWRAP2(retval = _self_->inverseMap());
| 84177 | return pyopencv_from(retval); |  | 84129 | return pyopencv_from(retval);
| 84178 | } |  | 84130 | }
| 84179 |  |  | 84131 |
| 84180 | return NULL; |  | 84132 | return NULL;
| 84181 | } |  | 84133 | }
| 84182 |  |  | 84134 |
| 84183 | static PyObject* pyopencv_cv_reg_reg_MapAffine_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84135 | static PyObject* pyopencv_cv_reg_reg_MapAffine_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw)
| 84184 | { |  | 84136 | {
| 84185 | using namespace cv::reg; |  | 84137 | using namespace cv::reg;
| 84186 |  |  | 84138 |
| 84187 |  |  | 84139 |
| 84188 | Ptr<cv::reg::MapAffine> * self1 = 0; |  | 84140 | Ptr<cv::reg::MapAffine> * self1 = 0;
| 84189 | if (!pyopencv_reg_MapAffine_getp(self, self1)) |  | 84141 | if (!pyopencv_reg_MapAffine_getp(self, self1))
| 84190 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)"); |  | 84142 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)");
| 84191 | Ptr<cv::reg::MapAffine> _self_ = *(self1); |  | 84143 | Ptr<cv::reg::MapAffine> _self_ = *(self1);
| 84192 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84144 | pyPrepareArgumentConversionErrorsStorage(2);
| 84193 |  |  | 84145 |
| 84194 | { |  | 84146 | {
| 84195 | PyObject* pyobj_img1 = NULL; |  | 84147 | PyObject* pyobj_img1 = NULL;
| 84196 | Mat img1; |  | 84148 | Mat img1;
| 84197 | PyObject* pyobj_img2 = NULL; |  | 84149 | PyObject* pyobj_img2 = NULL;
| 84198 | Mat img2; |  | 84150 | Mat img2;
| 84199 |  |  | 84151 |
| 84200 | const char* keywords[] = { "img1", "img2", NULL }; |  | 84152 | const char* keywords[] = { "img1", "img2", NULL };
| 84201 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapAffine.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 84153 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapAffine.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 84202 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 84154 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 84203 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 84155 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 84204 | { |  | 84156 | {
| 84205 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 84157 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 84206 | return pyopencv_from(img2); |  | 84158 | return pyopencv_from(img2);
| 84207 | } |  | 84159 | }
| 84208 |  |  | 84160 |
| 84209 |  |  | 84161 |
| 84210 | pyPopulateArgumentConversionErrors(); |  | 84162 | pyPopulateArgumentConversionErrors();
| 84211 | } |  | 84163 | }
| 84212 |  |  | 84164 |
| 84213 |  |  | 84165 |
| 84214 | { |  | 84166 | {
| 84215 | PyObject* pyobj_img1 = NULL; |  | 84167 | PyObject* pyobj_img1 = NULL;
| 84216 | UMat img1; |  | 84168 | UMat img1;
| 84217 | PyObject* pyobj_img2 = NULL; |  | 84169 | PyObject* pyobj_img2 = NULL;
| 84218 | UMat img2; |  | 84170 | UMat img2;
| 84219 |  |  | 84171 |
| 84220 | const char* keywords[] = { "img1", "img2", NULL }; |  | 84172 | const char* keywords[] = { "img1", "img2", NULL };
| 84221 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapAffine.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 84173 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapAffine.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 84222 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 84174 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 84223 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 84175 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 84224 | { |  | 84176 | {
| 84225 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 84177 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 84226 | return pyopencv_from(img2); |  | 84178 | return pyopencv_from(img2);
| 84227 | } |  | 84179 | }
| 84228 |  |  | 84180 |
| 84229 |  |  | 84181 |
| 84230 | pyPopulateArgumentConversionErrors(); |  | 84182 | pyPopulateArgumentConversionErrors();
| 84231 | } |  | 84183 | }
| 84232 | pyRaiseCVOverloadException("inverseWarp"); |  | 84184 | pyRaiseCVOverloadException("inverseWarp");
| 84233 |  |  | 84185 |
| 84234 | return NULL; |  | 84186 | return NULL;
| 84235 | } |  | 84187 | }
| 84236 |  |  | 84188 |
| 84237 | static PyObject* pyopencv_cv_reg_reg_MapAffine_scale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84189 | static PyObject* pyopencv_cv_reg_reg_MapAffine_scale(PyObject* self, PyObject* py_args, PyObject* kw)
| 84238 | { |  | 84190 | {
| 84239 | using namespace cv::reg; |  | 84191 | using namespace cv::reg;
| 84240 |  |  | 84192 |
| 84241 |  |  | 84193 |
| 84242 | Ptr<cv::reg::MapAffine> * self1 = 0; |  | 84194 | Ptr<cv::reg::MapAffine> * self1 = 0;
| 84243 | if (!pyopencv_reg_MapAffine_getp(self, self1)) |  | 84195 | if (!pyopencv_reg_MapAffine_getp(self, self1))
| 84244 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)"); |  | 84196 | return failmsgp("Incorrect type of self (must be 'reg_MapAffine' or its derivative)");
| 84245 | Ptr<cv::reg::MapAffine> _self_ = *(self1); |  | 84197 | Ptr<cv::reg::MapAffine> _self_ = *(self1);
| 84246 | PyObject* pyobj_factor = NULL; |  | 84198 | PyObject* pyobj_factor = NULL;
| 84247 | double factor=0; |  | 84199 | double factor=0;
| 84248 |  |  | 84200 |
| 84249 | const char* keywords[] = { "factor", NULL }; |  | 84201 | const char* keywords[] = { "factor", NULL };
| 84250 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapAffine.scale", (char**)keywords, &pyobj_factor) && |  | 84202 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapAffine.scale", (char**)keywords, &pyobj_factor) &&
| 84251 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) ) |  | 84203 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) )
| 84252 | { |  | 84204 | {
| 84253 | ERRWRAP2(_self_->scale(factor)); |  | 84205 | ERRWRAP2(_self_->scale(factor));
| 84254 | Py_RETURN_NONE; |  | 84206 | Py_RETURN_NONE;
| 84255 | } |  | 84207 | }
| 84256 |  |  | 84208 |
| 84257 | return NULL; |  | 84209 | return NULL;
| 84258 | } |  | 84210 | }
| 84259 |  |  | 84211 |
| 84260 |  |  | 84212 |
| 84261 |  |  | 84213 |
| 84262 | // Tables (reg_MapAffine) |  | 84214 | // Tables (reg_MapAffine)
| 84263 |  |  | 84215 |
| 84264 | static PyGetSetDef pyopencv_reg_MapAffine_getseters[] = |  | 84216 | static PyGetSetDef pyopencv_reg_MapAffine_getseters[] =
| 84265 | { |  | 84217 | {
| 84266 | {NULL} /* Sentinel */ |  | 84218 | {NULL} /* Sentinel */
| 84267 | }; |  | 84219 | };
| 84268 |  |  | 84220 |
| 84269 | static PyMethodDef pyopencv_reg_MapAffine_methods[] = |  | 84221 | static PyMethodDef pyopencv_reg_MapAffine_methods[] =
| 84270 | { |  | 84222 | {
| 84271 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_compose, 0), "compose(map) -> None\n."}, |  | 84223 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_compose, 0), "compose(map) -> None\n."},
| 84272 | {"getLinTr", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_getLinTr, 0), "getLinTr([, linTr]) -> linTr\n."}, |  | 84224 | {"getLinTr", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_getLinTr, 0), "getLinTr([, linTr]) -> linTr\n."},
| 84273 | {"getShift", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_getShift, 0), "getShift([, shift]) -> shift\n."}, |  | 84225 | {"getShift", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_getShift, 0), "getShift([, shift]) -> shift\n."},
| 84274 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_inverseMap, 0), "inverseMap() -> retval\n."}, |  | 84226 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_inverseMap, 0), "inverseMap() -> retval\n."},
| 84275 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."}, |  | 84227 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."},
| 84276 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_scale, 0), "scale(factor) -> None\n."}, |  | 84228 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapAffine_scale, 0), "scale(factor) -> None\n."},
| 84277 |  |  | 84229 |
| 84278 | {NULL, NULL} |  | 84230 | {NULL, NULL}
| 84279 | }; |  | 84231 | };
| 84280 |  |  | 84232 |
| 84281 | // Converter (reg_MapAffine) |  | 84233 | // Converter (reg_MapAffine)
| 84282 |  |  | 84234 |
| 84283 | template<> |  | 84235 | template<>
| 84284 | struct PyOpenCV_Converter< Ptr<cv::reg::MapAffine> > |  | 84236 | struct PyOpenCV_Converter< Ptr<cv::reg::MapAffine> >
| 84285 | { |  | 84237 | {
| 84286 | static PyObject* from(const Ptr<cv::reg::MapAffine>& r) |  | 84238 | static PyObject* from(const Ptr<cv::reg::MapAffine>& r)
| 84287 | { |  | 84239 | {
| 84288 | return pyopencv_reg_MapAffine_Instance(r); |  | 84240 | return pyopencv_reg_MapAffine_Instance(r);
| 84289 | } |  | 84241 | }
| 84290 | static bool to(PyObject* src, Ptr<cv::reg::MapAffine>& dst, const ArgInfo& info) |  | 84242 | static bool to(PyObject* src, Ptr<cv::reg::MapAffine>& dst, const ArgInfo& info)
| 84291 | { |  | 84243 | {
| 84292 | if(!src || src == Py_None) |  | 84244 | if(!src || src == Py_None)
| 84293 | return true; |  | 84245 | return true;
| 84294 | Ptr<cv::reg::MapAffine> * dst_; |  | 84246 | Ptr<cv::reg::MapAffine> * dst_;
| 84295 | if (pyopencv_reg_MapAffine_getp(src, dst_)) |  | 84247 | if (pyopencv_reg_MapAffine_getp(src, dst_))
| 84296 | { |  | 84248 | {
| 84297 | dst = *dst_; |  | 84249 | dst = *dst_;
| 84298 | return true; |  | 84250 | return true;
| 84299 | } |  | 84251 | }
| 84300 |  |  | 84252 |
| 84301 | failmsg("Expected Ptr<cv::reg::MapAffine> for argument '%s'", info.name); |  | 84253 | failmsg("Expected Ptr<cv::reg::MapAffine> for argument '%s'", info.name);
| 84302 | return false; |  | 84254 | return false;
| 84303 | } |  | 84255 | }
| 84304 | }; |  | 84256 | };
| 84305 |  |  | 84257 |
| 84306 | //================================================================================ |  | 84258 | //================================================================================
| 84307 | // reg_MapProjec (Generic) |  | 84259 | // reg_MapProjec (Generic)
| 84308 | //================================================================================ |  | 84260 | //================================================================================
| 84309 |  |  | 84261 |
| 84310 | // GetSet (reg_MapProjec) |  | 84262 | // GetSet (reg_MapProjec)
| 84311 |  |  | 84263 |
| 84312 |  |  | 84264 |
| 84313 |  |  | 84265 |
| 84314 | // Methods (reg_MapProjec) |  | 84266 | // Methods (reg_MapProjec)
| 84315 |  |  | 84267 |
| 84316 | static int pyopencv_cv_reg_reg_MapProjec_MapProjec(pyopencv_reg_MapProjec_t* self, PyObject* py_args, PyObject* kw) |  | 84268 | static int pyopencv_cv_reg_reg_MapProjec_MapProjec(pyopencv_reg_MapProjec_t* self, PyObject* py_args, PyObject* kw)
| 84317 | { |  | 84269 | {
| 84318 | using namespace cv::reg; |  | 84270 | using namespace cv::reg;
| 84319 |  |  | 84271 |
| 84320 | pyPrepareArgumentConversionErrorsStorage(3); |  | 84272 | pyPrepareArgumentConversionErrorsStorage(3);
| 84321 |  |  | 84273 |
| 84322 | { |  | 84274 | {
| 84323 |  |  | 84275 |
| 84324 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 84276 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 84325 | { |  | 84277 | {
| 84326 | new (&(self->v)) Ptr<cv::reg::MapProjec>(); // init Ptr with placement new |  | 84278 | new (&(self->v)) Ptr<cv::reg::MapProjec>(); // init Ptr with placement new
| 84327 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapProjec())); |  | 84279 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapProjec()));
| 84328 | return 0; |  | 84280 | return 0;
| 84329 | } |  | 84281 | }
| 84330 |  |  | 84282 |
| 84331 |  |  | 84283 |
| 84332 | pyPopulateArgumentConversionErrors(); |  | 84284 | pyPopulateArgumentConversionErrors();
| 84333 | } |  | 84285 | }
| 84334 |  |  | 84286 |
| 84335 |  |  | 84287 |
| 84336 | { |  | 84288 | {
| 84337 | PyObject* pyobj_projTr = NULL; |  | 84289 | PyObject* pyobj_projTr = NULL;
| 84338 | Mat projTr; |  | 84290 | Mat projTr;
| 84339 |  |  | 84291 |
| 84340 | const char* keywords[] = { "projTr", NULL }; |  | 84292 | const char* keywords[] = { "projTr", NULL };
| 84341 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapProjec", (char**)keywords, &pyobj_projTr) && |  | 84293 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapProjec", (char**)keywords, &pyobj_projTr) &&
| 84342 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 0)) ) |  | 84294 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 0)) )
| 84343 | { |  | 84295 | {
| 84344 | new (&(self->v)) Ptr<cv::reg::MapProjec>(); // init Ptr with placement new |  | 84296 | new (&(self->v)) Ptr<cv::reg::MapProjec>(); // init Ptr with placement new
| 84345 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapProjec(projTr))); |  | 84297 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapProjec(projTr)));
| 84346 | return 0; |  | 84298 | return 0;
| 84347 | } |  | 84299 | }
| 84348 |  |  | 84300 |
| 84349 |  |  | 84301 |
| 84350 | pyPopulateArgumentConversionErrors(); |  | 84302 | pyPopulateArgumentConversionErrors();
| 84351 | } |  | 84303 | }
| 84352 |  |  | 84304 |
| 84353 |  |  | 84305 |
| 84354 | { |  | 84306 | {
| 84355 | PyObject* pyobj_projTr = NULL; |  | 84307 | PyObject* pyobj_projTr = NULL;
| 84356 | UMat projTr; |  | 84308 | UMat projTr;
| 84357 |  |  | 84309 |
| 84358 | const char* keywords[] = { "projTr", NULL }; |  | 84310 | const char* keywords[] = { "projTr", NULL };
| 84359 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapProjec", (char**)keywords, &pyobj_projTr) && |  | 84311 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapProjec", (char**)keywords, &pyobj_projTr) &&
| 84360 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 0)) ) |  | 84312 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 0)) )
| 84361 | { |  | 84313 | {
| 84362 | new (&(self->v)) Ptr<cv::reg::MapProjec>(); // init Ptr with placement new |  | 84314 | new (&(self->v)) Ptr<cv::reg::MapProjec>(); // init Ptr with placement new
| 84363 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapProjec(projTr))); |  | 84315 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapProjec(projTr)));
| 84364 | return 0; |  | 84316 | return 0;
| 84365 | } |  | 84317 | }
| 84366 |  |  | 84318 |
| 84367 |  |  | 84319 |
| 84368 | pyPopulateArgumentConversionErrors(); |  | 84320 | pyPopulateArgumentConversionErrors();
| 84369 | } |  | 84321 | }
| 84370 | pyRaiseCVOverloadException("MapProjec"); |  | 84322 | pyRaiseCVOverloadException("MapProjec");
| 84371 |  |  | 84323 |
| 84372 | return -1; |  | 84324 | return -1;
| 84373 | } |  | 84325 | }
| 84374 |  |  | 84326 |
| 84375 | static PyObject* pyopencv_cv_reg_reg_MapProjec_compose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84327 | static PyObject* pyopencv_cv_reg_reg_MapProjec_compose(PyObject* self, PyObject* py_args, PyObject* kw)
| 84376 | { |  | 84328 | {
| 84377 | using namespace cv::reg; |  | 84329 | using namespace cv::reg;
| 84378 |  |  | 84330 |
| 84379 |  |  | 84331 |
| 84380 | Ptr<cv::reg::MapProjec> * self1 = 0; |  | 84332 | Ptr<cv::reg::MapProjec> * self1 = 0;
| 84381 | if (!pyopencv_reg_MapProjec_getp(self, self1)) |  | 84333 | if (!pyopencv_reg_MapProjec_getp(self, self1))
| 84382 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)"); |  | 84334 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)");
| 84383 | Ptr<cv::reg::MapProjec> _self_ = *(self1); |  | 84335 | Ptr<cv::reg::MapProjec> _self_ = *(self1);
| 84384 | PyObject* pyobj_map = NULL; |  | 84336 | PyObject* pyobj_map = NULL;
| 84385 | Ptr<Map> map; |  | 84337 | Ptr<Map> map;
| 84386 |  |  | 84338 |
| 84387 | const char* keywords[] = { "map", NULL }; |  | 84339 | const char* keywords[] = { "map", NULL };
| 84388 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapProjec.compose", (char**)keywords, &pyobj_map) && |  | 84340 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapProjec.compose", (char**)keywords, &pyobj_map) &&
| 84389 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) ) |  | 84341 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) )
| 84390 | { |  | 84342 | {
| 84391 | ERRWRAP2(_self_->compose(map)); |  | 84343 | ERRWRAP2(_self_->compose(map));
| 84392 | Py_RETURN_NONE; |  | 84344 | Py_RETURN_NONE;
| 84393 | } |  | 84345 | }
| 84394 |  |  | 84346 |
| 84395 | return NULL; |  | 84347 | return NULL;
| 84396 | } |  | 84348 | }
| 84397 |  |  | 84349 |
| 84398 | static PyObject* pyopencv_cv_reg_reg_MapProjec_getProjTr(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84350 | static PyObject* pyopencv_cv_reg_reg_MapProjec_getProjTr(PyObject* self, PyObject* py_args, PyObject* kw)
| 84399 | { |  | 84351 | {
| 84400 | using namespace cv::reg; |  | 84352 | using namespace cv::reg;
| 84401 |  |  | 84353 |
| 84402 |  |  | 84354 |
| 84403 | Ptr<cv::reg::MapProjec> * self1 = 0; |  | 84355 | Ptr<cv::reg::MapProjec> * self1 = 0;
| 84404 | if (!pyopencv_reg_MapProjec_getp(self, self1)) |  | 84356 | if (!pyopencv_reg_MapProjec_getp(self, self1))
| 84405 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)"); |  | 84357 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)");
| 84406 | Ptr<cv::reg::MapProjec> _self_ = *(self1); |  | 84358 | Ptr<cv::reg::MapProjec> _self_ = *(self1);
| 84407 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84359 | pyPrepareArgumentConversionErrorsStorage(2);
| 84408 |  |  | 84360 |
| 84409 | { |  | 84361 | {
| 84410 | PyObject* pyobj_projTr = NULL; |  | 84362 | PyObject* pyobj_projTr = NULL;
| 84411 | Mat projTr; |  | 84363 | Mat projTr;
| 84412 |  |  | 84364 |
| 84413 | const char* keywords[] = { "projTr", NULL }; |  | 84365 | const char* keywords[] = { "projTr", NULL };
| 84414 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapProjec.getProjTr", (char**)keywords, &pyobj_projTr) && |  | 84366 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapProjec.getProjTr", (char**)keywords, &pyobj_projTr) &&
| 84415 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 1)) ) |  | 84367 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 1)) )
| 84416 | { |  | 84368 | {
| 84417 | ERRWRAP2(_self_->getProjTr(projTr)); |  | 84369 | ERRWRAP2(_self_->getProjTr(projTr));
| 84418 | return pyopencv_from(projTr); |  | 84370 | return pyopencv_from(projTr);
| 84419 | } |  | 84371 | }
| 84420 |  |  | 84372 |
| 84421 |  |  | 84373 |
| 84422 | pyPopulateArgumentConversionErrors(); |  | 84374 | pyPopulateArgumentConversionErrors();
| 84423 | } |  | 84375 | }
| 84424 |  |  | 84376 |
| 84425 |  |  | 84377 |
| 84426 | { |  | 84378 | {
| 84427 | PyObject* pyobj_projTr = NULL; |  | 84379 | PyObject* pyobj_projTr = NULL;
| 84428 | UMat projTr; |  | 84380 | UMat projTr;
| 84429 |  |  | 84381 |
| 84430 | const char* keywords[] = { "projTr", NULL }; |  | 84382 | const char* keywords[] = { "projTr", NULL };
| 84431 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapProjec.getProjTr", (char**)keywords, &pyobj_projTr) && |  | 84383 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapProjec.getProjTr", (char**)keywords, &pyobj_projTr) &&
| 84432 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 1)) ) |  | 84384 | pyopencv_to_safe(pyobj_projTr, projTr, ArgInfo("projTr", 1)) )
| 84433 | { |  | 84385 | {
| 84434 | ERRWRAP2(_self_->getProjTr(projTr)); |  | 84386 | ERRWRAP2(_self_->getProjTr(projTr));
| 84435 | return pyopencv_from(projTr); |  | 84387 | return pyopencv_from(projTr);
| 84436 | } |  | 84388 | }
| 84437 |  |  | 84389 |
| 84438 |  |  | 84390 |
| 84439 | pyPopulateArgumentConversionErrors(); |  | 84391 | pyPopulateArgumentConversionErrors();
| 84440 | } |  | 84392 | }
| 84441 | pyRaiseCVOverloadException("getProjTr"); |  | 84393 | pyRaiseCVOverloadException("getProjTr");
| 84442 |  |  | 84394 |
| 84443 | return NULL; |  | 84395 | return NULL;
| 84444 | } |  | 84396 | }
| 84445 |  |  | 84397 |
| 84446 | static PyObject* pyopencv_cv_reg_reg_MapProjec_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84398 | static PyObject* pyopencv_cv_reg_reg_MapProjec_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 84447 | { |  | 84399 | {
| 84448 | using namespace cv::reg; |  | 84400 | using namespace cv::reg;
| 84449 |  |  | 84401 |
| 84450 |  |  | 84402 |
| 84451 | Ptr<cv::reg::MapProjec> * self1 = 0; |  | 84403 | Ptr<cv::reg::MapProjec> * self1 = 0;
| 84452 | if (!pyopencv_reg_MapProjec_getp(self, self1)) |  | 84404 | if (!pyopencv_reg_MapProjec_getp(self, self1))
| 84453 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)"); |  | 84405 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)");
| 84454 | Ptr<cv::reg::MapProjec> _self_ = *(self1); |  | 84406 | Ptr<cv::reg::MapProjec> _self_ = *(self1);
| 84455 | cv::Ptr<Map> retval; |  | 84407 | cv::Ptr<Map> retval;
| 84456 |  |  | 84408 |
| 84457 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 84409 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 84458 | { |  | 84410 | {
| 84459 | ERRWRAP2(retval = _self_->inverseMap()); |  | 84411 | ERRWRAP2(retval = _self_->inverseMap());
| 84460 | return pyopencv_from(retval); |  | 84412 | return pyopencv_from(retval);
| 84461 | } |  | 84413 | }
| 84462 |  |  | 84414 |
| 84463 | return NULL; |  | 84415 | return NULL;
| 84464 | } |  | 84416 | }
| 84465 |  |  | 84417 |
| 84466 | static PyObject* pyopencv_cv_reg_reg_MapProjec_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84418 | static PyObject* pyopencv_cv_reg_reg_MapProjec_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw)
| 84467 | { |  | 84419 | {
| 84468 | using namespace cv::reg; |  | 84420 | using namespace cv::reg;
| 84469 |  |  | 84421 |
| 84470 |  |  | 84422 |
| 84471 | Ptr<cv::reg::MapProjec> * self1 = 0; |  | 84423 | Ptr<cv::reg::MapProjec> * self1 = 0;
| 84472 | if (!pyopencv_reg_MapProjec_getp(self, self1)) |  | 84424 | if (!pyopencv_reg_MapProjec_getp(self, self1))
| 84473 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)"); |  | 84425 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)");
| 84474 | Ptr<cv::reg::MapProjec> _self_ = *(self1); |  | 84426 | Ptr<cv::reg::MapProjec> _self_ = *(self1);
| 84475 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84427 | pyPrepareArgumentConversionErrorsStorage(2);
| 84476 |  |  | 84428 |
| 84477 | { |  | 84429 | {
| 84478 | PyObject* pyobj_img1 = NULL; |  | 84430 | PyObject* pyobj_img1 = NULL;
| 84479 | Mat img1; |  | 84431 | Mat img1;
| 84480 | PyObject* pyobj_img2 = NULL; |  | 84432 | PyObject* pyobj_img2 = NULL;
| 84481 | Mat img2; |  | 84433 | Mat img2;
| 84482 |  |  | 84434 |
| 84483 | const char* keywords[] = { "img1", "img2", NULL }; |  | 84435 | const char* keywords[] = { "img1", "img2", NULL };
| 84484 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapProjec.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 84436 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapProjec.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 84485 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 84437 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 84486 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 84438 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 84487 | { |  | 84439 | {
| 84488 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 84440 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 84489 | return pyopencv_from(img2); |  | 84441 | return pyopencv_from(img2);
| 84490 | } |  | 84442 | }
| 84491 |  |  | 84443 |
| 84492 |  |  | 84444 |
| 84493 | pyPopulateArgumentConversionErrors(); |  | 84445 | pyPopulateArgumentConversionErrors();
| 84494 | } |  | 84446 | }
| 84495 |  |  | 84447 |
| 84496 |  |  | 84448 |
| 84497 | { |  | 84449 | {
| 84498 | PyObject* pyobj_img1 = NULL; |  | 84450 | PyObject* pyobj_img1 = NULL;
| 84499 | UMat img1; |  | 84451 | UMat img1;
| 84500 | PyObject* pyobj_img2 = NULL; |  | 84452 | PyObject* pyobj_img2 = NULL;
| 84501 | UMat img2; |  | 84453 | UMat img2;
| 84502 |  |  | 84454 |
| 84503 | const char* keywords[] = { "img1", "img2", NULL }; |  | 84455 | const char* keywords[] = { "img1", "img2", NULL };
| 84504 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapProjec.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 84456 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapProjec.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 84505 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 84457 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 84506 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 84458 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 84507 | { |  | 84459 | {
| 84508 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 84460 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 84509 | return pyopencv_from(img2); |  | 84461 | return pyopencv_from(img2);
| 84510 | } |  | 84462 | }
| 84511 |  |  | 84463 |
| 84512 |  |  | 84464 |
| 84513 | pyPopulateArgumentConversionErrors(); |  | 84465 | pyPopulateArgumentConversionErrors();
| 84514 | } |  | 84466 | }
| 84515 | pyRaiseCVOverloadException("inverseWarp"); |  | 84467 | pyRaiseCVOverloadException("inverseWarp");
| 84516 |  |  | 84468 |
| 84517 | return NULL; |  | 84469 | return NULL;
| 84518 | } |  | 84470 | }
| 84519 |  |  | 84471 |
| 84520 | static PyObject* pyopencv_cv_reg_reg_MapProjec_normalize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84472 | static PyObject* pyopencv_cv_reg_reg_MapProjec_normalize(PyObject* self, PyObject* py_args, PyObject* kw)
| 84521 | { |  | 84473 | {
| 84522 | using namespace cv::reg; |  | 84474 | using namespace cv::reg;
| 84523 |  |  | 84475 |
| 84524 |  |  | 84476 |
| 84525 | Ptr<cv::reg::MapProjec> * self1 = 0; |  | 84477 | Ptr<cv::reg::MapProjec> * self1 = 0;
| 84526 | if (!pyopencv_reg_MapProjec_getp(self, self1)) |  | 84478 | if (!pyopencv_reg_MapProjec_getp(self, self1))
| 84527 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)"); |  | 84479 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)");
| 84528 | Ptr<cv::reg::MapProjec> _self_ = *(self1); |  | 84480 | Ptr<cv::reg::MapProjec> _self_ = *(self1);
| 84529 |  |  | 84481 |
| 84530 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 84482 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 84531 | { |  | 84483 | {
| 84532 | ERRWRAP2(_self_->normalize()); |  | 84484 | ERRWRAP2(_self_->normalize());
| 84533 | Py_RETURN_NONE; |  | 84485 | Py_RETURN_NONE;
| 84534 | } |  | 84486 | }
| 84535 |  |  | 84487 |
| 84536 | return NULL; |  | 84488 | return NULL;
| 84537 | } |  | 84489 | }
| 84538 |  |  | 84490 |
| 84539 | static PyObject* pyopencv_cv_reg_reg_MapProjec_scale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84491 | static PyObject* pyopencv_cv_reg_reg_MapProjec_scale(PyObject* self, PyObject* py_args, PyObject* kw)
| 84540 | { |  | 84492 | {
| 84541 | using namespace cv::reg; |  | 84493 | using namespace cv::reg;
| 84542 |  |  | 84494 |
| 84543 |  |  | 84495 |
| 84544 | Ptr<cv::reg::MapProjec> * self1 = 0; |  | 84496 | Ptr<cv::reg::MapProjec> * self1 = 0;
| 84545 | if (!pyopencv_reg_MapProjec_getp(self, self1)) |  | 84497 | if (!pyopencv_reg_MapProjec_getp(self, self1))
| 84546 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)"); |  | 84498 | return failmsgp("Incorrect type of self (must be 'reg_MapProjec' or its derivative)");
| 84547 | Ptr<cv::reg::MapProjec> _self_ = *(self1); |  | 84499 | Ptr<cv::reg::MapProjec> _self_ = *(self1);
| 84548 | PyObject* pyobj_factor = NULL; |  | 84500 | PyObject* pyobj_factor = NULL;
| 84549 | double factor=0; |  | 84501 | double factor=0;
| 84550 |  |  | 84502 |
| 84551 | const char* keywords[] = { "factor", NULL }; |  | 84503 | const char* keywords[] = { "factor", NULL };
| 84552 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapProjec.scale", (char**)keywords, &pyobj_factor) && |  | 84504 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapProjec.scale", (char**)keywords, &pyobj_factor) &&
| 84553 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) ) |  | 84505 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) )
| 84554 | { |  | 84506 | {
| 84555 | ERRWRAP2(_self_->scale(factor)); |  | 84507 | ERRWRAP2(_self_->scale(factor));
| 84556 | Py_RETURN_NONE; |  | 84508 | Py_RETURN_NONE;
| 84557 | } |  | 84509 | }
| 84558 |  |  | 84510 |
| 84559 | return NULL; |  | 84511 | return NULL;
| 84560 | } |  | 84512 | }
| 84561 |  |  | 84513 |
| 84562 |  |  | 84514 |
| 84563 |  |  | 84515 |
| 84564 | // Tables (reg_MapProjec) |  | 84516 | // Tables (reg_MapProjec)
| 84565 |  |  | 84517 |
| 84566 | static PyGetSetDef pyopencv_reg_MapProjec_getseters[] = |  | 84518 | static PyGetSetDef pyopencv_reg_MapProjec_getseters[] =
| 84567 | { |  | 84519 | {
| 84568 | {NULL} /* Sentinel */ |  | 84520 | {NULL} /* Sentinel */
| 84569 | }; |  | 84521 | };
| 84570 |  |  | 84522 |
| 84571 | static PyMethodDef pyopencv_reg_MapProjec_methods[] = |  | 84523 | static PyMethodDef pyopencv_reg_MapProjec_methods[] =
| 84572 | { |  | 84524 | {
| 84573 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_compose, 0), "compose(map) -> None\n."}, |  | 84525 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_compose, 0), "compose(map) -> None\n."},
| 84574 | {"getProjTr", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_getProjTr, 0), "getProjTr([, projTr]) -> projTr\n."}, |  | 84526 | {"getProjTr", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_getProjTr, 0), "getProjTr([, projTr]) -> projTr\n."},
| 84575 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_inverseMap, 0), "inverseMap() -> retval\n."}, |  | 84527 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_inverseMap, 0), "inverseMap() -> retval\n."},
| 84576 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."}, |  | 84528 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."},
| 84577 | {"normalize", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_normalize, 0), "normalize() -> None\n."}, |  | 84529 | {"normalize", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_normalize, 0), "normalize() -> None\n."},
| 84578 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_scale, 0), "scale(factor) -> None\n."}, |  | 84530 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapProjec_scale, 0), "scale(factor) -> None\n."},
| 84579 |  |  | 84531 |
| 84580 | {NULL, NULL} |  | 84532 | {NULL, NULL}
| 84581 | }; |  | 84533 | };
| 84582 |  |  | 84534 |
| 84583 | // Converter (reg_MapProjec) |  | 84535 | // Converter (reg_MapProjec)
| 84584 |  |  | 84536 |
| 84585 | template<> |  | 84537 | template<>
| 84586 | struct PyOpenCV_Converter< Ptr<cv::reg::MapProjec> > |  | 84538 | struct PyOpenCV_Converter< Ptr<cv::reg::MapProjec> >
| 84587 | { |  | 84539 | {
| 84588 | static PyObject* from(const Ptr<cv::reg::MapProjec>& r) |  | 84540 | static PyObject* from(const Ptr<cv::reg::MapProjec>& r)
| 84589 | { |  | 84541 | {
| 84590 | return pyopencv_reg_MapProjec_Instance(r); |  | 84542 | return pyopencv_reg_MapProjec_Instance(r);
| 84591 | } |  | 84543 | }
| 84592 | static bool to(PyObject* src, Ptr<cv::reg::MapProjec>& dst, const ArgInfo& info) |  | 84544 | static bool to(PyObject* src, Ptr<cv::reg::MapProjec>& dst, const ArgInfo& info)
| 84593 | { |  | 84545 | {
| 84594 | if(!src || src == Py_None) |  | 84546 | if(!src || src == Py_None)
| 84595 | return true; |  | 84547 | return true;
| 84596 | Ptr<cv::reg::MapProjec> * dst_; |  | 84548 | Ptr<cv::reg::MapProjec> * dst_;
| 84597 | if (pyopencv_reg_MapProjec_getp(src, dst_)) |  | 84549 | if (pyopencv_reg_MapProjec_getp(src, dst_))
| 84598 | { |  | 84550 | {
| 84599 | dst = *dst_; |  | 84551 | dst = *dst_;
| 84600 | return true; |  | 84552 | return true;
| 84601 | } |  | 84553 | }
| 84602 |  |  | 84554 |
| 84603 | failmsg("Expected Ptr<cv::reg::MapProjec> for argument '%s'", info.name); |  | 84555 | failmsg("Expected Ptr<cv::reg::MapProjec> for argument '%s'", info.name);
| 84604 | return false; |  | 84556 | return false;
| 84605 | } |  | 84557 | }
| 84606 | }; |  | 84558 | };
| 84607 |  |  | 84559 |
| 84608 | //================================================================================ |  | 84560 | //================================================================================
| 84609 | // reg_MapShift (Generic) |  | 84561 | // reg_MapShift (Generic)
| 84610 | //================================================================================ |  | 84562 | //================================================================================
| 84611 |  |  | 84563 |
| 84612 | // GetSet (reg_MapShift) |  | 84564 | // GetSet (reg_MapShift)
| 84613 |  |  | 84565 |
| 84614 |  |  | 84566 |
| 84615 |  |  | 84567 |
| 84616 | // Methods (reg_MapShift) |  | 84568 | // Methods (reg_MapShift)
| 84617 |  |  | 84569 |
| 84618 | static int pyopencv_cv_reg_reg_MapShift_MapShift(pyopencv_reg_MapShift_t* self, PyObject* py_args, PyObject* kw) |  | 84570 | static int pyopencv_cv_reg_reg_MapShift_MapShift(pyopencv_reg_MapShift_t* self, PyObject* py_args, PyObject* kw)
| 84619 | { |  | 84571 | {
| 84620 | using namespace cv::reg; |  | 84572 | using namespace cv::reg;
| 84621 |  |  | 84573 |
| 84622 | pyPrepareArgumentConversionErrorsStorage(3); |  | 84574 | pyPrepareArgumentConversionErrorsStorage(3);
| 84623 |  |  | 84575 |
| 84624 | { |  | 84576 | {
| 84625 |  |  | 84577 |
| 84626 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 84578 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 84627 | { |  | 84579 | {
| 84628 | new (&(self->v)) Ptr<cv::reg::MapShift>(); // init Ptr with placement new |  | 84580 | new (&(self->v)) Ptr<cv::reg::MapShift>(); // init Ptr with placement new
| 84629 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapShift())); |  | 84581 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapShift()));
| 84630 | return 0; |  | 84582 | return 0;
| 84631 | } |  | 84583 | }
| 84632 |  |  | 84584 |
| 84633 |  |  | 84585 |
| 84634 | pyPopulateArgumentConversionErrors(); |  | 84586 | pyPopulateArgumentConversionErrors();
| 84635 | } |  | 84587 | }
| 84636 |  |  | 84588 |
| 84637 |  |  | 84589 |
| 84638 | { |  | 84590 | {
| 84639 | PyObject* pyobj_shift = NULL; |  | 84591 | PyObject* pyobj_shift = NULL;
| 84640 | Mat shift; |  | 84592 | Mat shift;
| 84641 |  |  | 84593 |
| 84642 | const char* keywords[] = { "shift", NULL }; |  | 84594 | const char* keywords[] = { "shift", NULL };
| 84643 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapShift", (char**)keywords, &pyobj_shift) && |  | 84595 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapShift", (char**)keywords, &pyobj_shift) &&
| 84644 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) ) |  | 84596 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) )
| 84645 | { |  | 84597 | {
| 84646 | new (&(self->v)) Ptr<cv::reg::MapShift>(); // init Ptr with placement new |  | 84598 | new (&(self->v)) Ptr<cv::reg::MapShift>(); // init Ptr with placement new
| 84647 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapShift(shift))); |  | 84599 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapShift(shift)));
| 84648 | return 0; |  | 84600 | return 0;
| 84649 | } |  | 84601 | }
| 84650 |  |  | 84602 |
| 84651 |  |  | 84603 |
| 84652 | pyPopulateArgumentConversionErrors(); |  | 84604 | pyPopulateArgumentConversionErrors();
| 84653 | } |  | 84605 | }
| 84654 |  |  | 84606 |
| 84655 |  |  | 84607 |
| 84656 | { |  | 84608 | {
| 84657 | PyObject* pyobj_shift = NULL; |  | 84609 | PyObject* pyobj_shift = NULL;
| 84658 | UMat shift; |  | 84610 | UMat shift;
| 84659 |  |  | 84611 |
| 84660 | const char* keywords[] = { "shift", NULL }; |  | 84612 | const char* keywords[] = { "shift", NULL };
| 84661 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapShift", (char**)keywords, &pyobj_shift) && |  | 84613 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapShift", (char**)keywords, &pyobj_shift) &&
| 84662 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) ) |  | 84614 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 0)) )
| 84663 | { |  | 84615 | {
| 84664 | new (&(self->v)) Ptr<cv::reg::MapShift>(); // init Ptr with placement new |  | 84616 | new (&(self->v)) Ptr<cv::reg::MapShift>(); // init Ptr with placement new
| 84665 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapShift(shift))); |  | 84617 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapShift(shift)));
| 84666 | return 0; |  | 84618 | return 0;
| 84667 | } |  | 84619 | }
| 84668 |  |  | 84620 |
| 84669 |  |  | 84621 |
| 84670 | pyPopulateArgumentConversionErrors(); |  | 84622 | pyPopulateArgumentConversionErrors();
| 84671 | } |  | 84623 | }
| 84672 | pyRaiseCVOverloadException("MapShift"); |  | 84624 | pyRaiseCVOverloadException("MapShift");
| 84673 |  |  | 84625 |
| 84674 | return -1; |  | 84626 | return -1;
| 84675 | } |  | 84627 | }
| 84676 |  |  | 84628 |
| 84677 | static PyObject* pyopencv_cv_reg_reg_MapShift_compose(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84629 | static PyObject* pyopencv_cv_reg_reg_MapShift_compose(PyObject* self, PyObject* py_args, PyObject* kw)
| 84678 | { |  | 84630 | {
| 84679 | using namespace cv::reg; |  | 84631 | using namespace cv::reg;
| 84680 |  |  | 84632 |
| 84681 |  |  | 84633 |
| 84682 | Ptr<cv::reg::MapShift> * self1 = 0; |  | 84634 | Ptr<cv::reg::MapShift> * self1 = 0;
| 84683 | if (!pyopencv_reg_MapShift_getp(self, self1)) |  | 84635 | if (!pyopencv_reg_MapShift_getp(self, self1))
| 84684 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)"); |  | 84636 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)");
| 84685 | Ptr<cv::reg::MapShift> _self_ = *(self1); |  | 84637 | Ptr<cv::reg::MapShift> _self_ = *(self1);
| 84686 | PyObject* pyobj_map = NULL; |  | 84638 | PyObject* pyobj_map = NULL;
| 84687 | Ptr<Map> map; |  | 84639 | Ptr<Map> map;
| 84688 |  |  | 84640 |
| 84689 | const char* keywords[] = { "map", NULL }; |  | 84641 | const char* keywords[] = { "map", NULL };
| 84690 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapShift.compose", (char**)keywords, &pyobj_map) && |  | 84642 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapShift.compose", (char**)keywords, &pyobj_map) &&
| 84691 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) ) |  | 84643 | pyopencv_to_safe(pyobj_map, map, ArgInfo("map", 0)) )
| 84692 | { |  | 84644 | {
| 84693 | ERRWRAP2(_self_->compose(map)); |  | 84645 | ERRWRAP2(_self_->compose(map));
| 84694 | Py_RETURN_NONE; |  | 84646 | Py_RETURN_NONE;
| 84695 | } |  | 84647 | }
| 84696 |  |  | 84648 |
| 84697 | return NULL; |  | 84649 | return NULL;
| 84698 | } |  | 84650 | }
| 84699 |  |  | 84651 |
| 84700 | static PyObject* pyopencv_cv_reg_reg_MapShift_getShift(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84652 | static PyObject* pyopencv_cv_reg_reg_MapShift_getShift(PyObject* self, PyObject* py_args, PyObject* kw)
| 84701 | { |  | 84653 | {
| 84702 | using namespace cv::reg; |  | 84654 | using namespace cv::reg;
| 84703 |  |  | 84655 |
| 84704 |  |  | 84656 |
| 84705 | Ptr<cv::reg::MapShift> * self1 = 0; |  | 84657 | Ptr<cv::reg::MapShift> * self1 = 0;
| 84706 | if (!pyopencv_reg_MapShift_getp(self, self1)) |  | 84658 | if (!pyopencv_reg_MapShift_getp(self, self1))
| 84707 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)"); |  | 84659 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)");
| 84708 | Ptr<cv::reg::MapShift> _self_ = *(self1); |  | 84660 | Ptr<cv::reg::MapShift> _self_ = *(self1);
| 84709 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84661 | pyPrepareArgumentConversionErrorsStorage(2);
| 84710 |  |  | 84662 |
| 84711 | { |  | 84663 | {
| 84712 | PyObject* pyobj_shift = NULL; |  | 84664 | PyObject* pyobj_shift = NULL;
| 84713 | Mat shift; |  | 84665 | Mat shift;
| 84714 |  |  | 84666 |
| 84715 | const char* keywords[] = { "shift", NULL }; |  | 84667 | const char* keywords[] = { "shift", NULL };
| 84716 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapShift.getShift", (char**)keywords, &pyobj_shift) && |  | 84668 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapShift.getShift", (char**)keywords, &pyobj_shift) &&
| 84717 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) ) |  | 84669 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) )
| 84718 | { |  | 84670 | {
| 84719 | ERRWRAP2(_self_->getShift(shift)); |  | 84671 | ERRWRAP2(_self_->getShift(shift));
| 84720 | return pyopencv_from(shift); |  | 84672 | return pyopencv_from(shift);
| 84721 | } |  | 84673 | }
| 84722 |  |  | 84674 |
| 84723 |  |  | 84675 |
| 84724 | pyPopulateArgumentConversionErrors(); |  | 84676 | pyPopulateArgumentConversionErrors();
| 84725 | } |  | 84677 | }
| 84726 |  |  | 84678 |
| 84727 |  |  | 84679 |
| 84728 | { |  | 84680 | {
| 84729 | PyObject* pyobj_shift = NULL; |  | 84681 | PyObject* pyobj_shift = NULL;
| 84730 | UMat shift; |  | 84682 | UMat shift;
| 84731 |  |  | 84683 |
| 84732 | const char* keywords[] = { "shift", NULL }; |  | 84684 | const char* keywords[] = { "shift", NULL };
| 84733 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapShift.getShift", (char**)keywords, &pyobj_shift) && |  | 84685 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:reg_MapShift.getShift", (char**)keywords, &pyobj_shift) &&
| 84734 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) ) |  | 84686 | pyopencv_to_safe(pyobj_shift, shift, ArgInfo("shift", 1)) )
| 84735 | { |  | 84687 | {
| 84736 | ERRWRAP2(_self_->getShift(shift)); |  | 84688 | ERRWRAP2(_self_->getShift(shift));
| 84737 | return pyopencv_from(shift); |  | 84689 | return pyopencv_from(shift);
| 84738 | } |  | 84690 | }
| 84739 |  |  | 84691 |
| 84740 |  |  | 84692 |
| 84741 | pyPopulateArgumentConversionErrors(); |  | 84693 | pyPopulateArgumentConversionErrors();
| 84742 | } |  | 84694 | }
| 84743 | pyRaiseCVOverloadException("getShift"); |  | 84695 | pyRaiseCVOverloadException("getShift");
| 84744 |  |  | 84696 |
| 84745 | return NULL; |  | 84697 | return NULL;
| 84746 | } |  | 84698 | }
| 84747 |  |  | 84699 |
| 84748 | static PyObject* pyopencv_cv_reg_reg_MapShift_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84700 | static PyObject* pyopencv_cv_reg_reg_MapShift_inverseMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 84749 | { |  | 84701 | {
| 84750 | using namespace cv::reg; |  | 84702 | using namespace cv::reg;
| 84751 |  |  | 84703 |
| 84752 |  |  | 84704 |
| 84753 | Ptr<cv::reg::MapShift> * self1 = 0; |  | 84705 | Ptr<cv::reg::MapShift> * self1 = 0;
| 84754 | if (!pyopencv_reg_MapShift_getp(self, self1)) |  | 84706 | if (!pyopencv_reg_MapShift_getp(self, self1))
| 84755 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)"); |  | 84707 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)");
| 84756 | Ptr<cv::reg::MapShift> _self_ = *(self1); |  | 84708 | Ptr<cv::reg::MapShift> _self_ = *(self1);
| 84757 | cv::Ptr<Map> retval; |  | 84709 | cv::Ptr<Map> retval;
| 84758 |  |  | 84710 |
| 84759 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 84711 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 84760 | { |  | 84712 | {
| 84761 | ERRWRAP2(retval = _self_->inverseMap()); |  | 84713 | ERRWRAP2(retval = _self_->inverseMap());
| 84762 | return pyopencv_from(retval); |  | 84714 | return pyopencv_from(retval);
| 84763 | } |  | 84715 | }
| 84764 |  |  | 84716 |
| 84765 | return NULL; |  | 84717 | return NULL;
| 84766 | } |  | 84718 | }
| 84767 |  |  | 84719 |
| 84768 | static PyObject* pyopencv_cv_reg_reg_MapShift_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84720 | static PyObject* pyopencv_cv_reg_reg_MapShift_inverseWarp(PyObject* self, PyObject* py_args, PyObject* kw)
| 84769 | { |  | 84721 | {
| 84770 | using namespace cv::reg; |  | 84722 | using namespace cv::reg;
| 84771 |  |  | 84723 |
| 84772 |  |  | 84724 |
| 84773 | Ptr<cv::reg::MapShift> * self1 = 0; |  | 84725 | Ptr<cv::reg::MapShift> * self1 = 0;
| 84774 | if (!pyopencv_reg_MapShift_getp(self, self1)) |  | 84726 | if (!pyopencv_reg_MapShift_getp(self, self1))
| 84775 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)"); |  | 84727 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)");
| 84776 | Ptr<cv::reg::MapShift> _self_ = *(self1); |  | 84728 | Ptr<cv::reg::MapShift> _self_ = *(self1);
| 84777 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84729 | pyPrepareArgumentConversionErrorsStorage(2);
| 84778 |  |  | 84730 |
| 84779 | { |  | 84731 | {
| 84780 | PyObject* pyobj_img1 = NULL; |  | 84732 | PyObject* pyobj_img1 = NULL;
| 84781 | Mat img1; |  | 84733 | Mat img1;
| 84782 | PyObject* pyobj_img2 = NULL; |  | 84734 | PyObject* pyobj_img2 = NULL;
| 84783 | Mat img2; |  | 84735 | Mat img2;
| 84784 |  |  | 84736 |
| 84785 | const char* keywords[] = { "img1", "img2", NULL }; |  | 84737 | const char* keywords[] = { "img1", "img2", NULL };
| 84786 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapShift.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 84738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapShift.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 84787 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 84739 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 84788 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 84740 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 84789 | { |  | 84741 | {
| 84790 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 84742 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 84791 | return pyopencv_from(img2); |  | 84743 | return pyopencv_from(img2);
| 84792 | } |  | 84744 | }
| 84793 |  |  | 84745 |
| 84794 |  |  | 84746 |
| 84795 | pyPopulateArgumentConversionErrors(); |  | 84747 | pyPopulateArgumentConversionErrors();
| 84796 | } |  | 84748 | }
| 84797 |  |  | 84749 |
| 84798 |  |  | 84750 |
| 84799 | { |  | 84751 | {
| 84800 | PyObject* pyobj_img1 = NULL; |  | 84752 | PyObject* pyobj_img1 = NULL;
| 84801 | UMat img1; |  | 84753 | UMat img1;
| 84802 | PyObject* pyobj_img2 = NULL; |  | 84754 | PyObject* pyobj_img2 = NULL;
| 84803 | UMat img2; |  | 84755 | UMat img2;
| 84804 |  |  | 84756 |
| 84805 | const char* keywords[] = { "img1", "img2", NULL }; |  | 84757 | const char* keywords[] = { "img1", "img2", NULL };
| 84806 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapShift.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) && |  | 84758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:reg_MapShift.inverseWarp", (char**)keywords, &pyobj_img1, &pyobj_img2) &&
| 84807 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 84759 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 84808 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) ) |  | 84760 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 1)) )
| 84809 | { |  | 84761 | {
| 84810 | ERRWRAP2(_self_->inverseWarp(img1, img2)); |  | 84762 | ERRWRAP2(_self_->inverseWarp(img1, img2));
| 84811 | return pyopencv_from(img2); |  | 84763 | return pyopencv_from(img2);
| 84812 | } |  | 84764 | }
| 84813 |  |  | 84765 |
| 84814 |  |  | 84766 |
| 84815 | pyPopulateArgumentConversionErrors(); |  | 84767 | pyPopulateArgumentConversionErrors();
| 84816 | } |  | 84768 | }
| 84817 | pyRaiseCVOverloadException("inverseWarp"); |  | 84769 | pyRaiseCVOverloadException("inverseWarp");
| 84818 |  |  | 84770 |
| 84819 | return NULL; |  | 84771 | return NULL;
| 84820 | } |  | 84772 | }
| 84821 |  |  | 84773 |
| 84822 | static PyObject* pyopencv_cv_reg_reg_MapShift_scale(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84774 | static PyObject* pyopencv_cv_reg_reg_MapShift_scale(PyObject* self, PyObject* py_args, PyObject* kw)
| 84823 | { |  | 84775 | {
| 84824 | using namespace cv::reg; |  | 84776 | using namespace cv::reg;
| 84825 |  |  | 84777 |
| 84826 |  |  | 84778 |
| 84827 | Ptr<cv::reg::MapShift> * self1 = 0; |  | 84779 | Ptr<cv::reg::MapShift> * self1 = 0;
| 84828 | if (!pyopencv_reg_MapShift_getp(self, self1)) |  | 84780 | if (!pyopencv_reg_MapShift_getp(self, self1))
| 84829 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)"); |  | 84781 | return failmsgp("Incorrect type of self (must be 'reg_MapShift' or its derivative)");
| 84830 | Ptr<cv::reg::MapShift> _self_ = *(self1); |  | 84782 | Ptr<cv::reg::MapShift> _self_ = *(self1);
| 84831 | PyObject* pyobj_factor = NULL; |  | 84783 | PyObject* pyobj_factor = NULL;
| 84832 | double factor=0; |  | 84784 | double factor=0;
| 84833 |  |  | 84785 |
| 84834 | const char* keywords[] = { "factor", NULL }; |  | 84786 | const char* keywords[] = { "factor", NULL };
| 84835 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapShift.scale", (char**)keywords, &pyobj_factor) && |  | 84787 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapShift.scale", (char**)keywords, &pyobj_factor) &&
| 84836 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) ) |  | 84788 | pyopencv_to_safe(pyobj_factor, factor, ArgInfo("factor", 0)) )
| 84837 | { |  | 84789 | {
| 84838 | ERRWRAP2(_self_->scale(factor)); |  | 84790 | ERRWRAP2(_self_->scale(factor));
| 84839 | Py_RETURN_NONE; |  | 84791 | Py_RETURN_NONE;
| 84840 | } |  | 84792 | }
| 84841 |  |  | 84793 |
| 84842 | return NULL; |  | 84794 | return NULL;
| 84843 | } |  | 84795 | }
| 84844 |  |  | 84796 |
| 84845 |  |  | 84797 |
| 84846 |  |  | 84798 |
| 84847 | // Tables (reg_MapShift) |  | 84799 | // Tables (reg_MapShift)
| 84848 |  |  | 84800 |
| 84849 | static PyGetSetDef pyopencv_reg_MapShift_getseters[] = |  | 84801 | static PyGetSetDef pyopencv_reg_MapShift_getseters[] =
| 84850 | { |  | 84802 | {
| 84851 | {NULL} /* Sentinel */ |  | 84803 | {NULL} /* Sentinel */
| 84852 | }; |  | 84804 | };
| 84853 |  |  | 84805 |
| 84854 | static PyMethodDef pyopencv_reg_MapShift_methods[] = |  | 84806 | static PyMethodDef pyopencv_reg_MapShift_methods[] =
| 84855 | { |  | 84807 | {
| 84856 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_compose, 0), "compose(map) -> None\n."}, |  | 84808 | {"compose", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_compose, 0), "compose(map) -> None\n."},
| 84857 | {"getShift", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_getShift, 0), "getShift([, shift]) -> shift\n."}, |  | 84809 | {"getShift", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_getShift, 0), "getShift([, shift]) -> shift\n."},
| 84858 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_inverseMap, 0), "inverseMap() -> retval\n."}, |  | 84810 | {"inverseMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_inverseMap, 0), "inverseMap() -> retval\n."},
| 84859 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."}, |  | 84811 | {"inverseWarp", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_inverseWarp, 0), "inverseWarp(img1[, img2]) -> img2\n."},
| 84860 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_scale, 0), "scale(factor) -> None\n."}, |  | 84812 | {"scale", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapShift_scale, 0), "scale(factor) -> None\n."},
| 84861 |  |  | 84813 |
| 84862 | {NULL, NULL} |  | 84814 | {NULL, NULL}
| 84863 | }; |  | 84815 | };
| 84864 |  |  | 84816 |
| 84865 | // Converter (reg_MapShift) |  | 84817 | // Converter (reg_MapShift)
| 84866 |  |  | 84818 |
| 84867 | template<> |  | 84819 | template<>
| 84868 | struct PyOpenCV_Converter< Ptr<cv::reg::MapShift> > |  | 84820 | struct PyOpenCV_Converter< Ptr<cv::reg::MapShift> >
| 84869 | { |  | 84821 | {
| 84870 | static PyObject* from(const Ptr<cv::reg::MapShift>& r) |  | 84822 | static PyObject* from(const Ptr<cv::reg::MapShift>& r)
| 84871 | { |  | 84823 | {
| 84872 | return pyopencv_reg_MapShift_Instance(r); |  | 84824 | return pyopencv_reg_MapShift_Instance(r);
| 84873 | } |  | 84825 | }
| 84874 | static bool to(PyObject* src, Ptr<cv::reg::MapShift>& dst, const ArgInfo& info) |  | 84826 | static bool to(PyObject* src, Ptr<cv::reg::MapShift>& dst, const ArgInfo& info)
| 84875 | { |  | 84827 | {
| 84876 | if(!src || src == Py_None) |  | 84828 | if(!src || src == Py_None)
| 84877 | return true; |  | 84829 | return true;
| 84878 | Ptr<cv::reg::MapShift> * dst_; |  | 84830 | Ptr<cv::reg::MapShift> * dst_;
| 84879 | if (pyopencv_reg_MapShift_getp(src, dst_)) |  | 84831 | if (pyopencv_reg_MapShift_getp(src, dst_))
| 84880 | { |  | 84832 | {
| 84881 | dst = *dst_; |  | 84833 | dst = *dst_;
| 84882 | return true; |  | 84834 | return true;
| 84883 | } |  | 84835 | }
| 84884 |  |  | 84836 |
| 84885 | failmsg("Expected Ptr<cv::reg::MapShift> for argument '%s'", info.name); |  | 84837 | failmsg("Expected Ptr<cv::reg::MapShift> for argument '%s'", info.name);
| 84886 | return false; |  | 84838 | return false;
| 84887 | } |  | 84839 | }
| 84888 | }; |  | 84840 | };
| 84889 |  |  | 84841 |
| 84890 | //================================================================================ |  | 84842 | //================================================================================
| 84891 | // reg_MapTypeCaster (Generic) |  | 84843 | // reg_MapTypeCaster (Generic)
| 84892 | //================================================================================ |  | 84844 | //================================================================================
| 84893 |  |  | 84845 |
| 84894 | // GetSet (reg_MapTypeCaster) |  | 84846 | // GetSet (reg_MapTypeCaster)
| 84895 |  |  | 84847 |
| 84896 |  |  | 84848 |
| 84897 |  |  | 84849 |
| 84898 | // Methods (reg_MapTypeCaster) |  | 84850 | // Methods (reg_MapTypeCaster)
| 84899 |  |  | 84851 |
| 84900 | static PyObject* pyopencv_cv_reg_reg_MapTypeCaster_toAffine_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84852 | static PyObject* pyopencv_cv_reg_reg_MapTypeCaster_toAffine_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 84901 | { |  | 84853 | {
| 84902 | using namespace cv::reg; |  | 84854 | using namespace cv::reg;
| 84903 |  |  | 84855 |
| 84904 | PyObject* pyobj_sourceMap = NULL; |  | 84856 | PyObject* pyobj_sourceMap = NULL;
| 84905 | Ptr<Map> sourceMap; |  | 84857 | Ptr<Map> sourceMap;
| 84906 | Ptr<MapAffine> retval; |  | 84858 | Ptr<MapAffine> retval;
| 84907 |  |  | 84859 |
| 84908 | const char* keywords[] = { "sourceMap", NULL }; |  | 84860 | const char* keywords[] = { "sourceMap", NULL };
| 84909 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapTypeCaster.toAffine", (char**)keywords, &pyobj_sourceMap) && |  | 84861 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapTypeCaster.toAffine", (char**)keywords, &pyobj_sourceMap) &&
| 84910 | pyopencv_to_safe(pyobj_sourceMap, sourceMap, ArgInfo("sourceMap", 0)) ) |  | 84862 | pyopencv_to_safe(pyobj_sourceMap, sourceMap, ArgInfo("sourceMap", 0)) )
| 84911 | { |  | 84863 | {
| 84912 | ERRWRAP2(retval = cv::reg::MapTypeCaster::toAffine(sourceMap)); |  | 84864 | ERRWRAP2(retval = cv::reg::MapTypeCaster::toAffine(sourceMap));
| 84913 | return pyopencv_from(retval); |  | 84865 | return pyopencv_from(retval);
| 84914 | } |  | 84866 | }
| 84915 |  |  | 84867 |
| 84916 | return NULL; |  | 84868 | return NULL;
| 84917 | } |  | 84869 | }
| 84918 |  |  | 84870 |
| 84919 | static PyObject* pyopencv_cv_reg_reg_MapTypeCaster_toProjec_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84871 | static PyObject* pyopencv_cv_reg_reg_MapTypeCaster_toProjec_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 84920 | { |  | 84872 | {
| 84921 | using namespace cv::reg; |  | 84873 | using namespace cv::reg;
| 84922 |  |  | 84874 |
| 84923 | PyObject* pyobj_sourceMap = NULL; |  | 84875 | PyObject* pyobj_sourceMap = NULL;
| 84924 | Ptr<Map> sourceMap; |  | 84876 | Ptr<Map> sourceMap;
| 84925 | Ptr<MapProjec> retval; |  | 84877 | Ptr<MapProjec> retval;
| 84926 |  |  | 84878 |
| 84927 | const char* keywords[] = { "sourceMap", NULL }; |  | 84879 | const char* keywords[] = { "sourceMap", NULL };
| 84928 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapTypeCaster.toProjec", (char**)keywords, &pyobj_sourceMap) && |  | 84880 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapTypeCaster.toProjec", (char**)keywords, &pyobj_sourceMap) &&
| 84929 | pyopencv_to_safe(pyobj_sourceMap, sourceMap, ArgInfo("sourceMap", 0)) ) |  | 84881 | pyopencv_to_safe(pyobj_sourceMap, sourceMap, ArgInfo("sourceMap", 0)) )
| 84930 | { |  | 84882 | {
| 84931 | ERRWRAP2(retval = cv::reg::MapTypeCaster::toProjec(sourceMap)); |  | 84883 | ERRWRAP2(retval = cv::reg::MapTypeCaster::toProjec(sourceMap));
| 84932 | return pyopencv_from(retval); |  | 84884 | return pyopencv_from(retval);
| 84933 | } |  | 84885 | }
| 84934 |  |  | 84886 |
| 84935 | return NULL; |  | 84887 | return NULL;
| 84936 | } |  | 84888 | }
| 84937 |  |  | 84889 |
| 84938 | static PyObject* pyopencv_cv_reg_reg_MapTypeCaster_toShift_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84890 | static PyObject* pyopencv_cv_reg_reg_MapTypeCaster_toShift_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 84939 | { |  | 84891 | {
| 84940 | using namespace cv::reg; |  | 84892 | using namespace cv::reg;
| 84941 |  |  | 84893 |
| 84942 | PyObject* pyobj_sourceMap = NULL; |  | 84894 | PyObject* pyobj_sourceMap = NULL;
| 84943 | Ptr<Map> sourceMap; |  | 84895 | Ptr<Map> sourceMap;
| 84944 | Ptr<MapShift> retval; |  | 84896 | Ptr<MapShift> retval;
| 84945 |  |  | 84897 |
| 84946 | const char* keywords[] = { "sourceMap", NULL }; |  | 84898 | const char* keywords[] = { "sourceMap", NULL };
| 84947 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapTypeCaster.toShift", (char**)keywords, &pyobj_sourceMap) && |  | 84899 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:reg_MapTypeCaster.toShift", (char**)keywords, &pyobj_sourceMap) &&
| 84948 | pyopencv_to_safe(pyobj_sourceMap, sourceMap, ArgInfo("sourceMap", 0)) ) |  | 84900 | pyopencv_to_safe(pyobj_sourceMap, sourceMap, ArgInfo("sourceMap", 0)) )
| 84949 | { |  | 84901 | {
| 84950 | ERRWRAP2(retval = cv::reg::MapTypeCaster::toShift(sourceMap)); |  | 84902 | ERRWRAP2(retval = cv::reg::MapTypeCaster::toShift(sourceMap));
| 84951 | return pyopencv_from(retval); |  | 84903 | return pyopencv_from(retval);
| 84952 | } |  | 84904 | }
| 84953 |  |  | 84905 |
| 84954 | return NULL; |  | 84906 | return NULL;
| 84955 | } |  | 84907 | }
| 84956 |  |  | 84908 |
| 84957 |  |  | 84909 |
| 84958 |  |  | 84910 |
| 84959 | // Tables (reg_MapTypeCaster) |  | 84911 | // Tables (reg_MapTypeCaster)
| 84960 |  |  | 84912 |
| 84961 | static PyGetSetDef pyopencv_reg_MapTypeCaster_getseters[] = |  | 84913 | static PyGetSetDef pyopencv_reg_MapTypeCaster_getseters[] =
| 84962 | { |  | 84914 | {
| 84963 | {NULL} /* Sentinel */ |  | 84915 | {NULL} /* Sentinel */
| 84964 | }; |  | 84916 | };
| 84965 |  |  | 84917 |
| 84966 | static PyMethodDef pyopencv_reg_MapTypeCaster_methods[] = |  | 84918 | static PyMethodDef pyopencv_reg_MapTypeCaster_methods[] =
| 84967 | { |  | 84919 | {
| 84968 | {"toAffine", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapTypeCaster_toAffine_static, METH_STATIC), "toAffine(sourceMap) -> retval\n."}, |  | 84920 | {"toAffine", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapTypeCaster_toAffine_static, METH_STATIC), "toAffine(sourceMap) -> retval\n."},
| 84969 | {"toProjec", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapTypeCaster_toProjec_static, METH_STATIC), "toProjec(sourceMap) -> retval\n."}, |  | 84921 | {"toProjec", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapTypeCaster_toProjec_static, METH_STATIC), "toProjec(sourceMap) -> retval\n."},
| 84970 | {"toShift", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapTypeCaster_toShift_static, METH_STATIC), "toShift(sourceMap) -> retval\n."}, |  | 84922 | {"toShift", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapTypeCaster_toShift_static, METH_STATIC), "toShift(sourceMap) -> retval\n."},
| 84971 |  |  | 84923 |
| 84972 | {NULL, NULL} |  | 84924 | {NULL, NULL}
| 84973 | }; |  | 84925 | };
| 84974 |  |  | 84926 |
| 84975 | // Converter (reg_MapTypeCaster) |  | 84927 | // Converter (reg_MapTypeCaster)
| 84976 |  |  | 84928 |
| 84977 | template<> |  | 84929 | template<>
| 84978 | struct PyOpenCV_Converter< Ptr<cv::reg::MapTypeCaster> > |  | 84930 | struct PyOpenCV_Converter< Ptr<cv::reg::MapTypeCaster> >
| 84979 | { |  | 84931 | {
| 84980 | static PyObject* from(const Ptr<cv::reg::MapTypeCaster>& r) |  | 84932 | static PyObject* from(const Ptr<cv::reg::MapTypeCaster>& r)
| 84981 | { |  | 84933 | {
| 84982 | return pyopencv_reg_MapTypeCaster_Instance(r); |  | 84934 | return pyopencv_reg_MapTypeCaster_Instance(r);
| 84983 | } |  | 84935 | }
| 84984 | static bool to(PyObject* src, Ptr<cv::reg::MapTypeCaster>& dst, const ArgInfo& info) |  | 84936 | static bool to(PyObject* src, Ptr<cv::reg::MapTypeCaster>& dst, const ArgInfo& info)
| 84985 | { |  | 84937 | {
| 84986 | if(!src || src == Py_None) |  | 84938 | if(!src || src == Py_None)
| 84987 | return true; |  | 84939 | return true;
| 84988 | Ptr<cv::reg::MapTypeCaster> * dst_; |  | 84940 | Ptr<cv::reg::MapTypeCaster> * dst_;
| 84989 | if (pyopencv_reg_MapTypeCaster_getp(src, dst_)) |  | 84941 | if (pyopencv_reg_MapTypeCaster_getp(src, dst_))
| 84990 | { |  | 84942 | {
| 84991 | dst = *dst_; |  | 84943 | dst = *dst_;
| 84992 | return true; |  | 84944 | return true;
| 84993 | } |  | 84945 | }
| 84994 |  |  | 84946 |
| 84995 | failmsg("Expected Ptr<cv::reg::MapTypeCaster> for argument '%s'", info.name); |  | 84947 | failmsg("Expected Ptr<cv::reg::MapTypeCaster> for argument '%s'", info.name);
| 84996 | return false; |  | 84948 | return false;
| 84997 | } |  | 84949 | }
| 84998 | }; |  | 84950 | };
| 84999 |  |  | 84951 |
| 85000 | //================================================================================ |  | 84952 | //================================================================================
| 85001 | // reg_Mapper (Generic) |  | 84953 | // reg_Mapper (Generic)
| 85002 | //================================================================================ |  | 84954 | //================================================================================
| 85003 |  |  | 84955 |
| 85004 | // GetSet (reg_Mapper) |  | 84956 | // GetSet (reg_Mapper)
| 85005 |  |  | 84957 |
| 85006 |  |  | 84958 |
| 85007 |  |  | 84959 |
| 85008 | // Methods (reg_Mapper) |  | 84960 | // Methods (reg_Mapper)
| 85009 |  |  | 84961 |
| 85010 | static PyObject* pyopencv_cv_reg_reg_Mapper_calculate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 84962 | static PyObject* pyopencv_cv_reg_reg_Mapper_calculate(PyObject* self, PyObject* py_args, PyObject* kw)
| 85011 | { |  | 84963 | {
| 85012 | using namespace cv::reg; |  | 84964 | using namespace cv::reg;
| 85013 |  |  | 84965 |
| 85014 |  |  | 84966 |
| 85015 | Ptr<cv::reg::Mapper> * self1 = 0; |  | 84967 | Ptr<cv::reg::Mapper> * self1 = 0;
| 85016 | if (!pyopencv_reg_Mapper_getp(self, self1)) |  | 84968 | if (!pyopencv_reg_Mapper_getp(self, self1))
| 85017 | return failmsgp("Incorrect type of self (must be 'reg_Mapper' or its derivative)"); |  | 84969 | return failmsgp("Incorrect type of self (must be 'reg_Mapper' or its derivative)");
| 85018 | Ptr<cv::reg::Mapper> _self_ = *(self1); |  | 84970 | Ptr<cv::reg::Mapper> _self_ = *(self1);
| 85019 | pyPrepareArgumentConversionErrorsStorage(2); |  | 84971 | pyPrepareArgumentConversionErrorsStorage(2);
| 85020 |  |  | 84972 |
| 85021 | { |  | 84973 | {
| 85022 | PyObject* pyobj_img1 = NULL; |  | 84974 | PyObject* pyobj_img1 = NULL;
| 85023 | Mat img1; |  | 84975 | Mat img1;
| 85024 | PyObject* pyobj_img2 = NULL; |  | 84976 | PyObject* pyobj_img2 = NULL;
| 85025 | Mat img2; |  | 84977 | Mat img2;
| 85026 | PyObject* pyobj_init = NULL; |  | 84978 | PyObject* pyobj_init = NULL;
| 85027 | Ptr<Map> init=cv::Ptr<Map>(); |  | 84979 | Ptr<Map> init=cv::Ptr<Map>();
| 85028 | cv::Ptr<Map> retval; |  | 84980 | cv::Ptr<Map> retval;
| 85029 |  |  | 84981 |
| 85030 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 84982 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85031 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_Mapper.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 84983 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_Mapper.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85032 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 84984 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85033 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 84985 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85034 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 84986 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85035 | { |  | 84987 | {
| 85036 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 84988 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85037 | return pyopencv_from(retval); |  | 84989 | return pyopencv_from(retval);
| 85038 | } |  | 84990 | }
| 85039 |  |  | 84991 |
| 85040 |  |  | 84992 |
| 85041 | pyPopulateArgumentConversionErrors(); |  | 84993 | pyPopulateArgumentConversionErrors();
| 85042 | } |  | 84994 | }
| 85043 |  |  | 84995 |
| 85044 |  |  | 84996 |
| 85045 | { |  | 84997 | {
| 85046 | PyObject* pyobj_img1 = NULL; |  | 84998 | PyObject* pyobj_img1 = NULL;
| 85047 | UMat img1; |  | 84999 | UMat img1;
| 85048 | PyObject* pyobj_img2 = NULL; |  | 85000 | PyObject* pyobj_img2 = NULL;
| 85049 | UMat img2; |  | 85001 | UMat img2;
| 85050 | PyObject* pyobj_init = NULL; |  | 85002 | PyObject* pyobj_init = NULL;
| 85051 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85003 | Ptr<Map> init=cv::Ptr<Map>();
| 85052 | cv::Ptr<Map> retval; |  | 85004 | cv::Ptr<Map> retval;
| 85053 |  |  | 85005 |
| 85054 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85006 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85055 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_Mapper.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85007 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_Mapper.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85056 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85008 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85057 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85009 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85058 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85010 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85059 | { |  | 85011 | {
| 85060 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85012 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85061 | return pyopencv_from(retval); |  | 85013 | return pyopencv_from(retval);
| 85062 | } |  | 85014 | }
| 85063 |  |  | 85015 |
| 85064 |  |  | 85016 |
| 85065 | pyPopulateArgumentConversionErrors(); |  | 85017 | pyPopulateArgumentConversionErrors();
| 85066 | } |  | 85018 | }
| 85067 | pyRaiseCVOverloadException("calculate"); |  | 85019 | pyRaiseCVOverloadException("calculate");
| 85068 |  |  | 85020 |
| 85069 | return NULL; |  | 85021 | return NULL;
| 85070 | } |  | 85022 | }
| 85071 |  |  | 85023 |
| 85072 | static PyObject* pyopencv_cv_reg_reg_Mapper_getMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85024 | static PyObject* pyopencv_cv_reg_reg_Mapper_getMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 85073 | { |  | 85025 | {
| 85074 | using namespace cv::reg; |  | 85026 | using namespace cv::reg;
| 85075 |  |  | 85027 |
| 85076 |  |  | 85028 |
| 85077 | Ptr<cv::reg::Mapper> * self1 = 0; |  | 85029 | Ptr<cv::reg::Mapper> * self1 = 0;
| 85078 | if (!pyopencv_reg_Mapper_getp(self, self1)) |  | 85030 | if (!pyopencv_reg_Mapper_getp(self, self1))
| 85079 | return failmsgp("Incorrect type of self (must be 'reg_Mapper' or its derivative)"); |  | 85031 | return failmsgp("Incorrect type of self (must be 'reg_Mapper' or its derivative)");
| 85080 | Ptr<cv::reg::Mapper> _self_ = *(self1); |  | 85032 | Ptr<cv::reg::Mapper> _self_ = *(self1);
| 85081 | cv::Ptr<Map> retval; |  | 85033 | cv::Ptr<Map> retval;
| 85082 |  |  | 85034 |
| 85083 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85035 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85084 | { |  | 85036 | {
| 85085 | ERRWRAP2(retval = _self_->getMap()); |  | 85037 | ERRWRAP2(retval = _self_->getMap());
| 85086 | return pyopencv_from(retval); |  | 85038 | return pyopencv_from(retval);
| 85087 | } |  | 85039 | }
| 85088 |  |  | 85040 |
| 85089 | return NULL; |  | 85041 | return NULL;
| 85090 | } |  | 85042 | }
| 85091 |  |  | 85043 |
| 85092 |  |  | 85044 |
| 85093 |  |  | 85045 |
| 85094 | // Tables (reg_Mapper) |  | 85046 | // Tables (reg_Mapper)
| 85095 |  |  | 85047 |
| 85096 | static PyGetSetDef pyopencv_reg_Mapper_getseters[] = |  | 85048 | static PyGetSetDef pyopencv_reg_Mapper_getseters[] =
| 85097 | { |  | 85049 | {
| 85098 | {NULL} /* Sentinel */ |  | 85050 | {NULL} /* Sentinel */
| 85099 | }; |  | 85051 | };
| 85100 |  |  | 85052 |
| 85101 | static PyMethodDef pyopencv_reg_Mapper_methods[] = |  | 85053 | static PyMethodDef pyopencv_reg_Mapper_methods[] =
| 85102 | { |  | 85054 | {
| 85103 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Mapper_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."}, |  | 85055 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Mapper_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."},
| 85104 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Mapper_getMap, 0), "getMap() -> retval\n."}, |  | 85056 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_Mapper_getMap, 0), "getMap() -> retval\n."},
| 85105 |  |  | 85057 |
| 85106 | {NULL, NULL} |  | 85058 | {NULL, NULL}
| 85107 | }; |  | 85059 | };
| 85108 |  |  | 85060 |
| 85109 | // Converter (reg_Mapper) |  | 85061 | // Converter (reg_Mapper)
| 85110 |  |  | 85062 |
| 85111 | template<> |  | 85063 | template<>
| 85112 | struct PyOpenCV_Converter< Ptr<cv::reg::Mapper> > |  | 85064 | struct PyOpenCV_Converter< Ptr<cv::reg::Mapper> >
| 85113 | { |  | 85065 | {
| 85114 | static PyObject* from(const Ptr<cv::reg::Mapper>& r) |  | 85066 | static PyObject* from(const Ptr<cv::reg::Mapper>& r)
| 85115 | { |  | 85067 | {
| 85116 | return pyopencv_reg_Mapper_Instance(r); |  | 85068 | return pyopencv_reg_Mapper_Instance(r);
| 85117 | } |  | 85069 | }
| 85118 | static bool to(PyObject* src, Ptr<cv::reg::Mapper>& dst, const ArgInfo& info) |  | 85070 | static bool to(PyObject* src, Ptr<cv::reg::Mapper>& dst, const ArgInfo& info)
| 85119 | { |  | 85071 | {
| 85120 | if(!src || src == Py_None) |  | 85072 | if(!src || src == Py_None)
| 85121 | return true; |  | 85073 | return true;
| 85122 | Ptr<cv::reg::Mapper> * dst_; |  | 85074 | Ptr<cv::reg::Mapper> * dst_;
| 85123 | if (pyopencv_reg_Mapper_getp(src, dst_)) |  | 85075 | if (pyopencv_reg_Mapper_getp(src, dst_))
| 85124 | { |  | 85076 | {
| 85125 | dst = *dst_; |  | 85077 | dst = *dst_;
| 85126 | return true; |  | 85078 | return true;
| 85127 | } |  | 85079 | }
| 85128 |  |  | 85080 |
| 85129 | failmsg("Expected Ptr<cv::reg::Mapper> for argument '%s'", info.name); |  | 85081 | failmsg("Expected Ptr<cv::reg::Mapper> for argument '%s'", info.name);
| 85130 | return false; |  | 85082 | return false;
| 85131 | } |  | 85083 | }
| 85132 | }; |  | 85084 | };
| 85133 |  |  | 85085 |
| 85134 | //================================================================================ |  | 85086 | //================================================================================
| 85135 | // reg_MapperGradAffine (Generic) |  | 85087 | // reg_MapperGradAffine (Generic)
| 85136 | //================================================================================ |  | 85088 | //================================================================================
| 85137 |  |  | 85089 |
| 85138 | // GetSet (reg_MapperGradAffine) |  | 85090 | // GetSet (reg_MapperGradAffine)
| 85139 |  |  | 85091 |
| 85140 |  |  | 85092 |
| 85141 |  |  | 85093 |
| 85142 | // Methods (reg_MapperGradAffine) |  | 85094 | // Methods (reg_MapperGradAffine)
| 85143 |  |  | 85095 |
| 85144 | static int pyopencv_cv_reg_reg_MapperGradAffine_MapperGradAffine(pyopencv_reg_MapperGradAffine_t* self, PyObject* py_args, PyObject* kw) |  | 85096 | static int pyopencv_cv_reg_reg_MapperGradAffine_MapperGradAffine(pyopencv_reg_MapperGradAffine_t* self, PyObject* py_args, PyObject* kw)
| 85145 | { |  | 85097 | {
| 85146 | using namespace cv::reg; |  | 85098 | using namespace cv::reg;
| 85147 |  |  | 85099 |
| 85148 |  |  | 85100 |
| 85149 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85101 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85150 | { |  | 85102 | {
| 85151 | new (&(self->v)) Ptr<cv::reg::MapperGradAffine>(); // init Ptr with placement new |  | 85103 | new (&(self->v)) Ptr<cv::reg::MapperGradAffine>(); // init Ptr with placement new
| 85152 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradAffine())); |  | 85104 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradAffine()));
| 85153 | return 0; |  | 85105 | return 0;
| 85154 | } |  | 85106 | }
| 85155 |  |  | 85107 |
| 85156 | return -1; |  | 85108 | return -1;
| 85157 | } |  | 85109 | }
| 85158 |  |  | 85110 |
| 85159 | static PyObject* pyopencv_cv_reg_reg_MapperGradAffine_calculate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85111 | static PyObject* pyopencv_cv_reg_reg_MapperGradAffine_calculate(PyObject* self, PyObject* py_args, PyObject* kw)
| 85160 | { |  | 85112 | {
| 85161 | using namespace cv::reg; |  | 85113 | using namespace cv::reg;
| 85162 |  |  | 85114 |
| 85163 |  |  | 85115 |
| 85164 | Ptr<cv::reg::MapperGradAffine> * self1 = 0; |  | 85116 | Ptr<cv::reg::MapperGradAffine> * self1 = 0;
| 85165 | if (!pyopencv_reg_MapperGradAffine_getp(self, self1)) |  | 85117 | if (!pyopencv_reg_MapperGradAffine_getp(self, self1))
| 85166 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradAffine' or its derivative)"); |  | 85118 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradAffine' or its derivative)");
| 85167 | Ptr<cv::reg::MapperGradAffine> _self_ = *(self1); |  | 85119 | Ptr<cv::reg::MapperGradAffine> _self_ = *(self1);
| 85168 | pyPrepareArgumentConversionErrorsStorage(2); |  | 85120 | pyPrepareArgumentConversionErrorsStorage(2);
| 85169 |  |  | 85121 |
| 85170 | { |  | 85122 | {
| 85171 | PyObject* pyobj_img1 = NULL; |  | 85123 | PyObject* pyobj_img1 = NULL;
| 85172 | Mat img1; |  | 85124 | Mat img1;
| 85173 | PyObject* pyobj_img2 = NULL; |  | 85125 | PyObject* pyobj_img2 = NULL;
| 85174 | Mat img2; |  | 85126 | Mat img2;
| 85175 | PyObject* pyobj_init = NULL; |  | 85127 | PyObject* pyobj_init = NULL;
| 85176 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85128 | Ptr<Map> init=cv::Ptr<Map>();
| 85177 | cv::Ptr<Map> retval; |  | 85129 | cv::Ptr<Map> retval;
| 85178 |  |  | 85130 |
| 85179 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85131 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85180 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradAffine.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85132 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradAffine.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85181 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85133 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85182 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85134 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85183 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85135 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85184 | { |  | 85136 | {
| 85185 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85137 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85186 | return pyopencv_from(retval); |  | 85138 | return pyopencv_from(retval);
| 85187 | } |  | 85139 | }
| 85188 |  |  | 85140 |
| 85189 |  |  | 85141 |
| 85190 | pyPopulateArgumentConversionErrors(); |  | 85142 | pyPopulateArgumentConversionErrors();
| 85191 | } |  | 85143 | }
| 85192 |  |  | 85144 |
| 85193 |  |  | 85145 |
| 85194 | { |  | 85146 | {
| 85195 | PyObject* pyobj_img1 = NULL; |  | 85147 | PyObject* pyobj_img1 = NULL;
| 85196 | UMat img1; |  | 85148 | UMat img1;
| 85197 | PyObject* pyobj_img2 = NULL; |  | 85149 | PyObject* pyobj_img2 = NULL;
| 85198 | UMat img2; |  | 85150 | UMat img2;
| 85199 | PyObject* pyobj_init = NULL; |  | 85151 | PyObject* pyobj_init = NULL;
| 85200 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85152 | Ptr<Map> init=cv::Ptr<Map>();
| 85201 | cv::Ptr<Map> retval; |  | 85153 | cv::Ptr<Map> retval;
| 85202 |  |  | 85154 |
| 85203 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85155 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85204 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradAffine.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85156 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradAffine.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85205 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85157 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85206 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85158 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85207 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85159 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85208 | { |  | 85160 | {
| 85209 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85161 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85210 | return pyopencv_from(retval); |  | 85162 | return pyopencv_from(retval);
| 85211 | } |  | 85163 | }
| 85212 |  |  | 85164 |
| 85213 |  |  | 85165 |
| 85214 | pyPopulateArgumentConversionErrors(); |  | 85166 | pyPopulateArgumentConversionErrors();
| 85215 | } |  | 85167 | }
| 85216 | pyRaiseCVOverloadException("calculate"); |  | 85168 | pyRaiseCVOverloadException("calculate");
| 85217 |  |  | 85169 |
| 85218 | return NULL; |  | 85170 | return NULL;
| 85219 | } |  | 85171 | }
| 85220 |  |  | 85172 |
| 85221 | static PyObject* pyopencv_cv_reg_reg_MapperGradAffine_getMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85173 | static PyObject* pyopencv_cv_reg_reg_MapperGradAffine_getMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 85222 | { |  | 85174 | {
| 85223 | using namespace cv::reg; |  | 85175 | using namespace cv::reg;
| 85224 |  |  | 85176 |
| 85225 |  |  | 85177 |
| 85226 | Ptr<cv::reg::MapperGradAffine> * self1 = 0; |  | 85178 | Ptr<cv::reg::MapperGradAffine> * self1 = 0;
| 85227 | if (!pyopencv_reg_MapperGradAffine_getp(self, self1)) |  | 85179 | if (!pyopencv_reg_MapperGradAffine_getp(self, self1))
| 85228 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradAffine' or its derivative)"); |  | 85180 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradAffine' or its derivative)");
| 85229 | Ptr<cv::reg::MapperGradAffine> _self_ = *(self1); |  | 85181 | Ptr<cv::reg::MapperGradAffine> _self_ = *(self1);
| 85230 | cv::Ptr<Map> retval; |  | 85182 | cv::Ptr<Map> retval;
| 85231 |  |  | 85183 |
| 85232 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85184 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85233 | { |  | 85185 | {
| 85234 | ERRWRAP2(retval = _self_->getMap()); |  | 85186 | ERRWRAP2(retval = _self_->getMap());
| 85235 | return pyopencv_from(retval); |  | 85187 | return pyopencv_from(retval);
| 85236 | } |  | 85188 | }
| 85237 |  |  | 85189 |
| 85238 | return NULL; |  | 85190 | return NULL;
| 85239 | } |  | 85191 | }
| 85240 |  |  | 85192 |
| 85241 |  |  | 85193 |
| 85242 |  |  | 85194 |
| 85243 | // Tables (reg_MapperGradAffine) |  | 85195 | // Tables (reg_MapperGradAffine)
| 85244 |  |  | 85196 |
| 85245 | static PyGetSetDef pyopencv_reg_MapperGradAffine_getseters[] = |  | 85197 | static PyGetSetDef pyopencv_reg_MapperGradAffine_getseters[] =
| 85246 | { |  | 85198 | {
| 85247 | {NULL} /* Sentinel */ |  | 85199 | {NULL} /* Sentinel */
| 85248 | }; |  | 85200 | };
| 85249 |  |  | 85201 |
| 85250 | static PyMethodDef pyopencv_reg_MapperGradAffine_methods[] = |  | 85202 | static PyMethodDef pyopencv_reg_MapperGradAffine_methods[] =
| 85251 | { |  | 85203 | {
| 85252 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradAffine_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."}, |  | 85204 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradAffine_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."},
| 85253 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradAffine_getMap, 0), "getMap() -> retval\n."}, |  | 85205 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradAffine_getMap, 0), "getMap() -> retval\n."},
| 85254 |  |  | 85206 |
| 85255 | {NULL, NULL} |  | 85207 | {NULL, NULL}
| 85256 | }; |  | 85208 | };
| 85257 |  |  | 85209 |
| 85258 | // Converter (reg_MapperGradAffine) |  | 85210 | // Converter (reg_MapperGradAffine)
| 85259 |  |  | 85211 |
| 85260 | template<> |  | 85212 | template<>
| 85261 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradAffine> > |  | 85213 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradAffine> >
| 85262 | { |  | 85214 | {
| 85263 | static PyObject* from(const Ptr<cv::reg::MapperGradAffine>& r) |  | 85215 | static PyObject* from(const Ptr<cv::reg::MapperGradAffine>& r)
| 85264 | { |  | 85216 | {
| 85265 | return pyopencv_reg_MapperGradAffine_Instance(r); |  | 85217 | return pyopencv_reg_MapperGradAffine_Instance(r);
| 85266 | } |  | 85218 | }
| 85267 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradAffine>& dst, const ArgInfo& info) |  | 85219 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradAffine>& dst, const ArgInfo& info)
| 85268 | { |  | 85220 | {
| 85269 | if(!src || src == Py_None) |  | 85221 | if(!src || src == Py_None)
| 85270 | return true; |  | 85222 | return true;
| 85271 | Ptr<cv::reg::MapperGradAffine> * dst_; |  | 85223 | Ptr<cv::reg::MapperGradAffine> * dst_;
| 85272 | if (pyopencv_reg_MapperGradAffine_getp(src, dst_)) |  | 85224 | if (pyopencv_reg_MapperGradAffine_getp(src, dst_))
| 85273 | { |  | 85225 | {
| 85274 | dst = *dst_; |  | 85226 | dst = *dst_;
| 85275 | return true; |  | 85227 | return true;
| 85276 | } |  | 85228 | }
| 85277 |  |  | 85229 |
| 85278 | failmsg("Expected Ptr<cv::reg::MapperGradAffine> for argument '%s'", info.name); |  | 85230 | failmsg("Expected Ptr<cv::reg::MapperGradAffine> for argument '%s'", info.name);
| 85279 | return false; |  | 85231 | return false;
| 85280 | } |  | 85232 | }
| 85281 | }; |  | 85233 | };
| 85282 |  |  | 85234 |
| 85283 | //================================================================================ |  | 85235 | //================================================================================
| 85284 | // reg_MapperGradEuclid (Generic) |  | 85236 | // reg_MapperGradEuclid (Generic)
| 85285 | //================================================================================ |  | 85237 | //================================================================================
| 85286 |  |  | 85238 |
| 85287 | // GetSet (reg_MapperGradEuclid) |  | 85239 | // GetSet (reg_MapperGradEuclid)
| 85288 |  |  | 85240 |
| 85289 |  |  | 85241 |
| 85290 |  |  | 85242 |
| 85291 | // Methods (reg_MapperGradEuclid) |  | 85243 | // Methods (reg_MapperGradEuclid)
| 85292 |  |  | 85244 |
| 85293 | static int pyopencv_cv_reg_reg_MapperGradEuclid_MapperGradEuclid(pyopencv_reg_MapperGradEuclid_t* self, PyObject* py_args, PyObject* kw) |  | 85245 | static int pyopencv_cv_reg_reg_MapperGradEuclid_MapperGradEuclid(pyopencv_reg_MapperGradEuclid_t* self, PyObject* py_args, PyObject* kw)
| 85294 | { |  | 85246 | {
| 85295 | using namespace cv::reg; |  | 85247 | using namespace cv::reg;
| 85296 |  |  | 85248 |
| 85297 |  |  | 85249 |
| 85298 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85250 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85299 | { |  | 85251 | {
| 85300 | new (&(self->v)) Ptr<cv::reg::MapperGradEuclid>(); // init Ptr with placement new |  | 85252 | new (&(self->v)) Ptr<cv::reg::MapperGradEuclid>(); // init Ptr with placement new
| 85301 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradEuclid())); |  | 85253 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradEuclid()));
| 85302 | return 0; |  | 85254 | return 0;
| 85303 | } |  | 85255 | }
| 85304 |  |  | 85256 |
| 85305 | return -1; |  | 85257 | return -1;
| 85306 | } |  | 85258 | }
| 85307 |  |  | 85259 |
| 85308 | static PyObject* pyopencv_cv_reg_reg_MapperGradEuclid_calculate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85260 | static PyObject* pyopencv_cv_reg_reg_MapperGradEuclid_calculate(PyObject* self, PyObject* py_args, PyObject* kw)
| 85309 | { |  | 85261 | {
| 85310 | using namespace cv::reg; |  | 85262 | using namespace cv::reg;
| 85311 |  |  | 85263 |
| 85312 |  |  | 85264 |
| 85313 | Ptr<cv::reg::MapperGradEuclid> * self1 = 0; |  | 85265 | Ptr<cv::reg::MapperGradEuclid> * self1 = 0;
| 85314 | if (!pyopencv_reg_MapperGradEuclid_getp(self, self1)) |  | 85266 | if (!pyopencv_reg_MapperGradEuclid_getp(self, self1))
| 85315 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradEuclid' or its derivative)"); |  | 85267 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradEuclid' or its derivative)");
| 85316 | Ptr<cv::reg::MapperGradEuclid> _self_ = *(self1); |  | 85268 | Ptr<cv::reg::MapperGradEuclid> _self_ = *(self1);
| 85317 | pyPrepareArgumentConversionErrorsStorage(2); |  | 85269 | pyPrepareArgumentConversionErrorsStorage(2);
| 85318 |  |  | 85270 |
| 85319 | { |  | 85271 | {
| 85320 | PyObject* pyobj_img1 = NULL; |  | 85272 | PyObject* pyobj_img1 = NULL;
| 85321 | Mat img1; |  | 85273 | Mat img1;
| 85322 | PyObject* pyobj_img2 = NULL; |  | 85274 | PyObject* pyobj_img2 = NULL;
| 85323 | Mat img2; |  | 85275 | Mat img2;
| 85324 | PyObject* pyobj_init = NULL; |  | 85276 | PyObject* pyobj_init = NULL;
| 85325 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85277 | Ptr<Map> init=cv::Ptr<Map>();
| 85326 | cv::Ptr<Map> retval; |  | 85278 | cv::Ptr<Map> retval;
| 85327 |  |  | 85279 |
| 85328 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85280 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85329 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradEuclid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85281 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradEuclid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85330 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85282 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85331 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85283 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85332 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85284 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85333 | { |  | 85285 | {
| 85334 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85286 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85335 | return pyopencv_from(retval); |  | 85287 | return pyopencv_from(retval);
| 85336 | } |  | 85288 | }
| 85337 |  |  | 85289 |
| 85338 |  |  | 85290 |
| 85339 | pyPopulateArgumentConversionErrors(); |  | 85291 | pyPopulateArgumentConversionErrors();
| 85340 | } |  | 85292 | }
| 85341 |  |  | 85293 |
| 85342 |  |  | 85294 |
| 85343 | { |  | 85295 | {
| 85344 | PyObject* pyobj_img1 = NULL; |  | 85296 | PyObject* pyobj_img1 = NULL;
| 85345 | UMat img1; |  | 85297 | UMat img1;
| 85346 | PyObject* pyobj_img2 = NULL; |  | 85298 | PyObject* pyobj_img2 = NULL;
| 85347 | UMat img2; |  | 85299 | UMat img2;
| 85348 | PyObject* pyobj_init = NULL; |  | 85300 | PyObject* pyobj_init = NULL;
| 85349 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85301 | Ptr<Map> init=cv::Ptr<Map>();
| 85350 | cv::Ptr<Map> retval; |  | 85302 | cv::Ptr<Map> retval;
| 85351 |  |  | 85303 |
| 85352 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85304 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85353 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradEuclid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85305 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradEuclid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85354 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85306 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85355 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85307 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85356 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85308 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85357 | { |  | 85309 | {
| 85358 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85310 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85359 | return pyopencv_from(retval); |  | 85311 | return pyopencv_from(retval);
| 85360 | } |  | 85312 | }
| 85361 |  |  | 85313 |
| 85362 |  |  | 85314 |
| 85363 | pyPopulateArgumentConversionErrors(); |  | 85315 | pyPopulateArgumentConversionErrors();
| 85364 | } |  | 85316 | }
| 85365 | pyRaiseCVOverloadException("calculate"); |  | 85317 | pyRaiseCVOverloadException("calculate");
| 85366 |  |  | 85318 |
| 85367 | return NULL; |  | 85319 | return NULL;
| 85368 | } |  | 85320 | }
| 85369 |  |  | 85321 |
| 85370 | static PyObject* pyopencv_cv_reg_reg_MapperGradEuclid_getMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85322 | static PyObject* pyopencv_cv_reg_reg_MapperGradEuclid_getMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 85371 | { |  | 85323 | {
| 85372 | using namespace cv::reg; |  | 85324 | using namespace cv::reg;
| 85373 |  |  | 85325 |
| 85374 |  |  | 85326 |
| 85375 | Ptr<cv::reg::MapperGradEuclid> * self1 = 0; |  | 85327 | Ptr<cv::reg::MapperGradEuclid> * self1 = 0;
| 85376 | if (!pyopencv_reg_MapperGradEuclid_getp(self, self1)) |  | 85328 | if (!pyopencv_reg_MapperGradEuclid_getp(self, self1))
| 85377 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradEuclid' or its derivative)"); |  | 85329 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradEuclid' or its derivative)");
| 85378 | Ptr<cv::reg::MapperGradEuclid> _self_ = *(self1); |  | 85330 | Ptr<cv::reg::MapperGradEuclid> _self_ = *(self1);
| 85379 | cv::Ptr<Map> retval; |  | 85331 | cv::Ptr<Map> retval;
| 85380 |  |  | 85332 |
| 85381 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85333 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85382 | { |  | 85334 | {
| 85383 | ERRWRAP2(retval = _self_->getMap()); |  | 85335 | ERRWRAP2(retval = _self_->getMap());
| 85384 | return pyopencv_from(retval); |  | 85336 | return pyopencv_from(retval);
| 85385 | } |  | 85337 | }
| 85386 |  |  | 85338 |
| 85387 | return NULL; |  | 85339 | return NULL;
| 85388 | } |  | 85340 | }
| 85389 |  |  | 85341 |
| 85390 |  |  | 85342 |
| 85391 |  |  | 85343 |
| 85392 | // Tables (reg_MapperGradEuclid) |  | 85344 | // Tables (reg_MapperGradEuclid)
| 85393 |  |  | 85345 |
| 85394 | static PyGetSetDef pyopencv_reg_MapperGradEuclid_getseters[] = |  | 85346 | static PyGetSetDef pyopencv_reg_MapperGradEuclid_getseters[] =
| 85395 | { |  | 85347 | {
| 85396 | {NULL} /* Sentinel */ |  | 85348 | {NULL} /* Sentinel */
| 85397 | }; |  | 85349 | };
| 85398 |  |  | 85350 |
| 85399 | static PyMethodDef pyopencv_reg_MapperGradEuclid_methods[] = |  | 85351 | static PyMethodDef pyopencv_reg_MapperGradEuclid_methods[] =
| 85400 | { |  | 85352 | {
| 85401 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradEuclid_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."}, |  | 85353 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradEuclid_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."},
| 85402 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradEuclid_getMap, 0), "getMap() -> retval\n."}, |  | 85354 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradEuclid_getMap, 0), "getMap() -> retval\n."},
| 85403 |  |  | 85355 |
| 85404 | {NULL, NULL} |  | 85356 | {NULL, NULL}
| 85405 | }; |  | 85357 | };
| 85406 |  |  | 85358 |
| 85407 | // Converter (reg_MapperGradEuclid) |  | 85359 | // Converter (reg_MapperGradEuclid)
| 85408 |  |  | 85360 |
| 85409 | template<> |  | 85361 | template<>
| 85410 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradEuclid> > |  | 85362 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradEuclid> >
| 85411 | { |  | 85363 | {
| 85412 | static PyObject* from(const Ptr<cv::reg::MapperGradEuclid>& r) |  | 85364 | static PyObject* from(const Ptr<cv::reg::MapperGradEuclid>& r)
| 85413 | { |  | 85365 | {
| 85414 | return pyopencv_reg_MapperGradEuclid_Instance(r); |  | 85366 | return pyopencv_reg_MapperGradEuclid_Instance(r);
| 85415 | } |  | 85367 | }
| 85416 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradEuclid>& dst, const ArgInfo& info) |  | 85368 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradEuclid>& dst, const ArgInfo& info)
| 85417 | { |  | 85369 | {
| 85418 | if(!src || src == Py_None) |  | 85370 | if(!src || src == Py_None)
| 85419 | return true; |  | 85371 | return true;
| 85420 | Ptr<cv::reg::MapperGradEuclid> * dst_; |  | 85372 | Ptr<cv::reg::MapperGradEuclid> * dst_;
| 85421 | if (pyopencv_reg_MapperGradEuclid_getp(src, dst_)) |  | 85373 | if (pyopencv_reg_MapperGradEuclid_getp(src, dst_))
| 85422 | { |  | 85374 | {
| 85423 | dst = *dst_; |  | 85375 | dst = *dst_;
| 85424 | return true; |  | 85376 | return true;
| 85425 | } |  | 85377 | }
| 85426 |  |  | 85378 |
| 85427 | failmsg("Expected Ptr<cv::reg::MapperGradEuclid> for argument '%s'", info.name); |  | 85379 | failmsg("Expected Ptr<cv::reg::MapperGradEuclid> for argument '%s'", info.name);
| 85428 | return false; |  | 85380 | return false;
| 85429 | } |  | 85381 | }
| 85430 | }; |  | 85382 | };
| 85431 |  |  | 85383 |
| 85432 | //================================================================================ |  | 85384 | //================================================================================
| 85433 | // reg_MapperGradProj (Generic) |  | 85385 | // reg_MapperGradProj (Generic)
| 85434 | //================================================================================ |  | 85386 | //================================================================================
| 85435 |  |  | 85387 |
| 85436 | // GetSet (reg_MapperGradProj) |  | 85388 | // GetSet (reg_MapperGradProj)
| 85437 |  |  | 85389 |
| 85438 |  |  | 85390 |
| 85439 |  |  | 85391 |
| 85440 | // Methods (reg_MapperGradProj) |  | 85392 | // Methods (reg_MapperGradProj)
| 85441 |  |  | 85393 |
| 85442 | static int pyopencv_cv_reg_reg_MapperGradProj_MapperGradProj(pyopencv_reg_MapperGradProj_t* self, PyObject* py_args, PyObject* kw) |  | 85394 | static int pyopencv_cv_reg_reg_MapperGradProj_MapperGradProj(pyopencv_reg_MapperGradProj_t* self, PyObject* py_args, PyObject* kw)
| 85443 | { |  | 85395 | {
| 85444 | using namespace cv::reg; |  | 85396 | using namespace cv::reg;
| 85445 |  |  | 85397 |
| 85446 |  |  | 85398 |
| 85447 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85399 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85448 | { |  | 85400 | {
| 85449 | new (&(self->v)) Ptr<cv::reg::MapperGradProj>(); // init Ptr with placement new |  | 85401 | new (&(self->v)) Ptr<cv::reg::MapperGradProj>(); // init Ptr with placement new
| 85450 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradProj())); |  | 85402 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradProj()));
| 85451 | return 0; |  | 85403 | return 0;
| 85452 | } |  | 85404 | }
| 85453 |  |  | 85405 |
| 85454 | return -1; |  | 85406 | return -1;
| 85455 | } |  | 85407 | }
| 85456 |  |  | 85408 |
| 85457 | static PyObject* pyopencv_cv_reg_reg_MapperGradProj_calculate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85409 | static PyObject* pyopencv_cv_reg_reg_MapperGradProj_calculate(PyObject* self, PyObject* py_args, PyObject* kw)
| 85458 | { |  | 85410 | {
| 85459 | using namespace cv::reg; |  | 85411 | using namespace cv::reg;
| 85460 |  |  | 85412 |
| 85461 |  |  | 85413 |
| 85462 | Ptr<cv::reg::MapperGradProj> * self1 = 0; |  | 85414 | Ptr<cv::reg::MapperGradProj> * self1 = 0;
| 85463 | if (!pyopencv_reg_MapperGradProj_getp(self, self1)) |  | 85415 | if (!pyopencv_reg_MapperGradProj_getp(self, self1))
| 85464 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradProj' or its derivative)"); |  | 85416 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradProj' or its derivative)");
| 85465 | Ptr<cv::reg::MapperGradProj> _self_ = *(self1); |  | 85417 | Ptr<cv::reg::MapperGradProj> _self_ = *(self1);
| 85466 | pyPrepareArgumentConversionErrorsStorage(2); |  | 85418 | pyPrepareArgumentConversionErrorsStorage(2);
| 85467 |  |  | 85419 |
| 85468 | { |  | 85420 | {
| 85469 | PyObject* pyobj_img1 = NULL; |  | 85421 | PyObject* pyobj_img1 = NULL;
| 85470 | Mat img1; |  | 85422 | Mat img1;
| 85471 | PyObject* pyobj_img2 = NULL; |  | 85423 | PyObject* pyobj_img2 = NULL;
| 85472 | Mat img2; |  | 85424 | Mat img2;
| 85473 | PyObject* pyobj_init = NULL; |  | 85425 | PyObject* pyobj_init = NULL;
| 85474 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85426 | Ptr<Map> init=cv::Ptr<Map>();
| 85475 | cv::Ptr<Map> retval; |  | 85427 | cv::Ptr<Map> retval;
| 85476 |  |  | 85428 |
| 85477 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85429 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85478 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradProj.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85430 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradProj.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85479 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85431 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85480 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85432 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85481 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85433 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85482 | { |  | 85434 | {
| 85483 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85435 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85484 | return pyopencv_from(retval); |  | 85436 | return pyopencv_from(retval);
| 85485 | } |  | 85437 | }
| 85486 |  |  | 85438 |
| 85487 |  |  | 85439 |
| 85488 | pyPopulateArgumentConversionErrors(); |  | 85440 | pyPopulateArgumentConversionErrors();
| 85489 | } |  | 85441 | }
| 85490 |  |  | 85442 |
| 85491 |  |  | 85443 |
| 85492 | { |  | 85444 | {
| 85493 | PyObject* pyobj_img1 = NULL; |  | 85445 | PyObject* pyobj_img1 = NULL;
| 85494 | UMat img1; |  | 85446 | UMat img1;
| 85495 | PyObject* pyobj_img2 = NULL; |  | 85447 | PyObject* pyobj_img2 = NULL;
| 85496 | UMat img2; |  | 85448 | UMat img2;
| 85497 | PyObject* pyobj_init = NULL; |  | 85449 | PyObject* pyobj_init = NULL;
| 85498 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85450 | Ptr<Map> init=cv::Ptr<Map>();
| 85499 | cv::Ptr<Map> retval; |  | 85451 | cv::Ptr<Map> retval;
| 85500 |  |  | 85452 |
| 85501 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85453 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85502 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradProj.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85454 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradProj.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85503 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85455 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85504 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85456 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85505 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85457 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85506 | { |  | 85458 | {
| 85507 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85459 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85508 | return pyopencv_from(retval); |  | 85460 | return pyopencv_from(retval);
| 85509 | } |  | 85461 | }
| 85510 |  |  | 85462 |
| 85511 |  |  | 85463 |
| 85512 | pyPopulateArgumentConversionErrors(); |  | 85464 | pyPopulateArgumentConversionErrors();
| 85513 | } |  | 85465 | }
| 85514 | pyRaiseCVOverloadException("calculate"); |  | 85466 | pyRaiseCVOverloadException("calculate");
| 85515 |  |  | 85467 |
| 85516 | return NULL; |  | 85468 | return NULL;
| 85517 | } |  | 85469 | }
| 85518 |  |  | 85470 |
| 85519 | static PyObject* pyopencv_cv_reg_reg_MapperGradProj_getMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85471 | static PyObject* pyopencv_cv_reg_reg_MapperGradProj_getMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 85520 | { |  | 85472 | {
| 85521 | using namespace cv::reg; |  | 85473 | using namespace cv::reg;
| 85522 |  |  | 85474 |
| 85523 |  |  | 85475 |
| 85524 | Ptr<cv::reg::MapperGradProj> * self1 = 0; |  | 85476 | Ptr<cv::reg::MapperGradProj> * self1 = 0;
| 85525 | if (!pyopencv_reg_MapperGradProj_getp(self, self1)) |  | 85477 | if (!pyopencv_reg_MapperGradProj_getp(self, self1))
| 85526 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradProj' or its derivative)"); |  | 85478 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradProj' or its derivative)");
| 85527 | Ptr<cv::reg::MapperGradProj> _self_ = *(self1); |  | 85479 | Ptr<cv::reg::MapperGradProj> _self_ = *(self1);
| 85528 | cv::Ptr<Map> retval; |  | 85480 | cv::Ptr<Map> retval;
| 85529 |  |  | 85481 |
| 85530 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85482 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85531 | { |  | 85483 | {
| 85532 | ERRWRAP2(retval = _self_->getMap()); |  | 85484 | ERRWRAP2(retval = _self_->getMap());
| 85533 | return pyopencv_from(retval); |  | 85485 | return pyopencv_from(retval);
| 85534 | } |  | 85486 | }
| 85535 |  |  | 85487 |
| 85536 | return NULL; |  | 85488 | return NULL;
| 85537 | } |  | 85489 | }
| 85538 |  |  | 85490 |
| 85539 |  |  | 85491 |
| 85540 |  |  | 85492 |
| 85541 | // Tables (reg_MapperGradProj) |  | 85493 | // Tables (reg_MapperGradProj)
| 85542 |  |  | 85494 |
| 85543 | static PyGetSetDef pyopencv_reg_MapperGradProj_getseters[] = |  | 85495 | static PyGetSetDef pyopencv_reg_MapperGradProj_getseters[] =
| 85544 | { |  | 85496 | {
| 85545 | {NULL} /* Sentinel */ |  | 85497 | {NULL} /* Sentinel */
| 85546 | }; |  | 85498 | };
| 85547 |  |  | 85499 |
| 85548 | static PyMethodDef pyopencv_reg_MapperGradProj_methods[] = |  | 85500 | static PyMethodDef pyopencv_reg_MapperGradProj_methods[] =
| 85549 | { |  | 85501 | {
| 85550 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradProj_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."}, |  | 85502 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradProj_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."},
| 85551 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradProj_getMap, 0), "getMap() -> retval\n."}, |  | 85503 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradProj_getMap, 0), "getMap() -> retval\n."},
| 85552 |  |  | 85504 |
| 85553 | {NULL, NULL} |  | 85505 | {NULL, NULL}
| 85554 | }; |  | 85506 | };
| 85555 |  |  | 85507 |
| 85556 | // Converter (reg_MapperGradProj) |  | 85508 | // Converter (reg_MapperGradProj)
| 85557 |  |  | 85509 |
| 85558 | template<> |  | 85510 | template<>
| 85559 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradProj> > |  | 85511 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradProj> >
| 85560 | { |  | 85512 | {
| 85561 | static PyObject* from(const Ptr<cv::reg::MapperGradProj>& r) |  | 85513 | static PyObject* from(const Ptr<cv::reg::MapperGradProj>& r)
| 85562 | { |  | 85514 | {
| 85563 | return pyopencv_reg_MapperGradProj_Instance(r); |  | 85515 | return pyopencv_reg_MapperGradProj_Instance(r);
| 85564 | } |  | 85516 | }
| 85565 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradProj>& dst, const ArgInfo& info) |  | 85517 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradProj>& dst, const ArgInfo& info)
| 85566 | { |  | 85518 | {
| 85567 | if(!src || src == Py_None) |  | 85519 | if(!src || src == Py_None)
| 85568 | return true; |  | 85520 | return true;
| 85569 | Ptr<cv::reg::MapperGradProj> * dst_; |  | 85521 | Ptr<cv::reg::MapperGradProj> * dst_;
| 85570 | if (pyopencv_reg_MapperGradProj_getp(src, dst_)) |  | 85522 | if (pyopencv_reg_MapperGradProj_getp(src, dst_))
| 85571 | { |  | 85523 | {
| 85572 | dst = *dst_; |  | 85524 | dst = *dst_;
| 85573 | return true; |  | 85525 | return true;
| 85574 | } |  | 85526 | }
| 85575 |  |  | 85527 |
| 85576 | failmsg("Expected Ptr<cv::reg::MapperGradProj> for argument '%s'", info.name); |  | 85528 | failmsg("Expected Ptr<cv::reg::MapperGradProj> for argument '%s'", info.name);
| 85577 | return false; |  | 85529 | return false;
| 85578 | } |  | 85530 | }
| 85579 | }; |  | 85531 | };
| 85580 |  |  | 85532 |
| 85581 | //================================================================================ |  | 85533 | //================================================================================
| 85582 | // reg_MapperGradShift (Generic) |  | 85534 | // reg_MapperGradShift (Generic)
| 85583 | //================================================================================ |  | 85535 | //================================================================================
| 85584 |  |  | 85536 |
| 85585 | // GetSet (reg_MapperGradShift) |  | 85537 | // GetSet (reg_MapperGradShift)
| 85586 |  |  | 85538 |
| 85587 |  |  | 85539 |
| 85588 |  |  | 85540 |
| 85589 | // Methods (reg_MapperGradShift) |  | 85541 | // Methods (reg_MapperGradShift)
| 85590 |  |  | 85542 |
| 85591 | static int pyopencv_cv_reg_reg_MapperGradShift_MapperGradShift(pyopencv_reg_MapperGradShift_t* self, PyObject* py_args, PyObject* kw) |  | 85543 | static int pyopencv_cv_reg_reg_MapperGradShift_MapperGradShift(pyopencv_reg_MapperGradShift_t* self, PyObject* py_args, PyObject* kw)
| 85592 | { |  | 85544 | {
| 85593 | using namespace cv::reg; |  | 85545 | using namespace cv::reg;
| 85594 |  |  | 85546 |
| 85595 |  |  | 85547 |
| 85596 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85548 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85597 | { |  | 85549 | {
| 85598 | new (&(self->v)) Ptr<cv::reg::MapperGradShift>(); // init Ptr with placement new |  | 85550 | new (&(self->v)) Ptr<cv::reg::MapperGradShift>(); // init Ptr with placement new
| 85599 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradShift())); |  | 85551 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradShift()));
| 85600 | return 0; |  | 85552 | return 0;
| 85601 | } |  | 85553 | }
| 85602 |  |  | 85554 |
| 85603 | return -1; |  | 85555 | return -1;
| 85604 | } |  | 85556 | }
| 85605 |  |  | 85557 |
| 85606 | static PyObject* pyopencv_cv_reg_reg_MapperGradShift_calculate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85558 | static PyObject* pyopencv_cv_reg_reg_MapperGradShift_calculate(PyObject* self, PyObject* py_args, PyObject* kw)
| 85607 | { |  | 85559 | {
| 85608 | using namespace cv::reg; |  | 85560 | using namespace cv::reg;
| 85609 |  |  | 85561 |
| 85610 |  |  | 85562 |
| 85611 | Ptr<cv::reg::MapperGradShift> * self1 = 0; |  | 85563 | Ptr<cv::reg::MapperGradShift> * self1 = 0;
| 85612 | if (!pyopencv_reg_MapperGradShift_getp(self, self1)) |  | 85564 | if (!pyopencv_reg_MapperGradShift_getp(self, self1))
| 85613 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradShift' or its derivative)"); |  | 85565 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradShift' or its derivative)");
| 85614 | Ptr<cv::reg::MapperGradShift> _self_ = *(self1); |  | 85566 | Ptr<cv::reg::MapperGradShift> _self_ = *(self1);
| 85615 | pyPrepareArgumentConversionErrorsStorage(2); |  | 85567 | pyPrepareArgumentConversionErrorsStorage(2);
| 85616 |  |  | 85568 |
| 85617 | { |  | 85569 | {
| 85618 | PyObject* pyobj_img1 = NULL; |  | 85570 | PyObject* pyobj_img1 = NULL;
| 85619 | Mat img1; |  | 85571 | Mat img1;
| 85620 | PyObject* pyobj_img2 = NULL; |  | 85572 | PyObject* pyobj_img2 = NULL;
| 85621 | Mat img2; |  | 85573 | Mat img2;
| 85622 | PyObject* pyobj_init = NULL; |  | 85574 | PyObject* pyobj_init = NULL;
| 85623 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85575 | Ptr<Map> init=cv::Ptr<Map>();
| 85624 | cv::Ptr<Map> retval; |  | 85576 | cv::Ptr<Map> retval;
| 85625 |  |  | 85577 |
| 85626 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85578 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85627 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradShift.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85579 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradShift.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85628 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85580 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85629 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85581 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85630 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85582 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85631 | { |  | 85583 | {
| 85632 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85584 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85633 | return pyopencv_from(retval); |  | 85585 | return pyopencv_from(retval);
| 85634 | } |  | 85586 | }
| 85635 |  |  | 85587 |
| 85636 |  |  | 85588 |
| 85637 | pyPopulateArgumentConversionErrors(); |  | 85589 | pyPopulateArgumentConversionErrors();
| 85638 | } |  | 85590 | }
| 85639 |  |  | 85591 |
| 85640 |  |  | 85592 |
| 85641 | { |  | 85593 | {
| 85642 | PyObject* pyobj_img1 = NULL; |  | 85594 | PyObject* pyobj_img1 = NULL;
| 85643 | UMat img1; |  | 85595 | UMat img1;
| 85644 | PyObject* pyobj_img2 = NULL; |  | 85596 | PyObject* pyobj_img2 = NULL;
| 85645 | UMat img2; |  | 85597 | UMat img2;
| 85646 | PyObject* pyobj_init = NULL; |  | 85598 | PyObject* pyobj_init = NULL;
| 85647 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85599 | Ptr<Map> init=cv::Ptr<Map>();
| 85648 | cv::Ptr<Map> retval; |  | 85600 | cv::Ptr<Map> retval;
| 85649 |  |  | 85601 |
| 85650 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85602 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85651 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradShift.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85603 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradShift.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85652 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85604 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85653 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85605 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85654 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85606 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85655 | { |  | 85607 | {
| 85656 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85608 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85657 | return pyopencv_from(retval); |  | 85609 | return pyopencv_from(retval);
| 85658 | } |  | 85610 | }
| 85659 |  |  | 85611 |
| 85660 |  |  | 85612 |
| 85661 | pyPopulateArgumentConversionErrors(); |  | 85613 | pyPopulateArgumentConversionErrors();
| 85662 | } |  | 85614 | }
| 85663 | pyRaiseCVOverloadException("calculate"); |  | 85615 | pyRaiseCVOverloadException("calculate");
| 85664 |  |  | 85616 |
| 85665 | return NULL; |  | 85617 | return NULL;
| 85666 | } |  | 85618 | }
| 85667 |  |  | 85619 |
| 85668 | static PyObject* pyopencv_cv_reg_reg_MapperGradShift_getMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85620 | static PyObject* pyopencv_cv_reg_reg_MapperGradShift_getMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 85669 | { |  | 85621 | {
| 85670 | using namespace cv::reg; |  | 85622 | using namespace cv::reg;
| 85671 |  |  | 85623 |
| 85672 |  |  | 85624 |
| 85673 | Ptr<cv::reg::MapperGradShift> * self1 = 0; |  | 85625 | Ptr<cv::reg::MapperGradShift> * self1 = 0;
| 85674 | if (!pyopencv_reg_MapperGradShift_getp(self, self1)) |  | 85626 | if (!pyopencv_reg_MapperGradShift_getp(self, self1))
| 85675 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradShift' or its derivative)"); |  | 85627 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradShift' or its derivative)");
| 85676 | Ptr<cv::reg::MapperGradShift> _self_ = *(self1); |  | 85628 | Ptr<cv::reg::MapperGradShift> _self_ = *(self1);
| 85677 | cv::Ptr<Map> retval; |  | 85629 | cv::Ptr<Map> retval;
| 85678 |  |  | 85630 |
| 85679 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85631 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85680 | { |  | 85632 | {
| 85681 | ERRWRAP2(retval = _self_->getMap()); |  | 85633 | ERRWRAP2(retval = _self_->getMap());
| 85682 | return pyopencv_from(retval); |  | 85634 | return pyopencv_from(retval);
| 85683 | } |  | 85635 | }
| 85684 |  |  | 85636 |
| 85685 | return NULL; |  | 85637 | return NULL;
| 85686 | } |  | 85638 | }
| 85687 |  |  | 85639 |
| 85688 |  |  | 85640 |
| 85689 |  |  | 85641 |
| 85690 | // Tables (reg_MapperGradShift) |  | 85642 | // Tables (reg_MapperGradShift)
| 85691 |  |  | 85643 |
| 85692 | static PyGetSetDef pyopencv_reg_MapperGradShift_getseters[] = |  | 85644 | static PyGetSetDef pyopencv_reg_MapperGradShift_getseters[] =
| 85693 | { |  | 85645 | {
| 85694 | {NULL} /* Sentinel */ |  | 85646 | {NULL} /* Sentinel */
| 85695 | }; |  | 85647 | };
| 85696 |  |  | 85648 |
| 85697 | static PyMethodDef pyopencv_reg_MapperGradShift_methods[] = |  | 85649 | static PyMethodDef pyopencv_reg_MapperGradShift_methods[] =
| 85698 | { |  | 85650 | {
| 85699 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradShift_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."}, |  | 85651 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradShift_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."},
| 85700 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradShift_getMap, 0), "getMap() -> retval\n."}, |  | 85652 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradShift_getMap, 0), "getMap() -> retval\n."},
| 85701 |  |  | 85653 |
| 85702 | {NULL, NULL} |  | 85654 | {NULL, NULL}
| 85703 | }; |  | 85655 | };
| 85704 |  |  | 85656 |
| 85705 | // Converter (reg_MapperGradShift) |  | 85657 | // Converter (reg_MapperGradShift)
| 85706 |  |  | 85658 |
| 85707 | template<> |  | 85659 | template<>
| 85708 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradShift> > |  | 85660 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradShift> >
| 85709 | { |  | 85661 | {
| 85710 | static PyObject* from(const Ptr<cv::reg::MapperGradShift>& r) |  | 85662 | static PyObject* from(const Ptr<cv::reg::MapperGradShift>& r)
| 85711 | { |  | 85663 | {
| 85712 | return pyopencv_reg_MapperGradShift_Instance(r); |  | 85664 | return pyopencv_reg_MapperGradShift_Instance(r);
| 85713 | } |  | 85665 | }
| 85714 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradShift>& dst, const ArgInfo& info) |  | 85666 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradShift>& dst, const ArgInfo& info)
| 85715 | { |  | 85667 | {
| 85716 | if(!src || src == Py_None) |  | 85668 | if(!src || src == Py_None)
| 85717 | return true; |  | 85669 | return true;
| 85718 | Ptr<cv::reg::MapperGradShift> * dst_; |  | 85670 | Ptr<cv::reg::MapperGradShift> * dst_;
| 85719 | if (pyopencv_reg_MapperGradShift_getp(src, dst_)) |  | 85671 | if (pyopencv_reg_MapperGradShift_getp(src, dst_))
| 85720 | { |  | 85672 | {
| 85721 | dst = *dst_; |  | 85673 | dst = *dst_;
| 85722 | return true; |  | 85674 | return true;
| 85723 | } |  | 85675 | }
| 85724 |  |  | 85676 |
| 85725 | failmsg("Expected Ptr<cv::reg::MapperGradShift> for argument '%s'", info.name); |  | 85677 | failmsg("Expected Ptr<cv::reg::MapperGradShift> for argument '%s'", info.name);
| 85726 | return false; |  | 85678 | return false;
| 85727 | } |  | 85679 | }
| 85728 | }; |  | 85680 | };
| 85729 |  |  | 85681 |
| 85730 | //================================================================================ |  | 85682 | //================================================================================
| 85731 | // reg_MapperGradSimilar (Generic) |  | 85683 | // reg_MapperGradSimilar (Generic)
| 85732 | //================================================================================ |  | 85684 | //================================================================================
| 85733 |  |  | 85685 |
| 85734 | // GetSet (reg_MapperGradSimilar) |  | 85686 | // GetSet (reg_MapperGradSimilar)
| 85735 |  |  | 85687 |
| 85736 |  |  | 85688 |
| 85737 |  |  | 85689 |
| 85738 | // Methods (reg_MapperGradSimilar) |  | 85690 | // Methods (reg_MapperGradSimilar)
| 85739 |  |  | 85691 |
| 85740 | static int pyopencv_cv_reg_reg_MapperGradSimilar_MapperGradSimilar(pyopencv_reg_MapperGradSimilar_t* self, PyObject* py_args, PyObject* kw) |  | 85692 | static int pyopencv_cv_reg_reg_MapperGradSimilar_MapperGradSimilar(pyopencv_reg_MapperGradSimilar_t* self, PyObject* py_args, PyObject* kw)
| 85741 | { |  | 85693 | {
| 85742 | using namespace cv::reg; |  | 85694 | using namespace cv::reg;
| 85743 |  |  | 85695 |
| 85744 |  |  | 85696 |
| 85745 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85697 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85746 | { |  | 85698 | {
| 85747 | new (&(self->v)) Ptr<cv::reg::MapperGradSimilar>(); // init Ptr with placement new |  | 85699 | new (&(self->v)) Ptr<cv::reg::MapperGradSimilar>(); // init Ptr with placement new
| 85748 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradSimilar())); |  | 85700 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperGradSimilar()));
| 85749 | return 0; |  | 85701 | return 0;
| 85750 | } |  | 85702 | }
| 85751 |  |  | 85703 |
| 85752 | return -1; |  | 85704 | return -1;
| 85753 | } |  | 85705 | }
| 85754 |  |  | 85706 |
| 85755 | static PyObject* pyopencv_cv_reg_reg_MapperGradSimilar_calculate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85707 | static PyObject* pyopencv_cv_reg_reg_MapperGradSimilar_calculate(PyObject* self, PyObject* py_args, PyObject* kw)
| 85756 | { |  | 85708 | {
| 85757 | using namespace cv::reg; |  | 85709 | using namespace cv::reg;
| 85758 |  |  | 85710 |
| 85759 |  |  | 85711 |
| 85760 | Ptr<cv::reg::MapperGradSimilar> * self1 = 0; |  | 85712 | Ptr<cv::reg::MapperGradSimilar> * self1 = 0;
| 85761 | if (!pyopencv_reg_MapperGradSimilar_getp(self, self1)) |  | 85713 | if (!pyopencv_reg_MapperGradSimilar_getp(self, self1))
| 85762 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradSimilar' or its derivative)"); |  | 85714 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradSimilar' or its derivative)");
| 85763 | Ptr<cv::reg::MapperGradSimilar> _self_ = *(self1); |  | 85715 | Ptr<cv::reg::MapperGradSimilar> _self_ = *(self1);
| 85764 | pyPrepareArgumentConversionErrorsStorage(2); |  | 85716 | pyPrepareArgumentConversionErrorsStorage(2);
| 85765 |  |  | 85717 |
| 85766 | { |  | 85718 | {
| 85767 | PyObject* pyobj_img1 = NULL; |  | 85719 | PyObject* pyobj_img1 = NULL;
| 85768 | Mat img1; |  | 85720 | Mat img1;
| 85769 | PyObject* pyobj_img2 = NULL; |  | 85721 | PyObject* pyobj_img2 = NULL;
| 85770 | Mat img2; |  | 85722 | Mat img2;
| 85771 | PyObject* pyobj_init = NULL; |  | 85723 | PyObject* pyobj_init = NULL;
| 85772 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85724 | Ptr<Map> init=cv::Ptr<Map>();
| 85773 | cv::Ptr<Map> retval; |  | 85725 | cv::Ptr<Map> retval;
| 85774 |  |  | 85726 |
| 85775 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85727 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85776 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradSimilar.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85728 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradSimilar.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85777 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85729 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85778 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85730 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85779 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85731 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85780 | { |  | 85732 | {
| 85781 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85733 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85782 | return pyopencv_from(retval); |  | 85734 | return pyopencv_from(retval);
| 85783 | } |  | 85735 | }
| 85784 |  |  | 85736 |
| 85785 |  |  | 85737 |
| 85786 | pyPopulateArgumentConversionErrors(); |  | 85738 | pyPopulateArgumentConversionErrors();
| 85787 | } |  | 85739 | }
| 85788 |  |  | 85740 |
| 85789 |  |  | 85741 |
| 85790 | { |  | 85742 | {
| 85791 | PyObject* pyobj_img1 = NULL; |  | 85743 | PyObject* pyobj_img1 = NULL;
| 85792 | UMat img1; |  | 85744 | UMat img1;
| 85793 | PyObject* pyobj_img2 = NULL; |  | 85745 | PyObject* pyobj_img2 = NULL;
| 85794 | UMat img2; |  | 85746 | UMat img2;
| 85795 | PyObject* pyobj_init = NULL; |  | 85747 | PyObject* pyobj_init = NULL;
| 85796 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85748 | Ptr<Map> init=cv::Ptr<Map>();
| 85797 | cv::Ptr<Map> retval; |  | 85749 | cv::Ptr<Map> retval;
| 85798 |  |  | 85750 |
| 85799 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85751 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85800 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradSimilar.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85752 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperGradSimilar.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85801 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85753 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85802 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85754 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85803 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85755 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85804 | { |  | 85756 | {
| 85805 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85757 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85806 | return pyopencv_from(retval); |  | 85758 | return pyopencv_from(retval);
| 85807 | } |  | 85759 | }
| 85808 |  |  | 85760 |
| 85809 |  |  | 85761 |
| 85810 | pyPopulateArgumentConversionErrors(); |  | 85762 | pyPopulateArgumentConversionErrors();
| 85811 | } |  | 85763 | }
| 85812 | pyRaiseCVOverloadException("calculate"); |  | 85764 | pyRaiseCVOverloadException("calculate");
| 85813 |  |  | 85765 |
| 85814 | return NULL; |  | 85766 | return NULL;
| 85815 | } |  | 85767 | }
| 85816 |  |  | 85768 |
| 85817 | static PyObject* pyopencv_cv_reg_reg_MapperGradSimilar_getMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85769 | static PyObject* pyopencv_cv_reg_reg_MapperGradSimilar_getMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 85818 | { |  | 85770 | {
| 85819 | using namespace cv::reg; |  | 85771 | using namespace cv::reg;
| 85820 |  |  | 85772 |
| 85821 |  |  | 85773 |
| 85822 | Ptr<cv::reg::MapperGradSimilar> * self1 = 0; |  | 85774 | Ptr<cv::reg::MapperGradSimilar> * self1 = 0;
| 85823 | if (!pyopencv_reg_MapperGradSimilar_getp(self, self1)) |  | 85775 | if (!pyopencv_reg_MapperGradSimilar_getp(self, self1))
| 85824 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradSimilar' or its derivative)"); |  | 85776 | return failmsgp("Incorrect type of self (must be 'reg_MapperGradSimilar' or its derivative)");
| 85825 | Ptr<cv::reg::MapperGradSimilar> _self_ = *(self1); |  | 85777 | Ptr<cv::reg::MapperGradSimilar> _self_ = *(self1);
| 85826 | cv::Ptr<Map> retval; |  | 85778 | cv::Ptr<Map> retval;
| 85827 |  |  | 85779 |
| 85828 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85780 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 85829 | { |  | 85781 | {
| 85830 | ERRWRAP2(retval = _self_->getMap()); |  | 85782 | ERRWRAP2(retval = _self_->getMap());
| 85831 | return pyopencv_from(retval); |  | 85783 | return pyopencv_from(retval);
| 85832 | } |  | 85784 | }
| 85833 |  |  | 85785 |
| 85834 | return NULL; |  | 85786 | return NULL;
| 85835 | } |  | 85787 | }
| 85836 |  |  | 85788 |
| 85837 |  |  | 85789 |
| 85838 |  |  | 85790 |
| 85839 | // Tables (reg_MapperGradSimilar) |  | 85791 | // Tables (reg_MapperGradSimilar)
| 85840 |  |  | 85792 |
| 85841 | static PyGetSetDef pyopencv_reg_MapperGradSimilar_getseters[] = |  | 85793 | static PyGetSetDef pyopencv_reg_MapperGradSimilar_getseters[] =
| 85842 | { |  | 85794 | {
| 85843 | {NULL} /* Sentinel */ |  | 85795 | {NULL} /* Sentinel */
| 85844 | }; |  | 85796 | };
| 85845 |  |  | 85797 |
| 85846 | static PyMethodDef pyopencv_reg_MapperGradSimilar_methods[] = |  | 85798 | static PyMethodDef pyopencv_reg_MapperGradSimilar_methods[] =
| 85847 | { |  | 85799 | {
| 85848 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradSimilar_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."}, |  | 85800 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradSimilar_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."},
| 85849 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradSimilar_getMap, 0), "getMap() -> retval\n."}, |  | 85801 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperGradSimilar_getMap, 0), "getMap() -> retval\n."},
| 85850 |  |  | 85802 |
| 85851 | {NULL, NULL} |  | 85803 | {NULL, NULL}
| 85852 | }; |  | 85804 | };
| 85853 |  |  | 85805 |
| 85854 | // Converter (reg_MapperGradSimilar) |  | 85806 | // Converter (reg_MapperGradSimilar)
| 85855 |  |  | 85807 |
| 85856 | template<> |  | 85808 | template<>
| 85857 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradSimilar> > |  | 85809 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperGradSimilar> >
| 85858 | { |  | 85810 | {
| 85859 | static PyObject* from(const Ptr<cv::reg::MapperGradSimilar>& r) |  | 85811 | static PyObject* from(const Ptr<cv::reg::MapperGradSimilar>& r)
| 85860 | { |  | 85812 | {
| 85861 | return pyopencv_reg_MapperGradSimilar_Instance(r); |  | 85813 | return pyopencv_reg_MapperGradSimilar_Instance(r);
| 85862 | } |  | 85814 | }
| 85863 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradSimilar>& dst, const ArgInfo& info) |  | 85815 | static bool to(PyObject* src, Ptr<cv::reg::MapperGradSimilar>& dst, const ArgInfo& info)
| 85864 | { |  | 85816 | {
| 85865 | if(!src || src == Py_None) |  | 85817 | if(!src || src == Py_None)
| 85866 | return true; |  | 85818 | return true;
| 85867 | Ptr<cv::reg::MapperGradSimilar> * dst_; |  | 85819 | Ptr<cv::reg::MapperGradSimilar> * dst_;
| 85868 | if (pyopencv_reg_MapperGradSimilar_getp(src, dst_)) |  | 85820 | if (pyopencv_reg_MapperGradSimilar_getp(src, dst_))
| 85869 | { |  | 85821 | {
| 85870 | dst = *dst_; |  | 85822 | dst = *dst_;
| 85871 | return true; |  | 85823 | return true;
| 85872 | } |  | 85824 | }
| 85873 |  |  | 85825 |
| 85874 | failmsg("Expected Ptr<cv::reg::MapperGradSimilar> for argument '%s'", info.name); |  | 85826 | failmsg("Expected Ptr<cv::reg::MapperGradSimilar> for argument '%s'", info.name);
| 85875 | return false; |  | 85827 | return false;
| 85876 | } |  | 85828 | }
| 85877 | }; |  | 85829 | };
| 85878 |  |  | 85830 |
| 85879 | //================================================================================ |  | 85831 | //================================================================================
| 85880 | // reg_MapperPyramid (Generic) |  | 85832 | // reg_MapperPyramid (Generic)
| 85881 | //================================================================================ |  | 85833 | //================================================================================
| 85882 |  |  | 85834 |
| 85883 | // GetSet (reg_MapperPyramid) |  | 85835 | // GetSet (reg_MapperPyramid)
| 85884 |  |  | 85836 |
| 85885 |  |  | 85837 |
| 85886 | static PyObject* pyopencv_reg_MapperPyramid_get_numIterPerScale_(pyopencv_reg_MapperPyramid_t* p, void *closure) |  | 85838 | static PyObject* pyopencv_reg_MapperPyramid_get_numIterPerScale_(pyopencv_reg_MapperPyramid_t* p, void *closure)
| 85887 | { |  | 85839 | {
| 85888 | return pyopencv_from(p->v->numIterPerScale_); |  | 85840 | return pyopencv_from(p->v->numIterPerScale_);
| 85889 | } |  | 85841 | }
| 85890 |  |  | 85842 |
| 85891 | static int pyopencv_reg_MapperPyramid_set_numIterPerScale_(pyopencv_reg_MapperPyramid_t* p, PyObject *value, void *closure) |  | 85843 | static int pyopencv_reg_MapperPyramid_set_numIterPerScale_(pyopencv_reg_MapperPyramid_t* p, PyObject *value, void *closure)
| 85892 | { |  | 85844 | {
| 85893 | if (!value) |  | 85845 | if (!value)
| 85894 | { |  | 85846 | {
| 85895 | PyErr_SetString(PyExc_TypeError, "Cannot delete the numIterPerScale_ attribute"); |  | 85847 | PyErr_SetString(PyExc_TypeError, "Cannot delete the numIterPerScale_ attribute");
| 85896 | return -1; |  | 85848 | return -1;
| 85897 | } |  | 85849 | }
| 85898 | return pyopencv_to_safe(value, p->v->numIterPerScale_, ArgInfo("value", 0)) ? 0 : -1; |  | 85850 | return pyopencv_to_safe(value, p->v->numIterPerScale_, ArgInfo("value", 0)) ? 0 : -1;
| 85899 | } |  | 85851 | }
| 85900 |  |  | 85852 |
| 85901 | static PyObject* pyopencv_reg_MapperPyramid_get_numLev_(pyopencv_reg_MapperPyramid_t* p, void *closure) |  | 85853 | static PyObject* pyopencv_reg_MapperPyramid_get_numLev_(pyopencv_reg_MapperPyramid_t* p, void *closure)
| 85902 | { |  | 85854 | {
| 85903 | return pyopencv_from(p->v->numLev_); |  | 85855 | return pyopencv_from(p->v->numLev_);
| 85904 | } |  | 85856 | }
| 85905 |  |  | 85857 |
| 85906 | static int pyopencv_reg_MapperPyramid_set_numLev_(pyopencv_reg_MapperPyramid_t* p, PyObject *value, void *closure) |  | 85858 | static int pyopencv_reg_MapperPyramid_set_numLev_(pyopencv_reg_MapperPyramid_t* p, PyObject *value, void *closure)
| 85907 | { |  | 85859 | {
| 85908 | if (!value) |  | 85860 | if (!value)
| 85909 | { |  | 85861 | {
| 85910 | PyErr_SetString(PyExc_TypeError, "Cannot delete the numLev_ attribute"); |  | 85862 | PyErr_SetString(PyExc_TypeError, "Cannot delete the numLev_ attribute");
| 85911 | return -1; |  | 85863 | return -1;
| 85912 | } |  | 85864 | }
| 85913 | return pyopencv_to_safe(value, p->v->numLev_, ArgInfo("value", 0)) ? 0 : -1; |  | 85865 | return pyopencv_to_safe(value, p->v->numLev_, ArgInfo("value", 0)) ? 0 : -1;
| 85914 | } |  | 85866 | }
| 85915 |  |  | 85867 |
| 85916 |  |  | 85868 |
| 85917 | // Methods (reg_MapperPyramid) |  | 85869 | // Methods (reg_MapperPyramid)
| 85918 |  |  | 85870 |
| 85919 | static int pyopencv_cv_reg_reg_MapperPyramid_MapperPyramid(pyopencv_reg_MapperPyramid_t* self, PyObject* py_args, PyObject* kw) |  | 85871 | static int pyopencv_cv_reg_reg_MapperPyramid_MapperPyramid(pyopencv_reg_MapperPyramid_t* self, PyObject* py_args, PyObject* kw)
| 85920 | { |  | 85872 | {
| 85921 | using namespace cv::reg; |  | 85873 | using namespace cv::reg;
| 85922 |  |  | 85874 |
| 85923 | PyObject* pyobj_baseMapper = NULL; |  | 85875 | PyObject* pyobj_baseMapper = NULL;
| 85924 | Ptr<Mapper> baseMapper; |  | 85876 | Ptr<Mapper> baseMapper;
| 85925 |  |  | 85877 |
| 85926 | const char* keywords[] = { "baseMapper", NULL }; |  | 85878 | const char* keywords[] = { "baseMapper", NULL };
| 85927 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapperPyramid", (char**)keywords, &pyobj_baseMapper) && |  | 85879 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:MapperPyramid", (char**)keywords, &pyobj_baseMapper) &&
| 85928 | pyopencv_to_safe(pyobj_baseMapper, baseMapper, ArgInfo("baseMapper", 0)) ) |  | 85880 | pyopencv_to_safe(pyobj_baseMapper, baseMapper, ArgInfo("baseMapper", 0)) )
| 85929 | { |  | 85881 | {
| 85930 | new (&(self->v)) Ptr<cv::reg::MapperPyramid>(); // init Ptr with placement new |  | 85882 | new (&(self->v)) Ptr<cv::reg::MapperPyramid>(); // init Ptr with placement new
| 85931 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperPyramid(baseMapper))); |  | 85883 | if(self) ERRWRAP2(self->v.reset(new cv::reg::MapperPyramid(baseMapper)));
| 85932 | return 0; |  | 85884 | return 0;
| 85933 | } |  | 85885 | }
| 85934 |  |  | 85886 |
| 85935 | return -1; |  | 85887 | return -1;
| 85936 | } |  | 85888 | }
| 85937 |  |  | 85889 |
| 85938 | static PyObject* pyopencv_cv_reg_reg_MapperPyramid_calculate(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85890 | static PyObject* pyopencv_cv_reg_reg_MapperPyramid_calculate(PyObject* self, PyObject* py_args, PyObject* kw)
| 85939 | { |  | 85891 | {
| 85940 | using namespace cv::reg; |  | 85892 | using namespace cv::reg;
| 85941 |  |  | 85893 |
| 85942 |  |  | 85894 |
| 85943 | Ptr<cv::reg::MapperPyramid> * self1 = 0; |  | 85895 | Ptr<cv::reg::MapperPyramid> * self1 = 0;
| 85944 | if (!pyopencv_reg_MapperPyramid_getp(self, self1)) |  | 85896 | if (!pyopencv_reg_MapperPyramid_getp(self, self1))
| 85945 | return failmsgp("Incorrect type of self (must be 'reg_MapperPyramid' or its derivative)"); |  | 85897 | return failmsgp("Incorrect type of self (must be 'reg_MapperPyramid' or its derivative)");
| 85946 | Ptr<cv::reg::MapperPyramid> _self_ = *(self1); |  | 85898 | Ptr<cv::reg::MapperPyramid> _self_ = *(self1);
| 85947 | pyPrepareArgumentConversionErrorsStorage(2); |  | 85899 | pyPrepareArgumentConversionErrorsStorage(2);
| 85948 |  |  | 85900 |
| 85949 | { |  | 85901 | {
| 85950 | PyObject* pyobj_img1 = NULL; |  | 85902 | PyObject* pyobj_img1 = NULL;
| 85951 | Mat img1; |  | 85903 | Mat img1;
| 85952 | PyObject* pyobj_img2 = NULL; |  | 85904 | PyObject* pyobj_img2 = NULL;
| 85953 | Mat img2; |  | 85905 | Mat img2;
| 85954 | PyObject* pyobj_init = NULL; |  | 85906 | PyObject* pyobj_init = NULL;
| 85955 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85907 | Ptr<Map> init=cv::Ptr<Map>();
| 85956 | cv::Ptr<Map> retval; |  | 85908 | cv::Ptr<Map> retval;
| 85957 |  |  | 85909 |
| 85958 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85910 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85959 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperPyramid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85911 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperPyramid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85960 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85912 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85961 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85913 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85962 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85914 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85963 | { |  | 85915 | {
| 85964 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85916 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85965 | return pyopencv_from(retval); |  | 85917 | return pyopencv_from(retval);
| 85966 | } |  | 85918 | }
| 85967 |  |  | 85919 |
| 85968 |  |  | 85920 |
| 85969 | pyPopulateArgumentConversionErrors(); |  | 85921 | pyPopulateArgumentConversionErrors();
| 85970 | } |  | 85922 | }
| 85971 |  |  | 85923 |
| 85972 |  |  | 85924 |
| 85973 | { |  | 85925 | {
| 85974 | PyObject* pyobj_img1 = NULL; |  | 85926 | PyObject* pyobj_img1 = NULL;
| 85975 | UMat img1; |  | 85927 | UMat img1;
| 85976 | PyObject* pyobj_img2 = NULL; |  | 85928 | PyObject* pyobj_img2 = NULL;
| 85977 | UMat img2; |  | 85929 | UMat img2;
| 85978 | PyObject* pyobj_init = NULL; |  | 85930 | PyObject* pyobj_init = NULL;
| 85979 | Ptr<Map> init=cv::Ptr<Map>(); |  | 85931 | Ptr<Map> init=cv::Ptr<Map>();
| 85980 | cv::Ptr<Map> retval; |  | 85932 | cv::Ptr<Map> retval;
| 85981 |  |  | 85933 |
| 85982 | const char* keywords[] = { "img1", "img2", "init", NULL }; |  | 85934 | const char* keywords[] = { "img1", "img2", "init", NULL };
| 85983 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperPyramid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) && |  | 85935 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|O:reg_MapperPyramid.calculate", (char**)keywords, &pyobj_img1, &pyobj_img2, &pyobj_init) &&
| 85984 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) && |  | 85936 | pyopencv_to_safe(pyobj_img1, img1, ArgInfo("img1", 0)) &&
| 85985 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) && |  | 85937 | pyopencv_to_safe(pyobj_img2, img2, ArgInfo("img2", 0)) &&
| 85986 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) ) |  | 85938 | pyopencv_to_safe(pyobj_init, init, ArgInfo("init", 0)) )
| 85987 | { |  | 85939 | {
| 85988 | ERRWRAP2(retval = _self_->calculate(img1, img2, init)); |  | 85940 | ERRWRAP2(retval = _self_->calculate(img1, img2, init));
| 85989 | return pyopencv_from(retval); |  | 85941 | return pyopencv_from(retval);
| 85990 | } |  | 85942 | }
| 85991 |  |  | 85943 |
| 85992 |  |  | 85944 |
| 85993 | pyPopulateArgumentConversionErrors(); |  | 85945 | pyPopulateArgumentConversionErrors();
| 85994 | } |  | 85946 | }
| 85995 | pyRaiseCVOverloadException("calculate"); |  | 85947 | pyRaiseCVOverloadException("calculate");
| 85996 |  |  | 85948 |
| 85997 | return NULL; |  | 85949 | return NULL;
| 85998 | } |  | 85950 | }
| 85999 |  |  | 85951 |
| 86000 | static PyObject* pyopencv_cv_reg_reg_MapperPyramid_getMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 85952 | static PyObject* pyopencv_cv_reg_reg_MapperPyramid_getMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 86001 | { |  | 85953 | {
| 86002 | using namespace cv::reg; |  | 85954 | using namespace cv::reg;
| 86003 |  |  | 85955 |
| 86004 |  |  | 85956 |
| 86005 | Ptr<cv::reg::MapperPyramid> * self1 = 0; |  | 85957 | Ptr<cv::reg::MapperPyramid> * self1 = 0;
| 86006 | if (!pyopencv_reg_MapperPyramid_getp(self, self1)) |  | 85958 | if (!pyopencv_reg_MapperPyramid_getp(self, self1))
| 86007 | return failmsgp("Incorrect type of self (must be 'reg_MapperPyramid' or its derivative)"); |  | 85959 | return failmsgp("Incorrect type of self (must be 'reg_MapperPyramid' or its derivative)");
| 86008 | Ptr<cv::reg::MapperPyramid> _self_ = *(self1); |  | 85960 | Ptr<cv::reg::MapperPyramid> _self_ = *(self1);
| 86009 | cv::Ptr<Map> retval; |  | 85961 | cv::Ptr<Map> retval;
| 86010 |  |  | 85962 |
| 86011 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 85963 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86012 | { |  | 85964 | {
| 86013 | ERRWRAP2(retval = _self_->getMap()); |  | 85965 | ERRWRAP2(retval = _self_->getMap());
| 86014 | return pyopencv_from(retval); |  | 85966 | return pyopencv_from(retval);
| 86015 | } |  | 85967 | }
| 86016 |  |  | 85968 |
| 86017 | return NULL; |  | 85969 | return NULL;
| 86018 | } |  | 85970 | }
| 86019 |  |  | 85971 |
| 86020 |  |  | 85972 |
| 86021 |  |  | 85973 |
| 86022 | // Tables (reg_MapperPyramid) |  | 85974 | // Tables (reg_MapperPyramid)
| 86023 |  |  | 85975 |
| 86024 | static PyGetSetDef pyopencv_reg_MapperPyramid_getseters[] = |  | 85976 | static PyGetSetDef pyopencv_reg_MapperPyramid_getseters[] =
| 86025 | { |  | 85977 | {
| 86026 | {(char*)"numIterPerScale_", (getter)pyopencv_reg_MapperPyramid_get_numIterPerScale_, (setter)pyopencv_reg_MapperPyramid_set_numIterPerScale_, (char*)"numIterPerScale_", NULL}, |  | 85978 | {(char*)"numIterPerScale_", (getter)pyopencv_reg_MapperPyramid_get_numIterPerScale_, (setter)pyopencv_reg_MapperPyramid_set_numIterPerScale_, (char*)"numIterPerScale_", NULL},
| 86027 | {(char*)"numLev_", (getter)pyopencv_reg_MapperPyramid_get_numLev_, (setter)pyopencv_reg_MapperPyramid_set_numLev_, (char*)"numLev_", NULL}, |  | 85979 | {(char*)"numLev_", (getter)pyopencv_reg_MapperPyramid_get_numLev_, (setter)pyopencv_reg_MapperPyramid_set_numLev_, (char*)"numLev_", NULL},
| 86028 | {NULL} /* Sentinel */ |  | 85980 | {NULL} /* Sentinel */
| 86029 | }; |  | 85981 | };
| 86030 |  |  | 85982 |
| 86031 | static PyMethodDef pyopencv_reg_MapperPyramid_methods[] = |  | 85983 | static PyMethodDef pyopencv_reg_MapperPyramid_methods[] =
| 86032 | { |  | 85984 | {
| 86033 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperPyramid_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."}, |  | 85985 | {"calculate", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperPyramid_calculate, 0), "calculate(img1, img2[, init]) -> retval\n."},
| 86034 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperPyramid_getMap, 0), "getMap() -> retval\n."}, |  | 85986 | {"getMap", CV_PY_FN_WITH_KW_(pyopencv_cv_reg_reg_MapperPyramid_getMap, 0), "getMap() -> retval\n."},
| 86035 |  |  | 85987 |
| 86036 | {NULL, NULL} |  | 85988 | {NULL, NULL}
| 86037 | }; |  | 85989 | };
| 86038 |  |  | 85990 |
| 86039 | // Converter (reg_MapperPyramid) |  | 85991 | // Converter (reg_MapperPyramid)
| 86040 |  |  | 85992 |
| 86041 | template<> |  | 85993 | template<>
| 86042 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperPyramid> > |  | 85994 | struct PyOpenCV_Converter< Ptr<cv::reg::MapperPyramid> >
| 86043 | { |  | 85995 | {
| 86044 | static PyObject* from(const Ptr<cv::reg::MapperPyramid>& r) |  | 85996 | static PyObject* from(const Ptr<cv::reg::MapperPyramid>& r)
| 86045 | { |  | 85997 | {
| 86046 | return pyopencv_reg_MapperPyramid_Instance(r); |  | 85998 | return pyopencv_reg_MapperPyramid_Instance(r);
| 86047 | } |  | 85999 | }
| 86048 | static bool to(PyObject* src, Ptr<cv::reg::MapperPyramid>& dst, const ArgInfo& info) |  | 86000 | static bool to(PyObject* src, Ptr<cv::reg::MapperPyramid>& dst, const ArgInfo& info)
| 86049 | { |  | 86001 | {
| 86050 | if(!src || src == Py_None) |  | 86002 | if(!src || src == Py_None)
| 86051 | return true; |  | 86003 | return true;
| 86052 | Ptr<cv::reg::MapperPyramid> * dst_; |  | 86004 | Ptr<cv::reg::MapperPyramid> * dst_;
| 86053 | if (pyopencv_reg_MapperPyramid_getp(src, dst_)) |  | 86005 | if (pyopencv_reg_MapperPyramid_getp(src, dst_))
| 86054 | { |  | 86006 | {
| 86055 | dst = *dst_; |  | 86007 | dst = *dst_;
| 86056 | return true; |  | 86008 | return true;
| 86057 | } |  | 86009 | }
| 86058 |  |  | 86010 |
| 86059 | failmsg("Expected Ptr<cv::reg::MapperPyramid> for argument '%s'", info.name); |  | 86011 | failmsg("Expected Ptr<cv::reg::MapperPyramid> for argument '%s'", info.name);
| 86060 | return false; |  | 86012 | return false;
| 86061 | } |  | 86013 | }
| 86062 | }; |  | 86014 | };
| 86063 |  |  | 86015 |
| 86064 | //================================================================================ |  | 86016 | //================================================================================
| 86065 | // rgbd_DepthCleaner (Generic) |  | 86017 | // rgbd_DepthCleaner (Generic)
| 86066 | //================================================================================ |  | 86018 | //================================================================================
| 86067 |  |  | 86019 |
| 86068 | // GetSet (rgbd_DepthCleaner) |  | 86020 | // GetSet (rgbd_DepthCleaner)
| 86069 |  |  | 86021 |
| 86070 |  |  | 86022 |
| 86071 |  |  | 86023 |
| 86072 | // Methods (rgbd_DepthCleaner) |  | 86024 | // Methods (rgbd_DepthCleaner)
| 86073 |  |  | 86025 |
| 86074 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86026 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 86075 | { |  | 86027 | {
| 86076 | using namespace cv::rgbd; |  | 86028 | using namespace cv::rgbd;
| 86077 |  |  | 86029 |
| 86078 |  |  | 86030 |
| 86079 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86031 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86080 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86032 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86081 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86033 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86082 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86034 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86083 | pyPrepareArgumentConversionErrorsStorage(2); |  | 86035 | pyPrepareArgumentConversionErrorsStorage(2);
| 86084 |  |  | 86036 |
| 86085 | { |  | 86037 | {
| 86086 | PyObject* pyobj_points = NULL; |  | 86038 | PyObject* pyobj_points = NULL;
| 86087 | Mat points; |  | 86039 | Mat points;
| 86088 | PyObject* pyobj_depth = NULL; |  | 86040 | PyObject* pyobj_depth = NULL;
| 86089 | Mat depth; |  | 86041 | Mat depth;
| 86090 |  |  | 86042 |
| 86091 | const char* keywords[] = { "points", "depth", NULL }; |  | 86043 | const char* keywords[] = { "points", "depth", NULL };
| 86092 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_DepthCleaner.apply", (char**)keywords, &pyobj_points, &pyobj_depth) && |  | 86044 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_DepthCleaner.apply", (char**)keywords, &pyobj_points, &pyobj_depth) &&
| 86093 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 86045 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 86094 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 1)) ) |  | 86046 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 1)) )
| 86095 | { |  | 86047 | {
| 86096 | ERRWRAP2(_self_->operator ()(points, depth)); |  | 86048 | ERRWRAP2(_self_->operator ()(points, depth));
| 86097 | return pyopencv_from(depth); |  | 86049 | return pyopencv_from(depth);
| 86098 | } |  | 86050 | }
| 86099 |  |  | 86051 |
| 86100 |  |  | 86052 |
| 86101 | pyPopulateArgumentConversionErrors(); |  | 86053 | pyPopulateArgumentConversionErrors();
| 86102 | } |  | 86054 | }
| 86103 |  |  | 86055 |
| 86104 |  |  | 86056 |
| 86105 | { |  | 86057 | {
| 86106 | PyObject* pyobj_points = NULL; |  | 86058 | PyObject* pyobj_points = NULL;
| 86107 | UMat points; |  | 86059 | UMat points;
| 86108 | PyObject* pyobj_depth = NULL; |  | 86060 | PyObject* pyobj_depth = NULL;
| 86109 | UMat depth; |  | 86061 | UMat depth;
| 86110 |  |  | 86062 |
| 86111 | const char* keywords[] = { "points", "depth", NULL }; |  | 86063 | const char* keywords[] = { "points", "depth", NULL };
| 86112 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_DepthCleaner.apply", (char**)keywords, &pyobj_points, &pyobj_depth) && |  | 86064 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_DepthCleaner.apply", (char**)keywords, &pyobj_points, &pyobj_depth) &&
| 86113 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 86065 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 86114 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 1)) ) |  | 86066 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 1)) )
| 86115 | { |  | 86067 | {
| 86116 | ERRWRAP2(_self_->operator ()(points, depth)); |  | 86068 | ERRWRAP2(_self_->operator ()(points, depth));
| 86117 | return pyopencv_from(depth); |  | 86069 | return pyopencv_from(depth);
| 86118 | } |  | 86070 | }
| 86119 |  |  | 86071 |
| 86120 |  |  | 86072 |
| 86121 | pyPopulateArgumentConversionErrors(); |  | 86073 | pyPopulateArgumentConversionErrors();
| 86122 | } |  | 86074 | }
| 86123 | pyRaiseCVOverloadException("apply"); |  | 86075 | pyRaiseCVOverloadException("apply");
| 86124 |  |  | 86076 |
| 86125 | return NULL; |  | 86077 | return NULL;
| 86126 | } |  | 86078 | }
| 86127 |  |  | 86079 |
| 86128 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86080 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 86129 | { |  | 86081 | {
| 86130 | using namespace cv::rgbd; |  | 86082 | using namespace cv::rgbd;
| 86131 |  |  | 86083 |
| 86132 | PyObject* pyobj_depth = NULL; |  | 86084 | PyObject* pyobj_depth = NULL;
| 86133 | int depth=0; |  | 86085 | int depth=0;
| 86134 | PyObject* pyobj_window_size = NULL; |  | 86086 | PyObject* pyobj_window_size = NULL;
| 86135 | int window_size=5; |  | 86087 | int window_size=5;
| 86136 | PyObject* pyobj_method = NULL; |  | 86088 | PyObject* pyobj_method = NULL;
| 86137 | int method=DepthCleaner::DEPTH_CLEANER_NIL; |  | 86089 | int method=DepthCleaner::DEPTH_CLEANER_NIL;
| 86138 | Ptr<DepthCleaner> retval; |  | 86090 | Ptr<DepthCleaner> retval;
| 86139 |  |  | 86091 |
| 86140 | const char* keywords[] = { "depth", "window_size", "method", NULL }; |  | 86092 | const char* keywords[] = { "depth", "window_size", "method", NULL };
| 86141 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:rgbd_DepthCleaner.create", (char**)keywords, &pyobj_depth, &pyobj_window_size, &pyobj_method) && |  | 86093 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:rgbd_DepthCleaner.create", (char**)keywords, &pyobj_depth, &pyobj_window_size, &pyobj_method) &&
| 86142 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) && |  | 86094 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) &&
| 86143 | pyopencv_to_safe(pyobj_window_size, window_size, ArgInfo("window_size", 0)) && |  | 86095 | pyopencv_to_safe(pyobj_window_size, window_size, ArgInfo("window_size", 0)) &&
| 86144 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) ) |  | 86096 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) )
| 86145 | { |  | 86097 | {
| 86146 | ERRWRAP2(retval = cv::rgbd::DepthCleaner::create(depth, window_size, method)); |  | 86098 | ERRWRAP2(retval = cv::rgbd::DepthCleaner::create(depth, window_size, method));
| 86147 | return pyopencv_from(retval); |  | 86099 | return pyopencv_from(retval);
| 86148 | } |  | 86100 | }
| 86149 |  |  | 86101 |
| 86150 | return NULL; |  | 86102 | return NULL;
| 86151 | } |  | 86103 | }
| 86152 |  |  | 86104 |
| 86153 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_getDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86105 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_getDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 86154 | { |  | 86106 | {
| 86155 | using namespace cv::rgbd; |  | 86107 | using namespace cv::rgbd;
| 86156 |  |  | 86108 |
| 86157 |  |  | 86109 |
| 86158 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86110 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86159 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86111 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86160 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86112 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86161 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86113 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86162 | int retval; |  | 86114 | int retval;
| 86163 |  |  | 86115 |
| 86164 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86116 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86165 | { |  | 86117 | {
| 86166 | ERRWRAP2(retval = _self_->getDepth()); |  | 86118 | ERRWRAP2(retval = _self_->getDepth());
| 86167 | return pyopencv_from(retval); |  | 86119 | return pyopencv_from(retval);
| 86168 | } |  | 86120 | }
| 86169 |  |  | 86121 |
| 86170 | return NULL; |  | 86122 | return NULL;
| 86171 | } |  | 86123 | }
| 86172 |  |  | 86124 |
| 86173 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_getMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86125 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_getMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 86174 | { |  | 86126 | {
| 86175 | using namespace cv::rgbd; |  | 86127 | using namespace cv::rgbd;
| 86176 |  |  | 86128 |
| 86177 |  |  | 86129 |
| 86178 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86130 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86179 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86131 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86180 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86132 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86181 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86133 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86182 | int retval; |  | 86134 | int retval;
| 86183 |  |  | 86135 |
| 86184 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86136 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86185 | { |  | 86137 | {
| 86186 | ERRWRAP2(retval = _self_->getMethod()); |  | 86138 | ERRWRAP2(retval = _self_->getMethod());
| 86187 | return pyopencv_from(retval); |  | 86139 | return pyopencv_from(retval);
| 86188 | } |  | 86140 | }
| 86189 |  |  | 86141 |
| 86190 | return NULL; |  | 86142 | return NULL;
| 86191 | } |  | 86143 | }
| 86192 |  |  | 86144 |
| 86193 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_getWindowSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86145 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_getWindowSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 86194 | { |  | 86146 | {
| 86195 | using namespace cv::rgbd; |  | 86147 | using namespace cv::rgbd;
| 86196 |  |  | 86148 |
| 86197 |  |  | 86149 |
| 86198 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86150 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86199 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86151 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86200 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86152 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86201 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86153 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86202 | int retval; |  | 86154 | int retval;
| 86203 |  |  | 86155 |
| 86204 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86156 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86205 | { |  | 86157 | {
| 86206 | ERRWRAP2(retval = _self_->getWindowSize()); |  | 86158 | ERRWRAP2(retval = _self_->getWindowSize());
| 86207 | return pyopencv_from(retval); |  | 86159 | return pyopencv_from(retval);
| 86208 | } |  | 86160 | }
| 86209 |  |  | 86161 |
| 86210 | return NULL; |  | 86162 | return NULL;
| 86211 | } |  | 86163 | }
| 86212 |  |  | 86164 |
| 86213 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_initialize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86165 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_initialize(PyObject* self, PyObject* py_args, PyObject* kw)
| 86214 | { |  | 86166 | {
| 86215 | using namespace cv::rgbd; |  | 86167 | using namespace cv::rgbd;
| 86216 |  |  | 86168 |
| 86217 |  |  | 86169 |
| 86218 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86170 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86219 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86171 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86220 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86172 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86221 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86173 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86222 |  |  | 86174 |
| 86223 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86175 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86224 | { |  | 86176 | {
| 86225 | ERRWRAP2(_self_->initialize()); |  | 86177 | ERRWRAP2(_self_->initialize());
| 86226 | Py_RETURN_NONE; |  | 86178 | Py_RETURN_NONE;
| 86227 | } |  | 86179 | }
| 86228 |  |  | 86180 |
| 86229 | return NULL; |  | 86181 | return NULL;
| 86230 | } |  | 86182 | }
| 86231 |  |  | 86183 |
| 86232 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_setDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86184 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_setDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 86233 | { |  | 86185 | {
| 86234 | using namespace cv::rgbd; |  | 86186 | using namespace cv::rgbd;
| 86235 |  |  | 86187 |
| 86236 |  |  | 86188 |
| 86237 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86189 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86238 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86190 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86239 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86191 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86240 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86192 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86241 | PyObject* pyobj_val = NULL; |  | 86193 | PyObject* pyobj_val = NULL;
| 86242 | int val=0; |  | 86194 | int val=0;
| 86243 |  |  | 86195 |
| 86244 | const char* keywords[] = { "val", NULL }; |  | 86196 | const char* keywords[] = { "val", NULL };
| 86245 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_DepthCleaner.setDepth", (char**)keywords, &pyobj_val) && |  | 86197 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_DepthCleaner.setDepth", (char**)keywords, &pyobj_val) &&
| 86246 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 86198 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 86247 | { |  | 86199 | {
| 86248 | ERRWRAP2(_self_->setDepth(val)); |  | 86200 | ERRWRAP2(_self_->setDepth(val));
| 86249 | Py_RETURN_NONE; |  | 86201 | Py_RETURN_NONE;
| 86250 | } |  | 86202 | }
| 86251 |  |  | 86203 |
| 86252 | return NULL; |  | 86204 | return NULL;
| 86253 | } |  | 86205 | }
| 86254 |  |  | 86206 |
| 86255 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_setMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86207 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_setMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 86256 | { |  | 86208 | {
| 86257 | using namespace cv::rgbd; |  | 86209 | using namespace cv::rgbd;
| 86258 |  |  | 86210 |
| 86259 |  |  | 86211 |
| 86260 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86212 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86261 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86213 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86262 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86214 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86263 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86215 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86264 | PyObject* pyobj_val = NULL; |  | 86216 | PyObject* pyobj_val = NULL;
| 86265 | int val=0; |  | 86217 | int val=0;
| 86266 |  |  | 86218 |
| 86267 | const char* keywords[] = { "val", NULL }; |  | 86219 | const char* keywords[] = { "val", NULL };
| 86268 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_DepthCleaner.setMethod", (char**)keywords, &pyobj_val) && |  | 86220 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_DepthCleaner.setMethod", (char**)keywords, &pyobj_val) &&
| 86269 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 86221 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 86270 | { |  | 86222 | {
| 86271 | ERRWRAP2(_self_->setMethod(val)); |  | 86223 | ERRWRAP2(_self_->setMethod(val));
| 86272 | Py_RETURN_NONE; |  | 86224 | Py_RETURN_NONE;
| 86273 | } |  | 86225 | }
| 86274 |  |  | 86226 |
| 86275 | return NULL; |  | 86227 | return NULL;
| 86276 | } |  | 86228 | }
| 86277 |  |  | 86229 |
| 86278 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_setWindowSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86230 | static PyObject* pyopencv_cv_rgbd_rgbd_DepthCleaner_setWindowSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 86279 | { |  | 86231 | {
| 86280 | using namespace cv::rgbd; |  | 86232 | using namespace cv::rgbd;
| 86281 |  |  | 86233 |
| 86282 |  |  | 86234 |
| 86283 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0; |  | 86235 | Ptr<cv::rgbd::DepthCleaner> * self1 = 0;
| 86284 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1)) |  | 86236 | if (!pyopencv_rgbd_DepthCleaner_getp(self, self1))
| 86285 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)"); |  | 86237 | return failmsgp("Incorrect type of self (must be 'rgbd_DepthCleaner' or its derivative)");
| 86286 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1); |  | 86238 | Ptr<cv::rgbd::DepthCleaner> _self_ = *(self1);
| 86287 | PyObject* pyobj_val = NULL; |  | 86239 | PyObject* pyobj_val = NULL;
| 86288 | int val=0; |  | 86240 | int val=0;
| 86289 |  |  | 86241 |
| 86290 | const char* keywords[] = { "val", NULL }; |  | 86242 | const char* keywords[] = { "val", NULL };
| 86291 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_DepthCleaner.setWindowSize", (char**)keywords, &pyobj_val) && |  | 86243 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_DepthCleaner.setWindowSize", (char**)keywords, &pyobj_val) &&
| 86292 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 86244 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 86293 | { |  | 86245 | {
| 86294 | ERRWRAP2(_self_->setWindowSize(val)); |  | 86246 | ERRWRAP2(_self_->setWindowSize(val));
| 86295 | Py_RETURN_NONE; |  | 86247 | Py_RETURN_NONE;
| 86296 | } |  | 86248 | }
| 86297 |  |  | 86249 |
| 86298 | return NULL; |  | 86250 | return NULL;
| 86299 | } |  | 86251 | }
| 86300 |  |  | 86252 |
| 86301 |  |  | 86253 |
| 86302 |  |  | 86254 |
| 86303 | // Tables (rgbd_DepthCleaner) |  | 86255 | // Tables (rgbd_DepthCleaner)
| 86304 |  |  | 86256 |
| 86305 | static PyGetSetDef pyopencv_rgbd_DepthCleaner_getseters[] = |  | 86257 | static PyGetSetDef pyopencv_rgbd_DepthCleaner_getseters[] =
| 86306 | { |  | 86258 | {
| 86307 | {NULL} /* Sentinel */ |  | 86259 | {NULL} /* Sentinel */
| 86308 | }; |  | 86260 | };
| 86309 |  |  | 86261 |
| 86310 | static PyMethodDef pyopencv_rgbd_DepthCleaner_methods[] = |  | 86262 | static PyMethodDef pyopencv_rgbd_DepthCleaner_methods[] =
| 86311 | { |  | 86263 | {
| 86312 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_apply, 0), "apply(points[, depth]) -> depth\n. Given a set of 3d points in a depth image, compute the normals at each point.\n. * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S\n. * @param depth a rows x cols matrix of the cleaned up depth"}, |  | 86264 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_apply, 0), "apply(points[, depth]) -> depth\n. Given a set of 3d points in a depth image, compute the normals at each point.\n. * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S\n. * @param depth a rows x cols matrix of the cleaned up depth"},
| 86313 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_create_static, METH_STATIC), "create(depth[, window_size[, method]]) -> retval\n. Constructor\n. * @param depth the depth of the normals (only CV_32F or CV_64F)\n. * @param window_size the window size to compute the normals: can only be 1,3,5 or 7\n. * @param method one of the methods to use: RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_FALS"}, |  | 86265 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_create_static, METH_STATIC), "create(depth[, window_size[, method]]) -> retval\n. Constructor\n. * @param depth the depth of the normals (only CV_32F or CV_64F)\n. * @param window_size the window size to compute the normals: can only be 1,3,5 or 7\n. * @param method one of the methods to use: RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_FALS"},
| 86314 | {"getDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_getDepth, 0), "getDepth() -> retval\n."}, |  | 86266 | {"getDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_getDepth, 0), "getDepth() -> retval\n."},
| 86315 | {"getMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_getMethod, 0), "getMethod() -> retval\n."}, |  | 86267 | {"getMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_getMethod, 0), "getMethod() -> retval\n."},
| 86316 | {"getWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_getWindowSize, 0), "getWindowSize() -> retval\n."}, |  | 86268 | {"getWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_getWindowSize, 0), "getWindowSize() -> retval\n."},
| 86317 | {"initialize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_initialize, 0), "initialize() -> None\n. Initializes some data that is cached for later computation\n. * If that function is not called, it will be called the first time normals are computed"}, |  | 86269 | {"initialize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_initialize, 0), "initialize() -> None\n. Initializes some data that is cached for later computation\n. * If that function is not called, it will be called the first time normals are computed"},
| 86318 | {"setDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_setDepth, 0), "setDepth(val) -> None\n."}, |  | 86270 | {"setDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_setDepth, 0), "setDepth(val) -> None\n."},
| 86319 | {"setMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_setMethod, 0), "setMethod(val) -> None\n."}, |  | 86271 | {"setMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_setMethod, 0), "setMethod(val) -> None\n."},
| 86320 | {"setWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_setWindowSize, 0), "setWindowSize(val) -> None\n."}, |  | 86272 | {"setWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_DepthCleaner_setWindowSize, 0), "setWindowSize(val) -> None\n."},
| 86321 |  |  | 86273 |
| 86322 | {NULL, NULL} |  | 86274 | {NULL, NULL}
| 86323 | }; |  | 86275 | };
| 86324 |  |  | 86276 |
| 86325 | // Converter (rgbd_DepthCleaner) |  | 86277 | // Converter (rgbd_DepthCleaner)
| 86326 |  |  | 86278 |
| 86327 | template<> |  | 86279 | template<>
| 86328 | struct PyOpenCV_Converter< Ptr<cv::rgbd::DepthCleaner> > |  | 86280 | struct PyOpenCV_Converter< Ptr<cv::rgbd::DepthCleaner> >
| 86329 | { |  | 86281 | {
| 86330 | static PyObject* from(const Ptr<cv::rgbd::DepthCleaner>& r) |  | 86282 | static PyObject* from(const Ptr<cv::rgbd::DepthCleaner>& r)
| 86331 | { |  | 86283 | {
| 86332 | return pyopencv_rgbd_DepthCleaner_Instance(r); |  | 86284 | return pyopencv_rgbd_DepthCleaner_Instance(r);
| 86333 | } |  | 86285 | }
| 86334 | static bool to(PyObject* src, Ptr<cv::rgbd::DepthCleaner>& dst, const ArgInfo& info) |  | 86286 | static bool to(PyObject* src, Ptr<cv::rgbd::DepthCleaner>& dst, const ArgInfo& info)
| 86335 | { |  | 86287 | {
| 86336 | if(!src || src == Py_None) |  | 86288 | if(!src || src == Py_None)
| 86337 | return true; |  | 86289 | return true;
| 86338 | Ptr<cv::rgbd::DepthCleaner> * dst_; |  | 86290 | Ptr<cv::rgbd::DepthCleaner> * dst_;
| 86339 | if (pyopencv_rgbd_DepthCleaner_getp(src, dst_)) |  | 86291 | if (pyopencv_rgbd_DepthCleaner_getp(src, dst_))
| 86340 | { |  | 86292 | {
| 86341 | dst = *dst_; |  | 86293 | dst = *dst_;
| 86342 | return true; |  | 86294 | return true;
| 86343 | } |  | 86295 | }
| 86344 |  |  | 86296 |
| 86345 | failmsg("Expected Ptr<cv::rgbd::DepthCleaner> for argument '%s'", info.name); |  | 86297 | failmsg("Expected Ptr<cv::rgbd::DepthCleaner> for argument '%s'", info.name);
| 86346 | return false; |  | 86298 | return false;
| 86347 | } |  | 86299 | }
| 86348 | }; |  | 86300 | };
| 86349 |  |  | 86301 |
| 86350 | //================================================================================ |  | 86302 | //================================================================================
| 86351 | // rgbd_FastICPOdometry (Generic) |  | 86303 | // rgbd_FastICPOdometry (Generic)
| 86352 | //================================================================================ |  | 86304 | //================================================================================
| 86353 |  |  | 86305 |
| 86354 | // GetSet (rgbd_FastICPOdometry) |  | 86306 | // GetSet (rgbd_FastICPOdometry)
| 86355 |  |  | 86307 |
| 86356 |  |  | 86308 |
| 86357 |  |  | 86309 |
| 86358 | // Methods (rgbd_FastICPOdometry) |  | 86310 | // Methods (rgbd_FastICPOdometry)
| 86359 |  |  | 86311 |
| 86360 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86312 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 86361 | { |  | 86313 | {
| 86362 | using namespace cv::rgbd; |  | 86314 | using namespace cv::rgbd;
| 86363 |  |  | 86315 |
| 86364 | PyObject* pyobj_cameraMatrix = NULL; |  | 86316 | PyObject* pyobj_cameraMatrix = NULL;
| 86365 | Mat cameraMatrix; |  | 86317 | Mat cameraMatrix;
| 86366 | PyObject* pyobj_maxDistDiff = NULL; |  | 86318 | PyObject* pyobj_maxDistDiff = NULL;
| 86367 | float maxDistDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF(); |  | 86319 | float maxDistDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF();
| 86368 | PyObject* pyobj_angleThreshold = NULL; |  | 86320 | PyObject* pyobj_angleThreshold = NULL;
| 86369 | float angleThreshold=(float)(30. * CV_PI / 180.); |  | 86321 | float angleThreshold=(float)(30. * CV_PI / 180.);
| 86370 | PyObject* pyobj_sigmaDepth = NULL; |  | 86322 | PyObject* pyobj_sigmaDepth = NULL;
| 86371 | float sigmaDepth=0.04f; |  | 86323 | float sigmaDepth=0.04f;
| 86372 | PyObject* pyobj_sigmaSpatial = NULL; |  | 86324 | PyObject* pyobj_sigmaSpatial = NULL;
| 86373 | float sigmaSpatial=4.5f; |  | 86325 | float sigmaSpatial=4.5f;
| 86374 | PyObject* pyobj_kernelSize = NULL; |  | 86326 | PyObject* pyobj_kernelSize = NULL;
| 86375 | int kernelSize=7; |  | 86327 | int kernelSize=7;
| 86376 | PyObject* pyobj_iterCounts = NULL; |  | 86328 | PyObject* pyobj_iterCounts = NULL;
| 86377 | vector_int iterCounts=std::vector<int>(); |  | 86329 | vector_int iterCounts=std::vector<int>();
| 86378 | Ptr<FastICPOdometry> retval; |  | 86330 | Ptr<FastICPOdometry> retval;
| 86379 |  |  | 86331 |
| 86380 | const char* keywords[] = { "cameraMatrix", "maxDistDiff", "angleThreshold", "sigmaDepth", "sigmaSpatial", "kernelSize", "iterCounts", NULL }; |  | 86332 | const char* keywords[] = { "cameraMatrix", "maxDistDiff", "angleThreshold", "sigmaDepth", "sigmaSpatial", "kernelSize", "iterCounts", NULL };
| 86381 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:rgbd_FastICPOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_maxDistDiff, &pyobj_angleThreshold, &pyobj_sigmaDepth, &pyobj_sigmaSpatial, &pyobj_kernelSize, &pyobj_iterCounts) && |  | 86333 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OOOOOO:rgbd_FastICPOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_maxDistDiff, &pyobj_angleThreshold, &pyobj_sigmaDepth, &pyobj_sigmaSpatial, &pyobj_kernelSize, &pyobj_iterCounts) &&
| 86382 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) && |  | 86334 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) &&
| 86383 | pyopencv_to_safe(pyobj_maxDistDiff, maxDistDiff, ArgInfo("maxDistDiff", 0)) && |  | 86335 | pyopencv_to_safe(pyobj_maxDistDiff, maxDistDiff, ArgInfo("maxDistDiff", 0)) &&
| 86384 | pyopencv_to_safe(pyobj_angleThreshold, angleThreshold, ArgInfo("angleThreshold", 0)) && |  | 86336 | pyopencv_to_safe(pyobj_angleThreshold, angleThreshold, ArgInfo("angleThreshold", 0)) &&
| 86385 | pyopencv_to_safe(pyobj_sigmaDepth, sigmaDepth, ArgInfo("sigmaDepth", 0)) && |  | 86337 | pyopencv_to_safe(pyobj_sigmaDepth, sigmaDepth, ArgInfo("sigmaDepth", 0)) &&
| 86386 | pyopencv_to_safe(pyobj_sigmaSpatial, sigmaSpatial, ArgInfo("sigmaSpatial", 0)) && |  | 86338 | pyopencv_to_safe(pyobj_sigmaSpatial, sigmaSpatial, ArgInfo("sigmaSpatial", 0)) &&
| 86387 | pyopencv_to_safe(pyobj_kernelSize, kernelSize, ArgInfo("kernelSize", 0)) && |  | 86339 | pyopencv_to_safe(pyobj_kernelSize, kernelSize, ArgInfo("kernelSize", 0)) &&
| 86388 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) ) |  | 86340 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) )
| 86389 | { |  | 86341 | {
| 86390 | ERRWRAP2(retval = cv::rgbd::FastICPOdometry::create(cameraMatrix, maxDistDiff, angleThreshold, sigmaDepth, sigmaSpatial, kernelSize, iterCounts)); |  | 86342 | ERRWRAP2(retval = cv::rgbd::FastICPOdometry::create(cameraMatrix, maxDistDiff, angleThreshold, sigmaDepth, sigmaSpatial, kernelSize, iterCounts));
| 86391 | return pyopencv_from(retval); |  | 86343 | return pyopencv_from(retval);
| 86392 | } |  | 86344 | }
| 86393 |  |  | 86345 |
| 86394 | return NULL; |  | 86346 | return NULL;
| 86395 | } |  | 86347 | }
| 86396 |  |  | 86348 |
| 86397 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getAngleThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86349 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getAngleThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 86398 | { |  | 86350 | {
| 86399 | using namespace cv::rgbd; |  | 86351 | using namespace cv::rgbd;
| 86400 |  |  | 86352 |
| 86401 |  |  | 86353 |
| 86402 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86354 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86403 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86355 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86404 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86356 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86405 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86357 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86406 | float retval; |  | 86358 | float retval;
| 86407 |  |  | 86359 |
| 86408 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86360 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86409 | { |  | 86361 | {
| 86410 | ERRWRAP2(retval = _self_->getAngleThreshold()); |  | 86362 | ERRWRAP2(retval = _self_->getAngleThreshold());
| 86411 | return pyopencv_from(retval); |  | 86363 | return pyopencv_from(retval);
| 86412 | } |  | 86364 | }
| 86413 |  |  | 86365 |
| 86414 | return NULL; |  | 86366 | return NULL;
| 86415 | } |  | 86367 | }
| 86416 |  |  | 86368 |
| 86417 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86369 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 86418 | { |  | 86370 | {
| 86419 | using namespace cv::rgbd; |  | 86371 | using namespace cv::rgbd;
| 86420 |  |  | 86372 |
| 86421 |  |  | 86373 |
| 86422 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86374 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86423 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86375 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86424 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86376 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86425 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86377 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86426 | cv::Mat retval; |  | 86378 | cv::Mat retval;
| 86427 |  |  | 86379 |
| 86428 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86380 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86429 | { |  | 86381 | {
| 86430 | ERRWRAP2(retval = _self_->getCameraMatrix()); |  | 86382 | ERRWRAP2(retval = _self_->getCameraMatrix());
| 86431 | return pyopencv_from(retval); |  | 86383 | return pyopencv_from(retval);
| 86432 | } |  | 86384 | }
| 86433 |  |  | 86385 |
| 86434 | return NULL; |  | 86386 | return NULL;
| 86435 | } |  | 86387 | }
| 86436 |  |  | 86388 |
| 86437 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86389 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 86438 | { |  | 86390 | {
| 86439 | using namespace cv::rgbd; |  | 86391 | using namespace cv::rgbd;
| 86440 |  |  | 86392 |
| 86441 |  |  | 86393 |
| 86442 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86394 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86443 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86395 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86444 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86396 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86445 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86397 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86446 | cv::Mat retval; |  | 86398 | cv::Mat retval;
| 86447 |  |  | 86399 |
| 86448 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86400 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86449 | { |  | 86401 | {
| 86450 | ERRWRAP2(retval = _self_->getIterationCounts()); |  | 86402 | ERRWRAP2(retval = _self_->getIterationCounts());
| 86451 | return pyopencv_from(retval); |  | 86403 | return pyopencv_from(retval);
| 86452 | } |  | 86404 | }
| 86453 |  |  | 86405 |
| 86454 | return NULL; |  | 86406 | return NULL;
| 86455 | } |  | 86407 | }
| 86456 |  |  | 86408 |
| 86457 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getKernelSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86409 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getKernelSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 86458 | { |  | 86410 | {
| 86459 | using namespace cv::rgbd; |  | 86411 | using namespace cv::rgbd;
| 86460 |  |  | 86412 |
| 86461 |  |  | 86413 |
| 86462 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86414 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86463 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86415 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86464 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86416 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86465 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86417 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86466 | int retval; |  | 86418 | int retval;
| 86467 |  |  | 86419 |
| 86468 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86420 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86469 | { |  | 86421 | {
| 86470 | ERRWRAP2(retval = _self_->getKernelSize()); |  | 86422 | ERRWRAP2(retval = _self_->getKernelSize());
| 86471 | return pyopencv_from(retval); |  | 86423 | return pyopencv_from(retval);
| 86472 | } |  | 86424 | }
| 86473 |  |  | 86425 |
| 86474 | return NULL; |  | 86426 | return NULL;
| 86475 | } |  | 86427 | }
| 86476 |  |  | 86428 |
| 86477 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getMaxDistDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86429 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getMaxDistDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 86478 | { |  | 86430 | {
| 86479 | using namespace cv::rgbd; |  | 86431 | using namespace cv::rgbd;
| 86480 |  |  | 86432 |
| 86481 |  |  | 86433 |
| 86482 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86434 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86483 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86435 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86484 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86436 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86485 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86437 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86486 | double retval; |  | 86438 | double retval;
| 86487 |  |  | 86439 |
| 86488 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86440 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86489 | { |  | 86441 | {
| 86490 | ERRWRAP2(retval = _self_->getMaxDistDiff()); |  | 86442 | ERRWRAP2(retval = _self_->getMaxDistDiff());
| 86491 | return pyopencv_from(retval); |  | 86443 | return pyopencv_from(retval);
| 86492 | } |  | 86444 | }
| 86493 |  |  | 86445 |
| 86494 | return NULL; |  | 86446 | return NULL;
| 86495 | } |  | 86447 | }
| 86496 |  |  | 86448 |
| 86497 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86449 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 86498 | { |  | 86450 | {
| 86499 | using namespace cv::rgbd; |  | 86451 | using namespace cv::rgbd;
| 86500 |  |  | 86452 |
| 86501 |  |  | 86453 |
| 86502 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86454 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86503 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86455 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86504 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86456 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86505 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86457 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86506 | float retval; |  | 86458 | float retval;
| 86507 |  |  | 86459 |
| 86508 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86460 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86509 | { |  | 86461 | {
| 86510 | ERRWRAP2(retval = _self_->getSigmaDepth()); |  | 86462 | ERRWRAP2(retval = _self_->getSigmaDepth());
| 86511 | return pyopencv_from(retval); |  | 86463 | return pyopencv_from(retval);
| 86512 | } |  | 86464 | }
| 86513 |  |  | 86465 |
| 86514 | return NULL; |  | 86466 | return NULL;
| 86515 | } |  | 86467 | }
| 86516 |  |  | 86468 |
| 86517 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaSpatial(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86469 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaSpatial(PyObject* self, PyObject* py_args, PyObject* kw)
| 86518 | { |  | 86470 | {
| 86519 | using namespace cv::rgbd; |  | 86471 | using namespace cv::rgbd;
| 86520 |  |  | 86472 |
| 86521 |  |  | 86473 |
| 86522 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86474 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86523 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86475 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86524 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86476 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86525 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86477 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86526 | float retval; |  | 86478 | float retval;
| 86527 |  |  | 86479 |
| 86528 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86480 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86529 | { |  | 86481 | {
| 86530 | ERRWRAP2(retval = _self_->getSigmaSpatial()); |  | 86482 | ERRWRAP2(retval = _self_->getSigmaSpatial());
| 86531 | return pyopencv_from(retval); |  | 86483 | return pyopencv_from(retval);
| 86532 | } |  | 86484 | }
| 86533 |  |  | 86485 |
| 86534 | return NULL; |  | 86486 | return NULL;
| 86535 | } |  | 86487 | }
| 86536 |  |  | 86488 |
| 86537 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86489 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 86538 | { |  | 86490 | {
| 86539 | using namespace cv::rgbd; |  | 86491 | using namespace cv::rgbd;
| 86540 |  |  | 86492 |
| 86541 |  |  | 86493 |
| 86542 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86494 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86543 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86495 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86544 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86496 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86545 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86497 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86546 | int retval; |  | 86498 | int retval;
| 86547 |  |  | 86499 |
| 86548 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86500 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86549 | { |  | 86501 | {
| 86550 | ERRWRAP2(retval = _self_->getTransformType()); |  | 86502 | ERRWRAP2(retval = _self_->getTransformType());
| 86551 | return pyopencv_from(retval); |  | 86503 | return pyopencv_from(retval);
| 86552 | } |  | 86504 | }
| 86553 |  |  | 86505 |
| 86554 | return NULL; |  | 86506 | return NULL;
| 86555 | } |  | 86507 | }
| 86556 |  |  | 86508 |
| 86557 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86509 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw)
| 86558 | { |  | 86510 | {
| 86559 | using namespace cv::rgbd; |  | 86511 | using namespace cv::rgbd;
| 86560 |  |  | 86512 |
| 86561 |  |  | 86513 |
| 86562 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86514 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86563 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86515 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86564 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86516 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86565 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86517 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86566 | PyObject* pyobj_frame = NULL; |  | 86518 | PyObject* pyobj_frame = NULL;
| 86567 | Ptr<OdometryFrame> frame; |  | 86519 | Ptr<OdometryFrame> frame;
| 86568 | PyObject* pyobj_cacheType = NULL; |  | 86520 | PyObject* pyobj_cacheType = NULL;
| 86569 | int cacheType=0; |  | 86521 | int cacheType=0;
| 86570 | Size retval; |  | 86522 | Size retval;
| 86571 |  |  | 86523 |
| 86572 | const char* keywords[] = { "frame", "cacheType", NULL }; |  | 86524 | const char* keywords[] = { "frame", "cacheType", NULL };
| 86573 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_FastICPOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) && |  | 86525 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_FastICPOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) &&
| 86574 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 86526 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 86575 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) ) |  | 86527 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) )
| 86576 | { |  | 86528 | {
| 86577 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType)); |  | 86529 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType));
| 86578 | return pyopencv_from(retval); |  | 86530 | return pyopencv_from(retval);
| 86579 | } |  | 86531 | }
| 86580 |  |  | 86532 |
| 86581 | return NULL; |  | 86533 | return NULL;
| 86582 | } |  | 86534 | }
| 86583 |  |  | 86535 |
| 86584 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setAngleThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86536 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setAngleThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 86585 | { |  | 86537 | {
| 86586 | using namespace cv::rgbd; |  | 86538 | using namespace cv::rgbd;
| 86587 |  |  | 86539 |
| 86588 |  |  | 86540 |
| 86589 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86541 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86590 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86542 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86591 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86543 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86592 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86544 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86593 | PyObject* pyobj_f = NULL; |  | 86545 | PyObject* pyobj_f = NULL;
| 86594 | float f=0.f; |  | 86546 | float f=0.f;
| 86595 |  |  | 86547 |
| 86596 | const char* keywords[] = { "f", NULL }; |  | 86548 | const char* keywords[] = { "f", NULL };
| 86597 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setAngleThreshold", (char**)keywords, &pyobj_f) && |  | 86549 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setAngleThreshold", (char**)keywords, &pyobj_f) &&
| 86598 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) ) |  | 86550 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) )
| 86599 | { |  | 86551 | {
| 86600 | ERRWRAP2(_self_->setAngleThreshold(f)); |  | 86552 | ERRWRAP2(_self_->setAngleThreshold(f));
| 86601 | Py_RETURN_NONE; |  | 86553 | Py_RETURN_NONE;
| 86602 | } |  | 86554 | }
| 86603 |  |  | 86555 |
| 86604 | return NULL; |  | 86556 | return NULL;
| 86605 | } |  | 86557 | }
| 86606 |  |  | 86558 |
| 86607 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86559 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 86608 | { |  | 86560 | {
| 86609 | using namespace cv::rgbd; |  | 86561 | using namespace cv::rgbd;
| 86610 |  |  | 86562 |
| 86611 |  |  | 86563 |
| 86612 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86564 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86613 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86565 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86614 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86566 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86615 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86567 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86616 | PyObject* pyobj_val = NULL; |  | 86568 | PyObject* pyobj_val = NULL;
| 86617 | Mat val; |  | 86569 | Mat val;
| 86618 |  |  | 86570 |
| 86619 | const char* keywords[] = { "val", NULL }; |  | 86571 | const char* keywords[] = { "val", NULL };
| 86620 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) && |  | 86572 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) &&
| 86621 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 86573 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 86622 | { |  | 86574 | {
| 86623 | ERRWRAP2(_self_->setCameraMatrix(val)); |  | 86575 | ERRWRAP2(_self_->setCameraMatrix(val));
| 86624 | Py_RETURN_NONE; |  | 86576 | Py_RETURN_NONE;
| 86625 | } |  | 86577 | }
| 86626 |  |  | 86578 |
| 86627 | return NULL; |  | 86579 | return NULL;
| 86628 | } |  | 86580 | }
| 86629 |  |  | 86581 |
| 86630 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86582 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 86631 | { |  | 86583 | {
| 86632 | using namespace cv::rgbd; |  | 86584 | using namespace cv::rgbd;
| 86633 |  |  | 86585 |
| 86634 |  |  | 86586 |
| 86635 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86587 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86636 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86588 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86637 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86589 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86638 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86590 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86639 | PyObject* pyobj_val = NULL; |  | 86591 | PyObject* pyobj_val = NULL;
| 86640 | Mat val; |  | 86592 | Mat val;
| 86641 |  |  | 86593 |
| 86642 | const char* keywords[] = { "val", NULL }; |  | 86594 | const char* keywords[] = { "val", NULL };
| 86643 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setIterationCounts", (char**)keywords, &pyobj_val) && |  | 86595 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setIterationCounts", (char**)keywords, &pyobj_val) &&
| 86644 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 86596 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 86645 | { |  | 86597 | {
| 86646 | ERRWRAP2(_self_->setIterationCounts(val)); |  | 86598 | ERRWRAP2(_self_->setIterationCounts(val));
| 86647 | Py_RETURN_NONE; |  | 86599 | Py_RETURN_NONE;
| 86648 | } |  | 86600 | }
| 86649 |  |  | 86601 |
| 86650 | return NULL; |  | 86602 | return NULL;
| 86651 | } |  | 86603 | }
| 86652 |  |  | 86604 |
| 86653 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setKernelSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86605 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setKernelSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 86654 | { |  | 86606 | {
| 86655 | using namespace cv::rgbd; |  | 86607 | using namespace cv::rgbd;
| 86656 |  |  | 86608 |
| 86657 |  |  | 86609 |
| 86658 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86610 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86659 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86611 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86660 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86612 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86661 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86613 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86662 | PyObject* pyobj_f = NULL; |  | 86614 | PyObject* pyobj_f = NULL;
| 86663 | int f=0; |  | 86615 | int f=0;
| 86664 |  |  | 86616 |
| 86665 | const char* keywords[] = { "f", NULL }; |  | 86617 | const char* keywords[] = { "f", NULL };
| 86666 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setKernelSize", (char**)keywords, &pyobj_f) && |  | 86618 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setKernelSize", (char**)keywords, &pyobj_f) &&
| 86667 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) ) |  | 86619 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) )
| 86668 | { |  | 86620 | {
| 86669 | ERRWRAP2(_self_->setKernelSize(f)); |  | 86621 | ERRWRAP2(_self_->setKernelSize(f));
| 86670 | Py_RETURN_NONE; |  | 86622 | Py_RETURN_NONE;
| 86671 | } |  | 86623 | }
| 86672 |  |  | 86624 |
| 86673 | return NULL; |  | 86625 | return NULL;
| 86674 | } |  | 86626 | }
| 86675 |  |  | 86627 |
| 86676 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setMaxDistDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86628 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setMaxDistDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 86677 | { |  | 86629 | {
| 86678 | using namespace cv::rgbd; |  | 86630 | using namespace cv::rgbd;
| 86679 |  |  | 86631 |
| 86680 |  |  | 86632 |
| 86681 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86633 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86682 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86634 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86683 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86635 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86684 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86636 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86685 | PyObject* pyobj_val = NULL; |  | 86637 | PyObject* pyobj_val = NULL;
| 86686 | float val=0.f; |  | 86638 | float val=0.f;
| 86687 |  |  | 86639 |
| 86688 | const char* keywords[] = { "val", NULL }; |  | 86640 | const char* keywords[] = { "val", NULL };
| 86689 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setMaxDistDiff", (char**)keywords, &pyobj_val) && |  | 86641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setMaxDistDiff", (char**)keywords, &pyobj_val) &&
| 86690 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 86642 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 86691 | { |  | 86643 | {
| 86692 | ERRWRAP2(_self_->setMaxDistDiff(val)); |  | 86644 | ERRWRAP2(_self_->setMaxDistDiff(val));
| 86693 | Py_RETURN_NONE; |  | 86645 | Py_RETURN_NONE;
| 86694 | } |  | 86646 | }
| 86695 |  |  | 86647 |
| 86696 | return NULL; |  | 86648 | return NULL;
| 86697 | } |  | 86649 | }
| 86698 |  |  | 86650 |
| 86699 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86651 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 86700 | { |  | 86652 | {
| 86701 | using namespace cv::rgbd; |  | 86653 | using namespace cv::rgbd;
| 86702 |  |  | 86654 |
| 86703 |  |  | 86655 |
| 86704 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86656 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86705 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86657 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86706 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86658 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86707 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86659 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86708 | PyObject* pyobj_f = NULL; |  | 86660 | PyObject* pyobj_f = NULL;
| 86709 | float f=0.f; |  | 86661 | float f=0.f;
| 86710 |  |  | 86662 |
| 86711 | const char* keywords[] = { "f", NULL }; |  | 86663 | const char* keywords[] = { "f", NULL };
| 86712 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setSigmaDepth", (char**)keywords, &pyobj_f) && |  | 86664 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setSigmaDepth", (char**)keywords, &pyobj_f) &&
| 86713 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) ) |  | 86665 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) )
| 86714 | { |  | 86666 | {
| 86715 | ERRWRAP2(_self_->setSigmaDepth(f)); |  | 86667 | ERRWRAP2(_self_->setSigmaDepth(f));
| 86716 | Py_RETURN_NONE; |  | 86668 | Py_RETURN_NONE;
| 86717 | } |  | 86669 | }
| 86718 |  |  | 86670 |
| 86719 | return NULL; |  | 86671 | return NULL;
| 86720 | } |  | 86672 | }
| 86721 |  |  | 86673 |
| 86722 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaSpatial(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86674 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaSpatial(PyObject* self, PyObject* py_args, PyObject* kw)
| 86723 | { |  | 86675 | {
| 86724 | using namespace cv::rgbd; |  | 86676 | using namespace cv::rgbd;
| 86725 |  |  | 86677 |
| 86726 |  |  | 86678 |
| 86727 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86679 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86728 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86680 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86729 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86681 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86730 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86682 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86731 | PyObject* pyobj_f = NULL; |  | 86683 | PyObject* pyobj_f = NULL;
| 86732 | float f=0.f; |  | 86684 | float f=0.f;
| 86733 |  |  | 86685 |
| 86734 | const char* keywords[] = { "f", NULL }; |  | 86686 | const char* keywords[] = { "f", NULL };
| 86735 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setSigmaSpatial", (char**)keywords, &pyobj_f) && |  | 86687 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setSigmaSpatial", (char**)keywords, &pyobj_f) &&
| 86736 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) ) |  | 86688 | pyopencv_to_safe(pyobj_f, f, ArgInfo("f", 0)) )
| 86737 | { |  | 86689 | {
| 86738 | ERRWRAP2(_self_->setSigmaSpatial(f)); |  | 86690 | ERRWRAP2(_self_->setSigmaSpatial(f));
| 86739 | Py_RETURN_NONE; |  | 86691 | Py_RETURN_NONE;
| 86740 | } |  | 86692 | }
| 86741 |  |  | 86693 |
| 86742 | return NULL; |  | 86694 | return NULL;
| 86743 | } |  | 86695 | }
| 86744 |  |  | 86696 |
| 86745 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86697 | static PyObject* pyopencv_cv_rgbd_rgbd_FastICPOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 86746 | { |  | 86698 | {
| 86747 | using namespace cv::rgbd; |  | 86699 | using namespace cv::rgbd;
| 86748 |  |  | 86700 |
| 86749 |  |  | 86701 |
| 86750 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0; |  | 86702 | Ptr<cv::rgbd::FastICPOdometry> * self1 = 0;
| 86751 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1)) |  | 86703 | if (!pyopencv_rgbd_FastICPOdometry_getp(self, self1))
| 86752 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)"); |  | 86704 | return failmsgp("Incorrect type of self (must be 'rgbd_FastICPOdometry' or its derivative)");
| 86753 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1); |  | 86705 | Ptr<cv::rgbd::FastICPOdometry> _self_ = *(self1);
| 86754 | PyObject* pyobj_val = NULL; |  | 86706 | PyObject* pyobj_val = NULL;
| 86755 | int val=0; |  | 86707 | int val=0;
| 86756 |  |  | 86708 |
| 86757 | const char* keywords[] = { "val", NULL }; |  | 86709 | const char* keywords[] = { "val", NULL };
| 86758 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setTransformType", (char**)keywords, &pyobj_val) && |  | 86710 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_FastICPOdometry.setTransformType", (char**)keywords, &pyobj_val) &&
| 86759 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 86711 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 86760 | { |  | 86712 | {
| 86761 | ERRWRAP2(_self_->setTransformType(val)); |  | 86713 | ERRWRAP2(_self_->setTransformType(val));
| 86762 | Py_RETURN_NONE; |  | 86714 | Py_RETURN_NONE;
| 86763 | } |  | 86715 | }
| 86764 |  |  | 86716 |
| 86765 | return NULL; |  | 86717 | return NULL;
| 86766 | } |  | 86718 | }
| 86767 |  |  | 86719 |
| 86768 |  |  | 86720 |
| 86769 |  |  | 86721 |
| 86770 | // Tables (rgbd_FastICPOdometry) |  | 86722 | // Tables (rgbd_FastICPOdometry)
| 86771 |  |  | 86723 |
| 86772 | static PyGetSetDef pyopencv_rgbd_FastICPOdometry_getseters[] = |  | 86724 | static PyGetSetDef pyopencv_rgbd_FastICPOdometry_getseters[] =
| 86773 | { |  | 86725 | {
| 86774 | {NULL} /* Sentinel */ |  | 86726 | {NULL} /* Sentinel */
| 86775 | }; |  | 86727 | };
| 86776 |  |  | 86728 |
| 86777 | static PyMethodDef pyopencv_rgbd_FastICPOdometry_methods[] = |  | 86729 | static PyMethodDef pyopencv_rgbd_FastICPOdometry_methods[] =
| 86778 | { |  | 86730 | {
| 86779 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_create_static, METH_STATIC), "create(cameraMatrix[, maxDistDiff[, angleThreshold[, sigmaDepth[, sigmaSpatial[, kernelSize[, iterCounts]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param maxDistDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff\n. * @param angleThreshold Correspondence will be filtered out\n. * if an angle between their normals is bigger than threshold\n. * @param sigmaDepth Depth sigma in meters for bilateral smooth\n. * @param sigmaSpatial Spatial sigma in pixels for bilateral smooth\n. * @param kernelSize Kernel size in pixels for bilateral smooth\n. * @param iterCounts Count of iterations on each pyramid level"}, |  | 86731 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_create_static, METH_STATIC), "create(cameraMatrix[, maxDistDiff[, angleThreshold[, sigmaDepth[, sigmaSpatial[, kernelSize[, iterCounts]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param maxDistDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff\n. * @param angleThreshold Correspondence will be filtered out\n. * if an angle between their normals is bigger than threshold\n. * @param sigmaDepth Depth sigma in meters for bilateral smooth\n. * @param sigmaSpatial Spatial sigma in pixels for bilateral smooth\n. * @param kernelSize Kernel size in pixels for bilateral smooth\n. * @param iterCounts Count of iterations on each pyramid level"},
| 86780 | {"getAngleThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getAngleThreshold, 0), "getAngleThreshold() -> retval\n."}, |  | 86732 | {"getAngleThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getAngleThreshold, 0), "getAngleThreshold() -> retval\n."},
| 86781 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."}, |  | 86733 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."},
| 86782 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."}, |  | 86734 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."},
| 86783 | {"getKernelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getKernelSize, 0), "getKernelSize() -> retval\n."}, |  | 86735 | {"getKernelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getKernelSize, 0), "getKernelSize() -> retval\n."},
| 86784 | {"getMaxDistDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getMaxDistDiff, 0), "getMaxDistDiff() -> retval\n."}, |  | 86736 | {"getMaxDistDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getMaxDistDiff, 0), "getMaxDistDiff() -> retval\n."},
| 86785 | {"getSigmaDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaDepth, 0), "getSigmaDepth() -> retval\n."}, |  | 86737 | {"getSigmaDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaDepth, 0), "getSigmaDepth() -> retval\n."},
| 86786 | {"getSigmaSpatial", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaSpatial, 0), "getSigmaSpatial() -> retval\n."}, |  | 86738 | {"getSigmaSpatial", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getSigmaSpatial, 0), "getSigmaSpatial() -> retval\n."},
| 86787 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getTransformType, 0), "getTransformType() -> retval\n."}, |  | 86739 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_getTransformType, 0), "getTransformType() -> retval\n."},
| 86788 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."}, |  | 86740 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."},
| 86789 | {"setAngleThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setAngleThreshold, 0), "setAngleThreshold(f) -> None\n."}, |  | 86741 | {"setAngleThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setAngleThreshold, 0), "setAngleThreshold(f) -> None\n."},
| 86790 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."}, |  | 86742 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."},
| 86791 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."}, |  | 86743 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."},
| 86792 | {"setKernelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setKernelSize, 0), "setKernelSize(f) -> None\n."}, |  | 86744 | {"setKernelSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setKernelSize, 0), "setKernelSize(f) -> None\n."},
| 86793 | {"setMaxDistDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setMaxDistDiff, 0), "setMaxDistDiff(val) -> None\n."}, |  | 86745 | {"setMaxDistDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setMaxDistDiff, 0), "setMaxDistDiff(val) -> None\n."},
| 86794 | {"setSigmaDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaDepth, 0), "setSigmaDepth(f) -> None\n."}, |  | 86746 | {"setSigmaDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaDepth, 0), "setSigmaDepth(f) -> None\n."},
| 86795 | {"setSigmaSpatial", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaSpatial, 0), "setSigmaSpatial(f) -> None\n."}, |  | 86747 | {"setSigmaSpatial", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setSigmaSpatial, 0), "setSigmaSpatial(f) -> None\n."},
| 86796 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setTransformType, 0), "setTransformType(val) -> None\n."}, |  | 86748 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_FastICPOdometry_setTransformType, 0), "setTransformType(val) -> None\n."},
| 86797 |  |  | 86749 |
| 86798 | {NULL, NULL} |  | 86750 | {NULL, NULL}
| 86799 | }; |  | 86751 | };
| 86800 |  |  | 86752 |
| 86801 | // Converter (rgbd_FastICPOdometry) |  | 86753 | // Converter (rgbd_FastICPOdometry)
| 86802 |  |  | 86754 |
| 86803 | template<> |  | 86755 | template<>
| 86804 | struct PyOpenCV_Converter< Ptr<cv::rgbd::FastICPOdometry> > |  | 86756 | struct PyOpenCV_Converter< Ptr<cv::rgbd::FastICPOdometry> >
| 86805 | { |  | 86757 | {
| 86806 | static PyObject* from(const Ptr<cv::rgbd::FastICPOdometry>& r) |  | 86758 | static PyObject* from(const Ptr<cv::rgbd::FastICPOdometry>& r)
| 86807 | { |  | 86759 | {
| 86808 | return pyopencv_rgbd_FastICPOdometry_Instance(r); |  | 86760 | return pyopencv_rgbd_FastICPOdometry_Instance(r);
| 86809 | } |  | 86761 | }
| 86810 | static bool to(PyObject* src, Ptr<cv::rgbd::FastICPOdometry>& dst, const ArgInfo& info) |  | 86762 | static bool to(PyObject* src, Ptr<cv::rgbd::FastICPOdometry>& dst, const ArgInfo& info)
| 86811 | { |  | 86763 | {
| 86812 | if(!src || src == Py_None) |  | 86764 | if(!src || src == Py_None)
| 86813 | return true; |  | 86765 | return true;
| 86814 | Ptr<cv::rgbd::FastICPOdometry> * dst_; |  | 86766 | Ptr<cv::rgbd::FastICPOdometry> * dst_;
| 86815 | if (pyopencv_rgbd_FastICPOdometry_getp(src, dst_)) |  | 86767 | if (pyopencv_rgbd_FastICPOdometry_getp(src, dst_))
| 86816 | { |  | 86768 | {
| 86817 | dst = *dst_; |  | 86769 | dst = *dst_;
| 86818 | return true; |  | 86770 | return true;
| 86819 | } |  | 86771 | }
| 86820 |  |  | 86772 |
| 86821 | failmsg("Expected Ptr<cv::rgbd::FastICPOdometry> for argument '%s'", info.name); |  | 86773 | failmsg("Expected Ptr<cv::rgbd::FastICPOdometry> for argument '%s'", info.name);
| 86822 | return false; |  | 86774 | return false;
| 86823 | } |  | 86775 | }
| 86824 | }; |  | 86776 | };
| 86825 |  |  | 86777 |
| 86826 | //================================================================================ |  | 86778 | //================================================================================
| 86827 | // rgbd_ICPOdometry (Generic) |  | 86779 | // rgbd_ICPOdometry (Generic)
| 86828 | //================================================================================ |  | 86780 | //================================================================================
| 86829 |  |  | 86781 |
| 86830 | // GetSet (rgbd_ICPOdometry) |  | 86782 | // GetSet (rgbd_ICPOdometry)
| 86831 |  |  | 86783 |
| 86832 |  |  | 86784 |
| 86833 |  |  | 86785 |
| 86834 | // Methods (rgbd_ICPOdometry) |  | 86786 | // Methods (rgbd_ICPOdometry)
| 86835 |  |  | 86787 |
| 86836 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86788 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 86837 | { |  | 86789 | {
| 86838 | using namespace cv::rgbd; |  | 86790 | using namespace cv::rgbd;
| 86839 |  |  | 86791 |
| 86840 | PyObject* pyobj_cameraMatrix = NULL; |  | 86792 | PyObject* pyobj_cameraMatrix = NULL;
| 86841 | Mat cameraMatrix; |  | 86793 | Mat cameraMatrix;
| 86842 | PyObject* pyobj_minDepth = NULL; |  | 86794 | PyObject* pyobj_minDepth = NULL;
| 86843 | float minDepth=Odometry::DEFAULT_MIN_DEPTH(); |  | 86795 | float minDepth=Odometry::DEFAULT_MIN_DEPTH();
| 86844 | PyObject* pyobj_maxDepth = NULL; |  | 86796 | PyObject* pyobj_maxDepth = NULL;
| 86845 | float maxDepth=Odometry::DEFAULT_MAX_DEPTH(); |  | 86797 | float maxDepth=Odometry::DEFAULT_MAX_DEPTH();
| 86846 | PyObject* pyobj_maxDepthDiff = NULL; |  | 86798 | PyObject* pyobj_maxDepthDiff = NULL;
| 86847 | float maxDepthDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF(); |  | 86799 | float maxDepthDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF();
| 86848 | PyObject* pyobj_maxPointsPart = NULL; |  | 86800 | PyObject* pyobj_maxPointsPart = NULL;
| 86849 | float maxPointsPart=Odometry::DEFAULT_MAX_POINTS_PART(); |  | 86801 | float maxPointsPart=Odometry::DEFAULT_MAX_POINTS_PART();
| 86850 | PyObject* pyobj_iterCounts = NULL; |  | 86802 | PyObject* pyobj_iterCounts = NULL;
| 86851 | vector_int iterCounts=std::vector<int>(); |  | 86803 | vector_int iterCounts=std::vector<int>();
| 86852 | PyObject* pyobj_transformType = NULL; |  | 86804 | PyObject* pyobj_transformType = NULL;
| 86853 | int transformType=Odometry::RIGID_BODY_MOTION; |  | 86805 | int transformType=Odometry::RIGID_BODY_MOTION;
| 86854 | Ptr<ICPOdometry> retval; |  | 86806 | Ptr<ICPOdometry> retval;
| 86855 |  |  | 86807 |
| 86856 | const char* keywords[] = { "cameraMatrix", "minDepth", "maxDepth", "maxDepthDiff", "maxPointsPart", "iterCounts", "transformType", NULL }; |  | 86808 | const char* keywords[] = { "cameraMatrix", "minDepth", "maxDepth", "maxDepthDiff", "maxPointsPart", "iterCounts", "transformType", NULL };
| 86857 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOO:rgbd_ICPOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_minDepth, &pyobj_maxDepth, &pyobj_maxDepthDiff, &pyobj_maxPointsPart, &pyobj_iterCounts, &pyobj_transformType) && |  | 86809 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOO:rgbd_ICPOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_minDepth, &pyobj_maxDepth, &pyobj_maxDepthDiff, &pyobj_maxPointsPart, &pyobj_iterCounts, &pyobj_transformType) &&
| 86858 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) && |  | 86810 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) &&
| 86859 | pyopencv_to_safe(pyobj_minDepth, minDepth, ArgInfo("minDepth", 0)) && |  | 86811 | pyopencv_to_safe(pyobj_minDepth, minDepth, ArgInfo("minDepth", 0)) &&
| 86860 | pyopencv_to_safe(pyobj_maxDepth, maxDepth, ArgInfo("maxDepth", 0)) && |  | 86812 | pyopencv_to_safe(pyobj_maxDepth, maxDepth, ArgInfo("maxDepth", 0)) &&
| 86861 | pyopencv_to_safe(pyobj_maxDepthDiff, maxDepthDiff, ArgInfo("maxDepthDiff", 0)) && |  | 86813 | pyopencv_to_safe(pyobj_maxDepthDiff, maxDepthDiff, ArgInfo("maxDepthDiff", 0)) &&
| 86862 | pyopencv_to_safe(pyobj_maxPointsPart, maxPointsPart, ArgInfo("maxPointsPart", 0)) && |  | 86814 | pyopencv_to_safe(pyobj_maxPointsPart, maxPointsPart, ArgInfo("maxPointsPart", 0)) &&
| 86863 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) && |  | 86815 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) &&
| 86864 | pyopencv_to_safe(pyobj_transformType, transformType, ArgInfo("transformType", 0)) ) |  | 86816 | pyopencv_to_safe(pyobj_transformType, transformType, ArgInfo("transformType", 0)) )
| 86865 | { |  | 86817 | {
| 86866 | ERRWRAP2(retval = cv::rgbd::ICPOdometry::create(cameraMatrix, minDepth, maxDepth, maxDepthDiff, maxPointsPart, iterCounts, transformType)); |  | 86818 | ERRWRAP2(retval = cv::rgbd::ICPOdometry::create(cameraMatrix, minDepth, maxDepth, maxDepthDiff, maxPointsPart, iterCounts, transformType));
| 86867 | return pyopencv_from(retval); |  | 86819 | return pyopencv_from(retval);
| 86868 | } |  | 86820 | }
| 86869 |  |  | 86821 |
| 86870 | return NULL; |  | 86822 | return NULL;
| 86871 | } |  | 86823 | }
| 86872 |  |  | 86824 |
| 86873 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86825 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 86874 | { |  | 86826 | {
| 86875 | using namespace cv::rgbd; |  | 86827 | using namespace cv::rgbd;
| 86876 |  |  | 86828 |
| 86877 |  |  | 86829 |
| 86878 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86830 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 86879 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86831 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 86880 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86832 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 86881 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86833 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 86882 | cv::Mat retval; |  | 86834 | cv::Mat retval;
| 86883 |  |  | 86835 |
| 86884 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86836 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86885 | { |  | 86837 | {
| 86886 | ERRWRAP2(retval = _self_->getCameraMatrix()); |  | 86838 | ERRWRAP2(retval = _self_->getCameraMatrix());
| 86887 | return pyopencv_from(retval); |  | 86839 | return pyopencv_from(retval);
| 86888 | } |  | 86840 | }
| 86889 |  |  | 86841 |
| 86890 | return NULL; |  | 86842 | return NULL;
| 86891 | } |  | 86843 | }
| 86892 |  |  | 86844 |
| 86893 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86845 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 86894 | { |  | 86846 | {
| 86895 | using namespace cv::rgbd; |  | 86847 | using namespace cv::rgbd;
| 86896 |  |  | 86848 |
| 86897 |  |  | 86849 |
| 86898 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86850 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 86899 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86851 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 86900 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86852 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 86901 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86853 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 86902 | cv::Mat retval; |  | 86854 | cv::Mat retval;
| 86903 |  |  | 86855 |
| 86904 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86856 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86905 | { |  | 86857 | {
| 86906 | ERRWRAP2(retval = _self_->getIterationCounts()); |  | 86858 | ERRWRAP2(retval = _self_->getIterationCounts());
| 86907 | return pyopencv_from(retval); |  | 86859 | return pyopencv_from(retval);
| 86908 | } |  | 86860 | }
| 86909 |  |  | 86861 |
| 86910 | return NULL; |  | 86862 | return NULL;
| 86911 | } |  | 86863 | }
| 86912 |  |  | 86864 |
| 86913 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86865 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 86914 | { |  | 86866 | {
| 86915 | using namespace cv::rgbd; |  | 86867 | using namespace cv::rgbd;
| 86916 |  |  | 86868 |
| 86917 |  |  | 86869 |
| 86918 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86870 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 86919 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86871 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 86920 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86872 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 86921 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86873 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 86922 | double retval; |  | 86874 | double retval;
| 86923 |  |  | 86875 |
| 86924 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86876 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86925 | { |  | 86877 | {
| 86926 | ERRWRAP2(retval = _self_->getMaxDepth()); |  | 86878 | ERRWRAP2(retval = _self_->getMaxDepth());
| 86927 | return pyopencv_from(retval); |  | 86879 | return pyopencv_from(retval);
| 86928 | } |  | 86880 | }
| 86929 |  |  | 86881 |
| 86930 | return NULL; |  | 86882 | return NULL;
| 86931 | } |  | 86883 | }
| 86932 |  |  | 86884 |
| 86933 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86885 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 86934 | { |  | 86886 | {
| 86935 | using namespace cv::rgbd; |  | 86887 | using namespace cv::rgbd;
| 86936 |  |  | 86888 |
| 86937 |  |  | 86889 |
| 86938 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86890 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 86939 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86891 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 86940 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86892 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 86941 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86893 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 86942 | double retval; |  | 86894 | double retval;
| 86943 |  |  | 86895 |
| 86944 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86896 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86945 | { |  | 86897 | {
| 86946 | ERRWRAP2(retval = _self_->getMaxDepthDiff()); |  | 86898 | ERRWRAP2(retval = _self_->getMaxDepthDiff());
| 86947 | return pyopencv_from(retval); |  | 86899 | return pyopencv_from(retval);
| 86948 | } |  | 86900 | }
| 86949 |  |  | 86901 |
| 86950 | return NULL; |  | 86902 | return NULL;
| 86951 | } |  | 86903 | }
| 86952 |  |  | 86904 |
| 86953 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86905 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw)
| 86954 | { |  | 86906 | {
| 86955 | using namespace cv::rgbd; |  | 86907 | using namespace cv::rgbd;
| 86956 |  |  | 86908 |
| 86957 |  |  | 86909 |
| 86958 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86910 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 86959 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86911 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 86960 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86912 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 86961 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86913 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 86962 | double retval; |  | 86914 | double retval;
| 86963 |  |  | 86915 |
| 86964 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86916 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86965 | { |  | 86917 | {
| 86966 | ERRWRAP2(retval = _self_->getMaxPointsPart()); |  | 86918 | ERRWRAP2(retval = _self_->getMaxPointsPart());
| 86967 | return pyopencv_from(retval); |  | 86919 | return pyopencv_from(retval);
| 86968 | } |  | 86920 | }
| 86969 |  |  | 86921 |
| 86970 | return NULL; |  | 86922 | return NULL;
| 86971 | } |  | 86923 | }
| 86972 |  |  | 86924 |
| 86973 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86925 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw)
| 86974 | { |  | 86926 | {
| 86975 | using namespace cv::rgbd; |  | 86927 | using namespace cv::rgbd;
| 86976 |  |  | 86928 |
| 86977 |  |  | 86929 |
| 86978 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86930 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 86979 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86931 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 86980 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86932 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 86981 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86933 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 86982 | double retval; |  | 86934 | double retval;
| 86983 |  |  | 86935 |
| 86984 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86936 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 86985 | { |  | 86937 | {
| 86986 | ERRWRAP2(retval = _self_->getMaxRotation()); |  | 86938 | ERRWRAP2(retval = _self_->getMaxRotation());
| 86987 | return pyopencv_from(retval); |  | 86939 | return pyopencv_from(retval);
| 86988 | } |  | 86940 | }
| 86989 |  |  | 86941 |
| 86990 | return NULL; |  | 86942 | return NULL;
| 86991 | } |  | 86943 | }
| 86992 |  |  | 86944 |
| 86993 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86945 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw)
| 86994 | { |  | 86946 | {
| 86995 | using namespace cv::rgbd; |  | 86947 | using namespace cv::rgbd;
| 86996 |  |  | 86948 |
| 86997 |  |  | 86949 |
| 86998 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86950 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 86999 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86951 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87000 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86952 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87001 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86953 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87002 | double retval; |  | 86954 | double retval;
| 87003 |  |  | 86955 |
| 87004 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86956 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87005 | { |  | 86957 | {
| 87006 | ERRWRAP2(retval = _self_->getMaxTranslation()); |  | 86958 | ERRWRAP2(retval = _self_->getMaxTranslation());
| 87007 | return pyopencv_from(retval); |  | 86959 | return pyopencv_from(retval);
| 87008 | } |  | 86960 | }
| 87009 |  |  | 86961 |
| 87010 | return NULL; |  | 86962 | return NULL;
| 87011 | } |  | 86963 | }
| 87012 |  |  | 86964 |
| 87013 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMinDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86965 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getMinDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 87014 | { |  | 86966 | {
| 87015 | using namespace cv::rgbd; |  | 86967 | using namespace cv::rgbd;
| 87016 |  |  | 86968 |
| 87017 |  |  | 86969 |
| 87018 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86970 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87019 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86971 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87020 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86972 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87021 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86973 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87022 | double retval; |  | 86974 | double retval;
| 87023 |  |  | 86975 |
| 87024 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86976 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87025 | { |  | 86977 | {
| 87026 | ERRWRAP2(retval = _self_->getMinDepth()); |  | 86978 | ERRWRAP2(retval = _self_->getMinDepth());
| 87027 | return pyopencv_from(retval); |  | 86979 | return pyopencv_from(retval);
| 87028 | } |  | 86980 | }
| 87029 |  |  | 86981 |
| 87030 | return NULL; |  | 86982 | return NULL;
| 87031 | } |  | 86983 | }
| 87032 |  |  | 86984 |
| 87033 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getNormalsComputer(PyObject* self, PyObject* py_args, PyObject* kw) |  | 86985 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getNormalsComputer(PyObject* self, PyObject* py_args, PyObject* kw)
| 87034 | { |  | 86986 | {
| 87035 | using namespace cv::rgbd; |  | 86987 | using namespace cv::rgbd;
| 87036 |  |  | 86988 |
| 87037 |  |  | 86989 |
| 87038 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 86990 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87039 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 86991 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87040 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 86992 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87041 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 86993 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87042 | Ptr<RgbdNormals> retval; |  | 86994 | Ptr<RgbdNormals> retval;
| 87043 |  |  | 86995 |
| 87044 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 86996 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87045 | { |  | 86997 | {
| 87046 | ERRWRAP2(retval = _self_->getNormalsComputer()); |  | 86998 | ERRWRAP2(retval = _self_->getNormalsComputer());
| 87047 | return pyopencv_from(retval); |  | 86999 | return pyopencv_from(retval);
| 87048 | } |  | 87000 | }
| 87049 |  |  | 87001 |
| 87050 | return NULL; |  | 87002 | return NULL;
| 87051 | } |  | 87003 | }
| 87052 |  |  | 87004 |
| 87053 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87005 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 87054 | { |  | 87006 | {
| 87055 | using namespace cv::rgbd; |  | 87007 | using namespace cv::rgbd;
| 87056 |  |  | 87008 |
| 87057 |  |  | 87009 |
| 87058 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87010 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87059 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87011 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87060 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87012 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87061 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87013 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87062 | int retval; |  | 87014 | int retval;
| 87063 |  |  | 87015 |
| 87064 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87016 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87065 | { |  | 87017 | {
| 87066 | ERRWRAP2(retval = _self_->getTransformType()); |  | 87018 | ERRWRAP2(retval = _self_->getTransformType());
| 87067 | return pyopencv_from(retval); |  | 87019 | return pyopencv_from(retval);
| 87068 | } |  | 87020 | }
| 87069 |  |  | 87021 |
| 87070 | return NULL; |  | 87022 | return NULL;
| 87071 | } |  | 87023 | }
| 87072 |  |  | 87024 |
| 87073 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87025 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw)
| 87074 | { |  | 87026 | {
| 87075 | using namespace cv::rgbd; |  | 87027 | using namespace cv::rgbd;
| 87076 |  |  | 87028 |
| 87077 |  |  | 87029 |
| 87078 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87030 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87079 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87031 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87080 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87032 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87081 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87033 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87082 | PyObject* pyobj_frame = NULL; |  | 87034 | PyObject* pyobj_frame = NULL;
| 87083 | Ptr<OdometryFrame> frame; |  | 87035 | Ptr<OdometryFrame> frame;
| 87084 | PyObject* pyobj_cacheType = NULL; |  | 87036 | PyObject* pyobj_cacheType = NULL;
| 87085 | int cacheType=0; |  | 87037 | int cacheType=0;
| 87086 | Size retval; |  | 87038 | Size retval;
| 87087 |  |  | 87039 |
| 87088 | const char* keywords[] = { "frame", "cacheType", NULL }; |  | 87040 | const char* keywords[] = { "frame", "cacheType", NULL };
| 87089 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_ICPOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) && |  | 87041 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_ICPOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) &&
| 87090 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 87042 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 87091 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) ) |  | 87043 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) )
| 87092 | { |  | 87044 | {
| 87093 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType)); |  | 87045 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType));
| 87094 | return pyopencv_from(retval); |  | 87046 | return pyopencv_from(retval);
| 87095 | } |  | 87047 | }
| 87096 |  |  | 87048 |
| 87097 | return NULL; |  | 87049 | return NULL;
| 87098 | } |  | 87050 | }
| 87099 |  |  | 87051 |
| 87100 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87052 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 87101 | { |  | 87053 | {
| 87102 | using namespace cv::rgbd; |  | 87054 | using namespace cv::rgbd;
| 87103 |  |  | 87055 |
| 87104 |  |  | 87056 |
| 87105 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87057 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87106 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87058 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87107 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87059 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87108 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87060 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87109 | PyObject* pyobj_val = NULL; |  | 87061 | PyObject* pyobj_val = NULL;
| 87110 | Mat val; |  | 87062 | Mat val;
| 87111 |  |  | 87063 |
| 87112 | const char* keywords[] = { "val", NULL }; |  | 87064 | const char* keywords[] = { "val", NULL };
| 87113 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) && |  | 87065 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) &&
| 87114 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87066 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87115 | { |  | 87067 | {
| 87116 | ERRWRAP2(_self_->setCameraMatrix(val)); |  | 87068 | ERRWRAP2(_self_->setCameraMatrix(val));
| 87117 | Py_RETURN_NONE; |  | 87069 | Py_RETURN_NONE;
| 87118 | } |  | 87070 | }
| 87119 |  |  | 87071 |
| 87120 | return NULL; |  | 87072 | return NULL;
| 87121 | } |  | 87073 | }
| 87122 |  |  | 87074 |
| 87123 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87075 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 87124 | { |  | 87076 | {
| 87125 | using namespace cv::rgbd; |  | 87077 | using namespace cv::rgbd;
| 87126 |  |  | 87078 |
| 87127 |  |  | 87079 |
| 87128 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87080 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87129 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87081 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87130 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87082 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87131 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87083 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87132 | PyObject* pyobj_val = NULL; |  | 87084 | PyObject* pyobj_val = NULL;
| 87133 | Mat val; |  | 87085 | Mat val;
| 87134 |  |  | 87086 |
| 87135 | const char* keywords[] = { "val", NULL }; |  | 87087 | const char* keywords[] = { "val", NULL };
| 87136 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setIterationCounts", (char**)keywords, &pyobj_val) && |  | 87088 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setIterationCounts", (char**)keywords, &pyobj_val) &&
| 87137 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87089 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87138 | { |  | 87090 | {
| 87139 | ERRWRAP2(_self_->setIterationCounts(val)); |  | 87091 | ERRWRAP2(_self_->setIterationCounts(val));
| 87140 | Py_RETURN_NONE; |  | 87092 | Py_RETURN_NONE;
| 87141 | } |  | 87093 | }
| 87142 |  |  | 87094 |
| 87143 | return NULL; |  | 87095 | return NULL;
| 87144 | } |  | 87096 | }
| 87145 |  |  | 87097 |
| 87146 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87098 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 87147 | { |  | 87099 | {
| 87148 | using namespace cv::rgbd; |  | 87100 | using namespace cv::rgbd;
| 87149 |  |  | 87101 |
| 87150 |  |  | 87102 |
| 87151 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87103 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87152 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87104 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87153 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87105 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87154 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87106 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87155 | PyObject* pyobj_val = NULL; |  | 87107 | PyObject* pyobj_val = NULL;
| 87156 | double val=0; |  | 87108 | double val=0;
| 87157 |  |  | 87109 |
| 87158 | const char* keywords[] = { "val", NULL }; |  | 87110 | const char* keywords[] = { "val", NULL };
| 87159 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxDepth", (char**)keywords, &pyobj_val) && |  | 87111 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxDepth", (char**)keywords, &pyobj_val) &&
| 87160 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87112 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87161 | { |  | 87113 | {
| 87162 | ERRWRAP2(_self_->setMaxDepth(val)); |  | 87114 | ERRWRAP2(_self_->setMaxDepth(val));
| 87163 | Py_RETURN_NONE; |  | 87115 | Py_RETURN_NONE;
| 87164 | } |  | 87116 | }
| 87165 |  |  | 87117 |
| 87166 | return NULL; |  | 87118 | return NULL;
| 87167 | } |  | 87119 | }
| 87168 |  |  | 87120 |
| 87169 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87121 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 87170 | { |  | 87122 | {
| 87171 | using namespace cv::rgbd; |  | 87123 | using namespace cv::rgbd;
| 87172 |  |  | 87124 |
| 87173 |  |  | 87125 |
| 87174 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87126 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87175 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87127 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87176 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87128 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87177 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87129 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87178 | PyObject* pyobj_val = NULL; |  | 87130 | PyObject* pyobj_val = NULL;
| 87179 | double val=0; |  | 87131 | double val=0;
| 87180 |  |  | 87132 |
| 87181 | const char* keywords[] = { "val", NULL }; |  | 87133 | const char* keywords[] = { "val", NULL };
| 87182 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxDepthDiff", (char**)keywords, &pyobj_val) && |  | 87134 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxDepthDiff", (char**)keywords, &pyobj_val) &&
| 87183 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87135 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87184 | { |  | 87136 | {
| 87185 | ERRWRAP2(_self_->setMaxDepthDiff(val)); |  | 87137 | ERRWRAP2(_self_->setMaxDepthDiff(val));
| 87186 | Py_RETURN_NONE; |  | 87138 | Py_RETURN_NONE;
| 87187 | } |  | 87139 | }
| 87188 |  |  | 87140 |
| 87189 | return NULL; |  | 87141 | return NULL;
| 87190 | } |  | 87142 | }
| 87191 |  |  | 87143 |
| 87192 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87144 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw)
| 87193 | { |  | 87145 | {
| 87194 | using namespace cv::rgbd; |  | 87146 | using namespace cv::rgbd;
| 87195 |  |  | 87147 |
| 87196 |  |  | 87148 |
| 87197 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87149 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87198 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87150 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87199 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87151 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87200 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87152 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87201 | PyObject* pyobj_val = NULL; |  | 87153 | PyObject* pyobj_val = NULL;
| 87202 | double val=0; |  | 87154 | double val=0;
| 87203 |  |  | 87155 |
| 87204 | const char* keywords[] = { "val", NULL }; |  | 87156 | const char* keywords[] = { "val", NULL };
| 87205 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxPointsPart", (char**)keywords, &pyobj_val) && |  | 87157 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxPointsPart", (char**)keywords, &pyobj_val) &&
| 87206 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87158 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87207 | { |  | 87159 | {
| 87208 | ERRWRAP2(_self_->setMaxPointsPart(val)); |  | 87160 | ERRWRAP2(_self_->setMaxPointsPart(val));
| 87209 | Py_RETURN_NONE; |  | 87161 | Py_RETURN_NONE;
| 87210 | } |  | 87162 | }
| 87211 |  |  | 87163 |
| 87212 | return NULL; |  | 87164 | return NULL;
| 87213 | } |  | 87165 | }
| 87214 |  |  | 87166 |
| 87215 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87167 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw)
| 87216 | { |  | 87168 | {
| 87217 | using namespace cv::rgbd; |  | 87169 | using namespace cv::rgbd;
| 87218 |  |  | 87170 |
| 87219 |  |  | 87171 |
| 87220 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87172 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87221 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87173 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87222 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87174 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87223 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87175 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87224 | PyObject* pyobj_val = NULL; |  | 87176 | PyObject* pyobj_val = NULL;
| 87225 | double val=0; |  | 87177 | double val=0;
| 87226 |  |  | 87178 |
| 87227 | const char* keywords[] = { "val", NULL }; |  | 87179 | const char* keywords[] = { "val", NULL };
| 87228 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxRotation", (char**)keywords, &pyobj_val) && |  | 87180 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxRotation", (char**)keywords, &pyobj_val) &&
| 87229 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87181 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87230 | { |  | 87182 | {
| 87231 | ERRWRAP2(_self_->setMaxRotation(val)); |  | 87183 | ERRWRAP2(_self_->setMaxRotation(val));
| 87232 | Py_RETURN_NONE; |  | 87184 | Py_RETURN_NONE;
| 87233 | } |  | 87185 | }
| 87234 |  |  | 87186 |
| 87235 | return NULL; |  | 87187 | return NULL;
| 87236 | } |  | 87188 | }
| 87237 |  |  | 87189 |
| 87238 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87190 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw)
| 87239 | { |  | 87191 | {
| 87240 | using namespace cv::rgbd; |  | 87192 | using namespace cv::rgbd;
| 87241 |  |  | 87193 |
| 87242 |  |  | 87194 |
| 87243 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87195 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87244 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87196 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87245 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87197 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87246 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87198 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87247 | PyObject* pyobj_val = NULL; |  | 87199 | PyObject* pyobj_val = NULL;
| 87248 | double val=0; |  | 87200 | double val=0;
| 87249 |  |  | 87201 |
| 87250 | const char* keywords[] = { "val", NULL }; |  | 87202 | const char* keywords[] = { "val", NULL };
| 87251 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxTranslation", (char**)keywords, &pyobj_val) && |  | 87203 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMaxTranslation", (char**)keywords, &pyobj_val) &&
| 87252 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87204 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87253 | { |  | 87205 | {
| 87254 | ERRWRAP2(_self_->setMaxTranslation(val)); |  | 87206 | ERRWRAP2(_self_->setMaxTranslation(val));
| 87255 | Py_RETURN_NONE; |  | 87207 | Py_RETURN_NONE;
| 87256 | } |  | 87208 | }
| 87257 |  |  | 87209 |
| 87258 | return NULL; |  | 87210 | return NULL;
| 87259 | } |  | 87211 | }
| 87260 |  |  | 87212 |
| 87261 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMinDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87213 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setMinDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 87262 | { |  | 87214 | {
| 87263 | using namespace cv::rgbd; |  | 87215 | using namespace cv::rgbd;
| 87264 |  |  | 87216 |
| 87265 |  |  | 87217 |
| 87266 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87218 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87267 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87219 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87268 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87220 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87269 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87221 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87270 | PyObject* pyobj_val = NULL; |  | 87222 | PyObject* pyobj_val = NULL;
| 87271 | double val=0; |  | 87223 | double val=0;
| 87272 |  |  | 87224 |
| 87273 | const char* keywords[] = { "val", NULL }; |  | 87225 | const char* keywords[] = { "val", NULL };
| 87274 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMinDepth", (char**)keywords, &pyobj_val) && |  | 87226 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setMinDepth", (char**)keywords, &pyobj_val) &&
| 87275 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87227 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87276 | { |  | 87228 | {
| 87277 | ERRWRAP2(_self_->setMinDepth(val)); |  | 87229 | ERRWRAP2(_self_->setMinDepth(val));
| 87278 | Py_RETURN_NONE; |  | 87230 | Py_RETURN_NONE;
| 87279 | } |  | 87231 | }
| 87280 |  |  | 87232 |
| 87281 | return NULL; |  | 87233 | return NULL;
| 87282 | } |  | 87234 | }
| 87283 |  |  | 87235 |
| 87284 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87236 | static PyObject* pyopencv_cv_rgbd_rgbd_ICPOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 87285 | { |  | 87237 | {
| 87286 | using namespace cv::rgbd; |  | 87238 | using namespace cv::rgbd;
| 87287 |  |  | 87239 |
| 87288 |  |  | 87240 |
| 87289 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0; |  | 87241 | Ptr<cv::rgbd::ICPOdometry> * self1 = 0;
| 87290 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1)) |  | 87242 | if (!pyopencv_rgbd_ICPOdometry_getp(self, self1))
| 87291 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)"); |  | 87243 | return failmsgp("Incorrect type of self (must be 'rgbd_ICPOdometry' or its derivative)");
| 87292 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1); |  | 87244 | Ptr<cv::rgbd::ICPOdometry> _self_ = *(self1);
| 87293 | PyObject* pyobj_val = NULL; |  | 87245 | PyObject* pyobj_val = NULL;
| 87294 | int val=0; |  | 87246 | int val=0;
| 87295 |  |  | 87247 |
| 87296 | const char* keywords[] = { "val", NULL }; |  | 87248 | const char* keywords[] = { "val", NULL };
| 87297 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setTransformType", (char**)keywords, &pyobj_val) && |  | 87249 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_ICPOdometry.setTransformType", (char**)keywords, &pyobj_val) &&
| 87298 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87250 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87299 | { |  | 87251 | {
| 87300 | ERRWRAP2(_self_->setTransformType(val)); |  | 87252 | ERRWRAP2(_self_->setTransformType(val));
| 87301 | Py_RETURN_NONE; |  | 87253 | Py_RETURN_NONE;
| 87302 | } |  | 87254 | }
| 87303 |  |  | 87255 |
| 87304 | return NULL; |  | 87256 | return NULL;
| 87305 | } |  | 87257 | }
| 87306 |  |  | 87258 |
| 87307 |  |  | 87259 |
| 87308 |  |  | 87260 |
| 87309 | // Tables (rgbd_ICPOdometry) |  | 87261 | // Tables (rgbd_ICPOdometry)
| 87310 |  |  | 87262 |
| 87311 | static PyGetSetDef pyopencv_rgbd_ICPOdometry_getseters[] = |  | 87263 | static PyGetSetDef pyopencv_rgbd_ICPOdometry_getseters[] =
| 87312 | { |  | 87264 | {
| 87313 | {NULL} /* Sentinel */ |  | 87265 | {NULL} /* Sentinel */
| 87314 | }; |  | 87266 | };
| 87315 |  |  | 87267 |
| 87316 | static PyMethodDef pyopencv_rgbd_ICPOdometry_methods[] = |  | 87268 | static PyMethodDef pyopencv_rgbd_ICPOdometry_methods[] =
| 87317 | { |  | 87269 | {
| 87318 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_create_static, METH_STATIC), "create([, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, maxPointsPart[, iterCounts[, transformType]]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param minDepth Pixels with depth less than minDepth will not be used\n. * @param maxDepth Pixels with depth larger than maxDepth will not be used\n. * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff\n. * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart\n. * @param iterCounts Count of iterations on each pyramid level.\n. * @param transformType Class of trasformation"}, |  | 87270 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_create_static, METH_STATIC), "create([, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, maxPointsPart[, iterCounts[, transformType]]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param minDepth Pixels with depth less than minDepth will not be used\n. * @param maxDepth Pixels with depth larger than maxDepth will not be used\n. * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff\n. * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart\n. * @param iterCounts Count of iterations on each pyramid level.\n. * @param transformType Class of trasformation"},
| 87319 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."}, |  | 87271 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."},
| 87320 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."}, |  | 87272 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."},
| 87321 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepth, 0), "getMaxDepth() -> retval\n."}, |  | 87273 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepth, 0), "getMaxDepth() -> retval\n."},
| 87322 | {"getMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepthDiff, 0), "getMaxDepthDiff() -> retval\n."}, |  | 87274 | {"getMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxDepthDiff, 0), "getMaxDepthDiff() -> retval\n."},
| 87323 | {"getMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxPointsPart, 0), "getMaxPointsPart() -> retval\n."}, |  | 87275 | {"getMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxPointsPart, 0), "getMaxPointsPart() -> retval\n."},
| 87324 | {"getMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxRotation, 0), "getMaxRotation() -> retval\n."}, |  | 87276 | {"getMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxRotation, 0), "getMaxRotation() -> retval\n."},
| 87325 | {"getMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxTranslation, 0), "getMaxTranslation() -> retval\n."}, |  | 87277 | {"getMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMaxTranslation, 0), "getMaxTranslation() -> retval\n."},
| 87326 | {"getMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMinDepth, 0), "getMinDepth() -> retval\n."}, |  | 87278 | {"getMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getMinDepth, 0), "getMinDepth() -> retval\n."},
| 87327 | {"getNormalsComputer", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getNormalsComputer, 0), "getNormalsComputer() -> retval\n."}, |  | 87279 | {"getNormalsComputer", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getNormalsComputer, 0), "getNormalsComputer() -> retval\n."},
| 87328 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getTransformType, 0), "getTransformType() -> retval\n."}, |  | 87280 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_getTransformType, 0), "getTransformType() -> retval\n."},
| 87329 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."}, |  | 87281 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."},
| 87330 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."}, |  | 87282 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."},
| 87331 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."}, |  | 87283 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."},
| 87332 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepth, 0), "setMaxDepth(val) -> None\n."}, |  | 87284 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepth, 0), "setMaxDepth(val) -> None\n."},
| 87333 | {"setMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepthDiff, 0), "setMaxDepthDiff(val) -> None\n."}, |  | 87285 | {"setMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxDepthDiff, 0), "setMaxDepthDiff(val) -> None\n."},
| 87334 | {"setMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxPointsPart, 0), "setMaxPointsPart(val) -> None\n."}, |  | 87286 | {"setMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxPointsPart, 0), "setMaxPointsPart(val) -> None\n."},
| 87335 | {"setMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxRotation, 0), "setMaxRotation(val) -> None\n."}, |  | 87287 | {"setMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxRotation, 0), "setMaxRotation(val) -> None\n."},
| 87336 | {"setMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxTranslation, 0), "setMaxTranslation(val) -> None\n."}, |  | 87288 | {"setMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMaxTranslation, 0), "setMaxTranslation(val) -> None\n."},
| 87337 | {"setMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMinDepth, 0), "setMinDepth(val) -> None\n."}, |  | 87289 | {"setMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setMinDepth, 0), "setMinDepth(val) -> None\n."},
| 87338 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setTransformType, 0), "setTransformType(val) -> None\n."}, |  | 87290 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_ICPOdometry_setTransformType, 0), "setTransformType(val) -> None\n."},
| 87339 |  |  | 87291 |
| 87340 | {NULL, NULL} |  | 87292 | {NULL, NULL}
| 87341 | }; |  | 87293 | };
| 87342 |  |  | 87294 |
| 87343 | // Converter (rgbd_ICPOdometry) |  | 87295 | // Converter (rgbd_ICPOdometry)
| 87344 |  |  | 87296 |
| 87345 | template<> |  | 87297 | template<>
| 87346 | struct PyOpenCV_Converter< Ptr<cv::rgbd::ICPOdometry> > |  | 87298 | struct PyOpenCV_Converter< Ptr<cv::rgbd::ICPOdometry> >
| 87347 | { |  | 87299 | {
| 87348 | static PyObject* from(const Ptr<cv::rgbd::ICPOdometry>& r) |  | 87300 | static PyObject* from(const Ptr<cv::rgbd::ICPOdometry>& r)
| 87349 | { |  | 87301 | {
| 87350 | return pyopencv_rgbd_ICPOdometry_Instance(r); |  | 87302 | return pyopencv_rgbd_ICPOdometry_Instance(r);
| 87351 | } |  | 87303 | }
| 87352 | static bool to(PyObject* src, Ptr<cv::rgbd::ICPOdometry>& dst, const ArgInfo& info) |  | 87304 | static bool to(PyObject* src, Ptr<cv::rgbd::ICPOdometry>& dst, const ArgInfo& info)
| 87353 | { |  | 87305 | {
| 87354 | if(!src || src == Py_None) |  | 87306 | if(!src || src == Py_None)
| 87355 | return true; |  | 87307 | return true;
| 87356 | Ptr<cv::rgbd::ICPOdometry> * dst_; |  | 87308 | Ptr<cv::rgbd::ICPOdometry> * dst_;
| 87357 | if (pyopencv_rgbd_ICPOdometry_getp(src, dst_)) |  | 87309 | if (pyopencv_rgbd_ICPOdometry_getp(src, dst_))
| 87358 | { |  | 87310 | {
| 87359 | dst = *dst_; |  | 87311 | dst = *dst_;
| 87360 | return true; |  | 87312 | return true;
| 87361 | } |  | 87313 | }
| 87362 |  |  | 87314 |
| 87363 | failmsg("Expected Ptr<cv::rgbd::ICPOdometry> for argument '%s'", info.name); |  | 87315 | failmsg("Expected Ptr<cv::rgbd::ICPOdometry> for argument '%s'", info.name);
| 87364 | return false; |  | 87316 | return false;
| 87365 | } |  | 87317 | }
| 87366 | }; |  | 87318 | };
| 87367 |  |  | 87319 |
| 87368 | //================================================================================ |  | 87320 | //================================================================================
| 87369 | // rgbd_Odometry (Generic) |  | 87321 | // rgbd_Odometry (Generic)
| 87370 | //================================================================================ |  | 87322 | //================================================================================
| 87371 |  |  | 87323 |
| 87372 | // GetSet (rgbd_Odometry) |  | 87324 | // GetSet (rgbd_Odometry)
| 87373 |  |  | 87325 |
| 87374 |  |  | 87326 |
| 87375 |  |  | 87327 |
| 87376 | // Methods (rgbd_Odometry) |  | 87328 | // Methods (rgbd_Odometry)
| 87377 |  |  | 87329 |
| 87378 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87330 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH(PyObject* self, PyObject* py_args, PyObject* kw)
| 87379 | { |  | 87331 | {
| 87380 | using namespace cv::rgbd; |  | 87332 | using namespace cv::rgbd;
| 87381 |  |  | 87333 |
| 87382 |  |  | 87334 |
| 87383 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87335 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87384 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87336 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87385 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87337 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87386 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87338 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87387 | float retval; |  | 87339 | float retval;
| 87388 |  |  | 87340 |
| 87389 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87341 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87390 | { |  | 87342 | {
| 87391 | ERRWRAP2(retval = _self_->DEFAULT_MAX_DEPTH()); |  | 87343 | ERRWRAP2(retval = _self_->DEFAULT_MAX_DEPTH());
| 87392 | return pyopencv_from(retval); |  | 87344 | return pyopencv_from(retval);
| 87393 | } |  | 87345 | }
| 87394 |  |  | 87346 |
| 87395 | return NULL; |  | 87347 | return NULL;
| 87396 | } |  | 87348 | }
| 87397 |  |  | 87349 |
| 87398 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH_DIFF(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87350 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH_DIFF(PyObject* self, PyObject* py_args, PyObject* kw)
| 87399 | { |  | 87351 | {
| 87400 | using namespace cv::rgbd; |  | 87352 | using namespace cv::rgbd;
| 87401 |  |  | 87353 |
| 87402 |  |  | 87354 |
| 87403 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87355 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87404 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87356 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87405 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87357 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87406 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87358 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87407 | float retval; |  | 87359 | float retval;
| 87408 |  |  | 87360 |
| 87409 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87361 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87410 | { |  | 87362 | {
| 87411 | ERRWRAP2(retval = _self_->DEFAULT_MAX_DEPTH_DIFF()); |  | 87363 | ERRWRAP2(retval = _self_->DEFAULT_MAX_DEPTH_DIFF());
| 87412 | return pyopencv_from(retval); |  | 87364 | return pyopencv_from(retval);
| 87413 | } |  | 87365 | }
| 87414 |  |  | 87366 |
| 87415 | return NULL; |  | 87367 | return NULL;
| 87416 | } |  | 87368 | }
| 87417 |  |  | 87369 |
| 87418 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_POINTS_PART(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87370 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_POINTS_PART(PyObject* self, PyObject* py_args, PyObject* kw)
| 87419 | { |  | 87371 | {
| 87420 | using namespace cv::rgbd; |  | 87372 | using namespace cv::rgbd;
| 87421 |  |  | 87373 |
| 87422 |  |  | 87374 |
| 87423 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87375 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87424 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87376 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87425 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87377 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87426 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87378 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87427 | float retval; |  | 87379 | float retval;
| 87428 |  |  | 87380 |
| 87429 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87381 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87430 | { |  | 87382 | {
| 87431 | ERRWRAP2(retval = _self_->DEFAULT_MAX_POINTS_PART()); |  | 87383 | ERRWRAP2(retval = _self_->DEFAULT_MAX_POINTS_PART());
| 87432 | return pyopencv_from(retval); |  | 87384 | return pyopencv_from(retval);
| 87433 | } |  | 87385 | }
| 87434 |  |  | 87386 |
| 87435 | return NULL; |  | 87387 | return NULL;
| 87436 | } |  | 87388 | }
| 87437 |  |  | 87389 |
| 87438 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_ROTATION(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87390 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_ROTATION(PyObject* self, PyObject* py_args, PyObject* kw)
| 87439 | { |  | 87391 | {
| 87440 | using namespace cv::rgbd; |  | 87392 | using namespace cv::rgbd;
| 87441 |  |  | 87393 |
| 87442 |  |  | 87394 |
| 87443 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87395 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87444 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87396 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87445 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87397 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87446 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87398 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87447 | float retval; |  | 87399 | float retval;
| 87448 |  |  | 87400 |
| 87449 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87401 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87450 | { |  | 87402 | {
| 87451 | ERRWRAP2(retval = _self_->DEFAULT_MAX_ROTATION()); |  | 87403 | ERRWRAP2(retval = _self_->DEFAULT_MAX_ROTATION());
| 87452 | return pyopencv_from(retval); |  | 87404 | return pyopencv_from(retval);
| 87453 | } |  | 87405 | }
| 87454 |  |  | 87406 |
| 87455 | return NULL; |  | 87407 | return NULL;
| 87456 | } |  | 87408 | }
| 87457 |  |  | 87409 |
| 87458 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_TRANSLATION(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87410 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_TRANSLATION(PyObject* self, PyObject* py_args, PyObject* kw)
| 87459 | { |  | 87411 | {
| 87460 | using namespace cv::rgbd; |  | 87412 | using namespace cv::rgbd;
| 87461 |  |  | 87413 |
| 87462 |  |  | 87414 |
| 87463 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87415 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87464 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87416 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87465 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87417 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87466 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87418 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87467 | float retval; |  | 87419 | float retval;
| 87468 |  |  | 87420 |
| 87469 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87421 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87470 | { |  | 87422 | {
| 87471 | ERRWRAP2(retval = _self_->DEFAULT_MAX_TRANSLATION()); |  | 87423 | ERRWRAP2(retval = _self_->DEFAULT_MAX_TRANSLATION());
| 87472 | return pyopencv_from(retval); |  | 87424 | return pyopencv_from(retval);
| 87473 | } |  | 87425 | }
| 87474 |  |  | 87426 |
| 87475 | return NULL; |  | 87427 | return NULL;
| 87476 | } |  | 87428 | }
| 87477 |  |  | 87429 |
| 87478 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MIN_DEPTH(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87430 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MIN_DEPTH(PyObject* self, PyObject* py_args, PyObject* kw)
| 87479 | { |  | 87431 | {
| 87480 | using namespace cv::rgbd; |  | 87432 | using namespace cv::rgbd;
| 87481 |  |  | 87433 |
| 87482 |  |  | 87434 |
| 87483 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87435 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87484 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87436 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87485 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87437 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87486 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87438 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87487 | float retval; |  | 87439 | float retval;
| 87488 |  |  | 87440 |
| 87489 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87441 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87490 | { |  | 87442 | {
| 87491 | ERRWRAP2(retval = _self_->DEFAULT_MIN_DEPTH()); |  | 87443 | ERRWRAP2(retval = _self_->DEFAULT_MIN_DEPTH());
| 87492 | return pyopencv_from(retval); |  | 87444 | return pyopencv_from(retval);
| 87493 | } |  | 87445 | }
| 87494 |  |  | 87446 |
| 87495 | return NULL; |  | 87447 | return NULL;
| 87496 | } |  | 87448 | }
| 87497 |  |  | 87449 |
| 87498 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_compute(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87450 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_compute(PyObject* self, PyObject* py_args, PyObject* kw)
| 87499 | { |  | 87451 | {
| 87500 | using namespace cv::rgbd; |  | 87452 | using namespace cv::rgbd;
| 87501 |  |  | 87453 |
| 87502 |  |  | 87454 |
| 87503 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87455 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87504 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87456 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87505 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87457 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87506 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87458 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87507 | pyPrepareArgumentConversionErrorsStorage(2); |  | 87459 | pyPrepareArgumentConversionErrorsStorage(2);
| 87508 |  |  | 87460 |
| 87509 | { |  | 87461 | {
| 87510 | PyObject* pyobj_srcImage = NULL; |  | 87462 | PyObject* pyobj_srcImage = NULL;
| 87511 | Mat srcImage; |  | 87463 | Mat srcImage;
| 87512 | PyObject* pyobj_srcDepth = NULL; |  | 87464 | PyObject* pyobj_srcDepth = NULL;
| 87513 | Mat srcDepth; |  | 87465 | Mat srcDepth;
| 87514 | PyObject* pyobj_srcMask = NULL; |  | 87466 | PyObject* pyobj_srcMask = NULL;
| 87515 | Mat srcMask; |  | 87467 | Mat srcMask;
| 87516 | PyObject* pyobj_dstImage = NULL; |  | 87468 | PyObject* pyobj_dstImage = NULL;
| 87517 | Mat dstImage; |  | 87469 | Mat dstImage;
| 87518 | PyObject* pyobj_dstDepth = NULL; |  | 87470 | PyObject* pyobj_dstDepth = NULL;
| 87519 | Mat dstDepth; |  | 87471 | Mat dstDepth;
| 87520 | PyObject* pyobj_dstMask = NULL; |  | 87472 | PyObject* pyobj_dstMask = NULL;
| 87521 | Mat dstMask; |  | 87473 | Mat dstMask;
| 87522 | PyObject* pyobj_Rt = NULL; |  | 87474 | PyObject* pyobj_Rt = NULL;
| 87523 | Mat Rt; |  | 87475 | Mat Rt;
| 87524 | PyObject* pyobj_initRt = NULL; |  | 87476 | PyObject* pyobj_initRt = NULL;
| 87525 | Mat initRt; |  | 87477 | Mat initRt;
| 87526 | bool retval; |  | 87478 | bool retval;
| 87527 |  |  | 87479 |
| 87528 | const char* keywords[] = { "srcImage", "srcDepth", "srcMask", "dstImage", "dstDepth", "dstMask", "Rt", "initRt", NULL }; |  | 87480 | const char* keywords[] = { "srcImage", "srcDepth", "srcMask", "dstImage", "dstDepth", "dstMask", "Rt", "initRt", NULL };
| 87529 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|OO:rgbd_Odometry.compute", (char**)keywords, &pyobj_srcImage, &pyobj_srcDepth, &pyobj_srcMask, &pyobj_dstImage, &pyobj_dstDepth, &pyobj_dstMask, &pyobj_Rt, &pyobj_initRt) && |  | 87481 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|OO:rgbd_Odometry.compute", (char**)keywords, &pyobj_srcImage, &pyobj_srcDepth, &pyobj_srcMask, &pyobj_dstImage, &pyobj_dstDepth, &pyobj_dstMask, &pyobj_Rt, &pyobj_initRt) &&
| 87530 | pyopencv_to_safe(pyobj_srcImage, srcImage, ArgInfo("srcImage", 0)) && |  | 87482 | pyopencv_to_safe(pyobj_srcImage, srcImage, ArgInfo("srcImage", 0)) &&
| 87531 | pyopencv_to_safe(pyobj_srcDepth, srcDepth, ArgInfo("srcDepth", 0)) && |  | 87483 | pyopencv_to_safe(pyobj_srcDepth, srcDepth, ArgInfo("srcDepth", 0)) &&
| 87532 | pyopencv_to_safe(pyobj_srcMask, srcMask, ArgInfo("srcMask", 0)) && |  | 87484 | pyopencv_to_safe(pyobj_srcMask, srcMask, ArgInfo("srcMask", 0)) &&
| 87533 | pyopencv_to_safe(pyobj_dstImage, dstImage, ArgInfo("dstImage", 0)) && |  | 87485 | pyopencv_to_safe(pyobj_dstImage, dstImage, ArgInfo("dstImage", 0)) &&
| 87534 | pyopencv_to_safe(pyobj_dstDepth, dstDepth, ArgInfo("dstDepth", 0)) && |  | 87486 | pyopencv_to_safe(pyobj_dstDepth, dstDepth, ArgInfo("dstDepth", 0)) &&
| 87535 | pyopencv_to_safe(pyobj_dstMask, dstMask, ArgInfo("dstMask", 0)) && |  | 87487 | pyopencv_to_safe(pyobj_dstMask, dstMask, ArgInfo("dstMask", 0)) &&
| 87536 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) && |  | 87488 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) &&
| 87537 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) ) |  | 87489 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) )
| 87538 | { |  | 87490 | {
| 87539 | ERRWRAP2(retval = _self_->compute(srcImage, srcDepth, srcMask, dstImage, dstDepth, dstMask, Rt, initRt)); |  | 87491 | ERRWRAP2(retval = _self_->compute(srcImage, srcDepth, srcMask, dstImage, dstDepth, dstMask, Rt, initRt));
| 87540 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt)); |  | 87492 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt));
| 87541 | } |  | 87493 | }
| 87542 |  |  | 87494 |
| 87543 |  |  | 87495 |
| 87544 | pyPopulateArgumentConversionErrors(); |  | 87496 | pyPopulateArgumentConversionErrors();
| 87545 | } |  | 87497 | }
| 87546 |  |  | 87498 |
| 87547 |  |  | 87499 |
| 87548 | { |  | 87500 | {
| 87549 | PyObject* pyobj_srcImage = NULL; |  | 87501 | PyObject* pyobj_srcImage = NULL;
| 87550 | Mat srcImage; |  | 87502 | Mat srcImage;
| 87551 | PyObject* pyobj_srcDepth = NULL; |  | 87503 | PyObject* pyobj_srcDepth = NULL;
| 87552 | Mat srcDepth; |  | 87504 | Mat srcDepth;
| 87553 | PyObject* pyobj_srcMask = NULL; |  | 87505 | PyObject* pyobj_srcMask = NULL;
| 87554 | Mat srcMask; |  | 87506 | Mat srcMask;
| 87555 | PyObject* pyobj_dstImage = NULL; |  | 87507 | PyObject* pyobj_dstImage = NULL;
| 87556 | Mat dstImage; |  | 87508 | Mat dstImage;
| 87557 | PyObject* pyobj_dstDepth = NULL; |  | 87509 | PyObject* pyobj_dstDepth = NULL;
| 87558 | Mat dstDepth; |  | 87510 | Mat dstDepth;
| 87559 | PyObject* pyobj_dstMask = NULL; |  | 87511 | PyObject* pyobj_dstMask = NULL;
| 87560 | Mat dstMask; |  | 87512 | Mat dstMask;
| 87561 | PyObject* pyobj_Rt = NULL; |  | 87513 | PyObject* pyobj_Rt = NULL;
| 87562 | UMat Rt; |  | 87514 | UMat Rt;
| 87563 | PyObject* pyobj_initRt = NULL; |  | 87515 | PyObject* pyobj_initRt = NULL;
| 87564 | Mat initRt; |  | 87516 | Mat initRt;
| 87565 | bool retval; |  | 87517 | bool retval;
| 87566 |  |  | 87518 |
| 87567 | const char* keywords[] = { "srcImage", "srcDepth", "srcMask", "dstImage", "dstDepth", "dstMask", "Rt", "initRt", NULL }; |  | 87519 | const char* keywords[] = { "srcImage", "srcDepth", "srcMask", "dstImage", "dstDepth", "dstMask", "Rt", "initRt", NULL };
| 87568 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|OO:rgbd_Odometry.compute", (char**)keywords, &pyobj_srcImage, &pyobj_srcDepth, &pyobj_srcMask, &pyobj_dstImage, &pyobj_dstDepth, &pyobj_dstMask, &pyobj_Rt, &pyobj_initRt) && |  | 87520 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOOOO|OO:rgbd_Odometry.compute", (char**)keywords, &pyobj_srcImage, &pyobj_srcDepth, &pyobj_srcMask, &pyobj_dstImage, &pyobj_dstDepth, &pyobj_dstMask, &pyobj_Rt, &pyobj_initRt) &&
| 87569 | pyopencv_to_safe(pyobj_srcImage, srcImage, ArgInfo("srcImage", 0)) && |  | 87521 | pyopencv_to_safe(pyobj_srcImage, srcImage, ArgInfo("srcImage", 0)) &&
| 87570 | pyopencv_to_safe(pyobj_srcDepth, srcDepth, ArgInfo("srcDepth", 0)) && |  | 87522 | pyopencv_to_safe(pyobj_srcDepth, srcDepth, ArgInfo("srcDepth", 0)) &&
| 87571 | pyopencv_to_safe(pyobj_srcMask, srcMask, ArgInfo("srcMask", 0)) && |  | 87523 | pyopencv_to_safe(pyobj_srcMask, srcMask, ArgInfo("srcMask", 0)) &&
| 87572 | pyopencv_to_safe(pyobj_dstImage, dstImage, ArgInfo("dstImage", 0)) && |  | 87524 | pyopencv_to_safe(pyobj_dstImage, dstImage, ArgInfo("dstImage", 0)) &&
| 87573 | pyopencv_to_safe(pyobj_dstDepth, dstDepth, ArgInfo("dstDepth", 0)) && |  | 87525 | pyopencv_to_safe(pyobj_dstDepth, dstDepth, ArgInfo("dstDepth", 0)) &&
| 87574 | pyopencv_to_safe(pyobj_dstMask, dstMask, ArgInfo("dstMask", 0)) && |  | 87526 | pyopencv_to_safe(pyobj_dstMask, dstMask, ArgInfo("dstMask", 0)) &&
| 87575 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) && |  | 87527 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) &&
| 87576 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) ) |  | 87528 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) )
| 87577 | { |  | 87529 | {
| 87578 | ERRWRAP2(retval = _self_->compute(srcImage, srcDepth, srcMask, dstImage, dstDepth, dstMask, Rt, initRt)); |  | 87530 | ERRWRAP2(retval = _self_->compute(srcImage, srcDepth, srcMask, dstImage, dstDepth, dstMask, Rt, initRt));
| 87579 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt)); |  | 87531 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt));
| 87580 | } |  | 87532 | }
| 87581 |  |  | 87533 |
| 87582 |  |  | 87534 |
| 87583 | pyPopulateArgumentConversionErrors(); |  | 87535 | pyPopulateArgumentConversionErrors();
| 87584 | } |  | 87536 | }
| 87585 | pyRaiseCVOverloadException("compute"); |  | 87537 | pyRaiseCVOverloadException("compute");
| 87586 |  |  | 87538 |
| 87587 | return NULL; |  | 87539 | return NULL;
| 87588 | } |  | 87540 | }
| 87589 |  |  | 87541 |
| 87590 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_compute2(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87542 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_compute2(PyObject* self, PyObject* py_args, PyObject* kw)
| 87591 | { |  | 87543 | {
| 87592 | using namespace cv::rgbd; |  | 87544 | using namespace cv::rgbd;
| 87593 |  |  | 87545 |
| 87594 |  |  | 87546 |
| 87595 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87547 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87596 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87548 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87597 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87549 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87598 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87550 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87599 | pyPrepareArgumentConversionErrorsStorage(2); |  | 87551 | pyPrepareArgumentConversionErrorsStorage(2);
| 87600 |  |  | 87552 |
| 87601 | { |  | 87553 | {
| 87602 | PyObject* pyobj_srcFrame = NULL; |  | 87554 | PyObject* pyobj_srcFrame = NULL;
| 87603 | Ptr<OdometryFrame> srcFrame; |  | 87555 | Ptr<OdometryFrame> srcFrame;
| 87604 | PyObject* pyobj_dstFrame = NULL; |  | 87556 | PyObject* pyobj_dstFrame = NULL;
| 87605 | Ptr<OdometryFrame> dstFrame; |  | 87557 | Ptr<OdometryFrame> dstFrame;
| 87606 | PyObject* pyobj_Rt = NULL; |  | 87558 | PyObject* pyobj_Rt = NULL;
| 87607 | Mat Rt; |  | 87559 | Mat Rt;
| 87608 | PyObject* pyobj_initRt = NULL; |  | 87560 | PyObject* pyobj_initRt = NULL;
| 87609 | Mat initRt; |  | 87561 | Mat initRt;
| 87610 | bool retval; |  | 87562 | bool retval;
| 87611 |  |  | 87563 |
| 87612 | const char* keywords[] = { "srcFrame", "dstFrame", "Rt", "initRt", NULL }; |  | 87564 | const char* keywords[] = { "srcFrame", "dstFrame", "Rt", "initRt", NULL };
| 87613 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_Odometry.compute2", (char**)keywords, &pyobj_srcFrame, &pyobj_dstFrame, &pyobj_Rt, &pyobj_initRt) && |  | 87565 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_Odometry.compute2", (char**)keywords, &pyobj_srcFrame, &pyobj_dstFrame, &pyobj_Rt, &pyobj_initRt) &&
| 87614 | pyopencv_to_safe(pyobj_srcFrame, srcFrame, ArgInfo("srcFrame", 0)) && |  | 87566 | pyopencv_to_safe(pyobj_srcFrame, srcFrame, ArgInfo("srcFrame", 0)) &&
| 87615 | pyopencv_to_safe(pyobj_dstFrame, dstFrame, ArgInfo("dstFrame", 0)) && |  | 87567 | pyopencv_to_safe(pyobj_dstFrame, dstFrame, ArgInfo("dstFrame", 0)) &&
| 87616 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) && |  | 87568 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) &&
| 87617 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) ) |  | 87569 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) )
| 87618 | { |  | 87570 | {
| 87619 | ERRWRAP2(retval = _self_->compute(srcFrame, dstFrame, Rt, initRt)); |  | 87571 | ERRWRAP2(retval = _self_->compute(srcFrame, dstFrame, Rt, initRt));
| 87620 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt)); |  | 87572 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt));
| 87621 | } |  | 87573 | }
| 87622 |  |  | 87574 |
| 87623 |  |  | 87575 |
| 87624 | pyPopulateArgumentConversionErrors(); |  | 87576 | pyPopulateArgumentConversionErrors();
| 87625 | } |  | 87577 | }
| 87626 |  |  | 87578 |
| 87627 |  |  | 87579 |
| 87628 | { |  | 87580 | {
| 87629 | PyObject* pyobj_srcFrame = NULL; |  | 87581 | PyObject* pyobj_srcFrame = NULL;
| 87630 | Ptr<OdometryFrame> srcFrame; |  | 87582 | Ptr<OdometryFrame> srcFrame;
| 87631 | PyObject* pyobj_dstFrame = NULL; |  | 87583 | PyObject* pyobj_dstFrame = NULL;
| 87632 | Ptr<OdometryFrame> dstFrame; |  | 87584 | Ptr<OdometryFrame> dstFrame;
| 87633 | PyObject* pyobj_Rt = NULL; |  | 87585 | PyObject* pyobj_Rt = NULL;
| 87634 | UMat Rt; |  | 87586 | UMat Rt;
| 87635 | PyObject* pyobj_initRt = NULL; |  | 87587 | PyObject* pyobj_initRt = NULL;
| 87636 | Mat initRt; |  | 87588 | Mat initRt;
| 87637 | bool retval; |  | 87589 | bool retval;
| 87638 |  |  | 87590 |
| 87639 | const char* keywords[] = { "srcFrame", "dstFrame", "Rt", "initRt", NULL }; |  | 87591 | const char* keywords[] = { "srcFrame", "dstFrame", "Rt", "initRt", NULL };
| 87640 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_Odometry.compute2", (char**)keywords, &pyobj_srcFrame, &pyobj_dstFrame, &pyobj_Rt, &pyobj_initRt) && |  | 87592 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_Odometry.compute2", (char**)keywords, &pyobj_srcFrame, &pyobj_dstFrame, &pyobj_Rt, &pyobj_initRt) &&
| 87641 | pyopencv_to_safe(pyobj_srcFrame, srcFrame, ArgInfo("srcFrame", 0)) && |  | 87593 | pyopencv_to_safe(pyobj_srcFrame, srcFrame, ArgInfo("srcFrame", 0)) &&
| 87642 | pyopencv_to_safe(pyobj_dstFrame, dstFrame, ArgInfo("dstFrame", 0)) && |  | 87594 | pyopencv_to_safe(pyobj_dstFrame, dstFrame, ArgInfo("dstFrame", 0)) &&
| 87643 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) && |  | 87595 | pyopencv_to_safe(pyobj_Rt, Rt, ArgInfo("Rt", 1)) &&
| 87644 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) ) |  | 87596 | pyopencv_to_safe(pyobj_initRt, initRt, ArgInfo("initRt", 0)) )
| 87645 | { |  | 87597 | {
| 87646 | ERRWRAP2(retval = _self_->compute(srcFrame, dstFrame, Rt, initRt)); |  | 87598 | ERRWRAP2(retval = _self_->compute(srcFrame, dstFrame, Rt, initRt));
| 87647 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt)); |  | 87599 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(Rt));
| 87648 | } |  | 87600 | }
| 87649 |  |  | 87601 |
| 87650 |  |  | 87602 |
| 87651 | pyPopulateArgumentConversionErrors(); |  | 87603 | pyPopulateArgumentConversionErrors();
| 87652 | } |  | 87604 | }
| 87653 | pyRaiseCVOverloadException("compute2"); |  | 87605 | pyRaiseCVOverloadException("compute2");
| 87654 |  |  | 87606 |
| 87655 | return NULL; |  | 87607 | return NULL;
| 87656 | } |  | 87608 | }
| 87657 |  |  | 87609 |
| 87658 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87610 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 87659 | { |  | 87611 | {
| 87660 | using namespace cv::rgbd; |  | 87612 | using namespace cv::rgbd;
| 87661 |  |  | 87613 |
| 87662 | PyObject* pyobj_odometryType = NULL; |  | 87614 | PyObject* pyobj_odometryType = NULL;
| 87663 | String odometryType; |  | 87615 | String odometryType;
| 87664 | Ptr<Odometry> retval; |  | 87616 | Ptr<Odometry> retval;
| 87665 |  |  | 87617 |
| 87666 | const char* keywords[] = { "odometryType", NULL }; |  | 87618 | const char* keywords[] = { "odometryType", NULL };
| 87667 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_Odometry.create", (char**)keywords, &pyobj_odometryType) && |  | 87619 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_Odometry.create", (char**)keywords, &pyobj_odometryType) &&
| 87668 | pyopencv_to_safe(pyobj_odometryType, odometryType, ArgInfo("odometryType", 0)) ) |  | 87620 | pyopencv_to_safe(pyobj_odometryType, odometryType, ArgInfo("odometryType", 0)) )
| 87669 | { |  | 87621 | {
| 87670 | ERRWRAP2(retval = cv::rgbd::Odometry::create(odometryType)); |  | 87622 | ERRWRAP2(retval = cv::rgbd::Odometry::create(odometryType));
| 87671 | return pyopencv_from(retval); |  | 87623 | return pyopencv_from(retval);
| 87672 | } |  | 87624 | }
| 87673 |  |  | 87625 |
| 87674 | return NULL; |  | 87626 | return NULL;
| 87675 | } |  | 87627 | }
| 87676 |  |  | 87628 |
| 87677 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87629 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 87678 | { |  | 87630 | {
| 87679 | using namespace cv::rgbd; |  | 87631 | using namespace cv::rgbd;
| 87680 |  |  | 87632 |
| 87681 |  |  | 87633 |
| 87682 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87634 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87683 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87635 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87684 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87636 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87685 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87637 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87686 | cv::Mat retval; |  | 87638 | cv::Mat retval;
| 87687 |  |  | 87639 |
| 87688 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87640 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87689 | { |  | 87641 | {
| 87690 | ERRWRAP2(retval = _self_->getCameraMatrix()); |  | 87642 | ERRWRAP2(retval = _self_->getCameraMatrix());
| 87691 | return pyopencv_from(retval); |  | 87643 | return pyopencv_from(retval);
| 87692 | } |  | 87644 | }
| 87693 |  |  | 87645 |
| 87694 | return NULL; |  | 87646 | return NULL;
| 87695 | } |  | 87647 | }
| 87696 |  |  | 87648 |
| 87697 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87649 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 87698 | { |  | 87650 | {
| 87699 | using namespace cv::rgbd; |  | 87651 | using namespace cv::rgbd;
| 87700 |  |  | 87652 |
| 87701 |  |  | 87653 |
| 87702 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87654 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87703 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87655 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87704 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87656 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87705 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87657 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87706 | int retval; |  | 87658 | int retval;
| 87707 |  |  | 87659 |
| 87708 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87660 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87709 | { |  | 87661 | {
| 87710 | ERRWRAP2(retval = _self_->getTransformType()); |  | 87662 | ERRWRAP2(retval = _self_->getTransformType());
| 87711 | return pyopencv_from(retval); |  | 87663 | return pyopencv_from(retval);
| 87712 | } |  | 87664 | }
| 87713 |  |  | 87665 |
| 87714 | return NULL; |  | 87666 | return NULL;
| 87715 | } |  | 87667 | }
| 87716 |  |  | 87668 |
| 87717 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87669 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw)
| 87718 | { |  | 87670 | {
| 87719 | using namespace cv::rgbd; |  | 87671 | using namespace cv::rgbd;
| 87720 |  |  | 87672 |
| 87721 |  |  | 87673 |
| 87722 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87674 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87723 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87675 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87724 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87676 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87725 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87677 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87726 | PyObject* pyobj_frame = NULL; |  | 87678 | PyObject* pyobj_frame = NULL;
| 87727 | Ptr<OdometryFrame> frame; |  | 87679 | Ptr<OdometryFrame> frame;
| 87728 | PyObject* pyobj_cacheType = NULL; |  | 87680 | PyObject* pyobj_cacheType = NULL;
| 87729 | int cacheType=0; |  | 87681 | int cacheType=0;
| 87730 | Size retval; |  | 87682 | Size retval;
| 87731 |  |  | 87683 |
| 87732 | const char* keywords[] = { "frame", "cacheType", NULL }; |  | 87684 | const char* keywords[] = { "frame", "cacheType", NULL };
| 87733 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_Odometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) && |  | 87685 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_Odometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) &&
| 87734 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 87686 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 87735 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) ) |  | 87687 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) )
| 87736 | { |  | 87688 | {
| 87737 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType)); |  | 87689 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType));
| 87738 | return pyopencv_from(retval); |  | 87690 | return pyopencv_from(retval);
| 87739 | } |  | 87691 | }
| 87740 |  |  | 87692 |
| 87741 | return NULL; |  | 87693 | return NULL;
| 87742 | } |  | 87694 | }
| 87743 |  |  | 87695 |
| 87744 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87696 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 87745 | { |  | 87697 | {
| 87746 | using namespace cv::rgbd; |  | 87698 | using namespace cv::rgbd;
| 87747 |  |  | 87699 |
| 87748 |  |  | 87700 |
| 87749 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87701 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87750 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87702 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87751 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87703 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87752 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87704 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87753 | PyObject* pyobj_val = NULL; |  | 87705 | PyObject* pyobj_val = NULL;
| 87754 | Mat val; |  | 87706 | Mat val;
| 87755 |  |  | 87707 |
| 87756 | const char* keywords[] = { "val", NULL }; |  | 87708 | const char* keywords[] = { "val", NULL };
| 87757 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_Odometry.setCameraMatrix", (char**)keywords, &pyobj_val) && |  | 87709 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_Odometry.setCameraMatrix", (char**)keywords, &pyobj_val) &&
| 87758 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87710 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87759 | { |  | 87711 | {
| 87760 | ERRWRAP2(_self_->setCameraMatrix(val)); |  | 87712 | ERRWRAP2(_self_->setCameraMatrix(val));
| 87761 | Py_RETURN_NONE; |  | 87713 | Py_RETURN_NONE;
| 87762 | } |  | 87714 | }
| 87763 |  |  | 87715 |
| 87764 | return NULL; |  | 87716 | return NULL;
| 87765 | } |  | 87717 | }
| 87766 |  |  | 87718 |
| 87767 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87719 | static PyObject* pyopencv_cv_rgbd_rgbd_Odometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 87768 | { |  | 87720 | {
| 87769 | using namespace cv::rgbd; |  | 87721 | using namespace cv::rgbd;
| 87770 |  |  | 87722 |
| 87771 |  |  | 87723 |
| 87772 | Ptr<cv::rgbd::Odometry> * self1 = 0; |  | 87724 | Ptr<cv::rgbd::Odometry> * self1 = 0;
| 87773 | if (!pyopencv_rgbd_Odometry_getp(self, self1)) |  | 87725 | if (!pyopencv_rgbd_Odometry_getp(self, self1))
| 87774 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)"); |  | 87726 | return failmsgp("Incorrect type of self (must be 'rgbd_Odometry' or its derivative)");
| 87775 | Ptr<cv::rgbd::Odometry> _self_ = *(self1); |  | 87727 | Ptr<cv::rgbd::Odometry> _self_ = *(self1);
| 87776 | PyObject* pyobj_val = NULL; |  | 87728 | PyObject* pyobj_val = NULL;
| 87777 | int val=0; |  | 87729 | int val=0;
| 87778 |  |  | 87730 |
| 87779 | const char* keywords[] = { "val", NULL }; |  | 87731 | const char* keywords[] = { "val", NULL };
| 87780 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_Odometry.setTransformType", (char**)keywords, &pyobj_val) && |  | 87732 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_Odometry.setTransformType", (char**)keywords, &pyobj_val) &&
| 87781 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 87733 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 87782 | { |  | 87734 | {
| 87783 | ERRWRAP2(_self_->setTransformType(val)); |  | 87735 | ERRWRAP2(_self_->setTransformType(val));
| 87784 | Py_RETURN_NONE; |  | 87736 | Py_RETURN_NONE;
| 87785 | } |  | 87737 | }
| 87786 |  |  | 87738 |
| 87787 | return NULL; |  | 87739 | return NULL;
| 87788 | } |  | 87740 | }
| 87789 |  |  | 87741 |
| 87790 |  |  | 87742 |
| 87791 |  |  | 87743 |
| 87792 | // Tables (rgbd_Odometry) |  | 87744 | // Tables (rgbd_Odometry)
| 87793 |  |  | 87745 |
| 87794 | static PyGetSetDef pyopencv_rgbd_Odometry_getseters[] = |  | 87746 | static PyGetSetDef pyopencv_rgbd_Odometry_getseters[] =
| 87795 | { |  | 87747 | {
| 87796 | {NULL} /* Sentinel */ |  | 87748 | {NULL} /* Sentinel */
| 87797 | }; |  | 87749 | };
| 87798 |  |  | 87750 |
| 87799 | static PyMethodDef pyopencv_rgbd_Odometry_methods[] = |  | 87751 | static PyMethodDef pyopencv_rgbd_Odometry_methods[] =
| 87800 | { |  | 87752 | {
| 87801 | {"DEFAULT_MAX_DEPTH", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH, 0), "DEFAULT_MAX_DEPTH() -> retval\n."}, |  | 87753 | {"DEFAULT_MAX_DEPTH", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH, 0), "DEFAULT_MAX_DEPTH() -> retval\n."},
| 87802 | {"DEFAULT_MAX_DEPTH_DIFF", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH_DIFF, 0), "DEFAULT_MAX_DEPTH_DIFF() -> retval\n."}, |  | 87754 | {"DEFAULT_MAX_DEPTH_DIFF", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_DEPTH_DIFF, 0), "DEFAULT_MAX_DEPTH_DIFF() -> retval\n."},
| 87803 | {"DEFAULT_MAX_POINTS_PART", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_POINTS_PART, 0), "DEFAULT_MAX_POINTS_PART() -> retval\n."}, |  | 87755 | {"DEFAULT_MAX_POINTS_PART", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_POINTS_PART, 0), "DEFAULT_MAX_POINTS_PART() -> retval\n."},
| 87804 | {"DEFAULT_MAX_ROTATION", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_ROTATION, 0), "DEFAULT_MAX_ROTATION() -> retval\n."}, |  | 87756 | {"DEFAULT_MAX_ROTATION", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_ROTATION, 0), "DEFAULT_MAX_ROTATION() -> retval\n."},
| 87805 | {"DEFAULT_MAX_TRANSLATION", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_TRANSLATION, 0), "DEFAULT_MAX_TRANSLATION() -> retval\n."}, |  | 87757 | {"DEFAULT_MAX_TRANSLATION", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MAX_TRANSLATION, 0), "DEFAULT_MAX_TRANSLATION() -> retval\n."},
| 87806 | {"DEFAULT_MIN_DEPTH", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MIN_DEPTH, 0), "DEFAULT_MIN_DEPTH() -> retval\n."}, |  | 87758 | {"DEFAULT_MIN_DEPTH", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_DEFAULT_MIN_DEPTH, 0), "DEFAULT_MIN_DEPTH() -> retval\n."},
| 87807 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_compute, 0), "compute(srcImage, srcDepth, srcMask, dstImage, dstDepth, dstMask[, Rt[, initRt]]) -> retval, Rt\n. Method to compute a transformation from the source frame to the destination one.\n. * Some odometry algorithms do not used some data of frames (eg. ICP does not use images).\n. * In such case corresponding arguments can be set as empty Mat.\n. * The method returns true if all internal computations were possible (e.g. there were enough correspondences,\n. * system of equations has a solution, etc) and resulting transformation satisfies some test if it's provided\n. * by the Odometry inheritor implementation (e.g. thresholds for maximum translation and rotation).\n. * @param srcImage Image data of the source frame (CV_8UC1)\n. * @param srcDepth Depth data of the source frame (CV_32FC1, in meters)\n. * @param srcMask Mask that sets which pixels have to be used from the source frame (CV_8UC1)\n. * @param dstImage Image data of the destination frame (CV_8UC1)\n. * @param dstDepth Depth data of the destination frame (CV_32FC1, in meters)\n. * @param dstMask Mask that sets which pixels have to be used from the destination frame (CV_8UC1)\n. * @param Rt Resulting transformation from the source frame to the destination one (rigid body motion):\n. dst_p = Rt * src_p, where dst_p is a homogeneous point in the destination frame and src_p is\n. homogeneous point in the source frame,\n. Rt is 4x4 matrix of CV_64FC1 type.\n. * @param initRt Initial transformation from the source frame to the destination one (optional)"}, |  | 87759 | {"compute", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_compute, 0), "compute(srcImage, srcDepth, srcMask, dstImage, dstDepth, dstMask[, Rt[, initRt]]) -> retval, Rt\n. Method to compute a transformation from the source frame to the destination one.\n. * Some odometry algorithms do not used some data of frames (eg. ICP does not use images).\n. * In such case corresponding arguments can be set as empty Mat.\n. * The method returns true if all internal computations were possible (e.g. there were enough correspondences,\n. * system of equations has a solution, etc) and resulting transformation satisfies some test if it's provided\n. * by the Odometry inheritor implementation (e.g. thresholds for maximum translation and rotation).\n. * @param srcImage Image data of the source frame (CV_8UC1)\n. * @param srcDepth Depth data of the source frame (CV_32FC1, in meters)\n. * @param srcMask Mask that sets which pixels have to be used from the source frame (CV_8UC1)\n. * @param dstImage Image data of the destination frame (CV_8UC1)\n. * @param dstDepth Depth data of the destination frame (CV_32FC1, in meters)\n. * @param dstMask Mask that sets which pixels have to be used from the destination frame (CV_8UC1)\n. * @param Rt Resulting transformation from the source frame to the destination one (rigid body motion):\n. dst_p = Rt * src_p, where dst_p is a homogeneous point in the destination frame and src_p is\n. homogeneous point in the source frame,\n. Rt is 4x4 matrix of CV_64FC1 type.\n. * @param initRt Initial transformation from the source frame to the destination one (optional)"},
| 87808 | {"compute2", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_compute2, 0), "compute2(srcFrame, dstFrame[, Rt[, initRt]]) -> retval, Rt\n. One more method to compute a transformation from the source frame to the destination one.\n. * It is designed to save on computing the frame data (image pyramids, normals, etc.)."}, |  | 87760 | {"compute2", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_compute2, 0), "compute2(srcFrame, dstFrame[, Rt[, initRt]]) -> retval, Rt\n. One more method to compute a transformation from the source frame to the destination one.\n. * It is designed to save on computing the frame data (image pyramids, normals, etc.)."},
| 87809 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_create_static, METH_STATIC), "create(odometryType) -> retval\n."}, |  | 87761 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_create_static, METH_STATIC), "create(odometryType) -> retval\n."},
| 87810 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n. @see setCameraMatrix"}, |  | 87762 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n. @see setCameraMatrix"},
| 87811 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_getTransformType, 0), "getTransformType() -> retval\n. @see setTransformType"}, |  | 87763 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_getTransformType, 0), "getTransformType() -> retval\n. @see setTransformType"},
| 87812 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n. Prepare a cache for the frame. The function checks the precomputed/passed data (throws the error if this data\n. * does not satisfy) and computes all remaining cache data needed for the frame. Returned size is a resolution\n. * of the prepared frame.\n. * @param frame The odometry which will process the frame.\n. * @param cacheType The cache type: CACHE_SRC, CACHE_DST or CACHE_ALL."}, |  | 87764 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n. Prepare a cache for the frame. The function checks the precomputed/passed data (throws the error if this data\n. * does not satisfy) and computes all remaining cache data needed for the frame. Returned size is a resolution\n. * of the prepared frame.\n. * @param frame The odometry which will process the frame.\n. * @param cacheType The cache type: CACHE_SRC, CACHE_DST or CACHE_ALL."},
| 87813 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n. @copybrief getCameraMatrix @see getCameraMatrix"}, |  | 87765 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n. @copybrief getCameraMatrix @see getCameraMatrix"},
| 87814 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_setTransformType, 0), "setTransformType(val) -> None\n. @copybrief getTransformType @see getTransformType"}, |  | 87766 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_Odometry_setTransformType, 0), "setTransformType(val) -> None\n. @copybrief getTransformType @see getTransformType"},
| 87815 |  |  | 87767 |
| 87816 | {NULL, NULL} |  | 87768 | {NULL, NULL}
| 87817 | }; |  | 87769 | };
| 87818 |  |  | 87770 |
| 87819 | // Converter (rgbd_Odometry) |  | 87771 | // Converter (rgbd_Odometry)
| 87820 |  |  | 87772 |
| 87821 | template<> |  | 87773 | template<>
| 87822 | struct PyOpenCV_Converter< Ptr<cv::rgbd::Odometry> > |  | 87774 | struct PyOpenCV_Converter< Ptr<cv::rgbd::Odometry> >
| 87823 | { |  | 87775 | {
| 87824 | static PyObject* from(const Ptr<cv::rgbd::Odometry>& r) |  | 87776 | static PyObject* from(const Ptr<cv::rgbd::Odometry>& r)
| 87825 | { |  | 87777 | {
| 87826 | return pyopencv_rgbd_Odometry_Instance(r); |  | 87778 | return pyopencv_rgbd_Odometry_Instance(r);
| 87827 | } |  | 87779 | }
| 87828 | static bool to(PyObject* src, Ptr<cv::rgbd::Odometry>& dst, const ArgInfo& info) |  | 87780 | static bool to(PyObject* src, Ptr<cv::rgbd::Odometry>& dst, const ArgInfo& info)
| 87829 | { |  | 87781 | {
| 87830 | if(!src || src == Py_None) |  | 87782 | if(!src || src == Py_None)
| 87831 | return true; |  | 87783 | return true;
| 87832 | Ptr<cv::rgbd::Odometry> * dst_; |  | 87784 | Ptr<cv::rgbd::Odometry> * dst_;
| 87833 | if (pyopencv_rgbd_Odometry_getp(src, dst_)) |  | 87785 | if (pyopencv_rgbd_Odometry_getp(src, dst_))
| 87834 | { |  | 87786 | {
| 87835 | dst = *dst_; |  | 87787 | dst = *dst_;
| 87836 | return true; |  | 87788 | return true;
| 87837 | } |  | 87789 | }
| 87838 |  |  | 87790 |
| 87839 | failmsg("Expected Ptr<cv::rgbd::Odometry> for argument '%s'", info.name); |  | 87791 | failmsg("Expected Ptr<cv::rgbd::Odometry> for argument '%s'", info.name);
| 87840 | return false; |  | 87792 | return false;
| 87841 | } |  | 87793 | }
| 87842 | }; |  | 87794 | };
| 87843 |  |  | 87795 |
| 87844 | //================================================================================ |  | 87796 | //================================================================================
| 87845 | // rgbd_OdometryFrame (Generic) |  | 87797 | // rgbd_OdometryFrame (Generic)
| 87846 | //================================================================================ |  | 87798 | //================================================================================
| 87847 |  |  | 87799 |
| 87848 | // GetSet (rgbd_OdometryFrame) |  | 87800 | // GetSet (rgbd_OdometryFrame)
| 87849 |  |  | 87801 |
| 87850 |  |  | 87802 |
| 87851 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidCloud(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87803 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidCloud(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87852 | { |  | 87804 | {
| 87853 | return pyopencv_from(p->v->pyramidCloud); |  | 87805 | return pyopencv_from(p->v->pyramidCloud);
| 87854 | } |  | 87806 | }
| 87855 |  |  | 87807 |
| 87856 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidDepth(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87808 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidDepth(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87857 | { |  | 87809 | {
| 87858 | return pyopencv_from(p->v->pyramidDepth); |  | 87810 | return pyopencv_from(p->v->pyramidDepth);
| 87859 | } |  | 87811 | }
| 87860 |  |  | 87812 |
| 87861 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidImage(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87813 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidImage(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87862 | { |  | 87814 | {
| 87863 | return pyopencv_from(p->v->pyramidImage); |  | 87815 | return pyopencv_from(p->v->pyramidImage);
| 87864 | } |  | 87816 | }
| 87865 |  |  | 87817 |
| 87866 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidMask(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87818 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidMask(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87867 | { |  | 87819 | {
| 87868 | return pyopencv_from(p->v->pyramidMask); |  | 87820 | return pyopencv_from(p->v->pyramidMask);
| 87869 | } |  | 87821 | }
| 87870 |  |  | 87822 |
| 87871 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidNormals(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87823 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidNormals(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87872 | { |  | 87824 | {
| 87873 | return pyopencv_from(p->v->pyramidNormals); |  | 87825 | return pyopencv_from(p->v->pyramidNormals);
| 87874 | } |  | 87826 | }
| 87875 |  |  | 87827 |
| 87876 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidNormalsMask(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87828 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidNormalsMask(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87877 | { |  | 87829 | {
| 87878 | return pyopencv_from(p->v->pyramidNormalsMask); |  | 87830 | return pyopencv_from(p->v->pyramidNormalsMask);
| 87879 | } |  | 87831 | }
| 87880 |  |  | 87832 |
| 87881 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidTexturedMask(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87833 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramidTexturedMask(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87882 | { |  | 87834 | {
| 87883 | return pyopencv_from(p->v->pyramidTexturedMask); |  | 87835 | return pyopencv_from(p->v->pyramidTexturedMask);
| 87884 | } |  | 87836 | }
| 87885 |  |  | 87837 |
| 87886 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dx(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87838 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dx(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87887 | { |  | 87839 | {
| 87888 | return pyopencv_from(p->v->pyramid_dI_dx); |  | 87840 | return pyopencv_from(p->v->pyramid_dI_dx);
| 87889 | } |  | 87841 | }
| 87890 |  |  | 87842 |
| 87891 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dy(pyopencv_rgbd_OdometryFrame_t* p, void *closure) |  | 87843 | static PyObject* pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dy(pyopencv_rgbd_OdometryFrame_t* p, void *closure)
| 87892 | { |  | 87844 | {
| 87893 | return pyopencv_from(p->v->pyramid_dI_dy); |  | 87845 | return pyopencv_from(p->v->pyramid_dI_dy);
| 87894 | } |  | 87846 | }
| 87895 |  |  | 87847 |
| 87896 |  |  | 87848 |
| 87897 | // Methods (rgbd_OdometryFrame) |  | 87849 | // Methods (rgbd_OdometryFrame)
| 87898 |  |  | 87850 |
| 87899 | static PyObject* pyopencv_cv_rgbd_rgbd_OdometryFrame_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87851 | static PyObject* pyopencv_cv_rgbd_rgbd_OdometryFrame_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 87900 | { |  | 87852 | {
| 87901 | using namespace cv::rgbd; |  | 87853 | using namespace cv::rgbd;
| 87902 |  |  | 87854 |
| 87903 | PyObject* pyobj_image = NULL; |  | 87855 | PyObject* pyobj_image = NULL;
| 87904 | Mat image; |  | 87856 | Mat image;
| 87905 | PyObject* pyobj_depth = NULL; |  | 87857 | PyObject* pyobj_depth = NULL;
| 87906 | Mat depth; |  | 87858 | Mat depth;
| 87907 | PyObject* pyobj_mask = NULL; |  | 87859 | PyObject* pyobj_mask = NULL;
| 87908 | Mat mask; |  | 87860 | Mat mask;
| 87909 | PyObject* pyobj_normals = NULL; |  | 87861 | PyObject* pyobj_normals = NULL;
| 87910 | Mat normals; |  | 87862 | Mat normals;
| 87911 | PyObject* pyobj_ID = NULL; |  | 87863 | PyObject* pyobj_ID = NULL;
| 87912 | int ID=-1; |  | 87864 | int ID=-1;
| 87913 | Ptr<OdometryFrame> retval; |  | 87865 | Ptr<OdometryFrame> retval;
| 87914 |  |  | 87866 |
| 87915 | const char* keywords[] = { "image", "depth", "mask", "normals", "ID", NULL }; |  | 87867 | const char* keywords[] = { "image", "depth", "mask", "normals", "ID", NULL };
| 87916 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:rgbd_OdometryFrame.create", (char**)keywords, &pyobj_image, &pyobj_depth, &pyobj_mask, &pyobj_normals, &pyobj_ID) && |  | 87868 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:rgbd_OdometryFrame.create", (char**)keywords, &pyobj_image, &pyobj_depth, &pyobj_mask, &pyobj_normals, &pyobj_ID) &&
| 87917 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 87869 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 87918 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) && |  | 87870 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) &&
| 87919 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 87871 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 87920 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) && |  | 87872 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) &&
| 87921 | pyopencv_to_safe(pyobj_ID, ID, ArgInfo("ID", 0)) ) |  | 87873 | pyopencv_to_safe(pyobj_ID, ID, ArgInfo("ID", 0)) )
| 87922 | { |  | 87874 | {
| 87923 | ERRWRAP2(retval = cv::rgbd::OdometryFrame::create(image, depth, mask, normals, ID)); |  | 87875 | ERRWRAP2(retval = cv::rgbd::OdometryFrame::create(image, depth, mask, normals, ID));
| 87924 | return pyopencv_from(retval); |  | 87876 | return pyopencv_from(retval);
| 87925 | } |  | 87877 | }
| 87926 |  |  | 87878 |
| 87927 | return NULL; |  | 87879 | return NULL;
| 87928 | } |  | 87880 | }
| 87929 |  |  | 87881 |
| 87930 | static PyObject* pyopencv_cv_rgbd_rgbd_OdometryFrame_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87882 | static PyObject* pyopencv_cv_rgbd_rgbd_OdometryFrame_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 87931 | { |  | 87883 | {
| 87932 | using namespace cv::rgbd; |  | 87884 | using namespace cv::rgbd;
| 87933 |  |  | 87885 |
| 87934 |  |  | 87886 |
| 87935 | Ptr<cv::rgbd::OdometryFrame> * self1 = 0; |  | 87887 | Ptr<cv::rgbd::OdometryFrame> * self1 = 0;
| 87936 | if (!pyopencv_rgbd_OdometryFrame_getp(self, self1)) |  | 87888 | if (!pyopencv_rgbd_OdometryFrame_getp(self, self1))
| 87937 | return failmsgp("Incorrect type of self (must be 'rgbd_OdometryFrame' or its derivative)"); |  | 87889 | return failmsgp("Incorrect type of self (must be 'rgbd_OdometryFrame' or its derivative)");
| 87938 | Ptr<cv::rgbd::OdometryFrame> _self_ = *(self1); |  | 87890 | Ptr<cv::rgbd::OdometryFrame> _self_ = *(self1);
| 87939 |  |  | 87891 |
| 87940 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87892 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87941 | { |  | 87893 | {
| 87942 | ERRWRAP2(_self_->release()); |  | 87894 | ERRWRAP2(_self_->release());
| 87943 | Py_RETURN_NONE; |  | 87895 | Py_RETURN_NONE;
| 87944 | } |  | 87896 | }
| 87945 |  |  | 87897 |
| 87946 | return NULL; |  | 87898 | return NULL;
| 87947 | } |  | 87899 | }
| 87948 |  |  | 87900 |
| 87949 | static PyObject* pyopencv_cv_rgbd_rgbd_OdometryFrame_releasePyramids(PyObject* self, PyObject* py_args, PyObject* kw) |  | 87901 | static PyObject* pyopencv_cv_rgbd_rgbd_OdometryFrame_releasePyramids(PyObject* self, PyObject* py_args, PyObject* kw)
| 87950 | { |  | 87902 | {
| 87951 | using namespace cv::rgbd; |  | 87903 | using namespace cv::rgbd;
| 87952 |  |  | 87904 |
| 87953 |  |  | 87905 |
| 87954 | Ptr<cv::rgbd::OdometryFrame> * self1 = 0; |  | 87906 | Ptr<cv::rgbd::OdometryFrame> * self1 = 0;
| 87955 | if (!pyopencv_rgbd_OdometryFrame_getp(self, self1)) |  | 87907 | if (!pyopencv_rgbd_OdometryFrame_getp(self, self1))
| 87956 | return failmsgp("Incorrect type of self (must be 'rgbd_OdometryFrame' or its derivative)"); |  | 87908 | return failmsgp("Incorrect type of self (must be 'rgbd_OdometryFrame' or its derivative)");
| 87957 | Ptr<cv::rgbd::OdometryFrame> _self_ = *(self1); |  | 87909 | Ptr<cv::rgbd::OdometryFrame> _self_ = *(self1);
| 87958 |  |  | 87910 |
| 87959 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 87911 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 87960 | { |  | 87912 | {
| 87961 | ERRWRAP2(_self_->releasePyramids()); |  | 87913 | ERRWRAP2(_self_->releasePyramids());
| 87962 | Py_RETURN_NONE; |  | 87914 | Py_RETURN_NONE;
| 87963 | } |  | 87915 | }
| 87964 |  |  | 87916 |
| 87965 | return NULL; |  | 87917 | return NULL;
| 87966 | } |  | 87918 | }
| 87967 |  |  | 87919 |
| 87968 |  |  | 87920 |
| 87969 |  |  | 87921 |
| 87970 | // Tables (rgbd_OdometryFrame) |  | 87922 | // Tables (rgbd_OdometryFrame)
| 87971 |  |  | 87923 |
| 87972 | static PyGetSetDef pyopencv_rgbd_OdometryFrame_getseters[] = |  | 87924 | static PyGetSetDef pyopencv_rgbd_OdometryFrame_getseters[] =
| 87973 | { |  | 87925 | {
| 87974 | {(char*)"pyramidCloud", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidCloud, NULL, (char*)"pyramidCloud", NULL}, |  | 87926 | {(char*)"pyramidCloud", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidCloud, NULL, (char*)"pyramidCloud", NULL},
| 87975 | {(char*)"pyramidDepth", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidDepth, NULL, (char*)"pyramidDepth", NULL}, |  | 87927 | {(char*)"pyramidDepth", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidDepth, NULL, (char*)"pyramidDepth", NULL},
| 87976 | {(char*)"pyramidImage", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidImage, NULL, (char*)"pyramidImage", NULL}, |  | 87928 | {(char*)"pyramidImage", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidImage, NULL, (char*)"pyramidImage", NULL},
| 87977 | {(char*)"pyramidMask", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidMask, NULL, (char*)"pyramidMask", NULL}, |  | 87929 | {(char*)"pyramidMask", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidMask, NULL, (char*)"pyramidMask", NULL},
| 87978 | {(char*)"pyramidNormals", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidNormals, NULL, (char*)"pyramidNormals", NULL}, |  | 87930 | {(char*)"pyramidNormals", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidNormals, NULL, (char*)"pyramidNormals", NULL},
| 87979 | {(char*)"pyramidNormalsMask", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidNormalsMask, NULL, (char*)"pyramidNormalsMask", NULL}, |  | 87931 | {(char*)"pyramidNormalsMask", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidNormalsMask, NULL, (char*)"pyramidNormalsMask", NULL},
| 87980 | {(char*)"pyramidTexturedMask", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidTexturedMask, NULL, (char*)"pyramidTexturedMask", NULL}, |  | 87932 | {(char*)"pyramidTexturedMask", (getter)pyopencv_rgbd_OdometryFrame_get_pyramidTexturedMask, NULL, (char*)"pyramidTexturedMask", NULL},
| 87981 | {(char*)"pyramid_dI_dx", (getter)pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dx, NULL, (char*)"pyramid_dI_dx", NULL}, |  | 87933 | {(char*)"pyramid_dI_dx", (getter)pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dx, NULL, (char*)"pyramid_dI_dx", NULL},
| 87982 | {(char*)"pyramid_dI_dy", (getter)pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dy, NULL, (char*)"pyramid_dI_dy", NULL}, |  | 87934 | {(char*)"pyramid_dI_dy", (getter)pyopencv_rgbd_OdometryFrame_get_pyramid_dI_dy, NULL, (char*)"pyramid_dI_dy", NULL},
| 87983 | {NULL} /* Sentinel */ |  | 87935 | {NULL} /* Sentinel */
| 87984 | }; |  | 87936 | };
| 87985 |  |  | 87937 |
| 87986 | static PyMethodDef pyopencv_rgbd_OdometryFrame_methods[] = |  | 87938 | static PyMethodDef pyopencv_rgbd_OdometryFrame_methods[] =
| 87987 | { |  | 87939 | {
| 87988 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_OdometryFrame_create_static, METH_STATIC), "create([, image[, depth[, mask[, normals[, ID]]]]]) -> retval\n."}, |  | 87940 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_OdometryFrame_create_static, METH_STATIC), "create([, image[, depth[, mask[, normals[, ID]]]]]) -> retval\n."},
| 87989 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_OdometryFrame_release, 0), "release() -> None\n."}, |  | 87941 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_OdometryFrame_release, 0), "release() -> None\n."},
| 87990 | {"releasePyramids", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_OdometryFrame_releasePyramids, 0), "releasePyramids() -> None\n."}, |  | 87942 | {"releasePyramids", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_OdometryFrame_releasePyramids, 0), "releasePyramids() -> None\n."},
| 87991 |  |  | 87943 |
| 87992 | {NULL, NULL} |  | 87944 | {NULL, NULL}
| 87993 | }; |  | 87945 | };
| 87994 |  |  | 87946 |
| 87995 | // Converter (rgbd_OdometryFrame) |  | 87947 | // Converter (rgbd_OdometryFrame)
| 87996 |  |  | 87948 |
| 87997 | template<> |  | 87949 | template<>
| 87998 | struct PyOpenCV_Converter< Ptr<cv::rgbd::OdometryFrame> > |  | 87950 | struct PyOpenCV_Converter< Ptr<cv::rgbd::OdometryFrame> >
| 87999 | { |  | 87951 | {
| 88000 | static PyObject* from(const Ptr<cv::rgbd::OdometryFrame>& r) |  | 87952 | static PyObject* from(const Ptr<cv::rgbd::OdometryFrame>& r)
| 88001 | { |  | 87953 | {
| 88002 | return pyopencv_rgbd_OdometryFrame_Instance(r); |  | 87954 | return pyopencv_rgbd_OdometryFrame_Instance(r);
| 88003 | } |  | 87955 | }
| 88004 | static bool to(PyObject* src, Ptr<cv::rgbd::OdometryFrame>& dst, const ArgInfo& info) |  | 87956 | static bool to(PyObject* src, Ptr<cv::rgbd::OdometryFrame>& dst, const ArgInfo& info)
| 88005 | { |  | 87957 | {
| 88006 | if(!src || src == Py_None) |  | 87958 | if(!src || src == Py_None)
| 88007 | return true; |  | 87959 | return true;
| 88008 | Ptr<cv::rgbd::OdometryFrame> * dst_; |  | 87960 | Ptr<cv::rgbd::OdometryFrame> * dst_;
| 88009 | if (pyopencv_rgbd_OdometryFrame_getp(src, dst_)) |  | 87961 | if (pyopencv_rgbd_OdometryFrame_getp(src, dst_))
| 88010 | { |  | 87962 | {
| 88011 | dst = *dst_; |  | 87963 | dst = *dst_;
| 88012 | return true; |  | 87964 | return true;
| 88013 | } |  | 87965 | }
| 88014 |  |  | 87966 |
| 88015 | failmsg("Expected Ptr<cv::rgbd::OdometryFrame> for argument '%s'", info.name); |  | 87967 | failmsg("Expected Ptr<cv::rgbd::OdometryFrame> for argument '%s'", info.name);
| 88016 | return false; |  | 87968 | return false;
| 88017 | } |  | 87969 | }
| 88018 | }; |  | 87970 | };
| 88019 |  |  | 87971 |
| 88020 | //================================================================================ |  | 87972 | //================================================================================
| 88021 | // rgbd_RgbdFrame (Generic) |  | 87973 | // rgbd_RgbdFrame (Generic)
| 88022 | //================================================================================ |  | 87974 | //================================================================================
| 88023 |  |  | 87975 |
| 88024 | // GetSet (rgbd_RgbdFrame) |  | 87976 | // GetSet (rgbd_RgbdFrame)
| 88025 |  |  | 87977 |
| 88026 |  |  | 87978 |
| 88027 | static PyObject* pyopencv_rgbd_RgbdFrame_get_ID(pyopencv_rgbd_RgbdFrame_t* p, void *closure) |  | 87979 | static PyObject* pyopencv_rgbd_RgbdFrame_get_ID(pyopencv_rgbd_RgbdFrame_t* p, void *closure)
| 88028 | { |  | 87980 | {
| 88029 | return pyopencv_from(p->v->ID); |  | 87981 | return pyopencv_from(p->v->ID);
| 88030 | } |  | 87982 | }
| 88031 |  |  | 87983 |
| 88032 | static PyObject* pyopencv_rgbd_RgbdFrame_get_depth(pyopencv_rgbd_RgbdFrame_t* p, void *closure) |  | 87984 | static PyObject* pyopencv_rgbd_RgbdFrame_get_depth(pyopencv_rgbd_RgbdFrame_t* p, void *closure)
| 88033 | { |  | 87985 | {
| 88034 | return pyopencv_from(p->v->depth); |  | 87986 | return pyopencv_from(p->v->depth);
| 88035 | } |  | 87987 | }
| 88036 |  |  | 87988 |
| 88037 | static PyObject* pyopencv_rgbd_RgbdFrame_get_image(pyopencv_rgbd_RgbdFrame_t* p, void *closure) |  | 87989 | static PyObject* pyopencv_rgbd_RgbdFrame_get_image(pyopencv_rgbd_RgbdFrame_t* p, void *closure)
| 88038 | { |  | 87990 | {
| 88039 | return pyopencv_from(p->v->image); |  | 87991 | return pyopencv_from(p->v->image);
| 88040 | } |  | 87992 | }
| 88041 |  |  | 87993 |
| 88042 | static PyObject* pyopencv_rgbd_RgbdFrame_get_mask(pyopencv_rgbd_RgbdFrame_t* p, void *closure) |  | 87994 | static PyObject* pyopencv_rgbd_RgbdFrame_get_mask(pyopencv_rgbd_RgbdFrame_t* p, void *closure)
| 88043 | { |  | 87995 | {
| 88044 | return pyopencv_from(p->v->mask); |  | 87996 | return pyopencv_from(p->v->mask);
| 88045 | } |  | 87997 | }
| 88046 |  |  | 87998 |
| 88047 | static PyObject* pyopencv_rgbd_RgbdFrame_get_normals(pyopencv_rgbd_RgbdFrame_t* p, void *closure) |  | 87999 | static PyObject* pyopencv_rgbd_RgbdFrame_get_normals(pyopencv_rgbd_RgbdFrame_t* p, void *closure)
| 88048 | { |  | 88000 | {
| 88049 | return pyopencv_from(p->v->normals); |  | 88001 | return pyopencv_from(p->v->normals);
| 88050 | } |  | 88002 | }
| 88051 |  |  | 88003 |
| 88052 |  |  | 88004 |
| 88053 | // Methods (rgbd_RgbdFrame) |  | 88005 | // Methods (rgbd_RgbdFrame)
| 88054 |  |  | 88006 |
| 88055 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdFrame_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88007 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdFrame_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 88056 | { |  | 88008 | {
| 88057 | using namespace cv::rgbd; |  | 88009 | using namespace cv::rgbd;
| 88058 |  |  | 88010 |
| 88059 | PyObject* pyobj_image = NULL; |  | 88011 | PyObject* pyobj_image = NULL;
| 88060 | Mat image; |  | 88012 | Mat image;
| 88061 | PyObject* pyobj_depth = NULL; |  | 88013 | PyObject* pyobj_depth = NULL;
| 88062 | Mat depth; |  | 88014 | Mat depth;
| 88063 | PyObject* pyobj_mask = NULL; |  | 88015 | PyObject* pyobj_mask = NULL;
| 88064 | Mat mask; |  | 88016 | Mat mask;
| 88065 | PyObject* pyobj_normals = NULL; |  | 88017 | PyObject* pyobj_normals = NULL;
| 88066 | Mat normals; |  | 88018 | Mat normals;
| 88067 | PyObject* pyobj_ID = NULL; |  | 88019 | PyObject* pyobj_ID = NULL;
| 88068 | int ID=-1; |  | 88020 | int ID=-1;
| 88069 | Ptr<RgbdFrame> retval; |  | 88021 | Ptr<RgbdFrame> retval;
| 88070 |  |  | 88022 |
| 88071 | const char* keywords[] = { "image", "depth", "mask", "normals", "ID", NULL }; |  | 88023 | const char* keywords[] = { "image", "depth", "mask", "normals", "ID", NULL };
| 88072 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:rgbd_RgbdFrame.create", (char**)keywords, &pyobj_image, &pyobj_depth, &pyobj_mask, &pyobj_normals, &pyobj_ID) && |  | 88024 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOO:rgbd_RgbdFrame.create", (char**)keywords, &pyobj_image, &pyobj_depth, &pyobj_mask, &pyobj_normals, &pyobj_ID) &&
| 88073 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 88025 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 88074 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) && |  | 88026 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) &&
| 88075 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) && |  | 88027 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 0)) &&
| 88076 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) && |  | 88028 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) &&
| 88077 | pyopencv_to_safe(pyobj_ID, ID, ArgInfo("ID", 0)) ) |  | 88029 | pyopencv_to_safe(pyobj_ID, ID, ArgInfo("ID", 0)) )
| 88078 | { |  | 88030 | {
| 88079 | ERRWRAP2(retval = cv::rgbd::RgbdFrame::create(image, depth, mask, normals, ID)); |  | 88031 | ERRWRAP2(retval = cv::rgbd::RgbdFrame::create(image, depth, mask, normals, ID));
| 88080 | return pyopencv_from(retval); |  | 88032 | return pyopencv_from(retval);
| 88081 | } |  | 88033 | }
| 88082 |  |  | 88034 |
| 88083 | return NULL; |  | 88035 | return NULL;
| 88084 | } |  | 88036 | }
| 88085 |  |  | 88037 |
| 88086 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdFrame_release(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88038 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdFrame_release(PyObject* self, PyObject* py_args, PyObject* kw)
| 88087 | { |  | 88039 | {
| 88088 | using namespace cv::rgbd; |  | 88040 | using namespace cv::rgbd;
| 88089 |  |  | 88041 |
| 88090 |  |  | 88042 |
| 88091 | Ptr<cv::rgbd::RgbdFrame> * self1 = 0; |  | 88043 | Ptr<cv::rgbd::RgbdFrame> * self1 = 0;
| 88092 | if (!pyopencv_rgbd_RgbdFrame_getp(self, self1)) |  | 88044 | if (!pyopencv_rgbd_RgbdFrame_getp(self, self1))
| 88093 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdFrame' or its derivative)"); |  | 88045 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdFrame' or its derivative)");
| 88094 | Ptr<cv::rgbd::RgbdFrame> _self_ = *(self1); |  | 88046 | Ptr<cv::rgbd::RgbdFrame> _self_ = *(self1);
| 88095 |  |  | 88047 |
| 88096 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88048 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88097 | { |  | 88049 | {
| 88098 | ERRWRAP2(_self_->release()); |  | 88050 | ERRWRAP2(_self_->release());
| 88099 | Py_RETURN_NONE; |  | 88051 | Py_RETURN_NONE;
| 88100 | } |  | 88052 | }
| 88101 |  |  | 88053 |
| 88102 | return NULL; |  | 88054 | return NULL;
| 88103 | } |  | 88055 | }
| 88104 |  |  | 88056 |
| 88105 |  |  | 88057 |
| 88106 |  |  | 88058 |
| 88107 | // Tables (rgbd_RgbdFrame) |  | 88059 | // Tables (rgbd_RgbdFrame)
| 88108 |  |  | 88060 |
| 88109 | static PyGetSetDef pyopencv_rgbd_RgbdFrame_getseters[] = |  | 88061 | static PyGetSetDef pyopencv_rgbd_RgbdFrame_getseters[] =
| 88110 | { |  | 88062 | {
| 88111 | {(char*)"ID", (getter)pyopencv_rgbd_RgbdFrame_get_ID, NULL, (char*)"ID", NULL}, |  | 88063 | {(char*)"ID", (getter)pyopencv_rgbd_RgbdFrame_get_ID, NULL, (char*)"ID", NULL},
| 88112 | {(char*)"depth", (getter)pyopencv_rgbd_RgbdFrame_get_depth, NULL, (char*)"depth", NULL}, |  | 88064 | {(char*)"depth", (getter)pyopencv_rgbd_RgbdFrame_get_depth, NULL, (char*)"depth", NULL},
| 88113 | {(char*)"image", (getter)pyopencv_rgbd_RgbdFrame_get_image, NULL, (char*)"image", NULL}, |  | 88065 | {(char*)"image", (getter)pyopencv_rgbd_RgbdFrame_get_image, NULL, (char*)"image", NULL},
| 88114 | {(char*)"mask", (getter)pyopencv_rgbd_RgbdFrame_get_mask, NULL, (char*)"mask", NULL}, |  | 88066 | {(char*)"mask", (getter)pyopencv_rgbd_RgbdFrame_get_mask, NULL, (char*)"mask", NULL},
| 88115 | {(char*)"normals", (getter)pyopencv_rgbd_RgbdFrame_get_normals, NULL, (char*)"normals", NULL}, |  | 88067 | {(char*)"normals", (getter)pyopencv_rgbd_RgbdFrame_get_normals, NULL, (char*)"normals", NULL},
| 88116 | {NULL} /* Sentinel */ |  | 88068 | {NULL} /* Sentinel */
| 88117 | }; |  | 88069 | };
| 88118 |  |  | 88070 |
| 88119 | static PyMethodDef pyopencv_rgbd_RgbdFrame_methods[] = |  | 88071 | static PyMethodDef pyopencv_rgbd_RgbdFrame_methods[] =
| 88120 | { |  | 88072 | {
| 88121 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdFrame_create_static, METH_STATIC), "create([, image[, depth[, mask[, normals[, ID]]]]]) -> retval\n."}, |  | 88073 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdFrame_create_static, METH_STATIC), "create([, image[, depth[, mask[, normals[, ID]]]]]) -> retval\n."},
| 88122 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdFrame_release, 0), "release() -> None\n."}, |  | 88074 | {"release", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdFrame_release, 0), "release() -> None\n."},
| 88123 |  |  | 88075 |
| 88124 | {NULL, NULL} |  | 88076 | {NULL, NULL}
| 88125 | }; |  | 88077 | };
| 88126 |  |  | 88078 |
| 88127 | // Converter (rgbd_RgbdFrame) |  | 88079 | // Converter (rgbd_RgbdFrame)
| 88128 |  |  | 88080 |
| 88129 | template<> |  | 88081 | template<>
| 88130 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdFrame> > |  | 88082 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdFrame> >
| 88131 | { |  | 88083 | {
| 88132 | static PyObject* from(const Ptr<cv::rgbd::RgbdFrame>& r) |  | 88084 | static PyObject* from(const Ptr<cv::rgbd::RgbdFrame>& r)
| 88133 | { |  | 88085 | {
| 88134 | return pyopencv_rgbd_RgbdFrame_Instance(r); |  | 88086 | return pyopencv_rgbd_RgbdFrame_Instance(r);
| 88135 | } |  | 88087 | }
| 88136 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdFrame>& dst, const ArgInfo& info) |  | 88088 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdFrame>& dst, const ArgInfo& info)
| 88137 | { |  | 88089 | {
| 88138 | if(!src || src == Py_None) |  | 88090 | if(!src || src == Py_None)
| 88139 | return true; |  | 88091 | return true;
| 88140 | Ptr<cv::rgbd::RgbdFrame> * dst_; |  | 88092 | Ptr<cv::rgbd::RgbdFrame> * dst_;
| 88141 | if (pyopencv_rgbd_RgbdFrame_getp(src, dst_)) |  | 88093 | if (pyopencv_rgbd_RgbdFrame_getp(src, dst_))
| 88142 | { |  | 88094 | {
| 88143 | dst = *dst_; |  | 88095 | dst = *dst_;
| 88144 | return true; |  | 88096 | return true;
| 88145 | } |  | 88097 | }
| 88146 |  |  | 88098 |
| 88147 | failmsg("Expected Ptr<cv::rgbd::RgbdFrame> for argument '%s'", info.name); |  | 88099 | failmsg("Expected Ptr<cv::rgbd::RgbdFrame> for argument '%s'", info.name);
| 88148 | return false; |  | 88100 | return false;
| 88149 | } |  | 88101 | }
| 88150 | }; |  | 88102 | };
| 88151 |  |  | 88103 |
| 88152 | //================================================================================ |  | 88104 | //================================================================================
| 88153 | // rgbd_RgbdICPOdometry (Generic) |  | 88105 | // rgbd_RgbdICPOdometry (Generic)
| 88154 | //================================================================================ |  | 88106 | //================================================================================
| 88155 |  |  | 88107 |
| 88156 | // GetSet (rgbd_RgbdICPOdometry) |  | 88108 | // GetSet (rgbd_RgbdICPOdometry)
| 88157 |  |  | 88109 |
| 88158 |  |  | 88110 |
| 88159 |  |  | 88111 |
| 88160 | // Methods (rgbd_RgbdICPOdometry) |  | 88112 | // Methods (rgbd_RgbdICPOdometry)
| 88161 |  |  | 88113 |
| 88162 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88114 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 88163 | { |  | 88115 | {
| 88164 | using namespace cv::rgbd; |  | 88116 | using namespace cv::rgbd;
| 88165 |  |  | 88117 |
| 88166 | PyObject* pyobj_cameraMatrix = NULL; |  | 88118 | PyObject* pyobj_cameraMatrix = NULL;
| 88167 | Mat cameraMatrix; |  | 88119 | Mat cameraMatrix;
| 88168 | PyObject* pyobj_minDepth = NULL; |  | 88120 | PyObject* pyobj_minDepth = NULL;
| 88169 | float minDepth=Odometry::DEFAULT_MIN_DEPTH(); |  | 88121 | float minDepth=Odometry::DEFAULT_MIN_DEPTH();
| 88170 | PyObject* pyobj_maxDepth = NULL; |  | 88122 | PyObject* pyobj_maxDepth = NULL;
| 88171 | float maxDepth=Odometry::DEFAULT_MAX_DEPTH(); |  | 88123 | float maxDepth=Odometry::DEFAULT_MAX_DEPTH();
| 88172 | PyObject* pyobj_maxDepthDiff = NULL; |  | 88124 | PyObject* pyobj_maxDepthDiff = NULL;
| 88173 | float maxDepthDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF(); |  | 88125 | float maxDepthDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF();
| 88174 | PyObject* pyobj_maxPointsPart = NULL; |  | 88126 | PyObject* pyobj_maxPointsPart = NULL;
| 88175 | float maxPointsPart=Odometry::DEFAULT_MAX_POINTS_PART(); |  | 88127 | float maxPointsPart=Odometry::DEFAULT_MAX_POINTS_PART();
| 88176 | PyObject* pyobj_iterCounts = NULL; |  | 88128 | PyObject* pyobj_iterCounts = NULL;
| 88177 | vector_int iterCounts=std::vector<int>(); |  | 88129 | vector_int iterCounts=std::vector<int>();
| 88178 | PyObject* pyobj_minGradientMagnitudes = NULL; |  | 88130 | PyObject* pyobj_minGradientMagnitudes = NULL;
| 88179 | vector_float minGradientMagnitudes=std::vector<float>(); |  | 88131 | vector_float minGradientMagnitudes=std::vector<float>();
| 88180 | PyObject* pyobj_transformType = NULL; |  | 88132 | PyObject* pyobj_transformType = NULL;
| 88181 | int transformType=Odometry::RIGID_BODY_MOTION; |  | 88133 | int transformType=Odometry::RIGID_BODY_MOTION;
| 88182 | Ptr<RgbdICPOdometry> retval; |  | 88134 | Ptr<RgbdICPOdometry> retval;
| 88183 |  |  | 88135 |
| 88184 | const char* keywords[] = { "cameraMatrix", "minDepth", "maxDepth", "maxDepthDiff", "maxPointsPart", "iterCounts", "minGradientMagnitudes", "transformType", NULL }; |  | 88136 | const char* keywords[] = { "cameraMatrix", "minDepth", "maxDepth", "maxDepthDiff", "maxPointsPart", "iterCounts", "minGradientMagnitudes", "transformType", NULL };
| 88185 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:rgbd_RgbdICPOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_minDepth, &pyobj_maxDepth, &pyobj_maxDepthDiff, &pyobj_maxPointsPart, &pyobj_iterCounts, &pyobj_minGradientMagnitudes, &pyobj_transformType) && |  | 88137 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:rgbd_RgbdICPOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_minDepth, &pyobj_maxDepth, &pyobj_maxDepthDiff, &pyobj_maxPointsPart, &pyobj_iterCounts, &pyobj_minGradientMagnitudes, &pyobj_transformType) &&
| 88186 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) && |  | 88138 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) &&
| 88187 | pyopencv_to_safe(pyobj_minDepth, minDepth, ArgInfo("minDepth", 0)) && |  | 88139 | pyopencv_to_safe(pyobj_minDepth, minDepth, ArgInfo("minDepth", 0)) &&
| 88188 | pyopencv_to_safe(pyobj_maxDepth, maxDepth, ArgInfo("maxDepth", 0)) && |  | 88140 | pyopencv_to_safe(pyobj_maxDepth, maxDepth, ArgInfo("maxDepth", 0)) &&
| 88189 | pyopencv_to_safe(pyobj_maxDepthDiff, maxDepthDiff, ArgInfo("maxDepthDiff", 0)) && |  | 88141 | pyopencv_to_safe(pyobj_maxDepthDiff, maxDepthDiff, ArgInfo("maxDepthDiff", 0)) &&
| 88190 | pyopencv_to_safe(pyobj_maxPointsPart, maxPointsPart, ArgInfo("maxPointsPart", 0)) && |  | 88142 | pyopencv_to_safe(pyobj_maxPointsPart, maxPointsPart, ArgInfo("maxPointsPart", 0)) &&
| 88191 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) && |  | 88143 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) &&
| 88192 | pyopencv_to_safe(pyobj_minGradientMagnitudes, minGradientMagnitudes, ArgInfo("minGradientMagnitudes", 0)) && |  | 88144 | pyopencv_to_safe(pyobj_minGradientMagnitudes, minGradientMagnitudes, ArgInfo("minGradientMagnitudes", 0)) &&
| 88193 | pyopencv_to_safe(pyobj_transformType, transformType, ArgInfo("transformType", 0)) ) |  | 88145 | pyopencv_to_safe(pyobj_transformType, transformType, ArgInfo("transformType", 0)) )
| 88194 | { |  | 88146 | {
| 88195 | ERRWRAP2(retval = cv::rgbd::RgbdICPOdometry::create(cameraMatrix, minDepth, maxDepth, maxDepthDiff, maxPointsPart, iterCounts, minGradientMagnitudes, transformType)); |  | 88147 | ERRWRAP2(retval = cv::rgbd::RgbdICPOdometry::create(cameraMatrix, minDepth, maxDepth, maxDepthDiff, maxPointsPart, iterCounts, minGradientMagnitudes, transformType));
| 88196 | return pyopencv_from(retval); |  | 88148 | return pyopencv_from(retval);
| 88197 | } |  | 88149 | }
| 88198 |  |  | 88150 |
| 88199 | return NULL; |  | 88151 | return NULL;
| 88200 | } |  | 88152 | }
| 88201 |  |  | 88153 |
| 88202 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88154 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 88203 | { |  | 88155 | {
| 88204 | using namespace cv::rgbd; |  | 88156 | using namespace cv::rgbd;
| 88205 |  |  | 88157 |
| 88206 |  |  | 88158 |
| 88207 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88159 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88208 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88160 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88209 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88161 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88210 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88162 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88211 | cv::Mat retval; |  | 88163 | cv::Mat retval;
| 88212 |  |  | 88164 |
| 88213 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88165 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88214 | { |  | 88166 | {
| 88215 | ERRWRAP2(retval = _self_->getCameraMatrix()); |  | 88167 | ERRWRAP2(retval = _self_->getCameraMatrix());
| 88216 | return pyopencv_from(retval); |  | 88168 | return pyopencv_from(retval);
| 88217 | } |  | 88169 | }
| 88218 |  |  | 88170 |
| 88219 | return NULL; |  | 88171 | return NULL;
| 88220 | } |  | 88172 | }
| 88221 |  |  | 88173 |
| 88222 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88174 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 88223 | { |  | 88175 | {
| 88224 | using namespace cv::rgbd; |  | 88176 | using namespace cv::rgbd;
| 88225 |  |  | 88177 |
| 88226 |  |  | 88178 |
| 88227 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88179 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88228 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88180 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88229 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88181 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88230 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88182 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88231 | cv::Mat retval; |  | 88183 | cv::Mat retval;
| 88232 |  |  | 88184 |
| 88233 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88185 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88234 | { |  | 88186 | {
| 88235 | ERRWRAP2(retval = _self_->getIterationCounts()); |  | 88187 | ERRWRAP2(retval = _self_->getIterationCounts());
| 88236 | return pyopencv_from(retval); |  | 88188 | return pyopencv_from(retval);
| 88237 | } |  | 88189 | }
| 88238 |  |  | 88190 |
| 88239 | return NULL; |  | 88191 | return NULL;
| 88240 | } |  | 88192 | }
| 88241 |  |  | 88193 |
| 88242 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88194 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 88243 | { |  | 88195 | {
| 88244 | using namespace cv::rgbd; |  | 88196 | using namespace cv::rgbd;
| 88245 |  |  | 88197 |
| 88246 |  |  | 88198 |
| 88247 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88199 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88248 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88200 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88249 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88201 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88250 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88202 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88251 | double retval; |  | 88203 | double retval;
| 88252 |  |  | 88204 |
| 88253 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88205 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88254 | { |  | 88206 | {
| 88255 | ERRWRAP2(retval = _self_->getMaxDepth()); |  | 88207 | ERRWRAP2(retval = _self_->getMaxDepth());
| 88256 | return pyopencv_from(retval); |  | 88208 | return pyopencv_from(retval);
| 88257 | } |  | 88209 | }
| 88258 |  |  | 88210 |
| 88259 | return NULL; |  | 88211 | return NULL;
| 88260 | } |  | 88212 | }
| 88261 |  |  | 88213 |
| 88262 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88214 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 88263 | { |  | 88215 | {
| 88264 | using namespace cv::rgbd; |  | 88216 | using namespace cv::rgbd;
| 88265 |  |  | 88217 |
| 88266 |  |  | 88218 |
| 88267 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88219 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88268 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88220 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88269 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88221 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88270 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88222 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88271 | double retval; |  | 88223 | double retval;
| 88272 |  |  | 88224 |
| 88273 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88225 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88274 | { |  | 88226 | {
| 88275 | ERRWRAP2(retval = _self_->getMaxDepthDiff()); |  | 88227 | ERRWRAP2(retval = _self_->getMaxDepthDiff());
| 88276 | return pyopencv_from(retval); |  | 88228 | return pyopencv_from(retval);
| 88277 | } |  | 88229 | }
| 88278 |  |  | 88230 |
| 88279 | return NULL; |  | 88231 | return NULL;
| 88280 | } |  | 88232 | }
| 88281 |  |  | 88233 |
| 88282 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88234 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw)
| 88283 | { |  | 88235 | {
| 88284 | using namespace cv::rgbd; |  | 88236 | using namespace cv::rgbd;
| 88285 |  |  | 88237 |
| 88286 |  |  | 88238 |
| 88287 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88239 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88288 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88240 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88289 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88241 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88290 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88242 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88291 | double retval; |  | 88243 | double retval;
| 88292 |  |  | 88244 |
| 88293 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88245 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88294 | { |  | 88246 | {
| 88295 | ERRWRAP2(retval = _self_->getMaxPointsPart()); |  | 88247 | ERRWRAP2(retval = _self_->getMaxPointsPart());
| 88296 | return pyopencv_from(retval); |  | 88248 | return pyopencv_from(retval);
| 88297 | } |  | 88249 | }
| 88298 |  |  | 88250 |
| 88299 | return NULL; |  | 88251 | return NULL;
| 88300 | } |  | 88252 | }
| 88301 |  |  | 88253 |
| 88302 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88254 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw)
| 88303 | { |  | 88255 | {
| 88304 | using namespace cv::rgbd; |  | 88256 | using namespace cv::rgbd;
| 88305 |  |  | 88257 |
| 88306 |  |  | 88258 |
| 88307 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88259 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88308 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88260 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88309 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88261 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88310 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88262 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88311 | double retval; |  | 88263 | double retval;
| 88312 |  |  | 88264 |
| 88313 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88265 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88314 | { |  | 88266 | {
| 88315 | ERRWRAP2(retval = _self_->getMaxRotation()); |  | 88267 | ERRWRAP2(retval = _self_->getMaxRotation());
| 88316 | return pyopencv_from(retval); |  | 88268 | return pyopencv_from(retval);
| 88317 | } |  | 88269 | }
| 88318 |  |  | 88270 |
| 88319 | return NULL; |  | 88271 | return NULL;
| 88320 | } |  | 88272 | }
| 88321 |  |  | 88273 |
| 88322 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88274 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw)
| 88323 | { |  | 88275 | {
| 88324 | using namespace cv::rgbd; |  | 88276 | using namespace cv::rgbd;
| 88325 |  |  | 88277 |
| 88326 |  |  | 88278 |
| 88327 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88279 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88328 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88280 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88329 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88281 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88330 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88282 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88331 | double retval; |  | 88283 | double retval;
| 88332 |  |  | 88284 |
| 88333 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88285 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88334 | { |  | 88286 | {
| 88335 | ERRWRAP2(retval = _self_->getMaxTranslation()); |  | 88287 | ERRWRAP2(retval = _self_->getMaxTranslation());
| 88336 | return pyopencv_from(retval); |  | 88288 | return pyopencv_from(retval);
| 88337 | } |  | 88289 | }
| 88338 |  |  | 88290 |
| 88339 | return NULL; |  | 88291 | return NULL;
| 88340 | } |  | 88292 | }
| 88341 |  |  | 88293 |
| 88342 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88294 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 88343 | { |  | 88295 | {
| 88344 | using namespace cv::rgbd; |  | 88296 | using namespace cv::rgbd;
| 88345 |  |  | 88297 |
| 88346 |  |  | 88298 |
| 88347 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88299 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88348 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88300 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88349 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88301 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88350 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88302 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88351 | double retval; |  | 88303 | double retval;
| 88352 |  |  | 88304 |
| 88353 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88305 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88354 | { |  | 88306 | {
| 88355 | ERRWRAP2(retval = _self_->getMinDepth()); |  | 88307 | ERRWRAP2(retval = _self_->getMinDepth());
| 88356 | return pyopencv_from(retval); |  | 88308 | return pyopencv_from(retval);
| 88357 | } |  | 88309 | }
| 88358 |  |  | 88310 |
| 88359 | return NULL; |  | 88311 | return NULL;
| 88360 | } |  | 88312 | }
| 88361 |  |  | 88313 |
| 88362 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88314 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw)
| 88363 | { |  | 88315 | {
| 88364 | using namespace cv::rgbd; |  | 88316 | using namespace cv::rgbd;
| 88365 |  |  | 88317 |
| 88366 |  |  | 88318 |
| 88367 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88319 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88368 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88320 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88369 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88321 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88370 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88322 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88371 | cv::Mat retval; |  | 88323 | cv::Mat retval;
| 88372 |  |  | 88324 |
| 88373 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88325 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88374 | { |  | 88326 | {
| 88375 | ERRWRAP2(retval = _self_->getMinGradientMagnitudes()); |  | 88327 | ERRWRAP2(retval = _self_->getMinGradientMagnitudes());
| 88376 | return pyopencv_from(retval); |  | 88328 | return pyopencv_from(retval);
| 88377 | } |  | 88329 | }
| 88378 |  |  | 88330 |
| 88379 | return NULL; |  | 88331 | return NULL;
| 88380 | } |  | 88332 | }
| 88381 |  |  | 88333 |
| 88382 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getNormalsComputer(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88334 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getNormalsComputer(PyObject* self, PyObject* py_args, PyObject* kw)
| 88383 | { |  | 88335 | {
| 88384 | using namespace cv::rgbd; |  | 88336 | using namespace cv::rgbd;
| 88385 |  |  | 88337 |
| 88386 |  |  | 88338 |
| 88387 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88339 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88388 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88340 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88389 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88341 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88390 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88342 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88391 | Ptr<RgbdNormals> retval; |  | 88343 | Ptr<RgbdNormals> retval;
| 88392 |  |  | 88344 |
| 88393 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88345 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88394 | { |  | 88346 | {
| 88395 | ERRWRAP2(retval = _self_->getNormalsComputer()); |  | 88347 | ERRWRAP2(retval = _self_->getNormalsComputer());
| 88396 | return pyopencv_from(retval); |  | 88348 | return pyopencv_from(retval);
| 88397 | } |  | 88349 | }
| 88398 |  |  | 88350 |
| 88399 | return NULL; |  | 88351 | return NULL;
| 88400 | } |  | 88352 | }
| 88401 |  |  | 88353 |
| 88402 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88354 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 88403 | { |  | 88355 | {
| 88404 | using namespace cv::rgbd; |  | 88356 | using namespace cv::rgbd;
| 88405 |  |  | 88357 |
| 88406 |  |  | 88358 |
| 88407 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88359 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88408 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88360 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88409 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88361 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88410 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88362 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88411 | int retval; |  | 88363 | int retval;
| 88412 |  |  | 88364 |
| 88413 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88365 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88414 | { |  | 88366 | {
| 88415 | ERRWRAP2(retval = _self_->getTransformType()); |  | 88367 | ERRWRAP2(retval = _self_->getTransformType());
| 88416 | return pyopencv_from(retval); |  | 88368 | return pyopencv_from(retval);
| 88417 | } |  | 88369 | }
| 88418 |  |  | 88370 |
| 88419 | return NULL; |  | 88371 | return NULL;
| 88420 | } |  | 88372 | }
| 88421 |  |  | 88373 |
| 88422 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88374 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw)
| 88423 | { |  | 88375 | {
| 88424 | using namespace cv::rgbd; |  | 88376 | using namespace cv::rgbd;
| 88425 |  |  | 88377 |
| 88426 |  |  | 88378 |
| 88427 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88379 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88428 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88380 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88429 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88381 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88430 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88382 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88431 | PyObject* pyobj_frame = NULL; |  | 88383 | PyObject* pyobj_frame = NULL;
| 88432 | Ptr<OdometryFrame> frame; |  | 88384 | Ptr<OdometryFrame> frame;
| 88433 | PyObject* pyobj_cacheType = NULL; |  | 88385 | PyObject* pyobj_cacheType = NULL;
| 88434 | int cacheType=0; |  | 88386 | int cacheType=0;
| 88435 | Size retval; |  | 88387 | Size retval;
| 88436 |  |  | 88388 |
| 88437 | const char* keywords[] = { "frame", "cacheType", NULL }; |  | 88389 | const char* keywords[] = { "frame", "cacheType", NULL };
| 88438 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_RgbdICPOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) && |  | 88390 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_RgbdICPOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) &&
| 88439 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 88391 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 88440 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) ) |  | 88392 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) )
| 88441 | { |  | 88393 | {
| 88442 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType)); |  | 88394 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType));
| 88443 | return pyopencv_from(retval); |  | 88395 | return pyopencv_from(retval);
| 88444 | } |  | 88396 | }
| 88445 |  |  | 88397 |
| 88446 | return NULL; |  | 88398 | return NULL;
| 88447 | } |  | 88399 | }
| 88448 |  |  | 88400 |
| 88449 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88401 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 88450 | { |  | 88402 | {
| 88451 | using namespace cv::rgbd; |  | 88403 | using namespace cv::rgbd;
| 88452 |  |  | 88404 |
| 88453 |  |  | 88405 |
| 88454 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88406 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88455 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88407 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88456 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88408 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88457 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88409 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88458 | PyObject* pyobj_val = NULL; |  | 88410 | PyObject* pyobj_val = NULL;
| 88459 | Mat val; |  | 88411 | Mat val;
| 88460 |  |  | 88412 |
| 88461 | const char* keywords[] = { "val", NULL }; |  | 88413 | const char* keywords[] = { "val", NULL };
| 88462 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) && |  | 88414 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) &&
| 88463 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88415 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88464 | { |  | 88416 | {
| 88465 | ERRWRAP2(_self_->setCameraMatrix(val)); |  | 88417 | ERRWRAP2(_self_->setCameraMatrix(val));
| 88466 | Py_RETURN_NONE; |  | 88418 | Py_RETURN_NONE;
| 88467 | } |  | 88419 | }
| 88468 |  |  | 88420 |
| 88469 | return NULL; |  | 88421 | return NULL;
| 88470 | } |  | 88422 | }
| 88471 |  |  | 88423 |
| 88472 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88424 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 88473 | { |  | 88425 | {
| 88474 | using namespace cv::rgbd; |  | 88426 | using namespace cv::rgbd;
| 88475 |  |  | 88427 |
| 88476 |  |  | 88428 |
| 88477 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88429 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88478 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88430 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88479 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88431 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88480 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88432 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88481 | PyObject* pyobj_val = NULL; |  | 88433 | PyObject* pyobj_val = NULL;
| 88482 | Mat val; |  | 88434 | Mat val;
| 88483 |  |  | 88435 |
| 88484 | const char* keywords[] = { "val", NULL }; |  | 88436 | const char* keywords[] = { "val", NULL };
| 88485 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setIterationCounts", (char**)keywords, &pyobj_val) && |  | 88437 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setIterationCounts", (char**)keywords, &pyobj_val) &&
| 88486 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88438 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88487 | { |  | 88439 | {
| 88488 | ERRWRAP2(_self_->setIterationCounts(val)); |  | 88440 | ERRWRAP2(_self_->setIterationCounts(val));
| 88489 | Py_RETURN_NONE; |  | 88441 | Py_RETURN_NONE;
| 88490 | } |  | 88442 | }
| 88491 |  |  | 88443 |
| 88492 | return NULL; |  | 88444 | return NULL;
| 88493 | } |  | 88445 | }
| 88494 |  |  | 88446 |
| 88495 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88447 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 88496 | { |  | 88448 | {
| 88497 | using namespace cv::rgbd; |  | 88449 | using namespace cv::rgbd;
| 88498 |  |  | 88450 |
| 88499 |  |  | 88451 |
| 88500 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88452 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88501 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88453 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88502 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88454 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88503 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88455 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88504 | PyObject* pyobj_val = NULL; |  | 88456 | PyObject* pyobj_val = NULL;
| 88505 | double val=0; |  | 88457 | double val=0;
| 88506 |  |  | 88458 |
| 88507 | const char* keywords[] = { "val", NULL }; |  | 88459 | const char* keywords[] = { "val", NULL };
| 88508 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxDepth", (char**)keywords, &pyobj_val) && |  | 88460 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxDepth", (char**)keywords, &pyobj_val) &&
| 88509 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88461 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88510 | { |  | 88462 | {
| 88511 | ERRWRAP2(_self_->setMaxDepth(val)); |  | 88463 | ERRWRAP2(_self_->setMaxDepth(val));
| 88512 | Py_RETURN_NONE; |  | 88464 | Py_RETURN_NONE;
| 88513 | } |  | 88465 | }
| 88514 |  |  | 88466 |
| 88515 | return NULL; |  | 88467 | return NULL;
| 88516 | } |  | 88468 | }
| 88517 |  |  | 88469 |
| 88518 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88470 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 88519 | { |  | 88471 | {
| 88520 | using namespace cv::rgbd; |  | 88472 | using namespace cv::rgbd;
| 88521 |  |  | 88473 |
| 88522 |  |  | 88474 |
| 88523 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88475 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88524 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88476 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88525 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88477 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88526 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88478 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88527 | PyObject* pyobj_val = NULL; |  | 88479 | PyObject* pyobj_val = NULL;
| 88528 | double val=0; |  | 88480 | double val=0;
| 88529 |  |  | 88481 |
| 88530 | const char* keywords[] = { "val", NULL }; |  | 88482 | const char* keywords[] = { "val", NULL };
| 88531 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxDepthDiff", (char**)keywords, &pyobj_val) && |  | 88483 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxDepthDiff", (char**)keywords, &pyobj_val) &&
| 88532 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88484 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88533 | { |  | 88485 | {
| 88534 | ERRWRAP2(_self_->setMaxDepthDiff(val)); |  | 88486 | ERRWRAP2(_self_->setMaxDepthDiff(val));
| 88535 | Py_RETURN_NONE; |  | 88487 | Py_RETURN_NONE;
| 88536 | } |  | 88488 | }
| 88537 |  |  | 88489 |
| 88538 | return NULL; |  | 88490 | return NULL;
| 88539 | } |  | 88491 | }
| 88540 |  |  | 88492 |
| 88541 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88493 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw)
| 88542 | { |  | 88494 | {
| 88543 | using namespace cv::rgbd; |  | 88495 | using namespace cv::rgbd;
| 88544 |  |  | 88496 |
| 88545 |  |  | 88497 |
| 88546 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88498 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88547 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88499 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88548 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88500 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88549 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88501 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88550 | PyObject* pyobj_val = NULL; |  | 88502 | PyObject* pyobj_val = NULL;
| 88551 | double val=0; |  | 88503 | double val=0;
| 88552 |  |  | 88504 |
| 88553 | const char* keywords[] = { "val", NULL }; |  | 88505 | const char* keywords[] = { "val", NULL };
| 88554 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxPointsPart", (char**)keywords, &pyobj_val) && |  | 88506 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxPointsPart", (char**)keywords, &pyobj_val) &&
| 88555 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88507 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88556 | { |  | 88508 | {
| 88557 | ERRWRAP2(_self_->setMaxPointsPart(val)); |  | 88509 | ERRWRAP2(_self_->setMaxPointsPart(val));
| 88558 | Py_RETURN_NONE; |  | 88510 | Py_RETURN_NONE;
| 88559 | } |  | 88511 | }
| 88560 |  |  | 88512 |
| 88561 | return NULL; |  | 88513 | return NULL;
| 88562 | } |  | 88514 | }
| 88563 |  |  | 88515 |
| 88564 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88516 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw)
| 88565 | { |  | 88517 | {
| 88566 | using namespace cv::rgbd; |  | 88518 | using namespace cv::rgbd;
| 88567 |  |  | 88519 |
| 88568 |  |  | 88520 |
| 88569 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88521 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88570 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88522 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88571 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88523 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88572 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88524 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88573 | PyObject* pyobj_val = NULL; |  | 88525 | PyObject* pyobj_val = NULL;
| 88574 | double val=0; |  | 88526 | double val=0;
| 88575 |  |  | 88527 |
| 88576 | const char* keywords[] = { "val", NULL }; |  | 88528 | const char* keywords[] = { "val", NULL };
| 88577 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxRotation", (char**)keywords, &pyobj_val) && |  | 88529 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxRotation", (char**)keywords, &pyobj_val) &&
| 88578 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88530 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88579 | { |  | 88531 | {
| 88580 | ERRWRAP2(_self_->setMaxRotation(val)); |  | 88532 | ERRWRAP2(_self_->setMaxRotation(val));
| 88581 | Py_RETURN_NONE; |  | 88533 | Py_RETURN_NONE;
| 88582 | } |  | 88534 | }
| 88583 |  |  | 88535 |
| 88584 | return NULL; |  | 88536 | return NULL;
| 88585 | } |  | 88537 | }
| 88586 |  |  | 88538 |
| 88587 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88539 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw)
| 88588 | { |  | 88540 | {
| 88589 | using namespace cv::rgbd; |  | 88541 | using namespace cv::rgbd;
| 88590 |  |  | 88542 |
| 88591 |  |  | 88543 |
| 88592 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88544 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88593 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88545 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88594 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88546 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88595 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88547 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88596 | PyObject* pyobj_val = NULL; |  | 88548 | PyObject* pyobj_val = NULL;
| 88597 | double val=0; |  | 88549 | double val=0;
| 88598 |  |  | 88550 |
| 88599 | const char* keywords[] = { "val", NULL }; |  | 88551 | const char* keywords[] = { "val", NULL };
| 88600 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxTranslation", (char**)keywords, &pyobj_val) && |  | 88552 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMaxTranslation", (char**)keywords, &pyobj_val) &&
| 88601 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88553 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88602 | { |  | 88554 | {
| 88603 | ERRWRAP2(_self_->setMaxTranslation(val)); |  | 88555 | ERRWRAP2(_self_->setMaxTranslation(val));
| 88604 | Py_RETURN_NONE; |  | 88556 | Py_RETURN_NONE;
| 88605 | } |  | 88557 | }
| 88606 |  |  | 88558 |
| 88607 | return NULL; |  | 88559 | return NULL;
| 88608 | } |  | 88560 | }
| 88609 |  |  | 88561 |
| 88610 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88562 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 88611 | { |  | 88563 | {
| 88612 | using namespace cv::rgbd; |  | 88564 | using namespace cv::rgbd;
| 88613 |  |  | 88565 |
| 88614 |  |  | 88566 |
| 88615 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88567 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88616 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88568 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88617 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88569 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88618 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88570 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88619 | PyObject* pyobj_val = NULL; |  | 88571 | PyObject* pyobj_val = NULL;
| 88620 | double val=0; |  | 88572 | double val=0;
| 88621 |  |  | 88573 |
| 88622 | const char* keywords[] = { "val", NULL }; |  | 88574 | const char* keywords[] = { "val", NULL };
| 88623 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMinDepth", (char**)keywords, &pyobj_val) && |  | 88575 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMinDepth", (char**)keywords, &pyobj_val) &&
| 88624 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88576 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88625 | { |  | 88577 | {
| 88626 | ERRWRAP2(_self_->setMinDepth(val)); |  | 88578 | ERRWRAP2(_self_->setMinDepth(val));
| 88627 | Py_RETURN_NONE; |  | 88579 | Py_RETURN_NONE;
| 88628 | } |  | 88580 | }
| 88629 |  |  | 88581 |
| 88630 | return NULL; |  | 88582 | return NULL;
| 88631 | } |  | 88583 | }
| 88632 |  |  | 88584 |
| 88633 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88585 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw)
| 88634 | { |  | 88586 | {
| 88635 | using namespace cv::rgbd; |  | 88587 | using namespace cv::rgbd;
| 88636 |  |  | 88588 |
| 88637 |  |  | 88589 |
| 88638 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88590 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88639 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88591 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88640 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88592 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88641 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88593 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88642 | PyObject* pyobj_val = NULL; |  | 88594 | PyObject* pyobj_val = NULL;
| 88643 | Mat val; |  | 88595 | Mat val;
| 88644 |  |  | 88596 |
| 88645 | const char* keywords[] = { "val", NULL }; |  | 88597 | const char* keywords[] = { "val", NULL };
| 88646 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMinGradientMagnitudes", (char**)keywords, &pyobj_val) && |  | 88598 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setMinGradientMagnitudes", (char**)keywords, &pyobj_val) &&
| 88647 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88599 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88648 | { |  | 88600 | {
| 88649 | ERRWRAP2(_self_->setMinGradientMagnitudes(val)); |  | 88601 | ERRWRAP2(_self_->setMinGradientMagnitudes(val));
| 88650 | Py_RETURN_NONE; |  | 88602 | Py_RETURN_NONE;
| 88651 | } |  | 88603 | }
| 88652 |  |  | 88604 |
| 88653 | return NULL; |  | 88605 | return NULL;
| 88654 | } |  | 88606 | }
| 88655 |  |  | 88607 |
| 88656 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88608 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 88657 | { |  | 88609 | {
| 88658 | using namespace cv::rgbd; |  | 88610 | using namespace cv::rgbd;
| 88659 |  |  | 88611 |
| 88660 |  |  | 88612 |
| 88661 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0; |  | 88613 | Ptr<cv::rgbd::RgbdICPOdometry> * self1 = 0;
| 88662 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1)) |  | 88614 | if (!pyopencv_rgbd_RgbdICPOdometry_getp(self, self1))
| 88663 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)"); |  | 88615 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdICPOdometry' or its derivative)");
| 88664 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1); |  | 88616 | Ptr<cv::rgbd::RgbdICPOdometry> _self_ = *(self1);
| 88665 | PyObject* pyobj_val = NULL; |  | 88617 | PyObject* pyobj_val = NULL;
| 88666 | int val=0; |  | 88618 | int val=0;
| 88667 |  |  | 88619 |
| 88668 | const char* keywords[] = { "val", NULL }; |  | 88620 | const char* keywords[] = { "val", NULL };
| 88669 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setTransformType", (char**)keywords, &pyobj_val) && |  | 88621 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdICPOdometry.setTransformType", (char**)keywords, &pyobj_val) &&
| 88670 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88622 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 88671 | { |  | 88623 | {
| 88672 | ERRWRAP2(_self_->setTransformType(val)); |  | 88624 | ERRWRAP2(_self_->setTransformType(val));
| 88673 | Py_RETURN_NONE; |  | 88625 | Py_RETURN_NONE;
| 88674 | } |  | 88626 | }
| 88675 |  |  | 88627 |
| 88676 | return NULL; |  | 88628 | return NULL;
| 88677 | } |  | 88629 | }
| 88678 |  |  | 88630 |
| 88679 |  |  | 88631 |
| 88680 |  |  | 88632 |
| 88681 | // Tables (rgbd_RgbdICPOdometry) |  | 88633 | // Tables (rgbd_RgbdICPOdometry)
| 88682 |  |  | 88634 |
| 88683 | static PyGetSetDef pyopencv_rgbd_RgbdICPOdometry_getseters[] = |  | 88635 | static PyGetSetDef pyopencv_rgbd_RgbdICPOdometry_getseters[] =
| 88684 | { |  | 88636 | {
| 88685 | {NULL} /* Sentinel */ |  | 88637 | {NULL} /* Sentinel */
| 88686 | }; |  | 88638 | };
| 88687 |  |  | 88639 |
| 88688 | static PyMethodDef pyopencv_rgbd_RgbdICPOdometry_methods[] = |  | 88640 | static PyMethodDef pyopencv_rgbd_RgbdICPOdometry_methods[] =
| 88689 | { |  | 88641 | {
| 88690 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_create_static, METH_STATIC), "create([, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, maxPointsPart[, iterCounts[, minGradientMagnitudes[, transformType]]]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param minDepth Pixels with depth less than minDepth will not be used\n. * @param maxDepth Pixels with depth larger than maxDepth will not be used\n. * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff\n. * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart\n. * @param iterCounts Count of iterations on each pyramid level.\n. * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out\n. * if they have gradient magnitude less than minGradientMagnitudes[level].\n. * @param transformType Class of trasformation"}, |  | 88642 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_create_static, METH_STATIC), "create([, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, maxPointsPart[, iterCounts[, minGradientMagnitudes[, transformType]]]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param minDepth Pixels with depth less than minDepth will not be used\n. * @param maxDepth Pixels with depth larger than maxDepth will not be used\n. * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff\n. * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart\n. * @param iterCounts Count of iterations on each pyramid level.\n. * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out\n. * if they have gradient magnitude less than minGradientMagnitudes[level].\n. * @param transformType Class of trasformation"},
| 88691 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."}, |  | 88643 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."},
| 88692 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."}, |  | 88644 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."},
| 88693 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepth, 0), "getMaxDepth() -> retval\n."}, |  | 88645 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepth, 0), "getMaxDepth() -> retval\n."},
| 88694 | {"getMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepthDiff, 0), "getMaxDepthDiff() -> retval\n."}, |  | 88646 | {"getMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxDepthDiff, 0), "getMaxDepthDiff() -> retval\n."},
| 88695 | {"getMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxPointsPart, 0), "getMaxPointsPart() -> retval\n."}, |  | 88647 | {"getMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxPointsPart, 0), "getMaxPointsPart() -> retval\n."},
| 88696 | {"getMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxRotation, 0), "getMaxRotation() -> retval\n."}, |  | 88648 | {"getMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxRotation, 0), "getMaxRotation() -> retval\n."},
| 88697 | {"getMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxTranslation, 0), "getMaxTranslation() -> retval\n."}, |  | 88649 | {"getMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMaxTranslation, 0), "getMaxTranslation() -> retval\n."},
| 88698 | {"getMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinDepth, 0), "getMinDepth() -> retval\n."}, |  | 88650 | {"getMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinDepth, 0), "getMinDepth() -> retval\n."},
| 88699 | {"getMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinGradientMagnitudes, 0), "getMinGradientMagnitudes() -> retval\n."}, |  | 88651 | {"getMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getMinGradientMagnitudes, 0), "getMinGradientMagnitudes() -> retval\n."},
| 88700 | {"getNormalsComputer", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getNormalsComputer, 0), "getNormalsComputer() -> retval\n."}, |  | 88652 | {"getNormalsComputer", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getNormalsComputer, 0), "getNormalsComputer() -> retval\n."},
| 88701 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getTransformType, 0), "getTransformType() -> retval\n."}, |  | 88653 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_getTransformType, 0), "getTransformType() -> retval\n."},
| 88702 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."}, |  | 88654 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."},
| 88703 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."}, |  | 88655 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."},
| 88704 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."}, |  | 88656 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."},
| 88705 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepth, 0), "setMaxDepth(val) -> None\n."}, |  | 88657 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepth, 0), "setMaxDepth(val) -> None\n."},
| 88706 | {"setMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepthDiff, 0), "setMaxDepthDiff(val) -> None\n."}, |  | 88658 | {"setMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxDepthDiff, 0), "setMaxDepthDiff(val) -> None\n."},
| 88707 | {"setMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxPointsPart, 0), "setMaxPointsPart(val) -> None\n."}, |  | 88659 | {"setMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxPointsPart, 0), "setMaxPointsPart(val) -> None\n."},
| 88708 | {"setMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxRotation, 0), "setMaxRotation(val) -> None\n."}, |  | 88660 | {"setMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxRotation, 0), "setMaxRotation(val) -> None\n."},
| 88709 | {"setMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxTranslation, 0), "setMaxTranslation(val) -> None\n."}, |  | 88661 | {"setMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMaxTranslation, 0), "setMaxTranslation(val) -> None\n."},
| 88710 | {"setMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinDepth, 0), "setMinDepth(val) -> None\n."}, |  | 88662 | {"setMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinDepth, 0), "setMinDepth(val) -> None\n."},
| 88711 | {"setMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinGradientMagnitudes, 0), "setMinGradientMagnitudes(val) -> None\n."}, |  | 88663 | {"setMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setMinGradientMagnitudes, 0), "setMinGradientMagnitudes(val) -> None\n."},
| 88712 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setTransformType, 0), "setTransformType(val) -> None\n."}, |  | 88664 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdICPOdometry_setTransformType, 0), "setTransformType(val) -> None\n."},
| 88713 |  |  | 88665 |
| 88714 | {NULL, NULL} |  | 88666 | {NULL, NULL}
| 88715 | }; |  | 88667 | };
| 88716 |  |  | 88668 |
| 88717 | // Converter (rgbd_RgbdICPOdometry) |  | 88669 | // Converter (rgbd_RgbdICPOdometry)
| 88718 |  |  | 88670 |
| 88719 | template<> |  | 88671 | template<>
| 88720 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdICPOdometry> > |  | 88672 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdICPOdometry> >
| 88721 | { |  | 88673 | {
| 88722 | static PyObject* from(const Ptr<cv::rgbd::RgbdICPOdometry>& r) |  | 88674 | static PyObject* from(const Ptr<cv::rgbd::RgbdICPOdometry>& r)
| 88723 | { |  | 88675 | {
| 88724 | return pyopencv_rgbd_RgbdICPOdometry_Instance(r); |  | 88676 | return pyopencv_rgbd_RgbdICPOdometry_Instance(r);
| 88725 | } |  | 88677 | }
| 88726 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdICPOdometry>& dst, const ArgInfo& info) |  | 88678 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdICPOdometry>& dst, const ArgInfo& info)
| 88727 | { |  | 88679 | {
| 88728 | if(!src || src == Py_None) |  | 88680 | if(!src || src == Py_None)
| 88729 | return true; |  | 88681 | return true;
| 88730 | Ptr<cv::rgbd::RgbdICPOdometry> * dst_; |  | 88682 | Ptr<cv::rgbd::RgbdICPOdometry> * dst_;
| 88731 | if (pyopencv_rgbd_RgbdICPOdometry_getp(src, dst_)) |  | 88683 | if (pyopencv_rgbd_RgbdICPOdometry_getp(src, dst_))
| 88732 | { |  | 88684 | {
| 88733 | dst = *dst_; |  | 88685 | dst = *dst_;
| 88734 | return true; |  | 88686 | return true;
| 88735 | } |  | 88687 | }
| 88736 |  |  | 88688 |
| 88737 | failmsg("Expected Ptr<cv::rgbd::RgbdICPOdometry> for argument '%s'", info.name); |  | 88689 | failmsg("Expected Ptr<cv::rgbd::RgbdICPOdometry> for argument '%s'", info.name);
| 88738 | return false; |  | 88690 | return false;
| 88739 | } |  | 88691 | }
| 88740 | }; |  | 88692 | };
| 88741 |  |  | 88693 |
| 88742 | //================================================================================ |  | 88694 | //================================================================================
| 88743 | // rgbd_RgbdNormals (Generic) |  | 88695 | // rgbd_RgbdNormals (Generic)
| 88744 | //================================================================================ |  | 88696 | //================================================================================
| 88745 |  |  | 88697 |
| 88746 | // GetSet (rgbd_RgbdNormals) |  | 88698 | // GetSet (rgbd_RgbdNormals)
| 88747 |  |  | 88699 |
| 88748 |  |  | 88700 |
| 88749 |  |  | 88701 |
| 88750 | // Methods (rgbd_RgbdNormals) |  | 88702 | // Methods (rgbd_RgbdNormals)
| 88751 |  |  | 88703 |
| 88752 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88704 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 88753 | { |  | 88705 | {
| 88754 | using namespace cv::rgbd; |  | 88706 | using namespace cv::rgbd;
| 88755 |  |  | 88707 |
| 88756 |  |  | 88708 |
| 88757 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88709 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 88758 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88710 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 88759 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88711 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 88760 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88712 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 88761 | pyPrepareArgumentConversionErrorsStorage(2); |  | 88713 | pyPrepareArgumentConversionErrorsStorage(2);
| 88762 |  |  | 88714 |
| 88763 | { |  | 88715 | {
| 88764 | PyObject* pyobj_points = NULL; |  | 88716 | PyObject* pyobj_points = NULL;
| 88765 | Mat points; |  | 88717 | Mat points;
| 88766 | PyObject* pyobj_normals = NULL; |  | 88718 | PyObject* pyobj_normals = NULL;
| 88767 | Mat normals; |  | 88719 | Mat normals;
| 88768 |  |  | 88720 |
| 88769 | const char* keywords[] = { "points", "normals", NULL }; |  | 88721 | const char* keywords[] = { "points", "normals", NULL };
| 88770 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_RgbdNormals.apply", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 88722 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_RgbdNormals.apply", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 88771 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 88723 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 88772 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 88724 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 88773 | { |  | 88725 | {
| 88774 | ERRWRAP2(_self_->operator ()(points, normals)); |  | 88726 | ERRWRAP2(_self_->operator ()(points, normals));
| 88775 | return pyopencv_from(normals); |  | 88727 | return pyopencv_from(normals);
| 88776 | } |  | 88728 | }
| 88777 |  |  | 88729 |
| 88778 |  |  | 88730 |
| 88779 | pyPopulateArgumentConversionErrors(); |  | 88731 | pyPopulateArgumentConversionErrors();
| 88780 | } |  | 88732 | }
| 88781 |  |  | 88733 |
| 88782 |  |  | 88734 |
| 88783 | { |  | 88735 | {
| 88784 | PyObject* pyobj_points = NULL; |  | 88736 | PyObject* pyobj_points = NULL;
| 88785 | UMat points; |  | 88737 | UMat points;
| 88786 | PyObject* pyobj_normals = NULL; |  | 88738 | PyObject* pyobj_normals = NULL;
| 88787 | UMat normals; |  | 88739 | UMat normals;
| 88788 |  |  | 88740 |
| 88789 | const char* keywords[] = { "points", "normals", NULL }; |  | 88741 | const char* keywords[] = { "points", "normals", NULL };
| 88790 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_RgbdNormals.apply", (char**)keywords, &pyobj_points, &pyobj_normals) && |  | 88742 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:rgbd_RgbdNormals.apply", (char**)keywords, &pyobj_points, &pyobj_normals) &&
| 88791 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) && |  | 88743 | pyopencv_to_safe(pyobj_points, points, ArgInfo("points", 0)) &&
| 88792 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) ) |  | 88744 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 1)) )
| 88793 | { |  | 88745 | {
| 88794 | ERRWRAP2(_self_->operator ()(points, normals)); |  | 88746 | ERRWRAP2(_self_->operator ()(points, normals));
| 88795 | return pyopencv_from(normals); |  | 88747 | return pyopencv_from(normals);
| 88796 | } |  | 88748 | }
| 88797 |  |  | 88749 |
| 88798 |  |  | 88750 |
| 88799 | pyPopulateArgumentConversionErrors(); |  | 88751 | pyPopulateArgumentConversionErrors();
| 88800 | } |  | 88752 | }
| 88801 | pyRaiseCVOverloadException("apply"); |  | 88753 | pyRaiseCVOverloadException("apply");
| 88802 |  |  | 88754 |
| 88803 | return NULL; |  | 88755 | return NULL;
| 88804 | } |  | 88756 | }
| 88805 |  |  | 88757 |
| 88806 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88758 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 88807 | { |  | 88759 | {
| 88808 | using namespace cv::rgbd; |  | 88760 | using namespace cv::rgbd;
| 88809 |  |  | 88761 |
| 88810 | pyPrepareArgumentConversionErrorsStorage(2); |  | 88762 | pyPrepareArgumentConversionErrorsStorage(2);
| 88811 |  |  | 88763 |
| 88812 | { |  | 88764 | {
| 88813 | PyObject* pyobj_rows = NULL; |  | 88765 | PyObject* pyobj_rows = NULL;
| 88814 | int rows=0; |  | 88766 | int rows=0;
| 88815 | PyObject* pyobj_cols = NULL; |  | 88767 | PyObject* pyobj_cols = NULL;
| 88816 | int cols=0; |  | 88768 | int cols=0;
| 88817 | PyObject* pyobj_depth = NULL; |  | 88769 | PyObject* pyobj_depth = NULL;
| 88818 | int depth=0; |  | 88770 | int depth=0;
| 88819 | PyObject* pyobj_K = NULL; |  | 88771 | PyObject* pyobj_K = NULL;
| 88820 | Mat K; |  | 88772 | Mat K;
| 88821 | PyObject* pyobj_window_size = NULL; |  | 88773 | PyObject* pyobj_window_size = NULL;
| 88822 | int window_size=5; |  | 88774 | int window_size=5;
| 88823 | PyObject* pyobj_method = NULL; |  | 88775 | PyObject* pyobj_method = NULL;
| 88824 | int method=RgbdNormals::RGBD_NORMALS_METHOD_FALS; |  | 88776 | int method=RgbdNormals::RGBD_NORMALS_METHOD_FALS;
| 88825 | Ptr<RgbdNormals> retval; |  | 88777 | Ptr<RgbdNormals> retval;
| 88826 |  |  | 88778 |
| 88827 | const char* keywords[] = { "rows", "cols", "depth", "K", "window_size", "method", NULL }; |  | 88779 | const char* keywords[] = { "rows", "cols", "depth", "K", "window_size", "method", NULL };
| 88828 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:rgbd_RgbdNormals.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_depth, &pyobj_K, &pyobj_window_size, &pyobj_method) && |  | 88780 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:rgbd_RgbdNormals.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_depth, &pyobj_K, &pyobj_window_size, &pyobj_method) &&
| 88829 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 88781 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 88830 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 88782 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 88831 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) && |  | 88783 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) &&
| 88832 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 88784 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 88833 | pyopencv_to_safe(pyobj_window_size, window_size, ArgInfo("window_size", 0)) && |  | 88785 | pyopencv_to_safe(pyobj_window_size, window_size, ArgInfo("window_size", 0)) &&
| 88834 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) ) |  | 88786 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) )
| 88835 | { |  | 88787 | {
| 88836 | ERRWRAP2(retval = cv::rgbd::RgbdNormals::create(rows, cols, depth, K, window_size, method)); |  | 88788 | ERRWRAP2(retval = cv::rgbd::RgbdNormals::create(rows, cols, depth, K, window_size, method));
| 88837 | return pyopencv_from(retval); |  | 88789 | return pyopencv_from(retval);
| 88838 | } |  | 88790 | }
| 88839 |  |  | 88791 |
| 88840 |  |  | 88792 |
| 88841 | pyPopulateArgumentConversionErrors(); |  | 88793 | pyPopulateArgumentConversionErrors();
| 88842 | } |  | 88794 | }
| 88843 |  |  | 88795 |
| 88844 |  |  | 88796 |
| 88845 | { |  | 88797 | {
| 88846 | PyObject* pyobj_rows = NULL; |  | 88798 | PyObject* pyobj_rows = NULL;
| 88847 | int rows=0; |  | 88799 | int rows=0;
| 88848 | PyObject* pyobj_cols = NULL; |  | 88800 | PyObject* pyobj_cols = NULL;
| 88849 | int cols=0; |  | 88801 | int cols=0;
| 88850 | PyObject* pyobj_depth = NULL; |  | 88802 | PyObject* pyobj_depth = NULL;
| 88851 | int depth=0; |  | 88803 | int depth=0;
| 88852 | PyObject* pyobj_K = NULL; |  | 88804 | PyObject* pyobj_K = NULL;
| 88853 | UMat K; |  | 88805 | UMat K;
| 88854 | PyObject* pyobj_window_size = NULL; |  | 88806 | PyObject* pyobj_window_size = NULL;
| 88855 | int window_size=5; |  | 88807 | int window_size=5;
| 88856 | PyObject* pyobj_method = NULL; |  | 88808 | PyObject* pyobj_method = NULL;
| 88857 | int method=RgbdNormals::RGBD_NORMALS_METHOD_FALS; |  | 88809 | int method=RgbdNormals::RGBD_NORMALS_METHOD_FALS;
| 88858 | Ptr<RgbdNormals> retval; |  | 88810 | Ptr<RgbdNormals> retval;
| 88859 |  |  | 88811 |
| 88860 | const char* keywords[] = { "rows", "cols", "depth", "K", "window_size", "method", NULL }; |  | 88812 | const char* keywords[] = { "rows", "cols", "depth", "K", "window_size", "method", NULL };
| 88861 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:rgbd_RgbdNormals.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_depth, &pyobj_K, &pyobj_window_size, &pyobj_method) && |  | 88813 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OO:rgbd_RgbdNormals.create", (char**)keywords, &pyobj_rows, &pyobj_cols, &pyobj_depth, &pyobj_K, &pyobj_window_size, &pyobj_method) &&
| 88862 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) && |  | 88814 | pyopencv_to_safe(pyobj_rows, rows, ArgInfo("rows", 0)) &&
| 88863 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) && |  | 88815 | pyopencv_to_safe(pyobj_cols, cols, ArgInfo("cols", 0)) &&
| 88864 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) && |  | 88816 | pyopencv_to_safe(pyobj_depth, depth, ArgInfo("depth", 0)) &&
| 88865 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) && |  | 88817 | pyopencv_to_safe(pyobj_K, K, ArgInfo("K", 0)) &&
| 88866 | pyopencv_to_safe(pyobj_window_size, window_size, ArgInfo("window_size", 0)) && |  | 88818 | pyopencv_to_safe(pyobj_window_size, window_size, ArgInfo("window_size", 0)) &&
| 88867 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) ) |  | 88819 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) )
| 88868 | { |  | 88820 | {
| 88869 | ERRWRAP2(retval = cv::rgbd::RgbdNormals::create(rows, cols, depth, K, window_size, method)); |  | 88821 | ERRWRAP2(retval = cv::rgbd::RgbdNormals::create(rows, cols, depth, K, window_size, method));
| 88870 | return pyopencv_from(retval); |  | 88822 | return pyopencv_from(retval);
| 88871 | } |  | 88823 | }
| 88872 |  |  | 88824 |
| 88873 |  |  | 88825 |
| 88874 | pyPopulateArgumentConversionErrors(); |  | 88826 | pyPopulateArgumentConversionErrors();
| 88875 | } |  | 88827 | }
| 88876 | pyRaiseCVOverloadException("create"); |  | 88828 | pyRaiseCVOverloadException("create");
| 88877 |  |  | 88829 |
| 88878 | return NULL; |  | 88830 | return NULL;
| 88879 | } |  | 88831 | }
| 88880 |  |  | 88832 |
| 88881 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getCols(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88833 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getCols(PyObject* self, PyObject* py_args, PyObject* kw)
| 88882 | { |  | 88834 | {
| 88883 | using namespace cv::rgbd; |  | 88835 | using namespace cv::rgbd;
| 88884 |  |  | 88836 |
| 88885 |  |  | 88837 |
| 88886 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88838 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 88887 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88839 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 88888 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88840 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 88889 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88841 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 88890 | int retval; |  | 88842 | int retval;
| 88891 |  |  | 88843 |
| 88892 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88844 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88893 | { |  | 88845 | {
| 88894 | ERRWRAP2(retval = _self_->getCols()); |  | 88846 | ERRWRAP2(retval = _self_->getCols());
| 88895 | return pyopencv_from(retval); |  | 88847 | return pyopencv_from(retval);
| 88896 | } |  | 88848 | }
| 88897 |  |  | 88849 |
| 88898 | return NULL; |  | 88850 | return NULL;
| 88899 | } |  | 88851 | }
| 88900 |  |  | 88852 |
| 88901 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88853 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 88902 | { |  | 88854 | {
| 88903 | using namespace cv::rgbd; |  | 88855 | using namespace cv::rgbd;
| 88904 |  |  | 88856 |
| 88905 |  |  | 88857 |
| 88906 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88858 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 88907 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88859 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 88908 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88860 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 88909 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88861 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 88910 | int retval; |  | 88862 | int retval;
| 88911 |  |  | 88863 |
| 88912 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88864 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88913 | { |  | 88865 | {
| 88914 | ERRWRAP2(retval = _self_->getDepth()); |  | 88866 | ERRWRAP2(retval = _self_->getDepth());
| 88915 | return pyopencv_from(retval); |  | 88867 | return pyopencv_from(retval);
| 88916 | } |  | 88868 | }
| 88917 |  |  | 88869 |
| 88918 | return NULL; |  | 88870 | return NULL;
| 88919 | } |  | 88871 | }
| 88920 |  |  | 88872 |
| 88921 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88873 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getK(PyObject* self, PyObject* py_args, PyObject* kw)
| 88922 | { |  | 88874 | {
| 88923 | using namespace cv::rgbd; |  | 88875 | using namespace cv::rgbd;
| 88924 |  |  | 88876 |
| 88925 |  |  | 88877 |
| 88926 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88878 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 88927 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88879 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 88928 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88880 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 88929 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88881 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 88930 | cv::Mat retval; |  | 88882 | cv::Mat retval;
| 88931 |  |  | 88883 |
| 88932 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88884 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88933 | { |  | 88885 | {
| 88934 | ERRWRAP2(retval = _self_->getK()); |  | 88886 | ERRWRAP2(retval = _self_->getK());
| 88935 | return pyopencv_from(retval); |  | 88887 | return pyopencv_from(retval);
| 88936 | } |  | 88888 | }
| 88937 |  |  | 88889 |
| 88938 | return NULL; |  | 88890 | return NULL;
| 88939 | } |  | 88891 | }
| 88940 |  |  | 88892 |
| 88941 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88893 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 88942 | { |  | 88894 | {
| 88943 | using namespace cv::rgbd; |  | 88895 | using namespace cv::rgbd;
| 88944 |  |  | 88896 |
| 88945 |  |  | 88897 |
| 88946 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88898 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 88947 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88899 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 88948 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88900 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 88949 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88901 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 88950 | int retval; |  | 88902 | int retval;
| 88951 |  |  | 88903 |
| 88952 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88904 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88953 | { |  | 88905 | {
| 88954 | ERRWRAP2(retval = _self_->getMethod()); |  | 88906 | ERRWRAP2(retval = _self_->getMethod());
| 88955 | return pyopencv_from(retval); |  | 88907 | return pyopencv_from(retval);
| 88956 | } |  | 88908 | }
| 88957 |  |  | 88909 |
| 88958 | return NULL; |  | 88910 | return NULL;
| 88959 | } |  | 88911 | }
| 88960 |  |  | 88912 |
| 88961 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getRows(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88913 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getRows(PyObject* self, PyObject* py_args, PyObject* kw)
| 88962 | { |  | 88914 | {
| 88963 | using namespace cv::rgbd; |  | 88915 | using namespace cv::rgbd;
| 88964 |  |  | 88916 |
| 88965 |  |  | 88917 |
| 88966 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88918 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 88967 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88919 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 88968 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88920 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 88969 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88921 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 88970 | int retval; |  | 88922 | int retval;
| 88971 |  |  | 88923 |
| 88972 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88924 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88973 | { |  | 88925 | {
| 88974 | ERRWRAP2(retval = _self_->getRows()); |  | 88926 | ERRWRAP2(retval = _self_->getRows());
| 88975 | return pyopencv_from(retval); |  | 88927 | return pyopencv_from(retval);
| 88976 | } |  | 88928 | }
| 88977 |  |  | 88929 |
| 88978 | return NULL; |  | 88930 | return NULL;
| 88979 | } |  | 88931 | }
| 88980 |  |  | 88932 |
| 88981 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getWindowSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88933 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_getWindowSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 88982 | { |  | 88934 | {
| 88983 | using namespace cv::rgbd; |  | 88935 | using namespace cv::rgbd;
| 88984 |  |  | 88936 |
| 88985 |  |  | 88937 |
| 88986 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88938 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 88987 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88939 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 88988 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88940 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 88989 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88941 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 88990 | int retval; |  | 88942 | int retval;
| 88991 |  |  | 88943 |
| 88992 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88944 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 88993 | { |  | 88945 | {
| 88994 | ERRWRAP2(retval = _self_->getWindowSize()); |  | 88946 | ERRWRAP2(retval = _self_->getWindowSize());
| 88995 | return pyopencv_from(retval); |  | 88947 | return pyopencv_from(retval);
| 88996 | } |  | 88948 | }
| 88997 |  |  | 88949 |
| 88998 | return NULL; |  | 88950 | return NULL;
| 88999 | } |  | 88951 | }
| 89000 |  |  | 88952 |
| 89001 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_initialize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88953 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_initialize(PyObject* self, PyObject* py_args, PyObject* kw)
| 89002 | { |  | 88954 | {
| 89003 | using namespace cv::rgbd; |  | 88955 | using namespace cv::rgbd;
| 89004 |  |  | 88956 |
| 89005 |  |  | 88957 |
| 89006 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88958 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 89007 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88959 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 89008 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88960 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 89009 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88961 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 89010 |  |  | 88962 |
| 89011 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 88963 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89012 | { |  | 88964 | {
| 89013 | ERRWRAP2(_self_->initialize()); |  | 88965 | ERRWRAP2(_self_->initialize());
| 89014 | Py_RETURN_NONE; |  | 88966 | Py_RETURN_NONE;
| 89015 | } |  | 88967 | }
| 89016 |  |  | 88968 |
| 89017 | return NULL; |  | 88969 | return NULL;
| 89018 | } |  | 88970 | }
| 89019 |  |  | 88971 |
| 89020 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setCols(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88972 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setCols(PyObject* self, PyObject* py_args, PyObject* kw)
| 89021 | { |  | 88973 | {
| 89022 | using namespace cv::rgbd; |  | 88974 | using namespace cv::rgbd;
| 89023 |  |  | 88975 |
| 89024 |  |  | 88976 |
| 89025 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 88977 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 89026 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 88978 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 89027 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 88979 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 89028 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 88980 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 89029 | PyObject* pyobj_val = NULL; |  | 88981 | PyObject* pyobj_val = NULL;
| 89030 | int val=0; |  | 88982 | int val=0;
| 89031 |  |  | 88983 |
| 89032 | const char* keywords[] = { "val", NULL }; |  | 88984 | const char* keywords[] = { "val", NULL };
| 89033 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setCols", (char**)keywords, &pyobj_val) && |  | 88985 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setCols", (char**)keywords, &pyobj_val) &&
| 89034 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 88986 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89035 | { |  | 88987 | {
| 89036 | ERRWRAP2(_self_->setCols(val)); |  | 88988 | ERRWRAP2(_self_->setCols(val));
| 89037 | Py_RETURN_NONE; |  | 88989 | Py_RETURN_NONE;
| 89038 | } |  | 88990 | }
| 89039 |  |  | 88991 |
| 89040 | return NULL; |  | 88992 | return NULL;
| 89041 | } |  | 88993 | }
| 89042 |  |  | 88994 |
| 89043 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 88995 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 89044 | { |  | 88996 | {
| 89045 | using namespace cv::rgbd; |  | 88997 | using namespace cv::rgbd;
| 89046 |  |  | 88998 |
| 89047 |  |  | 88999 |
| 89048 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 89000 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 89049 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 89001 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 89050 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 89002 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 89051 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 89003 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 89052 | PyObject* pyobj_val = NULL; |  | 89004 | PyObject* pyobj_val = NULL;
| 89053 | int val=0; |  | 89005 | int val=0;
| 89054 |  |  | 89006 |
| 89055 | const char* keywords[] = { "val", NULL }; |  | 89007 | const char* keywords[] = { "val", NULL };
| 89056 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setDepth", (char**)keywords, &pyobj_val) && |  | 89008 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setDepth", (char**)keywords, &pyobj_val) &&
| 89057 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89009 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89058 | { |  | 89010 | {
| 89059 | ERRWRAP2(_self_->setDepth(val)); |  | 89011 | ERRWRAP2(_self_->setDepth(val));
| 89060 | Py_RETURN_NONE; |  | 89012 | Py_RETURN_NONE;
| 89061 | } |  | 89013 | }
| 89062 |  |  | 89014 |
| 89063 | return NULL; |  | 89015 | return NULL;
| 89064 | } |  | 89016 | }
| 89065 |  |  | 89017 |
| 89066 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setK(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89018 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setK(PyObject* self, PyObject* py_args, PyObject* kw)
| 89067 | { |  | 89019 | {
| 89068 | using namespace cv::rgbd; |  | 89020 | using namespace cv::rgbd;
| 89069 |  |  | 89021 |
| 89070 |  |  | 89022 |
| 89071 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 89023 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 89072 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 89024 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 89073 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 89025 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 89074 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 89026 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 89075 | PyObject* pyobj_val = NULL; |  | 89027 | PyObject* pyobj_val = NULL;
| 89076 | Mat val; |  | 89028 | Mat val;
| 89077 |  |  | 89029 |
| 89078 | const char* keywords[] = { "val", NULL }; |  | 89030 | const char* keywords[] = { "val", NULL };
| 89079 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setK", (char**)keywords, &pyobj_val) && |  | 89031 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setK", (char**)keywords, &pyobj_val) &&
| 89080 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89032 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89081 | { |  | 89033 | {
| 89082 | ERRWRAP2(_self_->setK(val)); |  | 89034 | ERRWRAP2(_self_->setK(val));
| 89083 | Py_RETURN_NONE; |  | 89035 | Py_RETURN_NONE;
| 89084 | } |  | 89036 | }
| 89085 |  |  | 89037 |
| 89086 | return NULL; |  | 89038 | return NULL;
| 89087 | } |  | 89039 | }
| 89088 |  |  | 89040 |
| 89089 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89041 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 89090 | { |  | 89042 | {
| 89091 | using namespace cv::rgbd; |  | 89043 | using namespace cv::rgbd;
| 89092 |  |  | 89044 |
| 89093 |  |  | 89045 |
| 89094 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 89046 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 89095 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 89047 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 89096 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 89048 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 89097 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 89049 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 89098 | PyObject* pyobj_val = NULL; |  | 89050 | PyObject* pyobj_val = NULL;
| 89099 | int val=0; |  | 89051 | int val=0;
| 89100 |  |  | 89052 |
| 89101 | const char* keywords[] = { "val", NULL }; |  | 89053 | const char* keywords[] = { "val", NULL };
| 89102 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setMethod", (char**)keywords, &pyobj_val) && |  | 89054 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setMethod", (char**)keywords, &pyobj_val) &&
| 89103 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89055 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89104 | { |  | 89056 | {
| 89105 | ERRWRAP2(_self_->setMethod(val)); |  | 89057 | ERRWRAP2(_self_->setMethod(val));
| 89106 | Py_RETURN_NONE; |  | 89058 | Py_RETURN_NONE;
| 89107 | } |  | 89059 | }
| 89108 |  |  | 89060 |
| 89109 | return NULL; |  | 89061 | return NULL;
| 89110 | } |  | 89062 | }
| 89111 |  |  | 89063 |
| 89112 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setRows(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89064 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setRows(PyObject* self, PyObject* py_args, PyObject* kw)
| 89113 | { |  | 89065 | {
| 89114 | using namespace cv::rgbd; |  | 89066 | using namespace cv::rgbd;
| 89115 |  |  | 89067 |
| 89116 |  |  | 89068 |
| 89117 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 89069 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 89118 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 89070 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 89119 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 89071 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 89120 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 89072 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 89121 | PyObject* pyobj_val = NULL; |  | 89073 | PyObject* pyobj_val = NULL;
| 89122 | int val=0; |  | 89074 | int val=0;
| 89123 |  |  | 89075 |
| 89124 | const char* keywords[] = { "val", NULL }; |  | 89076 | const char* keywords[] = { "val", NULL };
| 89125 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setRows", (char**)keywords, &pyobj_val) && |  | 89077 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setRows", (char**)keywords, &pyobj_val) &&
| 89126 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89078 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89127 | { |  | 89079 | {
| 89128 | ERRWRAP2(_self_->setRows(val)); |  | 89080 | ERRWRAP2(_self_->setRows(val));
| 89129 | Py_RETURN_NONE; |  | 89081 | Py_RETURN_NONE;
| 89130 | } |  | 89082 | }
| 89131 |  |  | 89083 |
| 89132 | return NULL; |  | 89084 | return NULL;
| 89133 | } |  | 89085 | }
| 89134 |  |  | 89086 |
| 89135 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setWindowSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89087 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdNormals_setWindowSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 89136 | { |  | 89088 | {
| 89137 | using namespace cv::rgbd; |  | 89089 | using namespace cv::rgbd;
| 89138 |  |  | 89090 |
| 89139 |  |  | 89091 |
| 89140 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0; |  | 89092 | Ptr<cv::rgbd::RgbdNormals> * self1 = 0;
| 89141 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1)) |  | 89093 | if (!pyopencv_rgbd_RgbdNormals_getp(self, self1))
| 89142 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)"); |  | 89094 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdNormals' or its derivative)");
| 89143 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1); |  | 89095 | Ptr<cv::rgbd::RgbdNormals> _self_ = *(self1);
| 89144 | PyObject* pyobj_val = NULL; |  | 89096 | PyObject* pyobj_val = NULL;
| 89145 | int val=0; |  | 89097 | int val=0;
| 89146 |  |  | 89098 |
| 89147 | const char* keywords[] = { "val", NULL }; |  | 89099 | const char* keywords[] = { "val", NULL };
| 89148 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setWindowSize", (char**)keywords, &pyobj_val) && |  | 89100 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdNormals.setWindowSize", (char**)keywords, &pyobj_val) &&
| 89149 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89101 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89150 | { |  | 89102 | {
| 89151 | ERRWRAP2(_self_->setWindowSize(val)); |  | 89103 | ERRWRAP2(_self_->setWindowSize(val));
| 89152 | Py_RETURN_NONE; |  | 89104 | Py_RETURN_NONE;
| 89153 | } |  | 89105 | }
| 89154 |  |  | 89106 |
| 89155 | return NULL; |  | 89107 | return NULL;
| 89156 | } |  | 89108 | }
| 89157 |  |  | 89109 |
| 89158 |  |  | 89110 |
| 89159 |  |  | 89111 |
| 89160 | // Tables (rgbd_RgbdNormals) |  | 89112 | // Tables (rgbd_RgbdNormals)
| 89161 |  |  | 89113 |
| 89162 | static PyGetSetDef pyopencv_rgbd_RgbdNormals_getseters[] = |  | 89114 | static PyGetSetDef pyopencv_rgbd_RgbdNormals_getseters[] =
| 89163 | { |  | 89115 | {
| 89164 | {NULL} /* Sentinel */ |  | 89116 | {NULL} /* Sentinel */
| 89165 | }; |  | 89117 | };
| 89166 |  |  | 89118 |
| 89167 | static PyMethodDef pyopencv_rgbd_RgbdNormals_methods[] = |  | 89119 | static PyMethodDef pyopencv_rgbd_RgbdNormals_methods[] =
| 89168 | { |  | 89120 | {
| 89169 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_apply, 0), "apply(points[, normals]) -> normals\n. Given a set of 3d points in a depth image, compute the normals at each point.\n. * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S\n. * @param normals a rows x cols x 3 matrix"}, |  | 89121 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_apply, 0), "apply(points[, normals]) -> normals\n. Given a set of 3d points in a depth image, compute the normals at each point.\n. * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S\n. * @param normals a rows x cols x 3 matrix"},
| 89170 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_create_static, METH_STATIC), "create(rows, cols, depth, K[, window_size[, method]]) -> retval\n. Constructor\n. * @param rows the number of rows of the depth image normals will be computed on\n. * @param cols the number of cols of the depth image normals will be computed on\n. * @param depth the depth of the normals (only CV_32F or CV_64F)\n. * @param K the calibration matrix to use\n. * @param window_size the window size to compute the normals: can only be 1,3,5 or 7\n. * @param method one of the methods to use: RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_FALS"}, |  | 89122 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_create_static, METH_STATIC), "create(rows, cols, depth, K[, window_size[, method]]) -> retval\n. Constructor\n. * @param rows the number of rows of the depth image normals will be computed on\n. * @param cols the number of cols of the depth image normals will be computed on\n. * @param depth the depth of the normals (only CV_32F or CV_64F)\n. * @param K the calibration matrix to use\n. * @param window_size the window size to compute the normals: can only be 1,3,5 or 7\n. * @param method one of the methods to use: RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_FALS"},
| 89171 | {"getCols", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getCols, 0), "getCols() -> retval\n."}, |  | 89123 | {"getCols", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getCols, 0), "getCols() -> retval\n."},
| 89172 | {"getDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getDepth, 0), "getDepth() -> retval\n."}, |  | 89124 | {"getDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getDepth, 0), "getDepth() -> retval\n."},
| 89173 | {"getK", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getK, 0), "getK() -> retval\n."}, |  | 89125 | {"getK", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getK, 0), "getK() -> retval\n."},
| 89174 | {"getMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getMethod, 0), "getMethod() -> retval\n."}, |  | 89126 | {"getMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getMethod, 0), "getMethod() -> retval\n."},
| 89175 | {"getRows", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getRows, 0), "getRows() -> retval\n."}, |  | 89127 | {"getRows", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getRows, 0), "getRows() -> retval\n."},
| 89176 | {"getWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getWindowSize, 0), "getWindowSize() -> retval\n."}, |  | 89128 | {"getWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_getWindowSize, 0), "getWindowSize() -> retval\n."},
| 89177 | {"initialize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_initialize, 0), "initialize() -> None\n. Initializes some data that is cached for later computation\n. * If that function is not called, it will be called the first time normals are computed"}, |  | 89129 | {"initialize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_initialize, 0), "initialize() -> None\n. Initializes some data that is cached for later computation\n. * If that function is not called, it will be called the first time normals are computed"},
| 89178 | {"setCols", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setCols, 0), "setCols(val) -> None\n."}, |  | 89130 | {"setCols", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setCols, 0), "setCols(val) -> None\n."},
| 89179 | {"setDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setDepth, 0), "setDepth(val) -> None\n."}, |  | 89131 | {"setDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setDepth, 0), "setDepth(val) -> None\n."},
| 89180 | {"setK", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setK, 0), "setK(val) -> None\n."}, |  | 89132 | {"setK", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setK, 0), "setK(val) -> None\n."},
| 89181 | {"setMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setMethod, 0), "setMethod(val) -> None\n."}, |  | 89133 | {"setMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setMethod, 0), "setMethod(val) -> None\n."},
| 89182 | {"setRows", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setRows, 0), "setRows(val) -> None\n."}, |  | 89134 | {"setRows", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setRows, 0), "setRows(val) -> None\n."},
| 89183 | {"setWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setWindowSize, 0), "setWindowSize(val) -> None\n."}, |  | 89135 | {"setWindowSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdNormals_setWindowSize, 0), "setWindowSize(val) -> None\n."},
| 89184 |  |  | 89136 |
| 89185 | {NULL, NULL} |  | 89137 | {NULL, NULL}
| 89186 | }; |  | 89138 | };
| 89187 |  |  | 89139 |
| 89188 | // Converter (rgbd_RgbdNormals) |  | 89140 | // Converter (rgbd_RgbdNormals)
| 89189 |  |  | 89141 |
| 89190 | template<> |  | 89142 | template<>
| 89191 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdNormals> > |  | 89143 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdNormals> >
| 89192 | { |  | 89144 | {
| 89193 | static PyObject* from(const Ptr<cv::rgbd::RgbdNormals>& r) |  | 89145 | static PyObject* from(const Ptr<cv::rgbd::RgbdNormals>& r)
| 89194 | { |  | 89146 | {
| 89195 | return pyopencv_rgbd_RgbdNormals_Instance(r); |  | 89147 | return pyopencv_rgbd_RgbdNormals_Instance(r);
| 89196 | } |  | 89148 | }
| 89197 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdNormals>& dst, const ArgInfo& info) |  | 89149 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdNormals>& dst, const ArgInfo& info)
| 89198 | { |  | 89150 | {
| 89199 | if(!src || src == Py_None) |  | 89151 | if(!src || src == Py_None)
| 89200 | return true; |  | 89152 | return true;
| 89201 | Ptr<cv::rgbd::RgbdNormals> * dst_; |  | 89153 | Ptr<cv::rgbd::RgbdNormals> * dst_;
| 89202 | if (pyopencv_rgbd_RgbdNormals_getp(src, dst_)) |  | 89154 | if (pyopencv_rgbd_RgbdNormals_getp(src, dst_))
| 89203 | { |  | 89155 | {
| 89204 | dst = *dst_; |  | 89156 | dst = *dst_;
| 89205 | return true; |  | 89157 | return true;
| 89206 | } |  | 89158 | }
| 89207 |  |  | 89159 |
| 89208 | failmsg("Expected Ptr<cv::rgbd::RgbdNormals> for argument '%s'", info.name); |  | 89160 | failmsg("Expected Ptr<cv::rgbd::RgbdNormals> for argument '%s'", info.name);
| 89209 | return false; |  | 89161 | return false;
| 89210 | } |  | 89162 | }
| 89211 | }; |  | 89163 | };
| 89212 |  |  | 89164 |
| 89213 | //================================================================================ |  | 89165 | //================================================================================
| 89214 | // rgbd_RgbdOdometry (Generic) |  | 89166 | // rgbd_RgbdOdometry (Generic)
| 89215 | //================================================================================ |  | 89167 | //================================================================================
| 89216 |  |  | 89168 |
| 89217 | // GetSet (rgbd_RgbdOdometry) |  | 89169 | // GetSet (rgbd_RgbdOdometry)
| 89218 |  |  | 89170 |
| 89219 |  |  | 89171 |
| 89220 |  |  | 89172 |
| 89221 | // Methods (rgbd_RgbdOdometry) |  | 89173 | // Methods (rgbd_RgbdOdometry)
| 89222 |  |  | 89174 |
| 89223 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89175 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 89224 | { |  | 89176 | {
| 89225 | using namespace cv::rgbd; |  | 89177 | using namespace cv::rgbd;
| 89226 |  |  | 89178 |
| 89227 | PyObject* pyobj_cameraMatrix = NULL; |  | 89179 | PyObject* pyobj_cameraMatrix = NULL;
| 89228 | Mat cameraMatrix; |  | 89180 | Mat cameraMatrix;
| 89229 | PyObject* pyobj_minDepth = NULL; |  | 89181 | PyObject* pyobj_minDepth = NULL;
| 89230 | float minDepth=Odometry::DEFAULT_MIN_DEPTH(); |  | 89182 | float minDepth=Odometry::DEFAULT_MIN_DEPTH();
| 89231 | PyObject* pyobj_maxDepth = NULL; |  | 89183 | PyObject* pyobj_maxDepth = NULL;
| 89232 | float maxDepth=Odometry::DEFAULT_MAX_DEPTH(); |  | 89184 | float maxDepth=Odometry::DEFAULT_MAX_DEPTH();
| 89233 | PyObject* pyobj_maxDepthDiff = NULL; |  | 89185 | PyObject* pyobj_maxDepthDiff = NULL;
| 89234 | float maxDepthDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF(); |  | 89186 | float maxDepthDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF();
| 89235 | PyObject* pyobj_iterCounts = NULL; |  | 89187 | PyObject* pyobj_iterCounts = NULL;
| 89236 | vector_int iterCounts=std::vector<int>(); |  | 89188 | vector_int iterCounts=std::vector<int>();
| 89237 | PyObject* pyobj_minGradientMagnitudes = NULL; |  | 89189 | PyObject* pyobj_minGradientMagnitudes = NULL;
| 89238 | vector_float minGradientMagnitudes=std::vector<float>(); |  | 89190 | vector_float minGradientMagnitudes=std::vector<float>();
| 89239 | PyObject* pyobj_maxPointsPart = NULL; |  | 89191 | PyObject* pyobj_maxPointsPart = NULL;
| 89240 | float maxPointsPart=Odometry::DEFAULT_MAX_POINTS_PART(); |  | 89192 | float maxPointsPart=Odometry::DEFAULT_MAX_POINTS_PART();
| 89241 | PyObject* pyobj_transformType = NULL; |  | 89193 | PyObject* pyobj_transformType = NULL;
| 89242 | int transformType=Odometry::RIGID_BODY_MOTION; |  | 89194 | int transformType=Odometry::RIGID_BODY_MOTION;
| 89243 | Ptr<RgbdOdometry> retval; |  | 89195 | Ptr<RgbdOdometry> retval;
| 89244 |  |  | 89196 |
| 89245 | const char* keywords[] = { "cameraMatrix", "minDepth", "maxDepth", "maxDepthDiff", "iterCounts", "minGradientMagnitudes", "maxPointsPart", "transformType", NULL }; |  | 89197 | const char* keywords[] = { "cameraMatrix", "minDepth", "maxDepth", "maxDepthDiff", "iterCounts", "minGradientMagnitudes", "maxPointsPart", "transformType", NULL };
| 89246 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:rgbd_RgbdOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_minDepth, &pyobj_maxDepth, &pyobj_maxDepthDiff, &pyobj_iterCounts, &pyobj_minGradientMagnitudes, &pyobj_maxPointsPart, &pyobj_transformType) && |  | 89198 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|OOOOOOOO:rgbd_RgbdOdometry.create", (char**)keywords, &pyobj_cameraMatrix, &pyobj_minDepth, &pyobj_maxDepth, &pyobj_maxDepthDiff, &pyobj_iterCounts, &pyobj_minGradientMagnitudes, &pyobj_maxPointsPart, &pyobj_transformType) &&
| 89247 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) && |  | 89199 | pyopencv_to_safe(pyobj_cameraMatrix, cameraMatrix, ArgInfo("cameraMatrix", 0)) &&
| 89248 | pyopencv_to_safe(pyobj_minDepth, minDepth, ArgInfo("minDepth", 0)) && |  | 89200 | pyopencv_to_safe(pyobj_minDepth, minDepth, ArgInfo("minDepth", 0)) &&
| 89249 | pyopencv_to_safe(pyobj_maxDepth, maxDepth, ArgInfo("maxDepth", 0)) && |  | 89201 | pyopencv_to_safe(pyobj_maxDepth, maxDepth, ArgInfo("maxDepth", 0)) &&
| 89250 | pyopencv_to_safe(pyobj_maxDepthDiff, maxDepthDiff, ArgInfo("maxDepthDiff", 0)) && |  | 89202 | pyopencv_to_safe(pyobj_maxDepthDiff, maxDepthDiff, ArgInfo("maxDepthDiff", 0)) &&
| 89251 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) && |  | 89203 | pyopencv_to_safe(pyobj_iterCounts, iterCounts, ArgInfo("iterCounts", 0)) &&
| 89252 | pyopencv_to_safe(pyobj_minGradientMagnitudes, minGradientMagnitudes, ArgInfo("minGradientMagnitudes", 0)) && |  | 89204 | pyopencv_to_safe(pyobj_minGradientMagnitudes, minGradientMagnitudes, ArgInfo("minGradientMagnitudes", 0)) &&
| 89253 | pyopencv_to_safe(pyobj_maxPointsPart, maxPointsPart, ArgInfo("maxPointsPart", 0)) && |  | 89205 | pyopencv_to_safe(pyobj_maxPointsPart, maxPointsPart, ArgInfo("maxPointsPart", 0)) &&
| 89254 | pyopencv_to_safe(pyobj_transformType, transformType, ArgInfo("transformType", 0)) ) |  | 89206 | pyopencv_to_safe(pyobj_transformType, transformType, ArgInfo("transformType", 0)) )
| 89255 | { |  | 89207 | {
| 89256 | ERRWRAP2(retval = cv::rgbd::RgbdOdometry::create(cameraMatrix, minDepth, maxDepth, maxDepthDiff, iterCounts, minGradientMagnitudes, maxPointsPart, transformType)); |  | 89208 | ERRWRAP2(retval = cv::rgbd::RgbdOdometry::create(cameraMatrix, minDepth, maxDepth, maxDepthDiff, iterCounts, minGradientMagnitudes, maxPointsPart, transformType));
| 89257 | return pyopencv_from(retval); |  | 89209 | return pyopencv_from(retval);
| 89258 | } |  | 89210 | }
| 89259 |  |  | 89211 |
| 89260 | return NULL; |  | 89212 | return NULL;
| 89261 | } |  | 89213 | }
| 89262 |  |  | 89214 |
| 89263 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89215 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 89264 | { |  | 89216 | {
| 89265 | using namespace cv::rgbd; |  | 89217 | using namespace cv::rgbd;
| 89266 |  |  | 89218 |
| 89267 |  |  | 89219 |
| 89268 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89220 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89269 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89221 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89270 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89222 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89271 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89223 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89272 | cv::Mat retval; |  | 89224 | cv::Mat retval;
| 89273 |  |  | 89225 |
| 89274 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89226 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89275 | { |  | 89227 | {
| 89276 | ERRWRAP2(retval = _self_->getCameraMatrix()); |  | 89228 | ERRWRAP2(retval = _self_->getCameraMatrix());
| 89277 | return pyopencv_from(retval); |  | 89229 | return pyopencv_from(retval);
| 89278 | } |  | 89230 | }
| 89279 |  |  | 89231 |
| 89280 | return NULL; |  | 89232 | return NULL;
| 89281 | } |  | 89233 | }
| 89282 |  |  | 89234 |
| 89283 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89235 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 89284 | { |  | 89236 | {
| 89285 | using namespace cv::rgbd; |  | 89237 | using namespace cv::rgbd;
| 89286 |  |  | 89238 |
| 89287 |  |  | 89239 |
| 89288 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89240 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89289 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89241 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89290 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89242 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89291 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89243 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89292 | cv::Mat retval; |  | 89244 | cv::Mat retval;
| 89293 |  |  | 89245 |
| 89294 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89246 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89295 | { |  | 89247 | {
| 89296 | ERRWRAP2(retval = _self_->getIterationCounts()); |  | 89248 | ERRWRAP2(retval = _self_->getIterationCounts());
| 89297 | return pyopencv_from(retval); |  | 89249 | return pyopencv_from(retval);
| 89298 | } |  | 89250 | }
| 89299 |  |  | 89251 |
| 89300 | return NULL; |  | 89252 | return NULL;
| 89301 | } |  | 89253 | }
| 89302 |  |  | 89254 |
| 89303 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89255 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 89304 | { |  | 89256 | {
| 89305 | using namespace cv::rgbd; |  | 89257 | using namespace cv::rgbd;
| 89306 |  |  | 89258 |
| 89307 |  |  | 89259 |
| 89308 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89260 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89309 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89261 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89310 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89262 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89311 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89263 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89312 | double retval; |  | 89264 | double retval;
| 89313 |  |  | 89265 |
| 89314 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89266 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89315 | { |  | 89267 | {
| 89316 | ERRWRAP2(retval = _self_->getMaxDepth()); |  | 89268 | ERRWRAP2(retval = _self_->getMaxDepth());
| 89317 | return pyopencv_from(retval); |  | 89269 | return pyopencv_from(retval);
| 89318 | } |  | 89270 | }
| 89319 |  |  | 89271 |
| 89320 | return NULL; |  | 89272 | return NULL;
| 89321 | } |  | 89273 | }
| 89322 |  |  | 89274 |
| 89323 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89275 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 89324 | { |  | 89276 | {
| 89325 | using namespace cv::rgbd; |  | 89277 | using namespace cv::rgbd;
| 89326 |  |  | 89278 |
| 89327 |  |  | 89279 |
| 89328 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89280 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89329 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89281 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89330 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89282 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89331 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89283 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89332 | double retval; |  | 89284 | double retval;
| 89333 |  |  | 89285 |
| 89334 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89286 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89335 | { |  | 89287 | {
| 89336 | ERRWRAP2(retval = _self_->getMaxDepthDiff()); |  | 89288 | ERRWRAP2(retval = _self_->getMaxDepthDiff());
| 89337 | return pyopencv_from(retval); |  | 89289 | return pyopencv_from(retval);
| 89338 | } |  | 89290 | }
| 89339 |  |  | 89291 |
| 89340 | return NULL; |  | 89292 | return NULL;
| 89341 | } |  | 89293 | }
| 89342 |  |  | 89294 |
| 89343 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89295 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw)
| 89344 | { |  | 89296 | {
| 89345 | using namespace cv::rgbd; |  | 89297 | using namespace cv::rgbd;
| 89346 |  |  | 89298 |
| 89347 |  |  | 89299 |
| 89348 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89300 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89349 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89301 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89350 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89302 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89351 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89303 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89352 | double retval; |  | 89304 | double retval;
| 89353 |  |  | 89305 |
| 89354 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89306 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89355 | { |  | 89307 | {
| 89356 | ERRWRAP2(retval = _self_->getMaxPointsPart()); |  | 89308 | ERRWRAP2(retval = _self_->getMaxPointsPart());
| 89357 | return pyopencv_from(retval); |  | 89309 | return pyopencv_from(retval);
| 89358 | } |  | 89310 | }
| 89359 |  |  | 89311 |
| 89360 | return NULL; |  | 89312 | return NULL;
| 89361 | } |  | 89313 | }
| 89362 |  |  | 89314 |
| 89363 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89315 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw)
| 89364 | { |  | 89316 | {
| 89365 | using namespace cv::rgbd; |  | 89317 | using namespace cv::rgbd;
| 89366 |  |  | 89318 |
| 89367 |  |  | 89319 |
| 89368 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89320 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89369 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89321 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89370 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89322 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89371 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89323 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89372 | double retval; |  | 89324 | double retval;
| 89373 |  |  | 89325 |
| 89374 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89326 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89375 | { |  | 89327 | {
| 89376 | ERRWRAP2(retval = _self_->getMaxRotation()); |  | 89328 | ERRWRAP2(retval = _self_->getMaxRotation());
| 89377 | return pyopencv_from(retval); |  | 89329 | return pyopencv_from(retval);
| 89378 | } |  | 89330 | }
| 89379 |  |  | 89331 |
| 89380 | return NULL; |  | 89332 | return NULL;
| 89381 | } |  | 89333 | }
| 89382 |  |  | 89334 |
| 89383 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89335 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw)
| 89384 | { |  | 89336 | {
| 89385 | using namespace cv::rgbd; |  | 89337 | using namespace cv::rgbd;
| 89386 |  |  | 89338 |
| 89387 |  |  | 89339 |
| 89388 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89340 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89389 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89341 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89390 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89342 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89391 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89343 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89392 | double retval; |  | 89344 | double retval;
| 89393 |  |  | 89345 |
| 89394 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89346 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89395 | { |  | 89347 | {
| 89396 | ERRWRAP2(retval = _self_->getMaxTranslation()); |  | 89348 | ERRWRAP2(retval = _self_->getMaxTranslation());
| 89397 | return pyopencv_from(retval); |  | 89349 | return pyopencv_from(retval);
| 89398 | } |  | 89350 | }
| 89399 |  |  | 89351 |
| 89400 | return NULL; |  | 89352 | return NULL;
| 89401 | } |  | 89353 | }
| 89402 |  |  | 89354 |
| 89403 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89355 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 89404 | { |  | 89356 | {
| 89405 | using namespace cv::rgbd; |  | 89357 | using namespace cv::rgbd;
| 89406 |  |  | 89358 |
| 89407 |  |  | 89359 |
| 89408 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89360 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89409 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89361 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89410 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89362 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89411 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89363 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89412 | double retval; |  | 89364 | double retval;
| 89413 |  |  | 89365 |
| 89414 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89366 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89415 | { |  | 89367 | {
| 89416 | ERRWRAP2(retval = _self_->getMinDepth()); |  | 89368 | ERRWRAP2(retval = _self_->getMinDepth());
| 89417 | return pyopencv_from(retval); |  | 89369 | return pyopencv_from(retval);
| 89418 | } |  | 89370 | }
| 89419 |  |  | 89371 |
| 89420 | return NULL; |  | 89372 | return NULL;
| 89421 | } |  | 89373 | }
| 89422 |  |  | 89374 |
| 89423 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89375 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw)
| 89424 | { |  | 89376 | {
| 89425 | using namespace cv::rgbd; |  | 89377 | using namespace cv::rgbd;
| 89426 |  |  | 89378 |
| 89427 |  |  | 89379 |
| 89428 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89380 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89429 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89381 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89430 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89382 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89431 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89383 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89432 | cv::Mat retval; |  | 89384 | cv::Mat retval;
| 89433 |  |  | 89385 |
| 89434 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89386 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89435 | { |  | 89387 | {
| 89436 | ERRWRAP2(retval = _self_->getMinGradientMagnitudes()); |  | 89388 | ERRWRAP2(retval = _self_->getMinGradientMagnitudes());
| 89437 | return pyopencv_from(retval); |  | 89389 | return pyopencv_from(retval);
| 89438 | } |  | 89390 | }
| 89439 |  |  | 89391 |
| 89440 | return NULL; |  | 89392 | return NULL;
| 89441 | } |  | 89393 | }
| 89442 |  |  | 89394 |
| 89443 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89395 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_getTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 89444 | { |  | 89396 | {
| 89445 | using namespace cv::rgbd; |  | 89397 | using namespace cv::rgbd;
| 89446 |  |  | 89398 |
| 89447 |  |  | 89399 |
| 89448 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89400 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89449 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89401 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89450 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89402 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89451 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89403 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89452 | int retval; |  | 89404 | int retval;
| 89453 |  |  | 89405 |
| 89454 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89406 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89455 | { |  | 89407 | {
| 89456 | ERRWRAP2(retval = _self_->getTransformType()); |  | 89408 | ERRWRAP2(retval = _self_->getTransformType());
| 89457 | return pyopencv_from(retval); |  | 89409 | return pyopencv_from(retval);
| 89458 | } |  | 89410 | }
| 89459 |  |  | 89411 |
| 89460 | return NULL; |  | 89412 | return NULL;
| 89461 | } |  | 89413 | }
| 89462 |  |  | 89414 |
| 89463 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89415 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_prepareFrameCache(PyObject* self, PyObject* py_args, PyObject* kw)
| 89464 | { |  | 89416 | {
| 89465 | using namespace cv::rgbd; |  | 89417 | using namespace cv::rgbd;
| 89466 |  |  | 89418 |
| 89467 |  |  | 89419 |
| 89468 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89420 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89469 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89421 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89470 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89422 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89471 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89423 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89472 | PyObject* pyobj_frame = NULL; |  | 89424 | PyObject* pyobj_frame = NULL;
| 89473 | Ptr<OdometryFrame> frame; |  | 89425 | Ptr<OdometryFrame> frame;
| 89474 | PyObject* pyobj_cacheType = NULL; |  | 89426 | PyObject* pyobj_cacheType = NULL;
| 89475 | int cacheType=0; |  | 89427 | int cacheType=0;
| 89476 | Size retval; |  | 89428 | Size retval;
| 89477 |  |  | 89429 |
| 89478 | const char* keywords[] = { "frame", "cacheType", NULL }; |  | 89430 | const char* keywords[] = { "frame", "cacheType", NULL };
| 89479 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_RgbdOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) && |  | 89431 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:rgbd_RgbdOdometry.prepareFrameCache", (char**)keywords, &pyobj_frame, &pyobj_cacheType) &&
| 89480 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) && |  | 89432 | pyopencv_to_safe(pyobj_frame, frame, ArgInfo("frame", 0)) &&
| 89481 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) ) |  | 89433 | pyopencv_to_safe(pyobj_cacheType, cacheType, ArgInfo("cacheType", 0)) )
| 89482 | { |  | 89434 | {
| 89483 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType)); |  | 89435 | ERRWRAP2(retval = _self_->prepareFrameCache(frame, cacheType));
| 89484 | return pyopencv_from(retval); |  | 89436 | return pyopencv_from(retval);
| 89485 | } |  | 89437 | }
| 89486 |  |  | 89438 |
| 89487 | return NULL; |  | 89439 | return NULL;
| 89488 | } |  | 89440 | }
| 89489 |  |  | 89441 |
| 89490 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89442 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setCameraMatrix(PyObject* self, PyObject* py_args, PyObject* kw)
| 89491 | { |  | 89443 | {
| 89492 | using namespace cv::rgbd; |  | 89444 | using namespace cv::rgbd;
| 89493 |  |  | 89445 |
| 89494 |  |  | 89446 |
| 89495 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89447 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89496 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89448 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89497 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89449 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89498 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89450 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89499 | PyObject* pyobj_val = NULL; |  | 89451 | PyObject* pyobj_val = NULL;
| 89500 | Mat val; |  | 89452 | Mat val;
| 89501 |  |  | 89453 |
| 89502 | const char* keywords[] = { "val", NULL }; |  | 89454 | const char* keywords[] = { "val", NULL };
| 89503 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) && |  | 89455 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setCameraMatrix", (char**)keywords, &pyobj_val) &&
| 89504 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89456 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89505 | { |  | 89457 | {
| 89506 | ERRWRAP2(_self_->setCameraMatrix(val)); |  | 89458 | ERRWRAP2(_self_->setCameraMatrix(val));
| 89507 | Py_RETURN_NONE; |  | 89459 | Py_RETURN_NONE;
| 89508 | } |  | 89460 | }
| 89509 |  |  | 89461 |
| 89510 | return NULL; |  | 89462 | return NULL;
| 89511 | } |  | 89463 | }
| 89512 |  |  | 89464 |
| 89513 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89465 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setIterationCounts(PyObject* self, PyObject* py_args, PyObject* kw)
| 89514 | { |  | 89466 | {
| 89515 | using namespace cv::rgbd; |  | 89467 | using namespace cv::rgbd;
| 89516 |  |  | 89468 |
| 89517 |  |  | 89469 |
| 89518 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89470 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89519 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89471 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89520 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89472 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89521 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89473 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89522 | PyObject* pyobj_val = NULL; |  | 89474 | PyObject* pyobj_val = NULL;
| 89523 | Mat val; |  | 89475 | Mat val;
| 89524 |  |  | 89476 |
| 89525 | const char* keywords[] = { "val", NULL }; |  | 89477 | const char* keywords[] = { "val", NULL };
| 89526 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setIterationCounts", (char**)keywords, &pyobj_val) && |  | 89478 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setIterationCounts", (char**)keywords, &pyobj_val) &&
| 89527 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89479 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89528 | { |  | 89480 | {
| 89529 | ERRWRAP2(_self_->setIterationCounts(val)); |  | 89481 | ERRWRAP2(_self_->setIterationCounts(val));
| 89530 | Py_RETURN_NONE; |  | 89482 | Py_RETURN_NONE;
| 89531 | } |  | 89483 | }
| 89532 |  |  | 89484 |
| 89533 | return NULL; |  | 89485 | return NULL;
| 89534 | } |  | 89486 | }
| 89535 |  |  | 89487 |
| 89536 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89488 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 89537 | { |  | 89489 | {
| 89538 | using namespace cv::rgbd; |  | 89490 | using namespace cv::rgbd;
| 89539 |  |  | 89491 |
| 89540 |  |  | 89492 |
| 89541 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89493 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89542 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89494 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89543 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89495 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89544 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89496 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89545 | PyObject* pyobj_val = NULL; |  | 89497 | PyObject* pyobj_val = NULL;
| 89546 | double val=0; |  | 89498 | double val=0;
| 89547 |  |  | 89499 |
| 89548 | const char* keywords[] = { "val", NULL }; |  | 89500 | const char* keywords[] = { "val", NULL };
| 89549 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxDepth", (char**)keywords, &pyobj_val) && |  | 89501 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxDepth", (char**)keywords, &pyobj_val) &&
| 89550 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89502 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89551 | { |  | 89503 | {
| 89552 | ERRWRAP2(_self_->setMaxDepth(val)); |  | 89504 | ERRWRAP2(_self_->setMaxDepth(val));
| 89553 | Py_RETURN_NONE; |  | 89505 | Py_RETURN_NONE;
| 89554 | } |  | 89506 | }
| 89555 |  |  | 89507 |
| 89556 | return NULL; |  | 89508 | return NULL;
| 89557 | } |  | 89509 | }
| 89558 |  |  | 89510 |
| 89559 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89511 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepthDiff(PyObject* self, PyObject* py_args, PyObject* kw)
| 89560 | { |  | 89512 | {
| 89561 | using namespace cv::rgbd; |  | 89513 | using namespace cv::rgbd;
| 89562 |  |  | 89514 |
| 89563 |  |  | 89515 |
| 89564 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89516 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89565 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89517 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89566 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89518 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89567 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89519 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89568 | PyObject* pyobj_val = NULL; |  | 89520 | PyObject* pyobj_val = NULL;
| 89569 | double val=0; |  | 89521 | double val=0;
| 89570 |  |  | 89522 |
| 89571 | const char* keywords[] = { "val", NULL }; |  | 89523 | const char* keywords[] = { "val", NULL };
| 89572 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxDepthDiff", (char**)keywords, &pyobj_val) && |  | 89524 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxDepthDiff", (char**)keywords, &pyobj_val) &&
| 89573 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89525 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89574 | { |  | 89526 | {
| 89575 | ERRWRAP2(_self_->setMaxDepthDiff(val)); |  | 89527 | ERRWRAP2(_self_->setMaxDepthDiff(val));
| 89576 | Py_RETURN_NONE; |  | 89528 | Py_RETURN_NONE;
| 89577 | } |  | 89529 | }
| 89578 |  |  | 89530 |
| 89579 | return NULL; |  | 89531 | return NULL;
| 89580 | } |  | 89532 | }
| 89581 |  |  | 89533 |
| 89582 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89534 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxPointsPart(PyObject* self, PyObject* py_args, PyObject* kw)
| 89583 | { |  | 89535 | {
| 89584 | using namespace cv::rgbd; |  | 89536 | using namespace cv::rgbd;
| 89585 |  |  | 89537 |
| 89586 |  |  | 89538 |
| 89587 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89539 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89588 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89540 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89589 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89541 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89590 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89542 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89591 | PyObject* pyobj_val = NULL; |  | 89543 | PyObject* pyobj_val = NULL;
| 89592 | double val=0; |  | 89544 | double val=0;
| 89593 |  |  | 89545 |
| 89594 | const char* keywords[] = { "val", NULL }; |  | 89546 | const char* keywords[] = { "val", NULL };
| 89595 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxPointsPart", (char**)keywords, &pyobj_val) && |  | 89547 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxPointsPart", (char**)keywords, &pyobj_val) &&
| 89596 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89548 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89597 | { |  | 89549 | {
| 89598 | ERRWRAP2(_self_->setMaxPointsPart(val)); |  | 89550 | ERRWRAP2(_self_->setMaxPointsPart(val));
| 89599 | Py_RETURN_NONE; |  | 89551 | Py_RETURN_NONE;
| 89600 | } |  | 89552 | }
| 89601 |  |  | 89553 |
| 89602 | return NULL; |  | 89554 | return NULL;
| 89603 | } |  | 89555 | }
| 89604 |  |  | 89556 |
| 89605 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89557 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxRotation(PyObject* self, PyObject* py_args, PyObject* kw)
| 89606 | { |  | 89558 | {
| 89607 | using namespace cv::rgbd; |  | 89559 | using namespace cv::rgbd;
| 89608 |  |  | 89560 |
| 89609 |  |  | 89561 |
| 89610 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89562 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89611 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89563 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89612 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89564 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89613 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89565 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89614 | PyObject* pyobj_val = NULL; |  | 89566 | PyObject* pyobj_val = NULL;
| 89615 | double val=0; |  | 89567 | double val=0;
| 89616 |  |  | 89568 |
| 89617 | const char* keywords[] = { "val", NULL }; |  | 89569 | const char* keywords[] = { "val", NULL };
| 89618 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxRotation", (char**)keywords, &pyobj_val) && |  | 89570 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxRotation", (char**)keywords, &pyobj_val) &&
| 89619 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89571 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89620 | { |  | 89572 | {
| 89621 | ERRWRAP2(_self_->setMaxRotation(val)); |  | 89573 | ERRWRAP2(_self_->setMaxRotation(val));
| 89622 | Py_RETURN_NONE; |  | 89574 | Py_RETURN_NONE;
| 89623 | } |  | 89575 | }
| 89624 |  |  | 89576 |
| 89625 | return NULL; |  | 89577 | return NULL;
| 89626 | } |  | 89578 | }
| 89627 |  |  | 89579 |
| 89628 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89580 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxTranslation(PyObject* self, PyObject* py_args, PyObject* kw)
| 89629 | { |  | 89581 | {
| 89630 | using namespace cv::rgbd; |  | 89582 | using namespace cv::rgbd;
| 89631 |  |  | 89583 |
| 89632 |  |  | 89584 |
| 89633 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89585 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89634 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89586 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89635 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89587 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89636 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89588 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89637 | PyObject* pyobj_val = NULL; |  | 89589 | PyObject* pyobj_val = NULL;
| 89638 | double val=0; |  | 89590 | double val=0;
| 89639 |  |  | 89591 |
| 89640 | const char* keywords[] = { "val", NULL }; |  | 89592 | const char* keywords[] = { "val", NULL };
| 89641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxTranslation", (char**)keywords, &pyobj_val) && |  | 89593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMaxTranslation", (char**)keywords, &pyobj_val) &&
| 89642 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89594 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89643 | { |  | 89595 | {
| 89644 | ERRWRAP2(_self_->setMaxTranslation(val)); |  | 89596 | ERRWRAP2(_self_->setMaxTranslation(val));
| 89645 | Py_RETURN_NONE; |  | 89597 | Py_RETURN_NONE;
| 89646 | } |  | 89598 | }
| 89647 |  |  | 89599 |
| 89648 | return NULL; |  | 89600 | return NULL;
| 89649 | } |  | 89601 | }
| 89650 |  |  | 89602 |
| 89651 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinDepth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89603 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinDepth(PyObject* self, PyObject* py_args, PyObject* kw)
| 89652 | { |  | 89604 | {
| 89653 | using namespace cv::rgbd; |  | 89605 | using namespace cv::rgbd;
| 89654 |  |  | 89606 |
| 89655 |  |  | 89607 |
| 89656 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89608 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89657 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89609 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89658 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89610 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89659 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89611 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89660 | PyObject* pyobj_val = NULL; |  | 89612 | PyObject* pyobj_val = NULL;
| 89661 | double val=0; |  | 89613 | double val=0;
| 89662 |  |  | 89614 |
| 89663 | const char* keywords[] = { "val", NULL }; |  | 89615 | const char* keywords[] = { "val", NULL };
| 89664 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMinDepth", (char**)keywords, &pyobj_val) && |  | 89616 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMinDepth", (char**)keywords, &pyobj_val) &&
| 89665 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89617 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89666 | { |  | 89618 | {
| 89667 | ERRWRAP2(_self_->setMinDepth(val)); |  | 89619 | ERRWRAP2(_self_->setMinDepth(val));
| 89668 | Py_RETURN_NONE; |  | 89620 | Py_RETURN_NONE;
| 89669 | } |  | 89621 | }
| 89670 |  |  | 89622 |
| 89671 | return NULL; |  | 89623 | return NULL;
| 89672 | } |  | 89624 | }
| 89673 |  |  | 89625 |
| 89674 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89626 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinGradientMagnitudes(PyObject* self, PyObject* py_args, PyObject* kw)
| 89675 | { |  | 89627 | {
| 89676 | using namespace cv::rgbd; |  | 89628 | using namespace cv::rgbd;
| 89677 |  |  | 89629 |
| 89678 |  |  | 89630 |
| 89679 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89631 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89680 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89632 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89681 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89633 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89682 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89634 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89683 | PyObject* pyobj_val = NULL; |  | 89635 | PyObject* pyobj_val = NULL;
| 89684 | Mat val; |  | 89636 | Mat val;
| 89685 |  |  | 89637 |
| 89686 | const char* keywords[] = { "val", NULL }; |  | 89638 | const char* keywords[] = { "val", NULL };
| 89687 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMinGradientMagnitudes", (char**)keywords, &pyobj_val) && |  | 89639 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setMinGradientMagnitudes", (char**)keywords, &pyobj_val) &&
| 89688 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89640 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89689 | { |  | 89641 | {
| 89690 | ERRWRAP2(_self_->setMinGradientMagnitudes(val)); |  | 89642 | ERRWRAP2(_self_->setMinGradientMagnitudes(val));
| 89691 | Py_RETURN_NONE; |  | 89643 | Py_RETURN_NONE;
| 89692 | } |  | 89644 | }
| 89693 |  |  | 89645 |
| 89694 | return NULL; |  | 89646 | return NULL;
| 89695 | } |  | 89647 | }
| 89696 |  |  | 89648 |
| 89697 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89649 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdOdometry_setTransformType(PyObject* self, PyObject* py_args, PyObject* kw)
| 89698 | { |  | 89650 | {
| 89699 | using namespace cv::rgbd; |  | 89651 | using namespace cv::rgbd;
| 89700 |  |  | 89652 |
| 89701 |  |  | 89653 |
| 89702 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0; |  | 89654 | Ptr<cv::rgbd::RgbdOdometry> * self1 = 0;
| 89703 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1)) |  | 89655 | if (!pyopencv_rgbd_RgbdOdometry_getp(self, self1))
| 89704 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)"); |  | 89656 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdOdometry' or its derivative)");
| 89705 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1); |  | 89657 | Ptr<cv::rgbd::RgbdOdometry> _self_ = *(self1);
| 89706 | PyObject* pyobj_val = NULL; |  | 89658 | PyObject* pyobj_val = NULL;
| 89707 | int val=0; |  | 89659 | int val=0;
| 89708 |  |  | 89660 |
| 89709 | const char* keywords[] = { "val", NULL }; |  | 89661 | const char* keywords[] = { "val", NULL };
| 89710 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setTransformType", (char**)keywords, &pyobj_val) && |  | 89662 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdOdometry.setTransformType", (char**)keywords, &pyobj_val) &&
| 89711 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 89663 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 89712 | { |  | 89664 | {
| 89713 | ERRWRAP2(_self_->setTransformType(val)); |  | 89665 | ERRWRAP2(_self_->setTransformType(val));
| 89714 | Py_RETURN_NONE; |  | 89666 | Py_RETURN_NONE;
| 89715 | } |  | 89667 | }
| 89716 |  |  | 89668 |
| 89717 | return NULL; |  | 89669 | return NULL;
| 89718 | } |  | 89670 | }
| 89719 |  |  | 89671 |
| 89720 |  |  | 89672 |
| 89721 |  |  | 89673 |
| 89722 | // Tables (rgbd_RgbdOdometry) |  | 89674 | // Tables (rgbd_RgbdOdometry)
| 89723 |  |  | 89675 |
| 89724 | static PyGetSetDef pyopencv_rgbd_RgbdOdometry_getseters[] = |  | 89676 | static PyGetSetDef pyopencv_rgbd_RgbdOdometry_getseters[] =
| 89725 | { |  | 89677 | {
| 89726 | {NULL} /* Sentinel */ |  | 89678 | {NULL} /* Sentinel */
| 89727 | }; |  | 89679 | };
| 89728 |  |  | 89680 |
| 89729 | static PyMethodDef pyopencv_rgbd_RgbdOdometry_methods[] = |  | 89681 | static PyMethodDef pyopencv_rgbd_RgbdOdometry_methods[] =
| 89730 | { |  | 89682 | {
| 89731 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_create_static, METH_STATIC), "create([, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, iterCounts[, minGradientMagnitudes[, maxPointsPart[, transformType]]]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param minDepth Pixels with depth less than minDepth will not be used (in meters)\n. * @param maxDepth Pixels with depth larger than maxDepth will not be used (in meters)\n. * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff (in meters)\n. * @param iterCounts Count of iterations on each pyramid level.\n. * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out\n. * if they have gradient magnitude less than minGradientMagnitudes[level].\n. * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart\n. * @param transformType Class of transformation"}, |  | 89683 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_create_static, METH_STATIC), "create([, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, iterCounts[, minGradientMagnitudes[, maxPointsPart[, transformType]]]]]]]]) -> retval\n. Constructor.\n. * @param cameraMatrix Camera matrix\n. * @param minDepth Pixels with depth less than minDepth will not be used (in meters)\n. * @param maxDepth Pixels with depth larger than maxDepth will not be used (in meters)\n. * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out\n. * if their depth difference is larger than maxDepthDiff (in meters)\n. * @param iterCounts Count of iterations on each pyramid level.\n. * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out\n. * if they have gradient magnitude less than minGradientMagnitudes[level].\n. * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart\n. * @param transformType Class of transformation"},
| 89732 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."}, |  | 89684 | {"getCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getCameraMatrix, 0), "getCameraMatrix() -> retval\n."},
| 89733 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."}, |  | 89685 | {"getIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getIterationCounts, 0), "getIterationCounts() -> retval\n."},
| 89734 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepth, 0), "getMaxDepth() -> retval\n."}, |  | 89686 | {"getMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepth, 0), "getMaxDepth() -> retval\n."},
| 89735 | {"getMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepthDiff, 0), "getMaxDepthDiff() -> retval\n."}, |  | 89687 | {"getMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxDepthDiff, 0), "getMaxDepthDiff() -> retval\n."},
| 89736 | {"getMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxPointsPart, 0), "getMaxPointsPart() -> retval\n."}, |  | 89688 | {"getMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxPointsPart, 0), "getMaxPointsPart() -> retval\n."},
| 89737 | {"getMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxRotation, 0), "getMaxRotation() -> retval\n."}, |  | 89689 | {"getMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxRotation, 0), "getMaxRotation() -> retval\n."},
| 89738 | {"getMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxTranslation, 0), "getMaxTranslation() -> retval\n."}, |  | 89690 | {"getMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMaxTranslation, 0), "getMaxTranslation() -> retval\n."},
| 89739 | {"getMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinDepth, 0), "getMinDepth() -> retval\n."}, |  | 89691 | {"getMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinDepth, 0), "getMinDepth() -> retval\n."},
| 89740 | {"getMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinGradientMagnitudes, 0), "getMinGradientMagnitudes() -> retval\n."}, |  | 89692 | {"getMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getMinGradientMagnitudes, 0), "getMinGradientMagnitudes() -> retval\n."},
| 89741 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getTransformType, 0), "getTransformType() -> retval\n."}, |  | 89693 | {"getTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_getTransformType, 0), "getTransformType() -> retval\n."},
| 89742 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."}, |  | 89694 | {"prepareFrameCache", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_prepareFrameCache, 0), "prepareFrameCache(frame, cacheType) -> retval\n."},
| 89743 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."}, |  | 89695 | {"setCameraMatrix", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setCameraMatrix, 0), "setCameraMatrix(val) -> None\n."},
| 89744 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."}, |  | 89696 | {"setIterationCounts", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setIterationCounts, 0), "setIterationCounts(val) -> None\n."},
| 89745 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepth, 0), "setMaxDepth(val) -> None\n."}, |  | 89697 | {"setMaxDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepth, 0), "setMaxDepth(val) -> None\n."},
| 89746 | {"setMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepthDiff, 0), "setMaxDepthDiff(val) -> None\n."}, |  | 89698 | {"setMaxDepthDiff", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxDepthDiff, 0), "setMaxDepthDiff(val) -> None\n."},
| 89747 | {"setMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxPointsPart, 0), "setMaxPointsPart(val) -> None\n."}, |  | 89699 | {"setMaxPointsPart", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxPointsPart, 0), "setMaxPointsPart(val) -> None\n."},
| 89748 | {"setMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxRotation, 0), "setMaxRotation(val) -> None\n."}, |  | 89700 | {"setMaxRotation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxRotation, 0), "setMaxRotation(val) -> None\n."},
| 89749 | {"setMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxTranslation, 0), "setMaxTranslation(val) -> None\n."}, |  | 89701 | {"setMaxTranslation", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMaxTranslation, 0), "setMaxTranslation(val) -> None\n."},
| 89750 | {"setMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinDepth, 0), "setMinDepth(val) -> None\n."}, |  | 89702 | {"setMinDepth", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinDepth, 0), "setMinDepth(val) -> None\n."},
| 89751 | {"setMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinGradientMagnitudes, 0), "setMinGradientMagnitudes(val) -> None\n."}, |  | 89703 | {"setMinGradientMagnitudes", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setMinGradientMagnitudes, 0), "setMinGradientMagnitudes(val) -> None\n."},
| 89752 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setTransformType, 0), "setTransformType(val) -> None\n."}, |  | 89704 | {"setTransformType", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdOdometry_setTransformType, 0), "setTransformType(val) -> None\n."},
| 89753 |  |  | 89705 |
| 89754 | {NULL, NULL} |  | 89706 | {NULL, NULL}
| 89755 | }; |  | 89707 | };
| 89756 |  |  | 89708 |
| 89757 | // Converter (rgbd_RgbdOdometry) |  | 89709 | // Converter (rgbd_RgbdOdometry)
| 89758 |  |  | 89710 |
| 89759 | template<> |  | 89711 | template<>
| 89760 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdOdometry> > |  | 89712 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdOdometry> >
| 89761 | { |  | 89713 | {
| 89762 | static PyObject* from(const Ptr<cv::rgbd::RgbdOdometry>& r) |  | 89714 | static PyObject* from(const Ptr<cv::rgbd::RgbdOdometry>& r)
| 89763 | { |  | 89715 | {
| 89764 | return pyopencv_rgbd_RgbdOdometry_Instance(r); |  | 89716 | return pyopencv_rgbd_RgbdOdometry_Instance(r);
| 89765 | } |  | 89717 | }
| 89766 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdOdometry>& dst, const ArgInfo& info) |  | 89718 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdOdometry>& dst, const ArgInfo& info)
| 89767 | { |  | 89719 | {
| 89768 | if(!src || src == Py_None) |  | 89720 | if(!src || src == Py_None)
| 89769 | return true; |  | 89721 | return true;
| 89770 | Ptr<cv::rgbd::RgbdOdometry> * dst_; |  | 89722 | Ptr<cv::rgbd::RgbdOdometry> * dst_;
| 89771 | if (pyopencv_rgbd_RgbdOdometry_getp(src, dst_)) |  | 89723 | if (pyopencv_rgbd_RgbdOdometry_getp(src, dst_))
| 89772 | { |  | 89724 | {
| 89773 | dst = *dst_; |  | 89725 | dst = *dst_;
| 89774 | return true; |  | 89726 | return true;
| 89775 | } |  | 89727 | }
| 89776 |  |  | 89728 |
| 89777 | failmsg("Expected Ptr<cv::rgbd::RgbdOdometry> for argument '%s'", info.name); |  | 89729 | failmsg("Expected Ptr<cv::rgbd::RgbdOdometry> for argument '%s'", info.name);
| 89778 | return false; |  | 89730 | return false;
| 89779 | } |  | 89731 | }
| 89780 | }; |  | 89732 | };
| 89781 |  |  | 89733 |
| 89782 | //================================================================================ |  | 89734 | //================================================================================
| 89783 | // rgbd_RgbdPlane (Generic) |  | 89735 | // rgbd_RgbdPlane (Generic)
| 89784 | //================================================================================ |  | 89736 | //================================================================================
| 89785 |  |  | 89737 |
| 89786 | // GetSet (rgbd_RgbdPlane) |  | 89738 | // GetSet (rgbd_RgbdPlane)
| 89787 |  |  | 89739 |
| 89788 |  |  | 89740 |
| 89789 |  |  | 89741 |
| 89790 | // Methods (rgbd_RgbdPlane) |  | 89742 | // Methods (rgbd_RgbdPlane)
| 89791 |  |  | 89743 |
| 89792 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89744 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 89793 | { |  | 89745 | {
| 89794 | using namespace cv::rgbd; |  | 89746 | using namespace cv::rgbd;
| 89795 |  |  | 89747 |
| 89796 |  |  | 89748 |
| 89797 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 89749 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 89798 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 89750 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 89799 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 89751 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 89800 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 89752 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 89801 | pyPrepareArgumentConversionErrorsStorage(4); |  | 89753 | pyPrepareArgumentConversionErrorsStorage(4);
| 89802 |  |  | 89754 |
| 89803 | { |  | 89755 | {
| 89804 | PyObject* pyobj_points3d = NULL; |  | 89756 | PyObject* pyobj_points3d = NULL;
| 89805 | Mat points3d; |  | 89757 | Mat points3d;
| 89806 | PyObject* pyobj_normals = NULL; |  | 89758 | PyObject* pyobj_normals = NULL;
| 89807 | Mat normals; |  | 89759 | Mat normals;
| 89808 | PyObject* pyobj_mask = NULL; |  | 89760 | PyObject* pyobj_mask = NULL;
| 89809 | Mat mask; |  | 89761 | Mat mask;
| 89810 | PyObject* pyobj_plane_coefficients = NULL; |  | 89762 | PyObject* pyobj_plane_coefficients = NULL;
| 89811 | Mat plane_coefficients; |  | 89763 | Mat plane_coefficients;
| 89812 |  |  | 89764 |
| 89813 | const char* keywords[] = { "points3d", "normals", "mask", "plane_coefficients", NULL }; |  | 89765 | const char* keywords[] = { "points3d", "normals", "mask", "plane_coefficients", NULL };
| 89814 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_normals, &pyobj_mask, &pyobj_plane_coefficients) && |  | 89766 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_normals, &pyobj_mask, &pyobj_plane_coefficients) &&
| 89815 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) && |  | 89767 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) &&
| 89816 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) && |  | 89768 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) &&
| 89817 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) && |  | 89769 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) &&
| 89818 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) ) |  | 89770 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) )
| 89819 | { |  | 89771 | {
| 89820 | ERRWRAP2(_self_->operator ()(points3d, normals, mask, plane_coefficients)); |  | 89772 | ERRWRAP2(_self_->operator ()(points3d, normals, mask, plane_coefficients));
| 89821 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients)); |  | 89773 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients));
| 89822 | } |  | 89774 | }
| 89823 |  |  | 89775 |
| 89824 |  |  | 89776 |
| 89825 | pyPopulateArgumentConversionErrors(); |  | 89777 | pyPopulateArgumentConversionErrors();
| 89826 | } |  | 89778 | }
| 89827 |  |  | 89779 |
| 89828 |  |  | 89780 |
| 89829 | { |  | 89781 | {
| 89830 | PyObject* pyobj_points3d = NULL; |  | 89782 | PyObject* pyobj_points3d = NULL;
| 89831 | Mat points3d; |  | 89783 | Mat points3d;
| 89832 | PyObject* pyobj_mask = NULL; |  | 89784 | PyObject* pyobj_mask = NULL;
| 89833 | Mat mask; |  | 89785 | Mat mask;
| 89834 | PyObject* pyobj_plane_coefficients = NULL; |  | 89786 | PyObject* pyobj_plane_coefficients = NULL;
| 89835 | Mat plane_coefficients; |  | 89787 | Mat plane_coefficients;
| 89836 |  |  | 89788 |
| 89837 | const char* keywords[] = { "points3d", "mask", "plane_coefficients", NULL }; |  | 89789 | const char* keywords[] = { "points3d", "mask", "plane_coefficients", NULL };
| 89838 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_mask, &pyobj_plane_coefficients) && |  | 89790 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_mask, &pyobj_plane_coefficients) &&
| 89839 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) && |  | 89791 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) &&
| 89840 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) && |  | 89792 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) &&
| 89841 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) ) |  | 89793 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) )
| 89842 | { |  | 89794 | {
| 89843 | ERRWRAP2(_self_->operator ()(points3d, mask, plane_coefficients)); |  | 89795 | ERRWRAP2(_self_->operator ()(points3d, mask, plane_coefficients));
| 89844 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients)); |  | 89796 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients));
| 89845 | } |  | 89797 | }
| 89846 |  |  | 89798 |
| 89847 |  |  | 89799 |
| 89848 | pyPopulateArgumentConversionErrors(); |  | 89800 | pyPopulateArgumentConversionErrors();
| 89849 | } |  | 89801 | }
| 89850 |  |  | 89802 |
| 89851 |  |  | 89803 |
| 89852 | { |  | 89804 | {
| 89853 | PyObject* pyobj_points3d = NULL; |  | 89805 | PyObject* pyobj_points3d = NULL;
| 89854 | UMat points3d; |  | 89806 | UMat points3d;
| 89855 | PyObject* pyobj_normals = NULL; |  | 89807 | PyObject* pyobj_normals = NULL;
| 89856 | UMat normals; |  | 89808 | UMat normals;
| 89857 | PyObject* pyobj_mask = NULL; |  | 89809 | PyObject* pyobj_mask = NULL;
| 89858 | UMat mask; |  | 89810 | UMat mask;
| 89859 | PyObject* pyobj_plane_coefficients = NULL; |  | 89811 | PyObject* pyobj_plane_coefficients = NULL;
| 89860 | UMat plane_coefficients; |  | 89812 | UMat plane_coefficients;
| 89861 |  |  | 89813 |
| 89862 | const char* keywords[] = { "points3d", "normals", "mask", "plane_coefficients", NULL }; |  | 89814 | const char* keywords[] = { "points3d", "normals", "mask", "plane_coefficients", NULL };
| 89863 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_normals, &pyobj_mask, &pyobj_plane_coefficients) && |  | 89815 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_normals, &pyobj_mask, &pyobj_plane_coefficients) &&
| 89864 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) && |  | 89816 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) &&
| 89865 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) && |  | 89817 | pyopencv_to_safe(pyobj_normals, normals, ArgInfo("normals", 0)) &&
| 89866 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) && |  | 89818 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) &&
| 89867 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) ) |  | 89819 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) )
| 89868 | { |  | 89820 | {
| 89869 | ERRWRAP2(_self_->operator ()(points3d, normals, mask, plane_coefficients)); |  | 89821 | ERRWRAP2(_self_->operator ()(points3d, normals, mask, plane_coefficients));
| 89870 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients)); |  | 89822 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients));
| 89871 | } |  | 89823 | }
| 89872 |  |  | 89824 |
| 89873 |  |  | 89825 |
| 89874 | pyPopulateArgumentConversionErrors(); |  | 89826 | pyPopulateArgumentConversionErrors();
| 89875 | } |  | 89827 | }
| 89876 |  |  | 89828 |
| 89877 |  |  | 89829 |
| 89878 | { |  | 89830 | {
| 89879 | PyObject* pyobj_points3d = NULL; |  | 89831 | PyObject* pyobj_points3d = NULL;
| 89880 | UMat points3d; |  | 89832 | UMat points3d;
| 89881 | PyObject* pyobj_mask = NULL; |  | 89833 | PyObject* pyobj_mask = NULL;
| 89882 | UMat mask; |  | 89834 | UMat mask;
| 89883 | PyObject* pyobj_plane_coefficients = NULL; |  | 89835 | PyObject* pyobj_plane_coefficients = NULL;
| 89884 | UMat plane_coefficients; |  | 89836 | UMat plane_coefficients;
| 89885 |  |  | 89837 |
| 89886 | const char* keywords[] = { "points3d", "mask", "plane_coefficients", NULL }; |  | 89838 | const char* keywords[] = { "points3d", "mask", "plane_coefficients", NULL };
| 89887 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_mask, &pyobj_plane_coefficients) && |  | 89839 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:rgbd_RgbdPlane.apply", (char**)keywords, &pyobj_points3d, &pyobj_mask, &pyobj_plane_coefficients) &&
| 89888 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) && |  | 89840 | pyopencv_to_safe(pyobj_points3d, points3d, ArgInfo("points3d", 0)) &&
| 89889 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) && |  | 89841 | pyopencv_to_safe(pyobj_mask, mask, ArgInfo("mask", 1)) &&
| 89890 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) ) |  | 89842 | pyopencv_to_safe(pyobj_plane_coefficients, plane_coefficients, ArgInfo("plane_coefficients", 1)) )
| 89891 | { |  | 89843 | {
| 89892 | ERRWRAP2(_self_->operator ()(points3d, mask, plane_coefficients)); |  | 89844 | ERRWRAP2(_self_->operator ()(points3d, mask, plane_coefficients));
| 89893 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients)); |  | 89845 | return Py_BuildValue("(NN)", pyopencv_from(mask), pyopencv_from(plane_coefficients));
| 89894 | } |  | 89846 | }
| 89895 |  |  | 89847 |
| 89896 |  |  | 89848 |
| 89897 | pyPopulateArgumentConversionErrors(); |  | 89849 | pyPopulateArgumentConversionErrors();
| 89898 | } |  | 89850 | }
| 89899 | pyRaiseCVOverloadException("apply"); |  | 89851 | pyRaiseCVOverloadException("apply");
| 89900 |  |  | 89852 |
| 89901 | return NULL; |  | 89853 | return NULL;
| 89902 | } |  | 89854 | }
| 89903 |  |  | 89855 |
| 89904 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89856 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 89905 | { |  | 89857 | {
| 89906 | using namespace cv::rgbd; |  | 89858 | using namespace cv::rgbd;
| 89907 |  |  | 89859 |
| 89908 | PyObject* pyobj_method = NULL; |  | 89860 | PyObject* pyobj_method = NULL;
| 89909 | int method=0; |  | 89861 | int method=0;
| 89910 | PyObject* pyobj_block_size = NULL; |  | 89862 | PyObject* pyobj_block_size = NULL;
| 89911 | int block_size=0; |  | 89863 | int block_size=0;
| 89912 | PyObject* pyobj_min_size = NULL; |  | 89864 | PyObject* pyobj_min_size = NULL;
| 89913 | int min_size=0; |  | 89865 | int min_size=0;
| 89914 | PyObject* pyobj_threshold = NULL; |  | 89866 | PyObject* pyobj_threshold = NULL;
| 89915 | double threshold=0; |  | 89867 | double threshold=0;
| 89916 | PyObject* pyobj_sensor_error_a = NULL; |  | 89868 | PyObject* pyobj_sensor_error_a = NULL;
| 89917 | double sensor_error_a=0; |  | 89869 | double sensor_error_a=0;
| 89918 | PyObject* pyobj_sensor_error_b = NULL; |  | 89870 | PyObject* pyobj_sensor_error_b = NULL;
| 89919 | double sensor_error_b=0; |  | 89871 | double sensor_error_b=0;
| 89920 | PyObject* pyobj_sensor_error_c = NULL; |  | 89872 | PyObject* pyobj_sensor_error_c = NULL;
| 89921 | double sensor_error_c=0; |  | 89873 | double sensor_error_c=0;
| 89922 | Ptr<RgbdPlane> retval; |  | 89874 | Ptr<RgbdPlane> retval;
| 89923 |  |  | 89875 |
| 89924 | const char* keywords[] = { "method", "block_size", "min_size", "threshold", "sensor_error_a", "sensor_error_b", "sensor_error_c", NULL }; |  | 89876 | const char* keywords[] = { "method", "block_size", "min_size", "threshold", "sensor_error_a", "sensor_error_b", "sensor_error_c", NULL };
| 89925 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OOO:rgbd_RgbdPlane.create", (char**)keywords, &pyobj_method, &pyobj_block_size, &pyobj_min_size, &pyobj_threshold, &pyobj_sensor_error_a, &pyobj_sensor_error_b, &pyobj_sensor_error_c) && |  | 89877 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOOO|OOO:rgbd_RgbdPlane.create", (char**)keywords, &pyobj_method, &pyobj_block_size, &pyobj_min_size, &pyobj_threshold, &pyobj_sensor_error_a, &pyobj_sensor_error_b, &pyobj_sensor_error_c) &&
| 89926 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) && |  | 89878 | pyopencv_to_safe(pyobj_method, method, ArgInfo("method", 0)) &&
| 89927 | pyopencv_to_safe(pyobj_block_size, block_size, ArgInfo("block_size", 0)) && |  | 89879 | pyopencv_to_safe(pyobj_block_size, block_size, ArgInfo("block_size", 0)) &&
| 89928 | pyopencv_to_safe(pyobj_min_size, min_size, ArgInfo("min_size", 0)) && |  | 89880 | pyopencv_to_safe(pyobj_min_size, min_size, ArgInfo("min_size", 0)) &&
| 89929 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) && |  | 89881 | pyopencv_to_safe(pyobj_threshold, threshold, ArgInfo("threshold", 0)) &&
| 89930 | pyopencv_to_safe(pyobj_sensor_error_a, sensor_error_a, ArgInfo("sensor_error_a", 0)) && |  | 89882 | pyopencv_to_safe(pyobj_sensor_error_a, sensor_error_a, ArgInfo("sensor_error_a", 0)) &&
| 89931 | pyopencv_to_safe(pyobj_sensor_error_b, sensor_error_b, ArgInfo("sensor_error_b", 0)) && |  | 89883 | pyopencv_to_safe(pyobj_sensor_error_b, sensor_error_b, ArgInfo("sensor_error_b", 0)) &&
| 89932 | pyopencv_to_safe(pyobj_sensor_error_c, sensor_error_c, ArgInfo("sensor_error_c", 0)) ) |  | 89884 | pyopencv_to_safe(pyobj_sensor_error_c, sensor_error_c, ArgInfo("sensor_error_c", 0)) )
| 89933 | { |  | 89885 | {
| 89934 | ERRWRAP2(retval = cv::rgbd::RgbdPlane::create(method, block_size, min_size, threshold, sensor_error_a, sensor_error_b, sensor_error_c)); |  | 89886 | ERRWRAP2(retval = cv::rgbd::RgbdPlane::create(method, block_size, min_size, threshold, sensor_error_a, sensor_error_b, sensor_error_c));
| 89935 | return pyopencv_from(retval); |  | 89887 | return pyopencv_from(retval);
| 89936 | } |  | 89888 | }
| 89937 |  |  | 89889 |
| 89938 | return NULL; |  | 89890 | return NULL;
| 89939 | } |  | 89891 | }
| 89940 |  |  | 89892 |
| 89941 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89893 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 89942 | { |  | 89894 | {
| 89943 | using namespace cv::rgbd; |  | 89895 | using namespace cv::rgbd;
| 89944 |  |  | 89896 |
| 89945 |  |  | 89897 |
| 89946 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 89898 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 89947 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 89899 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 89948 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 89900 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 89949 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 89901 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 89950 | int retval; |  | 89902 | int retval;
| 89951 |  |  | 89903 |
| 89952 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89904 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89953 | { |  | 89905 | {
| 89954 | ERRWRAP2(retval = _self_->getBlockSize()); |  | 89906 | ERRWRAP2(retval = _self_->getBlockSize());
| 89955 | return pyopencv_from(retval); |  | 89907 | return pyopencv_from(retval);
| 89956 | } |  | 89908 | }
| 89957 |  |  | 89909 |
| 89958 | return NULL; |  | 89910 | return NULL;
| 89959 | } |  | 89911 | }
| 89960 |  |  | 89912 |
| 89961 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89913 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 89962 | { |  | 89914 | {
| 89963 | using namespace cv::rgbd; |  | 89915 | using namespace cv::rgbd;
| 89964 |  |  | 89916 |
| 89965 |  |  | 89917 |
| 89966 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 89918 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 89967 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 89919 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 89968 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 89920 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 89969 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 89921 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 89970 | int retval; |  | 89922 | int retval;
| 89971 |  |  | 89923 |
| 89972 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89924 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89973 | { |  | 89925 | {
| 89974 | ERRWRAP2(retval = _self_->getMethod()); |  | 89926 | ERRWRAP2(retval = _self_->getMethod());
| 89975 | return pyopencv_from(retval); |  | 89927 | return pyopencv_from(retval);
| 89976 | } |  | 89928 | }
| 89977 |  |  | 89929 |
| 89978 | return NULL; |  | 89930 | return NULL;
| 89979 | } |  | 89931 | }
| 89980 |  |  | 89932 |
| 89981 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getMinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89933 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getMinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 89982 | { |  | 89934 | {
| 89983 | using namespace cv::rgbd; |  | 89935 | using namespace cv::rgbd;
| 89984 |  |  | 89936 |
| 89985 |  |  | 89937 |
| 89986 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 89938 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 89987 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 89939 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 89988 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 89940 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 89989 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 89941 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 89990 | int retval; |  | 89942 | int retval;
| 89991 |  |  | 89943 |
| 89992 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89944 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 89993 | { |  | 89945 | {
| 89994 | ERRWRAP2(retval = _self_->getMinSize()); |  | 89946 | ERRWRAP2(retval = _self_->getMinSize());
| 89995 | return pyopencv_from(retval); |  | 89947 | return pyopencv_from(retval);
| 89996 | } |  | 89948 | }
| 89997 |  |  | 89949 |
| 89998 | return NULL; |  | 89950 | return NULL;
| 89999 | } |  | 89951 | }
| 90000 |  |  | 89952 |
| 90001 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorA(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89953 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorA(PyObject* self, PyObject* py_args, PyObject* kw)
| 90002 | { |  | 89954 | {
| 90003 | using namespace cv::rgbd; |  | 89955 | using namespace cv::rgbd;
| 90004 |  |  | 89956 |
| 90005 |  |  | 89957 |
| 90006 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 89958 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90007 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 89959 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90008 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 89960 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90009 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 89961 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90010 | double retval; |  | 89962 | double retval;
| 90011 |  |  | 89963 |
| 90012 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89964 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90013 | { |  | 89965 | {
| 90014 | ERRWRAP2(retval = _self_->getSensorErrorA()); |  | 89966 | ERRWRAP2(retval = _self_->getSensorErrorA());
| 90015 | return pyopencv_from(retval); |  | 89967 | return pyopencv_from(retval);
| 90016 | } |  | 89968 | }
| 90017 |  |  | 89969 |
| 90018 | return NULL; |  | 89970 | return NULL;
| 90019 | } |  | 89971 | }
| 90020 |  |  | 89972 |
| 90021 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorB(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89973 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorB(PyObject* self, PyObject* py_args, PyObject* kw)
| 90022 | { |  | 89974 | {
| 90023 | using namespace cv::rgbd; |  | 89975 | using namespace cv::rgbd;
| 90024 |  |  | 89976 |
| 90025 |  |  | 89977 |
| 90026 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 89978 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90027 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 89979 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90028 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 89980 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90029 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 89981 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90030 | double retval; |  | 89982 | double retval;
| 90031 |  |  | 89983 |
| 90032 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 89984 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90033 | { |  | 89985 | {
| 90034 | ERRWRAP2(retval = _self_->getSensorErrorB()); |  | 89986 | ERRWRAP2(retval = _self_->getSensorErrorB());
| 90035 | return pyopencv_from(retval); |  | 89987 | return pyopencv_from(retval);
| 90036 | } |  | 89988 | }
| 90037 |  |  | 89989 |
| 90038 | return NULL; |  | 89990 | return NULL;
| 90039 | } |  | 89991 | }
| 90040 |  |  | 89992 |
| 90041 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorC(PyObject* self, PyObject* py_args, PyObject* kw) |  | 89993 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorC(PyObject* self, PyObject* py_args, PyObject* kw)
| 90042 | { |  | 89994 | {
| 90043 | using namespace cv::rgbd; |  | 89995 | using namespace cv::rgbd;
| 90044 |  |  | 89996 |
| 90045 |  |  | 89997 |
| 90046 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 89998 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90047 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 89999 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90048 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90000 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90049 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90001 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90050 | double retval; |  | 90002 | double retval;
| 90051 |  |  | 90003 |
| 90052 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90004 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90053 | { |  | 90005 | {
| 90054 | ERRWRAP2(retval = _self_->getSensorErrorC()); |  | 90006 | ERRWRAP2(retval = _self_->getSensorErrorC());
| 90055 | return pyopencv_from(retval); |  | 90007 | return pyopencv_from(retval);
| 90056 | } |  | 90008 | }
| 90057 |  |  | 90009 |
| 90058 | return NULL; |  | 90010 | return NULL;
| 90059 | } |  | 90011 | }
| 90060 |  |  | 90012 |
| 90061 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90013 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_getThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 90062 | { |  | 90014 | {
| 90063 | using namespace cv::rgbd; |  | 90015 | using namespace cv::rgbd;
| 90064 |  |  | 90016 |
| 90065 |  |  | 90017 |
| 90066 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90018 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90067 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90019 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90068 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90020 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90069 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90021 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90070 | double retval; |  | 90022 | double retval;
| 90071 |  |  | 90023 |
| 90072 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90024 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90073 | { |  | 90025 | {
| 90074 | ERRWRAP2(retval = _self_->getThreshold()); |  | 90026 | ERRWRAP2(retval = _self_->getThreshold());
| 90075 | return pyopencv_from(retval); |  | 90027 | return pyopencv_from(retval);
| 90076 | } |  | 90028 | }
| 90077 |  |  | 90029 |
| 90078 | return NULL; |  | 90030 | return NULL;
| 90079 | } |  | 90031 | }
| 90080 |  |  | 90032 |
| 90081 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90033 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setBlockSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 90082 | { |  | 90034 | {
| 90083 | using namespace cv::rgbd; |  | 90035 | using namespace cv::rgbd;
| 90084 |  |  | 90036 |
| 90085 |  |  | 90037 |
| 90086 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90038 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90087 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90039 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90088 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90040 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90089 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90041 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90090 | PyObject* pyobj_val = NULL; |  | 90042 | PyObject* pyobj_val = NULL;
| 90091 | int val=0; |  | 90043 | int val=0;
| 90092 |  |  | 90044 |
| 90093 | const char* keywords[] = { "val", NULL }; |  | 90045 | const char* keywords[] = { "val", NULL };
| 90094 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setBlockSize", (char**)keywords, &pyobj_val) && |  | 90046 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setBlockSize", (char**)keywords, &pyobj_val) &&
| 90095 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90047 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90096 | { |  | 90048 | {
| 90097 | ERRWRAP2(_self_->setBlockSize(val)); |  | 90049 | ERRWRAP2(_self_->setBlockSize(val));
| 90098 | Py_RETURN_NONE; |  | 90050 | Py_RETURN_NONE;
| 90099 | } |  | 90051 | }
| 90100 |  |  | 90052 |
| 90101 | return NULL; |  | 90053 | return NULL;
| 90102 | } |  | 90054 | }
| 90103 |  |  | 90055 |
| 90104 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setMethod(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90056 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setMethod(PyObject* self, PyObject* py_args, PyObject* kw)
| 90105 | { |  | 90057 | {
| 90106 | using namespace cv::rgbd; |  | 90058 | using namespace cv::rgbd;
| 90107 |  |  | 90059 |
| 90108 |  |  | 90060 |
| 90109 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90061 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90110 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90062 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90111 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90063 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90112 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90064 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90113 | PyObject* pyobj_val = NULL; |  | 90065 | PyObject* pyobj_val = NULL;
| 90114 | int val=0; |  | 90066 | int val=0;
| 90115 |  |  | 90067 |
| 90116 | const char* keywords[] = { "val", NULL }; |  | 90068 | const char* keywords[] = { "val", NULL };
| 90117 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setMethod", (char**)keywords, &pyobj_val) && |  | 90069 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setMethod", (char**)keywords, &pyobj_val) &&
| 90118 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90070 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90119 | { |  | 90071 | {
| 90120 | ERRWRAP2(_self_->setMethod(val)); |  | 90072 | ERRWRAP2(_self_->setMethod(val));
| 90121 | Py_RETURN_NONE; |  | 90073 | Py_RETURN_NONE;
| 90122 | } |  | 90074 | }
| 90123 |  |  | 90075 |
| 90124 | return NULL; |  | 90076 | return NULL;
| 90125 | } |  | 90077 | }
| 90126 |  |  | 90078 |
| 90127 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setMinSize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90079 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setMinSize(PyObject* self, PyObject* py_args, PyObject* kw)
| 90128 | { |  | 90080 | {
| 90129 | using namespace cv::rgbd; |  | 90081 | using namespace cv::rgbd;
| 90130 |  |  | 90082 |
| 90131 |  |  | 90083 |
| 90132 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90084 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90133 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90085 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90134 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90086 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90135 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90087 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90136 | PyObject* pyobj_val = NULL; |  | 90088 | PyObject* pyobj_val = NULL;
| 90137 | int val=0; |  | 90089 | int val=0;
| 90138 |  |  | 90090 |
| 90139 | const char* keywords[] = { "val", NULL }; |  | 90091 | const char* keywords[] = { "val", NULL };
| 90140 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setMinSize", (char**)keywords, &pyobj_val) && |  | 90092 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setMinSize", (char**)keywords, &pyobj_val) &&
| 90141 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90093 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90142 | { |  | 90094 | {
| 90143 | ERRWRAP2(_self_->setMinSize(val)); |  | 90095 | ERRWRAP2(_self_->setMinSize(val));
| 90144 | Py_RETURN_NONE; |  | 90096 | Py_RETURN_NONE;
| 90145 | } |  | 90097 | }
| 90146 |  |  | 90098 |
| 90147 | return NULL; |  | 90099 | return NULL;
| 90148 | } |  | 90100 | }
| 90149 |  |  | 90101 |
| 90150 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorA(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90102 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorA(PyObject* self, PyObject* py_args, PyObject* kw)
| 90151 | { |  | 90103 | {
| 90152 | using namespace cv::rgbd; |  | 90104 | using namespace cv::rgbd;
| 90153 |  |  | 90105 |
| 90154 |  |  | 90106 |
| 90155 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90107 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90156 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90108 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90157 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90109 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90158 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90110 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90159 | PyObject* pyobj_val = NULL; |  | 90111 | PyObject* pyobj_val = NULL;
| 90160 | double val=0; |  | 90112 | double val=0;
| 90161 |  |  | 90113 |
| 90162 | const char* keywords[] = { "val", NULL }; |  | 90114 | const char* keywords[] = { "val", NULL };
| 90163 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setSensorErrorA", (char**)keywords, &pyobj_val) && |  | 90115 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setSensorErrorA", (char**)keywords, &pyobj_val) &&
| 90164 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90116 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90165 | { |  | 90117 | {
| 90166 | ERRWRAP2(_self_->setSensorErrorA(val)); |  | 90118 | ERRWRAP2(_self_->setSensorErrorA(val));
| 90167 | Py_RETURN_NONE; |  | 90119 | Py_RETURN_NONE;
| 90168 | } |  | 90120 | }
| 90169 |  |  | 90121 |
| 90170 | return NULL; |  | 90122 | return NULL;
| 90171 | } |  | 90123 | }
| 90172 |  |  | 90124 |
| 90173 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorB(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90125 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorB(PyObject* self, PyObject* py_args, PyObject* kw)
| 90174 | { |  | 90126 | {
| 90175 | using namespace cv::rgbd; |  | 90127 | using namespace cv::rgbd;
| 90176 |  |  | 90128 |
| 90177 |  |  | 90129 |
| 90178 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90130 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90179 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90131 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90180 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90132 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90181 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90133 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90182 | PyObject* pyobj_val = NULL; |  | 90134 | PyObject* pyobj_val = NULL;
| 90183 | double val=0; |  | 90135 | double val=0;
| 90184 |  |  | 90136 |
| 90185 | const char* keywords[] = { "val", NULL }; |  | 90137 | const char* keywords[] = { "val", NULL };
| 90186 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setSensorErrorB", (char**)keywords, &pyobj_val) && |  | 90138 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setSensorErrorB", (char**)keywords, &pyobj_val) &&
| 90187 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90139 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90188 | { |  | 90140 | {
| 90189 | ERRWRAP2(_self_->setSensorErrorB(val)); |  | 90141 | ERRWRAP2(_self_->setSensorErrorB(val));
| 90190 | Py_RETURN_NONE; |  | 90142 | Py_RETURN_NONE;
| 90191 | } |  | 90143 | }
| 90192 |  |  | 90144 |
| 90193 | return NULL; |  | 90145 | return NULL;
| 90194 | } |  | 90146 | }
| 90195 |  |  | 90147 |
| 90196 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorC(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90148 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorC(PyObject* self, PyObject* py_args, PyObject* kw)
| 90197 | { |  | 90149 | {
| 90198 | using namespace cv::rgbd; |  | 90150 | using namespace cv::rgbd;
| 90199 |  |  | 90151 |
| 90200 |  |  | 90152 |
| 90201 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90153 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90202 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90154 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90203 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90155 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90204 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90156 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90205 | PyObject* pyobj_val = NULL; |  | 90157 | PyObject* pyobj_val = NULL;
| 90206 | double val=0; |  | 90158 | double val=0;
| 90207 |  |  | 90159 |
| 90208 | const char* keywords[] = { "val", NULL }; |  | 90160 | const char* keywords[] = { "val", NULL };
| 90209 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setSensorErrorC", (char**)keywords, &pyobj_val) && |  | 90161 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setSensorErrorC", (char**)keywords, &pyobj_val) &&
| 90210 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90162 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90211 | { |  | 90163 | {
| 90212 | ERRWRAP2(_self_->setSensorErrorC(val)); |  | 90164 | ERRWRAP2(_self_->setSensorErrorC(val));
| 90213 | Py_RETURN_NONE; |  | 90165 | Py_RETURN_NONE;
| 90214 | } |  | 90166 | }
| 90215 |  |  | 90167 |
| 90216 | return NULL; |  | 90168 | return NULL;
| 90217 | } |  | 90169 | }
| 90218 |  |  | 90170 |
| 90219 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90171 | static PyObject* pyopencv_cv_rgbd_rgbd_RgbdPlane_setThreshold(PyObject* self, PyObject* py_args, PyObject* kw)
| 90220 | { |  | 90172 | {
| 90221 | using namespace cv::rgbd; |  | 90173 | using namespace cv::rgbd;
| 90222 |  |  | 90174 |
| 90223 |  |  | 90175 |
| 90224 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0; |  | 90176 | Ptr<cv::rgbd::RgbdPlane> * self1 = 0;
| 90225 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1)) |  | 90177 | if (!pyopencv_rgbd_RgbdPlane_getp(self, self1))
| 90226 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)"); |  | 90178 | return failmsgp("Incorrect type of self (must be 'rgbd_RgbdPlane' or its derivative)");
| 90227 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1); |  | 90179 | Ptr<cv::rgbd::RgbdPlane> _self_ = *(self1);
| 90228 | PyObject* pyobj_val = NULL; |  | 90180 | PyObject* pyobj_val = NULL;
| 90229 | double val=0; |  | 90181 | double val=0;
| 90230 |  |  | 90182 |
| 90231 | const char* keywords[] = { "val", NULL }; |  | 90183 | const char* keywords[] = { "val", NULL };
| 90232 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setThreshold", (char**)keywords, &pyobj_val) && |  | 90184 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:rgbd_RgbdPlane.setThreshold", (char**)keywords, &pyobj_val) &&
| 90233 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90185 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90234 | { |  | 90186 | {
| 90235 | ERRWRAP2(_self_->setThreshold(val)); |  | 90187 | ERRWRAP2(_self_->setThreshold(val));
| 90236 | Py_RETURN_NONE; |  | 90188 | Py_RETURN_NONE;
| 90237 | } |  | 90189 | }
| 90238 |  |  | 90190 |
| 90239 | return NULL; |  | 90191 | return NULL;
| 90240 | } |  | 90192 | }
| 90241 |  |  | 90193 |
| 90242 |  |  | 90194 |
| 90243 |  |  | 90195 |
| 90244 | // Tables (rgbd_RgbdPlane) |  | 90196 | // Tables (rgbd_RgbdPlane)
| 90245 |  |  | 90197 |
| 90246 | static PyGetSetDef pyopencv_rgbd_RgbdPlane_getseters[] = |  | 90198 | static PyGetSetDef pyopencv_rgbd_RgbdPlane_getseters[] =
| 90247 | { |  | 90199 | {
| 90248 | {NULL} /* Sentinel */ |  | 90200 | {NULL} /* Sentinel */
| 90249 | }; |  | 90201 | };
| 90250 |  |  | 90202 |
| 90251 | static PyMethodDef pyopencv_rgbd_RgbdPlane_methods[] = |  | 90203 | static PyMethodDef pyopencv_rgbd_RgbdPlane_methods[] =
| 90252 | { |  | 90204 | {
| 90253 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_apply, 0), "apply(points3d, normals[, mask[, plane_coefficients]]) -> mask, plane_coefficients\n. Find The planes in a depth image\n. * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels\n. * @param normals the normals for every point in the depth image\n. * @param mask An image where each pixel is labeled with the plane it belongs to\n. * and 255 if it does not belong to any plane\n. * @param plane_coefficients the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0, norm(a,b,c)=1\n. * and c < 0 (so that the normal points towards the camera)\n\n\n\napply(points3d[, mask[, plane_coefficients]]) -> mask, plane_coefficients\n. Find The planes in a depth image but without doing a normal check, which is faster but less accurate\n. * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels\n. * @param mask An image where each pixel is labeled with the plane it belongs to\n. * and 255 if it does not belong to any plane\n. * @param plane_coefficients the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0"}, |  | 90205 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_apply, 0), "apply(points3d, normals[, mask[, plane_coefficients]]) -> mask, plane_coefficients\n. Find The planes in a depth image\n. * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels\n. * @param normals the normals for every point in the depth image\n. * @param mask An image where each pixel is labeled with the plane it belongs to\n. * and 255 if it does not belong to any plane\n. * @param plane_coefficients the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0, norm(a,b,c)=1\n. * and c < 0 (so that the normal points towards the camera)\n\n\n\napply(points3d[, mask[, plane_coefficients]]) -> mask, plane_coefficients\n. Find The planes in a depth image but without doing a normal check, which is faster but less accurate\n. * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels\n. * @param mask An image where each pixel is labeled with the plane it belongs to\n. * and 255 if it does not belong to any plane\n. * @param plane_coefficients the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0"},
| 90254 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_create_static, METH_STATIC), "create(method, block_size, min_size, threshold[, sensor_error_a[, sensor_error_b[, sensor_error_c]]]) -> retval\n. Constructor\n. * @param block_size The size of the blocks to look at for a stable MSE\n. * @param min_size The minimum size of a cluster to be considered a plane\n. * @param threshold The maximum distance of a point from a plane to belong to it (in meters)\n. * @param sensor_error_a coefficient of the sensor error. 0 by default, 0.0075 for a Kinect\n. * @param sensor_error_b coefficient of the sensor error. 0 by default\n. * @param sensor_error_c coefficient of the sensor error. 0 by default\n. * @param method The method to use to compute the planes."}, |  | 90206 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_create_static, METH_STATIC), "create(method, block_size, min_size, threshold[, sensor_error_a[, sensor_error_b[, sensor_error_c]]]) -> retval\n. Constructor\n. * @param block_size The size of the blocks to look at for a stable MSE\n. * @param min_size The minimum size of a cluster to be considered a plane\n. * @param threshold The maximum distance of a point from a plane to belong to it (in meters)\n. * @param sensor_error_a coefficient of the sensor error. 0 by default, 0.0075 for a Kinect\n. * @param sensor_error_b coefficient of the sensor error. 0 by default\n. * @param sensor_error_c coefficient of the sensor error. 0 by default\n. * @param method The method to use to compute the planes."},
| 90255 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getBlockSize, 0), "getBlockSize() -> retval\n."}, |  | 90207 | {"getBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getBlockSize, 0), "getBlockSize() -> retval\n."},
| 90256 | {"getMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getMethod, 0), "getMethod() -> retval\n."}, |  | 90208 | {"getMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getMethod, 0), "getMethod() -> retval\n."},
| 90257 | {"getMinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getMinSize, 0), "getMinSize() -> retval\n."}, |  | 90209 | {"getMinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getMinSize, 0), "getMinSize() -> retval\n."},
| 90258 | {"getSensorErrorA", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorA, 0), "getSensorErrorA() -> retval\n."}, |  | 90210 | {"getSensorErrorA", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorA, 0), "getSensorErrorA() -> retval\n."},
| 90259 | {"getSensorErrorB", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorB, 0), "getSensorErrorB() -> retval\n."}, |  | 90211 | {"getSensorErrorB", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorB, 0), "getSensorErrorB() -> retval\n."},
| 90260 | {"getSensorErrorC", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorC, 0), "getSensorErrorC() -> retval\n."}, |  | 90212 | {"getSensorErrorC", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getSensorErrorC, 0), "getSensorErrorC() -> retval\n."},
| 90261 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getThreshold, 0), "getThreshold() -> retval\n."}, |  | 90213 | {"getThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_getThreshold, 0), "getThreshold() -> retval\n."},
| 90262 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setBlockSize, 0), "setBlockSize(val) -> None\n."}, |  | 90214 | {"setBlockSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setBlockSize, 0), "setBlockSize(val) -> None\n."},
| 90263 | {"setMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setMethod, 0), "setMethod(val) -> None\n."}, |  | 90215 | {"setMethod", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setMethod, 0), "setMethod(val) -> None\n."},
| 90264 | {"setMinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setMinSize, 0), "setMinSize(val) -> None\n."}, |  | 90216 | {"setMinSize", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setMinSize, 0), "setMinSize(val) -> None\n."},
| 90265 | {"setSensorErrorA", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorA, 0), "setSensorErrorA(val) -> None\n."}, |  | 90217 | {"setSensorErrorA", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorA, 0), "setSensorErrorA(val) -> None\n."},
| 90266 | {"setSensorErrorB", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorB, 0), "setSensorErrorB(val) -> None\n."}, |  | 90218 | {"setSensorErrorB", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorB, 0), "setSensorErrorB(val) -> None\n."},
| 90267 | {"setSensorErrorC", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorC, 0), "setSensorErrorC(val) -> None\n."}, |  | 90219 | {"setSensorErrorC", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setSensorErrorC, 0), "setSensorErrorC(val) -> None\n."},
| 90268 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setThreshold, 0), "setThreshold(val) -> None\n."}, |  | 90220 | {"setThreshold", CV_PY_FN_WITH_KW_(pyopencv_cv_rgbd_rgbd_RgbdPlane_setThreshold, 0), "setThreshold(val) -> None\n."},
| 90269 |  |  | 90221 |
| 90270 | {NULL, NULL} |  | 90222 | {NULL, NULL}
| 90271 | }; |  | 90223 | };
| 90272 |  |  | 90224 |
| 90273 | // Converter (rgbd_RgbdPlane) |  | 90225 | // Converter (rgbd_RgbdPlane)
| 90274 |  |  | 90226 |
| 90275 | template<> |  | 90227 | template<>
| 90276 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdPlane> > |  | 90228 | struct PyOpenCV_Converter< Ptr<cv::rgbd::RgbdPlane> >
| 90277 | { |  | 90229 | {
| 90278 | static PyObject* from(const Ptr<cv::rgbd::RgbdPlane>& r) |  | 90230 | static PyObject* from(const Ptr<cv::rgbd::RgbdPlane>& r)
| 90279 | { |  | 90231 | {
| 90280 | return pyopencv_rgbd_RgbdPlane_Instance(r); |  | 90232 | return pyopencv_rgbd_RgbdPlane_Instance(r);
| 90281 | } |  | 90233 | }
| 90282 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdPlane>& dst, const ArgInfo& info) |  | 90234 | static bool to(PyObject* src, Ptr<cv::rgbd::RgbdPlane>& dst, const ArgInfo& info)
| 90283 | { |  | 90235 | {
| 90284 | if(!src || src == Py_None) |  | 90236 | if(!src || src == Py_None)
| 90285 | return true; |  | 90237 | return true;
| 90286 | Ptr<cv::rgbd::RgbdPlane> * dst_; |  | 90238 | Ptr<cv::rgbd::RgbdPlane> * dst_;
| 90287 | if (pyopencv_rgbd_RgbdPlane_getp(src, dst_)) |  | 90239 | if (pyopencv_rgbd_RgbdPlane_getp(src, dst_))
| 90288 | { |  | 90240 | {
| 90289 | dst = *dst_; |  | 90241 | dst = *dst_;
| 90290 | return true; |  | 90242 | return true;
| 90291 | } |  | 90243 | }
| 90292 |  |  | 90244 |
| 90293 | failmsg("Expected Ptr<cv::rgbd::RgbdPlane> for argument '%s'", info.name); |  | 90245 | failmsg("Expected Ptr<cv::rgbd::RgbdPlane> for argument '%s'", info.name);
| 90294 | return false; |  | 90246 | return false;
| 90295 | } |  | 90247 | }
| 90296 | }; |  | 90248 | };
| 90297 |  |  | 90249 |
| 90298 | //================================================================================ |  | 90250 | //================================================================================
| 90299 | // saliency_MotionSaliency (Generic) |  | 90251 | // saliency_MotionSaliency (Generic)
| 90300 | //================================================================================ |  | 90252 | //================================================================================
| 90301 |  |  | 90253 |
| 90302 | // GetSet (saliency_MotionSaliency) |  | 90254 | // GetSet (saliency_MotionSaliency)
| 90303 |  |  | 90255 |
| 90304 |  |  | 90256 |
| 90305 |  |  | 90257 |
| 90306 | // Methods (saliency_MotionSaliency) |  | 90258 | // Methods (saliency_MotionSaliency)
| 90307 |  |  | 90259 |
| 90308 |  |  | 90260 |
| 90309 |  |  | 90261 |
| 90310 | // Tables (saliency_MotionSaliency) |  | 90262 | // Tables (saliency_MotionSaliency)
| 90311 |  |  | 90263 |
| 90312 | static PyGetSetDef pyopencv_saliency_MotionSaliency_getseters[] = |  | 90264 | static PyGetSetDef pyopencv_saliency_MotionSaliency_getseters[] =
| 90313 | { |  | 90265 | {
| 90314 | {NULL} /* Sentinel */ |  | 90266 | {NULL} /* Sentinel */
| 90315 | }; |  | 90267 | };
| 90316 |  |  | 90268 |
| 90317 | static PyMethodDef pyopencv_saliency_MotionSaliency_methods[] = |  | 90269 | static PyMethodDef pyopencv_saliency_MotionSaliency_methods[] =
| 90318 | { |  | 90270 | {
| 90319 |  |  | 90271 |
| 90320 | {NULL, NULL} |  | 90272 | {NULL, NULL}
| 90321 | }; |  | 90273 | };
| 90322 |  |  | 90274 |
| 90323 | // Converter (saliency_MotionSaliency) |  | 90275 | // Converter (saliency_MotionSaliency)
| 90324 |  |  | 90276 |
| 90325 | template<> |  | 90277 | template<>
| 90326 | struct PyOpenCV_Converter< Ptr<cv::saliency::MotionSaliency> > |  | 90278 | struct PyOpenCV_Converter< Ptr<cv::saliency::MotionSaliency> >
| 90327 | { |  | 90279 | {
| 90328 | static PyObject* from(const Ptr<cv::saliency::MotionSaliency>& r) |  | 90280 | static PyObject* from(const Ptr<cv::saliency::MotionSaliency>& r)
| 90329 | { |  | 90281 | {
| 90330 | return pyopencv_saliency_MotionSaliency_Instance(r); |  | 90282 | return pyopencv_saliency_MotionSaliency_Instance(r);
| 90331 | } |  | 90283 | }
| 90332 | static bool to(PyObject* src, Ptr<cv::saliency::MotionSaliency>& dst, const ArgInfo& info) |  | 90284 | static bool to(PyObject* src, Ptr<cv::saliency::MotionSaliency>& dst, const ArgInfo& info)
| 90333 | { |  | 90285 | {
| 90334 | if(!src || src == Py_None) |  | 90286 | if(!src || src == Py_None)
| 90335 | return true; |  | 90287 | return true;
| 90336 | Ptr<cv::saliency::MotionSaliency> * dst_; |  | 90288 | Ptr<cv::saliency::MotionSaliency> * dst_;
| 90337 | if (pyopencv_saliency_MotionSaliency_getp(src, dst_)) |  | 90289 | if (pyopencv_saliency_MotionSaliency_getp(src, dst_))
| 90338 | { |  | 90290 | {
| 90339 | dst = *dst_; |  | 90291 | dst = *dst_;
| 90340 | return true; |  | 90292 | return true;
| 90341 | } |  | 90293 | }
| 90342 |  |  | 90294 |
| 90343 | failmsg("Expected Ptr<cv::saliency::MotionSaliency> for argument '%s'", info.name); |  | 90295 | failmsg("Expected Ptr<cv::saliency::MotionSaliency> for argument '%s'", info.name);
| 90344 | return false; |  | 90296 | return false;
| 90345 | } |  | 90297 | }
| 90346 | }; |  | 90298 | };
| 90347 |  |  | 90299 |
| 90348 | //================================================================================ |  | 90300 | //================================================================================
| 90349 | // saliency_MotionSaliencyBinWangApr2014 (Generic) |  | 90301 | // saliency_MotionSaliencyBinWangApr2014 (Generic)
| 90350 | //================================================================================ |  | 90302 | //================================================================================
| 90351 |  |  | 90303 |
| 90352 | // GetSet (saliency_MotionSaliencyBinWangApr2014) |  | 90304 | // GetSet (saliency_MotionSaliencyBinWangApr2014)
| 90353 |  |  | 90305 |
| 90354 |  |  | 90306 |
| 90355 |  |  | 90307 |
| 90356 | // Methods (saliency_MotionSaliencyBinWangApr2014) |  | 90308 | // Methods (saliency_MotionSaliencyBinWangApr2014)
| 90357 |  |  | 90309 |
| 90358 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90310 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw)
| 90359 | { |  | 90311 | {
| 90360 | using namespace cv::saliency; |  | 90312 | using namespace cv::saliency;
| 90361 |  |  | 90313 |
| 90362 |  |  | 90314 |
| 90363 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0; |  | 90315 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0;
| 90364 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1)) |  | 90316 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1))
| 90365 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)"); |  | 90317 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)");
| 90366 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1); |  | 90318 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1);
| 90367 | pyPrepareArgumentConversionErrorsStorage(2); |  | 90319 | pyPrepareArgumentConversionErrorsStorage(2);
| 90368 |  |  | 90320 |
| 90369 | { |  | 90321 | {
| 90370 | PyObject* pyobj_image = NULL; |  | 90322 | PyObject* pyobj_image = NULL;
| 90371 | Mat image; |  | 90323 | Mat image;
| 90372 | PyObject* pyobj_saliencyMap = NULL; |  | 90324 | PyObject* pyobj_saliencyMap = NULL;
| 90373 | Mat saliencyMap; |  | 90325 | Mat saliencyMap;
| 90374 | bool retval; |  | 90326 | bool retval;
| 90375 |  |  | 90327 |
| 90376 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 90328 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 90377 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_MotionSaliencyBinWangApr2014.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 90329 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_MotionSaliencyBinWangApr2014.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 90378 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 90330 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 90379 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 90331 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 90380 | { |  | 90332 | {
| 90381 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 90333 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 90382 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 90334 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 90383 | } |  | 90335 | }
| 90384 |  |  | 90336 |
| 90385 |  |  | 90337 |
| 90386 | pyPopulateArgumentConversionErrors(); |  | 90338 | pyPopulateArgumentConversionErrors();
| 90387 | } |  | 90339 | }
| 90388 |  |  | 90340 |
| 90389 |  |  | 90341 |
| 90390 | { |  | 90342 | {
| 90391 | PyObject* pyobj_image = NULL; |  | 90343 | PyObject* pyobj_image = NULL;
| 90392 | UMat image; |  | 90344 | UMat image;
| 90393 | PyObject* pyobj_saliencyMap = NULL; |  | 90345 | PyObject* pyobj_saliencyMap = NULL;
| 90394 | UMat saliencyMap; |  | 90346 | UMat saliencyMap;
| 90395 | bool retval; |  | 90347 | bool retval;
| 90396 |  |  | 90348 |
| 90397 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 90349 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 90398 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_MotionSaliencyBinWangApr2014.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 90350 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_MotionSaliencyBinWangApr2014.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 90399 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 90351 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 90400 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 90352 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 90401 | { |  | 90353 | {
| 90402 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 90354 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 90403 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 90355 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 90404 | } |  | 90356 | }
| 90405 |  |  | 90357 |
| 90406 |  |  | 90358 |
| 90407 | pyPopulateArgumentConversionErrors(); |  | 90359 | pyPopulateArgumentConversionErrors();
| 90408 | } |  | 90360 | }
| 90409 | pyRaiseCVOverloadException("computeSaliency"); |  | 90361 | pyRaiseCVOverloadException("computeSaliency");
| 90410 |  |  | 90362 |
| 90411 | return NULL; |  | 90363 | return NULL;
| 90412 | } |  | 90364 | }
| 90413 |  |  | 90365 |
| 90414 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90366 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 90415 | { |  | 90367 | {
| 90416 | using namespace cv::saliency; |  | 90368 | using namespace cv::saliency;
| 90417 |  |  | 90369 |
| 90418 | Ptr<MotionSaliencyBinWangApr2014> retval; |  | 90370 | Ptr<MotionSaliencyBinWangApr2014> retval;
| 90419 |  |  | 90371 |
| 90420 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90372 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90421 | { |  | 90373 | {
| 90422 | ERRWRAP2(retval = cv::saliency::MotionSaliencyBinWangApr2014::create()); |  | 90374 | ERRWRAP2(retval = cv::saliency::MotionSaliencyBinWangApr2014::create());
| 90423 | return pyopencv_from(retval); |  | 90375 | return pyopencv_from(retval);
| 90424 | } |  | 90376 | }
| 90425 |  |  | 90377 |
| 90426 | return NULL; |  | 90378 | return NULL;
| 90427 | } |  | 90379 | }
| 90428 |  |  | 90380 |
| 90429 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageHeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90381 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageHeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 90430 | { |  | 90382 | {
| 90431 | using namespace cv::saliency; |  | 90383 | using namespace cv::saliency;
| 90432 |  |  | 90384 |
| 90433 |  |  | 90385 |
| 90434 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0; |  | 90386 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0;
| 90435 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1)) |  | 90387 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1))
| 90436 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)"); |  | 90388 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)");
| 90437 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1); |  | 90389 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1);
| 90438 | int retval; |  | 90390 | int retval;
| 90439 |  |  | 90391 |
| 90440 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90392 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90441 | { |  | 90393 | {
| 90442 | ERRWRAP2(retval = _self_->getImageHeight()); |  | 90394 | ERRWRAP2(retval = _self_->getImageHeight());
| 90443 | return pyopencv_from(retval); |  | 90395 | return pyopencv_from(retval);
| 90444 | } |  | 90396 | }
| 90445 |  |  | 90397 |
| 90446 | return NULL; |  | 90398 | return NULL;
| 90447 | } |  | 90399 | }
| 90448 |  |  | 90400 |
| 90449 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90401 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 90450 | { |  | 90402 | {
| 90451 | using namespace cv::saliency; |  | 90403 | using namespace cv::saliency;
| 90452 |  |  | 90404 |
| 90453 |  |  | 90405 |
| 90454 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0; |  | 90406 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0;
| 90455 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1)) |  | 90407 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1))
| 90456 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)"); |  | 90408 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)");
| 90457 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1); |  | 90409 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1);
| 90458 | int retval; |  | 90410 | int retval;
| 90459 |  |  | 90411 |
| 90460 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90412 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90461 | { |  | 90413 | {
| 90462 | ERRWRAP2(retval = _self_->getImageWidth()); |  | 90414 | ERRWRAP2(retval = _self_->getImageWidth());
| 90463 | return pyopencv_from(retval); |  | 90415 | return pyopencv_from(retval);
| 90464 | } |  | 90416 | }
| 90465 |  |  | 90417 |
| 90466 | return NULL; |  | 90418 | return NULL;
| 90467 | } |  | 90419 | }
| 90468 |  |  | 90420 |
| 90469 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_init(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90421 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_init(PyObject* self, PyObject* py_args, PyObject* kw)
| 90470 | { |  | 90422 | {
| 90471 | using namespace cv::saliency; |  | 90423 | using namespace cv::saliency;
| 90472 |  |  | 90424 |
| 90473 |  |  | 90425 |
| 90474 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0; |  | 90426 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0;
| 90475 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1)) |  | 90427 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1))
| 90476 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)"); |  | 90428 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)");
| 90477 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1); |  | 90429 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1);
| 90478 | bool retval; |  | 90430 | bool retval;
| 90479 |  |  | 90431 |
| 90480 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90432 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90481 | { |  | 90433 | {
| 90482 | ERRWRAP2(retval = _self_->init()); |  | 90434 | ERRWRAP2(retval = _self_->init());
| 90483 | return pyopencv_from(retval); |  | 90435 | return pyopencv_from(retval);
| 90484 | } |  | 90436 | }
| 90485 |  |  | 90437 |
| 90486 | return NULL; |  | 90438 | return NULL;
| 90487 | } |  | 90439 | }
| 90488 |  |  | 90440 |
| 90489 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageHeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90441 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageHeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 90490 | { |  | 90442 | {
| 90491 | using namespace cv::saliency; |  | 90443 | using namespace cv::saliency;
| 90492 |  |  | 90444 |
| 90493 |  |  | 90445 |
| 90494 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0; |  | 90446 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0;
| 90495 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1)) |  | 90447 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1))
| 90496 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)"); |  | 90448 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)");
| 90497 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1); |  | 90449 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1);
| 90498 | PyObject* pyobj_val = NULL; |  | 90450 | PyObject* pyobj_val = NULL;
| 90499 | int val=0; |  | 90451 | int val=0;
| 90500 |  |  | 90452 |
| 90501 | const char* keywords[] = { "val", NULL }; |  | 90453 | const char* keywords[] = { "val", NULL };
| 90502 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_MotionSaliencyBinWangApr2014.setImageHeight", (char**)keywords, &pyobj_val) && |  | 90454 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_MotionSaliencyBinWangApr2014.setImageHeight", (char**)keywords, &pyobj_val) &&
| 90503 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90455 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90504 | { |  | 90456 | {
| 90505 | ERRWRAP2(_self_->setImageHeight(val)); |  | 90457 | ERRWRAP2(_self_->setImageHeight(val));
| 90506 | Py_RETURN_NONE; |  | 90458 | Py_RETURN_NONE;
| 90507 | } |  | 90459 | }
| 90508 |  |  | 90460 |
| 90509 | return NULL; |  | 90461 | return NULL;
| 90510 | } |  | 90462 | }
| 90511 |  |  | 90463 |
| 90512 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90464 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 90513 | { |  | 90465 | {
| 90514 | using namespace cv::saliency; |  | 90466 | using namespace cv::saliency;
| 90515 |  |  | 90467 |
| 90516 |  |  | 90468 |
| 90517 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0; |  | 90469 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0;
| 90518 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1)) |  | 90470 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1))
| 90519 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)"); |  | 90471 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)");
| 90520 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1); |  | 90472 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1);
| 90521 | PyObject* pyobj_val = NULL; |  | 90473 | PyObject* pyobj_val = NULL;
| 90522 | int val=0; |  | 90474 | int val=0;
| 90523 |  |  | 90475 |
| 90524 | const char* keywords[] = { "val", NULL }; |  | 90476 | const char* keywords[] = { "val", NULL };
| 90525 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_MotionSaliencyBinWangApr2014.setImageWidth", (char**)keywords, &pyobj_val) && |  | 90477 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_MotionSaliencyBinWangApr2014.setImageWidth", (char**)keywords, &pyobj_val) &&
| 90526 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90478 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90527 | { |  | 90479 | {
| 90528 | ERRWRAP2(_self_->setImageWidth(val)); |  | 90480 | ERRWRAP2(_self_->setImageWidth(val));
| 90529 | Py_RETURN_NONE; |  | 90481 | Py_RETURN_NONE;
| 90530 | } |  | 90482 | }
| 90531 |  |  | 90483 |
| 90532 | return NULL; |  | 90484 | return NULL;
| 90533 | } |  | 90485 | }
| 90534 |  |  | 90486 |
| 90535 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImagesize(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90487 | static PyObject* pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImagesize(PyObject* self, PyObject* py_args, PyObject* kw)
| 90536 | { |  | 90488 | {
| 90537 | using namespace cv::saliency; |  | 90489 | using namespace cv::saliency;
| 90538 |  |  | 90490 |
| 90539 |  |  | 90491 |
| 90540 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0; |  | 90492 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * self1 = 0;
| 90541 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1)) |  | 90493 | if (!pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(self, self1))
| 90542 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)"); |  | 90494 | return failmsgp("Incorrect type of self (must be 'saliency_MotionSaliencyBinWangApr2014' or its derivative)");
| 90543 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1); |  | 90495 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> _self_ = *(self1);
| 90544 | PyObject* pyobj_W = NULL; |  | 90496 | PyObject* pyobj_W = NULL;
| 90545 | int W=0; |  | 90497 | int W=0;
| 90546 | PyObject* pyobj_H = NULL; |  | 90498 | PyObject* pyobj_H = NULL;
| 90547 | int H=0; |  | 90499 | int H=0;
| 90548 |  |  | 90500 |
| 90549 | const char* keywords[] = { "W", "H", NULL }; |  | 90501 | const char* keywords[] = { "W", "H", NULL };
| 90550 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:saliency_MotionSaliencyBinWangApr2014.setImagesize", (char**)keywords, &pyobj_W, &pyobj_H) && |  | 90502 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:saliency_MotionSaliencyBinWangApr2014.setImagesize", (char**)keywords, &pyobj_W, &pyobj_H) &&
| 90551 | pyopencv_to_safe(pyobj_W, W, ArgInfo("W", 0)) && |  | 90503 | pyopencv_to_safe(pyobj_W, W, ArgInfo("W", 0)) &&
| 90552 | pyopencv_to_safe(pyobj_H, H, ArgInfo("H", 0)) ) |  | 90504 | pyopencv_to_safe(pyobj_H, H, ArgInfo("H", 0)) )
| 90553 | { |  | 90505 | {
| 90554 | ERRWRAP2(_self_->setImagesize(W, H)); |  | 90506 | ERRWRAP2(_self_->setImagesize(W, H));
| 90555 | Py_RETURN_NONE; |  | 90507 | Py_RETURN_NONE;
| 90556 | } |  | 90508 | }
| 90557 |  |  | 90509 |
| 90558 | return NULL; |  | 90510 | return NULL;
| 90559 | } |  | 90511 | }
| 90560 |  |  | 90512 |
| 90561 |  |  | 90513 |
| 90562 |  |  | 90514 |
| 90563 | // Tables (saliency_MotionSaliencyBinWangApr2014) |  | 90515 | // Tables (saliency_MotionSaliencyBinWangApr2014)
| 90564 |  |  | 90516 |
| 90565 | static PyGetSetDef pyopencv_saliency_MotionSaliencyBinWangApr2014_getseters[] = |  | 90517 | static PyGetSetDef pyopencv_saliency_MotionSaliencyBinWangApr2014_getseters[] =
| 90566 | { |  | 90518 | {
| 90567 | {NULL} /* Sentinel */ |  | 90519 | {NULL} /* Sentinel */
| 90568 | }; |  | 90520 | };
| 90569 |  |  | 90521 |
| 90570 | static PyMethodDef pyopencv_saliency_MotionSaliencyBinWangApr2014_methods[] = |  | 90522 | static PyMethodDef pyopencv_saliency_MotionSaliencyBinWangApr2014_methods[] =
| 90571 | { |  | 90523 | {
| 90572 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."}, |  | 90524 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."},
| 90573 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_create_static, METH_STATIC), "create() -> retval\n."}, |  | 90525 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_create_static, METH_STATIC), "create() -> retval\n."},
| 90574 | {"getImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageHeight, 0), "getImageHeight() -> retval\n."}, |  | 90526 | {"getImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageHeight, 0), "getImageHeight() -> retval\n."},
| 90575 | {"getImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageWidth, 0), "getImageWidth() -> retval\n."}, |  | 90527 | {"getImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_getImageWidth, 0), "getImageWidth() -> retval\n."},
| 90576 | {"init", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_init, 0), "init() -> retval\n. @brief This function allows the correct initialization of all data structures that will be used by the\n. algorithm."}, |  | 90528 | {"init", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_init, 0), "init() -> retval\n. @brief This function allows the correct initialization of all data structures that will be used by the\n. algorithm."},
| 90577 | {"setImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageHeight, 0), "setImageHeight(val) -> None\n."}, |  | 90529 | {"setImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageHeight, 0), "setImageHeight(val) -> None\n."},
| 90578 | {"setImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageWidth, 0), "setImageWidth(val) -> None\n."}, |  | 90530 | {"setImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImageWidth, 0), "setImageWidth(val) -> None\n."},
| 90579 | {"setImagesize", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImagesize, 0), "setImagesize(W, H) -> None\n. @brief This is a utility function that allows to set the correct size (taken from the input image) in the\n. corresponding variables that will be used to size the data structures of the algorithm.\n. @param W width of input image\n. @param H height of input image"}, |  | 90531 | {"setImagesize", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_MotionSaliencyBinWangApr2014_setImagesize, 0), "setImagesize(W, H) -> None\n. @brief This is a utility function that allows to set the correct size (taken from the input image) in the\n. corresponding variables that will be used to size the data structures of the algorithm.\n. @param W width of input image\n. @param H height of input image"},
| 90580 |  |  | 90532 |
| 90581 | {NULL, NULL} |  | 90533 | {NULL, NULL}
| 90582 | }; |  | 90534 | };
| 90583 |  |  | 90535 |
| 90584 | // Converter (saliency_MotionSaliencyBinWangApr2014) |  | 90536 | // Converter (saliency_MotionSaliencyBinWangApr2014)
| 90585 |  |  | 90537 |
| 90586 | template<> |  | 90538 | template<>
| 90587 | struct PyOpenCV_Converter< Ptr<cv::saliency::MotionSaliencyBinWangApr2014> > |  | 90539 | struct PyOpenCV_Converter< Ptr<cv::saliency::MotionSaliencyBinWangApr2014> >
| 90588 | { |  | 90540 | {
| 90589 | static PyObject* from(const Ptr<cv::saliency::MotionSaliencyBinWangApr2014>& r) |  | 90541 | static PyObject* from(const Ptr<cv::saliency::MotionSaliencyBinWangApr2014>& r)
| 90590 | { |  | 90542 | {
| 90591 | return pyopencv_saliency_MotionSaliencyBinWangApr2014_Instance(r); |  | 90543 | return pyopencv_saliency_MotionSaliencyBinWangApr2014_Instance(r);
| 90592 | } |  | 90544 | }
| 90593 | static bool to(PyObject* src, Ptr<cv::saliency::MotionSaliencyBinWangApr2014>& dst, const ArgInfo& info) |  | 90545 | static bool to(PyObject* src, Ptr<cv::saliency::MotionSaliencyBinWangApr2014>& dst, const ArgInfo& info)
| 90594 | { |  | 90546 | {
| 90595 | if(!src || src == Py_None) |  | 90547 | if(!src || src == Py_None)
| 90596 | return true; |  | 90548 | return true;
| 90597 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * dst_; |  | 90549 | Ptr<cv::saliency::MotionSaliencyBinWangApr2014> * dst_;
| 90598 | if (pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(src, dst_)) |  | 90550 | if (pyopencv_saliency_MotionSaliencyBinWangApr2014_getp(src, dst_))
| 90599 | { |  | 90551 | {
| 90600 | dst = *dst_; |  | 90552 | dst = *dst_;
| 90601 | return true; |  | 90553 | return true;
| 90602 | } |  | 90554 | }
| 90603 |  |  | 90555 |
| 90604 | failmsg("Expected Ptr<cv::saliency::MotionSaliencyBinWangApr2014> for argument '%s'", info.name); |  | 90556 | failmsg("Expected Ptr<cv::saliency::MotionSaliencyBinWangApr2014> for argument '%s'", info.name);
| 90605 | return false; |  | 90557 | return false;
| 90606 | } |  | 90558 | }
| 90607 | }; |  | 90559 | };
| 90608 |  |  | 90560 |
| 90609 | //================================================================================ |  | 90561 | //================================================================================
| 90610 | // saliency_Objectness (Generic) |  | 90562 | // saliency_Objectness (Generic)
| 90611 | //================================================================================ |  | 90563 | //================================================================================
| 90612 |  |  | 90564 |
| 90613 | // GetSet (saliency_Objectness) |  | 90565 | // GetSet (saliency_Objectness)
| 90614 |  |  | 90566 |
| 90615 |  |  | 90567 |
| 90616 |  |  | 90568 |
| 90617 | // Methods (saliency_Objectness) |  | 90569 | // Methods (saliency_Objectness)
| 90618 |  |  | 90570 |
| 90619 |  |  | 90571 |
| 90620 |  |  | 90572 |
| 90621 | // Tables (saliency_Objectness) |  | 90573 | // Tables (saliency_Objectness)
| 90622 |  |  | 90574 |
| 90623 | static PyGetSetDef pyopencv_saliency_Objectness_getseters[] = |  | 90575 | static PyGetSetDef pyopencv_saliency_Objectness_getseters[] =
| 90624 | { |  | 90576 | {
| 90625 | {NULL} /* Sentinel */ |  | 90577 | {NULL} /* Sentinel */
| 90626 | }; |  | 90578 | };
| 90627 |  |  | 90579 |
| 90628 | static PyMethodDef pyopencv_saliency_Objectness_methods[] = |  | 90580 | static PyMethodDef pyopencv_saliency_Objectness_methods[] =
| 90629 | { |  | 90581 | {
| 90630 |  |  | 90582 |
| 90631 | {NULL, NULL} |  | 90583 | {NULL, NULL}
| 90632 | }; |  | 90584 | };
| 90633 |  |  | 90585 |
| 90634 | // Converter (saliency_Objectness) |  | 90586 | // Converter (saliency_Objectness)
| 90635 |  |  | 90587 |
| 90636 | template<> |  | 90588 | template<>
| 90637 | struct PyOpenCV_Converter< Ptr<cv::saliency::Objectness> > |  | 90589 | struct PyOpenCV_Converter< Ptr<cv::saliency::Objectness> >
| 90638 | { |  | 90590 | {
| 90639 | static PyObject* from(const Ptr<cv::saliency::Objectness>& r) |  | 90591 | static PyObject* from(const Ptr<cv::saliency::Objectness>& r)
| 90640 | { |  | 90592 | {
| 90641 | return pyopencv_saliency_Objectness_Instance(r); |  | 90593 | return pyopencv_saliency_Objectness_Instance(r);
| 90642 | } |  | 90594 | }
| 90643 | static bool to(PyObject* src, Ptr<cv::saliency::Objectness>& dst, const ArgInfo& info) |  | 90595 | static bool to(PyObject* src, Ptr<cv::saliency::Objectness>& dst, const ArgInfo& info)
| 90644 | { |  | 90596 | {
| 90645 | if(!src || src == Py_None) |  | 90597 | if(!src || src == Py_None)
| 90646 | return true; |  | 90598 | return true;
| 90647 | Ptr<cv::saliency::Objectness> * dst_; |  | 90599 | Ptr<cv::saliency::Objectness> * dst_;
| 90648 | if (pyopencv_saliency_Objectness_getp(src, dst_)) |  | 90600 | if (pyopencv_saliency_Objectness_getp(src, dst_))
| 90649 | { |  | 90601 | {
| 90650 | dst = *dst_; |  | 90602 | dst = *dst_;
| 90651 | return true; |  | 90603 | return true;
| 90652 | } |  | 90604 | }
| 90653 |  |  | 90605 |
| 90654 | failmsg("Expected Ptr<cv::saliency::Objectness> for argument '%s'", info.name); |  | 90606 | failmsg("Expected Ptr<cv::saliency::Objectness> for argument '%s'", info.name);
| 90655 | return false; |  | 90607 | return false;
| 90656 | } |  | 90608 | }
| 90657 | }; |  | 90609 | };
| 90658 |  |  | 90610 |
| 90659 | //================================================================================ |  | 90611 | //================================================================================
| 90660 | // saliency_ObjectnessBING (Generic) |  | 90612 | // saliency_ObjectnessBING (Generic)
| 90661 | //================================================================================ |  | 90613 | //================================================================================
| 90662 |  |  | 90614 |
| 90663 | // GetSet (saliency_ObjectnessBING) |  | 90615 | // GetSet (saliency_ObjectnessBING)
| 90664 |  |  | 90616 |
| 90665 |  |  | 90617 |
| 90666 |  |  | 90618 |
| 90667 | // Methods (saliency_ObjectnessBING) |  | 90619 | // Methods (saliency_ObjectnessBING)
| 90668 |  |  | 90620 |
| 90669 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90621 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw)
| 90670 | { |  | 90622 | {
| 90671 | using namespace cv::saliency; |  | 90623 | using namespace cv::saliency;
| 90672 |  |  | 90624 |
| 90673 |  |  | 90625 |
| 90674 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90626 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90675 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90627 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90676 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90628 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90677 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90629 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90678 | pyPrepareArgumentConversionErrorsStorage(2); |  | 90630 | pyPrepareArgumentConversionErrorsStorage(2);
| 90679 |  |  | 90631 |
| 90680 | { |  | 90632 | {
| 90681 | PyObject* pyobj_image = NULL; |  | 90633 | PyObject* pyobj_image = NULL;
| 90682 | Mat image; |  | 90634 | Mat image;
| 90683 | PyObject* pyobj_saliencyMap = NULL; |  | 90635 | PyObject* pyobj_saliencyMap = NULL;
| 90684 | Mat saliencyMap; |  | 90636 | Mat saliencyMap;
| 90685 | bool retval; |  | 90637 | bool retval;
| 90686 |  |  | 90638 |
| 90687 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 90639 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 90688 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_ObjectnessBING.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 90640 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_ObjectnessBING.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 90689 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 90641 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 90690 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 90642 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 90691 | { |  | 90643 | {
| 90692 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 90644 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 90693 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 90645 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 90694 | } |  | 90646 | }
| 90695 |  |  | 90647 |
| 90696 |  |  | 90648 |
| 90697 | pyPopulateArgumentConversionErrors(); |  | 90649 | pyPopulateArgumentConversionErrors();
| 90698 | } |  | 90650 | }
| 90699 |  |  | 90651 |
| 90700 |  |  | 90652 |
| 90701 | { |  | 90653 | {
| 90702 | PyObject* pyobj_image = NULL; |  | 90654 | PyObject* pyobj_image = NULL;
| 90703 | UMat image; |  | 90655 | UMat image;
| 90704 | PyObject* pyobj_saliencyMap = NULL; |  | 90656 | PyObject* pyobj_saliencyMap = NULL;
| 90705 | UMat saliencyMap; |  | 90657 | UMat saliencyMap;
| 90706 | bool retval; |  | 90658 | bool retval;
| 90707 |  |  | 90659 |
| 90708 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 90660 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 90709 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_ObjectnessBING.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 90661 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_ObjectnessBING.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 90710 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 90662 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 90711 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 90663 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 90712 | { |  | 90664 | {
| 90713 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 90665 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 90714 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 90666 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 90715 | } |  | 90667 | }
| 90716 |  |  | 90668 |
| 90717 |  |  | 90669 |
| 90718 | pyPopulateArgumentConversionErrors(); |  | 90670 | pyPopulateArgumentConversionErrors();
| 90719 | } |  | 90671 | }
| 90720 | pyRaiseCVOverloadException("computeSaliency"); |  | 90672 | pyRaiseCVOverloadException("computeSaliency");
| 90721 |  |  | 90673 |
| 90722 | return NULL; |  | 90674 | return NULL;
| 90723 | } |  | 90675 | }
| 90724 |  |  | 90676 |
| 90725 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90677 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 90726 | { |  | 90678 | {
| 90727 | using namespace cv::saliency; |  | 90679 | using namespace cv::saliency;
| 90728 |  |  | 90680 |
| 90729 | Ptr<ObjectnessBING> retval; |  | 90681 | Ptr<ObjectnessBING> retval;
| 90730 |  |  | 90682 |
| 90731 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90683 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90732 | { |  | 90684 | {
| 90733 | ERRWRAP2(retval = cv::saliency::ObjectnessBING::create()); |  | 90685 | ERRWRAP2(retval = cv::saliency::ObjectnessBING::create());
| 90734 | return pyopencv_from(retval); |  | 90686 | return pyopencv_from(retval);
| 90735 | } |  | 90687 | }
| 90736 |  |  | 90688 |
| 90737 | return NULL; |  | 90689 | return NULL;
| 90738 | } |  | 90690 | }
| 90739 |  |  | 90691 |
| 90740 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getBase(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90692 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getBase(PyObject* self, PyObject* py_args, PyObject* kw)
| 90741 | { |  | 90693 | {
| 90742 | using namespace cv::saliency; |  | 90694 | using namespace cv::saliency;
| 90743 |  |  | 90695 |
| 90744 |  |  | 90696 |
| 90745 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90697 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90746 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90698 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90747 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90699 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90748 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90700 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90749 | double retval; |  | 90701 | double retval;
| 90750 |  |  | 90702 |
| 90751 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90703 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90752 | { |  | 90704 | {
| 90753 | ERRWRAP2(retval = _self_->getBase()); |  | 90705 | ERRWRAP2(retval = _self_->getBase());
| 90754 | return pyopencv_from(retval); |  | 90706 | return pyopencv_from(retval);
| 90755 | } |  | 90707 | }
| 90756 |  |  | 90708 |
| 90757 | return NULL; |  | 90709 | return NULL;
| 90758 | } |  | 90710 | }
| 90759 |  |  | 90711 |
| 90760 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getNSS(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90712 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getNSS(PyObject* self, PyObject* py_args, PyObject* kw)
| 90761 | { |  | 90713 | {
| 90762 | using namespace cv::saliency; |  | 90714 | using namespace cv::saliency;
| 90763 |  |  | 90715 |
| 90764 |  |  | 90716 |
| 90765 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90717 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90766 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90718 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90767 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90719 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90768 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90720 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90769 | int retval; |  | 90721 | int retval;
| 90770 |  |  | 90722 |
| 90771 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90723 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90772 | { |  | 90724 | {
| 90773 | ERRWRAP2(retval = _self_->getNSS()); |  | 90725 | ERRWRAP2(retval = _self_->getNSS());
| 90774 | return pyopencv_from(retval); |  | 90726 | return pyopencv_from(retval);
| 90775 | } |  | 90727 | }
| 90776 |  |  | 90728 |
| 90777 | return NULL; |  | 90729 | return NULL;
| 90778 | } |  | 90730 | }
| 90779 |  |  | 90731 |
| 90780 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getW(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90732 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getW(PyObject* self, PyObject* py_args, PyObject* kw)
| 90781 | { |  | 90733 | {
| 90782 | using namespace cv::saliency; |  | 90734 | using namespace cv::saliency;
| 90783 |  |  | 90735 |
| 90784 |  |  | 90736 |
| 90785 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90737 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90786 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90738 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90787 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90739 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90788 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90740 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90789 | int retval; |  | 90741 | int retval;
| 90790 |  |  | 90742 |
| 90791 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90743 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90792 | { |  | 90744 | {
| 90793 | ERRWRAP2(retval = _self_->getW()); |  | 90745 | ERRWRAP2(retval = _self_->getW());
| 90794 | return pyopencv_from(retval); |  | 90746 | return pyopencv_from(retval);
| 90795 | } |  | 90747 | }
| 90796 |  |  | 90748 |
| 90797 | return NULL; |  | 90749 | return NULL;
| 90798 | } |  | 90750 | }
| 90799 |  |  | 90751 |
| 90800 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getobjectnessValues(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90752 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_getobjectnessValues(PyObject* self, PyObject* py_args, PyObject* kw)
| 90801 | { |  | 90753 | {
| 90802 | using namespace cv::saliency; |  | 90754 | using namespace cv::saliency;
| 90803 |  |  | 90755 |
| 90804 |  |  | 90756 |
| 90805 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90757 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90806 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90758 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90807 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90759 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90808 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90760 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90809 | std::vector<float> retval; |  | 90761 | std::vector<float> retval;
| 90810 |  |  | 90762 |
| 90811 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90763 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90812 | { |  | 90764 | {
| 90813 | ERRWRAP2(retval = _self_->getobjectnessValues()); |  | 90765 | ERRWRAP2(retval = _self_->getobjectnessValues());
| 90814 | return pyopencv_from(retval); |  | 90766 | return pyopencv_from(retval);
| 90815 | } |  | 90767 | }
| 90816 |  |  | 90768 |
| 90817 | return NULL; |  | 90769 | return NULL;
| 90818 | } |  | 90770 | }
| 90819 |  |  | 90771 |
| 90820 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90772 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 90821 | { |  | 90773 | {
| 90822 | using namespace cv::saliency; |  | 90774 | using namespace cv::saliency;
| 90823 |  |  | 90775 |
| 90824 |  |  | 90776 |
| 90825 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90777 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90826 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90778 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90827 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90779 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90828 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90780 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90829 |  |  | 90781 |
| 90830 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90782 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90831 | { |  | 90783 | {
| 90832 | ERRWRAP2(_self_->read()); |  | 90784 | ERRWRAP2(_self_->read());
| 90833 | Py_RETURN_NONE; |  | 90785 | Py_RETURN_NONE;
| 90834 | } |  | 90786 | }
| 90835 |  |  | 90787 |
| 90836 | return NULL; |  | 90788 | return NULL;
| 90837 | } |  | 90789 | }
| 90838 |  |  | 90790 |
| 90839 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setBBResDir(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90791 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setBBResDir(PyObject* self, PyObject* py_args, PyObject* kw)
| 90840 | { |  | 90792 | {
| 90841 | using namespace cv::saliency; |  | 90793 | using namespace cv::saliency;
| 90842 |  |  | 90794 |
| 90843 |  |  | 90795 |
| 90844 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90796 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90845 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90797 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90846 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90798 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90847 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90799 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90848 | PyObject* pyobj_resultsDir = NULL; |  | 90800 | PyObject* pyobj_resultsDir = NULL;
| 90849 | String resultsDir; |  | 90801 | String resultsDir;
| 90850 |  |  | 90802 |
| 90851 | const char* keywords[] = { "resultsDir", NULL }; |  | 90803 | const char* keywords[] = { "resultsDir", NULL };
| 90852 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setBBResDir", (char**)keywords, &pyobj_resultsDir) && |  | 90804 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setBBResDir", (char**)keywords, &pyobj_resultsDir) &&
| 90853 | pyopencv_to_safe(pyobj_resultsDir, resultsDir, ArgInfo("resultsDir", 0)) ) |  | 90805 | pyopencv_to_safe(pyobj_resultsDir, resultsDir, ArgInfo("resultsDir", 0)) )
| 90854 | { |  | 90806 | {
| 90855 | ERRWRAP2(_self_->setBBResDir(resultsDir)); |  | 90807 | ERRWRAP2(_self_->setBBResDir(resultsDir));
| 90856 | Py_RETURN_NONE; |  | 90808 | Py_RETURN_NONE;
| 90857 | } |  | 90809 | }
| 90858 |  |  | 90810 |
| 90859 | return NULL; |  | 90811 | return NULL;
| 90860 | } |  | 90812 | }
| 90861 |  |  | 90813 |
| 90862 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setBase(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90814 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setBase(PyObject* self, PyObject* py_args, PyObject* kw)
| 90863 | { |  | 90815 | {
| 90864 | using namespace cv::saliency; |  | 90816 | using namespace cv::saliency;
| 90865 |  |  | 90817 |
| 90866 |  |  | 90818 |
| 90867 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90819 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90868 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90820 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90869 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90821 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90870 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90822 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90871 | PyObject* pyobj_val = NULL; |  | 90823 | PyObject* pyobj_val = NULL;
| 90872 | double val=0; |  | 90824 | double val=0;
| 90873 |  |  | 90825 |
| 90874 | const char* keywords[] = { "val", NULL }; |  | 90826 | const char* keywords[] = { "val", NULL };
| 90875 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setBase", (char**)keywords, &pyobj_val) && |  | 90827 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setBase", (char**)keywords, &pyobj_val) &&
| 90876 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90828 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90877 | { |  | 90829 | {
| 90878 | ERRWRAP2(_self_->setBase(val)); |  | 90830 | ERRWRAP2(_self_->setBase(val));
| 90879 | Py_RETURN_NONE; |  | 90831 | Py_RETURN_NONE;
| 90880 | } |  | 90832 | }
| 90881 |  |  | 90833 |
| 90882 | return NULL; |  | 90834 | return NULL;
| 90883 | } |  | 90835 | }
| 90884 |  |  | 90836 |
| 90885 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setNSS(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90837 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setNSS(PyObject* self, PyObject* py_args, PyObject* kw)
| 90886 | { |  | 90838 | {
| 90887 | using namespace cv::saliency; |  | 90839 | using namespace cv::saliency;
| 90888 |  |  | 90840 |
| 90889 |  |  | 90841 |
| 90890 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90842 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90891 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90843 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90892 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90844 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90893 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90845 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90894 | PyObject* pyobj_val = NULL; |  | 90846 | PyObject* pyobj_val = NULL;
| 90895 | int val=0; |  | 90847 | int val=0;
| 90896 |  |  | 90848 |
| 90897 | const char* keywords[] = { "val", NULL }; |  | 90849 | const char* keywords[] = { "val", NULL };
| 90898 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setNSS", (char**)keywords, &pyobj_val) && |  | 90850 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setNSS", (char**)keywords, &pyobj_val) &&
| 90899 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90851 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90900 | { |  | 90852 | {
| 90901 | ERRWRAP2(_self_->setNSS(val)); |  | 90853 | ERRWRAP2(_self_->setNSS(val));
| 90902 | Py_RETURN_NONE; |  | 90854 | Py_RETURN_NONE;
| 90903 | } |  | 90855 | }
| 90904 |  |  | 90856 |
| 90905 | return NULL; |  | 90857 | return NULL;
| 90906 | } |  | 90858 | }
| 90907 |  |  | 90859 |
| 90908 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setTrainingPath(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90860 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setTrainingPath(PyObject* self, PyObject* py_args, PyObject* kw)
| 90909 | { |  | 90861 | {
| 90910 | using namespace cv::saliency; |  | 90862 | using namespace cv::saliency;
| 90911 |  |  | 90863 |
| 90912 |  |  | 90864 |
| 90913 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90865 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90914 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90866 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90915 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90867 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90916 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90868 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90917 | PyObject* pyobj_trainingPath = NULL; |  | 90869 | PyObject* pyobj_trainingPath = NULL;
| 90918 | String trainingPath; |  | 90870 | String trainingPath;
| 90919 |  |  | 90871 |
| 90920 | const char* keywords[] = { "trainingPath", NULL }; |  | 90872 | const char* keywords[] = { "trainingPath", NULL };
| 90921 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setTrainingPath", (char**)keywords, &pyobj_trainingPath) && |  | 90873 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setTrainingPath", (char**)keywords, &pyobj_trainingPath) &&
| 90922 | pyopencv_to_safe(pyobj_trainingPath, trainingPath, ArgInfo("trainingPath", 0)) ) |  | 90874 | pyopencv_to_safe(pyobj_trainingPath, trainingPath, ArgInfo("trainingPath", 0)) )
| 90923 | { |  | 90875 | {
| 90924 | ERRWRAP2(_self_->setTrainingPath(trainingPath)); |  | 90876 | ERRWRAP2(_self_->setTrainingPath(trainingPath));
| 90925 | Py_RETURN_NONE; |  | 90877 | Py_RETURN_NONE;
| 90926 | } |  | 90878 | }
| 90927 |  |  | 90879 |
| 90928 | return NULL; |  | 90880 | return NULL;
| 90929 | } |  | 90881 | }
| 90930 |  |  | 90882 |
| 90931 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setW(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90883 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_setW(PyObject* self, PyObject* py_args, PyObject* kw)
| 90932 | { |  | 90884 | {
| 90933 | using namespace cv::saliency; |  | 90885 | using namespace cv::saliency;
| 90934 |  |  | 90886 |
| 90935 |  |  | 90887 |
| 90936 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90888 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90937 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90889 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90938 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90890 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90939 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90891 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90940 | PyObject* pyobj_val = NULL; |  | 90892 | PyObject* pyobj_val = NULL;
| 90941 | int val=0; |  | 90893 | int val=0;
| 90942 |  |  | 90894 |
| 90943 | const char* keywords[] = { "val", NULL }; |  | 90895 | const char* keywords[] = { "val", NULL };
| 90944 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setW", (char**)keywords, &pyobj_val) && |  | 90896 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_ObjectnessBING.setW", (char**)keywords, &pyobj_val) &&
| 90945 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 90897 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 90946 | { |  | 90898 | {
| 90947 | ERRWRAP2(_self_->setW(val)); |  | 90899 | ERRWRAP2(_self_->setW(val));
| 90948 | Py_RETURN_NONE; |  | 90900 | Py_RETURN_NONE;
| 90949 | } |  | 90901 | }
| 90950 |  |  | 90902 |
| 90951 | return NULL; |  | 90903 | return NULL;
| 90952 | } |  | 90904 | }
| 90953 |  |  | 90905 |
| 90954 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_write(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90906 | static PyObject* pyopencv_cv_saliency_saliency_ObjectnessBING_write(PyObject* self, PyObject* py_args, PyObject* kw)
| 90955 | { |  | 90907 | {
| 90956 | using namespace cv::saliency; |  | 90908 | using namespace cv::saliency;
| 90957 |  |  | 90909 |
| 90958 |  |  | 90910 |
| 90959 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0; |  | 90911 | Ptr<cv::saliency::ObjectnessBING> * self1 = 0;
| 90960 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1)) |  | 90912 | if (!pyopencv_saliency_ObjectnessBING_getp(self, self1))
| 90961 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)"); |  | 90913 | return failmsgp("Incorrect type of self (must be 'saliency_ObjectnessBING' or its derivative)");
| 90962 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1); |  | 90914 | Ptr<cv::saliency::ObjectnessBING> _self_ = *(self1);
| 90963 |  |  | 90915 |
| 90964 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 90916 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 90965 | { |  | 90917 | {
| 90966 | ERRWRAP2(_self_->write()); |  | 90918 | ERRWRAP2(_self_->write());
| 90967 | Py_RETURN_NONE; |  | 90919 | Py_RETURN_NONE;
| 90968 | } |  | 90920 | }
| 90969 |  |  | 90921 |
| 90970 | return NULL; |  | 90922 | return NULL;
| 90971 | } |  | 90923 | }
| 90972 |  |  | 90924 |
| 90973 |  |  | 90925 |
| 90974 |  |  | 90926 |
| 90975 | // Tables (saliency_ObjectnessBING) |  | 90927 | // Tables (saliency_ObjectnessBING)
| 90976 |  |  | 90928 |
| 90977 | static PyGetSetDef pyopencv_saliency_ObjectnessBING_getseters[] = |  | 90929 | static PyGetSetDef pyopencv_saliency_ObjectnessBING_getseters[] =
| 90978 | { |  | 90930 | {
| 90979 | {NULL} /* Sentinel */ |  | 90931 | {NULL} /* Sentinel */
| 90980 | }; |  | 90932 | };
| 90981 |  |  | 90933 |
| 90982 | static PyMethodDef pyopencv_saliency_ObjectnessBING_methods[] = |  | 90934 | static PyMethodDef pyopencv_saliency_ObjectnessBING_methods[] =
| 90983 | { |  | 90935 | {
| 90984 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."}, |  | 90936 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."},
| 90985 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_create_static, METH_STATIC), "create() -> retval\n."}, |  | 90937 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_create_static, METH_STATIC), "create() -> retval\n."},
| 90986 | {"getBase", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getBase, 0), "getBase() -> retval\n."}, |  | 90938 | {"getBase", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getBase, 0), "getBase() -> retval\n."},
| 90987 | {"getNSS", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getNSS, 0), "getNSS() -> retval\n."}, |  | 90939 | {"getNSS", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getNSS, 0), "getNSS() -> retval\n."},
| 90988 | {"getW", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getW, 0), "getW() -> retval\n."}, |  | 90940 | {"getW", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getW, 0), "getW() -> retval\n."},
| 90989 | {"getobjectnessValues", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getobjectnessValues, 0), "getobjectnessValues() -> retval\n. @brief Return the list of the rectangles' objectness value,\n. \n. in the same order as the *vector\\<Vec4i\\> objectnessBoundingBox* returned by the algorithm (in\n. computeSaliencyImpl function). The bigger value these scores are, it is more likely to be an\n. object window."}, |  | 90941 | {"getobjectnessValues", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_getobjectnessValues, 0), "getobjectnessValues() -> retval\n. @brief Return the list of the rectangles' objectness value,\n. \n. in the same order as the *vector\\<Vec4i\\> objectnessBoundingBox* returned by the algorithm (in\n. computeSaliencyImpl function). The bigger value these scores are, it is more likely to be an\n. object window."},
| 90990 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_read, 0), "read() -> None\n."}, |  | 90942 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_read, 0), "read() -> None\n."},
| 90991 | {"setBBResDir", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setBBResDir, 0), "setBBResDir(resultsDir) -> None\n. @brief This is a utility function that allows to set an arbitrary path in which the algorithm will save the\n. optional results\n. \n. (ie writing on file the total number and the list of rectangles returned by objectess, one for\n. each row).\n. @param resultsDir results' folder path"}, |  | 90943 | {"setBBResDir", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setBBResDir, 0), "setBBResDir(resultsDir) -> None\n. @brief This is a utility function that allows to set an arbitrary path in which the algorithm will save the\n. optional results\n. \n. (ie writing on file the total number and the list of rectangles returned by objectess, one for\n. each row).\n. @param resultsDir results' folder path"},
| 90992 | {"setBase", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setBase, 0), "setBase(val) -> None\n."}, |  | 90944 | {"setBase", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setBase, 0), "setBase(val) -> None\n."},
| 90993 | {"setNSS", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setNSS, 0), "setNSS(val) -> None\n."}, |  | 90945 | {"setNSS", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setNSS, 0), "setNSS(val) -> None\n."},
| 90994 | {"setTrainingPath", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setTrainingPath, 0), "setTrainingPath(trainingPath) -> None\n. @brief This is a utility function that allows to set the correct path from which the algorithm will load\n. the trained model.\n. @param trainingPath trained model path"}, |  | 90946 | {"setTrainingPath", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setTrainingPath, 0), "setTrainingPath(trainingPath) -> None\n. @brief This is a utility function that allows to set the correct path from which the algorithm will load\n. the trained model.\n. @param trainingPath trained model path"},
| 90995 | {"setW", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setW, 0), "setW(val) -> None\n."}, |  | 90947 | {"setW", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_setW, 0), "setW(val) -> None\n."},
| 90996 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_write, 0), "write() -> None\n."}, |  | 90948 | {"write", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_ObjectnessBING_write, 0), "write() -> None\n."},
| 90997 |  |  | 90949 |
| 90998 | {NULL, NULL} |  | 90950 | {NULL, NULL}
| 90999 | }; |  | 90951 | };
| 91000 |  |  | 90952 |
| 91001 | // Converter (saliency_ObjectnessBING) |  | 90953 | // Converter (saliency_ObjectnessBING)
| 91002 |  |  | 90954 |
| 91003 | template<> |  | 90955 | template<>
| 91004 | struct PyOpenCV_Converter< Ptr<cv::saliency::ObjectnessBING> > |  | 90956 | struct PyOpenCV_Converter< Ptr<cv::saliency::ObjectnessBING> >
| 91005 | { |  | 90957 | {
| 91006 | static PyObject* from(const Ptr<cv::saliency::ObjectnessBING>& r) |  | 90958 | static PyObject* from(const Ptr<cv::saliency::ObjectnessBING>& r)
| 91007 | { |  | 90959 | {
| 91008 | return pyopencv_saliency_ObjectnessBING_Instance(r); |  | 90960 | return pyopencv_saliency_ObjectnessBING_Instance(r);
| 91009 | } |  | 90961 | }
| 91010 | static bool to(PyObject* src, Ptr<cv::saliency::ObjectnessBING>& dst, const ArgInfo& info) |  | 90962 | static bool to(PyObject* src, Ptr<cv::saliency::ObjectnessBING>& dst, const ArgInfo& info)
| 91011 | { |  | 90963 | {
| 91012 | if(!src || src == Py_None) |  | 90964 | if(!src || src == Py_None)
| 91013 | return true; |  | 90965 | return true;
| 91014 | Ptr<cv::saliency::ObjectnessBING> * dst_; |  | 90966 | Ptr<cv::saliency::ObjectnessBING> * dst_;
| 91015 | if (pyopencv_saliency_ObjectnessBING_getp(src, dst_)) |  | 90967 | if (pyopencv_saliency_ObjectnessBING_getp(src, dst_))
| 91016 | { |  | 90968 | {
| 91017 | dst = *dst_; |  | 90969 | dst = *dst_;
| 91018 | return true; |  | 90970 | return true;
| 91019 | } |  | 90971 | }
| 91020 |  |  | 90972 |
| 91021 | failmsg("Expected Ptr<cv::saliency::ObjectnessBING> for argument '%s'", info.name); |  | 90973 | failmsg("Expected Ptr<cv::saliency::ObjectnessBING> for argument '%s'", info.name);
| 91022 | return false; |  | 90974 | return false;
| 91023 | } |  | 90975 | }
| 91024 | }; |  | 90976 | };
| 91025 |  |  | 90977 |
| 91026 | //================================================================================ |  | 90978 | //================================================================================
| 91027 | // saliency_Saliency (Generic) |  | 90979 | // saliency_Saliency (Generic)
| 91028 | //================================================================================ |  | 90980 | //================================================================================
| 91029 |  |  | 90981 |
| 91030 | // GetSet (saliency_Saliency) |  | 90982 | // GetSet (saliency_Saliency)
| 91031 |  |  | 90983 |
| 91032 |  |  | 90984 |
| 91033 |  |  | 90985 |
| 91034 | // Methods (saliency_Saliency) |  | 90986 | // Methods (saliency_Saliency)
| 91035 |  |  | 90987 |
| 91036 | static PyObject* pyopencv_cv_saliency_saliency_Saliency_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw) |  | 90988 | static PyObject* pyopencv_cv_saliency_saliency_Saliency_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw)
| 91037 | { |  | 90989 | {
| 91038 | using namespace cv::saliency; |  | 90990 | using namespace cv::saliency;
| 91039 |  |  | 90991 |
| 91040 |  |  | 90992 |
| 91041 | Ptr<cv::saliency::Saliency> * self1 = 0; |  | 90993 | Ptr<cv::saliency::Saliency> * self1 = 0;
| 91042 | if (!pyopencv_saliency_Saliency_getp(self, self1)) |  | 90994 | if (!pyopencv_saliency_Saliency_getp(self, self1))
| 91043 | return failmsgp("Incorrect type of self (must be 'saliency_Saliency' or its derivative)"); |  | 90995 | return failmsgp("Incorrect type of self (must be 'saliency_Saliency' or its derivative)");
| 91044 | Ptr<cv::saliency::Saliency> _self_ = *(self1); |  | 90996 | Ptr<cv::saliency::Saliency> _self_ = *(self1);
| 91045 | pyPrepareArgumentConversionErrorsStorage(2); |  | 90997 | pyPrepareArgumentConversionErrorsStorage(2);
| 91046 |  |  | 90998 |
| 91047 | { |  | 90999 | {
| 91048 | PyObject* pyobj_image = NULL; |  | 91000 | PyObject* pyobj_image = NULL;
| 91049 | Mat image; |  | 91001 | Mat image;
| 91050 | PyObject* pyobj_saliencyMap = NULL; |  | 91002 | PyObject* pyobj_saliencyMap = NULL;
| 91051 | Mat saliencyMap; |  | 91003 | Mat saliencyMap;
| 91052 | bool retval; |  | 91004 | bool retval;
| 91053 |  |  | 91005 |
| 91054 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 91006 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 91055 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_Saliency.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 91007 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_Saliency.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 91056 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 91008 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 91057 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 91009 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 91058 | { |  | 91010 | {
| 91059 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 91011 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 91060 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 91012 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 91061 | } |  | 91013 | }
| 91062 |  |  | 91014 |
| 91063 |  |  | 91015 |
| 91064 | pyPopulateArgumentConversionErrors(); |  | 91016 | pyPopulateArgumentConversionErrors();
| 91065 | } |  | 91017 | }
| 91066 |  |  | 91018 |
| 91067 |  |  | 91019 |
| 91068 | { |  | 91020 | {
| 91069 | PyObject* pyobj_image = NULL; |  | 91021 | PyObject* pyobj_image = NULL;
| 91070 | UMat image; |  | 91022 | UMat image;
| 91071 | PyObject* pyobj_saliencyMap = NULL; |  | 91023 | PyObject* pyobj_saliencyMap = NULL;
| 91072 | UMat saliencyMap; |  | 91024 | UMat saliencyMap;
| 91073 | bool retval; |  | 91025 | bool retval;
| 91074 |  |  | 91026 |
| 91075 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 91027 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 91076 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_Saliency.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 91028 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_Saliency.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 91077 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 91029 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 91078 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 91030 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 91079 | { |  | 91031 | {
| 91080 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 91032 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 91081 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 91033 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 91082 | } |  | 91034 | }
| 91083 |  |  | 91035 |
| 91084 |  |  | 91036 |
| 91085 | pyPopulateArgumentConversionErrors(); |  | 91037 | pyPopulateArgumentConversionErrors();
| 91086 | } |  | 91038 | }
| 91087 | pyRaiseCVOverloadException("computeSaliency"); |  | 91039 | pyRaiseCVOverloadException("computeSaliency");
| 91088 |  |  | 91040 |
| 91089 | return NULL; |  | 91041 | return NULL;
| 91090 | } |  | 91042 | }
| 91091 |  |  | 91043 |
| 91092 |  |  | 91044 |
| 91093 |  |  | 91045 |
| 91094 | // Tables (saliency_Saliency) |  | 91046 | // Tables (saliency_Saliency)
| 91095 |  |  | 91047 |
| 91096 | static PyGetSetDef pyopencv_saliency_Saliency_getseters[] = |  | 91048 | static PyGetSetDef pyopencv_saliency_Saliency_getseters[] =
| 91097 | { |  | 91049 | {
| 91098 | {NULL} /* Sentinel */ |  | 91050 | {NULL} /* Sentinel */
| 91099 | }; |  | 91051 | };
| 91100 |  |  | 91052 |
| 91101 | static PyMethodDef pyopencv_saliency_Saliency_methods[] = |  | 91053 | static PyMethodDef pyopencv_saliency_Saliency_methods[] =
| 91102 | { |  | 91054 | {
| 91103 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_Saliency_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n. * \\brief Compute the saliency\n. * \\param image The image.\n. * \\param saliencyMap The computed saliency map.\n. * \\return true if the saliency map is computed, false otherwise"}, |  | 91055 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_Saliency_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n. * \\brief Compute the saliency\n. * \\param image The image.\n. * \\param saliencyMap The computed saliency map.\n. * \\return true if the saliency map is computed, false otherwise"},
| 91104 |  |  | 91056 |
| 91105 | {NULL, NULL} |  | 91057 | {NULL, NULL}
| 91106 | }; |  | 91058 | };
| 91107 |  |  | 91059 |
| 91108 | // Converter (saliency_Saliency) |  | 91060 | // Converter (saliency_Saliency)
| 91109 |  |  | 91061 |
| 91110 | template<> |  | 91062 | template<>
| 91111 | struct PyOpenCV_Converter< Ptr<cv::saliency::Saliency> > |  | 91063 | struct PyOpenCV_Converter< Ptr<cv::saliency::Saliency> >
| 91112 | { |  | 91064 | {
| 91113 | static PyObject* from(const Ptr<cv::saliency::Saliency>& r) |  | 91065 | static PyObject* from(const Ptr<cv::saliency::Saliency>& r)
| 91114 | { |  | 91066 | {
| 91115 | return pyopencv_saliency_Saliency_Instance(r); |  | 91067 | return pyopencv_saliency_Saliency_Instance(r);
| 91116 | } |  | 91068 | }
| 91117 | static bool to(PyObject* src, Ptr<cv::saliency::Saliency>& dst, const ArgInfo& info) |  | 91069 | static bool to(PyObject* src, Ptr<cv::saliency::Saliency>& dst, const ArgInfo& info)
| 91118 | { |  | 91070 | {
| 91119 | if(!src || src == Py_None) |  | 91071 | if(!src || src == Py_None)
| 91120 | return true; |  | 91072 | return true;
| 91121 | Ptr<cv::saliency::Saliency> * dst_; |  | 91073 | Ptr<cv::saliency::Saliency> * dst_;
| 91122 | if (pyopencv_saliency_Saliency_getp(src, dst_)) |  | 91074 | if (pyopencv_saliency_Saliency_getp(src, dst_))
| 91123 | { |  | 91075 | {
| 91124 | dst = *dst_; |  | 91076 | dst = *dst_;
| 91125 | return true; |  | 91077 | return true;
| 91126 | } |  | 91078 | }
| 91127 |  |  | 91079 |
| 91128 | failmsg("Expected Ptr<cv::saliency::Saliency> for argument '%s'", info.name); |  | 91080 | failmsg("Expected Ptr<cv::saliency::Saliency> for argument '%s'", info.name);
| 91129 | return false; |  | 91081 | return false;
| 91130 | } |  | 91082 | }
| 91131 | }; |  | 91083 | };
| 91132 |  |  | 91084 |
| 91133 | //================================================================================ |  | 91085 | //================================================================================
| 91134 | // saliency_StaticSaliency (Generic) |  | 91086 | // saliency_StaticSaliency (Generic)
| 91135 | //================================================================================ |  | 91087 | //================================================================================
| 91136 |  |  | 91088 |
| 91137 | // GetSet (saliency_StaticSaliency) |  | 91089 | // GetSet (saliency_StaticSaliency)
| 91138 |  |  | 91090 |
| 91139 |  |  | 91091 |
| 91140 |  |  | 91092 |
| 91141 | // Methods (saliency_StaticSaliency) |  | 91093 | // Methods (saliency_StaticSaliency)
| 91142 |  |  | 91094 |
| 91143 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliency_computeBinaryMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91095 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliency_computeBinaryMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 91144 | { |  | 91096 | {
| 91145 | using namespace cv::saliency; |  | 91097 | using namespace cv::saliency;
| 91146 |  |  | 91098 |
| 91147 |  |  | 91099 |
| 91148 | Ptr<cv::saliency::StaticSaliency> * self1 = 0; |  | 91100 | Ptr<cv::saliency::StaticSaliency> * self1 = 0;
| 91149 | if (!pyopencv_saliency_StaticSaliency_getp(self, self1)) |  | 91101 | if (!pyopencv_saliency_StaticSaliency_getp(self, self1))
| 91150 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliency' or its derivative)"); |  | 91102 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliency' or its derivative)");
| 91151 | Ptr<cv::saliency::StaticSaliency> _self_ = *(self1); |  | 91103 | Ptr<cv::saliency::StaticSaliency> _self_ = *(self1);
| 91152 | pyPrepareArgumentConversionErrorsStorage(2); |  | 91104 | pyPrepareArgumentConversionErrorsStorage(2);
| 91153 |  |  | 91105 |
| 91154 | { |  | 91106 | {
| 91155 | PyObject* pyobj__saliencyMap = NULL; |  | 91107 | PyObject* pyobj__saliencyMap = NULL;
| 91156 | Mat _saliencyMap; |  | 91108 | Mat _saliencyMap;
| 91157 | PyObject* pyobj__binaryMap = NULL; |  | 91109 | PyObject* pyobj__binaryMap = NULL;
| 91158 | Mat _binaryMap; |  | 91110 | Mat _binaryMap;
| 91159 | bool retval; |  | 91111 | bool retval;
| 91160 |  |  | 91112 |
| 91161 | const char* keywords[] = { "_saliencyMap", "_binaryMap", NULL }; |  | 91113 | const char* keywords[] = { "_saliencyMap", "_binaryMap", NULL };
| 91162 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliency.computeBinaryMap", (char**)keywords, &pyobj__saliencyMap, &pyobj__binaryMap) && |  | 91114 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliency.computeBinaryMap", (char**)keywords, &pyobj__saliencyMap, &pyobj__binaryMap) &&
| 91163 | pyopencv_to_safe(pyobj__saliencyMap, _saliencyMap, ArgInfo("_saliencyMap", 0)) && |  | 91115 | pyopencv_to_safe(pyobj__saliencyMap, _saliencyMap, ArgInfo("_saliencyMap", 0)) &&
| 91164 | pyopencv_to_safe(pyobj__binaryMap, _binaryMap, ArgInfo("_binaryMap", 1)) ) |  | 91116 | pyopencv_to_safe(pyobj__binaryMap, _binaryMap, ArgInfo("_binaryMap", 1)) )
| 91165 | { |  | 91117 | {
| 91166 | ERRWRAP2(retval = _self_->computeBinaryMap(_saliencyMap, _binaryMap)); |  | 91118 | ERRWRAP2(retval = _self_->computeBinaryMap(_saliencyMap, _binaryMap));
| 91167 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(_binaryMap)); |  | 91119 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(_binaryMap));
| 91168 | } |  | 91120 | }
| 91169 |  |  | 91121 |
| 91170 |  |  | 91122 |
| 91171 | pyPopulateArgumentConversionErrors(); |  | 91123 | pyPopulateArgumentConversionErrors();
| 91172 | } |  | 91124 | }
| 91173 |  |  | 91125 |
| 91174 |  |  | 91126 |
| 91175 | { |  | 91127 | {
| 91176 | PyObject* pyobj__saliencyMap = NULL; |  | 91128 | PyObject* pyobj__saliencyMap = NULL;
| 91177 | UMat _saliencyMap; |  | 91129 | UMat _saliencyMap;
| 91178 | PyObject* pyobj__binaryMap = NULL; |  | 91130 | PyObject* pyobj__binaryMap = NULL;
| 91179 | UMat _binaryMap; |  | 91131 | UMat _binaryMap;
| 91180 | bool retval; |  | 91132 | bool retval;
| 91181 |  |  | 91133 |
| 91182 | const char* keywords[] = { "_saliencyMap", "_binaryMap", NULL }; |  | 91134 | const char* keywords[] = { "_saliencyMap", "_binaryMap", NULL };
| 91183 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliency.computeBinaryMap", (char**)keywords, &pyobj__saliencyMap, &pyobj__binaryMap) && |  | 91135 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliency.computeBinaryMap", (char**)keywords, &pyobj__saliencyMap, &pyobj__binaryMap) &&
| 91184 | pyopencv_to_safe(pyobj__saliencyMap, _saliencyMap, ArgInfo("_saliencyMap", 0)) && |  | 91136 | pyopencv_to_safe(pyobj__saliencyMap, _saliencyMap, ArgInfo("_saliencyMap", 0)) &&
| 91185 | pyopencv_to_safe(pyobj__binaryMap, _binaryMap, ArgInfo("_binaryMap", 1)) ) |  | 91137 | pyopencv_to_safe(pyobj__binaryMap, _binaryMap, ArgInfo("_binaryMap", 1)) )
| 91186 | { |  | 91138 | {
| 91187 | ERRWRAP2(retval = _self_->computeBinaryMap(_saliencyMap, _binaryMap)); |  | 91139 | ERRWRAP2(retval = _self_->computeBinaryMap(_saliencyMap, _binaryMap));
| 91188 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(_binaryMap)); |  | 91140 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(_binaryMap));
| 91189 | } |  | 91141 | }
| 91190 |  |  | 91142 |
| 91191 |  |  | 91143 |
| 91192 | pyPopulateArgumentConversionErrors(); |  | 91144 | pyPopulateArgumentConversionErrors();
| 91193 | } |  | 91145 | }
| 91194 | pyRaiseCVOverloadException("computeBinaryMap"); |  | 91146 | pyRaiseCVOverloadException("computeBinaryMap");
| 91195 |  |  | 91147 |
| 91196 | return NULL; |  | 91148 | return NULL;
| 91197 | } |  | 91149 | }
| 91198 |  |  | 91150 |
| 91199 |  |  | 91151 |
| 91200 |  |  | 91152 |
| 91201 | // Tables (saliency_StaticSaliency) |  | 91153 | // Tables (saliency_StaticSaliency)
| 91202 |  |  | 91154 |
| 91203 | static PyGetSetDef pyopencv_saliency_StaticSaliency_getseters[] = |  | 91155 | static PyGetSetDef pyopencv_saliency_StaticSaliency_getseters[] =
| 91204 | { |  | 91156 | {
| 91205 | {NULL} /* Sentinel */ |  | 91157 | {NULL} /* Sentinel */
| 91206 | }; |  | 91158 | };
| 91207 |  |  | 91159 |
| 91208 | static PyMethodDef pyopencv_saliency_StaticSaliency_methods[] = |  | 91160 | static PyMethodDef pyopencv_saliency_StaticSaliency_methods[] =
| 91209 | { |  | 91161 | {
| 91210 | {"computeBinaryMap", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliency_computeBinaryMap, 0), "computeBinaryMap(_saliencyMap[, _binaryMap]) -> retval, _binaryMap\n. @brief This function perform a binary map of given saliency map. This is obtained in this\n. way:\n. \n. In a first step, to improve the definition of interest areas and facilitate identification of\n. targets, a segmentation by clustering is performed, using *K-means algorithm*. Then, to gain a\n. binary representation of clustered saliency map, since values of the map can vary according to\n. the characteristics of frame under analysis, it is not convenient to use a fixed threshold. So,\n. *Otsu's algorithm* is used, which assumes that the image to be thresholded contains two classes\n. of pixels or bi-modal histograms (e.g. foreground and back-ground pixels); later on, the\n. algorithm calculates the optimal threshold separating those two classes, so that their\n. intra-class variance is minimal.\n. \n. @param _saliencyMap the saliency map obtained through one of the specialized algorithms\n. @param _binaryMap the binary map"}, |  | 91162 | {"computeBinaryMap", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliency_computeBinaryMap, 0), "computeBinaryMap(_saliencyMap[, _binaryMap]) -> retval, _binaryMap\n. @brief This function perform a binary map of given saliency map. This is obtained in this\n. way:\n. \n. In a first step, to improve the definition of interest areas and facilitate identification of\n. targets, a segmentation by clustering is performed, using *K-means algorithm*. Then, to gain a\n. binary representation of clustered saliency map, since values of the map can vary according to\n. the characteristics of frame under analysis, it is not convenient to use a fixed threshold. So,\n. *Otsu's algorithm* is used, which assumes that the image to be thresholded contains two classes\n. of pixels or bi-modal histograms (e.g. foreground and back-ground pixels); later on, the\n. algorithm calculates the optimal threshold separating those two classes, so that their\n. intra-class variance is minimal.\n. \n. @param _saliencyMap the saliency map obtained through one of the specialized algorithms\n. @param _binaryMap the binary map"},
| 91211 |  |  | 91163 |
| 91212 | {NULL, NULL} |  | 91164 | {NULL, NULL}
| 91213 | }; |  | 91165 | };
| 91214 |  |  | 91166 |
| 91215 | // Converter (saliency_StaticSaliency) |  | 91167 | // Converter (saliency_StaticSaliency)
| 91216 |  |  | 91168 |
| 91217 | template<> |  | 91169 | template<>
| 91218 | struct PyOpenCV_Converter< Ptr<cv::saliency::StaticSaliency> > |  | 91170 | struct PyOpenCV_Converter< Ptr<cv::saliency::StaticSaliency> >
| 91219 | { |  | 91171 | {
| 91220 | static PyObject* from(const Ptr<cv::saliency::StaticSaliency>& r) |  | 91172 | static PyObject* from(const Ptr<cv::saliency::StaticSaliency>& r)
| 91221 | { |  | 91173 | {
| 91222 | return pyopencv_saliency_StaticSaliency_Instance(r); |  | 91174 | return pyopencv_saliency_StaticSaliency_Instance(r);
| 91223 | } |  | 91175 | }
| 91224 | static bool to(PyObject* src, Ptr<cv::saliency::StaticSaliency>& dst, const ArgInfo& info) |  | 91176 | static bool to(PyObject* src, Ptr<cv::saliency::StaticSaliency>& dst, const ArgInfo& info)
| 91225 | { |  | 91177 | {
| 91226 | if(!src || src == Py_None) |  | 91178 | if(!src || src == Py_None)
| 91227 | return true; |  | 91179 | return true;
| 91228 | Ptr<cv::saliency::StaticSaliency> * dst_; |  | 91180 | Ptr<cv::saliency::StaticSaliency> * dst_;
| 91229 | if (pyopencv_saliency_StaticSaliency_getp(src, dst_)) |  | 91181 | if (pyopencv_saliency_StaticSaliency_getp(src, dst_))
| 91230 | { |  | 91182 | {
| 91231 | dst = *dst_; |  | 91183 | dst = *dst_;
| 91232 | return true; |  | 91184 | return true;
| 91233 | } |  | 91185 | }
| 91234 |  |  | 91186 |
| 91235 | failmsg("Expected Ptr<cv::saliency::StaticSaliency> for argument '%s'", info.name); |  | 91187 | failmsg("Expected Ptr<cv::saliency::StaticSaliency> for argument '%s'", info.name);
| 91236 | return false; |  | 91188 | return false;
| 91237 | } |  | 91189 | }
| 91238 | }; |  | 91190 | };
| 91239 |  |  | 91191 |
| 91240 | //================================================================================ |  | 91192 | //================================================================================
| 91241 | // saliency_StaticSaliencyFineGrained (Generic) |  | 91193 | // saliency_StaticSaliencyFineGrained (Generic)
| 91242 | //================================================================================ |  | 91194 | //================================================================================
| 91243 |  |  | 91195 |
| 91244 | // GetSet (saliency_StaticSaliencyFineGrained) |  | 91196 | // GetSet (saliency_StaticSaliencyFineGrained)
| 91245 |  |  | 91197 |
| 91246 |  |  | 91198 |
| 91247 |  |  | 91199 |
| 91248 | // Methods (saliency_StaticSaliencyFineGrained) |  | 91200 | // Methods (saliency_StaticSaliencyFineGrained)
| 91249 |  |  | 91201 |
| 91250 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91202 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw)
| 91251 | { |  | 91203 | {
| 91252 | using namespace cv::saliency; |  | 91204 | using namespace cv::saliency;
| 91253 |  |  | 91205 |
| 91254 |  |  | 91206 |
| 91255 | Ptr<cv::saliency::StaticSaliencyFineGrained> * self1 = 0; |  | 91207 | Ptr<cv::saliency::StaticSaliencyFineGrained> * self1 = 0;
| 91256 | if (!pyopencv_saliency_StaticSaliencyFineGrained_getp(self, self1)) |  | 91208 | if (!pyopencv_saliency_StaticSaliencyFineGrained_getp(self, self1))
| 91257 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencyFineGrained' or its derivative)"); |  | 91209 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencyFineGrained' or its derivative)");
| 91258 | Ptr<cv::saliency::StaticSaliencyFineGrained> _self_ = *(self1); |  | 91210 | Ptr<cv::saliency::StaticSaliencyFineGrained> _self_ = *(self1);
| 91259 | pyPrepareArgumentConversionErrorsStorage(2); |  | 91211 | pyPrepareArgumentConversionErrorsStorage(2);
| 91260 |  |  | 91212 |
| 91261 | { |  | 91213 | {
| 91262 | PyObject* pyobj_image = NULL; |  | 91214 | PyObject* pyobj_image = NULL;
| 91263 | Mat image; |  | 91215 | Mat image;
| 91264 | PyObject* pyobj_saliencyMap = NULL; |  | 91216 | PyObject* pyobj_saliencyMap = NULL;
| 91265 | Mat saliencyMap; |  | 91217 | Mat saliencyMap;
| 91266 | bool retval; |  | 91218 | bool retval;
| 91267 |  |  | 91219 |
| 91268 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 91220 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 91269 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencyFineGrained.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 91221 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencyFineGrained.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 91270 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 91222 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 91271 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 91223 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 91272 | { |  | 91224 | {
| 91273 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 91225 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 91274 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 91226 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 91275 | } |  | 91227 | }
| 91276 |  |  | 91228 |
| 91277 |  |  | 91229 |
| 91278 | pyPopulateArgumentConversionErrors(); |  | 91230 | pyPopulateArgumentConversionErrors();
| 91279 | } |  | 91231 | }
| 91280 |  |  | 91232 |
| 91281 |  |  | 91233 |
| 91282 | { |  | 91234 | {
| 91283 | PyObject* pyobj_image = NULL; |  | 91235 | PyObject* pyobj_image = NULL;
| 91284 | UMat image; |  | 91236 | UMat image;
| 91285 | PyObject* pyobj_saliencyMap = NULL; |  | 91237 | PyObject* pyobj_saliencyMap = NULL;
| 91286 | UMat saliencyMap; |  | 91238 | UMat saliencyMap;
| 91287 | bool retval; |  | 91239 | bool retval;
| 91288 |  |  | 91240 |
| 91289 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 91241 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 91290 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencyFineGrained.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 91242 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencyFineGrained.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 91291 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 91243 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 91292 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 91244 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 91293 | { |  | 91245 | {
| 91294 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 91246 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 91295 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 91247 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 91296 | } |  | 91248 | }
| 91297 |  |  | 91249 |
| 91298 |  |  | 91250 |
| 91299 | pyPopulateArgumentConversionErrors(); |  | 91251 | pyPopulateArgumentConversionErrors();
| 91300 | } |  | 91252 | }
| 91301 | pyRaiseCVOverloadException("computeSaliency"); |  | 91253 | pyRaiseCVOverloadException("computeSaliency");
| 91302 |  |  | 91254 |
| 91303 | return NULL; |  | 91255 | return NULL;
| 91304 | } |  | 91256 | }
| 91305 |  |  | 91257 |
| 91306 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91258 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 91307 | { |  | 91259 | {
| 91308 | using namespace cv::saliency; |  | 91260 | using namespace cv::saliency;
| 91309 |  |  | 91261 |
| 91310 | Ptr<StaticSaliencyFineGrained> retval; |  | 91262 | Ptr<StaticSaliencyFineGrained> retval;
| 91311 |  |  | 91263 |
| 91312 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 91264 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 91313 | { |  | 91265 | {
| 91314 | ERRWRAP2(retval = cv::saliency::StaticSaliencyFineGrained::create()); |  | 91266 | ERRWRAP2(retval = cv::saliency::StaticSaliencyFineGrained::create());
| 91315 | return pyopencv_from(retval); |  | 91267 | return pyopencv_from(retval);
| 91316 | } |  | 91268 | }
| 91317 |  |  | 91269 |
| 91318 | return NULL; |  | 91270 | return NULL;
| 91319 | } |  | 91271 | }
| 91320 |  |  | 91272 |
| 91321 |  |  | 91273 |
| 91322 |  |  | 91274 |
| 91323 | // Tables (saliency_StaticSaliencyFineGrained) |  | 91275 | // Tables (saliency_StaticSaliencyFineGrained)
| 91324 |  |  | 91276 |
| 91325 | static PyGetSetDef pyopencv_saliency_StaticSaliencyFineGrained_getseters[] = |  | 91277 | static PyGetSetDef pyopencv_saliency_StaticSaliencyFineGrained_getseters[] =
| 91326 | { |  | 91278 | {
| 91327 | {NULL} /* Sentinel */ |  | 91279 | {NULL} /* Sentinel */
| 91328 | }; |  | 91280 | };
| 91329 |  |  | 91281 |
| 91330 | static PyMethodDef pyopencv_saliency_StaticSaliencyFineGrained_methods[] = |  | 91282 | static PyMethodDef pyopencv_saliency_StaticSaliencyFineGrained_methods[] =
| 91331 | { |  | 91283 | {
| 91332 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."}, |  | 91284 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."},
| 91333 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_create_static, METH_STATIC), "create() -> retval\n."}, |  | 91285 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencyFineGrained_create_static, METH_STATIC), "create() -> retval\n."},
| 91334 |  |  | 91286 |
| 91335 | {NULL, NULL} |  | 91287 | {NULL, NULL}
| 91336 | }; |  | 91288 | };
| 91337 |  |  | 91289 |
| 91338 | // Converter (saliency_StaticSaliencyFineGrained) |  | 91290 | // Converter (saliency_StaticSaliencyFineGrained)
| 91339 |  |  | 91291 |
| 91340 | template<> |  | 91292 | template<>
| 91341 | struct PyOpenCV_Converter< Ptr<cv::saliency::StaticSaliencyFineGrained> > |  | 91293 | struct PyOpenCV_Converter< Ptr<cv::saliency::StaticSaliencyFineGrained> >
| 91342 | { |  | 91294 | {
| 91343 | static PyObject* from(const Ptr<cv::saliency::StaticSaliencyFineGrained>& r) |  | 91295 | static PyObject* from(const Ptr<cv::saliency::StaticSaliencyFineGrained>& r)
| 91344 | { |  | 91296 | {
| 91345 | return pyopencv_saliency_StaticSaliencyFineGrained_Instance(r); |  | 91297 | return pyopencv_saliency_StaticSaliencyFineGrained_Instance(r);
| 91346 | } |  | 91298 | }
| 91347 | static bool to(PyObject* src, Ptr<cv::saliency::StaticSaliencyFineGrained>& dst, const ArgInfo& info) |  | 91299 | static bool to(PyObject* src, Ptr<cv::saliency::StaticSaliencyFineGrained>& dst, const ArgInfo& info)
| 91348 | { |  | 91300 | {
| 91349 | if(!src || src == Py_None) |  | 91301 | if(!src || src == Py_None)
| 91350 | return true; |  | 91302 | return true;
| 91351 | Ptr<cv::saliency::StaticSaliencyFineGrained> * dst_; |  | 91303 | Ptr<cv::saliency::StaticSaliencyFineGrained> * dst_;
| 91352 | if (pyopencv_saliency_StaticSaliencyFineGrained_getp(src, dst_)) |  | 91304 | if (pyopencv_saliency_StaticSaliencyFineGrained_getp(src, dst_))
| 91353 | { |  | 91305 | {
| 91354 | dst = *dst_; |  | 91306 | dst = *dst_;
| 91355 | return true; |  | 91307 | return true;
| 91356 | } |  | 91308 | }
| 91357 |  |  | 91309 |
| 91358 | failmsg("Expected Ptr<cv::saliency::StaticSaliencyFineGrained> for argument '%s'", info.name); |  | 91310 | failmsg("Expected Ptr<cv::saliency::StaticSaliencyFineGrained> for argument '%s'", info.name);
| 91359 | return false; |  | 91311 | return false;
| 91360 | } |  | 91312 | }
| 91361 | }; |  | 91313 | };
| 91362 |  |  | 91314 |
| 91363 | //================================================================================ |  | 91315 | //================================================================================
| 91364 | // saliency_StaticSaliencySpectralResidual (Generic) |  | 91316 | // saliency_StaticSaliencySpectralResidual (Generic)
| 91365 | //================================================================================ |  | 91317 | //================================================================================
| 91366 |  |  | 91318 |
| 91367 | // GetSet (saliency_StaticSaliencySpectralResidual) |  | 91319 | // GetSet (saliency_StaticSaliencySpectralResidual)
| 91368 |  |  | 91320 |
| 91369 |  |  | 91321 |
| 91370 |  |  | 91322 |
| 91371 | // Methods (saliency_StaticSaliencySpectralResidual) |  | 91323 | // Methods (saliency_StaticSaliencySpectralResidual)
| 91372 |  |  | 91324 |
| 91373 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91325 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_computeSaliency(PyObject* self, PyObject* py_args, PyObject* kw)
| 91374 | { |  | 91326 | {
| 91375 | using namespace cv::saliency; |  | 91327 | using namespace cv::saliency;
| 91376 |  |  | 91328 |
| 91377 |  |  | 91329 |
| 91378 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0; |  | 91330 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0;
| 91379 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1)) |  | 91331 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1))
| 91380 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)"); |  | 91332 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)");
| 91381 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1); |  | 91333 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1);
| 91382 | pyPrepareArgumentConversionErrorsStorage(2); |  | 91334 | pyPrepareArgumentConversionErrorsStorage(2);
| 91383 |  |  | 91335 |
| 91384 | { |  | 91336 | {
| 91385 | PyObject* pyobj_image = NULL; |  | 91337 | PyObject* pyobj_image = NULL;
| 91386 | Mat image; |  | 91338 | Mat image;
| 91387 | PyObject* pyobj_saliencyMap = NULL; |  | 91339 | PyObject* pyobj_saliencyMap = NULL;
| 91388 | Mat saliencyMap; |  | 91340 | Mat saliencyMap;
| 91389 | bool retval; |  | 91341 | bool retval;
| 91390 |  |  | 91342 |
| 91391 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 91343 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 91392 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencySpectralResidual.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 91344 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencySpectralResidual.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 91393 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 91345 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 91394 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 91346 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 91395 | { |  | 91347 | {
| 91396 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 91348 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 91397 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 91349 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 91398 | } |  | 91350 | }
| 91399 |  |  | 91351 |
| 91400 |  |  | 91352 |
| 91401 | pyPopulateArgumentConversionErrors(); |  | 91353 | pyPopulateArgumentConversionErrors();
| 91402 | } |  | 91354 | }
| 91403 |  |  | 91355 |
| 91404 |  |  | 91356 |
| 91405 | { |  | 91357 | {
| 91406 | PyObject* pyobj_image = NULL; |  | 91358 | PyObject* pyobj_image = NULL;
| 91407 | UMat image; |  | 91359 | UMat image;
| 91408 | PyObject* pyobj_saliencyMap = NULL; |  | 91360 | PyObject* pyobj_saliencyMap = NULL;
| 91409 | UMat saliencyMap; |  | 91361 | UMat saliencyMap;
| 91410 | bool retval; |  | 91362 | bool retval;
| 91411 |  |  | 91363 |
| 91412 | const char* keywords[] = { "image", "saliencyMap", NULL }; |  | 91364 | const char* keywords[] = { "image", "saliencyMap", NULL };
| 91413 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencySpectralResidual.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) && |  | 91365 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:saliency_StaticSaliencySpectralResidual.computeSaliency", (char**)keywords, &pyobj_image, &pyobj_saliencyMap) &&
| 91414 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) && |  | 91366 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) &&
| 91415 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) ) |  | 91367 | pyopencv_to_safe(pyobj_saliencyMap, saliencyMap, ArgInfo("saliencyMap", 1)) )
| 91416 | { |  | 91368 | {
| 91417 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap)); |  | 91369 | ERRWRAP2(retval = _self_->computeSaliency(image, saliencyMap));
| 91418 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap)); |  | 91370 | return Py_BuildValue("(NN)", pyopencv_from(retval), pyopencv_from(saliencyMap));
| 91419 | } |  | 91371 | }
| 91420 |  |  | 91372 |
| 91421 |  |  | 91373 |
| 91422 | pyPopulateArgumentConversionErrors(); |  | 91374 | pyPopulateArgumentConversionErrors();
| 91423 | } |  | 91375 | }
| 91424 | pyRaiseCVOverloadException("computeSaliency"); |  | 91376 | pyRaiseCVOverloadException("computeSaliency");
| 91425 |  |  | 91377 |
| 91426 | return NULL; |  | 91378 | return NULL;
| 91427 | } |  | 91379 | }
| 91428 |  |  | 91380 |
| 91429 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91381 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 91430 | { |  | 91382 | {
| 91431 | using namespace cv::saliency; |  | 91383 | using namespace cv::saliency;
| 91432 |  |  | 91384 |
| 91433 | Ptr<StaticSaliencySpectralResidual> retval; |  | 91385 | Ptr<StaticSaliencySpectralResidual> retval;
| 91434 |  |  | 91386 |
| 91435 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 91387 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 91436 | { |  | 91388 | {
| 91437 | ERRWRAP2(retval = cv::saliency::StaticSaliencySpectralResidual::create()); |  | 91389 | ERRWRAP2(retval = cv::saliency::StaticSaliencySpectralResidual::create());
| 91438 | return pyopencv_from(retval); |  | 91390 | return pyopencv_from(retval);
| 91439 | } |  | 91391 | }
| 91440 |  |  | 91392 |
| 91441 | return NULL; |  | 91393 | return NULL;
| 91442 | } |  | 91394 | }
| 91443 |  |  | 91395 |
| 91444 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageHeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91396 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageHeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 91445 | { |  | 91397 | {
| 91446 | using namespace cv::saliency; |  | 91398 | using namespace cv::saliency;
| 91447 |  |  | 91399 |
| 91448 |  |  | 91400 |
| 91449 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0; |  | 91401 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0;
| 91450 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1)) |  | 91402 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1))
| 91451 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)"); |  | 91403 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)");
| 91452 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1); |  | 91404 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1);
| 91453 | int retval; |  | 91405 | int retval;
| 91454 |  |  | 91406 |
| 91455 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 91407 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 91456 | { |  | 91408 | {
| 91457 | ERRWRAP2(retval = _self_->getImageHeight()); |  | 91409 | ERRWRAP2(retval = _self_->getImageHeight());
| 91458 | return pyopencv_from(retval); |  | 91410 | return pyopencv_from(retval);
| 91459 | } |  | 91411 | }
| 91460 |  |  | 91412 |
| 91461 | return NULL; |  | 91413 | return NULL;
| 91462 | } |  | 91414 | }
| 91463 |  |  | 91415 |
| 91464 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91416 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 91465 | { |  | 91417 | {
| 91466 | using namespace cv::saliency; |  | 91418 | using namespace cv::saliency;
| 91467 |  |  | 91419 |
| 91468 |  |  | 91420 |
| 91469 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0; |  | 91421 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0;
| 91470 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1)) |  | 91422 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1))
| 91471 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)"); |  | 91423 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)");
| 91472 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1); |  | 91424 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1);
| 91473 | int retval; |  | 91425 | int retval;
| 91474 |  |  | 91426 |
| 91475 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 91427 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 91476 | { |  | 91428 | {
| 91477 | ERRWRAP2(retval = _self_->getImageWidth()); |  | 91429 | ERRWRAP2(retval = _self_->getImageWidth());
| 91478 | return pyopencv_from(retval); |  | 91430 | return pyopencv_from(retval);
| 91479 | } |  | 91431 | }
| 91480 |  |  | 91432 |
| 91481 | return NULL; |  | 91433 | return NULL;
| 91482 | } |  | 91434 | }
| 91483 |  |  | 91435 |
| 91484 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_read(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91436 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_read(PyObject* self, PyObject* py_args, PyObject* kw)
| 91485 | { |  | 91437 | {
| 91486 | using namespace cv::saliency; |  | 91438 | using namespace cv::saliency;
| 91487 |  |  | 91439 |
| 91488 |  |  | 91440 |
| 91489 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0; |  | 91441 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0;
| 91490 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1)) |  | 91442 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1))
| 91491 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)"); |  | 91443 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)");
| 91492 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1); |  | 91444 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1);
| 91493 | PyObject* pyobj_fn = NULL; |  | 91445 | PyObject* pyobj_fn = NULL;
| 91494 | cv::FileNode fn; |  | 91446 | cv::FileNode fn;
| 91495 |  |  | 91447 |
| 91496 | const char* keywords[] = { "fn", NULL }; |  | 91448 | const char* keywords[] = { "fn", NULL };
| 91497 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_StaticSaliencySpectralResidual.read", (char**)keywords, &pyobj_fn) && |  | 91449 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_StaticSaliencySpectralResidual.read", (char**)keywords, &pyobj_fn) &&
| 91498 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) ) |  | 91450 | pyopencv_to_safe(pyobj_fn, fn, ArgInfo("fn", 0)) )
| 91499 | { |  | 91451 | {
| 91500 | ERRWRAP2(_self_->read(fn)); |  | 91452 | ERRWRAP2(_self_->read(fn));
| 91501 | Py_RETURN_NONE; |  | 91453 | Py_RETURN_NONE;
| 91502 | } |  | 91454 | }
| 91503 |  |  | 91455 |
| 91504 | return NULL; |  | 91456 | return NULL;
| 91505 | } |  | 91457 | }
| 91506 |  |  | 91458 |
| 91507 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageHeight(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91459 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageHeight(PyObject* self, PyObject* py_args, PyObject* kw)
| 91508 | { |  | 91460 | {
| 91509 | using namespace cv::saliency; |  | 91461 | using namespace cv::saliency;
| 91510 |  |  | 91462 |
| 91511 |  |  | 91463 |
| 91512 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0; |  | 91464 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0;
| 91513 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1)) |  | 91465 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1))
| 91514 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)"); |  | 91466 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)");
| 91515 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1); |  | 91467 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1);
| 91516 | PyObject* pyobj_val = NULL; |  | 91468 | PyObject* pyobj_val = NULL;
| 91517 | int val=0; |  | 91469 | int val=0;
| 91518 |  |  | 91470 |
| 91519 | const char* keywords[] = { "val", NULL }; |  | 91471 | const char* keywords[] = { "val", NULL };
| 91520 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_StaticSaliencySpectralResidual.setImageHeight", (char**)keywords, &pyobj_val) && |  | 91472 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_StaticSaliencySpectralResidual.setImageHeight", (char**)keywords, &pyobj_val) &&
| 91521 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 91473 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 91522 | { |  | 91474 | {
| 91523 | ERRWRAP2(_self_->setImageHeight(val)); |  | 91475 | ERRWRAP2(_self_->setImageHeight(val));
| 91524 | Py_RETURN_NONE; |  | 91476 | Py_RETURN_NONE;
| 91525 | } |  | 91477 | }
| 91526 |  |  | 91478 |
| 91527 | return NULL; |  | 91479 | return NULL;
| 91528 | } |  | 91480 | }
| 91529 |  |  | 91481 |
| 91530 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageWidth(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91482 | static PyObject* pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageWidth(PyObject* self, PyObject* py_args, PyObject* kw)
| 91531 | { |  | 91483 | {
| 91532 | using namespace cv::saliency; |  | 91484 | using namespace cv::saliency;
| 91533 |  |  | 91485 |
| 91534 |  |  | 91486 |
| 91535 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0; |  | 91487 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * self1 = 0;
| 91536 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1)) |  | 91488 | if (!pyopencv_saliency_StaticSaliencySpectralResidual_getp(self, self1))
| 91537 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)"); |  | 91489 | return failmsgp("Incorrect type of self (must be 'saliency_StaticSaliencySpectralResidual' or its derivative)");
| 91538 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1); |  | 91490 | Ptr<cv::saliency::StaticSaliencySpectralResidual> _self_ = *(self1);
| 91539 | PyObject* pyobj_val = NULL; |  | 91491 | PyObject* pyobj_val = NULL;
| 91540 | int val=0; |  | 91492 | int val=0;
| 91541 |  |  | 91493 |
| 91542 | const char* keywords[] = { "val", NULL }; |  | 91494 | const char* keywords[] = { "val", NULL };
| 91543 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_StaticSaliencySpectralResidual.setImageWidth", (char**)keywords, &pyobj_val) && |  | 91495 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:saliency_StaticSaliencySpectralResidual.setImageWidth", (char**)keywords, &pyobj_val) &&
| 91544 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) ) |  | 91496 | pyopencv_to_safe(pyobj_val, val, ArgInfo("val", 0)) )
| 91545 | { |  | 91497 | {
| 91546 | ERRWRAP2(_self_->setImageWidth(val)); |  | 91498 | ERRWRAP2(_self_->setImageWidth(val));
| 91547 | Py_RETURN_NONE; |  | 91499 | Py_RETURN_NONE;
| 91548 | } |  | 91500 | }
| 91549 |  |  | 91501 |
| 91550 | return NULL; |  | 91502 | return NULL;
| 91551 | } |  | 91503 | }
| 91552 |  |  | 91504 |
| 91553 |  |  | 91505 |
| 91554 |  |  | 91506 |
| 91555 | // Tables (saliency_StaticSaliencySpectralResidual) |  | 91507 | // Tables (saliency_StaticSaliencySpectralResidual)
| 91556 |  |  | 91508 |
| 91557 | static PyGetSetDef pyopencv_saliency_StaticSaliencySpectralResidual_getseters[] = |  | 91509 | static PyGetSetDef pyopencv_saliency_StaticSaliencySpectralResidual_getseters[] =
| 91558 | { |  | 91510 | {
| 91559 | {NULL} /* Sentinel */ |  | 91511 | {NULL} /* Sentinel */
| 91560 | }; |  | 91512 | };
| 91561 |  |  | 91513 |
| 91562 | static PyMethodDef pyopencv_saliency_StaticSaliencySpectralResidual_methods[] = |  | 91514 | static PyMethodDef pyopencv_saliency_StaticSaliencySpectralResidual_methods[] =
| 91563 | { |  | 91515 | {
| 91564 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."}, |  | 91516 | {"computeSaliency", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_computeSaliency, 0), "computeSaliency(image[, saliencyMap]) -> retval, saliencyMap\n."},
| 91565 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_create_static, METH_STATIC), "create() -> retval\n."}, |  | 91517 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_create_static, METH_STATIC), "create() -> retval\n."},
| 91566 | {"getImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageHeight, 0), "getImageHeight() -> retval\n."}, |  | 91518 | {"getImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageHeight, 0), "getImageHeight() -> retval\n."},
| 91567 | {"getImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageWidth, 0), "getImageWidth() -> retval\n."}, |  | 91519 | {"getImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_getImageWidth, 0), "getImageWidth() -> retval\n."},
| 91568 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_read, 0), "read(fn) -> None\n."}, |  | 91520 | {"read", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_read, 0), "read(fn) -> None\n."},
| 91569 | {"setImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageHeight, 0), "setImageHeight(val) -> None\n."}, |  | 91521 | {"setImageHeight", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageHeight, 0), "setImageHeight(val) -> None\n."},
| 91570 | {"setImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageWidth, 0), "setImageWidth(val) -> None\n."}, |  | 91522 | {"setImageWidth", CV_PY_FN_WITH_KW_(pyopencv_cv_saliency_saliency_StaticSaliencySpectralResidual_setImageWidth, 0), "setImageWidth(val) -> None\n."},
| 91571 |  |  | 91523 |
| 91572 | {NULL, NULL} |  | 91524 | {NULL, NULL}
| 91573 | }; |  | 91525 | };
| 91574 |  |  | 91526 |
| 91575 | // Converter (saliency_StaticSaliencySpectralResidual) |  | 91527 | // Converter (saliency_StaticSaliencySpectralResidual)
| 91576 |  |  | 91528 |
| 91577 | template<> |  | 91529 | template<>
| 91578 | struct PyOpenCV_Converter< Ptr<cv::saliency::StaticSaliencySpectralResidual> > |  | 91530 | struct PyOpenCV_Converter< Ptr<cv::saliency::StaticSaliencySpectralResidual> >
| 91579 | { |  | 91531 | {
| 91580 | static PyObject* from(const Ptr<cv::saliency::StaticSaliencySpectralResidual>& r) |  | 91532 | static PyObject* from(const Ptr<cv::saliency::StaticSaliencySpectralResidual>& r)
| 91581 | { |  | 91533 | {
| 91582 | return pyopencv_saliency_StaticSaliencySpectralResidual_Instance(r); |  | 91534 | return pyopencv_saliency_StaticSaliencySpectralResidual_Instance(r);
| 91583 | } |  | 91535 | }
| 91584 | static bool to(PyObject* src, Ptr<cv::saliency::StaticSaliencySpectralResidual>& dst, const ArgInfo& info) |  | 91536 | static bool to(PyObject* src, Ptr<cv::saliency::StaticSaliencySpectralResidual>& dst, const ArgInfo& info)
| 91585 | { |  | 91537 | {
| 91586 | if(!src || src == Py_None) |  | 91538 | if(!src || src == Py_None)
| 91587 | return true; |  | 91539 | return true;
| 91588 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * dst_; |  | 91540 | Ptr<cv::saliency::StaticSaliencySpectralResidual> * dst_;
| 91589 | if (pyopencv_saliency_StaticSaliencySpectralResidual_getp(src, dst_)) |  | 91541 | if (pyopencv_saliency_StaticSaliencySpectralResidual_getp(src, dst_))
| 91590 | { |  | 91542 | {
| 91591 | dst = *dst_; |  | 91543 | dst = *dst_;
| 91592 | return true; |  | 91544 | return true;
| 91593 | } |  | 91545 | }
| 91594 |  |  | 91546 |
| 91595 | failmsg("Expected Ptr<cv::saliency::StaticSaliencySpectralResidual> for argument '%s'", info.name); |  | 91547 | failmsg("Expected Ptr<cv::saliency::StaticSaliencySpectralResidual> for argument '%s'", info.name);
| 91596 | return false; |  | 91548 | return false;
| 91597 | } |  | 91549 | }
| 91598 | }; |  | 91550 | };
| 91599 |  |  | 91551 |
| 91600 | //================================================================================ |  | 91552 | //================================================================================
| 91601 | // segmentation_IntelligentScissorsMB (Generic) |  | 91553 | // segmentation_IntelligentScissorsMB (Generic)
| 91602 | //================================================================================ |  | 91554 | //================================================================================
| 91603 |  |  | 91555 |
| 91604 | // GetSet (segmentation_IntelligentScissorsMB) |  | 91556 | // GetSet (segmentation_IntelligentScissorsMB)
| 91605 |  |  | 91557 |
| 91606 |  |  | 91558 |
| 91607 |  |  | 91559 |
| 91608 | // Methods (segmentation_IntelligentScissorsMB) |  | 91560 | // Methods (segmentation_IntelligentScissorsMB)
| 91609 |  |  | 91561 |
| 91610 | static int pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_IntelligentScissorsMB(pyopencv_segmentation_IntelligentScissorsMB_t* self, PyObject* py_args, PyObject* kw) |  | 91562 | static int pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_IntelligentScissorsMB(pyopencv_segmentation_IntelligentScissorsMB_t* self, PyObject* py_args, PyObject* kw)
| 91611 | { |  | 91563 | {
| 91612 | using namespace cv::segmentation; |  | 91564 | using namespace cv::segmentation;
| 91613 |  |  | 91565 |
| 91614 |  |  | 91566 |
| 91615 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 91567 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 91616 | { |  | 91568 | {
| 91617 | if(self) ERRWRAP2(new (&(self->v)) cv::segmentation::IntelligentScissorsMB()); |  | 91569 | if(self) ERRWRAP2(new (&(self->v)) cv::segmentation::IntelligentScissorsMB());
| 91618 | return 0; |  | 91570 | return 0;
| 91619 | } |  | 91571 | }
| 91620 |  |  | 91572 |
| 91621 | return -1; |  | 91573 | return -1;
| 91622 | } |  | 91574 | }
| 91623 |  |  | 91575 |
| 91624 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImage(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91576 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImage(PyObject* self, PyObject* py_args, PyObject* kw)
| 91625 | { |  | 91577 | {
| 91626 | using namespace cv::segmentation; |  | 91578 | using namespace cv::segmentation;
| 91627 |  |  | 91579 |
| 91628 |  |  | 91580 |
| 91629 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91581 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91630 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91582 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91631 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91583 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91632 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91584 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91633 | pyPrepareArgumentConversionErrorsStorage(2); |  | 91585 | pyPrepareArgumentConversionErrorsStorage(2);
| 91634 |  |  | 91586 |
| 91635 | { |  | 91587 | {
| 91636 | PyObject* pyobj_image = NULL; |  | 91588 | PyObject* pyobj_image = NULL;
| 91637 | Mat image; |  | 91589 | Mat image;
| 91638 | IntelligentScissorsMB retval; |  | 91590 | IntelligentScissorsMB retval;
| 91639 |  |  | 91591 |
| 91640 | const char* keywords[] = { "image", NULL }; |  | 91592 | const char* keywords[] = { "image", NULL };
| 91641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:segmentation_IntelligentScissorsMB.applyImage", (char**)keywords, &pyobj_image) && |  | 91593 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:segmentation_IntelligentScissorsMB.applyImage", (char**)keywords, &pyobj_image) &&
| 91642 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 91594 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 91643 | { |  | 91595 | {
| 91644 | ERRWRAP2(retval = _self_->applyImage(image)); |  | 91596 | ERRWRAP2(retval = _self_->applyImage(image));
| 91645 | return pyopencv_from(retval); |  | 91597 | return pyopencv_from(retval);
| 91646 | } |  | 91598 | }
| 91647 |  |  | 91599 |
| 91648 |  |  | 91600 |
| 91649 | pyPopulateArgumentConversionErrors(); |  | 91601 | pyPopulateArgumentConversionErrors();
| 91650 | } |  | 91602 | }
| 91651 |  |  | 91603 |
| 91652 |  |  | 91604 |
| 91653 | { |  | 91605 | {
| 91654 | PyObject* pyobj_image = NULL; |  | 91606 | PyObject* pyobj_image = NULL;
| 91655 | UMat image; |  | 91607 | UMat image;
| 91656 | IntelligentScissorsMB retval; |  | 91608 | IntelligentScissorsMB retval;
| 91657 |  |  | 91609 |
| 91658 | const char* keywords[] = { "image", NULL }; |  | 91610 | const char* keywords[] = { "image", NULL };
| 91659 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:segmentation_IntelligentScissorsMB.applyImage", (char**)keywords, &pyobj_image) && |  | 91611 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:segmentation_IntelligentScissorsMB.applyImage", (char**)keywords, &pyobj_image) &&
| 91660 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 91612 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 91661 | { |  | 91613 | {
| 91662 | ERRWRAP2(retval = _self_->applyImage(image)); |  | 91614 | ERRWRAP2(retval = _self_->applyImage(image));
| 91663 | return pyopencv_from(retval); |  | 91615 | return pyopencv_from(retval);
| 91664 | } |  | 91616 | }
| 91665 |  |  | 91617 |
| 91666 |  |  | 91618 |
| 91667 | pyPopulateArgumentConversionErrors(); |  | 91619 | pyPopulateArgumentConversionErrors();
| 91668 | } |  | 91620 | }
| 91669 | pyRaiseCVOverloadException("applyImage"); |  | 91621 | pyRaiseCVOverloadException("applyImage");
| 91670 |  |  | 91622 |
| 91671 | return NULL; |  | 91623 | return NULL;
| 91672 | } |  | 91624 | }
| 91673 |  |  | 91625 |
| 91674 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImageFeatures(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91626 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImageFeatures(PyObject* self, PyObject* py_args, PyObject* kw)
| 91675 | { |  | 91627 | {
| 91676 | using namespace cv::segmentation; |  | 91628 | using namespace cv::segmentation;
| 91677 |  |  | 91629 |
| 91678 |  |  | 91630 |
| 91679 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91631 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91680 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91632 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91681 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91633 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91682 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91634 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91683 | pyPrepareArgumentConversionErrorsStorage(2); |  | 91635 | pyPrepareArgumentConversionErrorsStorage(2);
| 91684 |  |  | 91636 |
| 91685 | { |  | 91637 | {
| 91686 | PyObject* pyobj_non_edge = NULL; |  | 91638 | PyObject* pyobj_non_edge = NULL;
| 91687 | Mat non_edge; |  | 91639 | Mat non_edge;
| 91688 | PyObject* pyobj_gradient_direction = NULL; |  | 91640 | PyObject* pyobj_gradient_direction = NULL;
| 91689 | Mat gradient_direction; |  | 91641 | Mat gradient_direction;
| 91690 | PyObject* pyobj_gradient_magnitude = NULL; |  | 91642 | PyObject* pyobj_gradient_magnitude = NULL;
| 91691 | Mat gradient_magnitude; |  | 91643 | Mat gradient_magnitude;
| 91692 | PyObject* pyobj_image = NULL; |  | 91644 | PyObject* pyobj_image = NULL;
| 91693 | Mat image; |  | 91645 | Mat image;
| 91694 | IntelligentScissorsMB retval; |  | 91646 | IntelligentScissorsMB retval;
| 91695 |  |  | 91647 |
| 91696 | const char* keywords[] = { "non_edge", "gradient_direction", "gradient_magnitude", "image", NULL }; |  | 91648 | const char* keywords[] = { "non_edge", "gradient_direction", "gradient_magnitude", "image", NULL };
| 91697 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:segmentation_IntelligentScissorsMB.applyImageFeatures", (char**)keywords, &pyobj_non_edge, &pyobj_gradient_direction, &pyobj_gradient_magnitude, &pyobj_image) && |  | 91649 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:segmentation_IntelligentScissorsMB.applyImageFeatures", (char**)keywords, &pyobj_non_edge, &pyobj_gradient_direction, &pyobj_gradient_magnitude, &pyobj_image) &&
| 91698 | pyopencv_to_safe(pyobj_non_edge, non_edge, ArgInfo("non_edge", 0)) && |  | 91650 | pyopencv_to_safe(pyobj_non_edge, non_edge, ArgInfo("non_edge", 0)) &&
| 91699 | pyopencv_to_safe(pyobj_gradient_direction, gradient_direction, ArgInfo("gradient_direction", 0)) && |  | 91651 | pyopencv_to_safe(pyobj_gradient_direction, gradient_direction, ArgInfo("gradient_direction", 0)) &&
| 91700 | pyopencv_to_safe(pyobj_gradient_magnitude, gradient_magnitude, ArgInfo("gradient_magnitude", 0)) && |  | 91652 | pyopencv_to_safe(pyobj_gradient_magnitude, gradient_magnitude, ArgInfo("gradient_magnitude", 0)) &&
| 91701 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 91653 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 91702 | { |  | 91654 | {
| 91703 | ERRWRAP2(retval = _self_->applyImageFeatures(non_edge, gradient_direction, gradient_magnitude, image)); |  | 91655 | ERRWRAP2(retval = _self_->applyImageFeatures(non_edge, gradient_direction, gradient_magnitude, image));
| 91704 | return pyopencv_from(retval); |  | 91656 | return pyopencv_from(retval);
| 91705 | } |  | 91657 | }
| 91706 |  |  | 91658 |
| 91707 |  |  | 91659 |
| 91708 | pyPopulateArgumentConversionErrors(); |  | 91660 | pyPopulateArgumentConversionErrors();
| 91709 | } |  | 91661 | }
| 91710 |  |  | 91662 |
| 91711 |  |  | 91663 |
| 91712 | { |  | 91664 | {
| 91713 | PyObject* pyobj_non_edge = NULL; |  | 91665 | PyObject* pyobj_non_edge = NULL;
| 91714 | UMat non_edge; |  | 91666 | UMat non_edge;
| 91715 | PyObject* pyobj_gradient_direction = NULL; |  | 91667 | PyObject* pyobj_gradient_direction = NULL;
| 91716 | UMat gradient_direction; |  | 91668 | UMat gradient_direction;
| 91717 | PyObject* pyobj_gradient_magnitude = NULL; |  | 91669 | PyObject* pyobj_gradient_magnitude = NULL;
| 91718 | UMat gradient_magnitude; |  | 91670 | UMat gradient_magnitude;
| 91719 | PyObject* pyobj_image = NULL; |  | 91671 | PyObject* pyobj_image = NULL;
| 91720 | UMat image; |  | 91672 | UMat image;
| 91721 | IntelligentScissorsMB retval; |  | 91673 | IntelligentScissorsMB retval;
| 91722 |  |  | 91674 |
| 91723 | const char* keywords[] = { "non_edge", "gradient_direction", "gradient_magnitude", "image", NULL }; |  | 91675 | const char* keywords[] = { "non_edge", "gradient_direction", "gradient_magnitude", "image", NULL };
| 91724 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:segmentation_IntelligentScissorsMB.applyImageFeatures", (char**)keywords, &pyobj_non_edge, &pyobj_gradient_direction, &pyobj_gradient_magnitude, &pyobj_image) && |  | 91676 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO|O:segmentation_IntelligentScissorsMB.applyImageFeatures", (char**)keywords, &pyobj_non_edge, &pyobj_gradient_direction, &pyobj_gradient_magnitude, &pyobj_image) &&
| 91725 | pyopencv_to_safe(pyobj_non_edge, non_edge, ArgInfo("non_edge", 0)) && |  | 91677 | pyopencv_to_safe(pyobj_non_edge, non_edge, ArgInfo("non_edge", 0)) &&
| 91726 | pyopencv_to_safe(pyobj_gradient_direction, gradient_direction, ArgInfo("gradient_direction", 0)) && |  | 91678 | pyopencv_to_safe(pyobj_gradient_direction, gradient_direction, ArgInfo("gradient_direction", 0)) &&
| 91727 | pyopencv_to_safe(pyobj_gradient_magnitude, gradient_magnitude, ArgInfo("gradient_magnitude", 0)) && |  | 91679 | pyopencv_to_safe(pyobj_gradient_magnitude, gradient_magnitude, ArgInfo("gradient_magnitude", 0)) &&
| 91728 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) ) |  | 91680 | pyopencv_to_safe(pyobj_image, image, ArgInfo("image", 0)) )
| 91729 | { |  | 91681 | {
| 91730 | ERRWRAP2(retval = _self_->applyImageFeatures(non_edge, gradient_direction, gradient_magnitude, image)); |  | 91682 | ERRWRAP2(retval = _self_->applyImageFeatures(non_edge, gradient_direction, gradient_magnitude, image));
| 91731 | return pyopencv_from(retval); |  | 91683 | return pyopencv_from(retval);
| 91732 | } |  | 91684 | }
| 91733 |  |  | 91685 |
| 91734 |  |  | 91686 |
| 91735 | pyPopulateArgumentConversionErrors(); |  | 91687 | pyPopulateArgumentConversionErrors();
| 91736 | } |  | 91688 | }
| 91737 | pyRaiseCVOverloadException("applyImageFeatures"); |  | 91689 | pyRaiseCVOverloadException("applyImageFeatures");
| 91738 |  |  | 91690 |
| 91739 | return NULL; |  | 91691 | return NULL;
| 91740 | } |  | 91692 | }
| 91741 |  |  | 91693 |
| 91742 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_buildMap(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91694 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_buildMap(PyObject* self, PyObject* py_args, PyObject* kw)
| 91743 | { |  | 91695 | {
| 91744 | using namespace cv::segmentation; |  | 91696 | using namespace cv::segmentation;
| 91745 |  |  | 91697 |
| 91746 |  |  | 91698 |
| 91747 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91699 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91748 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91700 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91749 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91701 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91750 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91702 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91751 | PyObject* pyobj_sourcePt = NULL; |  | 91703 | PyObject* pyobj_sourcePt = NULL;
| 91752 | Point sourcePt; |  | 91704 | Point sourcePt;
| 91753 |  |  | 91705 |
| 91754 | const char* keywords[] = { "sourcePt", NULL }; |  | 91706 | const char* keywords[] = { "sourcePt", NULL };
| 91755 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:segmentation_IntelligentScissorsMB.buildMap", (char**)keywords, &pyobj_sourcePt) && |  | 91707 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:segmentation_IntelligentScissorsMB.buildMap", (char**)keywords, &pyobj_sourcePt) &&
| 91756 | pyopencv_to_safe(pyobj_sourcePt, sourcePt, ArgInfo("sourcePt", 0)) ) |  | 91708 | pyopencv_to_safe(pyobj_sourcePt, sourcePt, ArgInfo("sourcePt", 0)) )
| 91757 | { |  | 91709 | {
| 91758 | ERRWRAP2(_self_->buildMap(sourcePt)); |  | 91710 | ERRWRAP2(_self_->buildMap(sourcePt));
| 91759 | Py_RETURN_NONE; |  | 91711 | Py_RETURN_NONE;
| 91760 | } |  | 91712 | }
| 91761 |  |  | 91713 |
| 91762 | return NULL; |  | 91714 | return NULL;
| 91763 | } |  | 91715 | }
| 91764 |  |  | 91716 |
| 91765 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_getContour(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91717 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_getContour(PyObject* self, PyObject* py_args, PyObject* kw)
| 91766 | { |  | 91718 | {
| 91767 | using namespace cv::segmentation; |  | 91719 | using namespace cv::segmentation;
| 91768 |  |  | 91720 |
| 91769 |  |  | 91721 |
| 91770 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91722 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91771 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91723 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91772 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91724 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91773 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91725 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91774 | pyPrepareArgumentConversionErrorsStorage(2); |  | 91726 | pyPrepareArgumentConversionErrorsStorage(2);
| 91775 |  |  | 91727 |
| 91776 | { |  | 91728 | {
| 91777 | PyObject* pyobj_targetPt = NULL; |  | 91729 | PyObject* pyobj_targetPt = NULL;
| 91778 | Point targetPt; |  | 91730 | Point targetPt;
| 91779 | PyObject* pyobj_contour = NULL; |  | 91731 | PyObject* pyobj_contour = NULL;
| 91780 | Mat contour; |  | 91732 | Mat contour;
| 91781 | PyObject* pyobj_backward = NULL; |  | 91733 | PyObject* pyobj_backward = NULL;
| 91782 | bool backward=false; |  | 91734 | bool backward=false;
| 91783 |  |  | 91735 |
| 91784 | const char* keywords[] = { "targetPt", "contour", "backward", NULL }; |  | 91736 | const char* keywords[] = { "targetPt", "contour", "backward", NULL };
| 91785 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:segmentation_IntelligentScissorsMB.getContour", (char**)keywords, &pyobj_targetPt, &pyobj_contour, &pyobj_backward) && |  | 91737 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:segmentation_IntelligentScissorsMB.getContour", (char**)keywords, &pyobj_targetPt, &pyobj_contour, &pyobj_backward) &&
| 91786 | pyopencv_to_safe(pyobj_targetPt, targetPt, ArgInfo("targetPt", 0)) && |  | 91738 | pyopencv_to_safe(pyobj_targetPt, targetPt, ArgInfo("targetPt", 0)) &&
| 91787 | pyopencv_to_safe(pyobj_contour, contour, ArgInfo("contour", 1)) && |  | 91739 | pyopencv_to_safe(pyobj_contour, contour, ArgInfo("contour", 1)) &&
| 91788 | pyopencv_to_safe(pyobj_backward, backward, ArgInfo("backward", 0)) ) |  | 91740 | pyopencv_to_safe(pyobj_backward, backward, ArgInfo("backward", 0)) )
| 91789 | { |  | 91741 | {
| 91790 | ERRWRAP2(_self_->getContour(targetPt, contour, backward)); |  | 91742 | ERRWRAP2(_self_->getContour(targetPt, contour, backward));
| 91791 | return pyopencv_from(contour); |  | 91743 | return pyopencv_from(contour);
| 91792 | } |  | 91744 | }
| 91793 |  |  | 91745 |
| 91794 |  |  | 91746 |
| 91795 | pyPopulateArgumentConversionErrors(); |  | 91747 | pyPopulateArgumentConversionErrors();
| 91796 | } |  | 91748 | }
| 91797 |  |  | 91749 |
| 91798 |  |  | 91750 |
| 91799 | { |  | 91751 | {
| 91800 | PyObject* pyobj_targetPt = NULL; |  | 91752 | PyObject* pyobj_targetPt = NULL;
| 91801 | Point targetPt; |  | 91753 | Point targetPt;
| 91802 | PyObject* pyobj_contour = NULL; |  | 91754 | PyObject* pyobj_contour = NULL;
| 91803 | UMat contour; |  | 91755 | UMat contour;
| 91804 | PyObject* pyobj_backward = NULL; |  | 91756 | PyObject* pyobj_backward = NULL;
| 91805 | bool backward=false; |  | 91757 | bool backward=false;
| 91806 |  |  | 91758 |
| 91807 | const char* keywords[] = { "targetPt", "contour", "backward", NULL }; |  | 91759 | const char* keywords[] = { "targetPt", "contour", "backward", NULL };
| 91808 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:segmentation_IntelligentScissorsMB.getContour", (char**)keywords, &pyobj_targetPt, &pyobj_contour, &pyobj_backward) && |  | 91760 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|OO:segmentation_IntelligentScissorsMB.getContour", (char**)keywords, &pyobj_targetPt, &pyobj_contour, &pyobj_backward) &&
| 91809 | pyopencv_to_safe(pyobj_targetPt, targetPt, ArgInfo("targetPt", 0)) && |  | 91761 | pyopencv_to_safe(pyobj_targetPt, targetPt, ArgInfo("targetPt", 0)) &&
| 91810 | pyopencv_to_safe(pyobj_contour, contour, ArgInfo("contour", 1)) && |  | 91762 | pyopencv_to_safe(pyobj_contour, contour, ArgInfo("contour", 1)) &&
| 91811 | pyopencv_to_safe(pyobj_backward, backward, ArgInfo("backward", 0)) ) |  | 91763 | pyopencv_to_safe(pyobj_backward, backward, ArgInfo("backward", 0)) )
| 91812 | { |  | 91764 | {
| 91813 | ERRWRAP2(_self_->getContour(targetPt, contour, backward)); |  | 91765 | ERRWRAP2(_self_->getContour(targetPt, contour, backward));
| 91814 | return pyopencv_from(contour); |  | 91766 | return pyopencv_from(contour);
| 91815 | } |  | 91767 | }
| 91816 |  |  | 91768 |
| 91817 |  |  | 91769 |
| 91818 | pyPopulateArgumentConversionErrors(); |  | 91770 | pyPopulateArgumentConversionErrors();
| 91819 | } |  | 91771 | }
| 91820 | pyRaiseCVOverloadException("getContour"); |  | 91772 | pyRaiseCVOverloadException("getContour");
| 91821 |  |  | 91773 |
| 91822 | return NULL; |  | 91774 | return NULL;
| 91823 | } |  | 91775 | }
| 91824 |  |  | 91776 |
| 91825 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureCannyParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91777 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureCannyParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 91826 | { |  | 91778 | {
| 91827 | using namespace cv::segmentation; |  | 91779 | using namespace cv::segmentation;
| 91828 |  |  | 91780 |
| 91829 |  |  | 91781 |
| 91830 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91782 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91831 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91783 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91832 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91784 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91833 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91785 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91834 | PyObject* pyobj_threshold1 = NULL; |  | 91786 | PyObject* pyobj_threshold1 = NULL;
| 91835 | double threshold1=0; |  | 91787 | double threshold1=0;
| 91836 | PyObject* pyobj_threshold2 = NULL; |  | 91788 | PyObject* pyobj_threshold2 = NULL;
| 91837 | double threshold2=0; |  | 91789 | double threshold2=0;
| 91838 | PyObject* pyobj_apertureSize = NULL; |  | 91790 | PyObject* pyobj_apertureSize = NULL;
| 91839 | int apertureSize=3; |  | 91791 | int apertureSize=3;
| 91840 | PyObject* pyobj_L2gradient = NULL; |  | 91792 | PyObject* pyobj_L2gradient = NULL;
| 91841 | bool L2gradient=false; |  | 91793 | bool L2gradient=false;
| 91842 | IntelligentScissorsMB retval; |  | 91794 | IntelligentScissorsMB retval;
| 91843 |  |  | 91795 |
| 91844 | const char* keywords[] = { "threshold1", "threshold2", "apertureSize", "L2gradient", NULL }; |  | 91796 | const char* keywords[] = { "threshold1", "threshold2", "apertureSize", "L2gradient", NULL };
| 91845 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:segmentation_IntelligentScissorsMB.setEdgeFeatureCannyParameters", (char**)keywords, &pyobj_threshold1, &pyobj_threshold2, &pyobj_apertureSize, &pyobj_L2gradient) && |  | 91797 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO|OO:segmentation_IntelligentScissorsMB.setEdgeFeatureCannyParameters", (char**)keywords, &pyobj_threshold1, &pyobj_threshold2, &pyobj_apertureSize, &pyobj_L2gradient) &&
| 91846 | pyopencv_to_safe(pyobj_threshold1, threshold1, ArgInfo("threshold1", 0)) && |  | 91798 | pyopencv_to_safe(pyobj_threshold1, threshold1, ArgInfo("threshold1", 0)) &&
| 91847 | pyopencv_to_safe(pyobj_threshold2, threshold2, ArgInfo("threshold2", 0)) && |  | 91799 | pyopencv_to_safe(pyobj_threshold2, threshold2, ArgInfo("threshold2", 0)) &&
| 91848 | pyopencv_to_safe(pyobj_apertureSize, apertureSize, ArgInfo("apertureSize", 0)) && |  | 91800 | pyopencv_to_safe(pyobj_apertureSize, apertureSize, ArgInfo("apertureSize", 0)) &&
| 91849 | pyopencv_to_safe(pyobj_L2gradient, L2gradient, ArgInfo("L2gradient", 0)) ) |  | 91801 | pyopencv_to_safe(pyobj_L2gradient, L2gradient, ArgInfo("L2gradient", 0)) )
| 91850 | { |  | 91802 | {
| 91851 | ERRWRAP2(retval = _self_->setEdgeFeatureCannyParameters(threshold1, threshold2, apertureSize, L2gradient)); |  | 91803 | ERRWRAP2(retval = _self_->setEdgeFeatureCannyParameters(threshold1, threshold2, apertureSize, L2gradient));
| 91852 | return pyopencv_from(retval); |  | 91804 | return pyopencv_from(retval);
| 91853 | } |  | 91805 | }
| 91854 |  |  | 91806 |
| 91855 | return NULL; |  | 91807 | return NULL;
| 91856 | } |  | 91808 | }
| 91857 |  |  | 91809 |
| 91858 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureZeroCrossingParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91810 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureZeroCrossingParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 91859 | { |  | 91811 | {
| 91860 | using namespace cv::segmentation; |  | 91812 | using namespace cv::segmentation;
| 91861 |  |  | 91813 |
| 91862 |  |  | 91814 |
| 91863 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91815 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91864 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91816 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91865 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91817 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91866 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91818 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91867 | PyObject* pyobj_gradient_magnitude_min_value = NULL; |  | 91819 | PyObject* pyobj_gradient_magnitude_min_value = NULL;
| 91868 | float gradient_magnitude_min_value=0.0f; |  | 91820 | float gradient_magnitude_min_value=0.0f;
| 91869 | IntelligentScissorsMB retval; |  | 91821 | IntelligentScissorsMB retval;
| 91870 |  |  | 91822 |
| 91871 | const char* keywords[] = { "gradient_magnitude_min_value", NULL }; |  | 91823 | const char* keywords[] = { "gradient_magnitude_min_value", NULL };
| 91872 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:segmentation_IntelligentScissorsMB.setEdgeFeatureZeroCrossingParameters", (char**)keywords, &pyobj_gradient_magnitude_min_value) && |  | 91824 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:segmentation_IntelligentScissorsMB.setEdgeFeatureZeroCrossingParameters", (char**)keywords, &pyobj_gradient_magnitude_min_value) &&
| 91873 | pyopencv_to_safe(pyobj_gradient_magnitude_min_value, gradient_magnitude_min_value, ArgInfo("gradient_magnitude_min_value", 0)) ) |  | 91825 | pyopencv_to_safe(pyobj_gradient_magnitude_min_value, gradient_magnitude_min_value, ArgInfo("gradient_magnitude_min_value", 0)) )
| 91874 | { |  | 91826 | {
| 91875 | ERRWRAP2(retval = _self_->setEdgeFeatureZeroCrossingParameters(gradient_magnitude_min_value)); |  | 91827 | ERRWRAP2(retval = _self_->setEdgeFeatureZeroCrossingParameters(gradient_magnitude_min_value));
| 91876 | return pyopencv_from(retval); |  | 91828 | return pyopencv_from(retval);
| 91877 | } |  | 91829 | }
| 91878 |  |  | 91830 |
| 91879 | return NULL; |  | 91831 | return NULL;
| 91880 | } |  | 91832 | }
| 91881 |  |  | 91833 |
| 91882 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setGradientMagnitudeMaxLimit(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91834 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setGradientMagnitudeMaxLimit(PyObject* self, PyObject* py_args, PyObject* kw)
| 91883 | { |  | 91835 | {
| 91884 | using namespace cv::segmentation; |  | 91836 | using namespace cv::segmentation;
| 91885 |  |  | 91837 |
| 91886 |  |  | 91838 |
| 91887 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91839 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91888 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91840 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91889 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91841 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91890 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91842 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91891 | PyObject* pyobj_gradient_magnitude_threshold_max = NULL; |  | 91843 | PyObject* pyobj_gradient_magnitude_threshold_max = NULL;
| 91892 | float gradient_magnitude_threshold_max=0.0f; |  | 91844 | float gradient_magnitude_threshold_max=0.0f;
| 91893 | IntelligentScissorsMB retval; |  | 91845 | IntelligentScissorsMB retval;
| 91894 |  |  | 91846 |
| 91895 | const char* keywords[] = { "gradient_magnitude_threshold_max", NULL }; |  | 91847 | const char* keywords[] = { "gradient_magnitude_threshold_max", NULL };
| 91896 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:segmentation_IntelligentScissorsMB.setGradientMagnitudeMaxLimit", (char**)keywords, &pyobj_gradient_magnitude_threshold_max) && |  | 91848 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "|O:segmentation_IntelligentScissorsMB.setGradientMagnitudeMaxLimit", (char**)keywords, &pyobj_gradient_magnitude_threshold_max) &&
| 91897 | pyopencv_to_safe(pyobj_gradient_magnitude_threshold_max, gradient_magnitude_threshold_max, ArgInfo("gradient_magnitude_threshold_max", 0)) ) |  | 91849 | pyopencv_to_safe(pyobj_gradient_magnitude_threshold_max, gradient_magnitude_threshold_max, ArgInfo("gradient_magnitude_threshold_max", 0)) )
| 91898 | { |  | 91850 | {
| 91899 | ERRWRAP2(retval = _self_->setGradientMagnitudeMaxLimit(gradient_magnitude_threshold_max)); |  | 91851 | ERRWRAP2(retval = _self_->setGradientMagnitudeMaxLimit(gradient_magnitude_threshold_max));
| 91900 | return pyopencv_from(retval); |  | 91852 | return pyopencv_from(retval);
| 91901 | } |  | 91853 | }
| 91902 |  |  | 91854 |
| 91903 | return NULL; |  | 91855 | return NULL;
| 91904 | } |  | 91856 | }
| 91905 |  |  | 91857 |
| 91906 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setWeights(PyObject* self, PyObject* py_args, PyObject* kw) |  | 91858 | static PyObject* pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setWeights(PyObject* self, PyObject* py_args, PyObject* kw)
| 91907 | { |  | 91859 | {
| 91908 | using namespace cv::segmentation; |  | 91860 | using namespace cv::segmentation;
| 91909 |  |  | 91861 |
| 91910 |  |  | 91862 |
| 91911 | cv::segmentation::IntelligentScissorsMB * self1 = 0; |  | 91863 | cv::segmentation::IntelligentScissorsMB * self1 = 0;
| 91912 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1)) |  | 91864 | if (!pyopencv_segmentation_IntelligentScissorsMB_getp(self, self1))
| 91913 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)"); |  | 91865 | return failmsgp("Incorrect type of self (must be 'segmentation_IntelligentScissorsMB' or its derivative)");
| 91914 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1); |  | 91866 | cv::segmentation::IntelligentScissorsMB* _self_ = (self1);
| 91915 | PyObject* pyobj_weight_non_edge = NULL; |  | 91867 | PyObject* pyobj_weight_non_edge = NULL;
| 91916 | float weight_non_edge=0.f; |  | 91868 | float weight_non_edge=0.f;
| 91917 | PyObject* pyobj_weight_gradient_direction = NULL; |  | 91869 | PyObject* pyobj_weight_gradient_direction = NULL;
| 91918 | float weight_gradient_direction=0.f; |  | 91870 | float weight_gradient_direction=0.f;
| 91919 | PyObject* pyobj_weight_gradient_magnitude = NULL; |  | 91871 | PyObject* pyobj_weight_gradient_magnitude = NULL;
| 91920 | float weight_gradient_magnitude=0.f; |  | 91872 | float weight_gradient_magnitude=0.f;
| 91921 | IntelligentScissorsMB retval; |  | 91873 | IntelligentScissorsMB retval;
| 91922 |  |  | 91874 |
| 91923 | const char* keywords[] = { "weight_non_edge", "weight_gradient_direction", "weight_gradient_magnitude", NULL }; |  | 91875 | const char* keywords[] = { "weight_non_edge", "weight_gradient_direction", "weight_gradient_magnitude", NULL };
| 91924 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:segmentation_IntelligentScissorsMB.setWeights", (char**)keywords, &pyobj_weight_non_edge, &pyobj_weight_gradient_direction, &pyobj_weight_gradient_magnitude) && |  | 91876 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OOO:segmentation_IntelligentScissorsMB.setWeights", (char**)keywords, &pyobj_weight_non_edge, &pyobj_weight_gradient_direction, &pyobj_weight_gradient_magnitude) &&
| 91925 | pyopencv_to_safe(pyobj_weight_non_edge, weight_non_edge, ArgInfo("weight_non_edge", 0)) && |  | 91877 | pyopencv_to_safe(pyobj_weight_non_edge, weight_non_edge, ArgInfo("weight_non_edge", 0)) &&
| 91926 | pyopencv_to_safe(pyobj_weight_gradient_direction, weight_gradient_direction, ArgInfo("weight_gradient_direction", 0)) && |  | 91878 | pyopencv_to_safe(pyobj_weight_gradient_direction, weight_gradient_direction, ArgInfo("weight_gradient_direction", 0)) &&
| 91927 | pyopencv_to_safe(pyobj_weight_gradient_magnitude, weight_gradient_magnitude, ArgInfo("weight_gradient_magnitude", 0)) ) |  | 91879 | pyopencv_to_safe(pyobj_weight_gradient_magnitude, weight_gradient_magnitude, ArgInfo("weight_gradient_magnitude", 0)) )
| 91928 | { |  | 91880 | {
| 91929 | ERRWRAP2(retval = _self_->setWeights(weight_non_edge, weight_gradient_direction, weight_gradient_magnitude)); |  | 91881 | ERRWRAP2(retval = _self_->setWeights(weight_non_edge, weight_gradient_direction, weight_gradient_magnitude));
| 91930 | return pyopencv_from(retval); |  | 91882 | return pyopencv_from(retval);
| 91931 | } |  | 91883 | }
| 91932 |  |  | 91884 |
| 91933 | return NULL; |  | 91885 | return NULL;
| 91934 | } |  | 91886 | }
| 91935 |  |  | 91887 |
| 91936 |  |  | 91888 |
| 91937 |  |  | 91889 |
| 91938 | // Tables (segmentation_IntelligentScissorsMB) |  | 91890 | // Tables (segmentation_IntelligentScissorsMB)
| 91939 |  |  | 91891 |
| 91940 | static PyGetSetDef pyopencv_segmentation_IntelligentScissorsMB_getseters[] = |  | 91892 | static PyGetSetDef pyopencv_segmentation_IntelligentScissorsMB_getseters[] =
| 91941 | { |  | 91893 | {
| 91942 | {NULL} /* Sentinel */ |  | 91894 | {NULL} /* Sentinel */
| 91943 | }; |  | 91895 | };
| 91944 |  |  | 91896 |
| 91945 | static PyMethodDef pyopencv_segmentation_IntelligentScissorsMB_methods[] = |  | 91897 | static PyMethodDef pyopencv_segmentation_IntelligentScissorsMB_methods[] =
| 91946 | { |  | 91898 | {
| 91947 | {"applyImage", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImage, 0), "applyImage(image) -> retval\n. @brief Specify input image and extract image features\n. *\n. * @param image input image. Type is #CV_8UC1 / #CV_8UC3"}, |  | 91899 | {"applyImage", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImage, 0), "applyImage(image) -> retval\n. @brief Specify input image and extract image features\n. *\n. * @param image input image. Type is #CV_8UC1 / #CV_8UC3"},
| 91948 | {"applyImageFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImageFeatures, 0), "applyImageFeatures(non_edge, gradient_direction, gradient_magnitude[, image]) -> retval\n. @brief Specify custom features of input image\n. *\n. * Customized advanced variant of applyImage() call.\n. *\n. * @param non_edge Specify cost of non-edge pixels. Type is CV_8UC1. Expected values are `{0, 1}`.\n. * @param gradient_direction Specify gradient direction feature. Type is CV_32FC2. Values are expected to be normalized: `x^2 + y^2 == 1`\n. * @param gradient_magnitude Specify cost of gradient magnitude function: Type is CV_32FC1. Values should be in range `[0, 1]`.\n. * @param image **Optional parameter**. Must be specified if subset of features is specified (non-specified features are calculated internally)"}, |  | 91900 | {"applyImageFeatures", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_applyImageFeatures, 0), "applyImageFeatures(non_edge, gradient_direction, gradient_magnitude[, image]) -> retval\n. @brief Specify custom features of input image\n. *\n. * Customized advanced variant of applyImage() call.\n. *\n. * @param non_edge Specify cost of non-edge pixels. Type is CV_8UC1. Expected values are `{0, 1}`.\n. * @param gradient_direction Specify gradient direction feature. Type is CV_32FC2. Values are expected to be normalized: `x^2 + y^2 == 1`\n. * @param gradient_magnitude Specify cost of gradient magnitude function: Type is CV_32FC1. Values should be in range `[0, 1]`.\n. * @param image **Optional parameter**. Must be specified if subset of features is specified (non-specified features are calculated internally)"},
| 91949 | {"buildMap", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_buildMap, 0), "buildMap(sourcePt) -> None\n. @brief Prepares a map of optimal paths for the given source point on the image\n. *\n. * @note applyImage() / applyImageFeatures() must be called before this call\n. *\n. * @param sourcePt The source point used to find the paths"}, |  | 91901 | {"buildMap", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_buildMap, 0), "buildMap(sourcePt) -> None\n. @brief Prepares a map of optimal paths for the given source point on the image\n. *\n. * @note applyImage() / applyImageFeatures() must be called before this call\n. *\n. * @param sourcePt The source point used to find the paths"},
| 91950 | {"getContour", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_getContour, 0), "getContour(targetPt[, contour[, backward]]) -> contour\n. @brief Extracts optimal contour for the given target point on the image\n. *\n. * @note buildMap() must be called before this call\n. *\n. * @param targetPt The target point\n. * @param[out] contour The list of pixels which contains optimal path between the source and the target points of the image. Type is CV_32SC2 (compatible with `std::vector<Point>`)\n. * @param backward Flag to indicate reverse order of retrieved pixels (use \"true\" value to fetch points from the target to the source point)"}, |  | 91902 | {"getContour", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_getContour, 0), "getContour(targetPt[, contour[, backward]]) -> contour\n. @brief Extracts optimal contour for the given target point on the image\n. *\n. * @note buildMap() must be called before this call\n. *\n. * @param targetPt The target point\n. * @param[out] contour The list of pixels which contains optimal path between the source and the target points of the image. Type is CV_32SC2 (compatible with `std::vector<Point>`)\n. * @param backward Flag to indicate reverse order of retrieved pixels (use \"true\" value to fetch points from the target to the source point)"},
| 91951 | {"setEdgeFeatureCannyParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureCannyParameters, 0), "setEdgeFeatureCannyParameters(threshold1, threshold2[, apertureSize[, L2gradient]]) -> retval\n. @brief Switch edge feature extractor to use Canny edge detector\n. *\n. * @note \"Laplacian Zero-Crossing\" feature extractor is used by default (following to original article)\n. *\n. * @sa Canny"}, |  | 91903 | {"setEdgeFeatureCannyParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureCannyParameters, 0), "setEdgeFeatureCannyParameters(threshold1, threshold2[, apertureSize[, L2gradient]]) -> retval\n. @brief Switch edge feature extractor to use Canny edge detector\n. *\n. * @note \"Laplacian Zero-Crossing\" feature extractor is used by default (following to original article)\n. *\n. * @sa Canny"},
| 91952 | {"setEdgeFeatureZeroCrossingParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureZeroCrossingParameters, 0), "setEdgeFeatureZeroCrossingParameters([, gradient_magnitude_min_value]) -> retval\n. @brief Switch to \"Laplacian Zero-Crossing\" edge feature extractor and specify its parameters\n. *\n. * This feature extractor is used by default according to article.\n. *\n. * Implementation has additional filtering for regions with low-amplitude noise.\n. * This filtering is enabled through parameter of minimal gradient amplitude (use some small value 4, 8, 16).\n. *\n. * @note Current implementation of this feature extractor is based on processing of grayscale images (color image is converted to grayscale image first).\n. *\n. * @note Canny edge detector is a bit slower, but provides better results (especially on color images): use setEdgeFeatureCannyParameters().\n. *\n. * @param gradient_magnitude_min_value Minimal gradient magnitude value for edge pixels (default: 0, check is disabled)"}, |  | 91904 | {"setEdgeFeatureZeroCrossingParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setEdgeFeatureZeroCrossingParameters, 0), "setEdgeFeatureZeroCrossingParameters([, gradient_magnitude_min_value]) -> retval\n. @brief Switch to \"Laplacian Zero-Crossing\" edge feature extractor and specify its parameters\n. *\n. * This feature extractor is used by default according to article.\n. *\n. * Implementation has additional filtering for regions with low-amplitude noise.\n. * This filtering is enabled through parameter of minimal gradient amplitude (use some small value 4, 8, 16).\n. *\n. * @note Current implementation of this feature extractor is based on processing of grayscale images (color image is converted to grayscale image first).\n. *\n. * @note Canny edge detector is a bit slower, but provides better results (especially on color images): use setEdgeFeatureCannyParameters().\n. *\n. * @param gradient_magnitude_min_value Minimal gradient magnitude value for edge pixels (default: 0, check is disabled)"},
| 91953 | {"setGradientMagnitudeMaxLimit", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setGradientMagnitudeMaxLimit, 0), "setGradientMagnitudeMaxLimit([, gradient_magnitude_threshold_max]) -> retval\n. @brief Specify gradient magnitude max value threshold\n. *\n. * Zero limit value is used to disable gradient magnitude thresholding (default behavior, as described in original article).\n. * Otherwize pixels with `gradient magnitude >= threshold` have zero cost.\n. *\n. * @note Thresholding should be used for images with irregular regions (to avoid stuck on parameters from high-contract areas, like embedded logos).\n. *\n. * @param gradient_magnitude_threshold_max Specify gradient magnitude max value threshold (default: 0, disabled)"}, |  | 91905 | {"setGradientMagnitudeMaxLimit", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setGradientMagnitudeMaxLimit, 0), "setGradientMagnitudeMaxLimit([, gradient_magnitude_threshold_max]) -> retval\n. @brief Specify gradient magnitude max value threshold\n. *\n. * Zero limit value is used to disable gradient magnitude thresholding (default behavior, as described in original article).\n. * Otherwize pixels with `gradient magnitude >= threshold` have zero cost.\n. *\n. * @note Thresholding should be used for images with irregular regions (to avoid stuck on parameters from high-contract areas, like embedded logos).\n. *\n. * @param gradient_magnitude_threshold_max Specify gradient magnitude max value threshold (default: 0, disabled)"},
| 91954 | {"setWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setWeights, 0), "setWeights(weight_non_edge, weight_gradient_direction, weight_gradient_magnitude) -> retval\n. @brief Specify weights of feature functions\n. *\n. * Consider keeping weights normalized (sum of weights equals to 1.0)\n. * Discrete dynamic programming (DP) goal is minimization of costs between pixels.\n. *\n. * @param weight_non_edge Specify cost of non-edge pixels (default: 0.43f)\n. * @param weight_gradient_direction Specify cost of gradient direction function (default: 0.43f)\n. * @param weight_gradient_magnitude Specify cost of gradient magnitude function (default: 0.14f)"}, |  | 91906 | {"setWeights", CV_PY_FN_WITH_KW_(pyopencv_cv_segmentation_segmentation_IntelligentScissorsMB_setWeights, 0), "setWeights(weight_non_edge, weight_gradient_direction, weight_gradient_magnitude) -> retval\n. @brief Specify weights of feature functions\n. *\n. * Consider keeping weights normalized (sum of weights equals to 1.0)\n. * Discrete dynamic programming (DP) goal is minimization of costs between pixels.\n. *\n. * @param weight_non_edge Specify cost of non-edge pixels (default: 0.43f)\n. * @param weight_gradient_direction Specify cost of gradient direction function (default: 0.43f)\n. * @param weight_gradient_magnitude Specify cost of gradient magnitude function (default: 0.14f)"},
| 91955 |  |  | 91907 |
| 91956 | {NULL, NULL} |  | 91908 | {NULL, NULL}
| 91957 | }; |  | 91909 | };
| 91958 |  |  | 91910 |
| 91959 | // Converter (segmentation_IntelligentScissorsMB) |  | 91911 | // Converter (segmentation_IntelligentScissorsMB)
| 91960 |  |  | 91912 |
| 91961 | template<> |  | 91913 | template<>
| 91962 | struct PyOpenCV_Converter< cv::segmentation::IntelligentScissorsMB > |  | 91914 | struct PyOpenCV_Converter< cv::segmentation::IntelligentScissorsMB >
| 91963 | { |  | 91915 | {
| 91964 | static PyObject* from(const cv::segmentation::IntelligentScissorsMB& r) |  | 91916 | static PyObject* from(const cv::segmentation::IntelligentScissorsMB& r)
| 91965 | { |  | 91917 | {
| 91966 | return pyopencv_segmentation_IntelligentScissorsMB_Instance(r); |  | 91918 | return pyopencv_segmentation_IntelligentScissorsMB_Instance(r);
| 91967 | } |  | 91919 | }
| 91968 | static bool to(PyObject* src, cv::segmentation::IntelligentScissorsMB& dst, const ArgInfo& info) |  | 91920 | static bool to(PyObject* src, cv::segmentation::IntelligentScissorsMB& dst, const ArgInfo& info)
| 91969 | { |  | 91921 | {
| 91970 | if(!src || src == Py_None) |  | 91922 | if(!src || src == Py_None)
| 91971 | return true; |  | 91923 | return true;
| 91972 | cv::segmentation::IntelligentScissorsMB * dst_; |  | 91924 | cv::segmentation::IntelligentScissorsMB * dst_;
| 91973 | if (pyopencv_segmentation_IntelligentScissorsMB_getp(src, dst_)) |  | 91925 | if (pyopencv_segmentation_IntelligentScissorsMB_getp(src, dst_))
| 91974 | { |  | 91926 | {
| 91975 | dst = *dst_; |  | 91927 | dst = *dst_;
| 91976 | return true; |  | 91928 | return true;
| 91977 | } |  | 91929 | }
| 91978 |  |  | 91930 |
| 91979 | failmsg("Expected cv::segmentation::IntelligentScissorsMB for argument '%s'", info.name); |  | 91931 | failmsg("Expected cv::segmentation::IntelligentScissorsMB for argument '%s'", info.name);
| 91980 | return false; |  | 91932 | return false;
| 91981 | } |  | 91933 | }
| 91982 | }; |  | 91934 | };
| 91983 |  |  | 91935 |
| 91984 | //================================================================================ |  | 91936 | //================================================================================
| 91985 | // stereo_MatchQuasiDense (Generic) |  | 91937 | // stereo_MatchQuasiDense (Generic)
| 91986 | //================================================================================ |  | 91938 | //================================================================================
| 91987 |  |  | 91939 |
| 91988 | // GetSet (stereo_MatchQuasiDense) |  | 91940 | // GetSet (stereo_MatchQuasiDense)
| 91989 |  |  | 91941 |
| 91990 |  |  | 91942 |
| 91991 | static PyObject* pyopencv_stereo_MatchQuasiDense_get_corr(pyopencv_stereo_MatchQuasiDense_t* p, void *closure) |  | 91943 | static PyObject* pyopencv_stereo_MatchQuasiDense_get_corr(pyopencv_stereo_MatchQuasiDense_t* p, void *closure)
| 91992 | { |  | 91944 | {
| 91993 | return pyopencv_from(p->v.corr); |  | 91945 | return pyopencv_from(p->v.corr);
| 91994 | } |  | 91946 | }
| 91995 |  |  | 91947 |
| 91996 | static int pyopencv_stereo_MatchQuasiDense_set_corr(pyopencv_stereo_MatchQuasiDense_t* p, PyObject *value, void *closure) |  | 91948 | static int pyopencv_stereo_MatchQuasiDense_set_corr(pyopencv_stereo_MatchQuasiDense_t* p, PyObject *value, void *closure)
| 91997 | { |  | 91949 | {
| 91998 | if (!value) |  | 91950 | if (!value)
| 91999 | { |  | 91951 | {
| 92000 | PyErr_SetString(PyExc_TypeError, "Cannot delete the corr attribute"); |  | 91952 | PyErr_SetString(PyExc_TypeError, "Cannot delete the corr attribute");
| 92001 | return -1; |  | 91953 | return -1;
| 92002 | } |  | 91954 | }
| 92003 | return pyopencv_to_safe(value, p->v.corr, ArgInfo("value", 0)) ? 0 : -1; |  | 91955 | return pyopencv_to_safe(value, p->v.corr, ArgInfo("value", 0)) ? 0 : -1;
| 92004 | } |  | 91956 | }
| 92005 |  |  | 91957 |
| 92006 | static PyObject* pyopencv_stereo_MatchQuasiDense_get_p0(pyopencv_stereo_MatchQuasiDense_t* p, void *closure) |  | 91958 | static PyObject* pyopencv_stereo_MatchQuasiDense_get_p0(pyopencv_stereo_MatchQuasiDense_t* p, void *closure)
| 92007 | { |  | 91959 | {
| 92008 | return pyopencv_from(p->v.p0); |  | 91960 | return pyopencv_from(p->v.p0);
| 92009 | } |  | 91961 | }
| 92010 |  |  | 91962 |
| 92011 | static int pyopencv_stereo_MatchQuasiDense_set_p0(pyopencv_stereo_MatchQuasiDense_t* p, PyObject *value, void *closure) |  | 91963 | static int pyopencv_stereo_MatchQuasiDense_set_p0(pyopencv_stereo_MatchQuasiDense_t* p, PyObject *value, void *closure)
| 92012 | { |  | 91964 | {
| 92013 | if (!value) |  | 91965 | if (!value)
| 92014 | { |  | 91966 | {
| 92015 | PyErr_SetString(PyExc_TypeError, "Cannot delete the p0 attribute"); |  | 91967 | PyErr_SetString(PyExc_TypeError, "Cannot delete the p0 attribute");
| 92016 | return -1; |  | 91968 | return -1;
| 92017 | } |  | 91969 | }
| 92018 | return pyopencv_to_safe(value, p->v.p0, ArgInfo("value", 0)) ? 0 : -1; |  | 91970 | return pyopencv_to_safe(value, p->v.p0, ArgInfo("value", 0)) ? 0 : -1;
| 92019 | } |  | 91971 | }
| 92020 |  |  | 91972 |
| 92021 | static PyObject* pyopencv_stereo_MatchQuasiDense_get_p1(pyopencv_stereo_MatchQuasiDense_t* p, void *closure) |  | 91973 | static PyObject* pyopencv_stereo_MatchQuasiDense_get_p1(pyopencv_stereo_MatchQuasiDense_t* p, void *closure)
| 92022 | { |  | 91974 | {
| 92023 | return pyopencv_from(p->v.p1); |  | 91975 | return pyopencv_from(p->v.p1);
| 92024 | } |  | 91976 | }
| 92025 |  |  | 91977 |
| 92026 | static int pyopencv_stereo_MatchQuasiDense_set_p1(pyopencv_stereo_MatchQuasiDense_t* p, PyObject *value, void *closure) |  | 91978 | static int pyopencv_stereo_MatchQuasiDense_set_p1(pyopencv_stereo_MatchQuasiDense_t* p, PyObject *value, void *closure)
| 92027 | { |  | 91979 | {
| 92028 | if (!value) |  | 91980 | if (!value)
| 92029 | { |  | 91981 | {
| 92030 | PyErr_SetString(PyExc_TypeError, "Cannot delete the p1 attribute"); |  | 91982 | PyErr_SetString(PyExc_TypeError, "Cannot delete the p1 attribute");
| 92031 | return -1; |  | 91983 | return -1;
| 92032 | } |  | 91984 | }
| 92033 | return pyopencv_to_safe(value, p->v.p1, ArgInfo("value", 0)) ? 0 : -1; |  | 91985 | return pyopencv_to_safe(value, p->v.p1, ArgInfo("value", 0)) ? 0 : -1;
| 92034 | } |  | 91986 | }
| 92035 |  |  | 91987 |
| 92036 |  |  | 91988 |
| 92037 | // Methods (stereo_MatchQuasiDense) |  | 91989 | // Methods (stereo_MatchQuasiDense)
| 92038 |  |  | 91990 |
| 92039 | static int pyopencv_cv_stereo_stereo_MatchQuasiDense_MatchQuasiDense(pyopencv_stereo_MatchQuasiDense_t* self, PyObject* py_args, PyObject* kw) |  | 91991 | static int pyopencv_cv_stereo_stereo_MatchQuasiDense_MatchQuasiDense(pyopencv_stereo_MatchQuasiDense_t* self, PyObject* py_args, PyObject* kw)
| 92040 | { |  | 91992 | {
| 92041 | using namespace cv::stereo; |  | 91993 | using namespace cv::stereo;
| 92042 |  |  | 91994 |
| 92043 |  |  | 91995 |
| 92044 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 91996 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 92045 | { |  | 91997 | {
| 92046 | if(self) ERRWRAP2(new (&(self->v)) cv::stereo::MatchQuasiDense()); |  | 91998 | if(self) ERRWRAP2(new (&(self->v)) cv::stereo::MatchQuasiDense());
| 92047 | return 0; |  | 91999 | return 0;
| 92048 | } |  | 92000 | }
| 92049 |  |  | 92001 |
| 92050 | return -1; |  | 92002 | return -1;
| 92051 | } |  | 92003 | }
| 92052 |  |  | 92004 |
| 92053 | static PyObject* pyopencv_cv_stereo_stereo_MatchQuasiDense_apply(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92005 | static PyObject* pyopencv_cv_stereo_stereo_MatchQuasiDense_apply(PyObject* self, PyObject* py_args, PyObject* kw)
| 92054 | { |  | 92006 | {
| 92055 | using namespace cv::stereo; |  | 92007 | using namespace cv::stereo;
| 92056 |  |  | 92008 |
| 92057 |  |  | 92009 |
| 92058 | cv::stereo::MatchQuasiDense * self1 = 0; |  | 92010 | cv::stereo::MatchQuasiDense * self1 = 0;
| 92059 | if (!pyopencv_stereo_MatchQuasiDense_getp(self, self1)) |  | 92011 | if (!pyopencv_stereo_MatchQuasiDense_getp(self, self1))
| 92060 | return failmsgp("Incorrect type of self (must be 'stereo_MatchQuasiDense' or its derivative)"); |  | 92012 | return failmsgp("Incorrect type of self (must be 'stereo_MatchQuasiDense' or its derivative)");
| 92061 | cv::stereo::MatchQuasiDense* _self_ = (self1); |  | 92013 | cv::stereo::MatchQuasiDense* _self_ = (self1);
| 92062 | PyObject* pyobj_rhs = NULL; |  | 92014 | PyObject* pyobj_rhs = NULL;
| 92063 | MatchQuasiDense rhs; |  | 92015 | MatchQuasiDense rhs;
| 92064 | bool retval; |  | 92016 | bool retval;
| 92065 |  |  | 92017 |
| 92066 | const char* keywords[] = { "rhs", NULL }; |  | 92018 | const char* keywords[] = { "rhs", NULL };
| 92067 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:stereo_MatchQuasiDense.apply", (char**)keywords, &pyobj_rhs) && |  | 92019 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:stereo_MatchQuasiDense.apply", (char**)keywords, &pyobj_rhs) &&
| 92068 | pyopencv_to_safe(pyobj_rhs, rhs, ArgInfo("rhs", 0)) ) |  | 92020 | pyopencv_to_safe(pyobj_rhs, rhs, ArgInfo("rhs", 0)) )
| 92069 | { |  | 92021 | {
| 92070 | ERRWRAP2(retval = _self_->operator <(rhs)); |  | 92022 | ERRWRAP2(retval = _self_->operator <(rhs));
| 92071 | return pyopencv_from(retval); |  | 92023 | return pyopencv_from(retval);
| 92072 | } |  | 92024 | }
| 92073 |  |  | 92025 |
| 92074 | return NULL; |  | 92026 | return NULL;
| 92075 | } |  | 92027 | }
| 92076 |  |  | 92028 |
| 92077 |  |  | 92029 |
| 92078 |  |  | 92030 |
| 92079 | // Tables (stereo_MatchQuasiDense) |  | 92031 | // Tables (stereo_MatchQuasiDense)
| 92080 |  |  | 92032 |
| 92081 | static PyGetSetDef pyopencv_stereo_MatchQuasiDense_getseters[] = |  | 92033 | static PyGetSetDef pyopencv_stereo_MatchQuasiDense_getseters[] =
| 92082 | { |  | 92034 | {
| 92083 | {(char*)"corr", (getter)pyopencv_stereo_MatchQuasiDense_get_corr, (setter)pyopencv_stereo_MatchQuasiDense_set_corr, (char*)"corr", NULL}, |  | 92035 | {(char*)"corr", (getter)pyopencv_stereo_MatchQuasiDense_get_corr, (setter)pyopencv_stereo_MatchQuasiDense_set_corr, (char*)"corr", NULL},
| 92084 | {(char*)"p0", (getter)pyopencv_stereo_MatchQuasiDense_get_p0, (setter)pyopencv_stereo_MatchQuasiDense_set_p0, (char*)"p0", NULL}, |  | 92036 | {(char*)"p0", (getter)pyopencv_stereo_MatchQuasiDense_get_p0, (setter)pyopencv_stereo_MatchQuasiDense_set_p0, (char*)"p0", NULL},
| 92085 | {(char*)"p1", (getter)pyopencv_stereo_MatchQuasiDense_get_p1, (setter)pyopencv_stereo_MatchQuasiDense_set_p1, (char*)"p1", NULL}, |  | 92037 | {(char*)"p1", (getter)pyopencv_stereo_MatchQuasiDense_get_p1, (setter)pyopencv_stereo_MatchQuasiDense_set_p1, (char*)"p1", NULL},
| 92086 | {NULL} /* Sentinel */ |  | 92038 | {NULL} /* Sentinel */
| 92087 | }; |  | 92039 | };
| 92088 |  |  | 92040 |
| 92089 | static PyMethodDef pyopencv_stereo_MatchQuasiDense_methods[] = |  | 92041 | static PyMethodDef pyopencv_stereo_MatchQuasiDense_methods[] =
| 92090 | { |  | 92042 | {
| 92091 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_MatchQuasiDense_apply, 0), "apply(rhs) -> retval\n."}, |  | 92043 | {"apply", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_MatchQuasiDense_apply, 0), "apply(rhs) -> retval\n."},
| 92092 |  |  | 92044 |
| 92093 | {NULL, NULL} |  | 92045 | {NULL, NULL}
| 92094 | }; |  | 92046 | };
| 92095 |  |  | 92047 |
| 92096 | // Converter (stereo_MatchQuasiDense) |  | 92048 | // Converter (stereo_MatchQuasiDense)
| 92097 |  |  | 92049 |
| 92098 | template<> |  | 92050 | template<>
| 92099 | struct PyOpenCV_Converter< cv::stereo::MatchQuasiDense > |  | 92051 | struct PyOpenCV_Converter< cv::stereo::MatchQuasiDense >
| 92100 | { |  | 92052 | {
| 92101 | static PyObject* from(const cv::stereo::MatchQuasiDense& r) |  | 92053 | static PyObject* from(const cv::stereo::MatchQuasiDense& r)
| 92102 | { |  | 92054 | {
| 92103 | return pyopencv_stereo_MatchQuasiDense_Instance(r); |  | 92055 | return pyopencv_stereo_MatchQuasiDense_Instance(r);
| 92104 | } |  | 92056 | }
| 92105 | static bool to(PyObject* src, cv::stereo::MatchQuasiDense& dst, const ArgInfo& info) |  | 92057 | static bool to(PyObject* src, cv::stereo::MatchQuasiDense& dst, const ArgInfo& info)
| 92106 | { |  | 92058 | {
| 92107 | if(!src || src == Py_None) |  | 92059 | if(!src || src == Py_None)
| 92108 | return true; |  | 92060 | return true;
| 92109 | cv::stereo::MatchQuasiDense * dst_; |  | 92061 | cv::stereo::MatchQuasiDense * dst_;
| 92110 | if (pyopencv_stereo_MatchQuasiDense_getp(src, dst_)) |  | 92062 | if (pyopencv_stereo_MatchQuasiDense_getp(src, dst_))
| 92111 | { |  | 92063 | {
| 92112 | dst = *dst_; |  | 92064 | dst = *dst_;
| 92113 | return true; |  | 92065 | return true;
| 92114 | } |  | 92066 | }
| 92115 |  |  | 92067 |
| 92116 | failmsg("Expected cv::stereo::MatchQuasiDense for argument '%s'", info.name); |  | 92068 | failmsg("Expected cv::stereo::MatchQuasiDense for argument '%s'", info.name);
| 92117 | return false; |  | 92069 | return false;
| 92118 | } |  | 92070 | }
| 92119 | }; |  | 92071 | };
| 92120 |  |  | 92072 |
| 92121 | //================================================================================ |  | 92073 | //================================================================================
| 92122 | // stereo_PropagationParameters (Generic) |  | 92074 | // stereo_PropagationParameters (Generic)
| 92123 | //================================================================================ |  | 92075 | //================================================================================
| 92124 |  |  | 92076 |
| 92125 | // GetSet (stereo_PropagationParameters) |  | 92077 | // GetSet (stereo_PropagationParameters)
| 92126 |  |  | 92078 |
| 92127 |  |  | 92079 |
| 92128 | static PyObject* pyopencv_stereo_PropagationParameters_get_borderX(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92080 | static PyObject* pyopencv_stereo_PropagationParameters_get_borderX(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92129 | { |  | 92081 | {
| 92130 | return pyopencv_from(p->v.borderX); |  | 92082 | return pyopencv_from(p->v.borderX);
| 92131 | } |  | 92083 | }
| 92132 |  |  | 92084 |
| 92133 | static int pyopencv_stereo_PropagationParameters_set_borderX(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92085 | static int pyopencv_stereo_PropagationParameters_set_borderX(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92134 | { |  | 92086 | {
| 92135 | if (!value) |  | 92087 | if (!value)
| 92136 | { |  | 92088 | {
| 92137 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderX attribute"); |  | 92089 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderX attribute");
| 92138 | return -1; |  | 92090 | return -1;
| 92139 | } |  | 92091 | }
| 92140 | return pyopencv_to_safe(value, p->v.borderX, ArgInfo("value", 0)) ? 0 : -1; |  | 92092 | return pyopencv_to_safe(value, p->v.borderX, ArgInfo("value", 0)) ? 0 : -1;
| 92141 | } |  | 92093 | }
| 92142 |  |  | 92094 |
| 92143 | static PyObject* pyopencv_stereo_PropagationParameters_get_borderY(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92095 | static PyObject* pyopencv_stereo_PropagationParameters_get_borderY(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92144 | { |  | 92096 | {
| 92145 | return pyopencv_from(p->v.borderY); |  | 92097 | return pyopencv_from(p->v.borderY);
| 92146 | } |  | 92098 | }
| 92147 |  |  | 92099 |
| 92148 | static int pyopencv_stereo_PropagationParameters_set_borderY(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92100 | static int pyopencv_stereo_PropagationParameters_set_borderY(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92149 | { |  | 92101 | {
| 92150 | if (!value) |  | 92102 | if (!value)
| 92151 | { |  | 92103 | {
| 92152 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderY attribute"); |  | 92104 | PyErr_SetString(PyExc_TypeError, "Cannot delete the borderY attribute");
| 92153 | return -1; |  | 92105 | return -1;
| 92154 | } |  | 92106 | }
| 92155 | return pyopencv_to_safe(value, p->v.borderY, ArgInfo("value", 0)) ? 0 : -1; |  | 92107 | return pyopencv_to_safe(value, p->v.borderY, ArgInfo("value", 0)) ? 0 : -1;
| 92156 | } |  | 92108 | }
| 92157 |  |  | 92109 |
| 92158 | static PyObject* pyopencv_stereo_PropagationParameters_get_corrWinSizeX(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92110 | static PyObject* pyopencv_stereo_PropagationParameters_get_corrWinSizeX(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92159 | { |  | 92111 | {
| 92160 | return pyopencv_from(p->v.corrWinSizeX); |  | 92112 | return pyopencv_from(p->v.corrWinSizeX);
| 92161 | } |  | 92113 | }
| 92162 |  |  | 92114 |
| 92163 | static int pyopencv_stereo_PropagationParameters_set_corrWinSizeX(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92115 | static int pyopencv_stereo_PropagationParameters_set_corrWinSizeX(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92164 | { |  | 92116 | {
| 92165 | if (!value) |  | 92117 | if (!value)
| 92166 | { |  | 92118 | {
| 92167 | PyErr_SetString(PyExc_TypeError, "Cannot delete the corrWinSizeX attribute"); |  | 92119 | PyErr_SetString(PyExc_TypeError, "Cannot delete the corrWinSizeX attribute");
| 92168 | return -1; |  | 92120 | return -1;
| 92169 | } |  | 92121 | }
| 92170 | return pyopencv_to_safe(value, p->v.corrWinSizeX, ArgInfo("value", 0)) ? 0 : -1; |  | 92122 | return pyopencv_to_safe(value, p->v.corrWinSizeX, ArgInfo("value", 0)) ? 0 : -1;
| 92171 | } |  | 92123 | }
| 92172 |  |  | 92124 |
| 92173 | static PyObject* pyopencv_stereo_PropagationParameters_get_corrWinSizeY(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92125 | static PyObject* pyopencv_stereo_PropagationParameters_get_corrWinSizeY(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92174 | { |  | 92126 | {
| 92175 | return pyopencv_from(p->v.corrWinSizeY); |  | 92127 | return pyopencv_from(p->v.corrWinSizeY);
| 92176 | } |  | 92128 | }
| 92177 |  |  | 92129 |
| 92178 | static int pyopencv_stereo_PropagationParameters_set_corrWinSizeY(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92130 | static int pyopencv_stereo_PropagationParameters_set_corrWinSizeY(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92179 | { |  | 92131 | {
| 92180 | if (!value) |  | 92132 | if (!value)
| 92181 | { |  | 92133 | {
| 92182 | PyErr_SetString(PyExc_TypeError, "Cannot delete the corrWinSizeY attribute"); |  | 92134 | PyErr_SetString(PyExc_TypeError, "Cannot delete the corrWinSizeY attribute");
| 92183 | return -1; |  | 92135 | return -1;
| 92184 | } |  | 92136 | }
| 92185 | return pyopencv_to_safe(value, p->v.corrWinSizeY, ArgInfo("value", 0)) ? 0 : -1; |  | 92137 | return pyopencv_to_safe(value, p->v.corrWinSizeY, ArgInfo("value", 0)) ? 0 : -1;
| 92186 | } |  | 92138 | }
| 92187 |  |  | 92139 |
| 92188 | static PyObject* pyopencv_stereo_PropagationParameters_get_correlationThreshold(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92140 | static PyObject* pyopencv_stereo_PropagationParameters_get_correlationThreshold(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92189 | { |  | 92141 | {
| 92190 | return pyopencv_from(p->v.correlationThreshold); |  | 92142 | return pyopencv_from(p->v.correlationThreshold);
| 92191 | } |  | 92143 | }
| 92192 |  |  | 92144 |
| 92193 | static int pyopencv_stereo_PropagationParameters_set_correlationThreshold(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92145 | static int pyopencv_stereo_PropagationParameters_set_correlationThreshold(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92194 | { |  | 92146 | {
| 92195 | if (!value) |  | 92147 | if (!value)
| 92196 | { |  | 92148 | {
| 92197 | PyErr_SetString(PyExc_TypeError, "Cannot delete the correlationThreshold attribute"); |  | 92149 | PyErr_SetString(PyExc_TypeError, "Cannot delete the correlationThreshold attribute");
| 92198 | return -1; |  | 92150 | return -1;
| 92199 | } |  | 92151 | }
| 92200 | return pyopencv_to_safe(value, p->v.correlationThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 92152 | return pyopencv_to_safe(value, p->v.correlationThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 92201 | } |  | 92153 | }
| 92202 |  |  | 92154 |
| 92203 | static PyObject* pyopencv_stereo_PropagationParameters_get_disparityGradient(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92155 | static PyObject* pyopencv_stereo_PropagationParameters_get_disparityGradient(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92204 | { |  | 92156 | {
| 92205 | return pyopencv_from(p->v.disparityGradient); |  | 92157 | return pyopencv_from(p->v.disparityGradient);
| 92206 | } |  | 92158 | }
| 92207 |  |  | 92159 |
| 92208 | static int pyopencv_stereo_PropagationParameters_set_disparityGradient(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92160 | static int pyopencv_stereo_PropagationParameters_set_disparityGradient(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92209 | { |  | 92161 | {
| 92210 | if (!value) |  | 92162 | if (!value)
| 92211 | { |  | 92163 | {
| 92212 | PyErr_SetString(PyExc_TypeError, "Cannot delete the disparityGradient attribute"); |  | 92164 | PyErr_SetString(PyExc_TypeError, "Cannot delete the disparityGradient attribute");
| 92213 | return -1; |  | 92165 | return -1;
| 92214 | } |  | 92166 | }
| 92215 | return pyopencv_to_safe(value, p->v.disparityGradient, ArgInfo("value", 0)) ? 0 : -1; |  | 92167 | return pyopencv_to_safe(value, p->v.disparityGradient, ArgInfo("value", 0)) ? 0 : -1;
| 92216 | } |  | 92168 | }
| 92217 |  |  | 92169 |
| 92218 | static PyObject* pyopencv_stereo_PropagationParameters_get_gftMaxNumFeatures(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92170 | static PyObject* pyopencv_stereo_PropagationParameters_get_gftMaxNumFeatures(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92219 | { |  | 92171 | {
| 92220 | return pyopencv_from(p->v.gftMaxNumFeatures); |  | 92172 | return pyopencv_from(p->v.gftMaxNumFeatures);
| 92221 | } |  | 92173 | }
| 92222 |  |  | 92174 |
| 92223 | static int pyopencv_stereo_PropagationParameters_set_gftMaxNumFeatures(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92175 | static int pyopencv_stereo_PropagationParameters_set_gftMaxNumFeatures(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92224 | { |  | 92176 | {
| 92225 | if (!value) |  | 92177 | if (!value)
| 92226 | { |  | 92178 | {
| 92227 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gftMaxNumFeatures attribute"); |  | 92179 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gftMaxNumFeatures attribute");
| 92228 | return -1; |  | 92180 | return -1;
| 92229 | } |  | 92181 | }
| 92230 | return pyopencv_to_safe(value, p->v.gftMaxNumFeatures, ArgInfo("value", 0)) ? 0 : -1; |  | 92182 | return pyopencv_to_safe(value, p->v.gftMaxNumFeatures, ArgInfo("value", 0)) ? 0 : -1;
| 92231 | } |  | 92183 | }
| 92232 |  |  | 92184 |
| 92233 | static PyObject* pyopencv_stereo_PropagationParameters_get_gftMinSeperationDist(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92185 | static PyObject* pyopencv_stereo_PropagationParameters_get_gftMinSeperationDist(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92234 | { |  | 92186 | {
| 92235 | return pyopencv_from(p->v.gftMinSeperationDist); |  | 92187 | return pyopencv_from(p->v.gftMinSeperationDist);
| 92236 | } |  | 92188 | }
| 92237 |  |  | 92189 |
| 92238 | static int pyopencv_stereo_PropagationParameters_set_gftMinSeperationDist(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92190 | static int pyopencv_stereo_PropagationParameters_set_gftMinSeperationDist(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92239 | { |  | 92191 | {
| 92240 | if (!value) |  | 92192 | if (!value)
| 92241 | { |  | 92193 | {
| 92242 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gftMinSeperationDist attribute"); |  | 92194 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gftMinSeperationDist attribute");
| 92243 | return -1; |  | 92195 | return -1;
| 92244 | } |  | 92196 | }
| 92245 | return pyopencv_to_safe(value, p->v.gftMinSeperationDist, ArgInfo("value", 0)) ? 0 : -1; |  | 92197 | return pyopencv_to_safe(value, p->v.gftMinSeperationDist, ArgInfo("value", 0)) ? 0 : -1;
| 92246 | } |  | 92198 | }
| 92247 |  |  | 92199 |
| 92248 | static PyObject* pyopencv_stereo_PropagationParameters_get_gftQualityThres(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92200 | static PyObject* pyopencv_stereo_PropagationParameters_get_gftQualityThres(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92249 | { |  | 92201 | {
| 92250 | return pyopencv_from(p->v.gftQualityThres); |  | 92202 | return pyopencv_from(p->v.gftQualityThres);
| 92251 | } |  | 92203 | }
| 92252 |  |  | 92204 |
| 92253 | static int pyopencv_stereo_PropagationParameters_set_gftQualityThres(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92205 | static int pyopencv_stereo_PropagationParameters_set_gftQualityThres(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92254 | { |  | 92206 | {
| 92255 | if (!value) |  | 92207 | if (!value)
| 92256 | { |  | 92208 | {
| 92257 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gftQualityThres attribute"); |  | 92209 | PyErr_SetString(PyExc_TypeError, "Cannot delete the gftQualityThres attribute");
| 92258 | return -1; |  | 92210 | return -1;
| 92259 | } |  | 92211 | }
| 92260 | return pyopencv_to_safe(value, p->v.gftQualityThres, ArgInfo("value", 0)) ? 0 : -1; |  | 92212 | return pyopencv_to_safe(value, p->v.gftQualityThres, ArgInfo("value", 0)) ? 0 : -1;
| 92261 | } |  | 92213 | }
| 92262 |  |  | 92214 |
| 92263 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkPyrLvl(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92215 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkPyrLvl(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92264 | { |  | 92216 | {
| 92265 | return pyopencv_from(p->v.lkPyrLvl); |  | 92217 | return pyopencv_from(p->v.lkPyrLvl);
| 92266 | } |  | 92218 | }
| 92267 |  |  | 92219 |
| 92268 | static int pyopencv_stereo_PropagationParameters_set_lkPyrLvl(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92220 | static int pyopencv_stereo_PropagationParameters_set_lkPyrLvl(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92269 | { |  | 92221 | {
| 92270 | if (!value) |  | 92222 | if (!value)
| 92271 | { |  | 92223 | {
| 92272 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkPyrLvl attribute"); |  | 92224 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkPyrLvl attribute");
| 92273 | return -1; |  | 92225 | return -1;
| 92274 | } |  | 92226 | }
| 92275 | return pyopencv_to_safe(value, p->v.lkPyrLvl, ArgInfo("value", 0)) ? 0 : -1; |  | 92227 | return pyopencv_to_safe(value, p->v.lkPyrLvl, ArgInfo("value", 0)) ? 0 : -1;
| 92276 | } |  | 92228 | }
| 92277 |  |  | 92229 |
| 92278 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkTemplateSize(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92230 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkTemplateSize(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92279 | { |  | 92231 | {
| 92280 | return pyopencv_from(p->v.lkTemplateSize); |  | 92232 | return pyopencv_from(p->v.lkTemplateSize);
| 92281 | } |  | 92233 | }
| 92282 |  |  | 92234 |
| 92283 | static int pyopencv_stereo_PropagationParameters_set_lkTemplateSize(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92235 | static int pyopencv_stereo_PropagationParameters_set_lkTemplateSize(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92284 | { |  | 92236 | {
| 92285 | if (!value) |  | 92237 | if (!value)
| 92286 | { |  | 92238 | {
| 92287 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkTemplateSize attribute"); |  | 92239 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkTemplateSize attribute");
| 92288 | return -1; |  | 92240 | return -1;
| 92289 | } |  | 92241 | }
| 92290 | return pyopencv_to_safe(value, p->v.lkTemplateSize, ArgInfo("value", 0)) ? 0 : -1; |  | 92242 | return pyopencv_to_safe(value, p->v.lkTemplateSize, ArgInfo("value", 0)) ? 0 : -1;
| 92291 | } |  | 92243 | }
| 92292 |  |  | 92244 |
| 92293 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkTermParam1(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92245 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkTermParam1(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92294 | { |  | 92246 | {
| 92295 | return pyopencv_from(p->v.lkTermParam1); |  | 92247 | return pyopencv_from(p->v.lkTermParam1);
| 92296 | } |  | 92248 | }
| 92297 |  |  | 92249 |
| 92298 | static int pyopencv_stereo_PropagationParameters_set_lkTermParam1(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92250 | static int pyopencv_stereo_PropagationParameters_set_lkTermParam1(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92299 | { |  | 92251 | {
| 92300 | if (!value) |  | 92252 | if (!value)
| 92301 | { |  | 92253 | {
| 92302 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkTermParam1 attribute"); |  | 92254 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkTermParam1 attribute");
| 92303 | return -1; |  | 92255 | return -1;
| 92304 | } |  | 92256 | }
| 92305 | return pyopencv_to_safe(value, p->v.lkTermParam1, ArgInfo("value", 0)) ? 0 : -1; |  | 92257 | return pyopencv_to_safe(value, p->v.lkTermParam1, ArgInfo("value", 0)) ? 0 : -1;
| 92306 | } |  | 92258 | }
| 92307 |  |  | 92259 |
| 92308 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkTermParam2(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92260 | static PyObject* pyopencv_stereo_PropagationParameters_get_lkTermParam2(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92309 | { |  | 92261 | {
| 92310 | return pyopencv_from(p->v.lkTermParam2); |  | 92262 | return pyopencv_from(p->v.lkTermParam2);
| 92311 | } |  | 92263 | }
| 92312 |  |  | 92264 |
| 92313 | static int pyopencv_stereo_PropagationParameters_set_lkTermParam2(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92265 | static int pyopencv_stereo_PropagationParameters_set_lkTermParam2(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92314 | { |  | 92266 | {
| 92315 | if (!value) |  | 92267 | if (!value)
| 92316 | { |  | 92268 | {
| 92317 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkTermParam2 attribute"); |  | 92269 | PyErr_SetString(PyExc_TypeError, "Cannot delete the lkTermParam2 attribute");
| 92318 | return -1; |  | 92270 | return -1;
| 92319 | } |  | 92271 | }
| 92320 | return pyopencv_to_safe(value, p->v.lkTermParam2, ArgInfo("value", 0)) ? 0 : -1; |  | 92272 | return pyopencv_to_safe(value, p->v.lkTermParam2, ArgInfo("value", 0)) ? 0 : -1;
| 92321 | } |  | 92273 | }
| 92322 |  |  | 92274 |
| 92323 | static PyObject* pyopencv_stereo_PropagationParameters_get_neighborhoodSize(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92275 | static PyObject* pyopencv_stereo_PropagationParameters_get_neighborhoodSize(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92324 | { |  | 92276 | {
| 92325 | return pyopencv_from(p->v.neighborhoodSize); |  | 92277 | return pyopencv_from(p->v.neighborhoodSize);
| 92326 | } |  | 92278 | }
| 92327 |  |  | 92279 |
| 92328 | static int pyopencv_stereo_PropagationParameters_set_neighborhoodSize(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92280 | static int pyopencv_stereo_PropagationParameters_set_neighborhoodSize(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92329 | { |  | 92281 | {
| 92330 | if (!value) |  | 92282 | if (!value)
| 92331 | { |  | 92283 | {
| 92332 | PyErr_SetString(PyExc_TypeError, "Cannot delete the neighborhoodSize attribute"); |  | 92284 | PyErr_SetString(PyExc_TypeError, "Cannot delete the neighborhoodSize attribute");
| 92333 | return -1; |  | 92285 | return -1;
| 92334 | } |  | 92286 | }
| 92335 | return pyopencv_to_safe(value, p->v.neighborhoodSize, ArgInfo("value", 0)) ? 0 : -1; |  | 92287 | return pyopencv_to_safe(value, p->v.neighborhoodSize, ArgInfo("value", 0)) ? 0 : -1;
| 92336 | } |  | 92288 | }
| 92337 |  |  | 92289 |
| 92338 | static PyObject* pyopencv_stereo_PropagationParameters_get_textrureThreshold(pyopencv_stereo_PropagationParameters_t* p, void *closure) |  | 92290 | static PyObject* pyopencv_stereo_PropagationParameters_get_textrureThreshold(pyopencv_stereo_PropagationParameters_t* p, void *closure)
| 92339 | { |  | 92291 | {
| 92340 | return pyopencv_from(p->v.textrureThreshold); |  | 92292 | return pyopencv_from(p->v.textrureThreshold);
| 92341 | } |  | 92293 | }
| 92342 |  |  | 92294 |
| 92343 | static int pyopencv_stereo_PropagationParameters_set_textrureThreshold(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure) |  | 92295 | static int pyopencv_stereo_PropagationParameters_set_textrureThreshold(pyopencv_stereo_PropagationParameters_t* p, PyObject *value, void *closure)
| 92344 | { |  | 92296 | {
| 92345 | if (!value) |  | 92297 | if (!value)
| 92346 | { |  | 92298 | {
| 92347 | PyErr_SetString(PyExc_TypeError, "Cannot delete the textrureThreshold attribute"); |  | 92299 | PyErr_SetString(PyExc_TypeError, "Cannot delete the textrureThreshold attribute");
| 92348 | return -1; |  | 92300 | return -1;
| 92349 | } |  | 92301 | }
| 92350 | return pyopencv_to_safe(value, p->v.textrureThreshold, ArgInfo("value", 0)) ? 0 : -1; |  | 92302 | return pyopencv_to_safe(value, p->v.textrureThreshold, ArgInfo("value", 0)) ? 0 : -1;
| 92351 | } |  | 92303 | }
| 92352 |  |  | 92304 |
| 92353 |  |  | 92305 |
| 92354 | // Methods (stereo_PropagationParameters) |  | 92306 | // Methods (stereo_PropagationParameters)
| 92355 |  |  | 92307 |
| 92356 |  |  | 92308 |
| 92357 |  |  | 92309 |
| 92358 | // Tables (stereo_PropagationParameters) |  | 92310 | // Tables (stereo_PropagationParameters)
| 92359 |  |  | 92311 |
| 92360 | static PyGetSetDef pyopencv_stereo_PropagationParameters_getseters[] = |  | 92312 | static PyGetSetDef pyopencv_stereo_PropagationParameters_getseters[] =
| 92361 | { |  | 92313 | {
| 92362 | {(char*)"borderX", (getter)pyopencv_stereo_PropagationParameters_get_borderX, (setter)pyopencv_stereo_PropagationParameters_set_borderX, (char*)"borderX", NULL}, |  | 92314 | {(char*)"borderX", (getter)pyopencv_stereo_PropagationParameters_get_borderX, (setter)pyopencv_stereo_PropagationParameters_set_borderX, (char*)"borderX", NULL},
| 92363 | {(char*)"borderY", (getter)pyopencv_stereo_PropagationParameters_get_borderY, (setter)pyopencv_stereo_PropagationParameters_set_borderY, (char*)"borderY", NULL}, |  | 92315 | {(char*)"borderY", (getter)pyopencv_stereo_PropagationParameters_get_borderY, (setter)pyopencv_stereo_PropagationParameters_set_borderY, (char*)"borderY", NULL},
| 92364 | {(char*)"corrWinSizeX", (getter)pyopencv_stereo_PropagationParameters_get_corrWinSizeX, (setter)pyopencv_stereo_PropagationParameters_set_corrWinSizeX, (char*)"corrWinSizeX", NULL}, |  | 92316 | {(char*)"corrWinSizeX", (getter)pyopencv_stereo_PropagationParameters_get_corrWinSizeX, (setter)pyopencv_stereo_PropagationParameters_set_corrWinSizeX, (char*)"corrWinSizeX", NULL},
| 92365 | {(char*)"corrWinSizeY", (getter)pyopencv_stereo_PropagationParameters_get_corrWinSizeY, (setter)pyopencv_stereo_PropagationParameters_set_corrWinSizeY, (char*)"corrWinSizeY", NULL}, |  | 92317 | {(char*)"corrWinSizeY", (getter)pyopencv_stereo_PropagationParameters_get_corrWinSizeY, (setter)pyopencv_stereo_PropagationParameters_set_corrWinSizeY, (char*)"corrWinSizeY", NULL},
| 92366 | {(char*)"correlationThreshold", (getter)pyopencv_stereo_PropagationParameters_get_correlationThreshold, (setter)pyopencv_stereo_PropagationParameters_set_correlationThreshold, (char*)"correlationThreshold", NULL}, |  | 92318 | {(char*)"correlationThreshold", (getter)pyopencv_stereo_PropagationParameters_get_correlationThreshold, (setter)pyopencv_stereo_PropagationParameters_set_correlationThreshold, (char*)"correlationThreshold", NULL},
| 92367 | {(char*)"disparityGradient", (getter)pyopencv_stereo_PropagationParameters_get_disparityGradient, (setter)pyopencv_stereo_PropagationParameters_set_disparityGradient, (char*)"disparityGradient", NULL}, |  | 92319 | {(char*)"disparityGradient", (getter)pyopencv_stereo_PropagationParameters_get_disparityGradient, (setter)pyopencv_stereo_PropagationParameters_set_disparityGradient, (char*)"disparityGradient", NULL},
| 92368 | {(char*)"gftMaxNumFeatures", (getter)pyopencv_stereo_PropagationParameters_get_gftMaxNumFeatures, (setter)pyopencv_stereo_PropagationParameters_set_gftMaxNumFeatures, (char*)"gftMaxNumFeatures", NULL}, |  | 92320 | {(char*)"gftMaxNumFeatures", (getter)pyopencv_stereo_PropagationParameters_get_gftMaxNumFeatures, (setter)pyopencv_stereo_PropagationParameters_set_gftMaxNumFeatures, (char*)"gftMaxNumFeatures", NULL},
| 92369 | {(char*)"gftMinSeperationDist", (getter)pyopencv_stereo_PropagationParameters_get_gftMinSeperationDist, (setter)pyopencv_stereo_PropagationParameters_set_gftMinSeperationDist, (char*)"gftMinSeperationDist", NULL}, |  | 92321 | {(char*)"gftMinSeperationDist", (getter)pyopencv_stereo_PropagationParameters_get_gftMinSeperationDist, (setter)pyopencv_stereo_PropagationParameters_set_gftMinSeperationDist, (char*)"gftMinSeperationDist", NULL},
| 92370 | {(char*)"gftQualityThres", (getter)pyopencv_stereo_PropagationParameters_get_gftQualityThres, (setter)pyopencv_stereo_PropagationParameters_set_gftQualityThres, (char*)"gftQualityThres", NULL}, |  | 92322 | {(char*)"gftQualityThres", (getter)pyopencv_stereo_PropagationParameters_get_gftQualityThres, (setter)pyopencv_stereo_PropagationParameters_set_gftQualityThres, (char*)"gftQualityThres", NULL},
| 92371 | {(char*)"lkPyrLvl", (getter)pyopencv_stereo_PropagationParameters_get_lkPyrLvl, (setter)pyopencv_stereo_PropagationParameters_set_lkPyrLvl, (char*)"lkPyrLvl", NULL}, |  | 92323 | {(char*)"lkPyrLvl", (getter)pyopencv_stereo_PropagationParameters_get_lkPyrLvl, (setter)pyopencv_stereo_PropagationParameters_set_lkPyrLvl, (char*)"lkPyrLvl", NULL},
| 92372 | {(char*)"lkTemplateSize", (getter)pyopencv_stereo_PropagationParameters_get_lkTemplateSize, (setter)pyopencv_stereo_PropagationParameters_set_lkTemplateSize, (char*)"lkTemplateSize", NULL}, |  | 92324 | {(char*)"lkTemplateSize", (getter)pyopencv_stereo_PropagationParameters_get_lkTemplateSize, (setter)pyopencv_stereo_PropagationParameters_set_lkTemplateSize, (char*)"lkTemplateSize", NULL},
| 92373 | {(char*)"lkTermParam1", (getter)pyopencv_stereo_PropagationParameters_get_lkTermParam1, (setter)pyopencv_stereo_PropagationParameters_set_lkTermParam1, (char*)"lkTermParam1", NULL}, |  | 92325 | {(char*)"lkTermParam1", (getter)pyopencv_stereo_PropagationParameters_get_lkTermParam1, (setter)pyopencv_stereo_PropagationParameters_set_lkTermParam1, (char*)"lkTermParam1", NULL},
| 92374 | {(char*)"lkTermParam2", (getter)pyopencv_stereo_PropagationParameters_get_lkTermParam2, (setter)pyopencv_stereo_PropagationParameters_set_lkTermParam2, (char*)"lkTermParam2", NULL}, |  | 92326 | {(char*)"lkTermParam2", (getter)pyopencv_stereo_PropagationParameters_get_lkTermParam2, (setter)pyopencv_stereo_PropagationParameters_set_lkTermParam2, (char*)"lkTermParam2", NULL},
| 92375 | {(char*)"neighborhoodSize", (getter)pyopencv_stereo_PropagationParameters_get_neighborhoodSize, (setter)pyopencv_stereo_PropagationParameters_set_neighborhoodSize, (char*)"neighborhoodSize", NULL}, |  | 92327 | {(char*)"neighborhoodSize", (getter)pyopencv_stereo_PropagationParameters_get_neighborhoodSize, (setter)pyopencv_stereo_PropagationParameters_set_neighborhoodSize, (char*)"neighborhoodSize", NULL},
| 92376 | {(char*)"textrureThreshold", (getter)pyopencv_stereo_PropagationParameters_get_textrureThreshold, (setter)pyopencv_stereo_PropagationParameters_set_textrureThreshold, (char*)"textrureThreshold", NULL}, |  | 92328 | {(char*)"textrureThreshold", (getter)pyopencv_stereo_PropagationParameters_get_textrureThreshold, (setter)pyopencv_stereo_PropagationParameters_set_textrureThreshold, (char*)"textrureThreshold", NULL},
| 92377 | {NULL} /* Sentinel */ |  | 92329 | {NULL} /* Sentinel */
| 92378 | }; |  | 92330 | };
| 92379 |  |  | 92331 |
| 92380 | static PyMethodDef pyopencv_stereo_PropagationParameters_methods[] = |  | 92332 | static PyMethodDef pyopencv_stereo_PropagationParameters_methods[] =
| 92381 | { |  | 92333 | {
| 92382 |  |  | 92334 |
| 92383 | {NULL, NULL} |  | 92335 | {NULL, NULL}
| 92384 | }; |  | 92336 | };
| 92385 |  |  | 92337 |
| 92386 | // Converter (stereo_PropagationParameters) |  | 92338 | // Converter (stereo_PropagationParameters)
| 92387 |  |  | 92339 |
| 92388 | template<> |  | 92340 | template<>
| 92389 | struct PyOpenCV_Converter< cv::stereo::PropagationParameters > |  | 92341 | struct PyOpenCV_Converter< cv::stereo::PropagationParameters >
| 92390 | { |  | 92342 | {
| 92391 | static PyObject* from(const cv::stereo::PropagationParameters& r) |  | 92343 | static PyObject* from(const cv::stereo::PropagationParameters& r)
| 92392 | { |  | 92344 | {
| 92393 | return pyopencv_stereo_PropagationParameters_Instance(r); |  | 92345 | return pyopencv_stereo_PropagationParameters_Instance(r);
| 92394 | } |  | 92346 | }
| 92395 | static bool to(PyObject* src, cv::stereo::PropagationParameters& dst, const ArgInfo& info) |  | 92347 | static bool to(PyObject* src, cv::stereo::PropagationParameters& dst, const ArgInfo& info)
| 92396 | { |  | 92348 | {
| 92397 | if(!src || src == Py_None) |  | 92349 | if(!src || src == Py_None)
| 92398 | return true; |  | 92350 | return true;
| 92399 | cv::stereo::PropagationParameters * dst_; |  | 92351 | cv::stereo::PropagationParameters * dst_;
| 92400 | if (pyopencv_stereo_PropagationParameters_getp(src, dst_)) |  | 92352 | if (pyopencv_stereo_PropagationParameters_getp(src, dst_))
| 92401 | { |  | 92353 | {
| 92402 | dst = *dst_; |  | 92354 | dst = *dst_;
| 92403 | return true; |  | 92355 | return true;
| 92404 | } |  | 92356 | }
| 92405 |  |  | 92357 |
| 92406 | failmsg("Expected cv::stereo::PropagationParameters for argument '%s'", info.name); |  | 92358 | failmsg("Expected cv::stereo::PropagationParameters for argument '%s'", info.name);
| 92407 | return false; |  | 92359 | return false;
| 92408 | } |  | 92360 | }
| 92409 | }; |  | 92361 | };
| 92410 |  |  | 92362 |
| 92411 | //================================================================================ |  | 92363 | //================================================================================
| 92412 | // stereo_QuasiDenseStereo (Generic) |  | 92364 | // stereo_QuasiDenseStereo (Generic)
| 92413 | //================================================================================ |  | 92365 | //================================================================================
| 92414 |  |  | 92366 |
| 92415 | // GetSet (stereo_QuasiDenseStereo) |  | 92367 | // GetSet (stereo_QuasiDenseStereo)
| 92416 |  |  | 92368 |
| 92417 |  |  | 92369 |
| 92418 | static PyObject* pyopencv_stereo_QuasiDenseStereo_get_Param(pyopencv_stereo_QuasiDenseStereo_t* p, void *closure) |  | 92370 | static PyObject* pyopencv_stereo_QuasiDenseStereo_get_Param(pyopencv_stereo_QuasiDenseStereo_t* p, void *closure)
| 92419 | { |  | 92371 | {
| 92420 | return pyopencv_from(p->v->Param); |  | 92372 | return pyopencv_from(p->v->Param);
| 92421 | } |  | 92373 | }
| 92422 |  |  | 92374 |
| 92423 | static int pyopencv_stereo_QuasiDenseStereo_set_Param(pyopencv_stereo_QuasiDenseStereo_t* p, PyObject *value, void *closure) |  | 92375 | static int pyopencv_stereo_QuasiDenseStereo_set_Param(pyopencv_stereo_QuasiDenseStereo_t* p, PyObject *value, void *closure)
| 92424 | { |  | 92376 | {
| 92425 | if (!value) |  | 92377 | if (!value)
| 92426 | { |  | 92378 | {
| 92427 | PyErr_SetString(PyExc_TypeError, "Cannot delete the Param attribute"); |  | 92379 | PyErr_SetString(PyExc_TypeError, "Cannot delete the Param attribute");
| 92428 | return -1; |  | 92380 | return -1;
| 92429 | } |  | 92381 | }
| 92430 | return pyopencv_to_safe(value, p->v->Param, ArgInfo("value", 0)) ? 0 : -1; |  | 92382 | return pyopencv_to_safe(value, p->v->Param, ArgInfo("value", 0)) ? 0 : -1;
| 92431 | } |  | 92383 | }
| 92432 |  |  | 92384 |
| 92433 |  |  | 92385 |
| 92434 | // Methods (stereo_QuasiDenseStereo) |  | 92386 | // Methods (stereo_QuasiDenseStereo)
| 92435 |  |  | 92387 |
| 92436 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92388 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 92437 | { |  | 92389 | {
| 92438 | using namespace cv::stereo; |  | 92390 | using namespace cv::stereo;
| 92439 |  |  | 92391 |
| 92440 | PyObject* pyobj_monoImgSize = NULL; |  | 92392 | PyObject* pyobj_monoImgSize = NULL;
| 92441 | Size monoImgSize; |  | 92393 | Size monoImgSize;
| 92442 | PyObject* pyobj_paramFilepath = NULL; |  | 92394 | PyObject* pyobj_paramFilepath = NULL;
| 92443 | String paramFilepath=cv::String(); |  | 92395 | String paramFilepath=cv::String();
| 92444 | cv::Ptr<QuasiDenseStereo> retval; |  | 92396 | cv::Ptr<QuasiDenseStereo> retval;
| 92445 |  |  | 92397 |
| 92446 | const char* keywords[] = { "monoImgSize", "paramFilepath", NULL }; |  | 92398 | const char* keywords[] = { "monoImgSize", "paramFilepath", NULL };
| 92447 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:stereo_QuasiDenseStereo.create", (char**)keywords, &pyobj_monoImgSize, &pyobj_paramFilepath) && |  | 92399 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O|O:stereo_QuasiDenseStereo.create", (char**)keywords, &pyobj_monoImgSize, &pyobj_paramFilepath) &&
| 92448 | pyopencv_to_safe(pyobj_monoImgSize, monoImgSize, ArgInfo("monoImgSize", 0)) && |  | 92400 | pyopencv_to_safe(pyobj_monoImgSize, monoImgSize, ArgInfo("monoImgSize", 0)) &&
| 92449 | pyopencv_to_safe(pyobj_paramFilepath, paramFilepath, ArgInfo("paramFilepath", 0)) ) |  | 92401 | pyopencv_to_safe(pyobj_paramFilepath, paramFilepath, ArgInfo("paramFilepath", 0)) )
| 92450 | { |  | 92402 | {
| 92451 | ERRWRAP2(retval = cv::stereo::QuasiDenseStereo::create(monoImgSize, paramFilepath)); |  | 92403 | ERRWRAP2(retval = cv::stereo::QuasiDenseStereo::create(monoImgSize, paramFilepath));
| 92452 | return pyopencv_from(retval); |  | 92404 | return pyopencv_from(retval);
| 92453 | } |  | 92405 | }
| 92454 |  |  | 92406 |
| 92455 | return NULL; |  | 92407 | return NULL;
| 92456 | } |  | 92408 | }
| 92457 |  |  | 92409 |
| 92458 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDenseMatches(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92410 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDenseMatches(PyObject* self, PyObject* py_args, PyObject* kw)
| 92459 | { |  | 92411 | {
| 92460 | using namespace cv::stereo; |  | 92412 | using namespace cv::stereo;
| 92461 |  |  | 92413 |
| 92462 |  |  | 92414 |
| 92463 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0; |  | 92415 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0;
| 92464 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1)) |  | 92416 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1))
| 92465 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)"); |  | 92417 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)");
| 92466 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1); |  | 92418 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1);
| 92467 | vector_MatchQuasiDense denseMatches; |  | 92419 | vector_MatchQuasiDense denseMatches;
| 92468 |  |  | 92420 |
| 92469 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 92421 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 92470 | { |  | 92422 | {
| 92471 | ERRWRAP2(_self_->getDenseMatches(denseMatches)); |  | 92423 | ERRWRAP2(_self_->getDenseMatches(denseMatches));
| 92472 | return pyopencv_from(denseMatches); |  | 92424 | return pyopencv_from(denseMatches);
| 92473 | } |  | 92425 | }
| 92474 |  |  | 92426 |
| 92475 | return NULL; |  | 92427 | return NULL;
| 92476 | } |  | 92428 | }
| 92477 |  |  | 92429 |
| 92478 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDisparity(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92430 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDisparity(PyObject* self, PyObject* py_args, PyObject* kw)
| 92479 | { |  | 92431 | {
| 92480 | using namespace cv::stereo; |  | 92432 | using namespace cv::stereo;
| 92481 |  |  | 92433 |
| 92482 |  |  | 92434 |
| 92483 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0; |  | 92435 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0;
| 92484 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1)) |  | 92436 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1))
| 92485 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)"); |  | 92437 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)");
| 92486 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1); |  | 92438 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1);
| 92487 | cv::Mat retval; |  | 92439 | cv::Mat retval;
| 92488 |  |  | 92440 |
| 92489 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 92441 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 92490 | { |  | 92442 | {
| 92491 | ERRWRAP2(retval = _self_->getDisparity()); |  | 92443 | ERRWRAP2(retval = _self_->getDisparity());
| 92492 | return pyopencv_from(retval); |  | 92444 | return pyopencv_from(retval);
| 92493 | } |  | 92445 | }
| 92494 |  |  | 92446 |
| 92495 | return NULL; |  | 92447 | return NULL;
| 92496 | } |  | 92448 | }
| 92497 |  |  | 92449 |
| 92498 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getMatch(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92450 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getMatch(PyObject* self, PyObject* py_args, PyObject* kw)
| 92499 | { |  | 92451 | {
| 92500 | using namespace cv::stereo; |  | 92452 | using namespace cv::stereo;
| 92501 |  |  | 92453 |
| 92502 |  |  | 92454 |
| 92503 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0; |  | 92455 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0;
| 92504 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1)) |  | 92456 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1))
| 92505 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)"); |  | 92457 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)");
| 92506 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1); |  | 92458 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1);
| 92507 | PyObject* pyobj_x = NULL; |  | 92459 | PyObject* pyobj_x = NULL;
| 92508 | int x=0; |  | 92460 | int x=0;
| 92509 | PyObject* pyobj_y = NULL; |  | 92461 | PyObject* pyobj_y = NULL;
| 92510 | int y=0; |  | 92462 | int y=0;
| 92511 | cv::Point2f retval; |  | 92463 | cv::Point2f retval;
| 92512 |  |  | 92464 |
| 92513 | const char* keywords[] = { "x", "y", NULL }; |  | 92465 | const char* keywords[] = { "x", "y", NULL };
| 92514 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:stereo_QuasiDenseStereo.getMatch", (char**)keywords, &pyobj_x, &pyobj_y) && |  | 92466 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:stereo_QuasiDenseStereo.getMatch", (char**)keywords, &pyobj_x, &pyobj_y) &&
| 92515 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) && |  | 92467 | pyopencv_to_safe(pyobj_x, x, ArgInfo("x", 0)) &&
| 92516 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) ) |  | 92468 | pyopencv_to_safe(pyobj_y, y, ArgInfo("y", 0)) )
| 92517 | { |  | 92469 | {
| 92518 | ERRWRAP2(retval = _self_->getMatch(x, y)); |  | 92470 | ERRWRAP2(retval = _self_->getMatch(x, y));
| 92519 | return pyopencv_from(retval); |  | 92471 | return pyopencv_from(retval);
| 92520 | } |  | 92472 | }
| 92521 |  |  | 92473 |
| 92522 | return NULL; |  | 92474 | return NULL;
| 92523 | } |  | 92475 | }
| 92524 |  |  | 92476 |
| 92525 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getSparseMatches(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92477 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_getSparseMatches(PyObject* self, PyObject* py_args, PyObject* kw)
| 92526 | { |  | 92478 | {
| 92527 | using namespace cv::stereo; |  | 92479 | using namespace cv::stereo;
| 92528 |  |  | 92480 |
| 92529 |  |  | 92481 |
| 92530 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0; |  | 92482 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0;
| 92531 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1)) |  | 92483 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1))
| 92532 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)"); |  | 92484 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)");
| 92533 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1); |  | 92485 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1);
| 92534 | vector_MatchQuasiDense sMatches; |  | 92486 | vector_MatchQuasiDense sMatches;
| 92535 |  |  | 92487 |
| 92536 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0)) |  | 92488 | if(PyObject_Size(py_args) == 0 && (!kw || PyObject_Size(kw) == 0))
| 92537 | { |  | 92489 | {
| 92538 | ERRWRAP2(_self_->getSparseMatches(sMatches)); |  | 92490 | ERRWRAP2(_self_->getSparseMatches(sMatches));
| 92539 | return pyopencv_from(sMatches); |  | 92491 | return pyopencv_from(sMatches);
| 92540 | } |  | 92492 | }
| 92541 |  |  | 92493 |
| 92542 | return NULL; |  | 92494 | return NULL;
| 92543 | } |  | 92495 | }
| 92544 |  |  | 92496 |
| 92545 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_loadParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92497 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_loadParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 92546 | { |  | 92498 | {
| 92547 | using namespace cv::stereo; |  | 92499 | using namespace cv::stereo;
| 92548 |  |  | 92500 |
| 92549 |  |  | 92501 |
| 92550 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0; |  | 92502 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0;
| 92551 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1)) |  | 92503 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1))
| 92552 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)"); |  | 92504 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)");
| 92553 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1); |  | 92505 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1);
| 92554 | PyObject* pyobj_filepath = NULL; |  | 92506 | PyObject* pyobj_filepath = NULL;
| 92555 | String filepath; |  | 92507 | String filepath;
| 92556 | int retval; |  | 92508 | int retval;
| 92557 |  |  | 92509 |
| 92558 | const char* keywords[] = { "filepath", NULL }; |  | 92510 | const char* keywords[] = { "filepath", NULL };
| 92559 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:stereo_QuasiDenseStereo.loadParameters", (char**)keywords, &pyobj_filepath) && |  | 92511 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:stereo_QuasiDenseStereo.loadParameters", (char**)keywords, &pyobj_filepath) &&
| 92560 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) ) |  | 92512 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) )
| 92561 | { |  | 92513 | {
| 92562 | ERRWRAP2(retval = _self_->loadParameters(filepath)); |  | 92514 | ERRWRAP2(retval = _self_->loadParameters(filepath));
| 92563 | return pyopencv_from(retval); |  | 92515 | return pyopencv_from(retval);
| 92564 | } |  | 92516 | }
| 92565 |  |  | 92517 |
| 92566 | return NULL; |  | 92518 | return NULL;
| 92567 | } |  | 92519 | }
| 92568 |  |  | 92520 |
| 92569 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_process(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92521 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_process(PyObject* self, PyObject* py_args, PyObject* kw)
| 92570 | { |  | 92522 | {
| 92571 | using namespace cv::stereo; |  | 92523 | using namespace cv::stereo;
| 92572 |  |  | 92524 |
| 92573 |  |  | 92525 |
| 92574 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0; |  | 92526 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0;
| 92575 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1)) |  | 92527 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1))
| 92576 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)"); |  | 92528 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)");
| 92577 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1); |  | 92529 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1);
| 92578 | PyObject* pyobj_imgLeft = NULL; |  | 92530 | PyObject* pyobj_imgLeft = NULL;
| 92579 | Mat imgLeft; |  | 92531 | Mat imgLeft;
| 92580 | PyObject* pyobj_imgRight = NULL; |  | 92532 | PyObject* pyobj_imgRight = NULL;
| 92581 | Mat imgRight; |  | 92533 | Mat imgRight;
| 92582 |  |  | 92534 |
| 92583 | const char* keywords[] = { "imgLeft", "imgRight", NULL }; |  | 92535 | const char* keywords[] = { "imgLeft", "imgRight", NULL };
| 92584 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:stereo_QuasiDenseStereo.process", (char**)keywords, &pyobj_imgLeft, &pyobj_imgRight) && |  | 92536 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:stereo_QuasiDenseStereo.process", (char**)keywords, &pyobj_imgLeft, &pyobj_imgRight) &&
| 92585 | pyopencv_to_safe(pyobj_imgLeft, imgLeft, ArgInfo("imgLeft", 0)) && |  | 92537 | pyopencv_to_safe(pyobj_imgLeft, imgLeft, ArgInfo("imgLeft", 0)) &&
| 92586 | pyopencv_to_safe(pyobj_imgRight, imgRight, ArgInfo("imgRight", 0)) ) |  | 92538 | pyopencv_to_safe(pyobj_imgRight, imgRight, ArgInfo("imgRight", 0)) )
| 92587 | { |  | 92539 | {
| 92588 | ERRWRAP2(_self_->process(imgLeft, imgRight)); |  | 92540 | ERRWRAP2(_self_->process(imgLeft, imgRight));
| 92589 | Py_RETURN_NONE; |  | 92541 | Py_RETURN_NONE;
| 92590 | } |  | 92542 | }
| 92591 |  |  | 92543 |
| 92592 | return NULL; |  | 92544 | return NULL;
| 92593 | } |  | 92545 | }
| 92594 |  |  | 92546 |
| 92595 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_saveParameters(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92547 | static PyObject* pyopencv_cv_stereo_stereo_QuasiDenseStereo_saveParameters(PyObject* self, PyObject* py_args, PyObject* kw)
| 92596 | { |  | 92548 | {
| 92597 | using namespace cv::stereo; |  | 92549 | using namespace cv::stereo;
| 92598 |  |  | 92550 |
| 92599 |  |  | 92551 |
| 92600 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0; |  | 92552 | Ptr<cv::stereo::QuasiDenseStereo> * self1 = 0;
| 92601 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1)) |  | 92553 | if (!pyopencv_stereo_QuasiDenseStereo_getp(self, self1))
| 92602 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)"); |  | 92554 | return failmsgp("Incorrect type of self (must be 'stereo_QuasiDenseStereo' or its derivative)");
| 92603 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1); |  | 92555 | Ptr<cv::stereo::QuasiDenseStereo> _self_ = *(self1);
| 92604 | PyObject* pyobj_filepath = NULL; |  | 92556 | PyObject* pyobj_filepath = NULL;
| 92605 | String filepath; |  | 92557 | String filepath;
| 92606 | int retval; |  | 92558 | int retval;
| 92607 |  |  | 92559 |
| 92608 | const char* keywords[] = { "filepath", NULL }; |  | 92560 | const char* keywords[] = { "filepath", NULL };
| 92609 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:stereo_QuasiDenseStereo.saveParameters", (char**)keywords, &pyobj_filepath) && |  | 92561 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "O:stereo_QuasiDenseStereo.saveParameters", (char**)keywords, &pyobj_filepath) &&
| 92610 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) ) |  | 92562 | pyopencv_to_safe(pyobj_filepath, filepath, ArgInfo("filepath", 4)) )
| 92611 | { |  | 92563 | {
| 92612 | ERRWRAP2(retval = _self_->saveParameters(filepath)); |  | 92564 | ERRWRAP2(retval = _self_->saveParameters(filepath));
| 92613 | return pyopencv_from(retval); |  | 92565 | return pyopencv_from(retval);
| 92614 | } |  | 92566 | }
| 92615 |  |  | 92567 |
| 92616 | return NULL; |  | 92568 | return NULL;
| 92617 | } |  | 92569 | }
| 92618 |  |  | 92570 |
| 92619 |  |  | 92571 |
| 92620 |  |  | 92572 |
| 92621 | // Tables (stereo_QuasiDenseStereo) |  | 92573 | // Tables (stereo_QuasiDenseStereo)
| 92622 |  |  | 92574 |
| 92623 | static PyGetSetDef pyopencv_stereo_QuasiDenseStereo_getseters[] = |  | 92575 | static PyGetSetDef pyopencv_stereo_QuasiDenseStereo_getseters[] =
| 92624 | { |  | 92576 | {
| 92625 | {(char*)"Param", (getter)pyopencv_stereo_QuasiDenseStereo_get_Param, (setter)pyopencv_stereo_QuasiDenseStereo_set_Param, (char*)"Param", NULL}, |  | 92577 | {(char*)"Param", (getter)pyopencv_stereo_QuasiDenseStereo_get_Param, (setter)pyopencv_stereo_QuasiDenseStereo_set_Param, (char*)"Param", NULL},
| 92626 | {NULL} /* Sentinel */ |  | 92578 | {NULL} /* Sentinel */
| 92627 | }; |  | 92579 | };
| 92628 |  |  | 92580 |
| 92629 | static PyMethodDef pyopencv_stereo_QuasiDenseStereo_methods[] = |  | 92581 | static PyMethodDef pyopencv_stereo_QuasiDenseStereo_methods[] =
| 92630 | { |  | 92582 | {
| 92631 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_create_static, METH_STATIC), "create(monoImgSize[, paramFilepath]) -> retval\n."}, |  | 92583 | {"create", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_create_static, METH_STATIC), "create(monoImgSize[, paramFilepath]) -> retval\n."},
| 92632 | {"getDenseMatches", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDenseMatches, 0), "getDenseMatches() -> denseMatches\n. * @brief Get The dense corresponding points.\n. * @param[out] denseMatches A vector containing all dense matches.\n. * @note The method clears the denseMatches vector.\n. * @note The returned Match elements inside the sMatches vector, do not use corr member."}, |  | 92584 | {"getDenseMatches", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDenseMatches, 0), "getDenseMatches() -> denseMatches\n. * @brief Get The dense corresponding points.\n. * @param[out] denseMatches A vector containing all dense matches.\n. * @note The method clears the denseMatches vector.\n. * @note The returned Match elements inside the sMatches vector, do not use corr member."},
| 92633 | {"getDisparity", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDisparity, 0), "getDisparity() -> retval\n. * @brief Compute and return the disparity map based on the correspondences found in the \"process\" method.\n. * @note Default level is 50\n. * @return cv::Mat containing a the disparity image in grayscale.\n. * @sa computeDisparity\n. * @sa quantizeDisparity"}, |  | 92585 | {"getDisparity", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getDisparity, 0), "getDisparity() -> retval\n. * @brief Compute and return the disparity map based on the correspondences found in the \"process\" method.\n. * @note Default level is 50\n. * @return cv::Mat containing a the disparity image in grayscale.\n. * @sa computeDisparity\n. * @sa quantizeDisparity"},
| 92634 | {"getMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getMatch, 0), "getMatch(x, y) -> retval\n. * @brief Specify pixel coordinates in the left image and get its corresponding location in the right image.\n. * @param[in] x The x pixel coordinate in the left image channel.\n. * @param[in] y The y pixel coordinate in the left image channel.\n. * @retval cv::Point(x, y) The location of the corresponding pixel in the right image.\n. * @retval cv::Point(0, 0) (NO_MATCH) if no match is found in the right image for the specified pixel location in the left image.\n. * @note This method should be always called after process, otherwise the matches will not be correct."}, |  | 92586 | {"getMatch", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getMatch, 0), "getMatch(x, y) -> retval\n. * @brief Specify pixel coordinates in the left image and get its corresponding location in the right image.\n. * @param[in] x The x pixel coordinate in the left image channel.\n. * @param[in] y The y pixel coordinate in the left image channel.\n. * @retval cv::Point(x, y) The location of the corresponding pixel in the right image.\n. * @retval cv::Point(0, 0) (NO_MATCH) if no match is found in the right image for the specified pixel location in the left image.\n. * @note This method should be always called after process, otherwise the matches will not be correct."},
| 92635 | {"getSparseMatches", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getSparseMatches, 0), "getSparseMatches() -> sMatches\n. * @brief Get The sparse corresponding points.\n. * @param[out] sMatches A vector containing all sparse correspondences.\n. * @note The method clears the sMatches vector.\n. * @note The returned Match elements inside the sMatches vector, do not use corr member."}, |  | 92587 | {"getSparseMatches", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_getSparseMatches, 0), "getSparseMatches() -> sMatches\n. * @brief Get The sparse corresponding points.\n. * @param[out] sMatches A vector containing all sparse correspondences.\n. * @note The method clears the sMatches vector.\n. * @note The returned Match elements inside the sMatches vector, do not use corr member."},
| 92636 | {"loadParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_loadParameters, 0), "loadParameters(filepath) -> retval\n. * @brief Load a file containing the configuration parameters of the class.\n. * @param[in] filepath The location of the .YAML file containing the configuration parameters.\n. * @note default value is an empty string in which case the default parameters will be loaded.\n. * @retval 1: If the path is not empty and the program loaded the parameters successfully.\n. * @retval 0: If the path is empty and the program loaded default parameters.\n. * @retval -1: If the file location is not valid or the program could not open the file and\n. * loaded default parameters from defaults.hpp.\n. * @note The method is automatically called in the constructor and configures the class.\n. * @note Loading different parameters will have an effect on the output. This is useful for tuning\n. * in case of video processing.\n. * @sa loadParameters"}, |  | 92588 | {"loadParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_loadParameters, 0), "loadParameters(filepath) -> retval\n. * @brief Load a file containing the configuration parameters of the class.\n. * @param[in] filepath The location of the .YAML file containing the configuration parameters.\n. * @note default value is an empty string in which case the default parameters will be loaded.\n. * @retval 1: If the path is not empty and the program loaded the parameters successfully.\n. * @retval 0: If the path is empty and the program loaded default parameters.\n. * @retval -1: If the file location is not valid or the program could not open the file and\n. * loaded default parameters from defaults.hpp.\n. * @note The method is automatically called in the constructor and configures the class.\n. * @note Loading different parameters will have an effect on the output. This is useful for tuning\n. * in case of video processing.\n. * @sa loadParameters"},
| 92637 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_process, 0), "process(imgLeft, imgRight) -> None\n. * @brief Main process of the algorithm. This method computes the sparse seeds and then densifies them.\n. *\n. * Initially input images are converted to gray-scale and then the sparseMatching method\n. * is called to obtain the sparse stereo. Finally quasiDenseMatching is called to densify the corresponding\n. * points.\n. * @param[in] imgLeft The left Channel of a stereo image pair.\n. * @param[in] imgRight The right Channel of a stereo image pair.\n. * @note If input images are in color, the method assumes that are BGR and converts them to grayscale.\n. * @sa sparseMatching\n. * @sa quasiDenseMatching"}, |  | 92589 | {"process", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_process, 0), "process(imgLeft, imgRight) -> None\n. * @brief Main process of the algorithm. This method computes the sparse seeds and then densifies them.\n. *\n. * Initially input images are converted to gray-scale and then the sparseMatching method\n. * is called to obtain the sparse stereo. Finally quasiDenseMatching is called to densify the corresponding\n. * points.\n. * @param[in] imgLeft The left Channel of a stereo image pair.\n. * @param[in] imgRight The right Channel of a stereo image pair.\n. * @note If input images are in color, the method assumes that are BGR and converts them to grayscale.\n. * @sa sparseMatching\n. * @sa quasiDenseMatching"},
| 92638 | {"saveParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_saveParameters, 0), "saveParameters(filepath) -> retval\n. * @brief Save a file containing all the configuration parameters the class is currently set to.\n. * @param[in] filepath The location to store the parameters file.\n. * @note Calling this method with no arguments will result in storing class parameters to a file\n. * names \"qds_parameters.yaml\" in the root project folder.\n. * @note This method can be used to generate a template file for tuning the class.\n. * @sa loadParameters"}, |  | 92590 | {"saveParameters", CV_PY_FN_WITH_KW_(pyopencv_cv_stereo_stereo_QuasiDenseStereo_saveParameters, 0), "saveParameters(filepath) -> retval\n. * @brief Save a file containing all the configuration parameters the class is currently set to.\n. * @param[in] filepath The location to store the parameters file.\n. * @note Calling this method with no arguments will result in storing class parameters to a file\n. * names \"qds_parameters.yaml\" in the root project folder.\n. * @note This method can be used to generate a template file for tuning the class.\n. * @sa loadParameters"},
| 92639 |  |  | 92591 |
| 92640 | {NULL, NULL} |  | 92592 | {NULL, NULL}
| 92641 | }; |  | 92593 | };
| 92642 |  |  | 92594 |
| 92643 | // Converter (stereo_QuasiDenseStereo) |  | 92595 | // Converter (stereo_QuasiDenseStereo)
| 92644 |  |  | 92596 |
| 92645 | template<> |  | 92597 | template<>
| 92646 | struct PyOpenCV_Converter< Ptr<cv::stereo::QuasiDenseStereo> > |  | 92598 | struct PyOpenCV_Converter< Ptr<cv::stereo::QuasiDenseStereo> >
| 92647 | { |  | 92599 | {
| 92648 | static PyObject* from(const Ptr<cv::stereo::QuasiDenseStereo>& r) |  | 92600 | static PyObject* from(const Ptr<cv::stereo::QuasiDenseStereo>& r)
| 92649 | { |  | 92601 | {
| 92650 | return pyopencv_stereo_QuasiDenseStereo_Instance(r); |  | 92602 | return pyopencv_stereo_QuasiDenseStereo_Instance(r);
| 92651 | } |  | 92603 | }
| 92652 | static bool to(PyObject* src, Ptr<cv::stereo::QuasiDenseStereo>& dst, const ArgInfo& info) |  | 92604 | static bool to(PyObject* src, Ptr<cv::stereo::QuasiDenseStereo>& dst, const ArgInfo& info)
| 92653 | { |  | 92605 | {
| 92654 | if(!src || src == Py_None) |  | 92606 | if(!src || src == Py_None)
| 92655 | return true; |  | 92607 | return true;
| 92656 | Ptr<cv::stereo::QuasiDenseStereo> * dst_; |  | 92608 | Ptr<cv::stereo::QuasiDenseStereo> * dst_;
| 92657 | if (pyopencv_stereo_QuasiDenseStereo_getp(src, dst_)) |  | 92609 | if (pyopencv_stereo_QuasiDenseStereo_getp(src, dst_))
| 92658 | { |  | 92610 | {
| 92659 | dst = *dst_; |  | 92611 | dst = *dst_;
| 92660 | return true; |  | 92612 | return true;
| 92661 | } |  | 92613 | }
| 92662 |  |  | 92614 |
| 92663 | failmsg("Expected Ptr<cv::stereo::QuasiDenseStereo> for argument '%s'", info.name); |  | 92615 | failmsg("Expected Ptr<cv::stereo::QuasiDenseStereo> for argument '%s'", info.name);
| 92664 | return false; |  | 92616 | return false;
| 92665 | } |  | 92617 | }
| 92666 | }; |  | 92618 | };
| 92667 |  |  | 92619 |
| 92668 | //================================================================================ |  | 92620 | //================================================================================
| 92669 | // structured_light_GrayCodePattern (Generic) |  | 92621 | // structured_light_GrayCodePattern (Generic)
| 92670 | //================================================================================ |  | 92622 | //================================================================================
| 92671 |  |  | 92623 |
| 92672 | // GetSet (structured_light_GrayCodePattern) |  | 92624 | // GetSet (structured_light_GrayCodePattern)
| 92673 |  |  | 92625 |
| 92674 |  |  | 92626 |
| 92675 |  |  | 92627 |
| 92676 | // Methods (structured_light_GrayCodePattern) |  | 92628 | // Methods (structured_light_GrayCodePattern)
| 92677 |  |  | 92629 |
| 92678 | static PyObject* pyopencv_cv_structured_light_structured_light_GrayCodePattern_create_static(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92630 | static PyObject* pyopencv_cv_structured_light_structured_light_GrayCodePattern_create_static(PyObject* self, PyObject* py_args, PyObject* kw)
| 92679 | { |  | 92631 | {
| 92680 | using namespace cv::structured_light; |  | 92632 | using namespace cv::structured_light;
| 92681 |  |  | 92633 |
| 92682 | PyObject* pyobj_width = NULL; |  | 92634 | PyObject* pyobj_width = NULL;
| 92683 | int width=0; |  | 92635 | int width=0;
| 92684 | PyObject* pyobj_height = NULL; |  | 92636 | PyObject* pyobj_height = NULL;
| 92685 | int height=0; |  | 92637 | int height=0;
| 92686 | Ptr<GrayCodePattern> retval; |  | 92638 | Ptr<GrayCodePattern> retval;
| 92687 |  |  | 92639 |
| 92688 | const char* keywords[] = { "width", "height", NULL }; |  | 92640 | const char* keywords[] = { "width", "height", NULL };
| 92689 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:structured_light_GrayCodePattern.create", (char**)keywords, &pyobj_width, &pyobj_height) && |  | 92641 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:structured_light_GrayCodePattern.create", (char**)keywords, &pyobj_width, &pyobj_height) &&
| 92690 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) && |  | 92642 | pyopencv_to_safe(pyobj_width, width, ArgInfo("width", 0)) &&
| 92691 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) ) |  | 92643 | pyopencv_to_safe(pyobj_height, height, ArgInfo("height", 0)) )
| 92692 | { |  | 92644 | {
| 92693 | ERRWRAP2(retval = cv::structured_light::GrayCodePattern::create(width, height)); |  | 92645 | ERRWRAP2(retval = cv::structured_light::GrayCodePattern::create(width, height));
| 92694 | return pyopencv_from(retval); |  | 92646 | return pyopencv_from(retval);
| 92695 | } |  | 92647 | }
| 92696 |  |  | 92648 |
| 92697 | return NULL; |  | 92649 | return NULL;
| 92698 | } |  | 92650 | }
| 92699 |  |  | 92651 |
| 92700 | static PyObject* pyopencv_cv_structured_light_structured_light_GrayCodePattern_getImagesForShadowMasks(PyObject* self, PyObject* py_args, PyObject* kw) |  | 92652 | static PyObject* pyopencv_cv_structured_light_structured_light_GrayCodePattern_getImagesForShadowMasks(PyObject* self, PyObject* py_args, PyObject* kw)
| 92701 | { |  | 92653 | {
| 92702 | using namespace cv::structured_light; |  | 92654 | using namespace cv::structured_light;
| 92703 |  |  | 92655 |
| 92704 |  |  | 92656 |
| 92705 | Ptr<cv::structured_light::GrayCodePattern> * self1 = 0; |  | 92657 | Ptr<cv::structured_light::GrayCodePattern> * self1 = 0;
| 92706 | if (!pyopencv_structured_light_GrayCodePattern_getp(self, self1)) |  | 92658 | if (!pyopencv_structured_light_GrayCodePattern_getp(self, self1))
| 92707 | return failmsgp("Incorrect type of self (must be 'structured_light_GrayCodePattern' or its derivative)"); |  | 92659 | return failmsgp("Incorrect type of self (must be 'structured_light_GrayCodePattern' or its derivative)");
| 92708 | Ptr<cv::structured_light::GrayCodePattern> _self_ = *(self1); |  | 92660 | Ptr<cv::structured_light::GrayCodePattern> _self_ = *(self1);
| 92709 | pyPrepareArgumentConversionErrorsStorage(2); |  | 92661 | pyPrepareArgumentConversionErrorsStorage(2);
| 92710 |  |  | 92662 |
| 92711 | { |  | 92663 | {
| 92712 | PyObject* pyobj_blackImage = NULL; |  | 92664 | PyObject* pyobj_blackImage = NULL;
| 92713 | Mat blackImage; |  | 92665 | Mat blackImage;
| 92714 | PyObject* pyobj_whiteImage = NULL; |  | 92666 | PyObject* pyobj_whiteImage = NULL;
| 92715 | Mat whiteImage; |  | 92667 | Mat whiteImage;
| 92716 |  |  | 92668 |
| 92717 | const char* keywords[] = { "blackImage", "whiteImage", NULL }; |  | 92669 | const char* keywords[] = { "blackImage", "whiteImage", NULL };
| 92718 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:structured_light_GrayCodePattern.getImagesForShadowMasks", (char**)keywords, &pyobj_blackImage, &pyobj_whiteImage) && |  | 92670 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:structured_light_GrayCodePattern.getImagesForShadowMasks", (char**)keywords, &pyobj_blackImage, &pyobj_whiteImage) &&
| 92719 | pyopencv_to_safe(pyobj_blackImage, blackImage, ArgInfo("blackImage", 1)) && |  | 92671 | pyopencv_to_safe(pyobj_blackImage, blackImage, ArgInfo("blackImage", 1)) &&
| 92720 | pyopencv_to_safe(pyobj_whiteImage, whiteImage, ArgInfo("whiteImage", 1)) ) |  | 92672 | pyopencv_to_safe(pyobj_whiteImage, whiteImage, ArgInfo("whiteImage", 1)) )
| 92721 | { |  | 92673 | {
| 92722 | ERRWRAP2(_self_->getImagesForShadowMasks(blackImage, whiteImage)); |  | 92674 | ERRWRAP2(_self_->getImagesForShadowMasks(blackImage, whiteImage));
| 92723 | return Py_BuildValue("(NN)", pyopencv_from(blackImage), pyopencv_from(whiteImage)); |  | 92675 | return Py_BuildValue("(NN)", pyopencv_from(blackImage), pyopencv_from(whiteImage));
| 92724 | } |  | 92676 | }
| 92725 |  |  | 92677 |
| 92726 |  |  | 92678 |
| 92727 | pyPopulateArgumentConversionErrors(); |  | 92679 | pyPopulateArgumentConversionErrors();
| 92728 | } |  | 92680 | }
| 92729 |  |  | 92681 |
| 92730 |  |  | 92682 |
| 92731 | { |  | 92683 | {
| 92732 | PyObject* pyobj_blackImage = NULL; |  | 92684 | PyObject* pyobj_blackImage = NULL;
| 92733 | UMat blackImage; |  | 92685 | UMat blackImage;
| 92734 | PyObject* pyobj_whiteImage = NULL; |  | 92686 | PyObject* pyobj_whiteImage = NULL;
| 92735 | UMat whiteImage; |  | 92687 | UMat whiteImage;
| 92736 |  |  | 92688 |
| 92737 | const char* keywords[] = { "blackImage", "whiteImage", NULL }; |  | 92689 | const char* keywords[] = { "blackImage", "whiteImage", NULL };
| 92738 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:structured_light_GrayCodePattern.getImagesForShadowMasks", (char**)keywords, &pyobj_blackImage, &pyobj_whiteImage) && |  | 92690 | if( PyArg_ParseTupleAndKeywords(py_args, kw, "OO:structured_light_GrayCodePattern.getImagesForShadowMasks", (char**)keywords, &pyobj_blackImage, &pyobj_whiteImage) &&
| 92739 | pyopencv_to_safe(pyobj_blackImage, blackImage, ArgInfo("blackImage", 1)) && |  | 92691 | pyopencv_to_safe(pyobj_blackImage, blackImage, ArgInfo("blackImage", 1)) &&
| 92740 | pyopencv_to_safe(pyobj_whiteImage, whiteImage, ArgInfo("whiteImage", 1)) ) |  | 92692 | pyopencv_to_safe(pyobj_whiteImage, whiteImage, ArgInfo("whiteImage", 1)) )
| 92741 | { |  | 92693 | {
| 92742 | ERRWRAP2(_self_->getImagesForShadowMasks(blackImage, whiteImage)); |  | 92694 | ERRWRAP2(_self_->getImagesForShadowMasks(blackImage, whiteImage));
| 92743 | return Py_BuildValue("(NN)", pyopencv_from(blackImage), pyopencv_from(whiteImage)); |  | 92695 | return Py_BuildValue("(NN)", pyopencv_from(blackImage), pyopencv_from(whiteImage));
| 92744 | } |  | 92696 | }
| 92745 |  |  | 92697 |
| 92746 |  |  | 92698 |
| 92747 | pyPopulateArgumentConversionErrors(); |  | 92699 | pyPopulateArgumentConversionErrors();
| 92748 | } |  | 92700 | }
| 92749 | pyRaiseCVOverloadException("getImagesForShadowMasks"); |  | 92701 | pyRaiseCVOverloadException("getImagesForShadowMasks");
| 92750 |  |  | 92702 |
| 92751 | return NULL; |  | 92703 | return&